@sweidos/eidos 1.0.34 → 1.2.0

package/dist/push.js

@@ -0,0 +1,113 @@
+import { getSwRegistration, registerPushCallbacks, sendToWorker } from "@sweidos/eidos";
+//#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 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));
+}
+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

@@ -0,0 +1,131 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _tanstack_react_query = require("@tanstack/react-query");
+let _sweidos_eidos = require("@sweidos/eidos");
+//#region src/query.ts
+/**
+* @sweidos/eidos/query
+*
+* TanStack Query (React Query) integration for Eidos.
+*
+* @example
+* ```ts
+* // Register once (e.g. alongside new QueryClient())
+* import { withEidosQueryClient } from '@sweidos/eidos/query'
+* withEidosQueryClient(queryClient)
+*
+* // In components
+* import { useEidosQuery, useEidosMutation } from '@sweidos/eidos/query'
+*
+* const { data, isPending } = useEidosQuery(products)
+*
+* const mutation = useEidosMutation(createOrder, {
+*   invalidates: [products],
+* })
+* ```
+*/
+var _globalClient = null;
+/**
+* Register a QueryClient with Eidos.
+*
+* Once called, `handle.invalidate()` will also call
+* `queryClient.invalidateQueries({ queryKey: ['eidos', url] })`, keeping
+* TanStack Query's cache in sync with Eidos's Cache Storage.
+*
+* Call this once, before rendering — e.g. alongside `new QueryClient()`.
+*
+* @example
+* ```ts
+* const queryClient = new QueryClient()
+* withEidosQueryClient(queryClient)
+*
+* // Wrap your app as usual
+* <QueryClientProvider client={queryClient}>
+*   <App />
+* </QueryClientProvider>
+* ```
+*/
+function withEidosQueryClient(client) {
+	_globalClient = client;
+	(0, _sweidos_eidos.setQueryInvalidator)((queryKey) => {
+		client.invalidateQueries({ queryKey });
+	});
+}
+/**
+* Wraps `useQuery` with Eidos-smart defaults.
+*
+* Key differences from plain `useQuery`:
+* - `networkMode: 'always'` — Eidos owns offline logic; queries run even when
+*   `navigator.onLine` is false (the SW cache or IndexedDB serves the data).
+* - `retry: false` — Eidos handles retries at the SW / replay layer; TQ
+*   retrying on top would double-fire and fight Eidos's backoff.
+*
+* @example
+* ```ts
+* const products = resource('/api/products', { offline: true })
+*
+* // Automatically typed as UseQueryResult<Product[]>
+* const { data, isPending, isError } = useEidosQuery<Product[]>(products)
+*
+* // Override any TQ option
+* const { data } = useEidosQuery(products, { staleTime: 30_000 })
+* ```
+*/
+function useEidosQuery(handle, options) {
+	return (0, _tanstack_react_query.useQuery)({
+		networkMode: "always",
+		retry: false,
+		...options,
+		...handle.query()
+	});
+}
+/**
+* Wraps `useMutation` for a single-argument Eidos action handle.
+*
+* Key differences from plain `useMutation`:
+* - `networkMode: 'always'` — action executes (or queues) even when offline.
+* - `invalidates` — shorthand to clear resource caches on success. Triggers
+*   both Eidos Cache Storage and TanStack Query invalidation (requires
+*   `withEidosQueryClient` for the TQ half).
+* - Return type is `TData | QueuedResult`. Narrow with `'queued' in data` to
+*   detect the offline-queued case.
+*
+* @example
+* ```ts
+* const mutation = useEidosMutation(createOrder, {
+*   invalidates: [products],
+*   onSuccess(data) {
+*     if ('queued' in data) toast('Saved offline — will sync when back online')
+*     else toast(`Order #${data.id} created!`)
+*   },
+* })
+*
+* // Trigger
+* mutation.mutate({ productId: 1, qty: 2 })
+* ```
+*/
+function useEidosMutation(handle, options) {
+	let contextClient = null;
+	try {
+		contextClient = (0, _tanstack_react_query.useQueryClient)();
+	} catch {}
+	const { invalidates, onSuccess, ...rest } = options ?? {};
+	return (0, _tanstack_react_query.useMutation)({
+		networkMode: "always",
+		...rest,
+		mutationFn: (arg) => handle(arg),
+		onSuccess: async (...args) => {
+			const [data] = args;
+			if (invalidates?.length) {
+				await Promise.all(invalidates.map((h) => h.invalidate()));
+				if (!_globalClient && contextClient) invalidates.forEach((h) => {
+					contextClient.invalidateQueries({ queryKey: h.query().queryKey });
+				});
+			}
+			if (onSuccess) await onSuccess(...args);
+		}
+	});
+}
+//#endregion
+exports.useEidosMutation = useEidosMutation;
+exports.useEidosQuery = useEidosQuery;
+exports.withEidosQueryClient = withEidosQueryClient;

