@sweidos/eidos 1.0.33 → 1.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@sweidos/eidos?color=22C55E&label=npm)](https://www.npmjs.com/package/@sweidos/eidos)
 [![npm downloads](https://img.shields.io/npm/dm/@sweidos/eidos?color=22C55E)](https://www.npmjs.com/package/@sweidos/eidos)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/@sweidos/eidos?label=minzip&color=22C55E)](https://bundlephobia.com/package/@sweidos/eidos)
+[![bundle size](https://deno.bundlejs.com/badge?q=@sweidos/eidos&badge=detailed&color=22C55E)](https://bundlejs.com/?q=@sweidos/eidos)
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-22C55E)](https://www.typescriptlang.org/)
 [![CI](https://github.com/iamadi11/eidos/actions/workflows/deploy.yml/badge.svg)](https://github.com/iamadi11/eidos/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-22C55E.svg)](LICENSE)
@@ -12,10 +12,10 @@
 Declare what your app needs offline. Eidos picks the cache strategy, registers the Service Worker, and persists your action queue to IndexedDB — automatically.
 
 ```ts
-import { resource, action } from '@sweidos/eidos'
+import { resource, action } from '@sweidos/eidos';
 
-const products = resource('/api/products', { offline: true })
-const createOrder = action(orderApi.create, { reliability: 'neverLose' })
+const products = resource('/api/products', { offline: true });
+const createOrder = action(orderApi.create, { reliability: 'neverLose' });
 ```
 
 No service worker file to write. No cache strategy to configure. No retry logic to implement.
@@ -60,12 +60,12 @@ npm install @sweidos/eidos
 
 ```ts
 // vite.config.ts
-import { eidos } from '@sweidos/eidos/vite'
-import { defineConfig } from 'vite'
+import { eidos } from '@sweidos/eidos/vite';
+import { defineConfig } from 'vite';
 
 export default defineConfig({
   plugins: [eidos()],
-})
+});
 ```
 
 > **Without Vite** — copy manually: `cp node_modules/@sweidos/eidos/dist/eidos-sw.js public/`
@@ -74,39 +74,39 @@ export default defineConfig({
 
 ```tsx
 // main.tsx
-import { EidosProvider } from '@sweidos/eidos'
-import { createRoot } from 'react-dom/client'
-import { App } from './App'
+import { EidosProvider } from '@sweidos/eidos';
+import { createRoot } from 'react-dom/client';
+import { App } from './App';
 
 createRoot(document.getElementById('root')!).render(
   <EidosProvider swPath="/eidos-sw.js">
     <App />
-  </EidosProvider>
-)
+  </EidosProvider>,
+);
 ```
 
 ```ts
 // src/lib/eidos.ts  ← module scope required for queue replay after reload
-import { resource, action } from '@sweidos/eidos'
+import { resource, action } from '@sweidos/eidos';
 
-export const products = resource('/api/products', { offline: true })
+export const products = resource('/api/products', { offline: true });
 
 export const createOrder = action(
   async (payload: OrderPayload) => {
-    const res = await fetch('/api/orders', { method: 'POST', body: JSON.stringify(payload) })
-    return res.json()
+    const res = await fetch('/api/orders', { method: 'POST', body: JSON.stringify(payload) });
+    return res.json();
   },
   { reliability: 'neverLose', name: 'createOrder' },
-)
+);
 ```
 
 ```tsx
 // In components — works the same online and offline
-const result = await createOrder({ productId: 1, qty: 2 })
+const result = await createOrder({ productId: 1, qty: 2 });
 
 if ('queued' in result) {
   // Saved to IndexedDB — replays automatically on reconnect
-  console.log(result.message)
+  console.log(result.message);
 }
 ```
 
@@ -114,35 +114,35 @@ if ('queued' in result) {
 
 ## What you get
 
-| Feature | Description |
-|---------|-------------|
-| **Auto strategy selection** | `offline: true` → StaleWhileRevalidate. No config needed. Override when you want. |
-| **Persistent action queue** | Failed writes go to IndexedDB and replay with exponential backoff on reconnect. |
-| **Request deduplication** | Concurrent `resource.fetch()` calls share one in-flight request. |
-| **Optimistic updates** | `onOptimistic` / `onRollback` callbacks for instant UI feedback. |
-| **Conflict resolution** | `onConflict` decides per 4xx whether to retry or drop a queued action. |
-| **Queue prioritization** | `priority: 'high' | 'normal' | 'low'` — high items replay before normal. |
-| **Cache warming** | `warmCache(handles[])` bulk-prefetches resources on login/init. |
-| **URL patterns** | `/api/products/*`, `/api/users/:id`, `**` wildcards — SW intercepts all matches. |
-| **Background Sync** | Registers a `sync` tag so queued actions replay even after tab close. |
-| **Devtools panel** | `<EidosDevtools />` — live queue, cache state, offline toggle, no CSS import. |
-| **Testing helpers** | `mockOffline`, `drainQueue`, `resetEidos`, `getCachedEntry` for Vitest/Jest. |
-| **OpenAPI codegen** | `npx eidos-gen openapi.json` generates typed `resource()` + `action()` declarations. |
+| Feature                     | Description                                                                          |
+| --------------------------- | ------------------------------------------------------------------------------------ |
+| **Auto strategy selection** | `offline: true` → StaleWhileRevalidate. No config needed. Override when you want.    |
+| **Persistent action queue** | Failed writes go to IndexedDB and replay with exponential backoff on reconnect.      |
+| **Request deduplication**   | Concurrent `resource.fetch()` calls share one in-flight request.                     |
+| **Optimistic updates**      | `onOptimistic` / `onRollback` callbacks for instant UI feedback.                     |
+| **Conflict resolution**     | `onConflict` decides per 4xx whether to retry or drop a queued action.               |
+| **Queue prioritization**    | `priority: 'high' \| 'normal' \| 'low'` — high items replay before normal.           |
+| **Cache warming**           | `warmCache(handles[])` bulk-prefetches resources on login/init.                      |
+| **URL patterns**            | `/api/products/*`, `/api/users/:id`, `**` wildcards — SW intercepts all matches.     |
+| **Background Sync**         | Registers a `sync` tag so queued actions replay even after tab close.                |
+| **Devtools panel**          | `<EidosDevtools />` — live queue, cache state, offline toggle, no CSS import.        |
+| **Testing helpers**         | `mockOffline`, `drainQueue`, `resetEidos`, `getCachedEntry` for Vitest/Jest.         |
+| **OpenAPI codegen**         | `npx eidos-gen openapi.json` generates typed `resource()` + `action()` declarations. |
 
 ---
 
 ## Framework support
 
-| Framework | Import path | Notes |
-|-----------|-------------|-------|
-| **React** | `@sweidos/eidos` | Hooks + `EidosProvider` |
-| **Next.js App Router** | `@sweidos/eidos/nextjs` | Pre-marked `'use client'` — no wrapper needed |
-| **SvelteKit** | `@sweidos/eidos/sveltekit` | `initEidosSvelteKit()` in `onMount`, framework-agnostic stores |
-| **Vue** | `@sweidos/eidos` | Framework-agnostic stores via `eidosStatus.subscribe()` |
-| **React Native** | `@sweidos/eidos/react-native` | AsyncStorage-backed queue, same `action()` API |
-| **Vanilla JS** | `@sweidos/eidos` | `eidosStatus`, `eidosQueue`, `eidosQueueStats` stores |
-| **Vite** | `@sweidos/eidos/vite` | Plugin auto-copies `eidos-sw.js` on every build |
-| **TanStack Query** | `@sweidos/eidos/query` | `useEidosQuery`, `useEidosMutation`, `withEidosQueryClient` |
+| Framework              | Import path                   | Notes                                                          |
+| ---------------------- | ----------------------------- | -------------------------------------------------------------- |
+| **React**              | `@sweidos/eidos`              | Hooks + `EidosProvider`                                        |
+| **Next.js App Router** | `@sweidos/eidos/nextjs`       | Pre-marked `'use client'` — no wrapper needed                  |
+| **SvelteKit**          | `@sweidos/eidos/sveltekit`    | `initEidosSvelteKit()` in `onMount`, framework-agnostic stores |
+| **Vue**                | `@sweidos/eidos`              | Framework-agnostic stores via `eidosStatus.subscribe()`        |
+| **React Native**       | `@sweidos/eidos/react-native` | AsyncStorage-backed queue, same `action()` API                 |
+| **Vanilla JS**         | `@sweidos/eidos`              | `eidosStatus`, `eidosQueue`, `eidosQueueStats` stores          |
+| **Vite**               | `@sweidos/eidos/vite`         | Plugin auto-copies `eidos-sw.js` on every build                |
+| **TanStack Query**     | `@sweidos/eidos/query`        | `useEidosQuery`, `useEidosMutation`, `withEidosQueryClient`    |
 
 ---
 
@@ -169,11 +169,11 @@ products.query()                 // { queryKey, queryFn } for useQuery
 
 **Auto-selected strategy:**
 
-| Config | Strategy | Use when |
-|--------|----------|----------|
-| `offline: true` | StaleWhileRevalidate | Default — fast + background refresh |
-| `offline: true, strategy: 'cache-first'` | CacheFirst | Static assets, config data |
-| `offline: true, strategy: 'network-first'` | NetworkFirst | Always-fresh with offline fallback |
+| Config                                     | Strategy             | Use when                            |
+| ------------------------------------------ | -------------------- | ----------------------------------- |
+| `offline: true`                            | StaleWhileRevalidate | Default — fast + background refresh |
+| `offline: true, strategy: 'cache-first'`   | CacheFirst           | Static assets, config data          |
+| `offline: true, strategy: 'network-first'` | NetworkFirst         | Always-fresh with offline fallback  |
 
 URL patterns work on any handle: `/api/products/*`, `/api/users/:id`, `**`
 
@@ -194,11 +194,11 @@ const createOrder = action(async (payload: OrderPayload) => { ... }, {
 ### React hooks
 
 ```ts
-const { isOnline, swStatus }    = useEidosStatus()
-const { pending, failed }       = useEidosQueueStats()
-const entry                     = useEidosResource('/api/products')
-const item                      = useEidosAction(queuedResult.id)
-useEidosOnDrain(() => toast('All offline actions synced!'))
+const { isOnline, swStatus } = useEidosStatus();
+const { pending, failed } = useEidosQueueStats();
+const entry = useEidosResource('/api/products');
+const item = useEidosAction(queuedResult.id);
+useEidosOnDrain(() => toast('All offline actions synced!'));
 ```
 
 ### Framework-agnostic stores
@@ -217,18 +217,18 @@ eidosResource('/api/products').getState() // ResourceEntry | undefined
 
 ```ts
 // main.tsx — register once
-withEidosQueryClient(queryClient)
+withEidosQueryClient(queryClient);
 
 // In components
-const { data, isPending } = useEidosQuery<Product[]>(products)
+const { data, isPending } = useEidosQuery<Product[]>(products);
 
 const mutation = useEidosMutation(createOrder, {
   invalidates: [products], // clears cache + invalidates TQ on success
   onSuccess(data) {
-    if ('queued' in data) toast('Saved offline')
-    else toast(`Order #${data.id} created`)
+    if ('queued' in data) toast('Saved offline');
+    else toast(`Order #${data.id} created`);
   },
-})
+});
 ```
 
 ---
@@ -237,25 +237,30 @@ const mutation = useEidosMutation(createOrder, {
 
 ```ts
 import {
-  mockOffline, mockOnline, drainQueue,
-  waitForQueueDrain, getCachedEntry,
-  clearEidosCache, resetEidos, getEidosState,
-} from '@sweidos/eidos/testing'
-
-beforeEach(() => resetEidos())
+  mockOffline,
+  mockOnline,
+  drainQueue,
+  waitForQueueDrain,
+  getCachedEntry,
+  clearEidosCache,
+  resetEidos,
+  getEidosState,
+} from '@sweidos/eidos/testing';
+
+beforeEach(() => resetEidos());
 
 it('queues action while offline', async () => {
-  mockOffline()
-  await createOrder({ productId: 1, qty: 2 })
-  expect(getEidosState().queue).toHaveLength(1)
-})
+  mockOffline();
+  await createOrder({ productId: 1, qty: 2 });
+  expect(getEidosState().queue).toHaveLength(1);
+});
 
 it('replays on reconnect', async () => {
-  mockOffline()
-  await createOrder({ productId: 1, qty: 2 })
-  const result = await drainQueue()
-  expect(result.succeeded).toBe(1)
-})
+  mockOffline();
+  await createOrder({ productId: 1, qty: 2 });
+  const result = await drainQueue();
+  expect(result.succeeded).toBe(1);
+});
 ```
 
 ---
@@ -274,10 +279,12 @@ Handles path params, `$ref` resolution, request/response types, DELETE body omis
 ## Devtools
 
 ```tsx
-import { EidosDevtools } from '@sweidos/eidos/devtools'
+import { EidosDevtools } from '@sweidos/eidos/devtools';
 
 // Drop anywhere — bottom-right floating panel, no CSS import
-{process.env.NODE_ENV === 'development' && <EidosDevtools />}
+{
+  process.env.NODE_ENV === 'development' && <EidosDevtools />;
+}
 ```
 
 Panel shows: live queue state · cache entries · SW status · offline simulation toggle.
@@ -296,12 +303,32 @@ Panel shows: live queue state · cache entries · SW status · offline simulatio
 
 ## Known limitations
 
-| Limitation | Detail |
-|------------|--------|
-| GET-only caching | SW intercepts `GET` only. Mutations go through `action()`. |
-| Module-scope actions | `action()` must be at module scope so functions are registered before a reload triggers replay. |
-| Single SW | Assumes one SW at the configured `swPath`. |
-| React Native resources | In-memory only — no Cache API or SW in RN. Action queue fully persists. |
+| Limitation             | Detail                                                                                          |
+| ---------------------- | ----------------------------------------------------------------------------------------------- |
+| GET-only caching       | SW intercepts `GET` only. Mutations go through `action()`.                                      |
+| Module-scope actions   | `action()` must be at module scope so functions are registered before a reload triggers replay. |
+| Single SW              | Assumes one SW at the configured `swPath`.                                                      |
+| React Native resources | In-memory only — no Cache API or SW in RN. Action queue fully persists.                         |
+
+---
+
+## How it compares
+
+|                            | **Eidos**                                                                                   | Workbox                                    | RTK Query / TanStack Query                                      |
+| -------------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------ | --------------------------------------------------------------- |
+| Service worker setup       | Generated for you — `resource()`/`action()` declarations drive the SW                       | Hand-write `routing` + `strategies` config | None — no SW                                                    |
+| Caching strategy           | Auto-derived from intent (`offline: true` → SWR, etc.), inspectable via devtools            | Manually chosen per route                  | Configurable `staleTime`/`gcTime`, no Cache Storage integration |
+| Offline writes             | `action()` + `reliability: 'neverLose'` → IndexedDB queue, auto-replay, exponential backoff | Background Sync plugin, you wire the queue | No built-in offline mutation queue                              |
+| Framework support          | React, Svelte, Vue, Next.js, React Native, vanilla JS                                       | Framework-agnostic (SW only)               | Per-library (RTK Query = Redux, TanStack = many)                |
+| TanStack Query bridge      | `@sweidos/eidos/query` — drop-in `useEidosQuery`/`useEidosMutation`                         | —                                          | Native                                                          |
+| Bundle size (core, brotli) | ~5.4 kB                                                                                     | ~3-6 kB (modular)                          | ~13 kB (TanStack Query core)                                    |
+
+Eidos isn't a replacement for TanStack Query — `@sweidos/eidos/query` is a thin
+adapter so you keep TQ's cache/devtools while Eidos owns the offline layer
+(SW caching + IndexedDB write queue). Workbox is a lower-level toolkit Eidos
+generates strategies _for_; Eidos picks and configures the strategy from your
+`resource()`/`action()` declarations instead of you writing `workbox-*` config
+by hand.
 
 ---
 

package/dist/action.js

@@ -1,69 +1,66 @@
-import { useEidosStore as d } from "./store.js";
-import { getSwRegistration as b } from "./sw-bridge.js";
-import { idbClearQueue as g, idbRemoveFromQueue as Q, idbUpdateQueueItem as h, idbGetPendingItems as I, idbGetQueue as R, idbAddToQueue as k } from "./idb.js";
-import { _getQueueStorage as v } from "./queue-storage.js";
-const l = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), S = {
-  add: (e) => k(e),
-  getAll: () => R(),
-  getPending: () => I(),
-  update: (e, t) => h(e, t),
-  remove: (e) => Q(e),
-  clear: () => g()
-};
-function o() {
-  return v() ?? S;
+import { useEidosStore as s } from "./store.js";
+import { getSwRegistration as w } from "./sw-bridge.js";
+import { idbQueueStorage as g } from "./idb.js";
+import { _getQueueStorage as m } from "./queue-storage.js";
+var d = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map();
+function u() {
+  return m() ?? g;
 }
-function m() {
+function y() {
   return crypto.randomUUID();
 }
-function U(e, t) {
-  const r = t.name || e.name || m();
-  l.set(r, e), t.onRollback && f.set(r, t.onRollback), t.onConflict && y.set(r, t.onConflict);
-  const u = async (...a) => {
-    var i, s;
-    const { isOnline: n } = d.getState();
-    if ((i = t.onOptimistic) == null || i.call(t, ...a), t.reliability === "neverLose") {
-      if (!n)
-        return p(r, r, a, t);
+function C(e, t) {
+  const r = t.name || e.name || y();
+  d.set(r, e), t.onRollback && p.set(r, t.onRollback), t.onConflict && f.set(r, t.onConflict);
+  const a = async (...i) => {
+    const { isOnline: n } = s.getState();
+    if (t.onOptimistic?.(...i), t.reliability === "neverLose") {
+      if (!n) return l(r, r, i, t);
       try {
-        return await e(...a);
+        return await e(...i);
       } catch {
-        return p(r, r, a, t);
+        return l(r, r, i, t);
       }
     }
     try {
-      return await e(...a);
-    } catch (w) {
-      throw (s = t.onRollback) == null || s.call(t, ...a), w;
+      return await e(...i);
+    } catch (o) {
+      throw t.onRollback?.(...i), o;
     }
   };
-  return Object.defineProperty(u, "id", { value: r, writable: !1 }), Object.defineProperty(u, "config", { value: t, writable: !1 }), u;
+  return Object.defineProperty(a, "id", {
+    value: r,
+    writable: !1
+  }), Object.defineProperty(a, "config", {
+    value: t,
+    writable: !1
+  }), a;
 }
-async function p(e, t, r, u) {
-  const a = m(), n = {
-    id: a,
+async function l(e, t, r, a) {
+  const i = y(), n = {
+    id: i,
     actionId: e,
     actionName: t,
     args: r,
     queuedAt: Date.now(),
     retryCount: 0,
-    maxRetries: u.maxRetries ?? 3,
+    maxRetries: a.maxRetries ?? 3,
     status: "pending",
-    priority: u.priority ?? "normal"
+    priority: a.priority ?? "normal"
   };
-  await o().add(n), d.getState().addQueueItem(n);
+  await u().add(n), s.getState().addQueueItem(n);
   try {
-    const i = b();
-    i && "sync" in i && await i.sync.register("eidos-queue-replay");
+    const o = w();
+    o && "sync" in o && await o.sync.register("eidos-queue-replay");
   } catch {
   }
   return {
     queued: !0,
-    id: a,
+    id: i,
     message: `"${t}" queued — will execute when online`
   };
 }
-function x(e) {
+function h(e) {
   if (e instanceof Response) return e.status >= 400 && e.status < 500;
   if (typeof e == "object" && e !== null) {
     const t = e.status;
@@ -71,76 +68,112 @@ function x(e) {
   }
   return !1;
 }
-function C(e) {
+function R(e) {
   return Math.min(2e3 * 2 ** e, 3e5) * (0.8 + Math.random() * 0.4);
 }
-let c = !1;
-async function j() {
-  const e = d.getState();
-  if (!e.isOnline || c)
-    return { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0, conflicted: 0 };
+var c = !1;
+async function _() {
+  const e = s.getState();
+  if (!e.isOnline || c) return {
+    attempted: 0,
+    succeeded: 0,
+    failed: 0,
+    retrying: 0,
+    skipped: 0,
+    conflicted: 0
+  };
   c = !0;
   try {
-    return await M(e);
+    return await Q(e);
   } finally {
     c = !1;
   }
 }
-async function _(e, t) {
-  var u;
-  const r = l.get(e.actionId);
+async function b(e, t) {
+  const r = d.get(e.actionId);
   if (!r) return "skipped";
   try {
     await r(...e.args);
     const a = Date.now();
-    return t.updateQueueItem(e.id, { status: "succeeded", completedAt: a }), await o().update(e.id, { status: "succeeded", completedAt: a }), setTimeout(() => {
-      t.removeQueueItem(e.id), o().remove(e.id);
+    return t.updateQueueItem(e.id, {
+      status: "succeeded",
+      completedAt: a
+    }), await u().update(e.id, {
+      status: "succeeded",
+      completedAt: a
+    }), setTimeout(() => {
+      t.removeQueueItem(e.id), u().remove(e.id);
     }, 3e3), "succeeded";
   } catch (a) {
-    if (x(a)) {
-      const i = y.get(e.actionId);
-      if (i && i(a, e.args) === "skip")
-        return t.removeQueueItem(e.id), await o().remove(e.id), "conflicted";
+    if (h(a)) {
+      const n = f.get(e.actionId);
+      if (n && n(a, e.args) === "skip")
+        return t.removeQueueItem(e.id), await u().remove(e.id), "conflicted";
     }
-    const n = e.retryCount + 1;
-    if (n >= e.maxRetries)
-      return t.updateQueueItem(e.id, { status: "failed", error: String(a), retryCount: n }), await o().update(e.id, { status: "failed", error: String(a), retryCount: n }), (u = f.get(e.actionId)) == null || u(...e.args), "failed";
+    const i = e.retryCount + 1;
+    if (i >= e.maxRetries)
+      return t.updateQueueItem(e.id, {
+        status: "failed",
+        error: String(a),
+        retryCount: i
+      }), await u().update(e.id, {
+        status: "failed",
+        error: String(a),
+        retryCount: i
+      }), p.get(e.actionId)?.(...e.args), "failed";
     {
-      const i = Date.now() + C(n);
-      return t.updateQueueItem(e.id, { status: "pending", retryCount: n, nextRetryAt: i }), await o().update(e.id, { status: "pending", retryCount: n, nextRetryAt: i }), "retrying";
+      const n = Date.now() + R(i);
+      return t.updateQueueItem(e.id, {
+        status: "pending",
+        retryCount: i,
+        nextRetryAt: n
+      }), await u().update(e.id, {
+        status: "pending",
+        retryCount: i,
+        nextRetryAt: n
+      }), "retrying";
     }
   }
 }
-async function A(e, t, r) {
+async function I(e, t, r) {
   if (e.length === 0) return;
-  const u = e.filter((n) => l.has(n.actionId));
-  if (r.skipped += e.length - u.length, u.length > 0) {
-    t.batchUpdateQueueItems(u.map((n) => ({ id: n.id, update: { status: "replaying" } })));
-    for (const n of u)
-      o().update(n.id, { status: "replaying" });
+  const a = e.filter((n) => d.has(n.actionId));
+  if (r.skipped += e.length - a.length, a.length > 0) {
+    t.batchUpdateQueueItems(a.map((n) => ({
+      id: n.id,
+      update: { status: "replaying" }
+    })));
+    for (const n of a) u().update(n.id, { status: "replaying" });
   }
-  const a = await Promise.allSettled(u.map((n) => _(n, t)));
-  for (const n of a) {
-    const i = n.status === "fulfilled" ? n.value : "failed";
-    i === "skipped" ? r.skipped++ : i === "conflicted" ? r.conflicted++ : (r.attempted++, r[i]++);
+  const i = await Promise.allSettled(a.map((n) => b(n, t)));
+  for (const n of i) {
+    const o = n.status === "fulfilled" ? n.value : "failed";
+    o === "skipped" ? r.skipped++ : o === "conflicted" ? r.conflicted++ : (r.attempted++, r[o]++);
   }
 }
-async function M(e) {
-  const t = await o().getPending(), r = Date.now(), u = t.filter(
-    (n) => n.retryCount < n.maxRetries && (!n.nextRetryAt || n.nextRetryAt <= r)
-  ), a = { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0, conflicted: 0 };
-  for (const n of ["high", "normal", "low"]) {
-    const i = u.filter((s) => (s.priority ?? "normal") === n);
-    await A(i, e, a);
-  }
-  return a;
+async function Q(e) {
+  const t = await u().getPending(), r = Date.now(), a = t.filter((n) => n.retryCount < n.maxRetries && (!n.nextRetryAt || n.nextRetryAt <= r)), i = {
+    attempted: 0,
+    succeeded: 0,
+    failed: 0,
+    retrying: 0,
+    skipped: 0,
+    conflicted: 0
+  };
+  for (const n of [
+    "high",
+    "normal",
+    "low"
+  ]) await I(a.filter((o) => (o.priority ?? "normal") === n), e, i);
+  return i;
 }
-async function T() {
-  await o().clear(), d.getState().hydrateQueue([]);
+async function A() {
+  await u().clear(), s.getState().hydrateQueue([]);
 }
 export {
-  U as action,
-  T as clearQueue,
-  j as replayQueue
+  C as action,
+  A as clearQueue,
+  _ as replayQueue
 };
-//# sourceMappingURL=action.js.map
+
+//# sourceMappingURL=action.js.map

package/dist/async-storage-adapter.js

@@ -1,5 +1,4 @@
-const i = "@eidos:queue";
-class l {
+var i = "@eidos:queue", l = class {
   constructor(t) {
     this.storage = t;
   }
@@ -15,28 +14,32 @@ class l {
     await this.storage.setItem(i, JSON.stringify(t));
   }
   async add(t) {
-    const e = await this.readAll();
-    e.push(t), await this.writeAll(e);
+    const a = await this.readAll();
+    a.push(t), await this.writeAll(a);
   }
   async getAll() {
     return this.readAll();
   }
   async getPending() {
-    return (await this.readAll()).filter((e) => e.status === "pending" || e.status === "failed");
+    return (await this.readAll()).filter((t) => t.status === "pending" || t.status === "failed");
   }
-  async update(t, e) {
-    const a = await this.readAll(), s = a.findIndex((r) => r.id === t);
-    s !== -1 && (a[s] = { ...a[s], ...e }), await this.writeAll(a);
+  async update(t, a) {
+    const e = await this.readAll(), s = e.findIndex((r) => r.id === t);
+    s !== -1 && (e[s] = {
+      ...e[s],
+      ...a
+    }), await this.writeAll(e);
   }
   async remove(t) {
-    const e = await this.readAll();
-    await this.writeAll(e.filter((a) => a.id !== t));
+    const a = await this.readAll();
+    await this.writeAll(a.filter((e) => e.id !== t));
   }
   async clear() {
     await this.storage.removeItem(i);
   }
-}
+};
 export {
   l as AsyncStorageQueueStorage
 };
-//# sourceMappingURL=async-storage-adapter.js.map
+
+//# sourceMappingURL=async-storage-adapter.js.map