saltfish 0.3.60 → 0.3.62

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

@@ -955,7 +955,8 @@ const playerStateMachineConfig = {
 const STORAGE_KEYS = {
   PROGRESS: "saltfish_progress",
   SESSION: "saltfish_session",
-  ANONYMOUS_USER: "saltfish_anonymous_user_data"
+  ANONYMOUS_USER: "saltfish_anonymous_user_data",
+  PENDING_NAVIGATION: "saltfish_pending_navigation"
 };
 const API = {
   BASE_URL: "https://player.saltfish.ai",
@@ -1155,15 +1156,30 @@ const _StorageManager = class _StorageManager {
     this.safeClearItem(STORAGE_KEYS.ANONYMOUS_USER);
   }
   // =============================================================================
-  // Anonymous User ID Methods
+  // Pending Navigation Methods (Cross-page URL transitions)
   // =============================================================================
   /**
-   * Get anonymous user ID from the anonymous user data object
-   * This reads from the same key as getAnonymousUserData() for consistency
+   * Get pending navigation data for cross-page URL transitions
+   * Used when a step has a url-path transition and user navigates causing hard refresh
    */
-  getAnonymousUserId() {
-    const data = this.getAnonymousUserData();
-    return (data == null ? void 0 : data.userId) || null;
+  getPendingNavigation() {
+    return this.safeGetItem(STORAGE_KEYS.PENDING_NAVIGATION);
+  }
+  /**
+   * Set pending navigation data
+   * Called when setting up a url-path transition to enable resuming after hard refresh
+   * @param data - The pending navigation data to save
+   */
+  setPendingNavigation(data) {
+    log(`[StorageManager] Saving pending navigation to step ${data.nextStepId} for pattern ${data.urlPattern}`);
+    return this.safeSetItem(STORAGE_KEYS.PENDING_NAVIGATION, data);
+  }
+  /**
+   * Clear pending navigation data
+   * Called after successful transition or when navigation is no longer valid
+   */
+  clearPendingNavigation() {
+    this.safeClearItem(STORAGE_KEYS.PENDING_NAVIGATION);
   }
   // =============================================================================
   // Utility Methods
@@ -1175,33 +1191,7 @@ const _StorageManager = class _StorageManager {
     this.clearProgress();
     this.clearSession();
     this.clearAnonymousUserData();
-  }
-  /**
-   * Get storage availability status
-   */
-  isStorageAvailable() {
-    return this.isLocalStorageAvailable;
-  }
-  /**
-   * Get storage usage information (if available)
-   */
-  getStorageInfo() {
-    const keys = [];
-    if (this.isLocalStorageAvailable) {
-      try {
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
-          if (key && key.startsWith("saltfish_")) {
-            keys.push(key);
-          }
-        }
-      } catch (error2) {
-      }
-    }
-    return {
-      available: this.isLocalStorageAvailable,
-      keys
-    };
+    this.clearPendingNavigation();
   }
 };
 __publicField(_StorageManager, "instance", null);
@@ -1874,6 +1864,47 @@ class ShareLinkService {
     }
   }
 }
