@ovineko/spa-guard 0.0.1-alpha-23 → 0.0.1-alpha-25

package/dist/_internal.js

@@ -1,25 +1,14 @@
 import {
-  attemptReload,
   createLogger,
   isChunkError,
   listenInternal,
-  sendBeacon,
-  serializeError,
-  shouldForceRetry,
-  shouldIgnoreMessages
-} from "./chunk-4FKSMB5F.js";
+  serializeError
+} from "./chunk-ZVYB2746.js";
 import {
   SPINNER_ID,
   defaultSpinnerSvg,
   extractVersionFromHtml
-} from "./chunk-3ISQYZVD.js";
-import {
-  applyI18n,
-  defaultErrorFallbackHtml,
-  defaultLoadingFallbackHtml,
-  getI18n,
-  getOptions
-} from "./chunk-DOTM7FSY.js";
+} from "./chunk-Z75UPJWV.js";
 import {
   dispatchAsyncRuntimeError,
   dispatchChunkLoadError,
@@ -28,17 +17,28 @@ import {
   dispatchNetworkTimeout,
   dispatchSyncRuntimeError,
   dispatchUnhandledRejection
-} from "./chunk-74K44EMP.js";
+} from "./chunk-XFILAQ7P.js";
 import {
+  attemptReload,
+  sendBeacon,
+  shouldForceRetry,
+  shouldIgnoreMessages
+} from "./chunk-CSN7MQGX.js";
+import {
+  applyI18n,
   debugSyncErrorEventType,
+  defaultErrorFallbackHtml,
+  defaultLoadingFallbackHtml,
   disableDefaultRetry,
   emitEvent,
   enableDefaultRetry,
+  getI18n,
+  getOptions,
   getRetryInfoForBeacon,
   isDefaultRetryEnabled,
   optionsWindowKey,
   subscribe
-} from "./chunk-YSKH5K6P.js";
+} from "./chunk-X6E7KUDK.js";
 import "./chunk-MLKGABMK.js";
 
 // src/common/handleErrorWithSpaGuard.ts

package/dist/chunk-CSN7MQGX.js

