eyevinn-channel-engine 3.3.11 → 3.4.1

package/.github/workflows/publish.yml

@@ -12,9 +12,11 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 16
           registry-url: https://registry.npmjs.org/
-      - run: npm install
-      - run: npm publish --access public
+      - run: |
+          npm install
+          npm run build
+          npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/dist/engine/ad_request.d.ts

@@ -0,0 +1,14 @@
+export = AdRequest;
+declare class AdRequest {
+    constructor(adCopyMgrUri: any, adXchangeUri: any);
+    _adCopyMgrUri: any;
+    _adXchangeUri: any;
+    _splices: any[];
+    resolve(): Promise<any>;
+    get splices(): any[];
+    _requestBreaks(): Promise<any>;
+    _requestAdsFromXchange(): Promise<any>;
+    _requestAds(): Promise<any>;
+    _fillBreak(adbreak: any): Promise<any>;
+    _getAdById(ad: any): Promise<any>;
+}

package/dist/engine/ad_request.js

@@ -0,0 +1,121 @@
+var MOCK_VAST = "<VAST version=\"4.0\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://www.iab.com/VAST\">  <Ad id=\"20001\" sequence=\"1\" conditionalAd=\"false\">    <InLine>      <AdSystem version=\"4.0\">iabtechlab</AdSystem>      <Error>http://example.com/error</Error>      <Impression id=\"Impression-ID\">http://example.com/track/impression</Impression>      <Pricing model=\"cpm\" currency=\"USD\">        <![CDATA[ 25.00 ]]>      </Pricing>      <AdTitle>Inline Simple Ad</AdTitle>      <AdVerifications></AdVerifications>      <Advertiser>IAB Sample Company</Advertiser>      <Category authority=\"http://www.iabtechlab.com/categoryauthority\">AD CONTENT description category</Category>      <Creatives>        <Creative id=\"5480\" sequence=\"1\" adId=\"2447226\">          <UniversalAdId idRegistry=\"Eyevinn-Ad-ID\" idValue=\"1\">1</UniversalAdId>          <Linear>            <TrackingEvents>              <Tracking event=\"start\" offset=\"09:15:23\">http://example.com/tracking/start</Tracking>              <Tracking event=\"firstQuartile\">http://example.com/tracking/firstQuartile</Tracking>              <Tracking event=\"midpoint\">http://example.com/tracking/midpoint</Tracking>              <Tracking event=\"thirdQuartile\">http://example.com/tracking/thirdQuartile</Tracking>              <Tracking event=\"complete\">http://example.com/tracking/complete</Tracking>            </TrackingEvents>            <Duration>00:00:45</Duration>            <MediaFiles/>            <VideoClicks>              <ClickThrough id=\"blog\">                <![CDATA[https://iabtechlab.com]]>              </ClickThrough>            </VideoClicks>          </Linear>        </Creative>      </Creatives>    </InLine>  </Ad></VAST>";
+var MOCK_VMAP = "<vmap:VMAP xmlns:vmap=\"http://www.iab.net/vmap-1.0\" version=\"1.0\">   <vmap:AdBreak breakType=\"linear\" breakId=\"midroll1\" timeOffset=\"00:00:15.000\">     <vmap:AdSource allowMultipleAds=\"true\" followRedirects=\"true\" id=\"1\">       <vmap:VASTAdData>         <VAST version=\"3.0\" xsi:noNamespaceSchemaLocation=\"vast.xsd\">        ".concat(MOCK_VAST, "\n        </VAST>       </vmap:VASTAdData>     </vmap:AdSource>     <vmap:TrackingEvents>       <vmap:Tracking event=\"breakStart\">http://server.com/breakstart</vmap:Tracking>       <vmap:Tracking event=\"breakEnd\">http://server.com/breakend</vmap:Tracking>     </vmap:TrackingEvents>   </vmap:AdBreak>   <vmap:AdBreak breakType=\"linear\" breakId=\"midroll2\" timeOffset=\"00:10:00.000\">     <vmap:AdSource allowMultipleAds=\"true\" followRedirects=\"true\" id=\"2\">       <vmap:VASTAdData>         <VAST version=\"3.0\" xsi:noNamespaceSchemaLocation=\"vast.xsd\">        ").concat(MOCK_VAST, "\n        </VAST>       </vmap:VASTAdData>     </vmap:AdSource>     <vmap:TrackingEvents>       <vmap:Tracking event=\"breakStart\">http://server.com/breakstart</vmap:Tracking>       <vmap:Tracking event=\"breakEnd\">http://server.com/breakend</vmap:Tracking>     </vmap:TrackingEvents>   </vmap:AdBreak> </vmap:VMAP>");
+var request = require('request');
+var debug = require('debug')('engine-adrequest');
+var DEFAULT_BREAK_PATTERN = [
+    { position: 0.0 },
+    { position: 10 * 60.0 }
+];
+var MOCK_ADS = [
+    'video-sff-impression',
+    'video-apotea-impression',
+    //  'video-spp-impression',
+];
+var ADID_MAP = {
+    'video-sff-impression': { adid: 4 },
+    'video-apotea-impression': { adid: 5 },
+    'video-spp-impression': { adid: 3 },
+};
+function shuffleArray(array) {
+    for (var i = array.length - 1; i > 0; i--) {
+        var j = Math.floor(Math.random() * (i + 1));
+        var temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+}
+var AdRequest = /** @class */ (function () {
+    function AdRequest(adCopyMgrUri, adXchangeUri) {
+        this._adCopyMgrUri = adCopyMgrUri;
+        this._adXchangeUri = adXchangeUri;
+        this._splices = [];
+    }
+    AdRequest.prototype.resolve = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this._requestBreaks().then(function (breaks) {
+                var adBreakPromises = [];
+                for (var i = 0; i < breaks.length; i++) {
+                    adBreakPromises.push(_this._fillBreak(breaks[i]));
+                }
+                Promise.all(adBreakPromises).then(function () {
+                    resolve(_this.splices);
+                }).catch(reject);
+            }).catch(reject);
+        });
+    };
+    Object.defineProperty(AdRequest.prototype, "splices", {
+        get: function () {
+            return this._splices.sort(function (a, b) { return a.position - b.position; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AdRequest.prototype._requestBreaks = function () {
+        return new Promise(function (resolve, reject) {
+            var breaks = DEFAULT_BREAK_PATTERN;
+            resolve(breaks);
+        });
+    };
+    AdRequest.prototype._requestAdsFromXchange = function () {
+        return new Promise(function (resolve, reject) {
+            var ads = MOCK_ADS;
+            debug("Got ads from xchange:");
+            debug(ads);
+            resolve(ads);
+        });
+    };
+    AdRequest.prototype._requestAds = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this._requestAdsFromXchange().then(function (ads) {
+                var resolvedAds = [];
+                var adPromises = [];
+                for (var i = 0; i < ads.length; i++) {
+                    var ad = ADID_MAP[ads[i]];
+                    resolvedAds.push(ad);
+                    adPromises.push(_this._getAdById(ad));
+                }
+                Promise.all(adPromises).then(function () {
+                    debug("Got ads:");
+                    debug(resolvedAds);
+                    resolve(resolvedAds);
+                })
+                    .catch(reject);
+            });
+        });
+    };
+    AdRequest.prototype._fillBreak = function (adbreak) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this._requestAds().then(function (ads) {
+                var p = 0.0;
+                for (var i = 0; i < ads.length; i++) {
+                    _this._splices.push({ adid: ads[i].adid, position: adbreak.position + p, segments: ads[i].segments });
+                    p += ads[i].duration;
+                }
+                resolve();
+            });
+        });
+    };
+    AdRequest.prototype._getAdById = function (ad) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            request({ url: _this._adCopyMgrUri + '/ad/' + ad.adid }, function (err, resp, body) {
+                if (resp.statusCode == 200) {
+                    var data = JSON.parse(body);
+                    ad.adid = data.id;
+                    ad.uri = data.uri;
+                    ad.segments = data.segments;
+                    ad.duration = (1 * data.duration);
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    };
+    return AdRequest;
+}());
+module.exports = AdRequest;

