@ovineko/spa-guard 0.0.1-alpha-17 → 0.0.1-alpha-19

package/dist/_internal.d.ts

@@ -0,0 +1,19 @@
+export { debugSyncErrorEventType } from "./common/constants";
+export { disableDefaultRetry, emitEvent, enableDefaultRetry, isDefaultRetryEnabled, subscribe, } from "./common/events/internal";
+export type { SPAGuardEvent, SPAGuardEventChunkError, UnsubscribeFn } from "./common/events/types";
+export { handleErrorWithSpaGuard } from "./common/handleErrorWithSpaGuard";
+export type { ErrorInfoLike, HandleErrorOptions } from "./common/handleErrorWithSpaGuard";
+export { defaultErrorFallbackHtml, defaultLoadingFallbackHtml } from "./common/html.generated";
+export { applyI18n, getI18n } from "./common/i18n";
+export { isChunkError } from "./common/isChunkError";
+export { listenInternal } from "./common/listen/internal";
+export { logMessage } from "./common/log";
+export { createLogger } from "./common/logger";
+export { getOptions, optionsWindowKey } from "./common/options";
+export type { Options } from "./common/options";
+export { extractVersionFromHtml } from "./common/parseVersion";
+export { attemptReload } from "./common/reload";
+export { retryImport } from "./common/retryImport";
+export { serializeError } from "./common/serializeError";
+export { defaultSpinnerSvg, SPINNER_ID } from "./common/spinner";
+export { dispatchAsyncRuntimeError, dispatchChunkLoadError, dispatchFinallyError, dispatchForceRetryError, dispatchNetworkTimeout, dispatchSyncRuntimeError, dispatchUnhandledRejection, } from "./runtime/debug/errorDispatchers";

package/dist/_internal.js

