@sweidos/eidos 1.0.25 → 1.0.31

package/dist/index.d.ts

@@ -13,6 +13,13 @@ export declare interface ActionConfig {
     maxRetries?: number;
     /** Human-readable name for the action (used in devtools). */
     name?: string;
+    /**
+     * Replay order when multiple queued actions are pending.
+     * `'high'` items replay before `'normal'`, which replay before `'low'`.
+     * Each tier completes fully before the next tier begins.
+     * Default: `'normal'`.
+     */
+    priority?: 'high' | 'normal' | 'low';
     /**
      * Called immediately before the async function executes, with the same args.
      * Use to apply an optimistic UI update (add item, mark as pending, etc.).
@@ -26,6 +33,20 @@ export declare interface ActionConfig {
      * Use to revert the optimistic update.
      */
     onRollback?: (...args: any[]) => void;
+    /**
+     * Called during queue replay when the server responds with a 4xx status code
+     * (client error — conflict, gone, unprocessable, etc.).
+     *
+     * Return `'retry'` to keep the item in the queue and retry per normal backoff.
+     * Return `'skip'` to silently remove the item without triggering `onRollback`.
+     *
+     * If not provided, 4xx errors are treated identically to other errors (retried
+     * until `maxRetries` is exhausted, then `onRollback` is called).
+     *
+     * The `error` argument is whatever `fn` threw — typically a `Response` object
+     * or a custom error with a `.status` property.
+     */
+    onConflict?: (error: unknown, args: any[]) => 'retry' | 'skip';
 }
 
 declare type ActionFn<TArgs extends any[], TReturn> = (...args: TArgs) => Promise<TReturn>;
@@ -46,15 +67,42 @@ export declare interface ActionQueueItem {
     retryCount: number;
     maxRetries: number;
     status: 'pending' | 'replaying' | 'succeeded' | 'failed';
+    /** Replay priority. High items replay before normal, normal before low. Default: 'normal'. */
+    priority?: 'high' | 'normal' | 'low';
     error?: string;
     completedAt?: number;
     /** Earliest timestamp at which this item should be retried (exponential backoff). */
     nextRetryAt?: number;
 }
 
