@ovineko/spa-guard 0.0.1-alpha-16 → 0.0.1-alpha-18

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-DCOE7VRF.js";
+import {
+  SPINNER_ID,
+  defaultSpinnerSvg,
+  extractVersionFromHtml
+} from "./chunk-EHIXY2ZY.js";
+import {
+  applyI18n,
+  defaultErrorFallbackHtml,
+  defaultLoadingFallbackHtml,
+  getI18n,
+  getOptions
+} from "./chunk-SHRE3V6T.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-74K44EMP.js

@@ -0,0 +1,50 @@
+import {
+  ForceRetryError,
+  debugSyncErrorEventType
+} from "./chunk-YSKH5K6P.js";
+
+// src/runtime/debug/errorDispatchers.ts
+function dispatchAsyncRuntimeError() {
+  setTimeout(() => {
+    throw new Error("Simulated runtime error from spa-guard debug panel");
+  }, 0);
+}
+function dispatchChunkLoadError() {
+  const error = new Error(
+    "Failed to fetch dynamically imported module: /nonexistent-chunk-" + Date.now() + ".js"
+  );
+  error.name = "ChunkLoadError";
+  void Promise.reject(error);
+}
+function dispatchFinallyError() {
+  void Promise.resolve().finally(() => {
+    throw new Error("Failed to fetch dynamically imported module: /finally-error-chunk.js");
+  });
+}
+function dispatchForceRetryError() {
+  void Promise.reject(new ForceRetryError("Simulated force-retry from spa-guard debug panel"));
+}
+function dispatchNetworkTimeout(delayMs = 3e3) {
+  setTimeout(() => {
+    void Promise.reject(new TypeError("NetworkError: request timed out"));
+  }, delayMs);
+}
+function dispatchSyncRuntimeError() {
+  const error = new Error("Simulated sync runtime error from spa-guard debug panel");
+  globalThis.dispatchEvent(new CustomEvent(debugSyncErrorEventType, { detail: { error } }));
+}
+function dispatchUnhandledRejection() {
+  void Promise.reject(
+    new Error("Simulated unhandled promise rejection from spa-guard debug panel")
+  );
+}
+
+export {
+  dispatchAsyncRuntimeError,
+  dispatchChunkLoadError,
+  dispatchFinallyError,
+  dispatchForceRetryError,
+  dispatchNetworkTimeout,
+  dispatchSyncRuntimeError,
+  dispatchUnhandledRejection
+};