@signageos/lib 23.8.1 → 23.8.2-master.4405

package/dist/Timer/increasingInterval.js

@@ -0,0 +1,108 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setIncreasingInterval = setIncreasingInterval;
+exports.clearIncreasingInterval = clearIncreasingInterval;
+var wait_1 = __importDefault(require("./wait"));
+var lastId = 0;
+var intervals = [];
+function setIncreasingInterval(startInterval, increase, maxInterval, callback) {
+    if (startInterval <= 0) {
+        throw new Error('Starting interval must be a positive number');
+    }
+    if (typeof maxInterval === 'number' && maxInterval < startInterval) {
+        throw new Error('Max interval must be higher than or equal to start interval');
+    }
+    if (typeof increase === 'number' && increase < 0) {
+        throw new Error('Increase must be a non-negative number');
+    }
+    var id = ++lastId;
+    intervals.push(id);
+    handler(id, startInterval, increase, maxInterval, callback).catch(function () { return clearIncreasingInterval(id); });
+    return id;
+}
+function clearIncreasingInterval(clearId) {
+    intervals = intervals.filter(function (id) { return id !== clearId; });
+}
+function handler(id, startInterval, increase, maxInterval, callback) {
+    return __awaiter(this, void 0, void 0, function () {
+        var interval;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    interval = startInterval;
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    return [4 /*yield*/, (0, wait_1.default)(interval)];
+                case 2:
+                    _a.sent();
+                    if (intervals.indexOf(id) < 0) {
+                        return [3 /*break*/, 3];
+                    }
+                    callback();
+                    interval = increaseInterval(interval, increase, maxInterval);
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function increaseInterval(previousInterval, increase, maxInterval) {
+    var newInterval;
+    if (typeof increase === 'number') {
+        newInterval = previousInterval + increase;
+    }
+    else if (typeof increase === 'function') {
+        newInterval = increase(previousInterval);
+    }
+    else {
+        throw new Error('Invalid increase value - must be either number or a function');
+    }
+    if (newInterval < previousInterval) {
+        throw new Error('Unexpected value: interval decreased');
+    }
+    if (typeof maxInterval === 'number') {
+        return Math.min(newInterval, maxInterval);
+    }
+    return newInterval;
+}
+//# sourceMappingURL=increasingInterval.js.map

package/dist/Timer/increasingInterval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"increasingInterval.js","sourceRoot":"","sources":["../../src/Timer/increasingInterval.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,sDAuBC;AAED,0DAEC;AAhCD,gDAA0B;AAE1B,IAAI,MAAM,GAAG,CAAC,CAAC;AACf,IAAI,SAAS,GAAa,EAAE,CAAC;AAE7B,SAAgB,qBAAqB,CACpC,aAAqB,EACrB,QAAyD,EACzD,WAAsC,EACtC,QAAoB;IAEpB,IAAI,aAAa,IAAI,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,GAAG,aAAa,EAAE,CAAC;QACpE,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAC;IAChF,CAAC;IAED,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC3D,CAAC;IAED,IAAM,EAAE,GAAG,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACnB,OAAO,CAAC,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,cAAM,OAAA,uBAAuB,CAAC,EAAE,CAAC,EAA3B,CAA2B,CAAC,CAAC;IAErG,OAAO,EAAE,CAAC;AACX,CAAC;AAED,SAAgB,uBAAuB,CAAC,OAAe;IACtD,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,UAAC,EAAU,IAAK,OAAA,EAAE,KAAK,OAAO,EAAd,CAAc,CAAC,CAAC;AAC9D,CAAC;AAED,SAAe,OAAO,CACrB,EAAU,EACV,aAAqB,EACrB,QAAyD,EACzD,WAAsC,EACtC,QAAoB;;;;;;oBAEhB,QAAQ,GAAG,aAAa,CAAC;;;yBAEtB,IAAI;oBACV,qBAAM,IAAA,cAAI,EAAC,QAAQ,CAAC,EAAA;;oBAApB,SAAoB,CAAC;oBAErB,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;wBAC/B,wBAAM;oBACP,CAAC;oBAED,QAAQ,EAAE,CAAC;oBACX,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;;;;;;CAE9D;AAED,SAAS,gBAAgB,CACxB,gBAAwB,EACxB,QAAyD,EACzD,WAAsC;IAEtC,IAAI,WAAmB,CAAC;IAExB,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAClC,WAAW,GAAG,gBAAgB,GAAG,QAAQ,CAAC;IAC3C,CAAC;SAAM,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QAC3C,WAAW,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAC1C,CAAC;SAAM,CAAC;QACP,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IACjF,CAAC;IAED,IAAI,WAAW,GAAG,gBAAgB,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,WAAW,CAAC;AACpB,CAAC"}

package/dist/Timer/nonConcurrentInterval.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Set an interval that will not run if the previous interval has not finished.
+ */
+export declare function setNonConcurrentInterval(callback: (...args: any[]) => any, ms: number, ...args: any[]): NodeJS.Timeout;

package/dist/Timer/nonConcurrentInterval.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNonConcurrentInterval = setNonConcurrentInterval;
+/**
+ * Set an interval that will not run if the previous interval has not finished.
+ */
+function setNonConcurrentInterval(callback, ms) {
+    var _this = this;
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var busy = false;
+    return setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (busy) {
+                        return [2 /*return*/];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 3, 4]);
+                    busy = true;
+                    return [4 /*yield*/, callback.apply(void 0, args)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    busy = false;
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }, ms);
+}
+//# sourceMappingURL=nonConcurrentInterval.js.map

package/dist/Timer/nonConcurrentInterval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonConcurrentInterval.js","sourceRoot":"","sources":["../../src/Timer/nonConcurrentInterval.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,4DAeC;AAlBD;;GAEG;AACH,SAAgB,wBAAwB,CAAC,QAAiC,EAAE,EAAU;IAAtF,iBAeC;IAfuF,cAAc;SAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;QAAd,6BAAc;;IACrG,IAAI,IAAI,GAAG,KAAK,CAAC;IAEjB,OAAO,WAAW,CAAC;;;;oBAClB,IAAI,IAAI,EAAE,CAAC;wBACV,sBAAO;oBACR,CAAC;;;;oBAGA,IAAI,GAAG,IAAI,CAAC;oBACZ,qBAAM,QAAQ,eAAI,IAAI,GAAC;;oBAAvB,SAAuB,CAAC;;;oBAExB,IAAI,GAAG,KAAK,CAAC;;;;;SAEd,EAAE,EAAE,CAAC,CAAC;AACR,CAAC"}

package/dist/Timer/progressiveWait.d.ts

@@ -0,0 +1,40 @@
+import { WaitOptions } from './wait';
+/**
+ * @returns wait() A progressive wait function.
+ * @returns reset() A function that resets the timeout to the initial value.
+ * @returns getCurrentTimeoutMs() How long it's currently waiting since the last wait.
+ *     It's not changing during a single iteration of wait().
+ * @returns getNextTimeoutMs() Same as the getCurrentTimeoutMs but for upcoming wait() iteration.
+ *     It's getCurrentTimeoutMs() value multiplied with initial multiplier (respecting the maximum value)
+ */
+export interface IProgressiveWait {
+    wait: (options?: WaitOptions) => Promise<void>;
+    reset: () => void;
+    getCurrentTimeoutMs: () => number;
+    getNextTimeoutMs: () => number;
+}
+export interface IProgressiveWaitFactory {
+    (initialTimeoutMs: number): IProgressiveWait;
+}
+/**
+ * Creates a progressive wait function that can be used to wait for a period of time,
+ * and then progressively increase the wait time by a multiplier.
+ *
+ * @param initialTimeoutMs The initial timeout in milliseconds.
+ * @param progressiveMultiplier The multiplier to use when increasing the timeout.
+ * @param maxTimeoutMs The maximum timeout in milliseconds.
+ * @example of usage:
+ * const wait = createProgressiveWait(1000);
+ * await wait(); // waits for 1000ms
+ * await wait(); // waits for 2000ms
+ * await wait(); // waits for 4000ms
+ * await wait(); // waits for 8000ms
+ * await wait(); // waits for 10000ms
+ *
+ * const wait = createProgressiveWait(1000, 3);
+ * await wait(); // waits for 1000ms
+ * await wait(); // waits for 3000ms
+ * await wait(); // waits for 9000ms
+ * await wait(); // waits for 10000ms
+ */
+export declare const createProgressiveWait: (initialTimeoutMs: number, progressiveMultiplier?: number, maxTimeoutMs?: number) => IProgressiveWait;

package/dist/Timer/progressiveWait.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgressiveWait = void 0;
+var wait_1 = __importDefault(require("./wait"));
+/**
+ * Creates a progressive wait function that can be used to wait for a period of time,
+ * and then progressively increase the wait time by a multiplier.
+ *
+ * @param initialTimeoutMs The initial timeout in milliseconds.
+ * @param progressiveMultiplier The multiplier to use when increasing the timeout.
+ * @param maxTimeoutMs The maximum timeout in milliseconds.
+ * @example of usage:
+ * const wait = createProgressiveWait(1000);
+ * await wait(); // waits for 1000ms
+ * await wait(); // waits for 2000ms
+ * await wait(); // waits for 4000ms
+ * await wait(); // waits for 8000ms
+ * await wait(); // waits for 10000ms
+ *
+ * const wait = createProgressiveWait(1000, 3);
+ * await wait(); // waits for 1000ms
+ * await wait(); // waits for 3000ms
+ * await wait(); // waits for 9000ms
+ * await wait(); // waits for 10000ms
+ */
+var createProgressiveWait = function (initialTimeoutMs, progressiveMultiplier, maxTimeoutMs) {
+    if (progressiveMultiplier === void 0) { progressiveMultiplier = 2; }
+    if (maxTimeoutMs === void 0) { maxTimeoutMs = initialTimeoutMs * 10; }
+    var currentTimeoutMs = initialTimeoutMs;
+    return {
+        wait: function () {
+            return __awaiter(this, arguments, void 0, function (options) {
+                if (options === void 0) { options = {}; }
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, (0, wait_1.default)(currentTimeoutMs, options)];
+                        case 1:
+                            _a.sent();
+                            currentTimeoutMs = this.getNextTimeoutMs();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        },
+        reset: function () {
+            currentTimeoutMs = initialTimeoutMs;
+        },
+        getCurrentTimeoutMs: function () {
+            return currentTimeoutMs;
+        },
+        getNextTimeoutMs: function () {
+            return Math.min(currentTimeoutMs * progressiveMultiplier, maxTimeoutMs);
+        },
+    };
+};
+exports.createProgressiveWait = createProgressiveWait;
+//# sourceMappingURL=progressiveWait.js.map

package/dist/Timer/progressiveWait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressiveWait.js","sourceRoot":"","sources":["../../src/Timer/progressiveWait.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gDAA2C;AAqB3C;;;;;;;;;;;;;;;;;;;;GAoBG;AAEI,IAAM,qBAAqB,GAAG,UACpC,gBAAwB,EACxB,qBAAiC,EACjC,YAA4C;IAD5C,sCAAA,EAAA,yBAAiC;IACjC,6BAAA,EAAA,eAAuB,gBAAgB,GAAG,EAAE;IAE5C,IAAI,gBAAgB,GAAG,gBAAgB,CAAC;IACxC,OAAO;QACA,IAAI;gEAAC,OAAyB;gBAAzB,wBAAA,EAAA,YAAyB;;;gCACnC,qBAAM,IAAA,cAAI,EAAC,gBAAgB,EAAE,OAAO,CAAC,EAAA;;4BAArC,SAAqC,CAAC;4BACtC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;;;;;SAC3C;QACD,KAAK;YACJ,gBAAgB,GAAG,gBAAgB,CAAC;QACrC,CAAC;QACD,mBAAmB;YAClB,OAAO,gBAAgB,CAAC;QACzB,CAAC;QACD,gBAAgB;YACf,OAAO,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,qBAAqB,EAAE,YAAY,CAAC,CAAC;QACzE,CAAC;KACD,CAAC;AACH,CAAC,CAAC;AArBW,QAAA,qBAAqB,yBAqBhC"}

package/dist/Timer/timeout.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Use `@signageos/core` instead.
+ */
+export * from '@signageos/core/dist/Timer/timeout';

package/dist/Timer/timeout.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @deprecated Use `@signageos/core` instead.
+ */
+__exportStar(require("@signageos/core/dist/Timer/timeout"), exports);
+//# sourceMappingURL=timeout.js.map

package/dist/Timer/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../../src/Timer/timeout.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,qEAAmD"}

package/dist/Timer/wait.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use `@signageos/core` instead.
+ */
+export * from '@signageos/core/dist/Timer/wait';
+export { default } from '@signageos/core/dist/Timer/wait';

package/dist/Timer/wait.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+/**
+ * @deprecated Use `@signageos/core` instead.
+ */
+__exportStar(require("@signageos/core/dist/Timer/wait"), exports);
+var wait_1 = require("@signageos/core/dist/Timer/wait");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(wait_1).default; } });
+//# sourceMappingURL=wait.js.map

