saltfish 0.3.36 → 0.3.38

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

@@ -2846,9 +2846,9 @@ class PlaylistOrchestrator {
           this.managers.cursorManager.setColor(updatedStore.manifest.cursorColor);
         }
         const isTriggeredAutomatically = finalOptions._triggeredByTriggerManager === true;
-        if (updatedStore.manifest.idleMode) {
-          const isFirstStep = updatedStore.currentStepId === ((_e = updatedStore.manifest.steps[0]) == null ? void 0 : _e.id);
-          if (updatedStore.manifest.compactFirstStep && isFirstStep) {
+        const isFirstStep = updatedStore.currentStepId === ((_e = updatedStore.manifest.steps[0]) == null ? void 0 : _e.id);
+        if (updatedStore.manifest.idleMode && isFirstStep) {
+          if (updatedStore.manifest.compactFirstStep) {
             const playerElement = this.managers.uiManager.getPlayerElement();
             playerElement == null ? void 0 : playerElement.classList.add("sf-player--compact");
             if (updatedStore.manifest.compactLabel) {
@@ -2911,6 +2911,51 @@ 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");
@@ -3147,47 +3192,24 @@ class StateMachineActionHandler {
     if (!step.urlRequirement) {
       return true;
     }
-    const { pattern, matchType } = step.urlRequirement;
-    if (!pattern) {
-      return true;
-    }
-    const checkUrl = () => {
-      const currentUrl = window.location.href;
-      const currentPath = window.location.pathname;
-      let matches = false;
-      if (matchType === "regex") {
-        try {
-          const regex = new RegExp(pattern);
-          matches = regex.test(currentUrl) || regex.test(currentPath);
-        } catch (error2) {
-        }
-      } else if (matchType === "contains") {
-        matches = currentUrl.includes(pattern) || currentPath.includes(pattern);
-      } else {
-        matches = currentUrl === pattern || currentPath === pattern;
-      }
-      return matches;
-    };
-    const maxRetries = 20;
-    const retryDelay = 100;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      if (checkUrl()) {
-        return true;
-      }
-      if (attempt < maxRetries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        const saltfishPlayer2 = window._saltfishPlayer;
-        if (!saltfishPlayer2) {
-          return false;
+    log(`StateMachineActionHandler: Validating URL requirement for step ${step.id} with retry logic`);
+    this.managers.transitionManager.startStateMachineValidation();
+    try {
+      const isValid = await validateUrlRequirementWithRetry(step.urlRequirement);
+      if (!isValid) {
+        log(`StateMachineActionHandler: URL requirement validation failed for step '${step.id}'`);
+        log(`StateMachineActionHandler: Exiting playlist and closing player`);
+        const saltfishPlayer = window._saltfishPlayer;
+        if (saltfishPlayer && typeof saltfishPlayer.destroy === "function") {
+          saltfishPlayer.destroy();
+        } else {
+          log("StateMachineActionHandler: Warning - Could not find SaltfishPlayer instance to destroy");
         }
       }
+      return isValid;
+    } finally {
+      this.managers.transitionManager.endStateMachineValidation();
     }
-    log(`StateMachineActionHandler: URL requirement validation failed after ${maxRetries} retries for step '${step.id}'`);
-    const saltfishPlayer = window._saltfishPlayer;
-    if (saltfishPlayer && typeof saltfishPlayer.destroy === "function") {
-      saltfishPlayer.destroy();
-    }
-    return false;
   }
   // Private action handler methods
   async handleStartVideoPlayback(context) {
@@ -8240,7 +8262,10 @@ class InteractionManager {
                   anonymousData.watchedPlaylists[currentStore.manifest.id] = {
                     status: "in_progress",
                     currentStepId: buttonConfig.action.target,
+                    timestamp: Date.now(),
+                    // Use timestamp for consistency with checkAndResumeInProgressPlaylist
                     lastProgressAt: Date.now()
+                    // Keep for backward compatibility
                   };
                   this.storageManager.setAnonymousUserData(anonymousData);
                   log(`InteractionManager: Updated anonymous user watchedPlaylists for step ${buttonConfig.action.target}`);
@@ -8878,12 +8903,17 @@ class TransitionManager {
     __publicField(this, "activeTransitions", /* @__PURE__ */ new Map());
     // Track current transition state
     __publicField(this, "waitingForInteraction", false);
+    // Track when StateMachineActionHandler is validating to avoid race conditions
+    __publicField(this, "isStateMachineValidating", false);
     // Reference to TriggerManager for coordinating playlist triggers
     __publicField(this, "triggerManager", null);
     /**
      * Handles URL changes by checking active URL path transitions and playlist triggers
      */
     __publicField(this, "handleURLChange", () => {
+      if (this.isStateMachineValidating) {
+        return;
+      }
       const urlPathTransitions = Array.from(this.activeTransitions.entries()).filter(([_, transition]) => {
         var _a;
         return ((_a = transition.data) == null ? void 0 : _a.type) === "url-path";
@@ -9156,37 +9186,6 @@ class TransitionManager {
     const pathMatch = regex.test(currentPath);
     return fullUrlMatch || pathMatch;
   }
-  /**
-   * Validates if the current URL matches a URL requirement
-   * @param urlRequirement - The URL requirement to validate against
-   * @returns true if URL matches, false otherwise
-   */
-  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(`TransitionManager: URL requirement validation (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;
-  }
   /**
    * Handles URL requirement validation failure by exiting and closing the playlist
    * @param stepId - The step ID that failed validation
@@ -9201,8 +9200,9 @@ class TransitionManager {
     }
   }
   /**
-   * Validates the URL requirement for the current step
-   * @returns true if validation passes or no requirement exists, false if validation fails
+   * Validates the URL requirement for the current step (immediate, no retries)
+   * Used for external navigation detection - should close immediately if URL doesn't match
+   * @returns boolean - true if validation passes or no requirement exists, false if validation fails
    */
   validateCurrentStepUrl() {
     const store = getSaltfishStore();
@@ -9215,7 +9215,7 @@ class TransitionManager {
     if (!currentStep || !currentStep.urlRequirement) {
       return true;
     }
-    const isValid = this.validateUrlRequirement(currentStep.urlRequirement);
+    const isValid = validateUrlRequirement(currentStep.urlRequirement);
     if (!isValid) {
       this.handleUrlRequirementFailure(currentStepId, currentStep.urlRequirement);
     }
@@ -9300,6 +9300,19 @@ class TransitionManager {
   reset() {
     this.cleanupTransitions();
   }
+  /**
+   * Marks the start of StateMachineActionHandler validation to prevent race conditions
+   * TransitionManager will skip validation while this flag is set
+   */
+  startStateMachineValidation() {
+    this.isStateMachineValidating = true;
+  }
+  /**
+   * Marks the end of StateMachineActionHandler validation
+   */
+  endStateMachineValidation() {
+    this.isStateMachineValidating = false;
+  }
   /**
    * Destroys the transition manager and cleans up resources
    */
@@ -11774,7 +11787,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.3.36";
+const version = "0.3.38";
 const packageJson = {
   version
 };