eyevinn-channel-engine 5.0.6 → 5.1.2

package/.github/workflows/nodejs.yml

@@ -1,5 +1,5 @@
 name: Node CI
-  
+
 on: [push]
 
 jobs:
@@ -9,12 +9,12 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [20.x, 22.x]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
     - name: npm install, build, and test

package/.github/workflows/publish.yml

@@ -1,5 +1,5 @@
 name: Publish
-  
+
 on:
   release:
     types: [released]
@@ -9,13 +9,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
-          node-version: 16
+          node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: |
-          npm install
+          npm ci
           npm run build
           npm publish
         env:

package/.github/workflows/rc.yml

@@ -1,5 +1,5 @@
 name: Publish release candidate
-  
+
 on:
   release:
     types: [prereleased]
@@ -9,13 +9,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
-          node-version: 16
+          node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: |
-          npm install
+          npm ci
           npm run build
           npm publish --tag rc
         env:

package/dist/engine/chaos_monkey.js

@@ -1,55 +1,16 @@
-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 };
+"use strict";
+const debug = require('debug')('chaos-monkey');
+const CHAOS_MONKEY_PROBABILITY = process.env.CHAOS_MONKEY_PROBABILITY || 0.5;
+const doChaos = () => process.env.CHAOS_MONKEY === "true" && Math.random() < CHAOS_MONKEY_PROBABILITY;
+const loadVod = async (p) => {
+    if (doChaos()) {
+        debug("Chaos Monkey is doing stuff");
+        throw new Error("Chaos monkey prevented you from loading a VOD");
+    }
+    else {
+        return await p;
     }
 };
-var _this = this;
-var debug = require('debug')('chaos-monkey');
-var CHAOS_MONKEY_PROBABILITY = process.env.CHAOS_MONKEY_PROBABILITY || 0.5;
-var doChaos = function () { return process.env.CHAOS_MONKEY === "true" && Math.random() < CHAOS_MONKEY_PROBABILITY; };
-var loadVod = function (p) { return __awaiter(_this, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!doChaos()) return [3 /*break*/, 1];
-                debug("Chaos Monkey is doing stuff");
-                throw new Error("Chaos monkey prevented you from loading a VOD");
-            case 1: return [4 /*yield*/, p];
-            case 2: return [2 /*return*/, _a.sent()];
-        }
-    });
-}); };
 module.exports = {
-    loadVod: loadVod
+    loadVod
 };

package/dist/engine/event_stream.js

