@sweidos/eidos 1.1.0 → 2.0.0

package/dist/index.js

@@ -1,45 +1,49 @@
 import { useEidosStore as o } from "./store.js";
-import { isBgSyncSupported as s, setOfflineSimulation as i } from "./sw-bridge.js";
-import { resource as u, setQueryInvalidator as m, warmCache as d } from "./resource.js";
-import { _getQueueStorage as p, setQueueStorage as c } from "./queue-storage.js";
-import { action as n, clearQueue as S, replayQueue as E } from "./action.js";
-import { subscribeReplayOnReconnect as g } from "./replay.js";
-import { _resetEidos as R, initEidos as y } from "./runtime.js";
-import { AsyncStorageQueueStorage as A } from "./async-storage-adapter.js";
-import { EidosProvider as v } from "./react/Provider.js";
-import { useEidos as _, useEidosAction as h, useEidosOnDrain as w, useEidosQueue as x, useEidosQueueStats as B, useEidosResource as C, useEidosResources as D, useEidosStatus as N } from "./react/hooks.js";
-import { VERSION as V } from "./version.js";
-import { eidosAction as k, eidosQueue as q, eidosQueueStats as z, eidosResource as F, eidosStatus as G, eidosStore as H } from "./stores.js";
+import { getSwRegistration as s, isBgSyncSupported as i, registerPushCallbacks as t, sendToWorker as u, setOfflineSimulation as m } from "./sw-bridge.js";
+import { resource as d, resourcePattern as n, setQueryInvalidator as p, warmCache as c } from "./resource.js";
+import { _getQueueStorage as f, setQueueStorage as E } from "./queue-storage.js";
+import { action as g, clearQueue as l, replayQueue as R } from "./action.js";
+import { subscribeReplayOnReconnect as O } from "./replay.js";
+import { _resetEidos as A, initEidos as P } from "./runtime.js";
+import { AsyncStorageQueueStorage as k } from "./async-storage-adapter.js";
+import { EidosProvider as w } from "./react/Provider.js";
+import { useEidos as I, useEidosAction as _, useEidosOnDrain as x, useEidosQueue as B, useEidosQueueStats as D, useEidosResource as N, useEidosResources as T, useEidosStatus as V } from "./react/hooks.js";
+import { VERSION as j } from "./version.js";
+import { eidosAction as z, eidosQueue as F, eidosQueueStats as G, eidosResource as H, eidosStatus as J, eidosStore as K } from "./stores.js";
 export {
-  A as AsyncStorageQueueStorage,
-  v as EidosProvider,
-  V as VERSION,
-  p as _getQueueStorage,
-  R as _resetEidos,
-  n as action,
-  S as clearQueue,
-  k as eidosAction,
-  q as eidosQueue,
-  z as eidosQueueStats,
-  F as eidosResource,
-  G as eidosStatus,
-  H as eidosStore,
-  y as initEidos,
-  s as isBgSyncSupported,
-  E as replayQueue,
-  u as resource,
-  i as setOfflineSimulation,
-  m as setQueryInvalidator,
-  c as setQueueStorage,
-  g as subscribeReplayOnReconnect,
-  _ as useEidos,
-  h as useEidosAction,
-  w as useEidosOnDrain,
-  x as useEidosQueue,
-  B as useEidosQueueStats,
-  C as useEidosResource,
-  D as useEidosResources,
-  N as useEidosStatus,
+  k as AsyncStorageQueueStorage,
+  w as EidosProvider,
+  j as VERSION,
+  f as _getQueueStorage,
+  A as _resetEidos,
+  g as action,
+  l as clearQueue,
+  z as eidosAction,
+  F as eidosQueue,
+  G as eidosQueueStats,
+  H as eidosResource,
+  J as eidosStatus,
+  K as eidosStore,
+  s as getSwRegistration,
+  P as initEidos,
+  i as isBgSyncSupported,
+  t as registerPushCallbacks,
+  R as replayQueue,
+  d as resource,
+  n as resourcePattern,
+  u as sendToWorker,
+  m as setOfflineSimulation,
+  p as setQueryInvalidator,
+  E as setQueueStorage,
+  O as subscribeReplayOnReconnect,
+  I as useEidos,
+  _ as useEidosAction,
+  x as useEidosOnDrain,
+  B as useEidosQueue,
+  D as useEidosQueueStats,
+  N as useEidosResource,
+  T as useEidosResources,
+  V as useEidosStatus,
   o as useEidosStore,
-  d as warmCache
+  c as warmCache
 };

package/dist/push.cjs