@@ -0,0 +1,295 @@
+import {
+  FORCE_RETRY_MAGIC,
+  RETRY_ATTEMPT_PARAM,
+  RETRY_ID_PARAM,
+  applyI18n,
+  clearLastReloadTime,
+  clearRetryAttemptFromUrl,
+  clearRetryStateFromUrl,
+  emitEvent,
+  generateRetryId,
+  getI18n,
+  getLastReloadTime,
+  getLogger,
+  getOptions,
+  getRetryAttemptFromUrl,
+  getRetryStateFromUrl,
+  isDefaultRetryEnabled,
+  setLastReloadTime,
+  setLastRetryResetInfo,
+  shouldResetRetryCycle
+} from "./chunk-X6E7KUDK.js";
+
+// src/common/shouldIgnore.ts
+var shouldIgnoreMessages = (messages) => {
+  const options = getOptions();
+  const ignorePatterns = (options.errors?.ignore ?? []).filter((p) => p !== "");
+  if (ignorePatterns.length === 0) {
+    return false;
+  }
+  const validMessages = messages.filter((msg) => typeof msg === "string");
+  return validMessages.some(
+    (message) => ignorePatterns.some((pattern) => message.includes(pattern))
+  );
+};
+var shouldForceRetry = (messages) => {
+  const options = getOptions();
+  const forceRetryPatterns = [...options.errors?.forceRetry ?? [], FORCE_RETRY_MAGIC].filter(
+    (p) => p !== ""
+  );
+  const validMessages = messages.filter((msg) => typeof msg === "string");
+  return validMessages.some(
+    (message) => forceRetryPatterns.some((pattern) => message.includes(pattern))
+  );
+};
+var shouldIgnoreBeacon = (beacon) => {
+  return shouldIgnoreMessages([beacon.errorMessage, beacon.eventMessage]);
+};
+
+// src/common/sendBeacon.ts
+var sendBeacon = (beacon) => {
+  if (shouldIgnoreBeacon(beacon)) {
+    return;
+  }
+  const options = getOptions();
+  if (!options.reportBeacon?.endpoint) {
+    getLogger()?.noBeaconEndpoint();
+    return;
+  }
+  const enrichedBeacon = options.appName ? { ...beacon, appName: options.appName } : beacon;
+  const body = JSON.stringify(enrichedBeacon);
+  const isSendBeaconAvailable = typeof globalThis.window?.navigator?.sendBeacon === "function";
+  const isSentBeacon = isSendBeaconAvailable && globalThis.window.navigator.sendBeacon(options.reportBeacon.endpoint, body);
+  if (!isSentBeacon && typeof fetch === "function") {
+    fetch(options.reportBeacon.endpoint, { body, keepalive: true, method: "POST" }).catch(
+      (error) => {
+        getLogger()?.beaconSendFailed(error);
+      }
+    );
+  }
+};
+
+// src/common/reload.ts
+var buildReloadUrl = (retryId, retryAttempt) => {
+  const url = new URL(globalThis.window.location.href);
+  url.searchParams.set(RETRY_ID_PARAM, retryId);
+  url.searchParams.set(RETRY_ATTEMPT_PARAM, String(retryAttempt));
+  return url.toString();
+};
+var buildReloadUrlAttemptOnly = (retryAttempt) => {
+  const url = new URL(globalThis.window.location.href);
+  url.searchParams.set(RETRY_ATTEMPT_PARAM, String(retryAttempt));
+  return url.toString();
+};
+var reloadScheduled = false;
+var attemptReload = (error) => {
+  if (reloadScheduled) {
+    getLogger()?.reloadAlreadyScheduled(error);
+    return;
+  }
+  reloadScheduled = true;
+  try {
+    const options = getOptions();
+    const reloadDelays = options.reloadDelays ?? [1e3, 2e3, 5e3];
+    const useRetryId = options.useRetryId ?? true;
+    const enableRetryReset = options.enableRetryReset ?? true;
+    const minTimeBetweenResets = options.minTimeBetweenResets ?? 5e3;
+    let retryState;
+    if (useRetryId) {
+      retryState = getRetryStateFromUrl();
+    } else {
+      const attempt = getRetryAttemptFromUrl();
+      retryState = attempt === null ? null : { retryAttempt: attempt, retryId: generateRetryId() };
+    }
+    let currentAttempt = retryState ? retryState.retryAttempt : 0;
+    let retryId = retryState?.retryId ?? generateRetryId();
+    getLogger()?.retryCycleStarting(retryId, currentAttempt);
+    const retryEnabled = isDefaultRetryEnabled();
+    emitEvent({
+      error,
+      isRetrying: retryEnabled && currentAttempt >= 0 && currentAttempt < reloadDelays.length,
+      name: "chunk-error"
+    });
+    if (!retryEnabled) {
+      reloadScheduled = false;
+      return;
+    }
+    if (enableRetryReset && retryState && retryState.retryAttempt > 0 && shouldResetRetryCycle(retryState, reloadDelays, minTimeBetweenResets)) {
+      const lastReload = getLastReloadTime();
+      const timeSinceReload = lastReload ? Date.now() - lastReload.timestamp : 0;
+      clearRetryStateFromUrl();
+      clearLastReloadTime();
+      setLastRetryResetInfo(retryState.retryId);
+      const errorMsg2 = String(error);
+      emitEvent(
+        {
+          name: "retry-reset",
+          previousAttempt: retryState.retryAttempt,
+          previousRetryId: retryState.retryId,
+          timeSinceReload
+        },
+        { silent: shouldIgnoreMessages([errorMsg2]) }
+      );
+      currentAttempt = 0;
+      retryId = generateRetryId();
+    }
+    if (currentAttempt === -1) {
+      const errorMsg2 = String(error);
+      if (!shouldIgnoreMessages([errorMsg2])) {
+        getLogger()?.fallbackAlreadyShown(error);
+      }
+      reloadScheduled = false;
+      showFallbackUI();
+      return;
+    }
+    if (currentAttempt >= reloadDelays.length) {
+      const errorMsg2 = String(error);
+      emitEvent(
+        {
+          finalAttempt: currentAttempt,
+          name: "retry-exhausted",
+          retryId: retryState?.retryId ?? ""
+        },
+        { silent: shouldIgnoreMessages([errorMsg2]) }
+      );
+      sendBeacon({
+        errorMessage: "Exceeded maximum reload attempts",
+        eventName: "chunk_error_max_reloads",
+        retryAttempt: currentAttempt,
+        retryId: retryState?.retryId,
+        serialized: JSON.stringify({
+          error: String(error),
+          retryAttempt: currentAttempt,
+          retryId: retryState?.retryId
+        })
+      });
+      if (!useRetryId) {
+        clearRetryAttemptFromUrl();
+      }
+      reloadScheduled = false;
+      showFallbackUI();
+      return;
+    }
+    const nextAttempt = currentAttempt + 1;
+    const delay = reloadDelays[currentAttempt] ?? 1e3;
+    const errorMsg = String(error);
+    emitEvent(
+      {
+        attempt: nextAttempt,
+        delay,
+        name: "retry-attempt",
+        retryId
+      },
+      { silent: shouldIgnoreMessages([errorMsg]) }
+    );
+    getLogger()?.retrySchedulingReload(retryId, nextAttempt, delay);
+    showLoadingUI(nextAttempt);
+    setTimeout(() => {
+      if (useRetryId && enableRetryReset) {
+        setLastReloadTime(retryId, nextAttempt);
+      }
+      if (useRetryId) {
+        const reloadUrl = buildReloadUrl(retryId, nextAttempt);
+        globalThis.window.location.href = reloadUrl;
+      } else {
+        globalThis.window.location.href = buildReloadUrlAttemptOnly(nextAttempt);
+      }
+    }, delay);
+  } catch {
+    reloadScheduled = false;
+  }
+};
+var showLoadingUI = (attempt) => {
+  const options = getOptions();
+  const loadingHtml = options.html?.loading?.content;
+  const selector = options.html?.fallback?.selector ?? "body";
+  if (!loadingHtml) {
+    return;
+  }
+  try {
+    const targetElement = document.querySelector(selector);
+    if (!targetElement) {
+      return;
+    }
+    const container = document.createElement("div");
+    container.innerHTML = loadingHtml;
+    const spinnerEl = container.querySelector("[data-spa-guard-spinner]");
+    if (spinnerEl) {
+      if (options.spinner?.disabled) {
+        spinnerEl.remove();
+      } else if (options.spinner?.content) {
+        spinnerEl.innerHTML = options.spinner.content;
+      }
+    }
+    const retryingSection = container.querySelector(
+      '[data-spa-guard-section="retrying"]'
+    );
+    if (retryingSection) {
+      retryingSection.style.display = "block";
+    }
+    const attemptEl = container.querySelector('[data-spa-guard-content="attempt"]');
+    if (attemptEl) {
+      attemptEl.textContent = String(attempt);
+    }
+    const t = getI18n();
+    if (t) {
+      applyI18n(container, t);
+    }
+    targetElement.innerHTML = container.innerHTML;
+  } catch {
+  }
+};
+var showFallbackUI = () => {
+  const options = getOptions();
+  const fallbackHtml = options.html?.fallback?.content;
+  const selector = options.html?.fallback?.selector ?? "body";
+  if (!fallbackHtml) {
+    getLogger()?.noFallbackConfigured();
+    return;
+  }
+  try {
+    const targetElement = document.querySelector(selector);
+    if (!targetElement) {
+      getLogger()?.fallbackTargetNotFound(selector);
+      return;
+    }
+    const container = document.createElement("div");
+    container.innerHTML = fallbackHtml;
+    const t = getI18n();
+    if (t) {
+      applyI18n(container, t);
+    }
+    targetElement.innerHTML = container.innerHTML;
+    const useRetryId = options.useRetryId ?? true;
+    const retryState = getRetryStateFromUrl();
+    if (retryState && retryState.retryAttempt === -1) {
+      getLogger()?.clearingRetryState();
+      clearRetryStateFromUrl();
+    } else if (!useRetryId && !retryState) {
+      clearRetryAttemptFromUrl();
+    }
+    const reloadBtn = targetElement.querySelector('[data-spa-guard-action="reload"]');
+    if (reloadBtn) {
+      reloadBtn.addEventListener("click", () => location.reload());
+    }
+    if (retryState) {
+      const retryIdElements = document.getElementsByClassName("spa-guard-retry-id");
+      for (const element of retryIdElements) {
+        element.textContent = retryState.retryId;
+      }
+    }
+    emitEvent({
+      name: "fallback-ui-shown"
+    });
+  } catch (error) {
+    getLogger()?.fallbackInjectFailed(error);
+  }
+};
+
+export {
+  shouldIgnoreMessages,
+  shouldForceRetry,
+  sendBeacon,
+  attemptReload,
+  showFallbackUI
+};