@@ -1,12 +1,12 @@
-var EventStream = /** @class */ (function () {
-    function EventStream(session) {
+"use strict";
+class EventStream {
+    constructor(session) {
         this._session = session;
     }
-    EventStream.prototype.poll = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var event = {};
-            event = _this._session.consumeEvent();
+    poll() {
+        return new Promise((resolve, reject) => {
+            let event = {};
+            event = this._session.consumeEvent();
             if (event) {
                 resolve(JSON.stringify(event));
             }
@@ -14,7 +14,6 @@ var EventStream = /** @class */ (function () {
                 resolve(JSON.stringify({}));
             }
         });
-    };
-    return EventStream;
-}());
+    }
+}
 module.exports = EventStream;

package/dist/engine/index.d.ts

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

package/dist/engine/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/engine/memcached_state_store.js

@@ -1,172 +1,60 @@
-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 MemcacheClient = require("memcache-client");
-var debug = require("debug")("memcached-state-store");
-var MemcachedStateStore = /** @class */ (function () {
-    function MemcachedStateStore(keyPrefix, opts) {
+"use strict";
+const MemcacheClient = require("memcache-client");
+const debug = require("debug")("memcached-state-store");
+class MemcachedStateStore {
+    constructor(keyPrefix, opts) {
         this.keyPrefix = keyPrefix;
         if (opts.version) {
-            var prependPrefix = opts.version.replace(/\./g, "X");
+            const prependPrefix = opts.version.replace(/\./g, "X");
             this.keyPrefix = prependPrefix + this.keyPrefix;
-            debug("Prepending keyprefix with ".concat(prependPrefix, " => ").concat(this.keyPrefix));
+            debug(`Prepending keyprefix with ${prependPrefix} => ${this.keyPrefix}`);
         }
         this.client = new MemcacheClient({ server: opts.memcachedUrl, cmdTimeout: 10000 });
     }
-    MemcachedStateStore.prototype.initAsync = function (id, initData) {
-        return __awaiter(this, void 0, void 0, function () {
-            var isInitiated, data, _i, _a, key, _b, _c, _d, _e, key, _f, _g;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
-                    case 0: return [4 /*yield*/, this.getAsync(id, "_initiated")];
-                    case 1:
-                        isInitiated = _h.sent();
-                        data = {};
-                        if (!!isInitiated) return [3 /*break*/, 7];
-                        _i = 0, _a = Object.keys(initData);
-                        _h.label = 2;
-                    case 2:
-                        if (!(_i < _a.length)) return [3 /*break*/, 5];
-                        key = _a[_i];
-                        debug("".concat(this.keyPrefix, ":").concat(id, ": Initiating key ").concat(key, " with init data"));
-                        _b = data;
-                        _c = key;
-                        return [4 /*yield*/, this.setAsync(id, key, initData[key])];
-                    case 3:
-                        _b[_c] = _h.sent();
-                        _h.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5: return [4 /*yield*/, this.setAsync(id, "_initiated", true)];
-                    case 6:
-                        _h.sent();
-                        return [3 /*break*/, 11];
-                    case 7:
-                        debug("".concat(this.keyPrefix, ":").concat(id, ": Already initiated, not initiating with init data"));
-                        _d = 0, _e = Object.keys(initData);
-                        _h.label = 8;
-                    case 8:
-                        if (!(_d < _e.length)) return [3 /*break*/, 11];
-                        key = _e[_d];
-                        debug("".concat(this.keyPrefix, ":").concat(id, ": Initiating key ").concat(key, " with data from store"));
-                        _f = data;
-                        _g = key;
-                        return [4 /*yield*/, this.getAsync(id, key)];
-                    case 9:
-                        _f[_g] = _h.sent();
-                        _h.label = 10;
-                    case 10:
-                        _d++;
-                        return [3 /*break*/, 8];
-                    case 11: return [2 /*return*/, data];
-                }
-            });
-        });
-    };
-    MemcachedStateStore.prototype.resetAsync = function (id, initData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.setAsync(id, "_initiated", false)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.initAsync(id, initData)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    MemcachedStateStore.prototype.resetAllAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                console.error("Shared Storage Reset Failed.\nMemcache-client: Flush All Command Not Implemented Yet");
-                return [2 /*return*/];
-            });
-        });
-    };
-    MemcachedStateStore.prototype.getAsync = function (id, key) {
-        return __awaiter(this, void 0, void 0, function () {
-            var storeKey, data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        storeKey = "" + this.keyPrefix + id + key;
-                        return [4 /*yield*/, this.client.get(storeKey)];
-                    case 1:
-                        data = _a.sent();
-                        if (data) {
-                            return [2 /*return*/, JSON.parse(data.value)];
-                        }
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    MemcachedStateStore.prototype.setAsync = function (id, key, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            var storeKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        storeKey = "" + this.keyPrefix + id + key;
-                        return [4 /*yield*/, this.client.set(storeKey, JSON.stringify(value))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, value];
-                }
-            });
-        });
-    };
-    MemcachedStateStore.prototype.setVolatileAsync = function (id, key, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                throw new Error("memcached: setVolatileAsync not implemented yet");
-            });
-        });
-    };
-    MemcachedStateStore.prototype.removeAsync = function (id, key) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                throw new Error("memcached: removeAsync not implemented yet");
-            });
-        });
-    };
-    return MemcachedStateStore;
-}());
+    async initAsync(id, initData) {
+        const isInitiated = await this.getAsync(id, "_initiated");
+        let data = {};
+        if (!isInitiated) {
+            for (const key of Object.keys(initData)) {
+                debug(`${this.keyPrefix}:${id}: Initiating key ${key} with init data`);
+                data[key] = await this.setAsync(id, key, initData[key]);
+            }
+            await this.setAsync(id, "_initiated", true);
+        }
+        else {
+            debug(`${this.keyPrefix}:${id}: Already initiated, not initiating with init data`);
+            for (const key of Object.keys(initData)) {
+                debug(`${this.keyPrefix}:${id}: Initiating key ${key} with data from store`);
+                data[key] = await this.getAsync(id, key);
+            }
+        }
+        return data;
+    }
+    async resetAsync(id, initData) {
+        await this.setAsync(id, "_initiated", false);
+        await this.initAsync(id, initData);
+    }
+    async resetAllAsync() {
+        console.error("Shared Storage Reset Failed.\nMemcache-client: Flush All Command Not Implemented Yet");
+    }
+    async getAsync(id, key) {
+        const storeKey = "" + this.keyPrefix + id + key;
+        const data = await this.client.get(storeKey);
+        if (data) {
+            return JSON.parse(data.value);
+        }
+        return null;
+    }
+    async setAsync(id, key, value) {
+        const storeKey = "" + this.keyPrefix + id + key;
+        await this.client.set(storeKey, JSON.stringify(value));
+        return value;
+    }
+    async setVolatileAsync(id, key, value) {
+        throw new Error("memcached: setVolatileAsync not implemented yet");
+    }
+    async removeAsync(id, key) {
+        throw new Error("memcached: removeAsync not implemented yet");
+    }
+}
 module.exports = MemcachedStateStore;