package/dist/engine/chaos_monkey.d.ts

@@ -0,0 +1 @@
+export function loadVod(p: any): Promise<any>;

package/dist/engine/chaos_monkey.js

@@ -0,0 +1,55 @@
+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 (_) 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 _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
+};

package/dist/engine/event_stream.d.ts

@@ -0,0 +1,6 @@
+export = EventStream;
+declare class EventStream {
+    constructor(session: any);
+    _session: any;
+    poll(): Promise<any>;
+}

package/dist/engine/event_stream.js

@@ -0,0 +1,20 @@
+var EventStream = /** @class */ (function () {
+    function EventStream(session) {
+        this._session = session;
+    }
+    EventStream.prototype.poll = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var event = {};
+            event = _this._session.consumeEvent();
+            if (event) {
+                resolve(JSON.stringify(event));
+            }
+            else {
+                resolve(JSON.stringify({}));
+            }
+        });
+    };
+    return EventStream;
+}());
+module.exports = EventStream;

package/dist/engine/memcached_state_store.d.ts

@@ -0,0 +1,12 @@
+export = MemcachedStateStore;
+declare class MemcachedStateStore {
+    constructor(keyPrefix: any, opts: any);
+    keyPrefix: any;
+    client: any;
+    initAsync(id: any, initData: any): Promise<{}>;
+    resetAsync(id: any, initData: any): Promise<void>;
+    getAsync(id: any, key: any): Promise<any>;
+    setAsync(id: any, key: any, value: any): Promise<any>;
+    setVolatileAsync(id: any, key: any, value: any): Promise<void>;
+    removeAsync(id: any, key: any): Promise<void>;
+}

