saltfish 0.3.70 → 0.3.73

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

@@ -1905,6 +1905,72 @@ const THRESHOLDS = {
   /** Minimum scroll distance in pixels to trigger scroll events */
   SCROLL_THRESHOLD_PX: 10
 };
+function stripShareIdFromUrl(url) {
+  try {
+    let cleanedUrl = url.replace(/[?&]saltfish-share-id=[^&#]*/g, (match, offset) => {
+      if (match.startsWith("?")) {
+        const afterMatch = url.substring(offset + match.length);
+        if (afterMatch.startsWith("&")) {
+          return "?";
+        }
+        return "";
+      }
+      return "";
+    });
+    cleanedUrl = cleanedUrl.replace(/\?&/g, "?");
+    cleanedUrl = cleanedUrl.replace(/&&/g, "&");
+    cleanedUrl = cleanedUrl.replace(/\?$/g, "");
+    cleanedUrl = cleanedUrl.replace(/&$/g, "");
+    return cleanedUrl;
+  } catch (error2) {
+    return url;
+  }
+}
+function validateUrlRequirement(urlRequirement) {
+  const { pattern, matchType } = urlRequirement;
+  if (!pattern) {
+    return true;
+  }
+  const currentUrl = stripShareIdFromUrl(window.location.href);
+  const currentPath = window.location.pathname;
+  if (matchType === "regex") {
+    try {
+      const regex = new RegExp(pattern);
+      const fullUrlMatch = regex.test(currentUrl);
+      const pathMatch = regex.test(currentPath);
+      const matches2 = fullUrlMatch || pathMatch;
+      log(`urlValidation: Result (regex) - matches: ${matches2}`);
+      return matches2;
+    } catch (error2) {
+      return false;
+    }
+  }
+  if (matchType === "contains") {
+    const matches2 = currentUrl.includes(pattern) || currentPath.includes(pattern);
+    return matches2;
+  }
+  const matches = currentUrl === pattern || currentPath === pattern;
+  return matches;
+}
+async function validateUrlRequirementWithRetry(urlRequirement, maxRetries = 20, retryDelay = 100) {
+  if (!urlRequirement) {
+    return true;
+  }
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (validateUrlRequirement(urlRequirement)) {
+      return true;
+    }
+    if (attempt < maxRetries - 1) {
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      const saltfishPlayer = window._saltfishPlayer;
+      if (!saltfishPlayer) {
+        return false;
+      }
+    }
+  }
+  log(`urlValidation: Expected pattern: '${urlRequirement.pattern}' (matchType: ${urlRequirement.matchType})`);
+  return false;
+}
 class PlayerInitializationService {
   constructor(managers) {
     __publicField(this, "managers");
@@ -2282,7 +2348,7 @@ class PlayerInitializationService {
     if (!pattern || typeof window === "undefined") {
       return false;
     }
-    const currentUrl = window.location.href;
+    const currentUrl = stripShareIdFromUrl(window.location.href);
     const currentPath = window.location.pathname;
     const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regexPattern = escapedPattern.replace(/\\\*/g, ".*");
@@ -2917,7 +2983,6 @@ class PlaylistOrchestrator {
           });
         }
       }
-      this.managers.analyticsManager.trackPlaylistStart(playlistId);
       this.managers.cursorManager.resetFirstAnimation();
       log(`[PlaylistOrchestrator.startPlaylist] Using validated manifest path: ${manifestPathToLoad}`);
       await this.managers.playlistManager.load(manifestPathToLoad, { ...finalOptions, persistence: playlistPersistence });
@@ -3012,51 +3077,6 @@ class PlaylistOrchestrator {
   destroy() {
   }
 }