package/dist/query.js

@@ -1,48 +1,128 @@
-import { useQuery, useQueryClient, useMutation } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { setQueryInvalidator } from "@sweidos/eidos";
-let _globalClient = null;
+//#region src/query.ts
+/**
+* @sweidos/eidos/query
+*
+* TanStack Query (React Query) integration for Eidos.
+*
+* @example
+* ```ts
+* // Register once (e.g. alongside new QueryClient())
+* import { withEidosQueryClient } from '@sweidos/eidos/query'
+* withEidosQueryClient(queryClient)
+*
+* // In components
+* import { useEidosQuery, useEidosMutation } from '@sweidos/eidos/query'
+*
+* const { data, isPending } = useEidosQuery(products)
+*
+* const mutation = useEidosMutation(createOrder, {
+*   invalidates: [products],
+* })
+* ```
+*/
+var _globalClient = null;
+/**
+* Register a QueryClient with Eidos.
+*
+* Once called, `handle.invalidate()` will also call
+* `queryClient.invalidateQueries({ queryKey: ['eidos', url] })`, keeping
+* TanStack Query's cache in sync with Eidos's Cache Storage.
+*
+* Call this once, before rendering — e.g. alongside `new QueryClient()`.
+*
+* @example
+* ```ts
+* const queryClient = new QueryClient()
+* withEidosQueryClient(queryClient)
+*
+* // Wrap your app as usual
+* <QueryClientProvider client={queryClient}>
+*   <App />
+* </QueryClientProvider>
+* ```
+*/
 function withEidosQueryClient(client) {
-  _globalClient = client;
-  setQueryInvalidator((queryKey) => {
-    client.invalidateQueries({ queryKey });
-  });
+	_globalClient = client;
+	setQueryInvalidator((queryKey) => {
+		client.invalidateQueries({ queryKey });
+	});
 }
+/**
+* Wraps `useQuery` with Eidos-smart defaults.
+*
+* Key differences from plain `useQuery`:
+* - `networkMode: 'always'` — Eidos owns offline logic; queries run even when
+*   `navigator.onLine` is false (the SW cache or IndexedDB serves the data).
+* - `retry: false` — Eidos handles retries at the SW / replay layer; TQ
+*   retrying on top would double-fire and fight Eidos's backoff.
+*
+* @example
+* ```ts
+* const products = resource('/api/products', { offline: true })
+*
+* // Automatically typed as UseQueryResult<Product[]>
+* const { data, isPending, isError } = useEidosQuery<Product[]>(products)
+*
+* // Override any TQ option
+* const { data } = useEidosQuery(products, { staleTime: 30_000 })
+* ```
+*/
 function useEidosQuery(handle, options) {
-  return useQuery({
-    networkMode: "always",
-    retry: false,
-    ...options,
-    ...handle.query()
-  });
+	return useQuery({
+		networkMode: "always",
+		retry: false,
+		...options,
+		...handle.query()
+	});
 }