package/dist/Timer/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../../src/Timer/wait.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,kEAAgD;AAChD,wDAA0D;AAAjD,gHAAA,OAAO,OAAA"}

package/dist/TypeScript/asyncIterator.d.ts

@@ -0,0 +1 @@
+export default function asyncIterator<T>(collection: Promise<T[]>): IterableIterator<Promise<T | undefined>>;

package/dist/TypeScript/asyncIterator.js

@@ -0,0 +1,76 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = asyncIterator;
+function asyncIterator(collection) {
+    var length, _loop_1, i;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                length = 1;
+                collection = collection.then(function (items) {
+                    if (items) {
+                        length = items.length;
+                    }
+                    return items;
+                });
+                _loop_1 = function (i) {
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0: return [4 /*yield*/, collection.then(function (items) {
+                                    if (!items) {
+                                        return undefined;
+                                    }
+                                    return items[i];
+                                })];
+                            case 1:
+                                _b.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                };
+                i = 0;
+                _a.label = 1;
+            case 1:
+                if (!(i < length)) return [3 /*break*/, 4];
+                return [5 /*yield**/, _loop_1(i)];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                i++;
+                return [3 /*break*/, 1];
+            case 4: return [2 /*return*/];
+        }
+    });
+}
+if (!Symbol.asyncIterator) {
+    Symbol.asyncIterator = asyncIterator;
+}
+//# sourceMappingURL=asyncIterator.js.map