package/dist/engine/memory_state_store.js

@@ -1,134 +1,57 @@
-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 debug = require("debug")("memory-state-store");
-var MemoryStateStore = /** @class */ (function () {
-    function MemoryStateStore(type, opts) {
+"use strict";
+const debug = require("debug")("memory-state-store");
+class MemoryStateStore {
+    constructor(type, opts) {
         this.sharedStates = {};
         this.globalSharedStates = {};
     }
-    MemoryStateStore.prototype.initAsync = function (id, initData) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (!this.sharedStates[id]) {
-                    this.sharedStates[id] = {};
-                    Object.keys(initData).forEach(function (key) {
-                        _this.sharedStates[id][key] = initData[key];
-                    });
-                }
-                return [2 /*return*/, this.sharedStates[id]];
-            });
-        });
-    };
-    MemoryStateStore.prototype.resetAsync = function (id, initData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.sharedStates[id] = null;
-                        return [4 /*yield*/, this.initAsync(id, initData)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    MemoryStateStore.prototype.resetAllAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.sharedStates = {};
-                this.globalSharedStates = {};
-                return [2 /*return*/];
-            });
-        });
-    };
-    MemoryStateStore.prototype.getAsync = function (id, key) {
-        return __awaiter(this, void 0, void 0, function () {
-            var value;
-            return __generator(this, function (_a) {
-                if (id === "" || id === null) {
-                    value = this.globalSharedStates[key];
-                }
-                else {
-                    if (!this.sharedStates[id]) {
-                        return [2 /*return*/, null];
-                    }
-                    value = this.sharedStates[id][key];
-                }
-                return [2 /*return*/, value];
+    async initAsync(id, initData) {
+        if (!this.sharedStates[id]) {
+            this.sharedStates[id] = {};
+            Object.keys(initData).forEach((key) => {
+                this.sharedStates[id][key] = initData[key];
             });
-        });
-    };
-    MemoryStateStore.prototype.setAsync = function (id, key, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (id === "" || id === null) {
-                    this.globalSharedStates[key] = value;
-                }
-                else {
-                    if (!this.sharedStates[id]) {
-                        this.sharedStates[id] = {};
-                    }
-                    this.sharedStates[id][key] = value;
-                    return [2 /*return*/, this.sharedStates[id][key]];
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    MemoryStateStore.prototype.setVolatileAsync = function (id, key, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.setAsync(id, key, value)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    MemoryStateStore.prototype.removeAsync = function (id, key) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                delete this.sharedStates[id][key];
-                return [2 /*return*/];
-            });
-        });
-    };
-    return MemoryStateStore;
-}());
+        }
+        return this.sharedStates[id];
+    }
+    async resetAsync(id, initData) {
+        this.sharedStates[id] = null;
+        await this.initAsync(id, initData);
+    }
+    async resetAllAsync() {
+        this.sharedStates = {};
+        this.globalSharedStates = {};
+    }
+    async getAsync(id, key) {
+        let value;
+        if (id === "" || id === null) {
+            value = this.globalSharedStates[key];
+        }
+        else {
+            if (!this.sharedStates[id]) {
+                return null;
+            }
+            value = this.sharedStates[id][key];
+        }
+        return value;
+    }
+    async setAsync(id, key, value) {
+        if (id === "" || id === null) {
+            this.globalSharedStates[key] = value;
+        }
+        else {
+            if (!this.sharedStates[id]) {
+                this.sharedStates[id] = {};
+            }
+            this.sharedStates[id][key] = value;
+            return this.sharedStates[id][key];
+        }
+    }
+    async setVolatileAsync(id, key, value) {
+        return await this.setAsync(id, key, value);
+    }
+    async removeAsync(id, key) {
+        delete this.sharedStates[id][key];
+    }
+}
 module.exports = MemoryStateStore;