@@ -0,0 +1,162 @@
+import {
+  attemptReload,
+  createLogger,
+  isChunkError,
+  listenInternal,
+  sendBeacon,
+  serializeError,
+  shouldForceRetry,
+  shouldIgnoreMessages
+} from "./chunk-4FKSMB5F.js";
+import {
+  SPINNER_ID,
+  defaultSpinnerSvg,
+  extractVersionFromHtml
+} from "./chunk-3ISQYZVD.js";
+import {
+  applyI18n,
+  defaultErrorFallbackHtml,
+  defaultLoadingFallbackHtml,
+  getI18n,
+  getOptions
+} from "./chunk-DOTM7FSY.js";
+import {
+  dispatchAsyncRuntimeError,
+  dispatchChunkLoadError,
+  dispatchFinallyError,
+  dispatchForceRetryError,
+  dispatchNetworkTimeout,
+  dispatchSyncRuntimeError,
+  dispatchUnhandledRejection
+} from "./chunk-74K44EMP.js";
+import {
+  debugSyncErrorEventType,
+  disableDefaultRetry,
+  emitEvent,
+  enableDefaultRetry,
+  getRetryInfoForBeacon,
+  isDefaultRetryEnabled,
+  optionsWindowKey,
+  subscribe
+} from "./chunk-YSKH5K6P.js";
+import "./chunk-MLKGABMK.js";
+
+// src/common/handleErrorWithSpaGuard.ts
+var handleErrorWithSpaGuard = (error, options) => {
+  const {
+    autoRetryChunkErrors = true,
+    errorInfo,
+    eventName,
+    onError,
+    sendBeaconOnError = true
+  } = options;
+  try {
+    onError?.(error);
+  } catch {
+  }
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (shouldIgnoreMessages([errorMessage])) {
+    return;
+  }
+  const isChunk = isChunkError(error);
+  const isForceRetry = shouldForceRetry([errorMessage]);
+  if ((isChunk || isForceRetry) && autoRetryChunkErrors) {
+    attemptReload(error);
+  } else if (sendBeaconOnError) {
+    sendBeacon({
+      errorMessage: error instanceof Error ? error.message : String(error),
+      eventName,
+      serialized: serializeError(errorInfo ? { error, errorInfo } : error),
+      ...getRetryInfoForBeacon()
+    });
+  }
+};
+
+// src/common/log.ts
+var logMessage = (msg) => `[spa-guard] ${msg}`;
+
+// src/common/retryImport.ts
+var wait = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timeoutId);
+    reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+  };
+  const timeoutId = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var retryImport = async (importFn, delays, options) => {
+  const { callReloadOnFailure, onRetry, signal } = options ?? {};
+  let lastError = new Error("Import failed after all retry attempts");
+  const totalAttempts = delays.length + 1;
+  for (let attempt = 0; attempt < totalAttempts; attempt++) {
+    if (signal?.aborted) {
+      throw signal.reason ?? new DOMException("Aborted", "AbortError");
+    }
+    try {
+      const result = await importFn();
+      if (attempt > 0) {
+        emitEvent({ attempt, name: "lazy-retry-success" });
+      }
+      return result;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const currentDelay = delays[attempt];
+      if (currentDelay === void 0) {
+        break;
+      }
+      onRetry?.(attempt + 1, currentDelay);
+      emitEvent({
+        attempt: attempt + 1,
+        delay: currentDelay,
+        name: "lazy-retry-attempt",
+        totalAttempts
+      });
+      await wait(currentDelay, signal);
+    }
+  }
+  const willReload = callReloadOnFailure === true && isChunkError(lastError) && isDefaultRetryEnabled();
+  emitEvent({ name: "lazy-retry-exhausted", totalAttempts, willReload });
+  if (willReload) {
+    attemptReload(lastError);
+  }
+  throw lastError;
+};
+export {
+  SPINNER_ID,
+  applyI18n,
+  attemptReload,
+  createLogger,
+  debugSyncErrorEventType,
+  defaultErrorFallbackHtml,
+  defaultLoadingFallbackHtml,
+  defaultSpinnerSvg,
+  disableDefaultRetry,
+  dispatchAsyncRuntimeError,
+  dispatchChunkLoadError,
+  dispatchFinallyError,
+  dispatchForceRetryError,
+  dispatchNetworkTimeout,
+  dispatchSyncRuntimeError,
+  dispatchUnhandledRejection,
+  emitEvent,
+  enableDefaultRetry,
+  extractVersionFromHtml,
+  getI18n,
+  getOptions,
+  handleErrorWithSpaGuard,
+  isChunkError,
+  isDefaultRetryEnabled,
+  listenInternal,
+  logMessage,
+  optionsWindowKey,
+  retryImport,
+  serializeError,
+  subscribe
+};

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

@@ -1,7 +1,20 @@
 import {
   defaultSpinnerHtml,
   getOptions
-} from "./chunk-KUC22DET.js";
+} from "./chunk-DOTM7FSY.js";
+
+// src/common/parseVersion.ts
+function extractVersionFromHtml(html) {
+  const collapsed = html.replaceAll(/[\r\n]+/g, "");
+  const versionMatch = collapsed.match(/__SPA_GUARD_VERSION__\s*=\s*"([^"]+)"/);
+  if (versionMatch?.[1]) {
+    return versionMatch[1];
+  }
+  const optionsMatch = collapsed.match(
+    /__SPA_GUARD_OPTIONS__\s*=\s*\{.*?"?version"?\s*:\s*"([^"]+)"/
+  );
+  return optionsMatch?.[1] ?? null;
+}
 
 // src/common/spinner.ts
 var SPINNER_ID = "__spa-guard-spinner";
@@ -32,6 +45,10 @@ function getSpinnerHtml(backgroundOverride) {
   return `<div id="${SPINNER_ID}" style="position:fixed;inset:0;z-index:2147483647;display:flex;align-items:center;justify-content:center;background:var(--spa-guard-spinner-bg,${bg})">${spinnerContent}</div>`;
 }
 function showSpinner(options) {
+  if (typeof document === "undefined") {
+    return () => {
+    };
+  }
   const opts = getOptions();
   if (opts.spinner?.disabled) {
     return () => {
@@ -58,6 +75,7 @@ function showSpinner(options) {
 }
 
 export {
+  extractVersionFromHtml,
   SPINNER_ID,
   defaultSpinnerSvg,
   dismissSpinner,