package/dist/TypeScript/asyncIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncIterator.js","sourceRoot":"","sources":["../../src/TypeScript/asyncIterator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gCAkBC;AAlBD,SAAyB,aAAa,CAAI,UAAwB;;;;;gBAC7D,MAAM,GAAW,CAAC,CAAC;gBACvB,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,UAAU,KAAU;oBAChD,IAAI,KAAK,EAAE,CAAC;wBACX,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;oBACvB,CAAC;oBAED,OAAO,KAAK,CAAC;gBACd,CAAC,CAAC,CAAC;oCAEM,CAAC;;;oCACT,qBAAM,UAAU,CAAC,IAAI,CAAC,UAAC,KAAU;oCAChC,IAAI,CAAC,KAAK,EAAE,CAAC;wCACZ,OAAO,SAAS,CAAC;oCAClB,CAAC;oCACD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;gCACjB,CAAC,CAAC,EAAA;;gCALF,SAKE,CAAC;;;;;gBANK,CAAC,GAAW,CAAC;;;qBAAE,CAAA,CAAC,GAAG,MAAM,CAAA;8CAAzB,CAAC;;;;;gBAA0B,CAAC,EAAE,CAAA;;;;;CAQvC;AAED,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC1B,MAAc,CAAC,aAAa,GAAG,aAAa,CAAC;AAC/C,CAAC"}