-function validateUrlRequirement(urlRequirement) {
-  const { pattern, matchType } = urlRequirement;
-  if (!pattern) {
-    return true;
-  }
-  const currentUrl = window.location.href;
-  const currentPath = window.location.pathname;
-  if (matchType === "regex") {
-    try {
-      const regex = new RegExp(pattern);
-      const fullUrlMatch = regex.test(currentUrl);
-      const pathMatch = regex.test(currentPath);
-      const matches2 = fullUrlMatch || pathMatch;
-      log(`urlValidation: Result (regex) - matches: ${matches2}`);
-      return matches2;
-    } catch (error2) {
-      return false;
-    }
-  }
-  if (matchType === "contains") {
-    const matches2 = currentUrl.includes(pattern) || currentPath.includes(pattern);
-    return matches2;
-  }
-  const matches = currentUrl === pattern || currentPath === pattern;
-  return matches;
-}
-async function validateUrlRequirementWithRetry(urlRequirement, maxRetries = 20, retryDelay = 100) {
-  if (!urlRequirement) {
-    return true;
-  }
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    if (validateUrlRequirement(urlRequirement)) {
-      return true;
-    }
-    if (attempt < maxRetries - 1) {
-      await new Promise((resolve) => setTimeout(resolve, retryDelay));
-      const saltfishPlayer = window._saltfishPlayer;
-      if (!saltfishPlayer) {
-        return false;
-      }
-    }
-  }
-  log(`urlValidation: Expected pattern: '${urlRequirement.pattern}' (matchType: ${urlRequirement.matchType})`);
-  return false;
-}
 class StateMachineActionHandler {
   constructor(managers) {
     __publicField(this, "managers");
@@ -3729,6 +3749,39 @@ function setupEventUpdater(eventManager) {
   let prevPreviousState = null;
   let prevIsMinimized = null;
   let prevStepId = null;
+  let pendingStartEvents = { playlistData: null, stepData: null };
+  let autoplayConfirmationTimer = null;
+  const firePendingEvents = () => {
+    if (autoplayConfirmationTimer) {
+      clearTimeout(autoplayConfirmationTimer);
+      autoplayConfirmationTimer = null;
+    }
+    if (pendingStartEvents.playlistData) {
+      eventManager.trigger("playlistStarted", {
+        timestamp: Date.now(),
+        playlist: pendingStartEvents.playlistData
+      });
+    }
+    if (pendingStartEvents.stepData) {
+      eventManager.trigger("stepStarted", {
+        timestamp: Date.now(),
+        step: { id: pendingStartEvents.stepData.id, title: pendingStartEvents.stepData.title },
+        playlist: { id: pendingStartEvents.stepData.playlistId, title: pendingStartEvents.stepData.playlistTitle }
+      });
+    }
+    pendingStartEvents = { playlistData: null, stepData: null };
+  };
+  const startAutoplayConfirmationTimer = () => {
+    if (autoplayConfirmationTimer) {
+      clearTimeout(autoplayConfirmationTimer);
+    }
+    autoplayConfirmationTimer = setTimeout(() => {
+      if (pendingStartEvents.playlistData || pendingStartEvents.stepData) {
+        firePendingEvents();
+      }
+      autoplayConfirmationTimer = null;
+    }, 500);
+  };
   const unsubscribe = useSaltfishStore.subscribe(
     (state) => {
       var _a;
@@ -3753,30 +3806,55 @@ function setupEventUpdater(eventManager) {
       log(`EventUpdater: Processing state change from '${eventData.previousState}' to '${eventData.currentState}'`, {
         manifestId: (_a = state.manifest) == null ? void 0 : _a.id
       });
-      handleStateTransitionEvents(eventData, state, eventManager);
+      if (eventData.previousState === "playing") {
+        if (eventData.currentState === "autoplayBlocked" || eventData.currentState === "idleMode") {
+          if (autoplayConfirmationTimer) {
+            clearTimeout(autoplayConfirmationTimer);
+            autoplayConfirmationTimer = null;
+          }
+          if (pendingStartEvents.playlistData || pendingStartEvents.stepData) {
+            pendingStartEvents = { playlistData: null, stepData: null };
+          }
+        } else if (pendingStartEvents.playlistData || pendingStartEvents.stepData) {
+          firePendingEvents();
+        }
+      }
+      handleStateTransitionEvents(eventData, state, eventManager, pendingStartEvents);
       handleMinimizeEvents(eventData, state, eventManager, actualPrevMinimized);
-      handleStepEvents(eventData, state, eventManager, actualPrevStepId);
+      handleStepEvents(eventData, state, eventManager, actualPrevStepId, pendingStartEvents);
       handleErrorEvents(eventData, state, eventManager);
+      if ((pendingStartEvents.playlistData || pendingStartEvents.stepData) && !autoplayConfirmationTimer) {
+        startAutoplayConfirmationTimer();
+      }
     }
   );
   return unsubscribe;
 }
-function handleStateTransitionEvents(eventData, store, eventManager) {
+function handleStateTransitionEvents(eventData, store, eventManager, pendingStartEvents) {
   const { prevPreviousState, previousState, currentState, currentStepId } = eventData;
   const isNormalPlaylistStart = currentState === "playing" && previousState === "paused" && prevPreviousState === "loading";
-  const isDelayedPlaylistStart = currentState === "playing" && (previousState === "autoplayBlocked" || previousState === "idleMode");
-  if ((isNormalPlaylistStart || isDelayedPlaylistStart) && store.manifest && currentStepId) {
+  const isUserInitiatedPlaylistStart = currentState === "playing" && (previousState === "autoplayBlocked" || previousState === "idleMode");
+  if (store.manifest && currentStepId) {
     const isStartingNode = currentStepId === store.manifest.startStep;
     if (isStartingNode) {
-      log(`EventUpdater: Triggering playlistStarted event for ${store.manifest.id} (starting node: ${currentStepId})`);
-      eventManager.trigger("playlistStarted", {
-        timestamp: Date.now(),
-        playlist: {
+      if (isUserInitiatedPlaylistStart) {
+        log(`EventUpdater: Triggering playlistStarted event for ${store.manifest.id} (user-initiated from ${previousState})`);
+        eventManager.trigger("playlistStarted", {
+          timestamp: Date.now(),
+          playlist: {
+            id: store.manifest.id,
+            title: store.manifest.name
+          }
+        });
+        return;
+      } else if (isNormalPlaylistStart) {
+        log(`EventUpdater: Deferring playlistStarted event for ${store.manifest.id} (pending autoplay confirmation)`);
+        pendingStartEvents.playlistData = {
           id: store.manifest.id,
           title: store.manifest.name
-        }
-      });
-      return;
+        };
+        return;
+      }
     }
   }
   if (previousState === "paused" && currentState === "playing") {
@@ -3810,7 +3888,7 @@ function handleMinimizeEvents(eventData, _store, eventManager, prevIsMinimized)
     });
   }
 }
-function handleStepEvents(eventData, store, eventManager, prevStepId) {
+function handleStepEvents(eventData, store, eventManager, prevStepId, pendingStartEvents) {
   var _a, _b, _c;
   const { prevPreviousState, previousState, currentStepId, currentState } = eventData;
   const currentStep = store.currentStepId ? (((_a = store.manifest) == null ? void 0 : _a.steps) || []).find((s) => s.id === store.currentStepId) : null;
@@ -3844,26 +3922,38 @@ function handleStepEvents(eventData, store, eventManager, prevStepId) {
     }
   }
   const isStepChange = currentStepId !== prevStepId && currentState === "playing";
-  const isAutoplayOrIdleModeTransition = (previousState === "autoplayBlocked" || previousState === "idleMode") && currentState === "playing" && prevStepId === currentStepId;
-  const isFirstStepOfPlaylist = prevPreviousState === "loading" && previousState === "paused" && currentState === "playing" && currentStepId;
-  const shouldTriggerStepStarted = currentStep && store.manifest && (isStepChange || isAutoplayOrIdleModeTransition || isFirstStepOfPlaylist);
+  const isUserInitiatedStepStart = (previousState === "autoplayBlocked" || previousState === "idleMode") && currentState === "playing" && prevStepId === currentStepId;
+  const isFirstPlayOfPlaylist = prevPreviousState === "loading" && previousState === "paused" && currentState === "playing" && currentStepId;
+  const isStartingNode = store.manifest && currentStepId === store.manifest.startStep;
+  const isFirstStepAutoplayAttempt = isStartingNode && isFirstPlayOfPlaylist;
+  const isNonStartingNodeFirstPlay = !isStartingNode && isFirstPlayOfPlaylist;
   log("EventUpdater.handleStepEvents: Step started check", {
     currentStep: currentStep == null ? void 0 : currentStep.id,
     hasManifest: !!store.manifest
   });
-  if (shouldTriggerStepStarted) {
-    log(`EventUpdater: Triggering stepStarted for ${currentStep.id}`);
-    eventManager.trigger("stepStarted", {
-      timestamp: Date.now(),
-      step: {
+  if (currentStep && store.manifest) {
+    if (isStepChange || isUserInitiatedStepStart || isNonStartingNodeFirstPlay) {
+      log(`EventUpdater: Triggering stepStarted for ${currentStep.id}`);
+      eventManager.trigger("stepStarted", {
+        timestamp: Date.now(),
+        step: {
+          id: currentStep.id,
+          title: currentStep.title || currentStep.id
+        },
+        playlist: {
+          id: store.manifest.id,
+          title: store.manifest.name
+        }
+      });
+    } else if (isFirstStepAutoplayAttempt) {
+      log(`EventUpdater: Deferring stepStarted for ${currentStep.id} (pending autoplay confirmation)`);
+      pendingStartEvents.stepData = {
         id: currentStep.id,
-        title: currentStep.title || currentStep.id
-      },
-      playlist: {
-        id: store.manifest.id,
-        title: store.manifest.name
-      }
-    });
+        title: currentStep.title || currentStep.id,
+        playlistId: store.manifest.id,
+        playlistTitle: store.manifest.name
+      };
+    }
   }
 }
 function handleErrorEvents(eventData, store, eventManager) {
@@ -8939,7 +9029,6 @@ class EventSubscriberManager {
   }
 }
 class AnalyticsManager extends EventSubscriberManager {
-  // Default to enabled
   /**
    * Creates a new AnalyticsManager
    * @param eventManager - Optional event manager to subscribe to events
@@ -8953,6 +9042,8 @@ class AnalyticsManager extends EventSubscriberManager {
     __publicField(this, "flushInterval", null);
     __publicField(this, "sessionId", null);
     __publicField(this, "analyticsEnabled", true);
+    // Default to enabled
+    __publicField(this, "boundVisibilityHandler", null);
   }
   /**
    * Subscribe to relevant player events for analytics tracking
@@ -9039,6 +9130,10 @@ class AnalyticsManager extends EventSubscriberManager {
         });
       }
     });
+    this.eventManager.on("playlistStarted", (event) => {
+      log(`AnalyticsManager: Playlist started event received - ${event.playlist.id}`);
+      this.trackPlaylistStart(event.playlist.id);
+    });
   }
   /**
    * Initializes the analytics manager
@@ -9055,6 +9150,8 @@ class AnalyticsManager extends EventSubscriberManager {
       this.flushInterval = window.setInterval(() => {
         this.flushEvents();
       }, ANALYTICS.FLUSH_INTERVAL_MS);
+      this.boundVisibilityHandler = this.handleVisibilityChange.bind(this);
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
     }
   }
   /**
@@ -9251,6 +9348,45 @@ class AnalyticsManager extends EventSubscriberManager {
       this.isSending = false;
     }
   }
+  /**
+   * Handles visibility change events to flush analytics when page is hidden
+   * Uses sendBeacon for reliable delivery during page unload
+   */
+  handleVisibilityChange() {
+    if (document.visibilityState === "hidden") {
+      this.flushWithBeacon();
+    }
+  }
+  /**
+   * Flushes events using sendBeacon API for reliable delivery during page unload
+   * sendBeacon is fire-and-forget and survives page navigation/close
+   */
+  flushWithBeacon() {
+    if (this.eventQueue.length === 0 || !this.config || !this.analyticsEnabled) {
+      return;
+    }
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    const payload = {
+      token: this.config.token,
+      sessionId: this.sessionId,
+      user: this.user,
+      events
+    };
+    try {
+      fetch("https://player.saltfish.ai/analytics", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload),
+        keepalive: true
+      });
+    } catch (error2) {
+      console.warn("AnalyticsManager: fetch keepalive failed, events returned to queue");
+      this.eventQueue = [...events, ...this.eventQueue];
+    }
+  }
   /**
    * Cleans up resources used by the analytics manager
    */
@@ -9262,6 +9398,10 @@ class AnalyticsManager extends EventSubscriberManager {
       clearInterval(this.flushInterval);
       this.flushInterval = null;
     }
+    if (this.boundVisibilityHandler) {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+      this.boundVisibilityHandler = null;
+    }
     if (this.eventManager) {
       this.eventManager = null;
     }
@@ -9726,7 +9866,7 @@ class TransitionManager {
     if (!pattern) {
       return false;
     }
-    const currentUrl = window.location.href;
+    const currentUrl = stripShareIdFromUrl(window.location.href);
     const currentPath = window.location.pathname;
     const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regexPattern = escapedPattern.replace(/\\\*/g, ".*");
@@ -10241,7 +10381,7 @@ class TriggerManager {
     if (!pattern) {
       return true;
     }
-    const currentUrl = this.normalizeUrl(window.location.href.split("#")[0]);
+    const currentUrl = this.normalizeUrl(stripShareIdFromUrl(window.location.href.split("#")[0]));
     const currentPath = window.location.pathname;
     if (triggers.urlMatchType === "regex") {
       try {
@@ -12569,7 +12709,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.3.70";
+const version = "0.3.73";
 const packageJson = {
   version
 };