+/**
+* Wraps `useMutation` for a single-argument Eidos action handle.
+*
+* Key differences from plain `useMutation`:
+* - `networkMode: 'always'` — action executes (or queues) even when offline.
+* - `invalidates` — shorthand to clear resource caches on success. Triggers
+*   both Eidos Cache Storage and TanStack Query invalidation (requires
+*   `withEidosQueryClient` for the TQ half).
+* - Return type is `TData | QueuedResult`. Narrow with `'queued' in data` to
+*   detect the offline-queued case.
+*
+* @example
+* ```ts
+* const mutation = useEidosMutation(createOrder, {
+*   invalidates: [products],
+*   onSuccess(data) {
+*     if ('queued' in data) toast('Saved offline — will sync when back online')
+*     else toast(`Order #${data.id} created!`)
+*   },
+* })
+*
+* // Trigger
+* mutation.mutate({ productId: 1, qty: 2 })
+* ```
+*/
 function useEidosMutation(handle, options) {
-  let contextClient = null;
-  try {
-    contextClient = useQueryClient();
-  } catch {
-  }
-  const { invalidates, onSuccess, ...rest } = options ?? {};
-  return useMutation({
-    networkMode: "always",
-    ...rest,
-    mutationFn: (arg) => handle(arg),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    onSuccess: async (...args) => {
-      const [data] = args;
-      if (invalidates == null ? void 0 : invalidates.length) {
-        await Promise.all(invalidates.map((h) => h.invalidate()));
-        if (!_globalClient && contextClient) {
-          invalidates.forEach((h) => {
-            contextClient.invalidateQueries({ queryKey: h.query().queryKey });
-          });
-        }
-      }
-      if (onSuccess) await onSuccess(...args);
-    }
-  });
+	let contextClient = null;
+	try {
+		contextClient = useQueryClient();
+	} catch {}
+	const { invalidates, onSuccess, ...rest } = options ?? {};
+	return useMutation({
+		networkMode: "always",
+		...rest,
+		mutationFn: (arg) => handle(arg),
+		onSuccess: async (...args) => {
+			const [data] = args;
+			if (invalidates?.length) {
+				await Promise.all(invalidates.map((h) => h.invalidate()));
+				if (!_globalClient && contextClient) invalidates.forEach((h) => {
+					contextClient.invalidateQueries({ queryKey: h.query().queryKey });
+				});
+			}
+			if (onSuccess) await onSuccess(...args);
+		}
+	});
 }
-export {
-  useEidosMutation,
-  useEidosQuery,
-  withEidosQueryClient
-};
+//#endregion
+export { useEidosMutation, useEidosQuery, withEidosQueryClient };

package/dist/queue-storage.js

@@ -1,12 +1,13 @@
-let e = null;
+var e = null;
 function u(t) {
   e = t;
 }
