@netless/slide 1.4.60 → 1.4.61

package/README.md

@@ -4,28 +4,18 @@
 
 ## changelog
 
-### 1.4.60 (2026-09-21)
-* 新增 `onPptMediaPermissionRequest(callback)` 与 `playPptMedia()`，支持在浏览器阻止自动播放时通知业务方并由真实用户点击恢复当前媒体
-* 增加 HTML5 音频和视频播放确认，覆盖浏览器静默暂停或未触发 `playerror` 的情况
-* 修复部分移动浏览器播放前 `duration`、`seekable` 为 0 导致 Howler 提前结束且不触发权限回调的问题
-* 修复视频启动时浏览器底层暂停独立音轨，以及用户点击恢复遇到 Howler pending play 无法重新播放的问题
+### 1.4.61 (2026-09-23)
+* 修复部分 PPT 中点击元素无法触发动画的问题
+* 修复重复触发条件导致动画重复推进的问题
+* 修复 PPT 冻结、恢复和销毁并发执行时的时序问题
+* `frozen()`、`release()`、`destroy()` 支持返回 Promise，便于等待操作完成
 
-### 1.4.60-alpha.0 (2026-09-20)
-* 修复部分移动浏览器中 HTML5 音频播放请求卡住后，用户点击恢复仍无法重新发起播放的问题
-* 避免将媒体加载或缓冲过程误判为自动播放权限错误，并忽略旧播放请求的迟到事件
+### 1.4.60 (2026-09-21)
+* 新增 PPT 媒体权限回调和点击恢复接口：`onPptMediaPermissionRequest(callback)`、`playPptMedia()`
+* 修复部分移动浏览器中 PPT 音视频无法自动播放或恢复的问题
 
 ### 1.4.59 (2026-09-18)
-* 优化移动端切页时的 Player 与 WebGL context 生命周期，减少重复创建和资源残留
-* 完善 Player 原地重置、候选 Player 交换和失败回退，避免快速切页后出现白屏或旧画面
-* 加强纹理缓存隔离、取消任务清理和 context 释放超时保护，降低页面切换对 RTC 与其他 WebGL 内容的影响
-
-### 1.4.59-alpha.4 (2026-09-17)
-* 增强 PPT 媒体自动播放恢复：为 Howler/HTML5 音频与视频增加播放确认 watchdog，覆盖浏览器静默失败未触发 `playerror` 的场景
-* 修正 Howler `playerror` 在内部状态已变为 playing 但 DOM 仍 paused 时被误过滤的问题
-
-### 1.4.59-alpha.0 (2026-09-11)
-* 新增 `onPptMediaPermissionRequest(callback)` 接口，用于通知当前 PPT 音视频需要用户交互后才能播放
-* 新增 `playPptMedia()` 接口，用于在用户点击事件中恢复当前仍处于播放状态、且本地被浏览器拦截的 PPT 音视频
+* 优化移动端切页时的播放器和 WebGL 资源管理，减少白屏和资源残留
 
 ### 1.4.58 (2026-09-07)
 * 修复低版本 WebView 中纯色图形显示为黑块的问题

package/lib/FrozenTaskManager.d.ts

@@ -2,13 +2,15 @@ export interface FrozenTask {
     type: "frozen" | "release";
     status: "running" | "wait";
     fn: () => Promise<void>;
+    promise: Promise<void>;
+    resolve: () => void;
+    reject: (error: unknown) => void;
 }
 export declare class FrozenTaskManager {
     private tasks;
     private isDestroy;
-    private isScheduling;
+    private runningTask?;
     private schedule;
-    private getRunningTask;
-    addTask(type: "frozen" | "release", fn: () => Promise<void>): void;
-    destroy(): void;
+    addTask(type: "frozen" | "release", fn: () => Promise<void>): Promise<void>;
+    destroy(): Promise<void>;
 }

package/lib/FrozenTaskManager.js

@@ -3,56 +3,65 @@ var FrozenTaskManager = /** @class */ (function () {
         var _this = this;
         this.tasks = [];
         this.isDestroy = false;
-        this.isScheduling = false;
         this.schedule = function () {
-            _this.isScheduling = true;
+            if (_this.runningTask || _this.isDestroy) {
+                return;
+            }
             var task = _this.tasks.shift();
-            if (task && !_this.isDestroy) {
-                task.status = "running";
-                task.fn.apply(null).then(function () {
-                    if (_this.tasks.length > 0) {
-                        setTimeout(_this.schedule);
-                    }
-                    else {
-                        _this.isScheduling = false;
-                    }
-                }).catch(function () {
-                    if (_this.tasks.length > 0) {
-                        setTimeout(_this.schedule);
-                    }
-                    else {
-                        _this.isScheduling = false;
-                    }
-                });
+            if (!task) {
+                return;
             }
+            task.status = "running";
+            _this.runningTask = task;
+            void task.fn.apply(null).then(task.resolve, task.reject).finally(function () {
+                if (_this.runningTask === task) {
+                    _this.runningTask = undefined;
+                }
+                if (!_this.isDestroy && _this.tasks.length > 0) {
+                    setTimeout(_this.schedule);
+                }
+            });
         };
     }
-    FrozenTaskManager.prototype.getRunningTask = function () {
-        if (this.tasks[0] && this.tasks[0].status === "running") {
-            return this.tasks[0];
-        }
-        return null;
-    };
     FrozenTaskManager.prototype.addTask = function (type, fn) {
+        var _a;
+        if (this.isDestroy) {
+            return Promise.resolve();
+        }
+        // Only consecutive requests may share a task. An opposite queued
+        // request separates a new intent from the running task of the same type.
+        var lastTask = (_a = this.tasks[this.tasks.length - 1]) !== null && _a !== void 0 ? _a : this.runningTask;
+        if ((lastTask === null || lastTask === void 0 ? void 0 : lastTask.type) === type) {
+            return lastTask.promise;
+        }
+        var resolveTask;
+        var rejectTask;
+        var promise = new Promise(function (resolve, reject) {
+            resolveTask = resolve;
+            rejectTask = reject;
+        });
+        // Existing callers are allowed to ignore frozen()/release(). Keep the
+        // original promise observable to awaiters without creating an
+        // unhandled rejection for legacy fire-and-forget calls.
+        promise.catch(function () { return undefined; });
         var task = {
             type: type,
             status: "wait",
             fn: fn,
+            promise: promise,
+            resolve: resolveTask,
+            reject: rejectTask,
         };
-        var runningTask = this.getRunningTask();
-        if (runningTask && type === runningTask.type) {
-            return;
-        }
-        else {
-            this.tasks = this.tasks.filter(function (v) { return v.type !== type; });
-            this.tasks.push(task);
-            if (!this.isScheduling) {
-                this.schedule();
-            }
-        }
+        this.tasks.push(task);
+        this.schedule();
+        return promise;
     };
     FrozenTaskManager.prototype.destroy = function () {
+        var _a, _b;
         this.isDestroy = true;
+        var pending = this.tasks.splice(0, this.tasks.length);
+        pending.forEach(function (task) { return task.resolve(); });
+        return (_b = (_a = this.runningTask) === null || _a === void 0 ? void 0 : _a.promise.catch(function () { return undefined; })) !== null && _b !== void 0 ? _b : Promise.resolve();
     };
     return FrozenTaskManager;
 }());

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.
      */