@sweidos/eidos 1.0.34 → 1.1.0

package/dist/sw-bridge.js

@@ -1,45 +1,45 @@
-import { useEidosStore as o } from "./store.js";
-let s = null, u = [];
-function v() {
+import { useEidosStore as i } from "./store.js";
+var s = null, o = [];
+function l() {
   return s;
 }
-async function w(t) {
+async function w(e) {
   if (typeof navigator > "u" || !("serviceWorker" in navigator)) {
-    o.getState().setSwStatus("unsupported");
+    i.getState().setSwStatus("unsupported");
     return;
   }
-  const e = o.getState();
-  e.setSwStatus("registering");
+  const t = i.getState();
+  t.setSwStatus("registering");
   try {
-    s = await navigator.serviceWorker.register(t, { scope: "/" }), await f(s), e.setSwStatus("active"), navigator.serviceWorker.addEventListener("message", S), window.addEventListener("online", () => e.setOnline(!0)), window.addEventListener("offline", () => e.setOnline(!1)), g();
+    s = await navigator.serviceWorker.register(e, { scope: "/" }), await f(s), t.setSwStatus("active"), navigator.serviceWorker.addEventListener("message", d), window.addEventListener("online", () => t.setOnline(!0)), window.addEventListener("offline", () => t.setOnline(!1)), S();
   } catch (n) {
-    e.setSwStatus("error", String(n));
+    t.setSwStatus("error", String(n));
   }
 }
-function f(t) {
-  return new Promise((e) => {
-    if (t.active) {
-      e();
+function f(e) {
+  return new Promise((t) => {
+    if (e.active) {
+      t();
       return;
     }
-    const n = t.installing ?? t.waiting;
+    const n = e.installing ?? e.waiting;
     if (!n) {
-      e();
+      t();
       return;
     }
-    const i = setTimeout(e, 1e4);
+    const a = setTimeout(t, 1e4);
     n.addEventListener("statechange", function r() {
-      n.state === "activated" && (clearTimeout(i), n.removeEventListener("statechange", r), e());
+      n.state === "activated" && (clearTimeout(a), n.removeEventListener("statechange", r), t());
     });
   });
 }
-function d(t) {
-  const e = s == null ? void 0 : s.active;
-  e ? e.postMessage(t) : u.push(t);
+function g(e) {
+  const t = s?.active;
+  t ? t.postMessage(e) : o.push(e);
 }
-let a = null;
-function E(t) {
-  a = t;
+var c = null;
+function E(e) {
+  c = e;
 }
 function p() {
   try {
@@ -48,58 +48,60 @@ function p() {
     return !1;
   }
 }
-function S(t) {
-  const e = t.data;
-  if (!(e != null && e.type)) return;
-  const n = o.getState(), { type: i, url: r } = e;
-  if (i === "EIDOS_BACKGROUND_SYNC") {
-    a == null || a();
+function d(e) {
+  const t = e.data;
+  if (!t?.type) return;
+  const n = i.getState(), { type: a, url: r } = t;
+  if (a === "EIDOS_BACKGROUND_SYNC") {
+    c?.();
     return;
   }
   if (r)
-    switch (i) {
+    switch (a) {
       case "EIDOS_CACHE_HIT": {
-        const c = n.resources[r];
+        const u = n.resources[r];
         n.updateResource(r, {
           status: "fresh",
           lastEvent: "cache-hit",
-          cacheHits: ((c == null ? void 0 : c.cacheHits) ?? 0) + 1
+          cacheHits: (u?.cacheHits ?? 0) + 1
         });
         break;
       }
-      case "EIDOS_CACHE_UPDATED": {
+      case "EIDOS_CACHE_UPDATED":
         n.updateResource(r, {
           status: "fresh",
           lastEvent: "cache-updated",
           cachedAt: Date.now()
         });
         break;
-      }
-      case "EIDOS_NETWORK_ERROR": {
+      case "EIDOS_NETWORK_ERROR":
         n.updateResource(r, {
           status: "error",
           lastEvent: "network-error"
         });
         break;
-      }
     }
 }
-function h(t) {
-  d({ type: "EIDOS_SIMULATE_OFFLINE", enabled: t }), o.getState().setOnline(!t);
+function h(e) {
+  g({
+    type: "EIDOS_SIMULATE_OFFLINE",
+    enabled: e
+  }), i.getState().setOnline(!e);
 }
-function g() {
-  const t = s == null ? void 0 : s.active;
-  if (t) {
-    for (const e of u) t.postMessage(e);
-    u = [];
+function S() {
+  const e = s?.active;
+  if (e) {
+    for (const t of o) e.postMessage(t);
+    o = [];
   }
 }
 export {
-  v as getSwRegistration,
+  l as getSwRegistration,
   p as isBgSyncSupported,
   E as registerBgSyncHandler,
   w as registerServiceWorker,
-  d as sendToWorker,
+  g as sendToWorker,
   h as setOfflineSimulation
 };
-//# sourceMappingURL=sw-bridge.js.map
+
+//# sourceMappingURL=sw-bridge.js.map

package/dist/testing.cjs

@@ -0,0 +1,165 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _sweidos_eidos = require("@sweidos/eidos");
+//#region src/testing.ts
+/**
+* @sweidos/eidos/testing
+*
+* Test helpers for Vitest, Jest, and Playwright.
+* Import only in test files — never in production code.
+*
+* All helpers work at the JS layer (no real SW or Cache API required).
+* Provide a `caches` mock when using getCachedEntry / clearEidosCache in jsdom.
+*/
+var _originalFetch = null;
+/**
+* Put Eidos into offline mode. Actions with `reliability: 'neverLose'` will
+* be queued instead of executed. Call `mockOnline()` to restore.
+*
+* @example
+* beforeEach(() => mockOffline())
+* afterEach(() => mockOnline())
+*/
+function mockOffline(options = {}) {
+	_sweidos_eidos.useEidosStore.getState().setOnline(false);
+	if (options.stubFetch && _originalFetch === null) {
+		_originalFetch = globalThis.fetch;
+		globalThis.fetch = () => Promise.reject(/* @__PURE__ */ new TypeError("Network request failed (stubbed by @sweidos/eidos/testing)"));
+	}
+}
+/**
+* Restore online mode. Removes any fetch stub installed by `mockOffline`.
+*/
+function mockOnline() {
+	_sweidos_eidos.useEidosStore.getState().setOnline(true);
+	if (_originalFetch !== null) {
+		globalThis.fetch = _originalFetch;
+		_originalFetch = null;
+	}
+}
+/**
+* Replay the action queue immediately and return the result.
+* Forces `isOnline = true` first so the replay is never skipped.
+*
+* @example
+* mockOffline()
+* await savePost(draft)        // queued
+* const result = await drainQueue()
+* expect(result.succeeded).toBe(1)
+*/
+async function drainQueue() {
+	_sweidos_eidos.useEidosStore.getState().setOnline(true);
+	return (0, _sweidos_eidos.replayQueue)();
+}
+/**
+* Wait until the action queue contains no pending or replaying items.
+* Resolves immediately if the queue is already clear.
+* Rejects with a timeout error if items remain after `timeout` ms.
+*
+* @example
+* mockOnline()
+* await waitForQueueDrain()
+* expect(getEidosState().queue).toHaveLength(0)
+*/
+function waitForQueueDrain(options = {}) {
+	const timeout = options.timeout ?? 5e3;
+	const interval = options.interval ?? 50;
+	const deadline = Date.now() + timeout;
+	return new Promise((resolve, reject) => {
+		function check() {
+			const { queue } = _sweidos_eidos.useEidosStore.getState();
+			const active = queue.filter((q) => q.status === "pending" || q.status === "replaying");
+			if (active.length === 0) {
+				resolve();
+				return;
+			}
+			if (Date.now() >= deadline) {
+				reject(/* @__PURE__ */ new Error(`[eidos/testing] waitForQueueDrain timed out after ${timeout}ms. ${active.length} item(s) still active (statuses: ${active.map((q) => q.status).join(", ")}).`));
+				return;
+			}
+			setTimeout(check, interval);
+		}
+		check();
+	});
+}
+/** Default Eidos cache namespace written by the service worker. */
+var EIDOS_CACHE_NAME = "eidos-resources-v1";
+/**
+* Read a cached Response for a URL from Eidos Cache Storage.
+* Returns `undefined` if the entry is not cached.
+*
+* Requires the Cache API (`caches` global). In jsdom, provide a mock (e.g.
+* `vitest-fetch-mock`, `jest-fetch-mock`, or a custom `setupFiles` polyfill).
+*
+* @example
+* const res = await getCachedEntry('/api/user/1')
+* expect(res).toBeDefined()
+* expect(await res!.json()).toMatchObject({ id: 1 })
+*/
+async function getCachedEntry(url, cacheName = EIDOS_CACHE_NAME) {
+	if (typeof caches === "undefined") return void 0;
+	return await (await caches.open(cacheName)).match(url) ?? void 0;
+}
+/**
+* Delete all entries from an Eidos cache namespace.
+* Call in `afterEach` to prevent cache state leaking between tests.
+*
+* @example
+* afterEach(() => clearEidosCache())
+*/
+async function clearEidosCache(cacheName = EIDOS_CACHE_NAME) {
+	if (typeof caches === "undefined") return;
+	await caches.delete(cacheName);
+}
+/**
+* Full reset — call in `beforeEach` to start each test from a clean slate.
+*
+* - Resets runtime initialisation flag (`_resetEidos`) so `initEidos()` can
+*   be called again without the duplicate-init guard firing.
+* - Clears IDB action queue and in-memory store queue.
+* - Restores online state and removes any fetch stub from `mockOffline`.
+* - Clears registered resource entries and resets SW status.
+*
+* @example
+* beforeEach(async () => {
+*   await resetEidos()
+* })
+*/
+async function resetEidos() {
+	(0, _sweidos_eidos._resetEidos)();
+	await (0, _sweidos_eidos.clearQueue)();
+	mockOnline();
+	_sweidos_eidos.useEidosStore.setState((s) => ({
+		...s,
+		resources: {},
+		swStatus: "idle",
+		swError: void 0
+	}));
+}
+/**
+* Return a plain-object snapshot of the current Eidos store state.
+* Useful for assertions without importing `useEidosStore` directly.
+*
+* @example
+* expect(getEidosState().isOnline).toBe(false)
+* expect(getEidosState().queue).toHaveLength(1)
+*/
+function getEidosState() {
+	const { isOnline, swStatus, swError, resources, queue } = _sweidos_eidos.useEidosStore.getState();
+	return {
+		isOnline,
+		swStatus,
+		swError,
+		resources,
+		queue
+	};
+}
+//#endregion
+exports.EIDOS_CACHE_NAME = EIDOS_CACHE_NAME;
+exports.clearEidosCache = clearEidosCache;
+exports.drainQueue = drainQueue;
+exports.getCachedEntry = getCachedEntry;
+exports.getEidosState = getEidosState;
+exports.mockOffline = mockOffline;
+exports.mockOnline = mockOnline;
+exports.resetEidos = resetEidos;
+exports.waitForQueueDrain = waitForQueueDrain;

package/dist/testing.js

@@ -1,86 +1,156 @@
-import { useEidosStore, replayQueue, _resetEidos, clearQueue } from "@sweidos/eidos";
-let _originalFetch = null;
+import { _resetEidos, clearQueue, replayQueue, useEidosStore } from "@sweidos/eidos";
+//#region src/testing.ts
+/**
+* @sweidos/eidos/testing
+*
+* Test helpers for Vitest, Jest, and Playwright.
+* Import only in test files — never in production code.
+*
+* All helpers work at the JS layer (no real SW or Cache API required).
+* Provide a `caches` mock when using getCachedEntry / clearEidosCache in jsdom.
+*/
+var _originalFetch = null;
+/**
+* Put Eidos into offline mode. Actions with `reliability: 'neverLose'` will
+* be queued instead of executed. Call `mockOnline()` to restore.
+*
+* @example
+* beforeEach(() => mockOffline())
+* afterEach(() => mockOnline())
+*/
 function mockOffline(options = {}) {
-  useEidosStore.getState().setOnline(false);
-  if (options.stubFetch && _originalFetch === null) {
-    _originalFetch = globalThis.fetch;
-    globalThis.fetch = () => Promise.reject(
-      new TypeError("Network request failed (stubbed by @sweidos/eidos/testing)")
-    );
-  }
+	useEidosStore.getState().setOnline(false);
+	if (options.stubFetch && _originalFetch === null) {
+		_originalFetch = globalThis.fetch;
+		globalThis.fetch = () => Promise.reject(/* @__PURE__ */ new TypeError("Network request failed (stubbed by @sweidos/eidos/testing)"));
+	}
 }
+/**
+* Restore online mode. Removes any fetch stub installed by `mockOffline`.
+*/
 function mockOnline() {
-  useEidosStore.getState().setOnline(true);
-  if (_originalFetch !== null) {
-    globalThis.fetch = _originalFetch;
-    _originalFetch = null;
-  }
+	useEidosStore.getState().setOnline(true);
+	if (_originalFetch !== null) {
+		globalThis.fetch = _originalFetch;
+		_originalFetch = null;
+	}
 }
+/**
+* Replay the action queue immediately and return the result.
+* Forces `isOnline = true` first so the replay is never skipped.
+*
+* @example
+* mockOffline()
+* await savePost(draft)        // queued
+* const result = await drainQueue()
+* expect(result.succeeded).toBe(1)
+*/
 async function drainQueue() {
-  useEidosStore.getState().setOnline(true);
-  return replayQueue();
+	useEidosStore.getState().setOnline(true);
+	return replayQueue();
 }
+/**
+* Wait until the action queue contains no pending or replaying items.
+* Resolves immediately if the queue is already clear.
+* Rejects with a timeout error if items remain after `timeout` ms.
+*
+* @example
+* mockOnline()
+* await waitForQueueDrain()
+* expect(getEidosState().queue).toHaveLength(0)
+*/
 function waitForQueueDrain(options = {}) {
-  const timeout = options.timeout ?? 5e3;
-  const interval = options.interval ?? 50;
-  const deadline = Date.now() + timeout;
-  return new Promise((resolve, reject) => {
-    function check() {
-      const { queue } = useEidosStore.getState();
-      const active = queue.filter(
-        (q) => q.status === "pending" || q.status === "replaying"
-      );
-      if (active.length === 0) {
-        resolve();
-        return;
-      }
-      if (Date.now() >= deadline) {
-        reject(
-          new Error(
-            `[eidos/testing] waitForQueueDrain timed out after ${timeout}ms. ${active.length} item(s) still active (statuses: ${active.map((q) => q.status).join(", ")}).`
-          )
-        );
-        return;
-      }
-      setTimeout(check, interval);
-    }
-    check();
-  });
+	const timeout = options.timeout ?? 5e3;
+	const interval = options.interval ?? 50;
+	const deadline = Date.now() + timeout;
+	return new Promise((resolve, reject) => {
+		function check() {
+			const { queue } = useEidosStore.getState();
+			const active = queue.filter((q) => q.status === "pending" || q.status === "replaying");
+			if (active.length === 0) {
+				resolve();
+				return;
+			}
+			if (Date.now() >= deadline) {
+				reject(/* @__PURE__ */ new Error(`[eidos/testing] waitForQueueDrain timed out after ${timeout}ms. ${active.length} item(s) still active (statuses: ${active.map((q) => q.status).join(", ")}).`));
+				return;
+			}
+			setTimeout(check, interval);
+		}
+		check();
+	});
 }
-const EIDOS_CACHE_NAME = "eidos-resources-v1";
+/** Default Eidos cache namespace written by the service worker. */
+var EIDOS_CACHE_NAME = "eidos-resources-v1";
+/**
+* Read a cached Response for a URL from Eidos Cache Storage.
+* Returns `undefined` if the entry is not cached.
+*
+* Requires the Cache API (`caches` global). In jsdom, provide a mock (e.g.
+* `vitest-fetch-mock`, `jest-fetch-mock`, or a custom `setupFiles` polyfill).
+*
+* @example
+* const res = await getCachedEntry('/api/user/1')
+* expect(res).toBeDefined()
+* expect(await res!.json()).toMatchObject({ id: 1 })
+*/
 async function getCachedEntry(url, cacheName = EIDOS_CACHE_NAME) {
-  if (typeof caches === "undefined") return void 0;
-  const cache = await caches.open(cacheName);
-  const match = await cache.match(url);
-  return match ?? void 0;
+	if (typeof caches === "undefined") return void 0;
+	return await (await caches.open(cacheName)).match(url) ?? void 0;
 }
+/**
+* Delete all entries from an Eidos cache namespace.
+* Call in `afterEach` to prevent cache state leaking between tests.
+*
+* @example
+* afterEach(() => clearEidosCache())
+*/
 async function clearEidosCache(cacheName = EIDOS_CACHE_NAME) {
-  if (typeof caches === "undefined") return;
-  await caches.delete(cacheName);
+	if (typeof caches === "undefined") return;
+	await caches.delete(cacheName);
 }
+/**
+* Full reset — call in `beforeEach` to start each test from a clean slate.
+*
+* - Resets runtime initialisation flag (`_resetEidos`) so `initEidos()` can
+*   be called again without the duplicate-init guard firing.
+* - Clears IDB action queue and in-memory store queue.
+* - Restores online state and removes any fetch stub from `mockOffline`.
+* - Clears registered resource entries and resets SW status.
+*
+* @example
+* beforeEach(async () => {
+*   await resetEidos()
+* })
+*/
 async function resetEidos() {
-  _resetEidos();
-  await clearQueue();
-  mockOnline();
-  useEidosStore.setState((s) => ({
-    ...s,
-    resources: {},
-    swStatus: "idle",
-    swError: void 0
-  }));
+	_resetEidos();
+	await clearQueue();
+	mockOnline();
+	useEidosStore.setState((s) => ({
+		...s,
+		resources: {},
+		swStatus: "idle",
+		swError: void 0
+	}));
 }
+/**
+* Return a plain-object snapshot of the current Eidos store state.
+* Useful for assertions without importing `useEidosStore` directly.
+*
+* @example
+* expect(getEidosState().isOnline).toBe(false)
+* expect(getEidosState().queue).toHaveLength(1)
+*/
 function getEidosState() {
-  const { isOnline, swStatus, swError, resources, queue } = useEidosStore.getState();
-  return { isOnline, swStatus, swError, resources, queue };
+	const { isOnline, swStatus, swError, resources, queue } = useEidosStore.getState();
+	return {
+		isOnline,
+		swStatus,
+		swError,
+		resources,
+		queue
+	};
 }
-export {
-  EIDOS_CACHE_NAME,
-  clearEidosCache,
-  drainQueue,
-  getCachedEntry,
-  getEidosState,
-  mockOffline,
-  mockOnline,
-  resetEidos,
-  waitForQueueDrain
-};
+//#endregion
+export { EIDOS_CACHE_NAME, clearEidosCache, drainQueue, getCachedEntry, getEidosState, mockOffline, mockOnline, resetEidos, waitForQueueDrain };

package/dist/version.js

@@ -1,5 +1,6 @@
-const o = "1.0.34";
+var r = "1.1.0";
 export {
-  o as VERSION
+  r as VERSION
 };
-//# sourceMappingURL=version.js.map
+
+//# sourceMappingURL=version.js.map

package/dist/vite.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let fs = require("fs");
+let path = require("path");
+//#region src/vite.ts
+/**
+* Vite plugin for Eidos.
+*
+* Automatically copies `eidos-sw.js` from the installed package into your
+* `public/` directory on every build and dev-server start, so the service
+* worker is always in sync with the installed package version.
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { eidos } from '@sweidos/eidos/vite'
+* import { defineConfig } from 'vite'
+*
+* export default defineConfig({
+*   plugins: [eidos()],
+* })
+* ```
+*/
+function eidos(options) {
+	const swDest = options?.swDest ?? "public/eidos-sw.js";
+	function copySW(root) {
+		const src = (0, path.resolve)(root, "node_modules/@sweidos/eidos/dist/eidos-sw.js");
+		if (!(0, fs.existsSync)(src)) {
+			console.warn("[eidos-vite] Could not locate eidos-sw.js in node_modules. Make sure @sweidos/eidos is installed.");
+			return;
+		}
+		const dest = (0, path.resolve)(root, swDest);
+		const destDir = (0, path.dirname)(dest);
+		if (!(0, fs.existsSync)(destDir)) (0, fs.mkdirSync)(destDir, { recursive: true });
+		(0, fs.copyFileSync)(src, dest);
+		console.log(`[eidos-vite] eidos-sw.js → ${swDest} ✓`);
+	}
+	return {
+		name: "eidos",
+		buildStart() {
+			copySW(process.cwd());
+		},
+		configureServer(server) {
+			copySW(server.config.root);
+		}
+	};
+}
+//#endregion
+exports.eidos = eidos;

package/dist/vite.js

@@ -1,31 +1,47 @@
-import { existsSync, mkdirSync, copyFileSync } from "fs";
-import { resolve, dirname } from "path";
+import { copyFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+//#region src/vite.ts
+/**
+* Vite plugin for Eidos.
+*
+* Automatically copies `eidos-sw.js` from the installed package into your
+* `public/` directory on every build and dev-server start, so the service
+* worker is always in sync with the installed package version.
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { eidos } from '@sweidos/eidos/vite'
+* import { defineConfig } from 'vite'
+*
+* export default defineConfig({
+*   plugins: [eidos()],
+* })
+* ```
+*/
 function eidos(options) {
-  const swDest = (options == null ? void 0 : options.swDest) ?? "public/eidos-sw.js";
-  function copySW(root) {
-    const src = resolve(root, "node_modules/@sweidos/eidos/dist/eidos-sw.js");
-    if (!existsSync(src)) {
-      console.warn(
-        "[eidos-vite] Could not locate eidos-sw.js in node_modules. Make sure @sweidos/eidos is installed."
-      );
-      return;
-    }
-    const dest = resolve(root, swDest);
-    const destDir = dirname(dest);
-    if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
-    copyFileSync(src, dest);
-    console.log(`[eidos-vite] eidos-sw.js → ${swDest} ✓`);
-  }
-  return {
-    name: "eidos",
-    buildStart() {
-      copySW(process.cwd());
-    },
-    configureServer(server) {
-      copySW(server.config.root);
-    }
-  };
+	const swDest = options?.swDest ?? "public/eidos-sw.js";
+	function copySW(root) {
+		const src = resolve(root, "node_modules/@sweidos/eidos/dist/eidos-sw.js");
+		if (!existsSync(src)) {
+			console.warn("[eidos-vite] Could not locate eidos-sw.js in node_modules. Make sure @sweidos/eidos is installed.");
+			return;
+		}
+		const dest = resolve(root, swDest);
+		const destDir = dirname(dest);
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		copyFileSync(src, dest);
+		console.log(`[eidos-vite] eidos-sw.js → ${swDest} ✓`);
+	}
+	return {
+		name: "eidos",
+		buildStart() {
+			copySW(process.cwd());
+		},
+		configureServer(server) {
+			copySW(server.config.root);
+		}
+	};
 }
-export {
-  eidos
-};
+//#endregion
+export { eidos };