+/** Minimal subset of @react-native-async-storage/async-storage (or any compatible key-value store). */
+export declare interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+
+/**
+ * QueueStorage implementation backed by any AsyncStorage-compatible API.
+ * Pass the AsyncStorage singleton from @react-native-async-storage/async-storage
+ * (or MMKV, SQLite, or any store that satisfies AsyncStorageLike).
+ */
+export declare class AsyncStorageQueueStorage implements QueueStorage {
+    private readonly storage;
+    constructor(storage: AsyncStorageLike);
+    private readAll;
+    private writeAll;
+    add(item: ActionQueueItem): Promise<void>;
+    getAll(): Promise<ActionQueueItem[]>;
+    getPending(): Promise<ActionQueueItem[]>;
+    update(id: string, patch: Partial<ActionQueueItem>): Promise<void>;
+    remove(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
 export declare type CacheStrategy = 'cache-first' | 'stale-while-revalidate' | 'network-first';
 
-/** Remove all items from the action queue (IDB + in-memory store). */
+/** Remove all items from the action queue (storage + in-memory store). */
 export declare function clearQueue(): Promise<void>;
 
 /**
@@ -67,7 +115,7 @@ export declare function clearQueue(): Promise<void>;
  */
 export declare function eidosAction(id: string): EidosReadable<ActionQueueItem | undefined>;
 
-declare interface EidosConfig {
+export declare interface EidosConfig {
     /** Path to the eidos service worker. Defaults to '/eidos-sw.js'. */
     swPath?: string;
     /** Automatically replay the action queue on reconnect. Default: true. */
@@ -93,8 +141,8 @@ declare interface EidosProviderProps extends EidosConfig {
 export declare const eidosQueue: EidosReadable<ActionQueueItem[]>;
 
 /**
- * Queue counts. Re-notifies on any queue mutation — compare values inside the
- * subscriber callback to skip work when counts haven't changed.
+ * Queue counts. Re-emits only when a count actually changes, not on every
+ * queue mutation (e.g. a status transition that doesn't change counts is skipped).
  */
 export declare const eidosQueueStats: EidosReadable<{
     pending: number;
@@ -129,8 +177,7 @@ export declare interface EidosState {
 
 /**
  * Online status + SW lifecycle.
- * Object identity changes on every notification — destructure or compare fields
- * in the subscriber if you need to avoid unnecessary work.
+ * Only re-emits when isOnline, swStatus, or swError actually changes.
  */
 export declare const eidosStatus: EidosReadable<{
     isOnline: boolean;
@@ -146,6 +193,10 @@ export declare interface EidosStore extends EidosState {
     unregisterResource: (url: string) => void;
     addQueueItem: (item: ActionQueueItem) => void;
     updateQueueItem: (id: string, update: Partial<ActionQueueItem>) => void;
+    batchUpdateQueueItems: (updates: Array<{
+        id: string;
+        update: Partial<ActionQueueItem>;
+    }>) => void;
     removeQueueItem: (id: string) => void;
     hydrateQueue: (items: ActionQueueItem[]) => void;
 }
@@ -165,6 +216,8 @@ export declare interface GeneratedStrategy {
     equivalentCode: string;
 }
 
+export declare function _getQueueStorage(): QueueStorage | null;
+
 declare function _getState(): EidosStore;
 
 export declare function initEidos(config?: EidosConfig): Promise<void>;
@@ -181,6 +234,15 @@ export declare interface QueuedResult {
     readonly message: string;
 }
 
+export declare interface QueueStorage {
+    add(item: ActionQueueItem): Promise<void>;
+    getAll(): Promise<ActionQueueItem[]>;
+    getPending(): Promise<ActionQueueItem[]>;
+    update(id: string, patch: Partial<ActionQueueItem>): Promise<void>;
+    remove(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
 export declare function replayQueue(): Promise<ReplayResult>;
 
 /** Summary returned by replayQueue(). */
@@ -195,6 +257,8 @@ export declare interface ReplayResult {
     retrying: number;
     /** Items whose actionId had no registered function — likely not yet imported. */
     skipped: number;
+    /** Items that received a 4xx response and were dropped via `onConflict: () => 'skip'`. */
+    conflicted: number;
 }
 
 export declare function _resetEidos(): void;
@@ -245,6 +309,9 @@ export declare function setOfflineSimulation(enabled: boolean): void;
 
 /* Excluded from this release type: setQueryInvalidator */
 
+/** Override the default IndexedDB queue with a custom storage backend (e.g. AsyncStorage for React Native). */
+export declare function setQueueStorage(s: QueueStorage): void;
+
 declare function _subscribe(listener: Listener): () => void;
 
 /** Full Eidos store — prefer the narrower hooks below for performance. */
@@ -285,6 +352,9 @@ export declare function useEidosQueueStats(): {
 /** Live state for a single registered resource URL. */
 export declare function useEidosResource(url: string): ResourceEntry;
 
+/** All registered resources — only re-renders when the resources map changes, not on queue mutations. */
+export declare function useEidosResources(): Record<string, ResourceEntry>;
+
 /**
  * Online + SW status — cheap subscription, safe to use in header components.
  * Three separate primitive selectors so each only triggers a re-render when
@@ -302,6 +372,32 @@ export declare const useEidosStore: {
     setState: (partial: Partial<EidosStore> | ((s: EidosStore) => Partial<EidosStore>)) => void;
 };
 
-export declare const VERSION = "1.0.25";
+export declare const VERSION = "1.0.31";
+
+/**
+ * Bulk-prefetch an array of resource handles concurrently, warming the cache
+ * for each one. Useful on login / app init when you know which resources the
+ * user will need offline.
+ *
+ * Pattern handles (containing `*`, `**`, or `:param`) are silently skipped —
+ * they match multiple URLs so there is no single URL to prefetch.
+ *
+ * @example
+ * import { warmCache } from '@sweidos/eidos'
+ *
+ * // In EidosProvider's onReady, or after login:
+ * const { warmed, failed } = await warmCache([products, userProfile, settings])
+ */
+export declare function warmCache(handles: ResourceHandle[]): Promise<WarmCacheResult>;
+
+/** Summary returned by warmCache(). */
+export declare interface WarmCacheResult {
+    /** Resources that were prefetched successfully. */
+    warmed: number;
+    /** Resources whose prefetch threw (network error, offline, etc.). */
+    failed: number;
+    /** The raw errors, in input order, for failed handles. */
+    errors: unknown[];
+}
 
 export { }

package/dist/index.js

@@ -1,37 +1,44 @@
-import { resource as s, setQueryInvalidator as r } from "./resource.js";
-import { action as t, clearQueue as u, replayQueue as d } from "./action.js";
-import { _resetEidos as E, initEidos as a } from "./runtime.js";
-import { EidosProvider as m } from "./react/Provider.js";
-import { useEidos as S, useEidosAction as x, useEidosOnDrain as c, useEidosQueue as Q, useEidosQueueStats as l, useEidosResource as y, useEidosStatus as O } from "./react/hooks.js";
-import { VERSION as v } from "./version.js";
-import { isBgSyncSupported as I, setOfflineSimulation as g } from "./sw-bridge.js";
-import { useEidosStore as D } from "./store.js";
-import { eidosAction as P, eidosQueue as V, eidosQueueStats as _, eidosResource as b, eidosStatus as h, eidosStore as j } from "./stores.js";
+import { resource as r, setQueryInvalidator as s, warmCache as t } from "./resource.js";
+import { action as i, clearQueue as d, replayQueue as a } from "./action.js";
+import { _resetEidos as S, initEidos as f } from "./runtime.js";
+import { _getQueueStorage as E, setQueueStorage as c } from "./queue-storage.js";
+import { AsyncStorageQueueStorage as x } from "./async-storage-adapter.js";
+import { EidosProvider as g } from "./react/Provider.js";
+import { useEidos as y, useEidosAction as R, useEidosOnDrain as A, useEidosQueue as O, useEidosQueueStats as v, useEidosResource as I, useEidosResources as _, useEidosStatus as h } from "./react/hooks.js";
+import { VERSION as B } from "./version.js";
+import { isBgSyncSupported as D, setOfflineSimulation as N } from "./sw-bridge.js";
+import { useEidosStore as V } from "./store.js";
+import { eidosAction as j, eidosQueue as k, eidosQueueStats as q, eidosResource as z, eidosStatus as F, eidosStore as G } from "./stores.js";
 export {
-  m as EidosProvider,
-  v as VERSION,
-  E as _resetEidos,
-  t as action,
-  u as clearQueue,
-  P as eidosAction,
-  V as eidosQueue,
-  _ as eidosQueueStats,
-  b as eidosResource,
-  h as eidosStatus,
-  j as eidosStore,
-  a as initEidos,
-  I as isBgSyncSupported,
-  d as replayQueue,
-  s as resource,
-  g as setOfflineSimulation,
-  r as setQueryInvalidator,
-  S as useEidos,
-  x as useEidosAction,
-  c as useEidosOnDrain,
-  Q as useEidosQueue,
-  l as useEidosQueueStats,
-  y as useEidosResource,
-  O as useEidosStatus,
-  D as useEidosStore
+  x as AsyncStorageQueueStorage,
+  g as EidosProvider,
+  B as VERSION,
+  E as _getQueueStorage,
+  S as _resetEidos,
+  i as action,
+  d as clearQueue,
+  j as eidosAction,
+  k as eidosQueue,
+  q as eidosQueueStats,
+  z as eidosResource,
+  F as eidosStatus,
+  G as eidosStore,
+  f as initEidos,
+  D as isBgSyncSupported,
+  a as replayQueue,
+  r as resource,
+  N as setOfflineSimulation,
+  s as setQueryInvalidator,
+  c as setQueueStorage,
+  y as useEidos,
+  R as useEidosAction,
+  A as useEidosOnDrain,
+  O as useEidosQueue,
+  v as useEidosQueueStats,
+  I as useEidosResource,
+  _ as useEidosResources,
+  h as useEidosStatus,
+  V as useEidosStore,
+  t as warmCache
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/nextjs.d.ts

@@ -0,0 +1,2 @@
+export { EidosProvider } from './index.ts';
+export { useEidos, useEidosStatus, useEidosQueue, useEidosQueueStats, useEidosResource, useEidosAction, useEidosOnDrain, } from './index.ts';

package/dist/nextjs.js

@@ -0,0 +1,12 @@
+"use client";
+import { EidosProvider, useEidos, useEidosAction, useEidosOnDrain, useEidosQueue, useEidosQueueStats, useEidosResource, useEidosStatus } from "@sweidos/eidos";
+export {
+  EidosProvider,
+  useEidos,
+  useEidosAction,
+  useEidosOnDrain,
+  useEidosQueue,
+  useEidosQueueStats,
+  useEidosResource,
+  useEidosStatus
+};

package/dist/queue-storage.js

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

package/dist/queue-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-storage.js","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"],"names":["_storage","setQueueStorage","s","_getQueueStorage"],"mappings":"AAWA,IAAIA,IAAgC;AAG7B,SAASC,EAAgBC,GAAuB;AACrD,EAAAF,IAAWE;AACb;AAEO,SAASC,IAAwC;AACtD,SAAOH;AACT;"}

package/dist/react/Devtools.d.ts

@@ -0,0 +1,7 @@
+export interface EidosDevtoolsProps {
+    /** Corner to anchor the panel. Default: 'bottom-right'. */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Start expanded. Default: false. */
+    defaultOpen?: boolean;
+}
+export declare function EidosDevtools({ position, defaultOpen }: EidosDevtoolsProps): import("react").JSX.Element;

package/dist/react/ProviderRN.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+
+export interface EidosProviderRNProps {
+    children: React.ReactNode;
+    /**
+     * Current network connectivity state.
+     * Pass the value from `useNetInfo()` (@react-native-community/netinfo).
+     * Defaults to `true` if omitted.
+     *
+     * @example
+     * const netInfo = useNetInfo()
+     * <EidosProviderRN isConnected={netInfo.isConnected ?? true}>
+     */
+    isConnected?: boolean;
+}
+/**
+ * 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()`.
+ */
+export declare function EidosProviderRN({ children, isConnected }: EidosProviderRNProps): React.JSX.Element;

package/dist/react/hooks.js

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

package/dist/react/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","sources":["../../src/react/hooks.ts"],"sourcesContent":["import { useEffect, useRef, useSyncExternalStore } from 'react'\nimport { useEidosStore } from '../store'\nimport type { EidosStore } from '../store'\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/** 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    let pending = 0, failed = 0, replaying = 0\n    for (const q of s.queue) {\n      if (q.status === 'pending') pending++\n      else if (q.status === 'failed') failed++\n      else if (q.status === 'replaying') replaying++\n    }\n    return `${pending},${failed},${replaying},${s.queue.length}`\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  callbackRef.current = callback\n\n  useEffect(() => {\n    if (prevRef.current > 0 && total === 0) {\n      callbackRef.current()\n    }\n    prevRef.current = total\n  }, [total])\n}\n"],"names":["useStore","selector","fn","s","useSyncExternalStore","useEidosStore","useEidos","useEidosResource","url","useEidosQueue","useEidosAction","id","item","useEidosStatus","isOnline","swStatus","swError","useEidosQueueStats","encoded","pending","failed","replaying","q","p","f","r","t","useEidosOnDrain","callback","total","prevRef","useRef","callbackRef","useEffect"],"mappings":";;AAMA,SAASA,EAAyBC,GAAwC;AACxE,QAAMC,IAAKD,MAAa,CAACE,MAAkBA;AAC3C,SAAOC,EAAqBC,EAAc,WAAW,MAAMH,EAAGG,EAAc,SAAA,CAAU,CAAC;AACzF;AAGO,SAASC,IAAW;AACzB,SAAON,EAAA;AACT;AAGO,SAASO,EAAiBC,GAAa;AAC5C,SAAOR,EAAS,CAACG,MAAMA,EAAE,UAAUK,CAAG,CAAC;AACzC;AAGO,SAASC,IAAgB;AAC9B,SAAOT,EAAS,CAACG,MAAMA,EAAE,KAAK;AAChC;AAOO,SAASO,EAAeC,GAAY;AACzC,SAAOX,EAAS,CAACG,MAAMA,EAAE,MAAM,KAAK,CAACS,MAASA,EAAK,OAAOD,CAAE,CAAC;AAC/D;AAOO,SAASE,IAAiB;AAC/B,QAAMC,IAAWd,EAAS,CAACG,MAAMA,EAAE,QAAQ,GACrCY,IAAWf,EAAS,CAACG,MAAMA,EAAE,QAAQ,GACrCa,IAAUhB,EAAS,CAACG,MAAMA,EAAE,OAAO;AACzC,SAAO,EAAE,UAAAW,GAAU,UAAAC,GAAU,SAAAC,EAAA;AAC/B;AAOO,SAASC,IAAqB;AAInC,QAAMC,IAAUlB,EAAS,CAACG,MAAM;AAC9B,QAAIgB,IAAU,GAAGC,IAAS,GAAGC,IAAY;AACzC,eAAWC,KAAKnB,EAAE;AAChB,MAAImB,EAAE,WAAW,YAAWH,MACnBG,EAAE,WAAW,WAAUF,MACvBE,EAAE,WAAW,eAAaD;AAErC,WAAO,GAAGF,CAAO,IAAIC,CAAM,IAAIC,CAAS,IAAIlB,EAAE,MAAM,MAAM;AAAA,EAC5D,CAAC,GACK,CAACoB,GAAGC,GAAGC,GAAGC,CAAC,IAAIR,EAAQ,MAAM,GAAG;AACtC,SAAO,EAAE,SAAS,CAACK,GAAG,QAAQ,CAACC,GAAG,WAAW,CAACC,GAAG,OAAO,CAACC,EAAA;AAC3D;AAUO,SAASC,EAAgBC,GAAsB;AACpD,QAAMC,IAAW7B,EAAS,CAACG,MAAMA,EAAE,MAAM,MAAM,GACzC2B,IAAWC,EAAO,CAAC,GACnBC,IAAcD,EAAOH,CAAQ;AACnC,EAAAI,EAAY,UAAUJ,GAEtBK,EAAU,MAAM;AACd,IAAIH,EAAQ,UAAU,KAAKD,MAAU,KACnCG,EAAY,QAAA,GAEdF,EAAQ,UAAUD;AAAA,EACpB,GAAG,CAACA,CAAK,CAAC;AACZ;"}
+{"version":3,"file":"hooks.js","sources":["../../src/react/hooks.ts"],"sourcesContent":["import { useEffect, useRef, useSyncExternalStore } from 'react'\nimport { useEidosStore } from '../store'\nimport type { EidosStore } from '../store'\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    let pending = 0, failed = 0, replaying = 0\n    for (const q of s.queue) {\n      if (q.status === 'pending') pending++\n      else if (q.status === 'failed') failed++\n      else if (q.status === 'replaying') replaying++\n    }\n    return `${pending},${failed},${replaying},${s.queue.length}`\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  callbackRef.current = callback\n\n  useEffect(() => {\n    if (prevRef.current > 0 && total === 0) {\n      callbackRef.current()\n    }\n    prevRef.current = total\n  }, [total])\n}\n"],"names":["useStore","selector","fn","s","useSyncExternalStore","useEidosStore","useEidos","useEidosResources","useEidosResource","url","useEidosQueue","useEidosAction","id","item","useEidosStatus","isOnline","swStatus","swError","useEidosQueueStats","encoded","pending","failed","replaying","q","p","f","r","t","useEidosOnDrain","callback","total","prevRef","useRef","callbackRef","useEffect"],"mappings":";;AAMA,SAASA,EAAyBC,GAAwC;AACxE,QAAMC,IAAKD,MAAa,CAACE,MAAkBA;AAC3C,SAAOC,EAAqBC,EAAc,WAAW,MAAMH,EAAGG,EAAc,SAAA,CAAU,CAAC;AACzF;AAGO,SAASC,IAAW;AACzB,SAAON,EAAA;AACT;AAGO,SAASO,IAAoB;AAClC,SAAOP,EAAS,CAACG,MAAMA,EAAE,SAAS;AACpC;AAGO,SAASK,EAAiBC,GAAa;AAC5C,SAAOT,EAAS,CAACG,MAAMA,EAAE,UAAUM,CAAG,CAAC;AACzC;AAGO,SAASC,IAAgB;AAC9B,SAAOV,EAAS,CAACG,MAAMA,EAAE,KAAK;AAChC;AAOO,SAASQ,EAAeC,GAAY;AACzC,SAAOZ,EAAS,CAACG,MAAMA,EAAE,MAAM,KAAK,CAACU,MAASA,EAAK,OAAOD,CAAE,CAAC;AAC/D;AAOO,SAASE,IAAiB;AAC/B,QAAMC,IAAWf,EAAS,CAACG,MAAMA,EAAE,QAAQ,GACrCa,IAAWhB,EAAS,CAACG,MAAMA,EAAE,QAAQ,GACrCc,IAAUjB,EAAS,CAACG,MAAMA,EAAE,OAAO;AACzC,SAAO,EAAE,UAAAY,GAAU,UAAAC,GAAU,SAAAC,EAAA;AAC/B;AAOO,SAASC,IAAqB;AAInC,QAAMC,IAAUnB,EAAS,CAACG,MAAM;AAC9B,QAAIiB,IAAU,GAAGC,IAAS,GAAGC,IAAY;AACzC,eAAWC,KAAKpB,EAAE;AAChB,MAAIoB,EAAE,WAAW,YAAWH,MACnBG,EAAE,WAAW,WAAUF,MACvBE,EAAE,WAAW,eAAaD;AAErC,WAAO,GAAGF,CAAO,IAAIC,CAAM,IAAIC,CAAS,IAAInB,EAAE,MAAM,MAAM;AAAA,EAC5D,CAAC,GACK,CAACqB,GAAGC,GAAGC,GAAGC,CAAC,IAAIR,EAAQ,MAAM,GAAG;AACtC,SAAO,EAAE,SAAS,CAACK,GAAG,QAAQ,CAACC,GAAG,WAAW,CAACC,GAAG,OAAO,CAACC,EAAA;AAC3D;AAUO,SAASC,EAAgBC,GAAsB;AACpD,QAAMC,IAAW9B,EAAS,CAACG,MAAMA,EAAE,MAAM,MAAM,GACzC4B,IAAWC,EAAO,CAAC,GACnBC,IAAcD,EAAOH,CAAQ;AACnC,EAAAI,EAAY,UAAUJ,GAEtBK,EAAU,MAAM;AACd,IAAIH,EAAQ,UAAU,KAAKD,MAAU,KACnCG,EAAY,QAAA,GAEdF,EAAQ,UAAUD;AAAA,EACpB,GAAG,CAACA,CAAK,CAAC;AACZ;"}

package/dist/react-native.d.ts

@@ -0,0 +1,8 @@
+export { EidosProviderRN } from './react/ProviderRN';
+export type { EidosProviderRNProps } from './react/ProviderRN';
+export { initEidosRN, _resetEidosRN } from './runtime-rn';
+export type { EidosRNConfig } from './runtime-rn';
+export { setQueueStorage } from './index.ts';
+export type { QueueStorage } from './index.ts';
+export { AsyncStorageQueueStorage } from './index.ts';
+export type { AsyncStorageLike } from './index.ts';

package/dist/react-native.js

@@ -0,0 +1,59 @@
+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";
+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 });
+}
+let _initialized = false;
+let _unsubscribe = null;
+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" || q.status === "failed");
+    if (store.isOnline && hasPending) {
+      setTimeout(replayQueue, 1200);
+    }
+  }
+}
+function _resetEidosRN() {
+  _unsubscribe == null ? void 0 : _unsubscribe();
+  _unsubscribe = null;
+  _initialized = false;
+}
+export {
+  AsyncStorageQueueStorage2 as AsyncStorageQueueStorage,
+  EidosProviderRN,
+  _resetEidosRN,
+  initEidosRN,
+  setQueueStorage2 as setQueueStorage
+};