@ovineko/spa-guard 0.0.1-alpha-1

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-VWV6L4Q2.js

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// package.json
+var name = "@ovineko/spa-guard";
+
+// src/common/constants.ts
+var optionsWindowKey = "__SPA_GUARD_OPTIONS__";
+var eventSubscribersWindowKey = /* @__PURE__ */ Symbol.for(`${name}:event-subscribers`);
+var internalConfigWindowKey = /* @__PURE__ */ Symbol.for(`${name}:internal-config`);
+var RETRY_ID_PARAM = "spaGuardRetryId";
+var RETRY_ATTEMPT_PARAM = "spaGuardRetryAttempt";
+
+// src/common/options.ts
+var options_exports = {};
+__export(options_exports, {
+  getOptions: () => getOptions,
+  optionsWindowKey: () => optionsWindowKey
+});
+
+// src/common/fallbackHtml.generated.ts
+var defaultFallbackHtml = `<div style="display:flex;align-items:center;justify-content:center;height:100vh;font-family:sans-serif"><div style="text-align:center"><h1>Something went wrong</h1><p>Please refresh the page to continue.</p><button onclick="location.reload()">Refresh Page</button></div></div>`;
+
+// src/common/options.ts
+var defaultOptions = {
+  fallbackHtml: defaultFallbackHtml,
+  reloadDelays: [1e3, 2e3, 5e3],
+  useRetryId: true
+};
+var getOptions = () => {
+  const windowOptions = globalThis.window?.[optionsWindowKey];
+  return {
+    ...defaultOptions,
+    ...windowOptions,
+    reportBeacon: {
+      ...defaultOptions.reportBeacon,
+      ...windowOptions?.reportBeacon
+    }
+  };
+};
+
+export {
+  name,
+  optionsWindowKey,
+  eventSubscribersWindowKey,
+  RETRY_ID_PARAM,
+  RETRY_ATTEMPT_PARAM,
+  getOptions,
+  options_exports
+};

package/dist/chunk-W65YKSMF.js

@@ -0,0 +1,6 @@
+// src/common/log.ts
+var logMessage = (msg) => `[spa-guard] ${msg}`;
+
+export {
+  logMessage
+};

package/dist/chunk-XV2YCVOR.js

@@ -0,0 +1,12 @@
+// src/schema/index.ts
+import Type from "typebox";
+var beaconSchema = Type.Object({
+  errorMessage: Type.Optional(Type.String()),
+  eventMessage: Type.Optional(Type.String()),
+  eventName: Type.Optional(Type.String()),
+  serialized: Type.Optional(Type.String())
+});
+
+export {
+  beaconSchema
+};

package/dist/common/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const optionsWindowKey = "__SPA_GUARD_OPTIONS__";
+export declare const eventSubscribersWindowKey: unique symbol;
+export declare const internalConfigWindowKey: unique symbol;
+export declare const RETRY_ID_PARAM = "spaGuardRetryId";
+export declare const RETRY_ATTEMPT_PARAM = "spaGuardRetryAttempt";

package/dist/common/events/index.d.ts

@@ -0,0 +1,2 @@
+export { subscribe } from "./internal";
+export * from "./types";

package/dist/common/events/internal.d.ts

@@ -0,0 +1,4 @@
+import type { SPAGuardEvent, SubscribeFn, UnsubscribeFn } from "./types";
+export declare const subscribers: Set<SubscribeFn>;
+export declare const emitEvent: (event: SPAGuardEvent) => void;
+export declare const subscribe: (cb: SubscribeFn) => UnsubscribeFn;

package/dist/common/events/types.d.ts

@@ -0,0 +1,8 @@
+export type SPAGuardEvent = SPAGuardEventTest & {
+    name: "test";
+};
+export interface SPAGuardEventTest {
+    name: "test";
+}
+export type SubscribeFn = (event: SPAGuardEvent) => void;
+export type UnsubscribeFn = () => void;

package/dist/common/fallbackHtml.generated.d.ts

@@ -0,0 +1 @@
+export declare const defaultFallbackHtml = "<div style=\"display:flex;align-items:center;justify-content:center;height:100vh;font-family:sans-serif\"><div style=\"text-align:center\"><h1>Something went wrong</h1><p>Please refresh the page to continue.</p><button onclick=\"location.reload()\">Refresh Page</button></div></div>";

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+export * as events from "./events";
+export { listen } from "./listen";
+export * as options from "./options";

