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

package/README.md

@@ -4,6 +4,12 @@
 
 ## changelog
 
+### 1.4.61 (2026-09-23)
+* 修复部分 PPT 中点击元素无法触发动画的问题
+* 修复重复触发条件导致动画重复推进的问题
+* 修复 PPT 冻结、恢复和销毁并发执行时的时序问题
+* `frozen()`、`release()`、`destroy()` 支持返回 Promise，便于等待操作完成
+
 ### 1.4.60 (2026-09-21)
 * 新增 PPT 媒体权限回调和点击恢复接口：`onPptMediaPermissionRequest(callback)`、`playPptMedia()`
 * 修复部分移动浏览器中 PPT 音视频无法自动播放或恢复的问题

package/lib/FrozenTaskManager.d.ts

@@ -11,7 +11,6 @@ export declare class FrozenTaskManager {
     private isDestroy;
     private runningTask?;
     private schedule;
-    private getRunningTask;
     addTask(type: "frozen" | "release", fn: () => Promise<void>): Promise<void>;
     destroy(): Promise<void>;
 }

package/lib/FrozenTaskManager.js

@@ -3,70 +3,56 @@ var FrozenTaskManager = /** @class */ (function () {
         var _this = this;
         this.tasks = [];
         this.isDestroy = false;
+        this.isScheduling = false;
         this.schedule = function () {
-            if (_this.runningTask || _this.isDestroy) {
-                return;
-            }
+            _this.isScheduling = true;
             var task = _this.tasks.shift();
-            if (!task) {
-                return;
+            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;
+                    }
+                });
             }
-            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 () {
-        var _a;
-        return (_a = this.runningTask) !== null && _a !== void 0 ? _a : null;
+        if (this.tasks[0] && this.tasks[0].status === "running") {
+            return this.tasks[0];
+        }
+        return null;
     };
     FrozenTaskManager.prototype.addTask = function (type, fn) {
-        if (this.isDestroy) {
-            return Promise.resolve();
-        }
-        var runningTask = this.getRunningTask();
-        if (runningTask && type === runningTask.type) {
-            return runningTask.promise;
-        }
-        var queuedTask = this.tasks.find(function (task) { return task.type === type; });
-        if (queuedTask) {
-            return queuedTask.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,
         };
-        this.tasks.push(task);
-        this.schedule();
-        return promise;
+        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();
+            }
+        }
     };
     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

@@ -327,6 +327,12 @@ export interface BasicSyncEvent {
     uuid?: string;
     incrId?: number;
     clientId?: string;
+    /** Transport author ID attached when the dispatched event is received. */
+    authorId?: number;
+}
+export interface SyncEventOrigin {
+    clientId?: string;
+    authorId?: number;
 }
 export interface SyncMediaPlayEvent extends BasicSyncEvent {
     type: "mediaPlay";
@@ -377,8 +383,8 @@ export interface SlideEventEmitter {
     removeListener(event: keyof typeof SLIDE_EVENTS, fn?: any): this;
     emit(event: typeof SLIDE_EVENTS.renderStart, index: number): boolean;
     on(event: typeof SLIDE_EVENTS.renderStart, listener: (index: number) => void): this;
-    emit(event: typeof SLIDE_EVENTS.renderEnd, index: number): boolean;
-    on(event: typeof SLIDE_EVENTS.renderEnd, listener: (index: number) => void): this;
+    emit(event: typeof SLIDE_EVENTS.renderEnd, index: number, origin?: SyncEventOrigin): boolean;
+    on(event: typeof SLIDE_EVENTS.renderEnd, listener: (index: number, origin?: SyncEventOrigin) => void): this;
     emit(event: typeof SLIDE_EVENTS.slideChange, nextSlideIndex: number): boolean;
     on(event: typeof SLIDE_EVENTS.slideChange, listener: (nextSlideIndex: number) => void): this;
     emit(event: typeof SLIDE_EVENTS.syncDispatch, args: SyncEvent): boolean;
@@ -401,8 +407,8 @@ export interface SlideEventEmitter {
     on(event: typeof SLIDE_EVENTS.mainSeqStepStart, listener: (index: number) => void): this;
     emit(event: typeof SLIDE_EVENTS.mainSeqStepEnd, index: number): boolean;
     on(event: typeof SLIDE_EVENTS.mainSeqStepEnd, listener: (index: number) => void): this;
-    emit(event: typeof SLIDE_EVENTS.stateChange, state: ISlideState): boolean;
-    on(event: typeof SLIDE_EVENTS.stateChange, listener: (state: ISlideState) => void): this;
+    emit(event: typeof SLIDE_EVENTS.stateChange, state: ISlideState, origin?: SyncEventOrigin): boolean;
+    on(event: typeof SLIDE_EVENTS.stateChange, listener: (state: ISlideState, origin?: SyncEventOrigin) => void): this;
     emit(event: typeof SLIDE_EVENTS.syncEventLag): boolean;
     on(event: typeof SLIDE_EVENTS.syncEventLag, listener: () => void): this;
     emit(event: typeof SLIDE_EVENTS.slideStepEnd): boolean;
@@ -476,6 +482,15 @@ export declare class Slide extends Slide_base {
     private pptMediaPermissionNotified;
     private pptMediaPermissionRenotifyPending;
     private pendingPptMediaState?;
+    private currentRenderEventOrigin?;
+    private currentRenderSlideIndex?;
+    private currentRenderEventSource?;
+    private isRenderEventOriginActive;
+    private mainSeqEventOwner?;
+    private interactiveSeqEventOwners;
+    private mediaEventOwners;
+    private applyingMediaEvents;
+    private applyingMediaEventNonce;
     private renderingIndex;
     private frameWidth;
     private frameHeight;
@@ -487,6 +502,7 @@ export declare class Slide extends Slide_base {
     private mode;
     private enableGlobalClick;
     private lastEmitedState;
+    private lastEmitedStateOrigin?;
     private syncQueue;
     private selfSyncEvents;
     private playerController;
@@ -558,6 +574,20 @@ export declare class Slide extends Slide_base {
     updateFixedFrameSize(width: number, height: number, callback?: () => void): void;
     private _resizeView;
     private receiveSyncHandler;
+    private applySyncEvent;
+    private handleSyncEvent;
+    private getSyncEventOrigin;
+    private getStateEventOrigin;
+    private isSamePlayerEventSource;
+    private createStateEventOwner;
+    private findSequenceEventOwner;
+    private getMediaEventOrigin;
+    private setInteractiveSeqEventOwner;
+    private setMediaEventOwner;
+    private beginApplyingMediaEvent;
+    private finishApplyingMediaEvent;
+    private invalidateApplyingMediaEvent;
+    private emitRenderEnd;
     /**
      * Set the state of the entire slide, the slide will update the screen with the incoming state.
      * It is called when synchronizing the whole.
@@ -677,6 +707,7 @@ export declare class Slide extends Slide_base {
      */
     doRenderSlide(index: number, isForward?: boolean): Promise<void>;
     private enqueueRenderSlide;
+    private withRenderEventOrigin;
     getSnapshot(): string | null;
     /**
      * 执行下一个主序列动画