+const ANALYTICS = {
+  /** Interval for flushing analytics events to the backend (30 seconds) */
+  FLUSH_INTERVAL_MS: 3e4
+};
+const TIMING = {
+  // Polling and updates
+  /** Video progress polling interval (50ms) */
+  VIDEO_PROGRESS_POLL_INTERVAL: 50,
+  /** Cursor position update throttle interval (100ms) */
+  CURSOR_UPDATE_THROTTLE: 100,
+  /** Delay for state processing operations (100ms) */
+  STATE_PROCESSING_DELAY_MS: 100,
+  // Analytics
+  /** Analytics event flush interval (30 seconds) */
+  ANALYTICS_FLUSH_INTERVAL: 3e4,
+  // Timeouts
+  /** User data loading timeout (5 seconds) */
+  USER_DATA_TIMEOUT: 5e3,
+  /** Step timeout - player will be destroyed if user stays on same step (120 seconds) */
+  STEP_TIMEOUT: 12e4,
+  /** Retry delay for failed operations (0.5 seconds) */
+  RETRY_DELAY_MS: 500,
+  // DOM and cursor operations
+  /** Delay for DOM stabilization before cursor operations (0.5 seconds) */
+  DOM_STABILIZATION_DELAY_MS: 500,
+  /** Default cursor animation distance in pixels */
+  CURSOR_DEFAULT_DISTANCE: 100,
+  // URL monitoring
+  /** Interval for checking URL path changes (5 seconds) */
+  URL_PATH_CHECK_INTERVAL_MS: 5e3,
+  // Session persistence
+  /** Session expiry time (30 minutes) */
+  SESSION_EXPIRY: 30 * 60 * 1e3,
+  // Cross-page navigation
+  /** Pending navigation expiry time (60 seconds) - longer than normal 6s rule for URL transitions */
+  PENDING_NAVIGATION_EXPIRY: 60 * 1e3
+};
+const THRESHOLDS = {
+  /** Minimum scroll distance in pixels to trigger scroll events */
+  SCROLL_THRESHOLD_PX: 10
+};
 class PlayerInitializationService {
   constructor(managers) {
     __publicField(this, "managers");
@@ -2038,7 +2069,11 @@ class PlayerInitializationService {
         if (this.userManagementService) {
           this.userManagementService.resolveUserDataLoaded();
         }
-        const resumedPlaylist = await this.checkAndResumeInProgressPlaylist(data.watchedPlaylists || {});
+        const resumedFromPendingNav = await this.checkAndResumeFromPendingNavigation();
+        if (resumedFromPendingNav) {
+          log("[PlayerInitializationService.fetchUserData] Resumed from pending URL navigation, skipping other checks");
+        }
+        const resumedPlaylist = resumedFromPendingNav || await this.checkAndResumeInProgressPlaylist(data.watchedPlaylists || {});
         if (!resumedPlaylist) {
           const shareData = await this.shareLinkService.shouldAutoStartSharePlaylist();
           if (shareData && this.playlistOrchestrator) {
@@ -2124,8 +2159,12 @@ class PlayerInitializationService {
           watchedPlaylists: anonymousUserData.watchedPlaylists || {}
         }
       });
+      const resumedFromPendingNav = await this.checkAndResumeFromPendingNavigation();
+      if (resumedFromPendingNav) {
+        log("[PlayerInitializationService.loadAnonymousUserData] Resumed from pending URL navigation, skipping other checks");
+      }
       const watchedPlaylists = anonymousUserData.watchedPlaylists || {};
-      const resumedPlaylist = await this.checkAndResumeInProgressPlaylist(watchedPlaylists);
+      const resumedPlaylist = resumedFromPendingNav || await this.checkAndResumeInProgressPlaylist(watchedPlaylists);
       if (!resumedPlaylist) {
         const shareData = await this.shareLinkService.shouldAutoStartSharePlaylist();
         if (shareData && this.playlistOrchestrator) {
@@ -2197,6 +2236,60 @@ class PlayerInitializationService {
     }
     return false;
   }
+  /**
+   * Check for pending navigation from cross-page URL transitions and auto-start the playlist
+   * This handles the case where user navigated to a new page (hard refresh)
+   * and we need to resume from the step that was waiting for that URL
+   * @returns true if a playlist was started from pending navigation
+   */
+  async checkAndResumeFromPendingNavigation() {
+    const pending = this.managers.storageManager.getPendingNavigation();
+    if (!pending) {
+      return false;
+    }
+    const ageMs = Date.now() - pending.timestamp;
+    if (ageMs > TIMING.PENDING_NAVIGATION_EXPIRY) {
+      this.managers.storageManager.clearPendingNavigation();
+      return false;
+    }
+    if (!this.isURLPathMatch(pending.urlPattern)) {
+      log(`[PlayerInitializationService.checkAndResumeFromPendingNavigation] URL doesn't match pending pattern '${pending.urlPattern}'`);
+      this.managers.storageManager.clearPendingNavigation();
+      return false;
+    }
+    log(`[PlayerInitializationService.checkAndResumeFromPendingNavigation] URL matches! Starting playlist ${pending.playlistId} at step ${pending.nextStepId}`);
+    this.managers.storageManager.clearPendingNavigation();
+    try {
+      if (this.playlistOrchestrator) {
+        await this.playlistOrchestrator.startPlaylist(pending.playlistId, {
+          startNodeId: pending.nextStepId
+        });
+        log(`[PlayerInitializationService.checkAndResumeFromPendingNavigation] Successfully started playlist from pending navigation`);
+        return true;
+      }
+    } catch (error2) {
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Checks if the current URL path matches a pattern
+   * Uses the same logic as TransitionManager for consistency
+   * @param pattern - The URL pattern to match (supports wildcards)
+   * @returns true if the current URL matches the pattern
+   */
+  isURLPathMatch(pattern) {
+    if (!pattern || typeof window === "undefined") {
+      return false;
+    }
+    const currentUrl = window.location.href;
+    const currentPath = window.location.pathname;
+    const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regexPattern = escapedPattern.replace(/\\\*/g, ".*");
+    const regex = new RegExp(regexPattern);
+    const match = regex.test(currentUrl) || regex.test(currentPath);
+    return match;
+  }
   /**
    * Get or create persistent anonymous user ID
    */
@@ -4283,7 +4376,7 @@ class DeviceDetector {
       return this.cachedDeviceInfo;
     }
     const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
-    const isTouchDevice2 = this.detectTouchSupport();
+    const isTouchDevice = this.detectTouchSupport();
     const { width, height } = this.getScreenDimensions();
     const mobileRegex = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile|mobile|CriOS/i;
     const tabletRegex = /iPad|Android(?!.*Mobile)|Tablet|tablet/i;
@@ -4292,14 +4385,14 @@ class DeviceDetector {
     const screenSize = this.getScreenSize(width, height);
     const isMobileByScreen = screenSize === "small" && Math.min(width, height) < 768;
     const isTabletByScreen = screenSize === "medium" && !isMobileByScreen;
-    const isMobile2 = isMobileUserAgent || isMobileByScreen && isTouchDevice2;
-    const isTablet2 = isTabletUserAgent || isTabletByScreen && isTouchDevice2 && !isMobile2;
-    const isDesktop2 = !isMobile2 && !isTablet2;
+    const isMobile = isMobileUserAgent || isMobileByScreen && isTouchDevice;
+    const isTablet = isTabletUserAgent || isTabletByScreen && isTouchDevice && !isMobile;
+    const isDesktop = !isMobile && !isTablet;
     const deviceInfo = {
-      isMobile: isMobile2,
-      isTablet: isTablet2,
-      isDesktop: isDesktop2,
-      isTouchDevice: isTouchDevice2,
+      isMobile,
+      isTablet,
+      isDesktop,
+      isTouchDevice,
       screenSize,
       orientation: this.detectOrientation(),
       userAgent
@@ -6648,44 +6741,6 @@ class VideoManager {
     this.soundbarElement = null;
   }
 }
-const ANALYTICS = {
-  /** Interval for flushing analytics events to the backend (30 seconds) */
-  FLUSH_INTERVAL_MS: 3e4
-};
-const TIMING = {
-  // Polling and updates
-  /** Video progress polling interval (50ms) */
-  VIDEO_PROGRESS_POLL_INTERVAL: 50,
-  /** Cursor position update throttle interval (100ms) */
-  CURSOR_UPDATE_THROTTLE: 100,
-  /** Delay for state processing operations (100ms) */
-  STATE_PROCESSING_DELAY_MS: 100,
-  // Analytics
-  /** Analytics event flush interval (30 seconds) */
-  ANALYTICS_FLUSH_INTERVAL: 3e4,
-  // Timeouts
-  /** User data loading timeout (5 seconds) */
-  USER_DATA_TIMEOUT: 5e3,
-  /** Step timeout - player will be destroyed if user stays on same step (120 seconds) */
-  STEP_TIMEOUT: 12e4,
-  /** Retry delay for failed operations (0.5 seconds) */
-  RETRY_DELAY_MS: 500,
-  // DOM and cursor operations
-  /** Delay for DOM stabilization before cursor operations (0.5 seconds) */
-  DOM_STABILIZATION_DELAY_MS: 500,
-  /** Default cursor animation distance in pixels */
-  CURSOR_DEFAULT_DISTANCE: 100,
-  // URL monitoring
-  /** Interval for checking URL path changes (5 seconds) */
-  URL_PATH_CHECK_INTERVAL_MS: 5e3,
-  // Session persistence
-  /** Session expiry time (30 minutes) */
-  SESSION_EXPIRY: 30 * 60 * 1e3
-};
-const THRESHOLDS = {
-  /** Minimum scroll distance in pixels to trigger scroll events */
-  SCROLL_THRESHOLD_PX: 10
-};
 const DEFAULT_CONFIG = {
   tolerance: 0.3,
   // 30% size difference allowed (70% match required)
@@ -9249,6 +9304,8 @@ class TransitionManager {
     __publicField(this, "isStateMachineValidating", false);
     // Reference to TriggerManager for coordinating playlist triggers
     __publicField(this, "triggerManager", null);
+    // beforeunload handler for cross-page URL transitions
+    __publicField(this, "beforeUnloadHandler", null);
     /**
      * Handles URL changes by checking active URL path transitions and playlist triggers
      */
@@ -9285,6 +9342,7 @@ class TransitionManager {
           }
           const { pattern, nextStepId } = transition.data;
           if (this.isURLPathMatch(pattern)) {
+            StorageManager.getInstance().clearPendingNavigation();
             this.triggerTransition(nextStepId);
             break;
           }
@@ -9475,6 +9533,8 @@ class TransitionManager {
     }
     const pathPattern = transition.target;
     const nextStepId = transition.nextStep;
+    this.savePendingNavigation(pathPattern, nextStepId);
+    this.setupBeforeUnloadHandler(pathPattern, nextStepId);
     const initialMatch = this.isURLPathMatch(pathPattern);
     if (initialMatch) {
       this.triggerTransition(nextStepId);
@@ -9501,6 +9561,7 @@ class TransitionManager {
       const match = this.isURLPathMatch(pathPattern);
       if (match) {
         clearInterval(intervalId);
+        StorageManager.getInstance().clearPendingNavigation();
         this.triggerTransition(nextStepId);
       }
     }, TIMING.URL_PATH_CHECK_INTERVAL_MS);
@@ -9517,6 +9578,47 @@ class TransitionManager {
       }
     });
   }
+  /**
+   * Saves pending navigation data for cross-page URL transitions
+   * This enables resuming from the correct step after a hard page refresh
+   * @param urlPattern - The URL pattern to match
+   * @param nextStepId - The step ID to navigate to
+   */
+  savePendingNavigation(urlPattern, nextStepId) {
+    const store = getSaltfishStore();
+    if (!store.manifest) {
+      return;
+    }
+    const storageManager2 = StorageManager.getInstance();
+    storageManager2.setPendingNavigation({
+      playlistId: store.manifest.id,
+      nextStepId,
+      urlPattern,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Sets up beforeunload handler as backup for cross-page URL transitions
+   * This ensures pending navigation is saved even if the page unloads unexpectedly
+   * @param urlPattern - The URL pattern to match
+   * @param nextStepId - The step ID to navigate to
+   */
+  setupBeforeUnloadHandler(urlPattern, nextStepId) {
+    this.removeBeforeUnloadHandler();
+    this.beforeUnloadHandler = () => {
+      this.savePendingNavigation(urlPattern, nextStepId);
+    };
+    window.addEventListener("beforeunload", this.beforeUnloadHandler);
+  }
+  /**
+   * Removes the beforeunload handler if it exists
+   */
+  removeBeforeUnloadHandler() {
+    if (this.beforeUnloadHandler) {
+      window.removeEventListener("beforeunload", this.beforeUnloadHandler);
+      this.beforeUnloadHandler = null;
+    }
+  }
   /**
    * Checks if the current URL path matches a pattern
    */
@@ -9626,6 +9728,7 @@ class TransitionManager {
     });
     this.activeTransitions.clear();
     this.waitingForInteraction = false;
+    this.removeBeforeUnloadHandler();
   }
   /**
    * Sets the waiting for interaction state
@@ -10862,6 +10965,11 @@ class PlaylistLoader {
     const manifestIdForProgress = manifest.id;
     const wasTriggered = options._triggeredByTriggerManager === true;
     let startStepId = manifest.startStep;
+    const pendingNav = this.checkPendingNavigation(manifest);
+    if (pendingNav) {
+      log(`PlaylistLoader: Resuming from pending URL navigation to step '${pendingNav.nextStepId}'`);
+      return pendingNav.nextStepId;
+    }
     if (options.startNodeId) {
       const customStep = manifest.steps.find((step) => step.id === options.startNodeId);
       if (customStep) {
@@ -10893,6 +11001,61 @@ class PlaylistLoader {
     }
     return startStepId;
   }
+  /**
+   * Checks for pending navigation from a cross-page URL transition
+   * This handles the case where user navigated to a new page (hard refresh)
+   * and we need to resume from the step that was waiting for that URL
+   * @param manifest - The loaded playlist manifest
+   * @returns The pending navigation data if valid, null otherwise
+   */
+  checkPendingNavigation(manifest) {
+    const storageManager2 = StorageManager.getInstance();
+    const pending = storageManager2.getPendingNavigation();
+    if (!pending) {
+      return null;
+    }
+    if (pending.playlistId !== manifest.id) {
+      log(`PlaylistLoader: Pending navigation is for different playlist (${pending.playlistId}), ignoring`);
+      return null;
+    }
+    const ageMs = Date.now() - pending.timestamp;
+    if (ageMs > TIMING.PENDING_NAVIGATION_EXPIRY) {
+      storageManager2.clearPendingNavigation();
+      return null;
+    }
+    if (!this.isURLPathMatch(pending.urlPattern)) {
+      log(`PlaylistLoader: URL doesn't match pending pattern '${pending.urlPattern}', clearing`);
+      storageManager2.clearPendingNavigation();
+      return null;
+    }
+    const targetStep = manifest.steps.find((step) => step.id === pending.nextStepId);
+    if (!targetStep) {
+      log(`PlaylistLoader: Pending navigation target step '${pending.nextStepId}' not found in manifest, clearing`);
+      storageManager2.clearPendingNavigation();
+      return null;
+    }
+    log(`PlaylistLoader: Using pending navigation to step '${pending.nextStepId}' (${Math.round(ageMs / 1e3)}s old)`);
+    storageManager2.clearPendingNavigation();
+    return pending;
+  }
+  /**
+   * Checks if the current URL path matches a pattern
+   * Uses the same logic as TransitionManager for consistency
+   * @param pattern - The URL pattern to match (supports wildcards)
+   * @returns true if the current URL matches the pattern
+   */
+  isURLPathMatch(pattern) {
+    if (!pattern) {
+      return false;
+    }
+    const currentUrl = window.location.href;
+    const currentPath = window.location.pathname;
+    const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regexPattern = escapedPattern.replace(/\\\*/g, ".*");
+    const regex = new RegExp(regexPattern);
+    const match = regex.test(currentUrl) || regex.test(currentPath);
+    return match;
+  }
 }
 class PlaylistManager extends EventSubscriberManager {
   /**
@@ -12306,7 +12469,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.3.60";
+const version = "0.3.62";
 const packageJson = {
   version
 };