@raydiant/playlist-window-manager 0.29.2 → 0.30.0

package/build/SurfaceBroker.test.d.ts

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

package/build/SurfaceBroker.test.js

@@ -0,0 +1,432 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+var SurfaceBroker_1 = __importStar(require("./SurfaceBroker"));
+var testUtils_1 = require("./testUtils");
+jest.useFakeTimers();
+// Lets promise callbacks run under fake timers.
+var settle = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var i;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                i = 0;
+                _a.label = 1;
+            case 1:
+                if (!(i < 20)) return [3 /*break*/, 4];
+                return [4 /*yield*/, Promise.resolve()];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                i += 1;
+                return [3 /*break*/, 1];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+var options = function (label) { return ({
+    url: "https://cdn.test/".concat(label, ".mp4"),
+    bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+    muted: true,
+    label: label,
+}); };
+function setup(hostOpts) {
+    var host = (0, testUtils_1.createFakeSurfaceHost)(hostOpts);
+    var warn = jest.fn();
+    var broker = new SurfaceBroker_1.default(host.surfaces, (0, testUtils_1.createLogger)({ warn: warn }));
+    var onEvent = jest.fn();
+    var onRefused = jest.fn();
+    var open = function (windowId) {
+        return broker.open(windowId, options(windowId), onEvent, onRefused);
+    };
+    var opens = function () { return host.calls.filter(function (c) { return c.method === 'openVideo'; }); };
+    var refusalsLogged = function (reason) {
+        return warn.mock.calls.filter(function (_a) {
+            var context = _a[1];
+            return context && context.reason === reason;
+        }).length;
+    };
+    return {
+        host: host,
+        broker: broker,
+        warn: warn,
+        onEvent: onEvent,
+        onRefused: onRefused,
+        open: open,
+        opens: opens,
+        refusalsLogged: refusalsLogged,
+    };
+}
+// Records the outcome of an open without letting a rejection go unhandled.
+function track(promise) {
+    var result = {};
+    promise.then(function (surface) {
+        result.surface = surface;
+    }, function (err) {
+        result.reason = err.reason;
+    });
+    return result;
+}
+describe('a refusal is answered', function () {
+    test.each(['no_decoder', 'unsupported'])('the host refusing %s is a refusal with that reason, logged once', function (reason) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, open, refusalsLogged, result;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup({ refuse: reason }), open = _a.open, refusalsLogged = _a.refusalsLogged;
+                    result = track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    expect(result.reason).toBe(reason);
+                    expect(refusalsLogged(reason)).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('an open past its deadline is refused, and a late handle is closed at once', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, open, refusalsLogged, result, lateId;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup({ hang: true }), host = _a.host, open = _a.open, refusalsLogged = _a.refusalsLogged;
+                    result = track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    expect(result.reason).toBeUndefined();
+                    jest.advanceTimersByTime(SurfaceBroker_1.SURFACE_OPEN_DEADLINE_MS);
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(result.reason).toBe('deadline');
+                    expect(refusalsLogged('deadline')).toBe(1);
+                    host.releaseHung();
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    lateId = host.lastId();
+                    expect(host.calls.filter(function (c) { return c.id === lateId; }).map(function (c) { return c.method; })).toEqual(['close']);
+                    expect(host.liveIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a first frame past its deadline closes the surface and is refused', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, open, onRefused, onEvent, refusalsLogged, result;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, open = _a.open, onRefused = _a.onRefused, onEvent = _a.onEvent, refusalsLogged = _a.refusalsLogged;
+                    result = track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    expect(result.surface).toBeDefined();
+                    jest.advanceTimersByTime(SurfaceBroker_1.SURFACE_FIRST_FRAME_DEADLINE_MS);
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(onRefused).toHaveBeenCalledWith('deadline');
+                    expect(refusalsLogged('deadline')).toBe(1);
+                    expect(host.liveIds()).toEqual([]);
+                    // A first frame after the deadline is not forwarded.
+                    host.emit(host.lastId(), {
+                        type: 'first_frame',
+                        width: 1920,
+                        height: 1080,
+                        durationS: 10,
+                    });
+                    expect(onEvent).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a first frame in time is forwarded and stops the deadline', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, open, onRefused, onEvent, frame;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, open = _a.open, onRefused = _a.onRefused, onEvent = _a.onEvent;
+                    track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    frame = {
+                        type: 'first_frame',
+                        width: 1920,
+                        height: 1080,
+                        durationS: 10,
+                    };
+                    host.emit(host.lastId(), frame);
+                    jest.advanceTimersByTime(SurfaceBroker_1.SURFACE_FIRST_FRAME_DEADLINE_MS * 2);
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(onEvent).toHaveBeenCalledWith(frame);
+                    expect(onRefused).not.toHaveBeenCalled();
+                    expect(host.liveIds()).toEqual([host.lastId()]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('no_decoder while a close is pending is tried once more after it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, broker, open, opens, refusalsLogged, first, surface, realClose, rejectOpen, realOpen, second;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, broker = _a.broker, open = _a.open, opens = _a.opens, refusalsLogged = _a.refusalsLogged;
+                    first = track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    surface = first.surface;
+                    realClose = surface.close.bind(surface);
+                    surface.close = function () {
+                        return new Promise(function (resolve) { return setTimeout(function () { return resolve(realClose()); }, 100); });
+                    };
+                    rejectOpen = function () { return undefined; };
+                    realOpen = host.surfaces.openVideo;
+                    host.surfaces.openVideo = function (opts) {
+                        host.surfaces.openVideo = realOpen;
+                        host.calls.push({ method: 'openVideo', args: [opts], seq: 0 });
+                        return new Promise(function (_, reject) {
+                            rejectOpen = reject;
+                        });
+                    };
+                    second = track(open('w2'));
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    broker.close('w1');
+                    rejectOpen(new Error('no_decoder'));
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(opens()).toHaveLength(2);
+                    jest.advanceTimersByTime(100);
+                    return [4 /*yield*/, settle()];
+                case 4:
+                    _b.sent();
+                    expect(opens()).toHaveLength(3);
+                    expect(second.surface).toBeDefined();
+                    expect(refusalsLogged('no_decoder')).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('no_decoder with no close pending is refused at once', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, open, opens, refusalsLogged, result;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup({ refuse: 'no_decoder' }), open = _a.open, opens = _a.opens, refusalsLogged = _a.refusalsLogged;
+                    result = track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    expect(result.reason).toBe('no_decoder');
+                    expect(opens()).toHaveLength(1);
+                    expect(refusalsLogged('no_decoder')).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('two at most; an open waits for a close', function () {
+    test('a third open with none closing or leaving is refused with no host call', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, open, opens, refusalsLogged, third;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, open = _a.open, opens = _a.opens, refusalsLogged = _a.refusalsLogged;
+                    track(open('w1'));
+                    track(open('w2'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    third = track(open('w3'));
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(third.reason).toBe('no_decoder');
+                    expect(opens()).toHaveLength(2);
+                    expect(refusalsLogged('no_decoder')).toBe(1);
+                    expect(host.violations).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a third open with a surface leaving waits for its close', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, broker, open, opens, third;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, broker = _a.broker, open = _a.open, opens = _a.opens;
+                    track(open('w1'));
+                    track(open('w2'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    broker.leaving('w1');
+                    third = track(open('w3'));
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(opens()).toHaveLength(2);
+                    expect(third.surface).toBeUndefined();
+                    return [4 /*yield*/, broker.close('w1')];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, settle()];
+                case 4:
+                    _b.sent();
+                    expect(opens()).toHaveLength(3);
+                    expect(third.surface).toBeDefined();
+                    expect(host.violations).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a third open with a close in flight waits for that close', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, broker, open, opens, first, surface, realClose, third;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, broker = _a.broker, open = _a.open, opens = _a.opens;
+                    first = track(open('w1'));
+                    track(open('w2'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    surface = first.surface;
+                    realClose = surface.close.bind(surface);
+                    surface.close = function () {
+                        return new Promise(function (resolve) { return setTimeout(function () { return resolve(realClose()); }, 100); });
+                    };
+                    broker.close('w1');
+                    third = track(open('w3'));
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(opens()).toHaveLength(2);
+                    jest.advanceTimersByTime(100);
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(opens()).toHaveLength(3);
+                    expect(third.surface).toBeDefined();
+                    expect(host.violations).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('an open given up before the host answers closes the handle', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, broker, open, result;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup({ hang: true }), host = _a.host, broker = _a.broker, open = _a.open;
+                    result = track(open('w1'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, broker.close('w1')];
+                case 2:
+                    _b.sent();
+                    host.releaseHung();
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(result.reason).toBe('closed');
+                    expect(host.liveIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('close is idempotent and closeAll closes every surface', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, host, broker, open;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), host = _a.host, broker = _a.broker, open = _a.open;
+                    track(open('w1'));
+                    track(open('w2'));
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, broker.close('w1')];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, broker.close('w1')];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, broker.closeAll()];
+                case 4:
+                    _b.sent();
+                    expect(host.liveIds()).toEqual([]);
+                    expect(host.calls.filter(function (c) { return c.method === 'close'; })).toHaveLength(2);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/index.d.ts

@@ -8,3 +8,4 @@ import PresentationWindow from './PresentationWindow';
 export * from './PresentationWindow';
 export { PresentationWindow };
 export * from './types';
+export * from './surfaces';

package/build/index.js

@@ -28,3 +28,4 @@ var PresentationWindow_1 = __importDefault(require("./PresentationWindow"));
 exports.PresentationWindow = PresentationWindow_1.default;
 __exportStar(require("./PresentationWindow"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./surfaces"), exports);

package/build/surfaces.d.ts

@@ -0,0 +1,52 @@
+export type VideoOptions = {
+    url: string;
+    bounds: Rect;
+    fit?: 'cover' | 'stretch';
+    loop?: boolean;
+    muted?: boolean;
+    label?: string;
+};
+export interface VideoSurface {
+    readonly id: number;
+    show(opts?: {
+        fadeMs?: number;
+    }): Promise<void>;
+    hide(opts?: {
+        fadeMs?: number;
+    }): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number): Promise<void>;
+    setBounds(r: Rect): Promise<void>;
+    setMuted(m: boolean): Promise<void>;
+    close(): Promise<void>;
+    onEvent(fn: (e: VideoEvent) => void): void;
+}
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type VideoEvent = {
+    type: 'first_frame';
+    width: number;
+    height: number;
+    durationS: number | null;
+} | {
+    type: 'playing';
+} | {
+    type: 'stalled';
+} | {
+    type: 'ended';
+} | {
+    type: 'error';
+    reason: 'fetch' | 'decode' | 'unsupported' | 'closed';
+};
+export interface SurfaceHost {
+    openVideo(opts: VideoOptions): Promise<VideoSurface>;
+    onHole(open: boolean): void;
+    showAfterRevealMs?: number;
+}
+export declare const VIDEO_REQUESTS: string[];
+export type VideoRefusalReason = 'no_decoder' | 'unsupported' | 'deadline' | 'not_offered';

package/build/surfaces.js

@@ -0,0 +1,15 @@
+"use strict";
+// The video contract's types, copied verbatim (exported, and kept out of
+// prettier so the copy stays diffable against the source) from the device
+// video contract that the Signage Stick's host builds to. A surface is a video
+// the host draws outside the browser, under the page, in a hole the page
+// clears.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIDEO_REQUESTS = void 0;
+// The messages an app sends to ask for, size, reveal and give up a surface.
+exports.VIDEO_REQUESTS = [
+    'open_video',
+    'video_bounds',
+    'video_hole_open',
+    'close_video',
+];

package/build/testUtils.d.ts

@@ -3,6 +3,7 @@ import * as re from '@raydiant/playlist-rule-engine';
 import PresentationWindow, { PresentationWindowOptions } from './PresentationWindow';
 import PlaylistWindowManagerState, { PlaylistWindowManagerStateOptions } from './PlaylistWindowManagerState';
 import { Presentation, ApplicationVersion, Logger, CreateWindowOptions } from './types';
+import { SurfaceHost, VideoEvent } from './surfaces';
 export declare function createPresentationWindow(overrides?: Partial<PresentationWindowOptions>): PresentationWindow;
 export declare function createPresentation(overrides?: Partial<Presentation>): Presentation;
 export declare function createPresentationRelationships(overrides?: Partial<Presentation['r']>): Presentation['r'];
@@ -41,3 +42,58 @@ export declare function createRenderer(): {
     runReceiveMessageCallback(type: string, payload: any): void;
     runErrorCallback(error: Error): void;
 };
+export interface RecordedCall {
+    method: string;
+    windowId: string;
+    args: unknown[];
+    seq: number;
+}
+export declare function createRecordingRenderer(): {
+    renderer: {
+        createWindow(opts: CreateWindowOptions): void;
+        loadWindow(windowId: string): Promise<void>;
+        updateWindowBounds(windowId: string, bounds: unknown): void;
+        showWindow(windowId: string, isFocused: boolean): void;
+        hideWindow(windowId: string): void;
+        removeWindow(windowId: string): Promise<void>;
+        sendMessageString(windowId: string, message: string): void;
+        sendMessageObject(windowId: string, type: string, payload?: unknown): void;
+        muteWindow(windowId: string): void;
+        unMuteWindow(windowId: string): void;
+        setWindowBackground(windowId: string, color: string): void;
+    };
+    calls: RecordedCall[];
+    received: RecordedCall[];
+    hooks: {
+        onLoad?: ((windowId: string) => void) | undefined;
+        onMessage?: ((windowId: string, type: string, payload?: any) => void) | undefined;
+    };
+    receive(windowId: string, type: string, payload?: any): void;
+    fail(windowId: string, err: Error): void;
+    liveWindowIds(): string[];
+};
+export interface FakeSurfaceCall {
+    id?: number;
+    method: string;
+    args: unknown[];
+    seq: number;
+}
+export declare function createFakeSurfaceHost(opts?: {
+    decoders?: number;
+    refuse?: 'no_decoder' | 'unsupported';
+    hang?: boolean;
+    hangShow?: boolean;
+    playingAfterMs?: number;
+}): {
+    surfaces: SurfaceHost;
+    calls: FakeSurfaceCall[];
+    violations: string[];
+    emit: (id: number, event: VideoEvent) => void;
+    releaseHung(): void;
+    liveIds(): number[];
+    lastId(): number;
+    refuseNext(reason: 'no_decoder' | 'unsupported'): void;
+    hangNextOpen(): void;
+    hangNextShow(): void;
+};
+export declare function flush(times?: number): Promise<void>;