@@ -0,0 +1,123 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _sweidos_eidos = require("@sweidos/eidos");
+//#region src/internal/url-base64.ts
+/** Decodes a base64url string (e.g. a VAPID public key) into raw bytes. */
+function urlBase64ToUint8Array(base64Url) {
+	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	const raw = atob(base64);
+	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+//#endregion
+//#region src/push.ts
+/**
+* @sweidos/eidos/push
+*
+* Web Push integration. Framework-agnostic: register click/expiry handlers
+* once at app init (any tab), and trigger subscription from a user gesture.
+*
+* @example
+* ```ts
+* import { registerPushHandlers, subscribeToPush } from '@sweidos/eidos/push'
+*
+* // App init — every tab, no permission prompt
+* registerPushHandlers({
+*   onNotificationClick: (data) => router.push(data.url),
+*   onSubscriptionExpired: (sub) => fetch('/api/push-subscribe', { method: 'POST', body: JSON.stringify(sub) }),
+* })
+*
+* // User gesture (button click)
+* const result = await subscribeToPush({
+*   vapidPublicKey: import.meta.env.VITE_EIDOS_VAPID_PUBLIC_KEY,
+*   onSubscribe: (sub) => fetch('/api/push-subscribe', { method: 'POST', body: JSON.stringify(sub) }),
+* })
+* ```
+*/
+/** Why push is unavailable on this device, or null if it's supported. */
+function getPushUnsupportedReason() {
+	if (typeof window === "undefined") return "no-push-api";
+	if (/iPhone|iPad|iPod/.test(navigator.userAgent) && !navigator.standalone) return "ios-not-installed";
+	if (!("serviceWorker" in navigator) || !("PushManager" in window) || !("Notification" in window)) return "no-push-api";
+	return null;
+}
+function isPushSupported() {
+	return getPushUnsupportedReason() === null;
+}
+function getPushPermissionState() {
+	if (!isPushSupported()) return "unsupported";
+	return Notification.permission;
+}
+function registerPushHandlers(handlers) {
+	(0, _sweidos_eidos.registerPushCallbacks)(handlers);
+}
+async function subscribeToPush(config) {
+	if (!isPushSupported()) return { status: "unsupported" };
+	let permission;
+	try {
+		permission = await Notification.requestPermission();
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+	if (permission !== "granted") return { status: "denied" };
+	const registration = (0, _sweidos_eidos.getSwRegistration)();
+	if (!registration) return { status: "sw-not-ready" };
+	try {
+		const applicationServerKey = urlBase64ToUint8Array(config.vapidPublicKey);
+		let subscription = await registration.pushManager.getSubscription();
+		if (subscription && !subscriptionKeyMatches(subscription, config.vapidPublicKey)) {
+			await subscription.unsubscribe();
+			subscription = null;
+		}
+		if (!subscription) subscription = await registration.pushManager.subscribe({
+			userVisibleOnly: true,
+			applicationServerKey
+		});
+		(0, _sweidos_eidos.sendToWorker)({
+			type: "EIDOS_CACHE_VAPID_KEY",
+			key: config.vapidPublicKey
+		});
+		const json = subscription.toJSON();
+		config.onSubscribe?.(json);
+		return {
+			status: "subscribed",
+			subscription: json
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+}
+async function unsubscribeFromPush() {
+	const registration = (0, _sweidos_eidos.getSwRegistration)();
+	if (!registration) return;
+	await (await registration.pushManager.getSubscription())?.unsubscribe();
+}
+async function getCurrentPushSubscription() {
+	const registration = (0, _sweidos_eidos.getSwRegistration)();
+	if (!registration) return null;
+	const subscription = await registration.pushManager.getSubscription();
+	return subscription ? subscription.toJSON() : null;
+}
+function uint8ArrayToUrlBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** Compares an existing subscription's key against the configured VAPID public key. */
+function subscriptionKeyMatches(subscription, vapidPublicKey) {
+	const key = subscription.options.applicationServerKey;
+	if (!key) return false;
+	return uint8ArrayToUrlBase64(new Uint8Array(key)) === uint8ArrayToUrlBase64(urlBase64ToUint8Array(vapidPublicKey));
+}
+//#endregion
+exports.getCurrentPushSubscription = getCurrentPushSubscription;
+exports.getPushPermissionState = getPushPermissionState;
+exports.getPushUnsupportedReason = getPushUnsupportedReason;
+exports.isPushSupported = isPushSupported;
+exports.registerPushHandlers = registerPushHandlers;
+exports.subscribeToPush = subscribeToPush;
+exports.unsubscribeFromPush = unsubscribeFromPush;

package/dist/push.d.ts

@@ -0,0 +1,28 @@
+export interface PushHandlers {
+    /** Fired when the user clicks a notification while a tab is open. */
+    onNotificationClick?: (data: unknown) => void;
+    /** Fired when the browser silently rotates the push subscription. Re-send to your backend. */
+    onSubscriptionExpired?: (sub: PushSubscriptionJSON) => void;
+}
+export interface PushConfig {
+    /** Base64url-encoded VAPID public key. Generate with `npx @sweidos/eidos generate-vapid-keys`. */
+    vapidPublicKey: string;
+    /** Called with the new subscription right after a successful subscribe. Send this to your backend. */
+    onSubscribe?: (sub: PushSubscriptionJSON) => void;
+}
+export type PushResult = {
+    status: 'subscribed';
+    subscription: PushSubscriptionJSON;
+} | {
+    status: 'denied' | 'unsupported' | 'sw-not-ready' | 'error';
+    error?: unknown;
+};
+export type PushUnsupportedReason = 'no-push-api' | 'ios-not-installed' | null;
+/** Why push is unavailable on this device, or null if it's supported. */
+export declare function getPushUnsupportedReason(): PushUnsupportedReason;
+export declare function isPushSupported(): boolean;
+export declare function getPushPermissionState(): NotificationPermission | 'unsupported';
+export declare function registerPushHandlers(handlers: PushHandlers): void;
+export declare function subscribeToPush(config: PushConfig): Promise<PushResult>;
+export declare function unsubscribeFromPush(): Promise<void>;
+export declare function getCurrentPushSubscription(): Promise<PushSubscriptionJSON | null>;

package/dist/push.js

@@ -0,0 +1,116 @@
+import { getSwRegistration, registerPushCallbacks, sendToWorker } from "@sweidos/eidos";
+//#region src/internal/url-base64.ts
+/** Decodes a base64url string (e.g. a VAPID public key) into raw bytes. */
+function urlBase64ToUint8Array(base64Url) {
+	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	const raw = atob(base64);
+	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+//#endregion
+//#region src/push.ts
+/**
+* @sweidos/eidos/push
+*
+* Web Push integration. Framework-agnostic: register click/expiry handlers
+* once at app init (any tab), and trigger subscription from a user gesture.
+*
+* @example
+* ```ts
+* import { registerPushHandlers, subscribeToPush } from '@sweidos/eidos/push'
+*
+* // App init — every tab, no permission prompt
+* registerPushHandlers({
+*   onNotificationClick: (data) => router.push(data.url),
+*   onSubscriptionExpired: (sub) => fetch('/api/push-subscribe', { method: 'POST', body: JSON.stringify(sub) }),
+* })
+*
+* // User gesture (button click)
+* const result = await subscribeToPush({
+*   vapidPublicKey: import.meta.env.VITE_EIDOS_VAPID_PUBLIC_KEY,
+*   onSubscribe: (sub) => fetch('/api/push-subscribe', { method: 'POST', body: JSON.stringify(sub) }),
+* })
+* ```
+*/
+/** Why push is unavailable on this device, or null if it's supported. */
+function getPushUnsupportedReason() {
+	if (typeof window === "undefined") return "no-push-api";
+	if (/iPhone|iPad|iPod/.test(navigator.userAgent) && !navigator.standalone) return "ios-not-installed";
+	if (!("serviceWorker" in navigator) || !("PushManager" in window) || !("Notification" in window)) return "no-push-api";
+	return null;
+}
+function isPushSupported() {
+	return getPushUnsupportedReason() === null;
+}
+function getPushPermissionState() {
+	if (!isPushSupported()) return "unsupported";
+	return Notification.permission;
+}
+function registerPushHandlers(handlers) {
+	registerPushCallbacks(handlers);
+}
+async function subscribeToPush(config) {
+	if (!isPushSupported()) return { status: "unsupported" };
+	let permission;
+	try {
+		permission = await Notification.requestPermission();
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+	if (permission !== "granted") return { status: "denied" };
+	const registration = getSwRegistration();
+	if (!registration) return { status: "sw-not-ready" };
+	try {
+		const applicationServerKey = urlBase64ToUint8Array(config.vapidPublicKey);
+		let subscription = await registration.pushManager.getSubscription();
+		if (subscription && !subscriptionKeyMatches(subscription, config.vapidPublicKey)) {
+			await subscription.unsubscribe();
+			subscription = null;
+		}
+		if (!subscription) subscription = await registration.pushManager.subscribe({
+			userVisibleOnly: true,
+			applicationServerKey
+		});
+		sendToWorker({
+			type: "EIDOS_CACHE_VAPID_KEY",
+			key: config.vapidPublicKey
+		});
+		const json = subscription.toJSON();
+		config.onSubscribe?.(json);
+		return {
+			status: "subscribed",
+			subscription: json
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+}
+async function unsubscribeFromPush() {
+	const registration = getSwRegistration();
+	if (!registration) return;
+	await (await registration.pushManager.getSubscription())?.unsubscribe();
+}
+async function getCurrentPushSubscription() {
+	const registration = getSwRegistration();
+	if (!registration) return null;
+	const subscription = await registration.pushManager.getSubscription();
+	return subscription ? subscription.toJSON() : null;
+}
+function uint8ArrayToUrlBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** Compares an existing subscription's key against the configured VAPID public key. */
+function subscriptionKeyMatches(subscription, vapidPublicKey) {
+	const key = subscription.options.applicationServerKey;
+	if (!key) return false;
+	return uint8ArrayToUrlBase64(new Uint8Array(key)) === uint8ArrayToUrlBase64(urlBase64ToUint8Array(vapidPublicKey));
+}
+//#endregion
+export { getCurrentPushSubscription, getPushPermissionState, getPushUnsupportedReason, isPushSupported, registerPushHandlers, subscribeToPush, unsubscribeFromPush };

package/dist/query.cjs

@@ -118,7 +118,7 @@ function useEidosMutation(handle, options) {
 			if (invalidates?.length) {
 				await Promise.all(invalidates.map((h) => h.invalidate()));
 				if (!_globalClient && contextClient) invalidates.forEach((h) => {
-					contextClient.invalidateQueries({ queryKey: h.query().queryKey });
+					contextClient.invalidateQueries({ queryKey: ["eidos", h.url] });
 				});
 			}
 			if (onSuccess) await onSuccess(...args);

package/dist/query.d.ts

@@ -1,5 +1,5 @@
 import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult, QueryClient } from '@tanstack/react-query';
-import { ResourceHandle, ActionHandle, QueuedResult } from '@sweidos/eidos';
+import { ResourceHandle, AnyResourceHandle, ActionHandle, QueuedResult } from '@sweidos/eidos';
 
 /**
  * Register a QueryClient with Eidos.
@@ -44,7 +44,6 @@ type EidosQueryOptions<T> = Omit<UseQueryOptions<T, Error, T, [string, string]>,
  * ```
  */
 export declare function useEidosQuery<T>(handle: ResourceHandle<T>, options?: EidosQueryOptions<T>): UseQueryResult<T, Error>;
-type AnyResourceHandle = ResourceHandle<any>;
 export interface EidosMutationOptions<TArg, TData> extends Omit<UseMutationOptions<TData | QueuedResult, Error, TArg>, 'mutationFn' | 'networkMode'> {
     /**
      * Resource handles to invalidate (Cache Storage + TanStack Query) after

package/dist/query.js

@@ -117,7 +117,7 @@ function useEidosMutation(handle, options) {
 			if (invalidates?.length) {
 				await Promise.all(invalidates.map((h) => h.invalidate()));
 				if (!_globalClient && contextClient) invalidates.forEach((h) => {
-					contextClient.invalidateQueries({ queryKey: h.query().queryKey });
+					contextClient.invalidateQueries({ queryKey: ["eidos", h.url] });
 				});
 			}
 			if (onSuccess) await onSuccess(...args);

package/dist/queue-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-storage.js","names":[],"sources":["../src/queue-storage.ts"],"sourcesContent":["import type { ActionQueueItem } from './types';\n\nexport interface QueueStorage {\n  add(item: ActionQueueItem): Promise<void>;\n  getAll(): Promise<ActionQueueItem[]>;\n  getPending(): Promise<ActionQueueItem[]>;\n  update(id: string, patch: Partial<ActionQueueItem>): Promise<void>;\n  remove(id: string): Promise<void>;\n  clear(): Promise<void>;\n}\n\nlet _storage: QueueStorage | null = null;\n\n/** Override the default IndexedDB queue with a custom storage backend (e.g. AsyncStorage for React Native). */\nexport function setQueueStorage(s: QueueStorage): void {\n  _storage = s;\n}\n\nexport function _getQueueStorage(): QueueStorage | null {\n  return _storage;\n}\n"],"mappings":"AAWA,IAAI,IAAgC;AAGpC,SAAgB,EAAgB,GAAuB;AACrD,EAAA,IAAW;AACb;AAEA,SAAgB,IAAwC;AACtD,SAAO;AACT"}

package/dist/queue-sync.js

@@ -0,0 +1,34 @@
+import { useEidosStore as o } from "./store.js";
+var c = "eidos-queue-sync", a;
+function r() {
+  return a !== void 0 || (a = typeof BroadcastChannel > "u" ? null : new BroadcastChannel(c)), a;
+}
+function i(e) {
+  r()?.postMessage(e);
+}
+function m() {
+  const e = r();
+  if (!e) return () => {
+  };
+  const s = (u) => {
+    const n = o.getState(), t = u.data;
+    switch (t.type) {
+      case "update":
+        n.updateQueueItem(t.id, t.update);
+        break;
+      case "batchUpdate":
+        n.batchUpdateQueueItems(t.updates);
+        break;
+      case "remove":
+        n.removeQueueItem(t.id);
+        break;
+    }
+  };
+  return e.addEventListener("message", s), () => e.removeEventListener("message", s);
+}
+export {
+  i as broadcastQueueSync,
+  m as subscribeQueueSync
+};
+
+//# sourceMappingURL=queue-sync.js.map

package/dist/queue-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-sync.js","names":[],"sources":["../src/queue-sync.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport type { ActionQueueItem } from './types';\n\nconst CHANNEL_NAME = 'eidos-queue-sync';\n\ntype QueueSyncMessage =\n  | { type: 'update'; id: string; update: Partial<ActionQueueItem> }\n  | { type: 'batchUpdate'; updates: Array<{ id: string; update: Partial<ActionQueueItem> }> }\n  | { type: 'remove'; id: string };\n\nlet _channel: BroadcastChannel | null | undefined;\n\nfunction getChannel(): BroadcastChannel | null {\n  if (_channel !== undefined) return _channel;\n  _channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(CHANNEL_NAME);\n  return _channel;\n}\n\n/**\n * Broadcasts a queue-item status change to other tabs sharing the same\n * IndexedDB queue. The replay-lock holder (see `replayQueue` in action.ts)\n * is the only tab that mutates queue-item status, so non-leader tabs would\n * otherwise show stale status until their own store re-hydrates.\n *\n * No-ops in environments without BroadcastChannel (React Native, old Safari).\n */\nexport function broadcastQueueSync(message: QueueSyncMessage): void {\n  getChannel()?.postMessage(message);\n}\n\n/**\n * Applies queue-item status updates broadcast by the replay-lock holder to\n * this tab's store. Returns an unsubscribe function.\n */\nexport function subscribeQueueSync(): () => void {\n  const channel = getChannel();\n  if (!channel) return () => {};\n\n  const handler = (event: MessageEvent<QueueSyncMessage>) => {\n    const store = useEidosStore.getState();\n    const message = event.data;\n    switch (message.type) {\n      case 'update':\n        store.updateQueueItem(message.id, message.update);\n        break;\n      case 'batchUpdate':\n        store.batchUpdateQueueItems(message.updates);\n        break;\n      case 'remove':\n        store.removeQueueItem(message.id);\n        break;\n    }\n  };\n\n  channel.addEventListener('message', handler);\n  return () => channel.removeEventListener('message', handler);\n}\n\n/** Test-only: reset the cached channel so each test gets a fresh instance. */\nexport function _resetQueueSyncChannel(): void {\n  _channel?.close();\n  _channel = undefined;\n}\n"],"mappings":";AAGA,IAAM,IAAe,oBAOjB;AAEJ,SAAS,IAAsC;AAC7C,SAAI,MAAa,WACjB,IAAW,OAAO,mBAAqB,MAAc,OAAO,IAAI,iBAAiB,CAAY,IACtF;AACT;AAUA,SAAgB,EAAmB,GAAiC;AAClE,EAAA,EAAW,GAAG,YAAY,CAAO;AACnC;AAMA,SAAgB,IAAiC;AAC/C,QAAM,IAAU,EAAW;AAC3B,MAAI,CAAC,EAAS,QAAA,MAAa;AAAA,EAAC;AAE5B,QAAM,IAAA,CAAW,MAA0C;AACzD,UAAM,IAAQ,EAAc,SAAS,GAC/B,IAAU,EAAM;AACtB,YAAQ,EAAQ,MAAhB;AAAA,MACE,KAAK;AACH,QAAA,EAAM,gBAAgB,EAAQ,IAAI,EAAQ,MAAM;AAChD;AAAA,MACF,KAAK;AACH,QAAA,EAAM,sBAAsB,EAAQ,OAAO;AAC3C;AAAA,MACF,KAAK;AACH,QAAA,EAAM,gBAAgB,EAAQ,EAAE;AAChC;AAAA,IACJ;AAAA,EACF;AAEA,SAAA,EAAQ,iBAAiB,WAAW,CAAO,GAC3C,MAAa,EAAQ,oBAAoB,WAAW,CAAO;AAC7D"}

package/dist/react/Provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.js","names":[],"sources":["../../src/react/Provider.tsx"],"sourcesContent":["import { useEffect, type ReactNode } from 'react';\nimport { initEidos, type EidosConfig } from '../runtime';\n\ninterface EidosProviderProps extends EidosConfig {\n  children: ReactNode;\n}\n\n/**\n * Mount once at the root of your application.\n * Registers the service worker and initialises the Eidos runtime.\n *\n * @example\n * <EidosProvider swPath=\"/eidos-sw.js\">\n *   <App />\n * </EidosProvider>\n */\nexport function EidosProvider({ children, swPath, autoReplay }: EidosProviderProps) {\n  useEffect(() => {\n    initEidos({ swPath, autoReplay });\n    // Run once on mount only\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return <>{children}</>;\n}\n"],"mappings":";;;AAgBA,SAAgB,EAAc,EAAE,UAAA,GAAU,QAAA,GAAQ,YAAA,EAAA,GAAkC;AAClF,SAAA,EAAA,MAAgB;AACd,IAAA,EAAU;AAAA,MAAE,QAAA;AAAA,MAAQ,YAAA;AAAA,IAAW,CAAC;AAAA,EAGlC,GAAG,CAAC,CAAC,GAEE,gBAAA,EAAA,GAAA,EAAG,UAAA,EAAW,CAAA;AACvB"}

package/dist/react/hooks.js

@@ -1,36 +1,36 @@
-import { useEidosStore as a } from "../store.js";
-import { useEffect as d, useRef as l, useSyncExternalStore as E } from "react";
+import { useEidosStore as o } from "../store.js";
+import { countQueueByStatus as l } from "../types.js";
+import { useEffect as i, useRef as c, useSyncExternalStore as p } from "react";
 function u(e) {
   const t = e ?? ((n) => n);
-  return E(a.subscribe, () => t(a.getState()));
+  return p(o.subscribe, () => t(o.getState()));
 }
-function S() {
+function R() {
   return u();
 }
 function q() {
   return u((e) => e.resources);
 }
-function R(e) {
+function w(e) {
   return u((t) => t.resources[e]);
 }
-function m() {
+function y() {
   return u((e) => e.queue);
 }
-function w(e) {
+function $(e) {
   return u((t) => t.queue.find((n) => n.id === e));
 }
-function y() {
+function O() {
   return {
     isOnline: u((e) => e.isOnline),
     swStatus: u((e) => e.swStatus),
     swError: u((e) => e.swError)
   };
 }
-function $() {
+function Q() {
   const [e, t, n, r] = u((s) => {
-    let o = 0, f = 0, c = 0;
-    for (const i of s.queue) i.status === "pending" ? o++ : i.status === "failed" ? f++ : i.status === "replaying" && c++;
-    return `${o},${f},${c},${s.queue.length}`;
+    const { pending: f, failed: a, replaying: d, total: E } = l(s.queue);
+    return `${f},${a},${d},${E}`;
   }).split(",");
   return {
     pending: +e,
@@ -39,23 +39,23 @@ function $() {
     total: +r
   };
 }
-function O(e) {
-  const t = u((s) => s.queue.length), n = l(0), r = l(e);
-  d(() => {
+function b(e) {
+  const t = u((s) => s.queue.length), n = c(0), r = c(e);
+  i(() => {
     r.current = e;
-  }), d(() => {
+  }), i(() => {
     n.current > 0 && t === 0 && r.current(), n.current = t;
   }, [t]);
 }
 export {
-  S as useEidos,
-  w as useEidosAction,
-  O as useEidosOnDrain,
-  m as useEidosQueue,
-  $ as useEidosQueueStats,
-  R as useEidosResource,
+  R as useEidos,
+  $ as useEidosAction,
+  b as useEidosOnDrain,
+  y as useEidosQueue,
+  Q as useEidosQueueStats,
+  w as useEidosResource,
   q as useEidosResources,
-  y as useEidosStatus
+  O as useEidosStatus
 };
 
 //# sourceMappingURL=hooks.js.map

package/dist/react/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":[],"sources":["../../src/react/hooks.ts"],"sourcesContent":["import { useEffect, useRef, useSyncExternalStore } from 'react';\nimport { useEidosStore } from '../store';\nimport type { EidosStore } from '../store';\nimport { countQueueByStatus } from '../types';\n\nfunction useStore(): EidosStore;\nfunction useStore<T>(selector: (state: EidosStore) => T): T;\nfunction useStore<T = EidosStore>(selector?: (state: EidosStore) => T): T {\n  const fn = selector ?? ((s: EidosStore) => s as unknown as T);\n  return useSyncExternalStore(useEidosStore.subscribe, () => fn(useEidosStore.getState()));\n}\n\n/** Full Eidos store — prefer the narrower hooks below for performance. */\nexport function useEidos() {\n  return useStore();\n}\n\n/** All registered resources — only re-renders when the resources map changes, not on queue mutations. */\nexport function useEidosResources() {\n  return useStore((s) => s.resources);\n}\n\n/** Live state for a single registered resource URL. */\nexport function useEidosResource(url: string) {\n  return useStore((s) => s.resources[url]);\n}\n\n/** The current action queue. */\nexport function useEidosQueue() {\n  return useStore((s) => s.queue);\n}\n\n/**\n * Live state for a single queue item by ID. Only re-renders when that specific\n * item changes — cheaper than `useEidosQueue().find(id)` which re-renders on\n * any queue mutation.\n */\nexport function useEidosAction(id: string) {\n  return useStore((s) => s.queue.find((item) => item.id === id));\n}\n\n/**\n * Online + SW status — cheap subscription, safe to use in header components.\n * Three separate primitive selectors so each only triggers a re-render when\n * its own value changes (no object-reference churn from a combined selector).\n */\nexport function useEidosStatus() {\n  const isOnline = useStore((s) => s.isOnline);\n  const swStatus = useStore((s) => s.swStatus);\n  const swError = useStore((s) => s.swError);\n  return { isOnline, swStatus, swError };\n}\n\n/**\n * Queue counts — single subscription, single loop. Re-renders only when a\n * count changes, not on every queue mutation. Use for badges and status bars\n * instead of `useEidosQueue()` when you only need numbers, not full items.\n */\nexport function useEidosQueueStats() {\n  // Encode as a comma-separated string so useSyncExternalStore's Object.is\n  // comparison bails out correctly when counts haven't changed. One loop,\n  // one subscription — cheaper than four separate filter() passes.\n  const encoded = useStore((s) => {\n    const { pending, failed, replaying, total } = countQueueByStatus(s.queue);\n    return `${pending},${failed},${replaying},${total}`;\n  });\n  const [p, f, r, t] = encoded.split(',');\n  return { pending: +p, failed: +f, replaying: +r, total: +t };\n}\n\n/**\n * Calls `callback` once each time the action queue drains from non-empty → 0.\n * Stable callback reference not required — always calls the latest version.\n * Use for \"all offline actions synced!\" toasts.\n *\n * @example\n * useEidosOnDrain(() => toast.success('All offline actions synced!'))\n */\nexport function useEidosOnDrain(callback: () => void) {\n  const total = useStore((s) => s.queue.length);\n  const prevRef = useRef(0);\n  const callbackRef = useRef(callback);\n\n  useEffect(() => {\n    callbackRef.current = callback;\n  });\n\n  useEffect(() => {\n    if (prevRef.current > 0 && total === 0) {\n      callbackRef.current();\n    }\n    prevRef.current = total;\n  }, [total]);\n}\n"],"mappings":";;;AAOA,SAAS,EAAyB,GAAwC;AACxE,QAAM,IAAK,MAAA,CAAc,MAAkB;AAC3C,SAAO,EAAqB,EAAc,WAAA,MAAiB,EAAG,EAAc,SAAS,CAAC,CAAC;AACzF;AAGA,SAAgB,IAAW;AACzB,SAAO,EAAS;AAClB;AAGA,SAAgB,IAAoB;AAClC,SAAO,EAAA,CAAU,MAAM,EAAE,SAAS;AACpC;AAGA,SAAgB,EAAiB,GAAa;AAC5C,SAAO,EAAA,CAAU,MAAM,EAAE,UAAU,CAAA,CAAI;AACzC;AAGA,SAAgB,IAAgB;AAC9B,SAAO,EAAA,CAAU,MAAM,EAAE,KAAK;AAChC;AAOA,SAAgB,EAAe,GAAY;AACzC,SAAO,EAAA,CAAU,MAAM,EAAE,MAAM,KAAA,CAAM,MAAS,EAAK,OAAO,CAAE,CAAC;AAC/D;AAOA,SAAgB,IAAiB;AAI/B,SAAO;AAAA,IAAE,UAHQ,EAAA,CAAU,MAAM,EAAE,QAG1B;AAAA,IAAU,UAFF,EAAA,CAAU,MAAM,EAAE,QAEhB;AAAA,IAAU,SADb,EAAA,CAAU,MAAM,EAAE,OACL;AAAA,EAAQ;AACvC;AAOA,SAAgB,IAAqB;AAQnC,QAAM,CAAC,GAAG,GAAG,GAAG,CAAA,IAJA,EAAA,CAAU,MAAM;AAC9B,UAAM,EAAE,SAAA,GAAS,QAAA,GAAQ,WAAA,GAAW,OAAA,EAAA,IAAU,EAAmB,EAAE,KAAK;AACxE,WAAO,GAAG,CAAA,IAAW,CAAA,IAAU,CAAA,IAAa,CAAA;AAAA,EAC9C,CACqB,EAAQ,MAAM,GAAG;AACtC,SAAO;AAAA,IAAE,SAAS,CAAC;AAAA,IAAG,QAAQ,CAAC;AAAA,IAAG,WAAW,CAAC;AAAA,IAAG,OAAO,CAAC;AAAA,EAAE;AAC7D;AAUA,SAAgB,EAAgB,GAAsB;AACpD,QAAM,IAAQ,EAAA,CAAU,MAAM,EAAE,MAAM,MAAM,GACtC,IAAU,EAAO,CAAC,GAClB,IAAc,EAAO,CAAQ;AAEnC,EAAA,EAAA,MAAgB;AACd,IAAA,EAAY,UAAU;AAAA,EACxB,CAAC,GAED,EAAA,MAAgB;AACd,IAAI,EAAQ,UAAU,KAAK,MAAU,KACnC,EAAY,QAAQ,GAEtB,EAAQ,UAAU;AAAA,EACpB,GAAG,CAAC,CAAK,CAAC;AACZ"}

package/dist/replay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","names":[],"sources":["../src/replay.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport { replayQueue } from './action';\n\n/**\n * Subscribe to online/offline transitions and trigger replayQueue() on\n * reconnect, plus replay any pending items left over from a previous session.\n *\n * Shared by the web (runtime.ts) and React Native (runtime-rn.ts) init paths.\n *\n * WHY subscribe to the store instead of window.addEventListener('online'):\n * setOfflineSimulation() updates the store directly but never fires a real\n * browser `online` event. Watching the store catches both:\n *   • Real network reconnects (sw-bridge updates store on window.online)\n *   • Simulation toggled off (setOfflineSimulation(false) → store.setOnline(true))\n *\n * Returns an unsubscribe function.\n */\nexport function subscribeReplayOnReconnect(): () => void {\n  let prevIsOnline = useEidosStore.getState().isOnline;\n\n  const unsubscribe = useEidosStore.subscribe(() => {\n    const { isOnline } = useEidosStore.getState();\n    const justCameOnline = isOnline && !prevIsOnline;\n    prevIsOnline = isOnline;\n\n    if (justCameOnline) {\n      // Small delay so the connection (or simulation reset) settles first\n      setTimeout(replayQueue, 600);\n    }\n  });\n\n  // Replay any pending items that survived a reload/restart.\n  // 'failed' items have already exhausted maxRetries and are never\n  // re-replayed (see _doReplayQueue), so they don't count here.\n  const store = useEidosStore.getState();\n  const hasPending = store.queue.some((q) => q.status === 'pending');\n  if (store.isOnline && hasPending) {\n    setTimeout(replayQueue, 1200);\n  }\n\n  return unsubscribe;\n}\n"],"mappings":";;AAiBA,SAAgB,IAAyC;AACvD,MAAI,IAAe,EAAc,SAAS,EAAE;AAE5C,QAAM,IAAc,EAAc,UAAA,MAAgB;AAChD,UAAM,EAAE,UAAA,EAAA,IAAa,EAAc,SAAS,GACtC,IAAiB,KAAY,CAAC;AACpC,IAAA,IAAe,GAEX,KAEF,WAAW,GAAa,GAAG;AAAA,EAE/B,CAAC,GAKK,IAAQ,EAAc,SAAS,GAC/B,IAAa,EAAM,MAAM,KAAA,CAAM,MAAM,EAAE,WAAW,SAAS;AACjE,SAAI,EAAM,YAAY,KACpB,WAAW,GAAa,IAAI,GAGvB;AACT"}