@raydiant/playlist-window-manager 0.29.2 → 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 () {
@@ -617,3 +645,298 @@ describe('detachCallbacks', function () {
         });
     }); });
 });
+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;
+}

package/build/SurfaceBroker.js

@@ -0,0 +1,311 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SurfaceRefusal = exports.DEFAULT_SHOW_AFTER_REVEAL_MS = exports.DEFAULT_SURFACE_SWAP_DELAY_MS = exports.MAX_LIVE_SURFACES = exports.SURFACE_FIRST_FRAME_DEADLINE_MS = exports.SURFACE_OPEN_DEADLINE_MS = void 0;
+// How long the host's openVideo may take to resolve.
+exports.SURFACE_OPEN_DEADLINE_MS = 2000;
+// From openVideo resolving to first_frame. Inside the 30-second ready timeout,
+// with time left for the app to fall back to <video> and still be ready.
+exports.SURFACE_FIRST_FRAME_DEADLINE_MS = 10000;
+// One playing and one prepared.
+exports.MAX_LIVE_SURFACES = 2;
+// How long a surface swap waits for the incoming window's first paint, and
+// how long showing a surface may take, when closeWindowDelayMs is not set:
+// 1000 ms, the closeWindowDelayMs the player passes.
+exports.DEFAULT_SURFACE_SWAP_DELAY_MS = 1000;
+// SurfaceHost.showAfterRevealMs when the player sets none. On the Signage
+// Stick (Fire OS 8.4, Amazon WebView 136, portrait) the WebView takes about
+// 80-120 ms longer than a surface to put a reveal on screen: 60 ms left the
+// theme trailing the picture by up to 35 ms, and 100 ms put it ahead by up
+// to 54 ms.
+exports.DEFAULT_SHOW_AFTER_REVEAL_MS = 80;
+// Rejects an open. `closed` means the window gave the surface up before the
+// open finished, which needs no answer to the app.
+var SurfaceRefusal = /** @class */ (function (_super) {
+    __extends(SurfaceRefusal, _super);
+    function SurfaceRefusal(reason) {
+        var _this = _super.call(this, "Video surface refused: ".concat(reason)) || this;
+        _this.reason = reason;
+        _this.name = 'SurfaceRefusal';
+        Object.setPrototypeOf(_this, SurfaceRefusal.prototype);
+        return _this;
+    }
+    return SurfaceRefusal;
+}(Error));
+exports.SurfaceRefusal = SurfaceRefusal;
+// The host rejects with an Error whose message is a short machine code.
+var reasonOf = function (err) {
+    if (err instanceof SurfaceRefusal && err.reason !== 'closed') {
+        return err.reason;
+    }
+    var code = typeof err === 'string'
+        ? err
+        : err && typeof err === 'object'
+            ? err.message
+            : undefined;
+    return code === 'no_decoder' ? 'no_decoder' : 'unsupported';
+};
+// Holds every video surface one window manager has open, so the manager never
+// asks the host for more than two at once and opens the next only after the
+// outgoing one has closed, leaving the host an idle decoder to reuse.
+var SurfaceBroker = /** @class */ (function () {
+    function SurfaceBroker(host, logger) {
+        this.host = host;
+        this.logger = logger;
+        this.entries = {};
+    }
+    // Resolves once the host has opened a hidden surface. Rejects with a
+    // SurfaceRefusal. A first frame later than its deadline closes the surface
+    // and reports it through onRefused instead.
+    SurfaceBroker.prototype.open = function (windowId, opts, onEvent, onRefused) {
+        return __awaiter(this, void 0, void 0, function () {
+            var markClosed, closed, entry, pending_1, surface, retried, err_1, reason, pending_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        markClosed = function () { return undefined; };
+                        closed = new Promise(function (resolve) {
+                            markClosed = resolve;
+                        });
+                        entry = {
+                            windowId: windowId,
+                            label: opts.label,
+                            surface: null,
+                            state: 'opening',
+                            leaving: false,
+                            firstFrameTimer: null,
+                            closePromise: null,
+                            closed: closed,
+                            markClosed: markClosed,
+                        };
+                        this.entries[windowId] = entry;
+                        _a.label = 1;
+                    case 1:
+                        this.throwIfGivenUp(entry);
+                        pending_1 = this.pendingCloses(entry);
+                        if (!(pending_1.length > 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, Promise.all(pending_1)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        if (this.liveOthers(entry).length >= exports.MAX_LIVE_SURFACES) {
+                            throw this.refuse(entry, 'no_decoder');
+                        }
+                        return [3 /*break*/, 5];
+                    case 4: return [3 /*break*/, 1];
+                    case 5:
+                        retried = false;
+                        _a.label = 6;
+                    case 6:
+                        this.throwIfGivenUp(entry);
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, , 12]);
+                        return [4 /*yield*/, this.openWithDeadline(opts)];
+                    case 8:
+                        surface = _a.sent();
+                        return [3 /*break*/, 13];
+                    case 9:
+                        err_1 = _a.sent();
+                        this.throwIfGivenUp(entry);
+                        reason = reasonOf(err_1);
+                        pending_2 = this.pendingCloses(entry);
+                        if (!(reason === 'no_decoder' && !retried && pending_2.length > 0)) return [3 /*break*/, 11];
+                        retried = true;
+                        return [4 /*yield*/, Promise.all(pending_2)];
+                    case 10:
+                        _a.sent();
+                        return [3 /*break*/, 12];
+                    case 11: throw this.refuse(entry, reason);
+                    case 12: return [3 /*break*/, 6];
+                    case 13:
+                        if (entry.state === 'closed') {
+                            surface.close();
+                            throw new SurfaceRefusal('closed');
+                        }
+                        entry.surface = surface;
+                        entry.state = 'open';
+                        entry.firstFrameTimer = setTimeout(function () {
+                            entry.firstFrameTimer = null;
+                            _this.warnRefusal(entry, 'deadline');
+                            _this.close(windowId);
+                            onRefused('deadline');
+                        }, exports.SURFACE_FIRST_FRAME_DEADLINE_MS);
+                        surface.onEvent(function (e) {
+                            if (entry.state !== 'open')
+                                return;
+                            if (e.type === 'first_frame') {
+                                if (!entry.firstFrameTimer)
+                                    return;
+                                clearTimeout(entry.firstFrameTimer);
+                                entry.firstFrameTimer = null;
+                            }
+                            onEvent(e);
+                        });
+                        return [2 /*return*/, surface];
+                }
+            });
+        });
+    };
+    // A swap has started for this window's surface; its close follows.
+    SurfaceBroker.prototype.leaving = function (windowId) {
+        var entry = this.entries[windowId];
+        if (entry)
+            entry.leaving = true;
+    };
+    // Closes the window's surface, or gives up its open. Idempotent.
+    SurfaceBroker.prototype.close = function (windowId) {
+        var _this = this;
+        var entry = this.entries[windowId];
+        if (!entry)
+            return Promise.resolve();
+        if (entry.closePromise)
+            return entry.closePromise;
+        if (entry.firstFrameTimer) {
+            clearTimeout(entry.firstFrameTimer);
+            entry.firstFrameTimer = null;
+        }
+        var surface = entry.surface;
+        if (!surface) {
+            // Still opening: open() closes a handle that resolves from here on.
+            this.forget(entry);
+            return Promise.resolve();
+        }
+        entry.state = 'closing';
+        entry.closePromise = surface
+            .close()
+            .catch(function (err) {
+            _this.logger.warn("Failed to close video surface for window '".concat(windowId, "' with '").concat(err && err.message, "'"), { windowId: windowId, presentationId: entry.label });
+        })
+            .then(function () { return _this.forget(entry); });
+        return entry.closePromise;
+    };
+    SurfaceBroker.prototype.closeAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(Object.keys(this.entries).map(function (id) { return _this.close(id); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // A window's hole opened or closed.
+    SurfaceBroker.prototype.onHole = function (open) {
+        this.host.onHole(open);
+    };
+    SurfaceBroker.prototype.openWithDeadline = function (opts) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var settled = false;
+            var timer = setTimeout(function () {
+                settled = true;
+                reject(new SurfaceRefusal('deadline'));
+            }, exports.SURFACE_OPEN_DEADLINE_MS);
+            new Promise(function (r) { return r(_this.host.openVideo(opts)); }).then(function (surface) {
+                if (settled) {
+                    // A late handle never holds a decoder nobody uses.
+                    surface.close();
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                resolve(surface);
+            }, function (err) {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    };
+    SurfaceBroker.prototype.throwIfGivenUp = function (entry) {
+        if (entry.state === 'closed') {
+            throw new SurfaceRefusal('closed');
+        }
+    };
+    SurfaceBroker.prototype.liveOthers = function (entry) {
+        var _this = this;
+        return Object.keys(this.entries)
+            .map(function (id) { return _this.entries[id]; })
+            .filter(function (e) { return e !== entry && e.state !== 'closed'; });
+    };
+    SurfaceBroker.prototype.pendingCloses = function (entry) {
+        return this.liveOthers(entry)
+            .filter(function (e) { return e.state === 'closing' || e.leaving; })
+            .map(function (e) { return e.closed; });
+    };
+    SurfaceBroker.prototype.refuse = function (entry, reason) {
+        this.forget(entry);
+        this.warnRefusal(entry, reason);
+        return new SurfaceRefusal(reason);
+    };
+    SurfaceBroker.prototype.warnRefusal = function (entry, reason) {
+        this.logger.warn("Sending 'video_refused' to window '".concat(entry.windowId, "', reason=").concat(reason), { windowId: entry.windowId, presentationId: entry.label, reason: reason });
+    };
+    SurfaceBroker.prototype.forget = function (entry) {
+        entry.state = 'closed';
+        if (this.entries[entry.windowId] === entry) {
+            delete this.entries[entry.windowId];
+        }
+        entry.markClosed();
+    };
+    return SurfaceBroker;
+}());
+exports.default = SurfaceBroker;