@raydiant/playlist-window-manager 0.29.1 → 0.30.0

package/build/PresentationWindow.test.js

@@ -1,4 +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 __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) {
@@ -35,8 +58,13 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 });
 var testUtils_1 = require("./testUtils");
+var re = __importStar(require("@raydiant/playlist-rule-engine"));
+var SurfaceBroker_1 = __importDefault(require("./SurfaceBroker"));
 var delay = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
 describe('embedded apps', function () {
     test('loads embedded url format', function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -431,3 +459,484 @@ describe('interrupt locks', function () {
     }); });
 });
 // TODO: Backfill tests for all legacy and embedded apps.
+describe('waitForFirstPaint', function () {
+    // The default (non-embedded) window resolves load() only after the app
+    // reports ready, so drive the handshake through the mock renderer.
+    var loadPresentationWindow = function (testRenderer, window) { return __awaiter(void 0, void 0, void 0, function () {
+        var loadPromise;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadPromise = window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('loaded', undefined);
+                    testRenderer.runReceiveMessageCallback('presentation_ready', undefined);
+                    return [4 /*yield*/, loadPromise];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    test('resolves when the window reports first_painted', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window, resolved, wait;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-first-paint',
+                        renderer: testRenderer,
+                    });
+                    return [4 /*yield*/, loadPresentationWindow(testRenderer, window)];
+                case 1:
+                    _a.sent();
+                    resolved = false;
+                    wait = window.waitForFirstPaint(5000).then(function () {
+                        resolved = true;
+                    });
+                    return [4 /*yield*/, delay(10)];
+                case 2:
+                    _a.sent();
+                    expect(resolved).toBe(false);
+                    testRenderer.runReceiveMessageCallback('first_painted', undefined);
+                    return [4 /*yield*/, wait];
+                case 3:
+                    _a.sent();
+                    expect(resolved).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('falls back to the timeout when no paint signal arrives', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-first-paint-timeout',
+                        renderer: testRenderer,
+                    });
+                    return [4 /*yield*/, loadPresentationWindow(testRenderer, window)];
+                case 1:
+                    _a.sent();
+                    // Resolves via the timeout even though first_painted never arrives.
+                    return [4 /*yield*/, window.waitForFirstPaint(20)];
+                case 2:
+                    // Resolves via the timeout even though first_painted never arrives.
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('resolves immediately when the window already painted since the last play', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window, resolved;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-first-paint-immediate',
+                        renderer: testRenderer,
+                    });
+                    return [4 /*yield*/, loadPresentationWindow(testRenderer, window)];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('first_painted', undefined);
+                    resolved = false;
+                    window.waitForFirstPaint(5000).then(function () {
+                        resolved = true;
+                    });
+                    return [4 /*yield*/, Promise.resolve()];
+                case 2:
+                    _a.sent();
+                    expect(resolved).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('play starts a new paint cycle', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window, resolved, wait;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-first-paint-replay',
+                        renderer: testRenderer,
+                    });
+                    return [4 /*yield*/, loadPresentationWindow(testRenderer, window)];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('first_painted', undefined);
+                    window.play();
+                    resolved = false;
+                    wait = window.waitForFirstPaint(5000).then(function () {
+                        resolved = true;
+                    });
+                    return [4 /*yield*/, delay(10)];
+                case 2:
+                    _a.sent();
+                    expect(resolved).toBe(false);
+                    testRenderer.runReceiveMessageCallback('first_painted', undefined);
+                    return [4 /*yield*/, wait];
+                case 3:
+                    _a.sent();
+                    expect(resolved).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('resolves pending waiters when the window is removed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window, wait;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-first-paint-removed',
+                        renderer: testRenderer,
+                    });
+                    return [4 /*yield*/, loadPresentationWindow(testRenderer, window)];
+                case 1:
+                    _a.sent();
+                    wait = window.waitForFirstPaint(5000);
+                    return [4 /*yield*/, window.remove()];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, wait];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('detachCallbacks', function () {
+    test('stops delivering events to the window manager', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window, loadPromise, onComplete;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-detach',
+                        renderer: testRenderer,
+                    });
+                    loadPromise = window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('loaded', undefined);
+                    testRenderer.runReceiveMessageCallback('presentation_ready', undefined);
+                    return [4 /*yield*/, loadPromise];
+                case 2:
+                    _a.sent();
+                    onComplete = jest.fn();
+                    window.onComplete(onComplete);
+                    window.detachCallbacks();
+                    testRenderer.runReceiveMessageCallback('presentation_complete', undefined);
+                    expect(onComplete).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('video surfaces', function () {
+    var CONTENT_URL = 'https://cdn.test/clip.mp4';
+    function setupVideoWindow(opts) {
+        var _a;
+        if (opts === void 0) { opts = {}; }
+        var testRenderer = (0, testUtils_1.createRenderer)();
+        var host = (0, testUtils_1.createFakeSurfaceHost)();
+        var warn = jest.fn();
+        var logger = (0, testUtils_1.createLogger)({ warn: warn });
+        var window = (0, testUtils_1.createPresentationWindow)({
+            windowId: 'video-window',
+            presentation: (0, testUtils_1.createPresentation)({
+                id: 'p1',
+                applicationVariables: (_a = opts.applicationVariables) !== null && _a !== void 0 ? _a : {
+                    content: { url: CONTENT_URL, filename: 'clip.mp4' },
+                },
+            }),
+            applicationVersion: (0, testUtils_1.createApplicationVersion)(opts.applicationVersion),
+            renderer: testRenderer,
+            logger: logger,
+            surfaceBroker: opts.withHost === false
+                ? undefined
+                : new SurfaceBroker_1.default(host.surfaces, logger),
+        });
+        var messages = function () {
+            return testRenderer.sendMessageString.mock.calls.map(function (_a) {
+                var message = _a[1];
+                return JSON.parse(message);
+            });
+        };
+        var refusals = function () {
+            return messages()
+                .filter(function (m) { return m.type === 'video_refused'; })
+                .map(function (m) { return m.payload.reason; });
+        };
+        var refusalsLogged = function () {
+            return warn.mock.calls.filter(function (_a) {
+                var message = _a[0];
+                return /video_refused/.test(message);
+            })
+                .length;
+        };
+        var openVideo = function (url) {
+            return testRenderer.runReceiveMessageCallback('open_video', {
+                url: url,
+                bounds: { x: 0.4, y: 10.6, width: 1919.6, height: 1080 },
+                muted: false,
+            });
+        };
+        return {
+            testRenderer: testRenderer,
+            host: host,
+            window: window,
+            messages: messages,
+            refusals: refusals,
+            refusalsLogged: refusalsLogged,
+            openVideo: openVideo,
+        };
+    }
+    test('open_video reaches the host, and render carries nativeVideo, only with a host', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var offered, unoffered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    offered = setupVideoWindow();
+                    offered.window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _a.sent();
+                    offered.testRenderer.runReceiveMessageCallback('loaded', undefined);
+                    expect(offered.messages().find(function (m) { return m.type === 'render'; }).payload.nativeVideo).toBe(true);
+                    offered.openVideo(CONTENT_URL);
+                    return [4 /*yield*/, delay(0)];
+                case 2:
+                    _a.sent();
+                    expect(offered.host.calls.filter(function (c) { return c.method === 'openVideo'; })[0].args[0]).toEqual({
+                        url: CONTENT_URL,
+                        bounds: { x: 0, y: 11, width: 1920, height: 1080 },
+                        muted: true,
+                        label: 'p1',
+                    });
+                    expect(offered.messages().map(function (m) { return m.type; })).toContain('video_opened');
+                    return [4 /*yield*/, offered.window.remove()];
+                case 3:
+                    _a.sent();
+                    unoffered = setupVideoWindow({ withHost: false });
+                    unoffered.window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 4:
+                    _a.sent();
+                    unoffered.testRenderer.runReceiveMessageCallback('loaded', undefined);
+                    expect(unoffered.messages().find(function (m) { return m.type === 'render'; }).payload).not.toHaveProperty('nativeVideo');
+                    unoffered.openVideo(CONTENT_URL);
+                    expect(unoffered.refusals()).toEqual(['not_offered']);
+                    expect(unoffered.refusalsLogged()).toBe(1);
+                    return [4 /*yield*/, unoffered.window.remove()];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a rendition beside the presentation url opens a surface', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, host, openVideo, refusals;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setupVideoWindow(), window = _a.window, host = _a.host, openVideo = _a.openVideo, refusals = _a.refusals;
+                    window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _b.sent();
+                    openVideo("".concat(CONTENT_URL, "_720p"));
+                    return [4 /*yield*/, delay(0)];
+                case 2:
+                    _b.sent();
+                    expect(host.calls.filter(function (c) { return c.method === 'openVideo'; })).toHaveLength(1);
+                    expect(refusals()).toEqual([]);
+                    return [4 /*yield*/, window.remove()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test.each([
+        ['a url the presentation does not hold', 'https://cdn.test/other.mp4'],
+        ['a url beside it with another suffix', "".concat(CONTENT_URL, "_1080p")],
+    ])('%s is refused not_offered', function (_, url) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, host, openVideo, refusals, refusalsLogged;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setupVideoWindow(), window = _a.window, host = _a.host, openVideo = _a.openVideo, refusals = _a.refusals, refusalsLogged = _a.refusalsLogged;
+                    window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _b.sent();
+                    openVideo(url);
+                    return [4 /*yield*/, delay(0)];
+                case 2:
+                    _b.sent();
+                    expect(refusals()).toEqual(['not_offered']);
+                    expect(refusalsLogged()).toBe(1);
+                    expect(host.calls).toEqual([]);
+                    return [4 /*yield*/, window.remove()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a url that is not http(s) is refused not_offered', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, host, openVideo, refusals;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setupVideoWindow({
+                        applicationVariables: { content: { url: 'blob:https://cdn.test/1' } },
+                    }), window = _a.window, host = _a.host, openVideo = _a.openVideo, refusals = _a.refusals;
+                    window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _b.sent();
+                    openVideo('blob:https://cdn.test/1');
+                    return [4 /*yield*/, delay(0)];
+                case 2:
+                    _b.sent();
+                    expect(refusals()).toEqual(['not_offered']);
+                    expect(host.calls).toEqual([]);
+                    return [4 /*yield*/, window.remove()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('an embedded app is refused not_offered', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, host, testRenderer, refusals, refusalsLogged;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setupVideoWindow({
+                        applicationVersion: { embeddedUrlFormat: 'https://embedded.test/' },
+                    }), window = _a.window, host = _a.host, testRenderer = _a.testRenderer, refusals = _a.refusals, refusalsLogged = _a.refusalsLogged;
+                    return [4 /*yield*/, window.load()];
+                case 1:
+                    _b.sent();
+                    testRenderer.runReceiveMessageCallback('open_video', {
+                        url: CONTENT_URL,
+                        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+                    });
+                    return [4 /*yield*/, delay(0)];
+                case 2:
+                    _b.sent();
+                    expect(refusals()).toEqual(['not_offered']);
+                    expect(refusalsLogged()).toBe(1);
+                    expect(host.calls).toEqual([]);
+                    return [4 /*yield*/, window.remove()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test("a zone's windows are offered no surface and refused not_offered", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, host, logger, zonePresentation, window, zoneWindowId, zoneMessages;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    host = (0, testUtils_1.createFakeSurfaceHost)();
+                    logger = (0, testUtils_1.createLogger)();
+                    zonePresentation = (0, testUtils_1.createPresentation)({
+                        id: 'z1',
+                        applicationDeploymentId: 'zone-app',
+                        applicationVariables: { content: { url: CONTENT_URL } },
+                    });
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'multizone',
+                        presentation: (0, testUtils_1.createPresentation)({
+                            id: 'mz',
+                            r: {
+                                resource: { updatedAt: 'updatedAt', createdAt: 'createdAt' },
+                                presentationsPlaylists: [{ playlistId: 'zone-playlist' }],
+                            },
+                        }),
+                        playlistWindowManagerState: (0, testUtils_1.createPlaylistWindowManagerState)({
+                            presentations: { z1: zonePresentation },
+                            applicationVersions: {
+                                'zone-app': (0, testUtils_1.createApplicationVersion)({ id: 'zone-app' }),
+                            },
+                        }),
+                        ruleEngineState: (0, testUtils_1.createRuleEngineState)({
+                            'zone-playlist': {
+                                id: 'zone-playlist',
+                                mode: re.PlaylistMode.Sequential,
+                                items: [{ presentationId: 'z1' }],
+                            },
+                        }, { z1: { id: 'z1', applicationName: 'videos' } }),
+                        renderer: testRenderer,
+                        logger: logger,
+                        surfaceBroker: new SurfaceBroker_1.default(host.surfaces, logger),
+                    });
+                    window.load();
+                    return [4 /*yield*/, delay(0)];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('open_child_window', {
+                        windowId: 'zone1',
+                        playlistId: 'zone-playlist',
+                        x: 0,
+                        y: 0,
+                        width: 960,
+                        height: 1080,
+                        isMuted: false,
+                        isFocused: false,
+                    });
+                    return [4 /*yield*/, delay(0)];
+                case 2:
+                    _a.sent();
+                    zoneWindowId = testRenderer.createWindow.mock.calls[1][0].windowId;
+                    testRenderer.runReceiveMessageCallback('loaded', undefined);
+                    zoneMessages = function () {
+                        return testRenderer.sendMessageString.mock.calls
+                            .filter(function (_a) {
+                            var windowId = _a[0];
+                            return windowId === zoneWindowId;
+                        })
+                            .map(function (_a) {
+                            var message = _a[1];
+                            return JSON.parse(message);
+                        });
+                    };
+                    expect(zoneMessages().find(function (m) { return m.type === 'render'; }).payload).not.toHaveProperty('nativeVideo');
+                    testRenderer.runReceiveMessageCallback('open_video', {
+                        url: CONTENT_URL,
+                        bounds: { x: 0, y: 0, width: 960, height: 1080 },
+                        muted: false,
+                    });
+                    return [4 /*yield*/, delay(0)];
+                case 3:
+                    _a.sent();
+                    expect(zoneMessages()
+                        .filter(function (m) { return m.type === 'video_refused'; })
+                        .map(function (m) { return m.payload.reason; })).toEqual(['not_offered']);
+                    expect(host.calls).toEqual([]);
+                    return [4 /*yield*/, window.remove()];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/SurfaceBroker.d.ts

@@ -0,0 +1,30 @@
+import { Logger } from './types';
+import { SurfaceHost, VideoEvent, VideoOptions, VideoSurface, VideoRefusalReason } from './surfaces';
+export declare const SURFACE_OPEN_DEADLINE_MS = 2000;
+export declare const SURFACE_FIRST_FRAME_DEADLINE_MS = 10000;
+export declare const MAX_LIVE_SURFACES = 2;
+export declare const DEFAULT_SURFACE_SWAP_DELAY_MS = 1000;
+export declare const DEFAULT_SHOW_AFTER_REVEAL_MS = 80;
+export type SurfaceRefusalReason = Exclude<VideoRefusalReason, 'not_offered'>;
+export declare class SurfaceRefusal extends Error {
+    reason: SurfaceRefusalReason | 'closed';
+    constructor(reason: SurfaceRefusalReason | 'closed');
+}
+export default class SurfaceBroker {
+    private host;
+    private logger;
+    private entries;
+    constructor(host: SurfaceHost, logger: Logger);
+    open(windowId: string, opts: VideoOptions, onEvent: (e: VideoEvent) => void, onRefused: (reason: SurfaceRefusalReason) => void): Promise<VideoSurface>;
+    leaving(windowId: string): void;
+    close(windowId: string): Promise<void>;
+    closeAll(): Promise<void>;
+    onHole(open: boolean): void;
+    private openWithDeadline;
+    private throwIfGivenUp;
+    private liveOthers;
+    private pendingCloses;
+    private refuse;
+    private warnRefusal;
+    private forget;
+}