saltfish 0.3.30 → 0.3.33

package/dist/saltfish-playlist-player.es.js

@@ -2732,7 +2732,7 @@ class PlaylistOrchestrator {
           { component: "PlaylistOrchestrator", method: "startPlaylist", playlistId }
         );
       }
-      const isPlaylistRunning = store.manifest && (store.currentState === "playing" || store.currentState === "paused" || store.currentState === "loading" || store.currentState === "waitingForInteraction" || store.currentState === "autoplayBlocked" || store.currentState === "minimized");
+      const isPlaylistRunning = store.manifest && (store.currentState === "playing" || store.currentState === "paused" || store.currentState === "loading" || store.currentState === "waitingForInteraction" || store.currentState === "autoplayBlocked" || store.currentState === "minimized" || store.currentState === "idleMode");
       if (isPlaylistRunning) {
         log("PlaylistOrchestrator: Starting new playlist while another is running, resetting state");
         if (this.managerOrchestrator) {
@@ -2912,6 +2912,9 @@ class StateMachineActionHandler {
   constructor(managers) {
     __publicField(this, "managers");
     __publicField(this, "destroyCallback", null);
+    __publicField(this, "cursorAnimationListener", null);
+    __publicField(this, "cursorAnimationVideoElement", null);
+    __publicField(this, "cursorAnimationStepId", null);
     this.managers = managers;
   }
   /**
@@ -3044,6 +3047,87 @@ class StateMachineActionHandler {
     return null;
   }
   destroy() {
+    this.cleanupCursorAnimationListener();
+  }
+  /**
+   * Cleans up the active cursor animation time listener
+   * @param stepId - Optional step ID to verify we're cleaning up the right listener
+   */
+  cleanupCursorAnimationListener(stepId) {
+    if (stepId && this.cursorAnimationStepId && stepId !== this.cursorAnimationStepId) {
+      log(`StateMachineActionHandler: Skipping cleanup - stepId mismatch (requested: ${stepId}, current: ${this.cursorAnimationStepId})`);
+      return;
+    }
+    if (this.cursorAnimationListener && this.cursorAnimationVideoElement) {
+      this.cursorAnimationVideoElement.removeEventListener("timeupdate", this.cursorAnimationListener);
+      this.cursorAnimationListener = null;
+      this.cursorAnimationVideoElement = null;
+      this.cursorAnimationStepId = null;
+    }
+  }
+  /**
+   * Schedules a cursor animation to run either immediately or at a specific video time
+   * Note: Works for both video and audio-only steps (audio files use the same video element)
+   */
+  scheduleCursorAnimation(animation, stepId) {
+    this.cleanupCursorAnimationListener();
+    let showAtSeconds = animation.showAtSeconds ?? 0;
+    if (typeof showAtSeconds !== "number" || !isFinite(showAtSeconds)) {
+      showAtSeconds = 0;
+    }
+    if (showAtSeconds < 0) {
+      showAtSeconds = 0;
+    }
+    if (showAtSeconds <= 0) {
+      this.managers.cursorManager.animate(animation);
+    } else {
+      const videoElement = this.managers.videoManager.getVideoElement();
+      if (!videoElement) {
+        return;
+      }
+      let animationTriggered = false;
+      let warningLogged = false;
+      const timeUpdateHandler = () => {
+        if (animationTriggered) {
+          return;
+        }
+        const currentTime = videoElement.currentTime;
+        const duration = videoElement.duration;
+        if (duration && !isNaN(duration) && showAtSeconds > duration && !warningLogged) {
+          warningLogged = true;
+          animationTriggered = true;
+          this.cleanupCursorAnimationListener();
+          this.managers.cursorManager.animate(animation);
+          return;
+        }
+        if (currentTime >= showAtSeconds) {
+          animationTriggered = true;
+          this.cleanupCursorAnimationListener();
+          this.managers.cursorManager.animate(animation);
+        }
+      };
+      const endedHandler = () => {
+        if (!animationTriggered) {
+          const store = getSaltfishStore();
+          if (store.currentStepId !== stepId) {
+            log(`StateMachineActionHandler: Video ended but step changed (was ${stepId}, now ${store.currentStepId}). Not triggering cursor animation.`);
+            this.cleanupCursorAnimationListener(stepId);
+            return;
+          }
+          videoElement.duration;
+          animationTriggered = true;
+          this.managers.cursorManager.animate(animation);
+          this.cleanupCursorAnimationListener();
+        }
+      };
+      this.cursorAnimationListener = () => {
+        timeUpdateHandler();
+      };
+      this.cursorAnimationVideoElement = videoElement;
+      this.cursorAnimationStepId = stepId;
+      videoElement.addEventListener("timeupdate", this.cursorAnimationListener);
+      videoElement.addEventListener("ended", endedHandler, { once: true });
+    }
   }
   /**
    * Validates URL requirement for a specific step with retry logic
@@ -3134,17 +3218,7 @@ class StateMachineActionHandler {
       if (currentStep.buttons) {
         this.managers.interactionManager.createButtons(currentStep.buttons);
       }
-      log(`StateMachineActionHandler: Processing cursor animations for step ${currentStep.id}`);
       log(`StateMachineActionHandler: Step has cursor animations: ${!!(currentStep.cursorAnimations && currentStep.cursorAnimations.length > 0)}`);
-      if (currentStep.cursorAnimations && currentStep.cursorAnimations.length > 0) {
-        log(`StateMachineActionHandler: Setting cursor visibility to true for step ${currentStep.id}`);
-        this.managers.cursorManager.setShouldShowCursor(true);
-        log(`StateMachineActionHandler: Starting cursor animation for step ${currentStep.id} with target: ${currentStep.cursorAnimations[0].targetSelector || "no target"}`);
-        this.managers.cursorManager.animate(currentStep.cursorAnimations[0]);
-      } else {
-        log(`StateMachineActionHandler: Setting cursor visibility to false for step ${currentStep.id} - step has no cursor animations`);
-        this.managers.cursorManager.setShouldShowCursor(false);
-      }
       const hasSpecialTransitions = currentStep.buttons && currentStep.buttons.length > 0 || currentStep.transitions.some(
         (t) => t.type === "dom-click" || t.type === "url-path" || t.type === "dom-element-visible"
       );
@@ -3233,6 +3307,14 @@ class StateMachineActionHandler {
         log("StateMachineActionHandler: Video loaded successfully, playing");
         this.managers.uiManager.hideError();
         loadTranscriptForStep();
+        if (currentStep.cursorAnimations && currentStep.cursorAnimations.length > 0) {
+          log(`StateMachineActionHandler: Setting cursor visibility and scheduling animation for step ${currentStep.id}`);
+          this.managers.cursorManager.setShouldShowCursor(true);
+          this.scheduleCursorAnimation(currentStep.cursorAnimations[0], currentStep.id);
+        } else {
+          log(`StateMachineActionHandler: Setting cursor visibility to false for step ${currentStep.id} - step has no cursor animations`);
+          this.managers.cursorManager.setShouldShowCursor(false);
+        }
         if (isAudioFallback) {
           this.managers.videoManager.startAudioVisualization();
         } else {
@@ -3655,6 +3737,9 @@ const _ManagerOrchestrator = class _ManagerOrchestrator {
     // Store updater unsubscribe functions
     __publicField(this, "uiUpdaterUnsubscribe", null);
     __publicField(this, "eventUpdaterUnsubscribe", null);
+    __publicField(this, "cursorAnimationListener", null);
+    __publicField(this, "cursorAnimationVideoElement", null);
+    __publicField(this, "cursorAnimationStepId", null);
     // Initialization state
     __publicField(this, "isInitialized", false);
     this.managers = managers;
@@ -3699,6 +3784,86 @@ const _ManagerOrchestrator = class _ManagerOrchestrator {
       stepTimeoutUnsubscribe();
     };
   }
+  /**
+   * Cleans up the active cursor animation time listener
+   * @param stepId - Optional step ID to verify we're cleaning up the right listener
+   */
+  cleanupCursorAnimationListener(stepId) {
+    if (stepId && this.cursorAnimationStepId && stepId !== this.cursorAnimationStepId) {
+      log(`ManagerOrchestrator: Skipping cleanup - stepId mismatch (requested: ${stepId}, current: ${this.cursorAnimationStepId})`);
+      return;
+    }
+    if (this.cursorAnimationListener && this.cursorAnimationVideoElement) {
+      this.cursorAnimationVideoElement.removeEventListener("timeupdate", this.cursorAnimationListener);
+      this.cursorAnimationListener = null;
+      this.cursorAnimationVideoElement = null;
+      this.cursorAnimationStepId = null;
+    }
+  }
+  /**
+   * Schedules a cursor animation to run either immediately or at a specific video time
+   * Note: Works for both video and audio-only steps (audio files use the same video element)
+   */
+  scheduleCursorAnimation(animation, stepId) {
+    this.cleanupCursorAnimationListener();
+    let showAtSeconds = animation.showAtSeconds ?? 0;
+    if (typeof showAtSeconds !== "number" || !isFinite(showAtSeconds)) {
+      showAtSeconds = 0;
+    }
+    if (showAtSeconds < 0) {
+      showAtSeconds = 0;
+    }
+    if (showAtSeconds <= 0) {
+      this.managers.cursorManager.animate(animation);
+    } else {
+      const videoElement = this.managers.videoManager.getVideoElement();
+      if (!videoElement) {
+        return;
+      }
+      let animationTriggered = false;
+      let warningLogged = false;
+      const timeUpdateHandler = () => {
+        if (animationTriggered) {
+          return;
+        }
+        const currentTime = videoElement.currentTime;
+        const duration = videoElement.duration;
+        if (duration && !isNaN(duration) && showAtSeconds > duration && !warningLogged) {
+          warningLogged = true;
+          animationTriggered = true;
+          this.cleanupCursorAnimationListener();
+          this.managers.cursorManager.animate(animation);
+          return;
+        }
+        if (currentTime >= showAtSeconds) {
+          animationTriggered = true;
+          this.cleanupCursorAnimationListener();
+          this.managers.cursorManager.animate(animation);
+        }
+      };
+      const endedHandler = () => {
+        if (!animationTriggered) {
+          const store = getSaltfishStore();
+          if (store.currentStepId !== stepId) {
+            log(`ManagerOrchestrator: Video ended but step changed (was ${stepId}, now ${store.currentStepId}). Not triggering cursor animation.`);
+            this.cleanupCursorAnimationListener(stepId);
+            return;
+          }
+          videoElement.duration;
+          animationTriggered = true;
+          this.managers.cursorManager.animate(animation);
+          this.cleanupCursorAnimationListener();
+        }
+      };
+      this.cursorAnimationListener = () => {
+        timeUpdateHandler();
+      };
+      this.cursorAnimationVideoElement = videoElement;
+      this.cursorAnimationStepId = stepId;
+      videoElement.addEventListener("timeupdate", this.cursorAnimationListener);
+      videoElement.addEventListener("ended", endedHandler, { once: true });
+    }
+  }
   /**
    * Handle store state changes
    */
@@ -3730,7 +3895,7 @@ const _ManagerOrchestrator = class _ManagerOrchestrator {
       const currentStep = manifest == null ? void 0 : manifest.steps.find((step) => step.id === store.currentStepId);
       if ((currentStep == null ? void 0 : currentStep.cursorAnimations) && currentStep.cursorAnimations.length > 0) {
         this.managers.cursorManager.setShouldShowCursor(true);
-        this.managers.cursorManager.animate(currentStep.cursorAnimations[0]);
+        this.scheduleCursorAnimation(currentStep.cursorAnimations[0], store.currentStepId || "unknown");
       }
     } else if (store.currentState === "completed" || store.currentState === "closing") {
       this.cleanupPlaylist();
@@ -3749,6 +3914,7 @@ const _ManagerOrchestrator = class _ManagerOrchestrator {
    */
   cleanupCurrentPlaylist() {
     try {
+      this.cleanupCursorAnimationListener();
       if (this.eventUpdaterUnsubscribe) {
         this.eventUpdaterUnsubscribe();
         this.eventUpdaterUnsubscribe = null;
@@ -3840,6 +4006,7 @@ const _ManagerOrchestrator = class _ManagerOrchestrator {
         isMinimized: store.isMinimized,
         manifestId: (_a = store.manifest) == null ? void 0 : _a.id
       });
+      this.cleanupCursorAnimationListener();
       if (this.uiUpdaterUnsubscribe) {
         this.uiUpdaterUnsubscribe();
         this.uiUpdaterUnsubscribe = null;
@@ -8206,21 +8373,13 @@ class InteractionManager {
     this.container = null;
   }
 }
-class AnalyticsManager {
-  // Default to enabled
+class EventSubscriberManager {
   /**
-   * Creates a new AnalyticsManager
+   * Creates a new event-subscribing manager instance
    * @param eventManager - Optional event manager to subscribe to events
    */
   constructor(eventManager) {
-    __publicField(this, "config", null);
-    __publicField(this, "user", null);
-    __publicField(this, "eventQueue", []);
-    __publicField(this, "isSending", false);
-    __publicField(this, "flushInterval", null);
     __publicField(this, "eventManager", null);
-    __publicField(this, "sessionId", null);
-    __publicField(this, "analyticsEnabled", true);
     if (eventManager) {
       this.setEventManager(eventManager);
     }
@@ -8233,6 +8392,23 @@ class AnalyticsManager {
     this.eventManager = eventManager;
     this.subscribeToEvents();
   }
+}
+class AnalyticsManager extends EventSubscriberManager {
+  // Default to enabled
+  /**
+   * Creates a new AnalyticsManager
+   * @param eventManager - Optional event manager to subscribe to events
+   */
+  constructor(eventManager) {
+    super(eventManager);
+    __publicField(this, "config", null);
+    __publicField(this, "user", null);
+    __publicField(this, "eventQueue", []);
+    __publicField(this, "isSending", false);
+    __publicField(this, "flushInterval", null);
+    __publicField(this, "sessionId", null);
+    __publicField(this, "analyticsEnabled", true);
+  }
   /**
    * Subscribe to relevant player events for analytics tracking
    */
@@ -9792,24 +9968,13 @@ class TriggerManager {
     this.visibleElements.clear();
   }
 }
-class ABTestManager {
+class ABTestManager extends EventSubscriberManager {
   /**
    * Creates a new ABTestManager
    * @param eventManager - Optional event manager to subscribe to events
    */
   constructor(eventManager) {
-    __publicField(this, "eventManager", null);
-    if (eventManager) {
-      this.setEventManager(eventManager);
-    }
-  }
-  /**
-   * Sets the event manager and subscribes to relevant events
-   * @param eventManager - Event manager instance
-   */
-  setEventManager(eventManager) {
-    this.eventManager = eventManager;
-    this.subscribeToEvents();
+    super(eventManager);
   }
   /**
    * Subscribe to relevant events for A/B testing
@@ -10189,30 +10354,19 @@ class PlaylistLoader {
     return startStepId;
   }
 }
-class PlaylistManager {
+class PlaylistManager extends EventSubscriberManager {
   /**
    * Creates a new PlaylistManager
    * @param eventManager - Optional event manager to subscribe to events
    * @param storageManager - Optional storage manager for localStorage operations
    */
   constructor(eventManager, storageManager2) {
-    __publicField(this, "eventManager", null);
+    super(eventManager);
     __publicField(this, "isUpdatingWatchedPlaylists", false);
     __publicField(this, "playlistLoader");
     __publicField(this, "storageManager");
     this.playlistLoader = new PlaylistLoader();
     this.storageManager = storageManager2 || StorageManager.getInstance();
-    if (eventManager) {
-      this.setEventManager(eventManager);
-    }
-  }
-  /**
-   * Sets the event manager and subscribes to relevant events
-   * @param eventManager - Event manager instance
-   */
-  setEventManager(eventManager) {
-    this.eventManager = eventManager;
-    this.subscribeToEvents();
   }
   /**
    * Subscribe to relevant player events for playlist tracking
@@ -11597,7 +11751,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.3.30";
+const version = "0.3.33";
 const packageJson = {
   version
 };