rebuild

+interface ProgramRepository {
+    findById(id:string) : Promise<any>;
+    findByIds(ids:Array<string>) : Promise<Array<any>>;
+    findByType(type:string) : Promise<Array<any>>;
+    replicate() : Promise<void>;
+}
+
+interface Player {
+    on(name:string, any);
+    start() : void;
+    stop() : void;
+}
+
+interface ProgramManager {
+    programRepository: ProgramRepository;
+}
+
+interface ProgramItemFactory {
+    basePath: string;
+    programRepository: ProgramRepository;
+    getProgramItem(programItemId:string) : Promise<any>;
+}
+
+declare var digsigPlayer: {
+    ProgramRepository: ProgramRepository,
+    ProgramManager: ProgramManager,
+    Player : Player,
+    ProgramItemFactory: ProgramItemFactory
+};
+
+declare module "digsig-player-service" {
+    export = digsigPlayer;
+}
\ No newline at end of file

@@ -2,13 +2,13 @@
   "name": "digsig-player-service",
   "name": "digsig-player-service",
   "version": "1.0.0",
   "version": "1.0.0",
   "description": "",
   "description": "",
-  "main": "target/index.js",
-  "types": "types/index.d.ts",
+  "main": "build/bundle.js",
+  "types": "index.d.ts",
   "scripts": {
   "scripts": {
     "pretest": "tsc --target es5 --outDir .tmp spec/index.ts",
     "pretest": "tsc --target es5 --outDir .tmp spec/index.ts",
     "test": "jasmine .tmp/spec/index.js",
     "test": "jasmine .tmp/spec/index.js",
     "posttest": "rm -R .tmp",
     "posttest": "rm -R .tmp",
-    "build:tsc": "tsc"
+    "build:tsc": "rollup -c rollup.config.js"
   },
   },
   "author": "Stefan Huber <stefan.huber@beyondit.at>",
   "author": "Stefan Huber <stefan.huber@beyondit.at>",
   "license": "ISC",
   "license": "ISC",
@@ -17,6 +17,11 @@
     "@types/jasmine": "^2.5.41",
     "@types/jasmine": "^2.5.41",
     "@types/node": "^7.0.0",
     "@types/node": "^7.0.0",
     "jasmine": "^2.5.3",
     "jasmine": "^2.5.3",
+    "rollup": "^0.41.4",
+    "rollup-plugin-commonjs": "^7.0.0",
+    "rollup-plugin-node-builtins": "^2.0.0",
+    "rollup-plugin-node-globals": "^1.1.0",
+    "rollup-plugin-typescript": "^0.8.1",
     "typescript": "^2.1.5"
     "typescript": "^2.1.5"
   }
   }
 }
 }

+var typescript = require('rollup-plugin-typescript');
+var builtins = require('rollup-plugin-node-builtins');
+var globals = require('rollup-plugin-node-globals');
+
+var rollupConfig = {
+  
+  moduleName : 'digsig',
+
+  entry: 'src/index.ts',
+
+  sourceMap: true,
+
+  format: 'cjs',
+
+  dest: 'build/bundle.js',
+
+  plugins: [    
+      builtins(),
+      globals(),
+      typescript()      
+  ]
+
+};
+
+module.exports = rollupConfig;
\ No newline at end of file

 export * from './player';
 export * from './player';
+export * from './program-manager';
 export * from './program-item/program-item';
 export * from './program-item/program-item';
 export * from './program-item/program-item-factory';
 export * from './program-item/program-item-factory';
-export * from './program-manager';
-export * from './program-repository';
-export * from './util';

-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-__export(require("./player"));
-__export(require("./program-item/program-item"));
-__export(require("./program-item/program-item-factory"));
-__export(require("./program-manager"));
-__export(require("./util"));

