@xhub-short/core 0.1.0-beta.13 → 0.1.0-beta.14

package/dist/index.d.ts

@@ -1632,6 +1632,10 @@ declare class OptimisticManager {
      * Execute API call after debounce delay
      */
     private executeDebouncedLikeApi;
+    /**
+     * Handle errors from debounced API calls
+     */
+    private handleDebouncedApiError;
     /**
      * Remove a pending action by ID
      */
@@ -1642,12 +1646,19 @@ declare class OptimisticManager {
     toggleFollow(videoId: string): Promise<boolean>;
     follow(videoId: string): Promise<boolean>;
     unfollow(videoId: string): Promise<boolean>;
+    addEventListener(listener: OptimisticEventListener): () => void;
+    removeEventListener(listener: OptimisticEventListener): void;
+    /**
+     * Reset all optimistic state
+     */
+    reset(): void;
     getPendingActions(): PendingAction[];
     hasPendingAction(videoId: string, type?: ActionType): boolean;
     getFailedQueue(): PendingAction[];
     retryFailed(): Promise<void>;
     clearFailed(): void;
     destroy(): void;
+    private emit;
     private performAction;
     private createRollbackData;
     private applyOptimisticUpdate;

package/dist/index.js

@@ -2675,27 +2675,33 @@ var OptimisticManager = class {
       if (this.intendedLikeState.get(videoId) === finalIntended) {
         this.intendedLikeState.delete(videoId);
       }
-      this.removePendingAction(actionId);
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger?.error(`[OptimisticManager] API failed for ${videoId}`, err);
-      if (!this.intendedLikeState.has(videoId)) {
-        const currentVideo = this.feedManager?.getVideo(videoId);
-        if (currentVideo) {
-          const rollbackIsLiked = !finalIntended;
-          const rollbackDelta = rollbackIsLiked ? 1 : -1;
-          this.feedManager?.updateVideo(videoId, {
-            isLiked: rollbackIsLiked,
-            stats: {
-              ...currentVideo.stats,
-              likes: Math.max(0, currentVideo.stats.likes + rollbackDelta)
-            }
-          });
-        }
-      }
+      this.handleDebouncedApiError(videoId, finalIntended, error);
+    } finally {
       this.removePendingAction(actionId);
     }
   }
+  /**
+   * Handle errors from debounced API calls
+   */
+  handleDebouncedApiError(videoId, finalIntended, error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    this.logger?.error(`[OptimisticManager] API failed for ${videoId}`, err);
+    if (!this.intendedLikeState.has(videoId)) {
+      const currentVideo = this.feedManager?.getVideo(videoId);
+      if (currentVideo) {
+        const rollbackIsLiked = !finalIntended;
+        const rollbackDelta = rollbackIsLiked ? 1 : -1;
+        this.feedManager?.updateVideo(videoId, {
+          isLiked: rollbackIsLiked,
+          stats: {
+            ...currentVideo.stats,
+            likes: Math.max(0, currentVideo.stats.likes + rollbackDelta)
+          }
+        });
+      }
+    }
+  }
   /**
    * Remove a pending action by ID
    */
@@ -2729,6 +2735,19 @@ var OptimisticManager = class {
       await this.interaction.unfollow(videoId);
     });
   }
+  addEventListener(listener) {
+    this.eventListeners.add(listener);
+    return () => this.removeEventListener(listener);
+  }
+  removeEventListener(listener) {
+    this.eventListeners.delete(listener);
+  }
+  /**
+   * Reset all optimistic state
+   */
+  reset() {
+    this.store.setState(createInitialState5());
+  }
   // ═══════════════════════════════════════════════════════════════
   // STATE MANAGEMENT
   // ═══════════════════════════════════════════════════════════════