package/dist/TypeScript/expect.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A function that does nothing, but can be used to assert types.
+ * It's alternative to should library or expect, but for TypeLand in TypeScript.
+ * @param _expected expected value for T type argument
+ */
+export declare function expectType<T>(_expected: T): void;

package/dist/TypeScript/expect.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectType = expectType;
+/**
+ * A function that does nothing, but can be used to assert types.
+ * It's alternative to should library or expect, but for TypeLand in TypeScript.
+ * @param _expected expected value for T type argument
+ */
+function expectType(_expected) {
+    // only for type expectations
+}
+//# sourceMappingURL=expect.js.map

package/dist/TypeScript/expect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.js","sourceRoot":"","sources":["../../src/TypeScript/expect.ts"],"names":[],"mappings":";;AAKA,gCAEC;AAPD;;;;GAIG;AACH,SAAgB,UAAU,CAAI,SAAY;IACzC,6BAA6B;AAC9B,CAAC"}

package/dist/TypeScript/generator.d.ts

@@ -0,0 +1 @@
+export declare function generateUnionTypeRecursive(path: string, typeName?: string): string;

package/dist/TypeScript/generator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnionTypeRecursive = generateUnionTypeRecursive;
+var checksum_1 = require("../Hash/checksum");
+var moduleDiscoverer_1 = require("../FileSystem/moduleDiscoverer");
+function generateUnionTypeRecursive(path, typeName) {
+    if (typeName === void 0) { typeName = 'IUnionType'; }
+    var moduleExports = (0, moduleDiscoverer_1.getModuleExportsRecursive)(path);
+    var stringModuleExports = moduleExports.filter(function (moduleExport) { return typeof moduleExport.value === 'string'; });
+    var imports = stringModuleExports.reduce(function (reduction, moduleExport) {
+        var hash = checksumModuleExport(moduleExport);
+        return reduction + "\nimport { ".concat(moduleExport.export, " as ").concat(hash, " } from '").concat(moduleExport.relativePath, "';");
+    }, '');
+    var unionTypes = stringModuleExports.map(function (moduleExport) { return checksumModuleExport(moduleExport); }).join(' | ');
+    return "".concat(imports, "\ntype ").concat(typeName, " = ").concat(unionTypes.length ? unionTypes : 'void', ";\nexport default ").concat(typeName, ";\n");
+}
+function checksumModuleExport(moduleExport) {
+    return moduleExport.export + '_' + (0, checksum_1.checksumString)(moduleExport.relativePath, 5);
+}
+//# sourceMappingURL=generator.js.map