-"use strict";
-var __extends = (this && this.__extends) || function (d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-};
-var events_1 = require("events");
-var util_1 = require("./util");
-var STATE_START = "start";
-var STATE_STOP = "stop";
-var Player = (function (_super) {
-    __extends(Player, _super);
-    function Player() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._minutesReplication = 5;
-        _this._replicationRetry = 10000;
-        _this._currentProgramItemId = '';
-        _this._currentReplicationCounter = 0;
-        _this._state = STATE_STOP;
-        return _this;
-    }
-    Object.defineProperty(Player.prototype, "state", {
-        set: function (st) {
-            this._state = st;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Player.prototype, "programManager", {
-        get: function () {
-            return this._programManager;
-        },
-        set: function (pm) {
-            this._programManager = pm;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Player.prototype, "programRepository", {
-        get: function () {
-            return this._programRepository;
-        },
-        set: function (pr) {
-            this._programRepository = pr;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Player.prototype, "minutesReplication", {
-        get: function () {
-            return this._minutesReplication;
-        },
-        set: function (mr) {
-            this._minutesReplication = mr;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Player.prototype, "replicationRetry", {
-        get: function () {
-            return this._replicationRetry;
-        },
-        set: function (rr) {
-            this._replicationRetry = rr;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Player.prototype.triggerReplication = function () {
-        var _this = this;
-        return this.programRepository.replicate()
-            .then(function () {
-            _this._currentReplicationCounter = 0;
-            _this.trigger(_this.triggerProgramItemId, util_1.Util.calculateNextMinute());
-        })
-            .catch(function () {
-            _this.trigger(_this.triggerReplication, _this.replicationRetry);
-        });
-    };
-    Player.prototype.triggerProgramItemId = function () {
-        var _this = this;
-        this.programManager.getCurrentProgramItemId()
-            .then(function (programItemId) {
-            _this._currentReplicationCounter++;
-            // if there is a new program item id trigger play
-            // else (1) calculate next potential program change point
-            // or (2) trigger replication
-            if (programItemId != _this._currentProgramItemId) {
-                _this._currentProgramItemId = programItemId;
-                _this.emit('play', programItemId);
-            }
-            else if (_this._currentReplicationCounter >= _this._minutesReplication) {
-                _this.triggerReplication();
-            }
-            else {
-                _this.trigger(_this.triggerProgramItemId, util_1.Util.calculateNextMinute());
-            }
-        });
-    };
-    Player.prototype.trigger = function (func, milliseconds) {
-        if (this._state === STATE_START) {
-            setTimeout(function () { func(); }, milliseconds);
-        }
-    };
-    Player.prototype.start = function () {
-        if (this._state === STATE_STOP) {
-            this.triggerReplication();
-            this._state = STATE_START;
-        }
-    };
-    Player.prototype.stop = function () {
-        this._state = STATE_STOP;
-    };
-    return Player;
-}(events_1.EventEmitter));
-exports.Player = Player;

-"use strict";
-var program_item_1 = require("./program-item");
-var ProgramItemFactory = (function () {
-    function ProgramItemFactory() {
-    }
-    Object.defineProperty(ProgramItemFactory.prototype, "basePath", {
-        get: function () {
-            return this._basePath;
-        },
-        set: function (bp) {
-            this._basePath = bp;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ProgramItemFactory.prototype, "programRepository", {
-        get: function () {
-            return this._programRepository;
-        },
-        set: function (pr) {
-            this._programRepository = pr;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ProgramItemFactory.prototype.getProgramItem = function (programItemId) {
-        var _this = this;
-        return this.programRepository
-            .findById(programItemId)
-            .then(function (programItem) {
-            return _this.prepareProgramItem(programItem.program_item_type, programItem);
-        });
-    };
-    ProgramItemFactory.prototype.prepareProgramItem = function (type, data) {
-        var programItem = new program_item_1.ProgramItem();
-        programItem.type = type;
-        if (type === program_item_1.PROGRAM_ITEM_TYPE_VIDEO) {
-            return this.prepareVideoItem(programItem, data);
-        }
-        else if (type === program_item_1.PROGRAM_ITEM_TYPE_SLIDESHOW) {
-            return this.prepareSlideshowItem(programItem, data);
-        }
-        else {
-            return null;
-        }
-    };
-    ProgramItemFactory.prototype.prepareSlideshowItem = function (programItem, data) {
-        var _this = this;
-        return this._programRepository.findByIds(data.images)
-            .then(function (images) {
-            programItem.data = {
-                speed: data.settings.speed,
-                effect: data.settings.effect,
-                images: []
-            };
-            for (var _i = 0, images_1 = images; _i < images_1.length; _i++) {
-                var image = images_1[_i];
-                programItem.data.images.push(_this.basePath + image.filename);
-            }
-            return programItem;
-        });
-    };
-    ProgramItemFactory.prototype.prepareVideoItem = function (programItem, data) {
-        var _this = this;
-        return this._programRepository.findById(data.video)
-            .then(function (data) {
-            programItem.data = {
-                video: _this.basePath + data['filename']
-            };
-            return programItem;
-        });
-    };
-    return ProgramItemFactory;
-}());
-exports.ProgramItemFactory = ProgramItemFactory;

-"use strict";
-exports.PROGRAM_ITEM_TYPE_SLIDESHOW = "slideshow";
-exports.PROGRAM_ITEM_TYPE_VIDEO = "video";
-var ProgramItem = (function () {
-    function ProgramItem() {
-    }
-    Object.defineProperty(ProgramItem.prototype, "type", {
-        get: function () {
-            return this._type;
-        },
-        set: function (t) {
-            this._type = t;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ProgramItem.prototype, "data", {
-        get: function () {
-            return this._data;
-        },
-        set: function (d) {
-            this._data = d;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return ProgramItem;
-}());
-exports.ProgramItem = ProgramItem;

-"use strict";
-var util_1 = require("./util");
-var ProgramManager = (function () {
-    function ProgramManager() {
-    }
-    Object.defineProperty(ProgramManager.prototype, "programRepository", {
-        get: function () {
-            return this._programRepository;
-        },
-        set: function (pr) {
-            this._programRepository = pr;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ProgramManager.prototype.getCurrentProgramItemId = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this.findCurrentProgramSegment().then(function (programSegment) {
-                var currentProgramItemId = programSegment.default;
-                if (programSegment.schedule) {
-                    currentProgramItemId = _this.findCurrentProgramItem(programSegment.schedule, util_1.Util.getDateInMinutes());
-                }
-                resolve(currentProgramItemId);
-            });
-        });
-    };
-    /**
-     * find program item in schedule, which fits
-     * according to current hh:mm
-     */
-    ProgramManager.prototype.findCurrentProgramItem = function (schedule, dateInMinutes) {
-        var timeList = [];
-        var tmpSchedule = {};
-        for (var startTime in schedule) {
-            if (schedule.hasOwnProperty(startTime)) {
-                var minutes = util_1.Util.convertToMinutes(startTime);
-                timeList.push(minutes);
-                tmpSchedule[minutes] = schedule[startTime];
-            }
-        }
-        // sort ascending (-)
-        timeList.sort(function (a, b) { return a - b; });
-        var last = 0;
-        for (var i = 0; i < timeList.length; i++) {
-            if (timeList[i] <= dateInMinutes) {
-                last = timeList[i];
-            }
-            else {
-                break;
-            }
-        }
-        return tmpSchedule[last];
-    };
-    /**
-     * Find the program segment
-     * This is dependent on the date set on the device
-     */
-    ProgramManager.prototype.findCurrentProgramSegment = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var today = util_1.Util.getISODate();
-            _this.programRepository.findByType('program')
-                .then(function (programs) {
-                if (programs.length > 0) {
-                    var program = programs[0];
-                    var programSegmentId = void 0;
-                    // if there is a program_segment for today else default
-                    if (program.schedule && program.schedule[today]) {
-                        programSegmentId = program.schedule[today];
-                    }
-                    else {
-                        programSegmentId = program.default;
-                    }
-                    _this.programRepository
-                        .findById(programSegmentId)
-                        .then(function (programSegment) {
-                        resolve(programSegment);
-                    }).catch(function (error) {
-                        reject("program segment not found");
-                    });
-                }
-                else {
-                    reject('No Program found');
-                }
-            }).catch(function (error) {
-                reject(error);
-            });
-        });
-    };
-    return ProgramManager;
-}());
-exports.ProgramManager = ProgramManager;

-"use strict";

-"use strict";
-var Util = (function () {
-    function Util() {
-    }
-    Util.getISODate = function () {
-        return (new Date()).toISOString().slice(0, 10);
-    };
-    Util.getDateInMinutes = function () {
-        var now = new Date();
-        return (now.getHours() * 60) + now.getMinutes();
-    };
-    /**
-     * convert a time input to minutes
-     * e.g. 23:59 = 1439
-     */
-    Util.convertToMinutes = function (time) {
-        var times = time.split(":");
-        var convered = (parseInt(times[0]) * 60) + parseInt(times[1]);
-        return (convered >= 0 && convered <= 1439) ? convered : 0;
-    };
-    Util.calculateNextMinute = function () {
-        return (60 - (Math.round((new Date()).getTime() / 1000) % 60)) * 1000;
-    };
-    return Util;
-}());
-exports.Util = Util;

-{
-    "compilerOptions": {
-        "outDir": "./target",
-        "module": "commonjs",
-        "target": "es5",
-        "declaration": true,
-        "declarationDir": "types"
-    },
-    "include": [
-        "./src/index.ts"
-    ]
-}
\ No newline at end of file

-export * from './player';
-export * from './program-item/program-item';
-export * from './program-item/program-item-factory';
-export * from './program-manager';
-export * from './program-repository';
-export * from './util';

-/// <reference types="node" />
-/// <reference types="es6-promise" />
-import { EventEmitter } from 'events';
-import { ProgramRepository } from './program-repository';
-import { ProgramManager } from './program-manager';
-export declare class Player extends EventEmitter {
-    protected _programRepository: ProgramRepository;
-    protected _programManager: ProgramManager;
-    protected _minutesReplication: number;
-    protected _replicationRetry: number;
-    protected _currentProgramItemId: string;
-    protected _currentReplicationCounter: number;
-    protected _state: string;
-    state: string;
-    programManager: ProgramManager;
-    programRepository: ProgramRepository;
-    minutesReplication: number;
-    replicationRetry: number;
-    triggerReplication(): Promise<void>;
-    triggerProgramItemId(): void;
-    trigger(func: Function, milliseconds: number): void;
-    start(): void;
-    stop(): void;
-}

-/// <reference types="es6-promise" />
-import { ProgramItem } from './program-item';
-import { ProgramRepository } from './../program-repository';
-export declare class ProgramItemFactory {
-    protected _programRepository: ProgramRepository;
-    protected _basePath: string;
-    basePath: string;
-    programRepository: ProgramRepository;
-    getProgramItem(programItemId: string): Promise<ProgramItem>;
-    prepareProgramItem(type: string, data: any): Promise<ProgramItem>;
-    prepareSlideshowItem(programItem: ProgramItem, data: any): Promise<ProgramItem>;
-    prepareVideoItem(programItem: ProgramItem, data: any): Promise<ProgramItem>;
-}

-export declare const PROGRAM_ITEM_TYPE_SLIDESHOW = "slideshow";
-export declare const PROGRAM_ITEM_TYPE_VIDEO = "video";
-export declare class ProgramItem {
-    protected _type: string;
-    protected _data: any;
-    type: string;
-    data: any;
-}

-/// <reference types="es6-promise" />
-import { ProgramRepository } from './program-repository';
-export declare class ProgramManager {
-    protected _programRepository: ProgramRepository;
-    programRepository: ProgramRepository;
-    getCurrentProgramItemId(): Promise<string>;
-    /**
-     * find program item in schedule, which fits
-     * according to current hh:mm
-     */
-    findCurrentProgramItem(schedule: any, dateInMinutes: number): string;
-    /**
-     * Find the program segment
-     * This is dependent on the date set on the device
-     */
-    findCurrentProgramSegment(): Promise<any>;
-}

-/// <reference types="es6-promise" />
-export interface ProgramRepository {
-    findById(id: string): Promise<any>;
-    findByIds(ids: Array<string>): Promise<Array<any>>;
-    findByType(type: string): Promise<Array<any>>;
-    replicate(): Promise<void>;
-}

-export declare class Util {
-    static getISODate(): string;
-    static getDateInMinutes(): number;
-    /**
-     * convert a time input to minutes
-     * e.g. 23:59 = 1439
-     */
-    static convertToMinutes(time: string): number;
-    static calculateNextMinute(): number;
-}