@@ -2754,9 +2773,12 @@ var OptimisticManager = class {
     this.store.setState({ isRetrying: true });
     const queue = [...state.failedQueue];
     for (const id of queue) {
-      const action = state.pendingActions.get(id);
-      if (action && action.retryCount < this.config.maxRetries) {
+      const action = this.store.getState().pendingActions.get(id);
+      if (!action) continue;
+      if (action.retryCount < this.config.maxRetries) {
         await this.retryAction(action);
+      } else {
+        this.emit({ type: "retryExhausted", action });
       }
     }
     this.store.setState({ isRetrying: false });
@@ -2784,9 +2806,22 @@ var OptimisticManager = class {
   // ═══════════════════════════════════════════════════════════════
   // PRIVATE UTILS
   // ═══════════════════════════════════════════════════════════════
+  emit(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.logger?.error("[OptimisticManager] Listener failed", error);
+      }
+    }
+  }
   async performAction(type, videoId, apiCall) {
     const video = this.feedManager?.getVideo(videoId);
     if (!video) return false;
+    if (this.hasPendingAction(videoId, type)) {
+      return false;
+    }
     const action = {
       id: generateActionId(),
       type,
@@ -2798,6 +2833,7 @@ var OptimisticManager = class {
     };
     this.addPendingAction(action);
     this.applyOptimisticUpdate(type, video);
+    this.emit({ type: "actionStart", action });
     try {
       await apiCall();
       this.markActionSuccess(action.id);
@@ -2836,6 +2872,7 @@ var OptimisticManager = class {
   }
   applyRollback(action) {
     this.feedManager?.updateVideo(action.videoId, action.rollbackData);
+    this.emit({ type: "actionRollback", action });
   }
   addPendingAction(action) {
     this.store.setState((state) => {
@@ -2847,6 +2884,10 @@ var OptimisticManager = class {
   markActionSuccess(id) {
     this.store.setState((state) => {
       const m = new Map(state.pendingActions);
+      const action = m.get(id);
+      if (action) {
+        this.emit({ type: "actionSuccess", action: { ...action, status: "success" } });
+      }
       m.delete(id);
       const q = state.failedQueue.filter((x) => x !== id);
       return { pendingActions: m, failedQueue: q, hasPending: m.size > 0 };
@@ -2857,21 +2898,45 @@ var OptimisticManager = class {
       const m = new Map(state.pendingActions);
       const a = m.get(id);
       if (!a) return state;
-      m.set(id, { ...a, status: "failed", error });
+      const failedAction = { ...a, status: "failed", error };
+      m.set(id, failedAction);
       const q = state.failedQueue.includes(id) ? state.failedQueue : [...state.failedQueue, id];
+      this.emit({
+        type: "actionFailed",
+        action: failedAction,
+        error: new Error(error)
+      });
       return { pendingActions: m, failedQueue: q };
     });
   }
   async retryAction(action) {
+    this.store.setState((state) => {
+      const m = new Map(state.pendingActions);
+      const a = m.get(action.id);
+      if (a) {
+        m.set(action.id, { ...a, retryCount: a.retryCount + 1 });
+      }
+      return { pendingActions: m };
+    });
+    const updatedAction = this.store.getState().pendingActions.get(action.id);
+    if (!updatedAction) return;
+    this.emit({ type: "retryStart", actionId: updatedAction.id });
     try {
-      if (action.type === "like") await this.interaction?.like(action.videoId);
-      else if (action.type === "unlike") await this.interaction?.unlike(action.videoId);
-      else if (action.type === "follow") await this.interaction?.follow(action.videoId);
-      else if (action.type === "unfollow") await this.interaction?.unfollow(action.videoId);
-      this.markActionSuccess(action.id);
+      if (updatedAction.type === "like") await this.interaction?.like(updatedAction.videoId);
+      else if (updatedAction.type === "unlike")
+        await this.interaction?.unlike(updatedAction.videoId);
+      else if (updatedAction.type === "follow")
+        await this.interaction?.follow(updatedAction.videoId);
+      else if (updatedAction.type === "unfollow")
+        await this.interaction?.unfollow(updatedAction.videoId);
+      const currentVideo = this.feedManager?.getVideo(updatedAction.videoId);
+      if (currentVideo) {
+        this.applyOptimisticUpdate(updatedAction.type, currentVideo);
+      }
+      this.markActionSuccess(updatedAction.id);
     } catch (e) {
-      this.markActionFailed(action.id, String(e));
-      this.applyRollback(action);
+      this.markActionFailed(updatedAction.id, String(e));
+      this.applyRollback(updatedAction);
     }
   }
   scheduleRetry() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xhub-short/core",
   "sideEffects": false,
-  "version": "0.1.0-beta.13",
+  "version": "0.1.0-beta.14",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,14 +21,14 @@
   ],
   "dependencies": {
     "zustand": "^5.0.0",
-    "@xhub-short/contracts": "0.1.0-beta.13"
+    "@xhub-short/contracts": "0.1.0-beta.14"
   },
   "devDependencies": {
     "tsup": "^8.3.0",
     "typescript": "^5.7.0",
     "vitest": "^2.1.0",
-    "@xhub-short/tsconfig": "0.0.1-beta.1",
-    "@xhub-short/vitest-config": "0.1.0-beta.12"
+    "@xhub-short/vitest-config": "0.1.0-beta.13",
+    "@xhub-short/tsconfig": "0.0.1-beta.2"
   },
   "scripts": {
     "build": "tsup",