@netless/slide 1.4.60-alpha.0 → 1.4.61-beta.0

package/lib/Lock.js

@@ -0,0 +1,54 @@
+/*
+    防止信令收发延迟高的时候, 用户狂点, 导致短时间触发多次信令的修改, 按照事件类型加同步锁, 即同一个事件类型仅有第一个事件生效, 多点不生效
+ */
+var Lock = /** @class */ (function () {
+    function Lock(available) {
+        this.autoUnlock = Object.create(null);
+        this.localKeyAutoRemove = Object.create(null);
+        this.localKeys = Object.create(null);
+        this.locks = Object.create(null);
+        this.available = false;
+        this.available = available;
+    }
+    Lock.prototype.addLock = function (type, key) {
+        var _this = this;
+        if (!this.available) {
+            return;
+        }
+        this.locks[type] = key;
+        this.localKeys[key] = true;
+        this.localKeyAutoRemove[key] = window.setTimeout(function () {
+            delete _this.localKeys[key];
+            delete _this.localKeyAutoRemove[key];
+        }, 60 * 1000);
+        this.autoUnlock[type] = window.setTimeout(function () {
+            delete _this.locks[type];
+            delete _this.autoUnlock[type];
+        }, 3000);
+    };
+    Lock.prototype.unlock = function (type, key) {
+        if (!this.available) {
+            return false;
+        }
+        var isLocalEvent = !!key && !!this.localKeys[key];
+        if (key && isLocalEvent) {
+            window.clearTimeout(this.localKeyAutoRemove[key]);
+            delete this.localKeys[key];
+            delete this.localKeyAutoRemove[key];
+        }
+        if (key && this.locks[type] && this.locks[type] === key) {
+            window.clearTimeout(this.autoUnlock[type]);
+            delete this.locks[type];
+            delete this.autoUnlock[type];
+        }
+        return isLocalEvent;
+    };
+    Lock.prototype.isLocked = function (type) {
+        if (!this.available) {
+            return false;
+        }
+        return !!this.locks[type];
+    };
+    return Lock;
+}());
+export { Lock };

package/lib/PlayerContextReleaseWait.js

@@ -0,0 +1,41 @@
+/**
+ * Wait for the browser to finish releasing a destroyed WebGL context before
+ * creating a replacement player. Uses rAF when available, but always settles
+ * within a bounded timeout so hidden/background WebViews cannot hang release.
+ */
+export function waitForPlayerContextRelease(platform) {
+    var isMobile = platform.isIOS() || platform.isAndroid();
+    var minFrames = isMobile ? 4 : 2;
+    var settleMs = isMobile ? 100 : 16;
+    var maxWaitMs = isMobile ? 500 : 200;
+    return new Promise(function (resolve) {
+        var settled = false;
+        var complete = function () {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            setTimeout(resolve, settleMs);
+        };
+        var timeoutId = setTimeout(complete, maxWaitMs);
+        var frameCount = 0;
+        var nextFrame = function () {
+            if (settled) {
+                return;
+            }
+            frameCount += 1;
+            if (frameCount >= minFrames) {
+                clearTimeout(timeoutId);
+                complete();
+                return;
+            }
+            if (typeof window.requestAnimationFrame === "function") {
+                window.requestAnimationFrame(nextFrame);
+            }
+            else {
+                setTimeout(nextFrame, 0);
+            }
+        };
+        nextFrame();
+    });
+}

package/lib/PlayerController.js

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,230 @@
+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/Slide.d.ts

@@ -460,6 +460,7 @@ export declare class Slide extends Slide_base {
     private lifecycle;
     private lifecycleGeneration;
     private renderVisibilityTimers;
+    private destroyPromise?;
     private isLoading;
     private isReleasing;
     private interactive;
@@ -718,12 +719,12 @@ export declare class Slide extends Slide_base {
     /**
      * Enter freeze state, cache the ppt screen as an image, and release the WebGL context.
      */
-    frozen(callback?: () => void): void;
+    frozen(callback?: () => void): Promise<void>;
     private _doRelease;
     /**
      * Recover from frozen state.
      */
-    release(callback?: () => void): void;
+    release(callback?: () => void): Promise<void>;
     private _doDestroy;
     private waitLoadEnd;
     /**
@@ -735,7 +736,7 @@ export declare class Slide extends Slide_base {
     /**
      * Destruction method.
      */
-    destroy(): void;
+    destroy(): Promise<void>;
     /**
      * Destroy the local cache of the current Slide instance, need to be called before destroy.
      */