package/dist/TypeScript/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../src/TypeScript/generator.ts"],"names":[],"mappings":";;AAGA,gEAYC;AAfD,6CAAkD;AAClD,mEAA0F;AAE1F,SAAgB,0BAA0B,CAAC,IAAY,EAAE,QAA+B;IAA/B,yBAAA,EAAA,uBAA+B;IACvF,IAAM,aAAa,GAAG,IAAA,4CAAyB,EAAC,IAAI,CAAC,CAAC;IACtD,IAAM,mBAAmB,GAAG,aAAa,CAAC,MAAM,CAAC,UAAC,YAA2B,IAAK,OAAA,OAAO,YAAY,CAAC,KAAK,KAAK,QAAQ,EAAtC,CAAsC,CAAC,CAAC;IAC1H,IAAM,OAAO,GAAG,mBAAmB,CAAC,MAAM,CAAC,UAAC,SAAiB,EAAE,YAA2B;QACzF,IAAM,IAAI,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAC;QAChD,OAAO,SAAS,GAAG,qBAAc,YAAY,CAAC,MAAM,iBAAO,IAAI,sBAAY,YAAY,CAAC,YAAY,OAAI,CAAC;IAC1G,CAAC,EAAE,EAAE,CAAC,CAAC;IACP,IAAM,UAAU,GAAG,mBAAmB,CAAC,GAAG,CAAC,UAAC,YAA2B,IAAK,OAAA,oBAAoB,CAAC,YAAY,CAAC,EAAlC,CAAkC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5H,OAAO,UAAG,OAAO,oBACX,QAAQ,gBAAM,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,+BAC3C,QAAQ,QACxB,CAAC;AACF,CAAC;AAED,SAAS,oBAAoB,CAAC,YAA2B;IACxD,OAAO,YAAY,CAAC,MAAM,GAAG,GAAG,GAAG,IAAA,yBAAc,EAAC,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;AACjF,CAAC"}

package/dist/TypeScript/object.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rename a property in a type.
+ * E.g.:
+ * ```ts
+ * type A = { a: string; b: number; };
+ * type B = RenameProperty<A, 'a', 'c'>;
+ * // B is { c: string; b: number; }
+ * ```
+ */
+export type RenameProperty<T, K extends keyof T, N extends string> = Omit<T, K> & {
+    [RenamedK in N]: T[K];
+};

