@netless/slide 1.4.59-alpha.3 → 1.4.59-alpha.4

package/lib/PlayerController.js

@@ -1,175 +0,0 @@
-import { GUI } from "dat.gui";
-var PlayerConfig = /** @class */ (function () {
-    function PlayerConfig(player) {
-        this.player = player;
-    }
-    ;
-    Object.defineProperty(PlayerConfig.prototype, "frameRate", {
-        get: function () {
-            return this.player.fps.value;
-        },
-        set: function (_) { },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "drawFrames", {
-        get: function () {
-            return this.player.runtime.fps;
-        },
-        set: function (_) { },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "drawCall", {
-        get: function () {
-            return this.player.runtime.drawCall;
-        },
-        set: function (_) { },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "resolution", {
-        get: function () {
-            return this.player.config.resolution;
-        },
-        set: function (value) {
-            this.player.updateConfig({ resolution: value });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "size", {
-        get: function () {
-            var _a, _b;
-            return ((_a = this.player.view) === null || _a === void 0 ? void 0 : _a.width) + "*" + ((_b = this.player.view) === null || _b === void 0 ? void 0 : _b.height);
-        },
-        set: function (_) { },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "minFPS", {
-        get: function () {
-            return this.player.config.minFPS;
-        },
-        set: function (value) {
-            this.player.updateConfig({ minFPS: value, maxFPS: this.player.config.maxFPS });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "maxFPS", {
-        get: function () {
-            return this.player.config.maxFPS;
-        },
-        set: function (value) {
-            this.player.updateConfig({ maxFPS: value, minFPS: this.player.config.minFPS });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "autoResolution", {
-        get: function () {
-            return this.player.config.autoResolution;
-        },
-        set: function (value) {
-            this.player.updateConfig({ autoResolution: value });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "autoFPS", {
-        get: function () {
-            return this.player.config.autoFPS;
-        },
-        set: function (value) {
-            this.player.updateConfig({ autoFPS: value });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "backgroundColor", {
-        get: function () {
-            return this.player.config.transactionBgColor;
-        },
-        set: function (value) {
-            this.player.updateConfig({ transactionBgColor: value });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayerConfig.prototype, "maxResolutionLevel", {
-        get: function () {
-            return this.player.config.maxResolutionLevel;
-        },
-        set: function (value) {
-            this.player.updateConfig({ maxResolutionLevel: value });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return PlayerConfig;
-}());
-export { PlayerConfig };
-var PlayerController = /** @class */ (function () {
-    function PlayerController(player, anchor) {
-        var _a;
-        this.config = new PlayerConfig(player);
-        this.anchor = anchor;
-        _a = this.createControllerGUI(), this.gui = _a[0], this.controller = _a[1];
-        this.createStats();
-    }
-    PlayerController.prototype.createStats = function () {
-        var _this = this;
-        this.stateId = setInterval(function () {
-            _this.controller.frameRate.updateDisplay();
-            _this.controller.size.updateDisplay();
-            _this.controller.minFPS.updateDisplay();
-            _this.controller.drawFrames.updateDisplay();
-            _this.controller.maxFPS.updateDisplay();
-            _this.controller.resolution.updateDisplay();
-            _this.controller.autoFps.updateDisplay();
-            _this.controller.autoResolution.updateDisplay();
-            _this.controller.drawCall.updateDisplay();
-        }, 16);
-    };
-    PlayerController.prototype.createControllerGUI = function () {
-        var gui = new GUI({
-            autoPlace: true,
-            closed: true,
-        });
-        gui.domElement.style.opacity = ".6";
-        gui.domElement.style.transformOrigin = "100% 0";
-        gui.domElement.style.transform = "scale(1)";
-        this.anchor.appendChild(gui.domElement);
-        gui.domElement.style.position = "absolute";
-        gui.domElement.style.right = "0";
-        gui.domElement.style.top = "0";
-        gui.domElement.style.zIndex = "2";
-        var controller = {
-            frameRate: gui.add(this.config, "frameRate"),
-            drawFrames: gui.add(this.config, "drawFrames"),
-            drawCall: gui.add(this.config, "drawCall"),
-            size: gui.add(this.config, "size"),
-            minFPS: gui.add(this.config, "minFPS", 0, 60),
-            maxFPS: gui.add(this.config, "maxFPS", 0, 60),
-            resolution: gui.add(this.config, "resolution", 0.5, 8, 0.5),
-            autoResolution: gui.add(this.config, "autoResolution"),
-            autoFps: gui.add(this.config, "autoFPS"),
-            maxResolutionLevel: gui.add(this.config, "maxResolutionLevel", 0, 4, 1),
-            transactionBgColor: gui.addColor(this.config, "backgroundColor"),
-        };
-        return [gui, controller];
-    };
-    PlayerController.prototype.destroy = function () {
-        try {
-            window.clearInterval(this.stateId);
-            this.anchor.removeChild(this.gui.domElement);
-            this.gui.destroy();
-        }
-        catch (_a) {
-            //
-        }
-    };
-    return PlayerController;
-}());
-export { PlayerController };

package/lib/RenderSlideVisibility.js

@@ -1,16 +0,0 @@
-/**
- * Reveal a completed live render and remove its fallback image.
- * Frozen and release states own visibility while their player transition is active.
- */
-export function updateRenderSlideVisibility(isReleasing, player, frame, cacheImage) {
-    if (isReleasing || !(player === null || player === void 0 ? void 0 : player.view)) {
-        return;
-    }
-    if (player.view.style.visibility === "hidden") {
-        player.view.style.visibility = "visible";
-    }
-    if (frame.style.visibility === "hidden") {
-        frame.style.visibility = "visible";
-    }
-    cacheImage.style.display = "none";
-}

package/lib/RenderingTaskManager.js

@@ -1,230 +0,0 @@
-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 (_) 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 };
-    }
-};
-import EventEmitter from "eventemitter3";
-var RenderTaskCancelledError = /** @class */ (function (_super) {
-    __extends(RenderTaskCancelledError, _super);
-    function RenderTaskCancelledError(message) {
-        if (message === void 0) { message = "render task cancelled"; }
-        var _this = _super.call(this, message) || this;
-        _this.code = "RENDER_TASK_CANCELLED";
-        _this.name = "AbortError";
-        return _this;
-    }
-    return RenderTaskCancelledError;
-}(Error));
-export { RenderTaskCancelledError };
-var Task = /** @class */ (function () {
-    function Task(index, slideIndex, fn, eventHub, id) {
-        this.state = "idle";
-        this.index = -1;
-        this.slideIndex = -1;
-        this.cancelled = false;
-        this.fn = fn;
-        this.index = index;
-        this.slideIndex = slideIndex;
-        this.eventHub = eventHub;
-        this.id = id;
-    }
-    Task.prototype.apply = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.cancelled) {
-                            return [2 /*return*/];
-                        }
-                        this.eventHub.emit("task-start", this);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        this.state = "start";
-                        return [4 /*yield*/, this.fn()];
-                    case 2:
-                        _a.sent();
-                        if (this.cancelled) {
-                            return [2 /*return*/];
-                        }
-                        this.state = "end";
-                        this.eventHub.emit("task-end", this);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_1 = _a.sent();
-                        if (this.cancelled) {
-                            return [2 /*return*/];
-                        }
-                        if (e_1 instanceof RenderTaskCancelledError) {
-                            this.cancel();
-                            this.eventHub.emit("task-cancel", {
-                                task: this,
-                                error: e_1,
-                            });
-                            return [2 /*return*/];
-                        }
-                        this.eventHub.emit("task-error", {
-                            task: this,
-                            error: e_1,
-                        });
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Task.prototype.cancel = function () {
-        this.cancelled = true;
-    };
-    return Task;
-}());
-export { Task };
-var RenderingTaskManager = /** @class */ (function () {
-    function RenderingTaskManager() {
-        var _this = this;
-        this.eventHub = new EventEmitter();
-        this.tasks = [];
-        this.index = 0;
-        this.destroyed = false;
-        this.eventHub.on("task-end", function (task) {
-            var _a;
-            var selfIndex = _this.tasks.findIndex(function (t) { return t.index === task.index; });
-            var nextIndex = selfIndex + 1;
-            if (nextIndex >= 0) {
-                (_a = _this.tasks[nextIndex]) === null || _a === void 0 ? void 0 : _a.apply();
-            }
-            if (selfIndex >= 0) {
-                _this.tasks.splice(selfIndex, 1);
-                _this.replaceIdleTask();
-            }
-            _this.eventHub.emit("task-end-" + task.id);
-        });
-        this.eventHub.on("task-error", function (_a) {
-            var _b;
-            var task = _a.task, error = _a.error;
-            var selfIndex = _this.tasks.findIndex(function (t) { return t.index === task.index; });
-            var wasRunning = task.state === "start";
-            if (selfIndex >= 0) {
-                _this.tasks.splice(selfIndex, 1);
-                _this.replaceIdleTask();
-                if (wasRunning && !_this.destroyed) {
-                    (_b = _this.tasks[selfIndex]) === null || _b === void 0 ? void 0 : _b.apply();
-                }
-            }
-            _this.eventHub.emit("task-error-" + task.id, error);
-        });
-        this.eventHub.on("task-cancel", function (_a) {
-            var _b;
-            var task = _a.task, error = _a.error;
-            var selfIndex = _this.tasks.findIndex(function (t) { return t.index === task.index; });
-            var wasRunning = task.state === "start";
-            if (selfIndex >= 0) {
-                _this.tasks.splice(selfIndex, 1);
-                if (wasRunning && !_this.destroyed) {
-                    (_b = _this.tasks[selfIndex]) === null || _b === void 0 ? void 0 : _b.apply();
-                }
-            }
-            _this.eventHub.emit("task-cancel-" + task.id, error);
-        });
-    }
-    RenderingTaskManager.prototype.cancelTask = function (task) {
-        var error = new RenderTaskCancelledError();
-        task.cancel();
-        this.eventHub.emit("task-cancel", { task: task, error: error });
-    };
-    RenderingTaskManager.prototype.replaceIdleTask = function () {
-        var _this = this;
-        var _a;
-        var ids = new Set();
-        for (var i = 0, len = this.tasks.length; i < len; i++) {
-            if (this.tasks[i].state === "idle" && ((_a = this.tasks[i + 1]) === null || _a === void 0 ? void 0 : _a.state) === "idle") {
-                ids.add(i);
-            }
-        }
-        // Remove from the end so deleting one idle task does not shift the
-        // indexes selected for the remaining cancellations.
-        Array.from(ids).sort(function (a, b) { return b - a; }).forEach(function (id) {
-            var task = _this.tasks.splice(id, 1)[0];
-            if (task) {
-                _this.cancelTask(task);
-            }
-        });
-    };
-    RenderingTaskManager.prototype.addTask = function (fn, slideIndex, id) {
-        if (this.destroyed) {
-            return undefined;
-        }
-        var task = new Task(this.index++, slideIndex, fn, this.eventHub, id);
-        this.tasks.push(task);
-        this.tasks.sort(function (a, b) { return a.index - b.index; });
-        this.replaceIdleTask();
-        if (this.tasks.length === 1) {
-            task.apply();
-        }
-        return task;
-    };
-    RenderingTaskManager.prototype.hasStartTask = function () {
-        return this.tasks.some(function (t) { return t.state === "start"; });
-    };
-    RenderingTaskManager.prototype.destroy = function () {
-        var _this = this;
-        if (this.destroyed) {
-            return;
-        }
-        this.destroyed = true;
-        var tasks = this.tasks.splice(0);
-        tasks.forEach(function (task) {
-            _this.cancelTask(task);
-        });
-        this.eventHub.removeAllListeners();
-    };
-    return RenderingTaskManager;
-}());
-export { RenderingTaskManager };

package/lib/SyncTaskManager.js

@@ -1,206 +0,0 @@
-function assertSyncEventQueuePolicy(policy) {
-    if (policy !== "fifo" && policy !== "latest-pending-render") {
-        throw new Error("Invalid sync event queue policy: " + policy);
-    }
-}
-export function resolveSyncEventQueuePolicy(mode, policy) {
-    if (policy === void 0) { policy = "fifo"; }
-    assertSyncEventQueuePolicy(policy);
-    return mode === "interactive" ? policy : "fifo";
-}
-function isPageScopedEvent(event) {
-    switch (event.type) {
-        case "renderSlide":
-        case "nextStep":
-        case "prevStep":
-        case "interactiveAnim":
-        case "mediaPlay":
-        case "mediaPause":
-        case "mediaSeek":
-        case "mediaFullscreen":
-            return true;
-        default:
-            return false;
-    }
-}
-var SyncTaskManager = /** @class */ (function () {
-    function SyncTaskManager(fn, options) {
-        var _this = this;
-        if (options === void 0) { options = {}; }
-        this.tasks = [];
-        this.isDestroy = false;
-        this.isScheduling = false;
-        this.isTaskRunning = false;
-        this.isCatchingUp = false;
-        this.compactedTasks = new WeakMap();
-        this.finishTask = function () {
-            _this.isTaskRunning = false;
-            _this.runningTask = undefined;
-            if (_this.isDestroy) {
-                _this.tasks.length = 0;
-                _this.isScheduling = false;
-            }
-            else if (_this.tasks.length > 0) {
-                window.requestAnimationFrame(_this.schedule);
-            }
-            else {
-                _this.isScheduling = false;
-                _this.setCatchUpState(false);
-            }
-        };
-        this.schedule = function () {
-            if (_this.isDestroy) {
-                _this.tasks.length = 0;
-                _this.isScheduling = false;
-                return;
-            }
-            _this.isScheduling = true;
-            var task = _this.tasks.shift();
-            if (!task) {
-                _this.isScheduling = false;
-                return;
-            }
-            _this.isTaskRunning = true;
-            _this.runningTask = task;
-            var compactInfo = _this.compactedTasks.get(task);
-            try {
-                _this.fn(task).then(function () {
-                    var _a;
-                    _this.compactedTasks.delete(task);
-                    if (compactInfo && !_this.isDestroy) {
-                        try {
-                            (_a = _this.onCompactedRenderComplete) === null || _a === void 0 ? void 0 : _a.call(_this, compactInfo, Date.now());
-                        }
-                        catch ( /* Observability must not interrupt synchronization. */_b) { /* Observability must not interrupt synchronization. */ }
-                    }
-                    _this.finishTask();
-                }, function () {
-                    _this.compactedTasks.delete(task);
-                    _this.finishTask();
-                });
-            }
-            catch (_a) {
-                _this.compactedTasks.delete(task);
-                _this.finishTask();
-            }
-        };
-        this.fn = fn;
-        this.policy = options.policy || "fifo";
-        this.onCompact = options.onCompact;
-        this.onCompactedRenderComplete = options.onCompactedRenderComplete;
-        this.onCatchUpStateChange = options.onCatchUpStateChange;
-        this.shouldTrackCatchUpEvent = options.shouldTrackCatchUpEvent;
-        assertSyncEventQueuePolicy(this.policy);
-    }
-    SyncTaskManager.prototype.destroy = function () {
-        this.isDestroy = true;
-        this.isCatchingUp = false;
-        this.runningTask = undefined;
-        this.tasks.length = 0;
-    };
-    SyncTaskManager.prototype.setPolicy = function (policy) {
-        assertSyncEventQueuePolicy(policy);
-        this.policy = policy;
-    };
-    SyncTaskManager.prototype.setCatchUpState = function (isCatchingUp) {
-        var _a;
-        if (this.isCatchingUp === isCatchingUp) {
-            return;
-        }
-        this.isCatchingUp = isCatchingUp;
-        try {
-            (_a = this.onCatchUpStateChange) === null || _a === void 0 ? void 0 : _a.call(this, isCatchingUp);
-        }
-        catch ( /* Observability must not interrupt synchronization. */_b) { /* Observability must not interrupt synchronization. */ }
-    };
-    SyncTaskManager.prototype.isCatchUpEvent = function (event) {
-        var _a, _b;
-        try {
-            return (_b = (_a = this.shouldTrackCatchUpEvent) === null || _a === void 0 ? void 0 : _a.call(this, event)) !== null && _b !== void 0 ? _b : true;
-        }
-        catch (_c) {
-            return true;
-        }
-    };
-    SyncTaskManager.prototype.compactForRender = function (event) {
-        var droppedEventTypes = {};
-        var droppedEventCount = 0;
-        var droppedRenderCount = 0;
-        var droppedStepCount = 0;
-        var droppedAnimationCount = 0;
-        var droppedMediaCount = 0;
-        while (this.tasks.length > 0) {
-            var pendingEvent = this.tasks[this.tasks.length - 1];
-            if (!isPageScopedEvent(pendingEvent)) {
-                break;
-            }
-            this.tasks.pop();
-            this.compactedTasks.delete(pendingEvent);
-            droppedEventCount += 1;
-            droppedEventTypes[pendingEvent.type] = (droppedEventTypes[pendingEvent.type] || 0) + 1;
-            if (pendingEvent.type === "renderSlide") {
-                droppedRenderCount += 1;
-            }
-            else if (pendingEvent.type === "nextStep" || pendingEvent.type === "prevStep") {
-                droppedStepCount += 1;
-            }
-            else if (pendingEvent.type === "interactiveAnim") {
-                droppedAnimationCount += 1;
-            }
-            else {
-                droppedMediaCount += 1;
-            }
-        }
-        if (droppedEventCount === 0) {
-            return undefined;
-        }
-        var boundaryEvent = this.tasks[this.tasks.length - 1];
-        return {
-            policy: "latest-pending-render",
-            droppedEventCount: droppedEventCount,
-            droppedRenderCount: droppedRenderCount,
-            droppedStepCount: droppedStepCount,
-            droppedAnimationCount: droppedAnimationCount,
-            droppedMediaCount: droppedMediaCount,
-            droppedOperationCount: droppedEventCount - droppedRenderCount,
-            droppedEventTypes: droppedEventTypes,
-            retainedSlideIndex: event.index,
-            retainedRenderReceivedAt: Date.now(),
-            hasRunningTask: this.isTaskRunning,
-            hardBoundaryType: boundaryEvent === null || boundaryEvent === void 0 ? void 0 : boundaryEvent.type,
-        };
-    };
-    SyncTaskManager.prototype.addTask = function (event) {
-        var _this = this;
-        var _a;
-        if (this.isDestroy) {
-            return undefined;
-        }
-        var hasPendingWork = this.isTaskRunning || this.tasks.length > 0;
-        var isIncomingCatchUpEvent = this.policy === "latest-pending-render" && this.isCatchUpEvent(event);
-        var hasCatchUpEvent = this.policy === "latest-pending-render" && (isIncomingCatchUpEvent ||
-            (!!this.runningTask && this.isCatchUpEvent(this.runningTask)) ||
-            this.tasks.some(function (pendingEvent) { return _this.isCatchUpEvent(pendingEvent); }));
-        var compactInfo = this.policy === "latest-pending-render" && event.type === "renderSlide" ?
-            this.compactForRender(event) :
-            undefined;
-        this.tasks.push(event);
-        var shouldStartCatchUp = hasCatchUpEvent && (hasPendingWork || (isIncomingCatchUpEvent && event.type === "renderSlide"));
-        if (shouldStartCatchUp) {
-            this.setCatchUpState(true);
-        }
-        if (compactInfo) {
-            this.compactedTasks.set(event, compactInfo);
-            try {
-                (_a = this.onCompact) === null || _a === void 0 ? void 0 : _a.call(this, compactInfo);
-            }
-            catch ( /* Observability must not interrupt synchronization. */_b) { /* Observability must not interrupt synchronization. */ }
-        }
-        if (!this.isScheduling) {
-            this.schedule();
-        }
-        return compactInfo;
-    };
-    return SyncTaskManager;
-}());
-export { SyncTaskManager };