package/dist/common/index.js

@@ -0,0 +1,358 @@
+import {
+  logMessage
+} from "../chunk-W65YKSMF.js";
+import {
+  RETRY_ATTEMPT_PARAM,
+  RETRY_ID_PARAM,
+  eventSubscribersWindowKey,
+  getOptions,
+  options_exports
+} from "../chunk-VWV6L4Q2.js";
+import {
+  __export
+} from "../chunk-MLKGABMK.js";
+
+// src/common/events/index.ts
+var events_exports = {};
+__export(events_exports, {
+  subscribe: () => subscribe
+});
+
+// src/common/events/internal.ts
+if (globalThis.window && !globalThis.window[eventSubscribersWindowKey]) {
+  globalThis.window[eventSubscribersWindowKey] = /* @__PURE__ */ new Set();
+}
+var subscribers = globalThis.window?.[eventSubscribersWindowKey] ?? /* @__PURE__ */ new Set();
+var emitEvent = (event) => {
+  subscribers.forEach((cb) => cb(event));
+};
+var subscribe = (cb) => {
+  subscribers.add(cb);
+  return () => subscribers.delete(cb);
+};
+
+// src/common/isChunkError.ts
+var isChunkError = (error) => {
+  const message = getErrorMessage(error);
+  if (!message) {
+    return false;
+  }
+  const patterns = [
+    /Failed to fetch dynamically imported module/i,
+    /Importing a module script failed/i,
+    /error loading dynamically imported module/i,
+    /Unable to preload CSS/i,
+    /Loading chunk \d+ failed/i,
+    /Loading CSS chunk \d+ failed/i,
+    /ChunkLoadError/i,
+    /Failed to fetch/i,
+    /NaN/i
+  ];
+  return patterns.some((pattern) => pattern.test(message));
+};
+var getErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  if (error && typeof error === "object" && "reason" in error) {
+    return getErrorMessage(error.reason);
+  }
+  return null;
+};
+
+// src/common/sendBeacon.ts
+var sendBeacon = (beacon) => {
+  const options = getOptions();
+  if (!options.reportBeacon?.endpoint) {
+    console.warn(logMessage("Report endpoint is not configured"));
+    return;
+  }
+  const body = JSON.stringify(beacon);
+  const isSendBeaconAvailable = typeof globalThis.window?.navigator.sendBeacon === "function";
+  const isSentBeacon = isSendBeaconAvailable && navigator.sendBeacon(options.reportBeacon.endpoint, body);
+  if (!isSentBeacon) {
+    fetch(options.reportBeacon.endpoint, { body, keepalive: true, method: "POST" }).catch(
+      (error) => {
+        console.error(logMessage("Failed to send beacon:"), error);
+      }
+    );
+  }
+};
+
+// src/common/reload.ts
+var getRetryStateFromUrl = () => {
+  try {
+    const params = new URLSearchParams(window.location.search);
+    const retryId = params.get(RETRY_ID_PARAM);
+    const retryAttempt = params.get(RETRY_ATTEMPT_PARAM);
+    if (retryId && retryAttempt) {
+      return {
+        retryAttempt: parseInt(retryAttempt, 10),
+        retryId
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var generateRetryId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const array = new Uint32Array(2);
+    crypto.getRandomValues(array);
+    return `${Date.now()}-${array[0].toString(36)}${array[1].toString(36)}`;
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 15)}`;
+};
+var buildReloadUrl = (retryId, retryAttempt) => {
+  const url = new URL(window.location.href);
+  url.searchParams.set(RETRY_ID_PARAM, retryId);
+  url.searchParams.set(RETRY_ATTEMPT_PARAM, String(retryAttempt));
+  return url.toString();
+};
+var attemptReload = (error) => {
+  const options = getOptions();
+  const reloadDelays = options.reloadDelays ?? [1e3, 2e3, 5e3];
+  const useRetryId = options.useRetryId ?? true;
+  const retryState = useRetryId ? getRetryStateFromUrl() : null;
+  const currentAttempt = retryState ? retryState.retryAttempt : 0;
+  if (currentAttempt >= reloadDelays.length) {
+    console.error(logMessage("All reload attempts exhausted"), error);
+    sendBeacon({
+      errorMessage: "Exceeded maximum reload attempts",
+      eventName: "chunk_error_max_reloads",
+      serialized: JSON.stringify({
+        error: String(error),
+        retryAttempt: currentAttempt,
+        retryId: retryState?.retryId
+      })
+    });
+    showFallbackUI();
+    return;
+  }
+  const nextAttempt = currentAttempt + 1;
+  const retryId = retryState?.retryId ?? generateRetryId();
+  const delay = reloadDelays[currentAttempt];
+  console.warn(
+    logMessage(
+      `Reload attempt ${nextAttempt}/${reloadDelays.length} in ${delay}ms (retryId: ${retryId})`
+    ),
+    error
+  );
+  setTimeout(() => {
+    if (useRetryId) {
+      const reloadUrl = buildReloadUrl(retryId, nextAttempt);
+      window.location.href = reloadUrl;
+    } else {
+      window.location.reload();
+    }
+  }, delay);
+};
+var showFallbackUI = () => {
+  const options = getOptions();
+  const fallbackHtml = options.fallbackHtml;
+  if (!fallbackHtml) {
+    console.error(logMessage("No fallback UI configured"));
+    return;
+  }
+  try {
+    document.body.innerHTML = fallbackHtml;
+  } catch (error) {
+    console.error(logMessage("Failed to inject fallback UI"), error);
+  }
+};
+
+// src/common/serializeError.ts
+var serializeError = (error) => {
+  try {
+    const serialized = serializeErrorInternal(error);
+    return JSON.stringify(serialized, null, 2);
+  } catch {
+    return JSON.stringify({
+      error: "Failed to serialize error",
+      fallback: String(error)
+    });
+  }
+};
+var serializeErrorInternal = (error) => {
+  if (error === null || error === void 0) {
+    return { type: "null", value: error };
+  }
+  if (typeof error !== "object") {
+    return { type: typeof error, value: error };
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+      stack: error.stack,
+      type: "Error",
+      ...extractErrorProperties(error)
+    };
+  }
+  if ("reason" in error && "promise" in error) {
+    return {
+      reason: serializeErrorInternal(error.reason),
+      type: "PromiseRejectionEvent"
+    };
+  }
+  if ("error" in error && "message" in error && "filename" in error) {
+    return {
+      colno: error.colno,
+      error: serializeErrorInternal(error.error),
+      filename: error.filename,
+      lineno: error.lineno,
+      message: error.message,
+      type: "ErrorEvent"
+    };
+  }
+  if ("violatedDirective" in error && "blockedURI" in error) {
+    const evt = error;
+    return {
+      blockedURI: evt.blockedURI,
+      columnNumber: evt.columnNumber,
+      effectiveDirective: evt.effectiveDirective,
+      lineNumber: evt.lineNumber,
+      originalPolicy: evt.originalPolicy,
+      sourceFile: evt.sourceFile,
+      type: "SecurityPolicyViolationEvent",
+      violatedDirective: evt.violatedDirective
+    };
+  }
+  if ("type" in error && "target" in error) {
+    const evt = error;
+    return {
+      eventType: evt.type,
+      target: extractEventTarget(evt.target),
+      timeStamp: evt.timeStamp,
+      type: "Event"
+    };
+  }
+  return {
+    type: "object",
+    value: extractOwnProperties(error)
+  };
+};
+var extractErrorProperties = (error) => {
+  const props = {};
+  for (const key of Object.getOwnPropertyNames(error)) {
+    if (!["message", "name", "stack"].includes(key)) {
+      try {
+        props[key] = error[key];
+      } catch {
+      }
+    }
+  }
+  return props;
+};
+var extractEventTarget = (target) => {
+  if (!target) {
+    return null;
+  }
+  if (target instanceof HTMLElement) {
+    return {
+      className: target.className,
+      href: target.href,
+      id: target.id,
+      src: target.src,
+      tagName: target.tagName
+    };
+  }
+  return { type: String(target) };
+};
+var extractOwnProperties = (obj) => {
+  const props = {};
+  for (const key of Object.keys(obj)) {
+    try {
+      const value = obj[key];
+      props[key] = typeof value === "object" ? String(value) : value;
+    } catch {
+    }
+  }
+  return props;
+};
+
+// src/common/listen/internal.ts
+var listenInternal = () => {
+  emitEvent({ name: "test" });
+  const wa = window.addEventListener;
+  wa(
+    "error",
+    (event) => {
+      console.error(logMessage("error:capture:"), event);
+      if (isChunkError(event)) {
+        event.preventDefault();
+        attemptReload(event);
+        return;
+      }
+      const serialized = serializeError(event);
+      sendBeacon({
+        errorMessage: event.message,
+        eventName: "error",
+        serialized
+      });
+    },
+    true
+  );
+  wa("error", (event) => {
+    console.error(logMessage("error:"), event);
+  });
+  wa("unhandledrejection", (event) => {
+    console.error(logMessage("unhandledrejection:"), event);
+    if (isChunkError(event.reason)) {
+      event.preventDefault();
+      attemptReload(event.reason);
+      return;
+    }
+    const serialized = serializeError(event);
+    sendBeacon({
+      errorMessage: String(event.reason),
+      eventName: "unhandledrejection",
+      serialized
+    });
+  });
+  wa("uncaughtException", (event) => {
+    console.error(logMessage("uncaughtException:"), event);
+    const serialized = serializeError(event);
+    sendBeacon({
+      eventName: "uncaughtException",
+      serialized
+    });
+  });
+  wa("securitypolicyviolation", (event) => {
+    console.error(logMessage("CSP violation:"), event.blockedURI, event.violatedDirective);
+    const serialized = serializeError(event);
+    sendBeacon({
+      eventMessage: `${event.violatedDirective}: ${event.blockedURI}`,
+      eventName: "securitypolicyviolation",
+      serialized
+    });
+  });
+  wa("vite:preloadError", (event) => {
+    console.error(logMessage("vite:preloadError:"), event);
+    event.preventDefault();
+    attemptReload(event);
+  });
+};
+
+// src/common/listen/index.ts
+var listen = () => {
+  if (!globalThis.window) {
+    return;
+  }
+  listenInternal();
+};
+export {
+  events_exports as events,
+  listen,
+  options_exports as options
+};

package/dist/common/isChunkError.d.ts

@@ -0,0 +1 @@
+export declare const isChunkError: (error: unknown) => boolean;

package/dist/common/listen/index.d.ts

@@ -0,0 +1 @@
+export declare const listen: () => void;

package/dist/common/listen/internal.d.ts

@@ -0,0 +1 @@
+export declare const listenInternal: () => void;

package/dist/common/log.d.ts

@@ -0,0 +1 @@
+export declare const logMessage: (msg: string) => string;

package/dist/common/options.d.ts

@@ -0,0 +1,12 @@
+export { optionsWindowKey } from "./constants";
+export interface Options {
+    fallbackHtml?: string;
+    /** @default [1000, 2000, 5000] */
+    reloadDelays?: number[];
+    reportBeacon?: {
+        endpoint?: string;
+    };
+    /** @default true */
+    useRetryId?: boolean;
+}
+export declare const getOptions: () => Options;

package/dist/common/reload.d.ts

@@ -0,0 +1 @@
+export declare const attemptReload: (error: unknown) => void;

package/dist/common/sendBeacon.d.ts

@@ -0,0 +1,2 @@
+import type { BeaconSchema } from "../schema";
+export declare const sendBeacon: (beacon: BeaconSchema) => void;

package/dist/common/serializeError.d.ts

@@ -0,0 +1 @@
+export declare const serializeError: (error: unknown) => string;

package/dist/fastify/index.d.ts

@@ -0,0 +1,45 @@
+import type { BeaconSchema } from "../schema";
+export interface FastifySPAGuardOptions {
+    /**
+     * Custom handler for beacon data
+     * @param beacon - Parsed beacon data
+     * @param request - Fastify request object
+     */
+    onBeacon?: (beacon: BeaconSchema, request: any) => Promise<void> | void;
+    /**
+     * Custom handler for invalid/unknown beacon data
+     * @param body - Raw body data
+     * @param request - Fastify request object
+     */
+    onUnknownBeacon?: (body: unknown, request: any) => Promise<void> | void;
+    /**
+     * The route path for the beacon endpoint
+     * @example "/api/beacon"
+     */
+    path: string;
+}
+/**
+ * SPA Guard plugin for Fastify
+ * Registers a POST endpoint to receive beacon data from the client
+ *
+ * @example
+ * ```ts
+ * import { fastifySPAGuard } from '@ovineko/spa-guard/fastify';
+ *
+ * app.register(fastifySPAGuard, {
+ *   path: '/api/beacon',
+ *   onBeacon: async (beacon, request) => {
+ *     // Handle beacon data (e.g., log to Sentry)
+ *     const error = new Error(beacon.errorMessage || 'Unknown error');
+ *     Sentry.captureException(error, {
+ *       extra: {
+ *         eventName: beacon.eventName,
+ *         eventMessage: beacon.eventMessage,
+ *         serialized: beacon.serialized,
+ *       },
+ *     });
+ *   },
+ * });
+ * ```
+ */
+export declare const fastifySPAGuard: (fastify: any, options: FastifySPAGuardOptions) => Promise<void>;

package/dist/fastify/index.js

@@ -0,0 +1,66 @@
+import {
+  logMessage
+} from "../chunk-W65YKSMF.js";
+import {
+  parseBeacon
+} from "../chunk-BL4EG6R7.js";
+import "../chunk-XV2YCVOR.js";
+import "../chunk-MLKGABMK.js";
+
+// src/fastify/index.ts
+var parseStringBody = (body) => {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+};
+var handleBeaconRequest = async (body, request, options) => {
+  try {
+    const beacon = parseBeacon(body);
+    if (options.onBeacon) {
+      await options.onBeacon(beacon, request);
+    } else {
+      request.log.info(
+        {
+          errorMessage: beacon.errorMessage,
+          eventMessage: beacon.eventMessage,
+          eventName: beacon.eventName,
+          serialized: beacon.serialized
+        },
+        logMessage("Beacon received")
+      );
+    }
+  } catch {
+    if (options.onUnknownBeacon) {
+      await options.onUnknownBeacon(body, request);
+    } else {
+      request.log.warn({ body }, logMessage("Unknown beacon format"));
+    }
+  }
+};
+var fastifySPAGuard = async (fastify, options) => {
+  const { onBeacon, onUnknownBeacon, path } = options;
+  fastify.post(
+    path,
+    {
+      schema: {
+        body: {
+          content: {
+            "text/plain": {
+              schema: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    async (request, reply) => {
+      const body = parseStringBody(request.body);
+      await handleBeaconRequest(body, request, { onBeacon, onUnknownBeacon });
+      return reply.status(200).send({ success: true });
+    }
+  );
+};
+export {
+  fastifySPAGuard
+};

package/dist/inline/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/react/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/react-error-boundary/index.d.ts

@@ -0,0 +1 @@
+export { ErrorBoundary } from "react-error-boundary";

package/dist/react-error-boundary/index.js

@@ -0,0 +1,7 @@
+import "../chunk-MLKGABMK.js";
+
+// src/react-error-boundary/index.tsx
+import { ErrorBoundary } from "react-error-boundary";
+export {
+  ErrorBoundary
+};

package/dist/react-router/index.d.ts

@@ -0,0 +1 @@
+export declare const ErrorBoundaryReactRouter: () => import("react/jsx-runtime").JSX.Element;

package/dist/react-router/index.js

@@ -0,0 +1,12 @@
+import "../chunk-MLKGABMK.js";
+
+// src/react-router/index.tsx
+import { useRouteError } from "react-router";
+import { jsx } from "react/jsx-runtime";
+var ErrorBoundaryReactRouter = () => {
+  const error = useRouteError();
+  return /* @__PURE__ */ jsx("div", { children: JSON.stringify(error) });
+};
+export {
+  ErrorBoundaryReactRouter
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,8 @@
+import Type from "typebox";
+export declare const beaconSchema: Type.TObject<{
+    errorMessage: Type.TOptional<Type.TString>;
+    eventMessage: Type.TOptional<Type.TString>;
+    eventName: Type.TOptional<Type.TString>;
+    serialized: Type.TOptional<Type.TString>;
+}>;
+export type BeaconSchema = Type.Static<typeof beaconSchema>;

package/dist/schema/index.js

@@ -0,0 +1,7 @@
+import {
+  beaconSchema
+} from "../chunk-XV2YCVOR.js";
+import "../chunk-MLKGABMK.js";
+export {
+  beaconSchema
+};