package/dist/TypeScript/object.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=object.js.map

package/dist/TypeScript/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/TypeScript/object.ts"],"names":[],"mappings":""}

package/dist/TypeScript/observable-polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/TypeScript/observable-polyfill.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var zen_observable_1 = __importDefault(require("zen-observable"));
+var root;
+if (typeof self !== 'undefined') {
+    root = self;
+}
+else if (typeof window !== 'undefined') {
+    root = window;
+}
+else if (typeof global !== 'undefined') {
+    root = global;
+}
+else if (typeof module !== 'undefined') {
+    root = module;
+}
+else {
+    root = Function('return this')();
+}
+if (typeof root.Observable === 'undefined') {
+    root.Observable = zen_observable_1.default;
+    Symbol.observable = zen_observable_1.default;
+}
+if (typeof root.Observable.prototype.map === 'undefined') {
+    root.Observable.prototype.map = zen_observable_1.default.prototype.map;
+}
+if (typeof root.Observable.prototype.filter === 'undefined') {
+    root.Observable.prototype.filter = zen_observable_1.default.prototype.filter;
+}
+//# sourceMappingURL=observable-polyfill.js.map

package/dist/TypeScript/observable-polyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable-polyfill.js","sourceRoot":"","sources":["../../src/TypeScript/observable-polyfill.ts"],"names":[],"mappings":";;;;;AAAA,kEAAwC;AAExC,IAAI,IAAI,CAAC;AAET,IAAI,OAAO,IAAI,KAAK,WAAW,EAAE,CAAC;IACjC,IAAI,GAAG,IAAI,CAAC;AACb,CAAC;KAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;IAC1C,IAAI,GAAG,MAAM,CAAC;AACf,CAAC;KAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;IAC1C,IAAI,GAAG,MAAM,CAAC;AACf,CAAC;KAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;IAC1C,IAAI,GAAG,MAAM,CAAC;AACf,CAAC;KAAM,CAAC;IACP,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;AAClC,CAAC;AAED,IAAI,OAAO,IAAI,CAAC,UAAU,KAAK,WAAW,EAAE,CAAC;IAC5C,IAAI,CAAC,UAAU,GAAG,wBAAU,CAAC;IAC5B,MAAc,CAAC,UAAU,GAAG,wBAAU,CAAC;AACzC,CAAC;AACD,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,KAAK,WAAW,EAAE,CAAC;IAC1D,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,GAAG,wBAAU,CAAC,SAAS,CAAC,GAAG,CAAC;AAC1D,CAAC;AACD,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;IAC7D,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,GAAG,wBAAU,CAAC,SAAS,CAAC,MAAM,CAAC;AAChE,CAAC"}

package/dist/Utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare function areArraysEqualIgnoreOrder<T>(arr1: T[], arr2: T[], comparator?: (a: T, b: T) => boolean): boolean;
+export declare function assertArraysEqualIgnoreOrder<T>(arr1: T[], arr2: T[], comparator?: (a: T, b: T) => boolean): void;

package/dist/Utils/array.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areArraysEqualIgnoreOrder = areArraysEqualIgnoreOrder;
+exports.assertArraysEqualIgnoreOrder = assertArraysEqualIgnoreOrder;
+var assert_1 = require("assert");
+var lodash_1 = require("lodash");
+function areArraysEqualIgnoreOrder(arr1, arr2, comparator) {
+    if (comparator === void 0) { comparator = lodash_1.isEqual; }
+    return (0, lodash_1.differenceWith)(arr1, arr2, comparator).length === 0 && (0, lodash_1.differenceWith)(arr2, arr1, comparator).length === 0;
+}
+function assertArraysEqualIgnoreOrder(arr1, arr2, comparator) {
+    if (comparator === void 0) { comparator = lodash_1.isEqual; }
+    if (!areArraysEqualIgnoreOrder(arr1, arr2, comparator)) {
+        throw new assert_1.AssertionError({
+            message: "Arrays are not equal",
+            expected: arr1,
+            actual: arr2,
+            operator: 'assertArraysEqualIgnoreOrder',
+            stackStartFn: assertArraysEqualIgnoreOrder,
+        });
+    }
+}
+//# sourceMappingURL=array.js.map