package/dist/engine/memcached_state_store.js

@@ -0,0 +1,164 @@
+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 (_) 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) {
+        this.keyPrefix = keyPrefix;
+        if (opts.version) {
+            var prependPrefix = opts.version.replace(/\./g, "X");
+            this.keyPrefix = prependPrefix + this.keyPrefix;
+            debug("Prepending keyprefix with ".concat(prependPrefix, " => ").concat(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.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;
+}());
+module.exports = MemcachedStateStore;

package/dist/engine/memory_state_store.d.ts

@@ -0,0 +1,11 @@
+export = MemoryStateStore;
+declare class MemoryStateStore {
+    constructor(type: any, opts: any);
+    sharedStates: {};
+    globalSharedStates: {};
+    initAsync(id: any, initData: any): Promise<any>;
+    getAsync(id: any, key: any): Promise<any>;
+    setAsync(id: any, key: any, value: any): Promise<any>;
+    setVolatileAsync(id: any, key: any, value: any): Promise<any>;
+    removeAsync(id: any, key: any): Promise<void>;
+}

package/dist/engine/memory_state_store.js

@@ -0,0 +1,105 @@
+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 (_) 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) {
+        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.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 {
+                    value = this.sharedStates[id][key];
+                }
+                return [2 /*return*/, value];
+            });
+        });
+    };
+    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 {
+                    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;
+}());
+module.exports = MemoryStateStore;

package/dist/engine/playhead_state.d.ts

@@ -0,0 +1,26 @@
+export const PlayheadState: Readonly<{
+    RUNNING: 1;
+    STOPPED: 2;
+    CRASHED: 3;
+    IDLE: 4;
+}>;
+export class PlayheadStateStore extends SharedStateStore {
+    constructor(opts: any);
+    create(sessionId: any): Promise<SharedPlayheadState>;
+}
+import SharedStateStore = require("./shared_state_store.js");
+declare class SharedPlayheadState {
+    constructor(store: any, sessionId: any, opts: any);
+    sessionId: any;
+    store: any;
+    state: number;
+    lastM3u8: any;
+    get(key: any): Promise<any>;
+    getState(): Promise<number>;
+    getLastM3u8(): Promise<any>;
+    getValues(keys: any): Promise<any>;
+    set(key: any, value: any): Promise<any>;
+    setState(newState: any): Promise<number>;
+    setLastM3u8(m3u8: any): Promise<any>;
+}
+export {};