-function n() {
+function r() {
   return e;
 }
 export {
-  n as _getQueueStorage,
+  r as _getQueueStorage,
   u as setQueueStorage
 };
-//# sourceMappingURL=queue-storage.js.map
+
+//# sourceMappingURL=queue-storage.js.map

package/dist/react/Devtools.d.ts

@@ -4,4 +4,4 @@ export interface EidosDevtoolsProps {
     /** Start expanded. Default: false. */
     defaultOpen?: boolean;
 }
-export declare function EidosDevtools({ position, defaultOpen }: EidosDevtoolsProps): import("react").JSX.Element;
+export declare function EidosDevtools({ position, defaultOpen, }: EidosDevtoolsProps): import("react").JSX.Element;

package/dist/react/Provider.js

@@ -1,12 +1,16 @@
-import { jsx as t, Fragment as m } from "react/jsx-runtime";
-import { useEffect as e } from "react";
-import { initEidos as f } from "../runtime.js";
+import { initEidos as t } from "../runtime.js";
+import { useEffect as m } from "react";
+import { Fragment as e, jsx as f } from "react/jsx-runtime";
 function d({ children: r, swPath: o, autoReplay: i }) {
-  return e(() => {
-    f({ swPath: o, autoReplay: i });
-  }, []), /* @__PURE__ */ t(m, { children: r });
+  return m(() => {
+    t({
+      swPath: o,
+      autoReplay: i
+    });
+  }, []), /* @__PURE__ */ f(e, { children: r });
 }
 export {
   d as EidosProvider
 };
-//# sourceMappingURL=Provider.js.map
+
+//# sourceMappingURL=Provider.js.map

package/dist/react/hooks.js

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

package/dist/react-native.js

@@ -1,59 +1,53 @@
-import { jsx, Fragment } from "react/jsx-runtime";
-import { useRef, useEffect } from "react";
-import { useEidosStore, AsyncStorageQueueStorage, setQueueStorage, replayQueue } from "@sweidos/eidos";
-import { AsyncStorageQueueStorage as AsyncStorageQueueStorage2, setQueueStorage as setQueueStorage2 } from "@sweidos/eidos";
+import { useEffect, useRef } from "react";
+import { AsyncStorageQueueStorage, AsyncStorageQueueStorage as AsyncStorageQueueStorage$1, setQueueStorage, setQueueStorage as setQueueStorage$1, subscribeReplayOnReconnect, useEidosStore } from "@sweidos/eidos";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/react/ProviderRN.tsx
+/**
+* Connectivity bridge for React Native.
+* Syncs the network state into the Eidos store so `initEidosRN`'s autoReplay
+* subscription fires when the device comes back online.
+*
+* Render this near the root of your app, after calling `initEidosRN()`.
+*/
 function EidosProviderRN({ children, isConnected }) {
-  const prevRef = useRef(void 0);
-  useEffect(() => {
-    const online = isConnected !== false;
-    if (online !== prevRef.current) {
-      prevRef.current = online;
-      useEidosStore.getState().setOnline(online);
-    }
-  }, [isConnected]);
-  return /* @__PURE__ */ jsx(Fragment, { children });
+	const prevRef = useRef(void 0);
+	useEffect(() => {
+		const online = isConnected !== false;
+		if (online !== prevRef.current) {
+			prevRef.current = online;
+			useEidosStore.getState().setOnline(online);
+		}
+	}, [isConnected]);
+	return /* @__PURE__ */ jsx(Fragment, { children });
 }
-let _initialized = false;
-let _unsubscribe = null;
+//#endregion
+//#region src/runtime-rn.ts
+var _initialized = false;
+var _unsubscribe = null;
+/**
+* Initialize Eidos for React Native.
+* Call this once at app startup (outside any component) before rendering.
+*
+* @example
+* import AsyncStorage from '@react-native-async-storage/async-storage'
+* await initEidosRN({ storage: AsyncStorage })
+*/
 async function initEidosRN(config) {
-  if (_initialized) return;
-  _initialized = true;
-  const { storage, autoReplay = true } = config;
-  const queueStorage = new AsyncStorageQueueStorage(storage);
-  setQueueStorage(queueStorage);
-  try {
-    const persisted = await queueStorage.getAll();
-    if (persisted.length > 0) {
-      useEidosStore.getState().hydrateQueue(persisted);
-    }
-  } catch {
-  }
-  if (autoReplay) {
-    let prevIsOnline = useEidosStore.getState().isOnline;
-    _unsubscribe = useEidosStore.subscribe(() => {
-      const { isOnline } = useEidosStore.getState();
-      const justCameOnline = isOnline && !prevIsOnline;
-      prevIsOnline = isOnline;
-      if (justCameOnline) {
-        setTimeout(replayQueue, 600);
-      }
-    });
-    const store = useEidosStore.getState();
-    const hasPending = store.queue.some((q) => q.status === "pending");
-    if (store.isOnline && hasPending) {
-      setTimeout(replayQueue, 1200);
-    }
-  }
+	if (_initialized) return;
+	_initialized = true;
+	const { storage, autoReplay = true } = config;
+	const queueStorage = new AsyncStorageQueueStorage$1(storage);
+	setQueueStorage$1(queueStorage);
+	try {
+		const persisted = await queueStorage.getAll();
+		if (persisted.length > 0) useEidosStore.getState().hydrateQueue(persisted);
+	} catch {}
+	if (autoReplay) _unsubscribe = subscribeReplayOnReconnect();
 }
 function _resetEidosRN() {
-  _unsubscribe == null ? void 0 : _unsubscribe();
-  _unsubscribe = null;
-  _initialized = false;
+	_unsubscribe?.();
+	_unsubscribe = null;
+	_initialized = false;
 }
-export {
-  AsyncStorageQueueStorage2 as AsyncStorageQueueStorage,
-  EidosProviderRN,
-  _resetEidosRN,
-  initEidosRN,
-  setQueueStorage2 as setQueueStorage
-};
+//#endregion
+export { AsyncStorageQueueStorage, EidosProviderRN, _resetEidosRN, initEidosRN, setQueueStorage };