package/dist/{chunk-SZS6GOPK.js → chunk-T72DERME.js}

@@ -3,7 +3,7 @@ import {
   getRetryAttemptFromUrl,
   getRetryStateFromUrl,
   subscribe
-} from "./chunk-YSKH5K6P.js";
+} from "./chunk-X6E7KUDK.js";
 
 // src/runtime/state.ts
 var getInitialStateFromUrl = () => {

package/dist/{chunk-YSKH5K6P.js → chunk-X6E7KUDK.js}

@@ -1,3 +1,7 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
 // package.json
 var name = "@ovineko/spa-guard";
 
@@ -9,6 +13,7 @@ var initializedKey = /* @__PURE__ */ Symbol.for(`${name}:initialized`);
 var loggerWindowKey = /* @__PURE__ */ Symbol.for(`${name}:logger`);
 var RETRY_ID_PARAM = "spaGuardRetryId";
 var RETRY_ATTEMPT_PARAM = "spaGuardRetryAttempt";
+var versionCheckStateWindowKey = /* @__PURE__ */ Symbol.for(`${name}:version-check-state`);
 var debugSyncErrorEventType = "spa-guard:debug-sync-error";
 
 // src/common/events/internal.ts
@@ -68,6 +73,152 @@ var isDefaultRetryEnabled = () => {
   return internalConfig.defaultRetryEnabled;
 };
 
+// src/common/i18n.ts
+function applyI18n(container, t) {
+  const contentEls = container.querySelectorAll("[data-spa-guard-content]");
+  for (const el of contentEls) {
+    const key = el.dataset.spaGuardContent;
+    if (key && key in t) {
+      const value = t[key];
+      if (typeof value === "string") {
+        el.textContent = value;
+      }
+    }
+  }
+  const actionEls = container.querySelectorAll("[data-spa-guard-action]");
+  for (const el of actionEls) {
+    const action = el.dataset.spaGuardAction;
+    const tKey = action === "try-again" ? "tryAgain" : action;
+    if (tKey && tKey in t) {
+      const value = t[tKey];
+      if (typeof value === "string") {
+        el.textContent = value;
+      }
+    }
+  }
+  if (t.rtl) {
+    for (const child of container.children) {
+      if (child instanceof HTMLElement && child.tagName !== "STYLE") {
+        child.style.direction = "rtl";
+      }
+    }
+  }
+}
+function getI18n() {
+  try {
+    const el = document.querySelector('meta[name="spa-guard-i18n"]');
+    if (!el) {
+      return null;
+    }
+    const content = el.getAttribute("content");
+    if (!content) {
+      return null;
+    }
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function setTranslations(translations) {
+  let el = document.querySelector('meta[name="spa-guard-i18n"]');
+  if (!el) {
+    el = document.createElement("meta");
+    el.setAttribute("name", "spa-guard-i18n");
+    document.head.append(el);
+  }
+  el.setAttribute("content", JSON.stringify(translations));
+}
+
+// src/common/html.generated.ts
+var defaultErrorFallbackHtml = `<style>.spa-guard-error-id:has(.spa-guard-retry-id:empty){display:none}.spa-guard-error-id{font-family:ui-monospace,SFMono-Regular,Consolas,"Liberation Mono",Menlo,monospace}</style><div style="display:flex;align-items:center;justify-content:center;min-height:100vh;padding:2rem;font-family:system-ui,sans-serif"><div style="text-align:center;max-width:480px"><div style="margin-bottom:1.5rem"><svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" fill="none" viewBox="0 0 24 24" stroke="#b0b0b0" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="8" x2="12" y2="12"/><line x1="12" y1="16" x2="12.01" y2="16"/></svg></div><h1 data-spa-guard-content="heading" style="font-size:1.375rem;font-weight:600;margin:0 0 .5rem;color:#1a1a1a;line-height:1.3">Something went wrong</h1><p data-spa-guard-content="message" style="max-width:600px;margin:0 auto 1.5rem;color:#666;font-size:.9375rem;line-height:1.5">Please refresh the page to continue.</p><div style="display:flex;gap:.5rem;justify-content:center;flex-wrap:wrap"><button data-spa-guard-action="try-again" type="button" style="display:none;padding:.5rem 1.25rem;font-size:.875rem;font-family:inherit;border-radius:6px;border:1px solid #d0d0d0;background:#fff;color:#333;cursor:pointer;line-height:1.5">Try again</button> <button data-spa-guard-action="reload" type="button" style="padding:.5rem 1.25rem;font-size:.875rem;font-family:inherit;border-radius:6px;border:1px solid transparent;background:#111;color:#fff;cursor:pointer;line-height:1.5">Reload page</button></div><p class="spa-guard-error-id" style="margin-top:1.5rem;font-size:.6875rem;color:#999">Error ID: <span class="spa-guard-retry-id"></span></p></div></div>`;
+var defaultLoadingFallbackHtml = `<div style="display:flex;align-items:center;justify-content:center;min-height:100vh;padding:2rem;font-family:system-ui,sans-serif"><div style="text-align:center"><div data-spa-guard-spinner style="margin-bottom:1.25rem"></div><h2 data-spa-guard-content="loading" style="font-size:1.125rem;font-weight:600;margin:0 0 .25rem;color:#1a1a1a">Loading...</h2><p data-spa-guard-section="retrying" style="display:none;font-size:.8125rem;color:#999;margin:.5rem 0 0"><span data-spa-guard-content="retrying">Retry attempt</span> <span data-spa-guard-content="attempt"></span></p></div></div>`;
+var defaultSpinnerHtml = `<svg width="40" height="40" viewBox="0 0 40 40" style="animation:spa-guard-spin .8s linear infinite"><circle cx="20" cy="20" r="16" fill="none" stroke="#e8e8e8" stroke-width="3"/><circle cx="20" cy="20" r="16" fill="none" stroke="#666" stroke-width="3" stroke-dasharray="80" stroke-dashoffset="60" stroke-linecap="round"/></svg><style>@keyframes spa-guard-spin{to{transform:rotate(360deg)}}</style>`;
+
+// src/common/options.ts
+var options_exports = {};
+__export(options_exports, {
+  getOptions: () => getOptions,
+  optionsWindowKey: () => optionsWindowKey
+});
+var defaultOptions = {
+  checkVersion: {
+    cache: "no-store",
+    interval: 3e5,
+    mode: "html",
+    onUpdate: "reload"
+  },
+  enableRetryReset: true,
+  errors: {
+    forceRetry: [],
+    ignore: []
+  },
+  handleUnhandledRejections: {
+    retry: true,
+    sendBeacon: true
+  },
+  html: {
+    fallback: {
+      content: defaultErrorFallbackHtml,
+      selector: "body"
+    },
+    loading: {
+      content: defaultLoadingFallbackHtml
+    }
+  },
+  lazyRetry: {
+    callReloadOnFailure: true,
+    retryDelays: [1e3, 2e3]
+  },
+  minTimeBetweenResets: 5e3,
+  reloadDelays: [1e3, 2e3, 5e3],
+  spinner: {
+    background: "#fff",
+    disabled: false
+  },
+  useRetryId: true
+};
+var getOptions = () => {
+  const windowOptions = globalThis.window?.[optionsWindowKey];
+  return {
+    ...defaultOptions,
+    ...windowOptions,
+    checkVersion: {
+      ...defaultOptions.checkVersion,
+      ...windowOptions?.checkVersion
+    },
+    errors: {
+      ...defaultOptions.errors,
+      ...windowOptions?.errors
+    },
+    handleUnhandledRejections: {
+      ...defaultOptions.handleUnhandledRejections,
+      ...windowOptions?.handleUnhandledRejections
+    },
+    html: {
+      fallback: {
+        ...defaultOptions.html?.fallback,
+        ...windowOptions?.html?.fallback
+      },
+      loading: {
+        ...defaultOptions.html?.loading,
+        ...windowOptions?.html?.loading
+      }
+    },
+    lazyRetry: {
+      ...defaultOptions.lazyRetry,
+      ...windowOptions?.lazyRetry
+    },
+    reportBeacon: {
+      ...defaultOptions.reportBeacon,
+      ...windowOptions?.reportBeacon
+    },
+    spinner: {
+      ...defaultOptions.spinner,
+      ...windowOptions?.spinner
+    }
+  };
+};
+
 // src/common/errors/ForceRetryError.ts
 var FORCE_RETRY_MAGIC = "__SPA_GUARD_FORCE_RETRY__";
 var ForceRetryError = class extends Error {
@@ -269,6 +420,7 @@ export {
   optionsWindowKey,
   RETRY_ID_PARAM,
   RETRY_ATTEMPT_PARAM,
+  versionCheckStateWindowKey,
   debugSyncErrorEventType,
   setLogger,
   getLogger,
@@ -279,12 +431,20 @@ export {
   disableDefaultRetry,
   enableDefaultRetry,
   isDefaultRetryEnabled,
+  applyI18n,
+  getI18n,
+  setTranslations,
   setLastReloadTime,
   getLastReloadTime,
   clearLastReloadTime,
   shouldResetRetryCycle,
   setLastRetryResetInfo,
   getLastRetryResetInfo,
+  defaultErrorFallbackHtml,
+  defaultLoadingFallbackHtml,
+  defaultSpinnerHtml,
+  getOptions,
+  options_exports,
   getRetryStateFromUrl,
   clearRetryStateFromUrl,
   updateRetryStateInUrl,

package/dist/{chunk-74K44EMP.js → chunk-XFILAQ7P.js}

@@ -1,7 +1,12 @@
+import {
+  showFallbackUI
+} from "./chunk-CSN7MQGX.js";
 import {
   ForceRetryError,
-  debugSyncErrorEventType
-} from "./chunk-YSKH5K6P.js";
+  debugSyncErrorEventType,
+  emitEvent,
+  getOptions
+} from "./chunk-X6E7KUDK.js";
 
 // src/runtime/debug/errorDispatchers.ts
 function dispatchAsyncRuntimeError() {
@@ -29,6 +34,16 @@ function dispatchNetworkTimeout(delayMs = 3e3) {
     void Promise.reject(new TypeError("NetworkError: request timed out"));
   }, delayMs);
 }
+function dispatchRetryExhausted() {
+  const options = getOptions();
+  const reloadDelays = options.reloadDelays ?? [1e3, 2e3, 5e3];
+  emitEvent({
+    finalAttempt: reloadDelays.length,
+    name: "retry-exhausted",
+    retryId: ""
+  });
+  showFallbackUI();
+}
 function dispatchSyncRuntimeError() {
   const error = new Error("Simulated sync runtime error from spa-guard debug panel");
   globalThis.dispatchEvent(new CustomEvent(debugSyncErrorEventType, { detail: { error } }));
@@ -45,6 +60,7 @@ export {
   dispatchFinallyError,
   dispatchForceRetryError,
   dispatchNetworkTimeout,
+  dispatchRetryExhausted,
   dispatchSyncRuntimeError,
   dispatchUnhandledRejection
 };

package/dist/{chunk-3ISQYZVD.js → chunk-Z75UPJWV.js}

@@ -1,7 +1,7 @@
 import {
   defaultSpinnerHtml,
   getOptions
-} from "./chunk-DOTM7FSY.js";
+} from "./chunk-X6E7KUDK.js";
 
 // src/common/parseVersion.ts
 function extractVersionFromHtml(html) {