@lls/offline 24.27.0 → 24.28.0-0854ed80

package/lib/index.js

@@ -13,7 +13,7 @@ var tryCatch = (fn) => {
 var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const dic = {};
   const cbks = {};
-  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+  const fn = ({ source, data: { eventId, methodName, results, error, arg } = {} }) => {
     if (eventId && eventId in dic) {
       if (error) {
         dic[eventId].reject(error);
@@ -21,22 +21,38 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
         dic[eventId].resolve(results);
       }
     } else {
-      if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
+      if (methodName && !(methodName in cbks)) {
         console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
       }
     }
-    methodName && cbks[methodName]?.(arg);
+    methodName && cbks[methodName]?.({ source, ...arg });
   };
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
-        dic[eventId] = { resolve, reject };
-        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          console.warn("slow request for", methodName, arg, eventId);
+        }, 3e3);
+        const doResolve = (arg2) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            resolve(arg2);
+          }
+        };
+        dic[eventId] = { resolve: doResolve, reject };
+        if (ports) {
+          offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+        } else {
+          offlineWorker2.postMessage({ eventId, methodName, arg });
+        }
       });
     };
   };
-  const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
+  const fns = Object.fromEntries(methodNames.map((name) => [name, makeFn(name)]));
+  const obj = Object.assign(fns, {
     on: (key, fn2) => {
       cbks[key] = fn2;
     }
@@ -53,42 +69,45 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => ({
+  (services) => ({
     canHandle: (methodName) => {
       return methodName in services;
     },
-    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+    handle: async ({ data: { eventId, methodName, arg } = {}, source, ports, target }) => {
+      const emitter = source?.postMessage && source || target?.postMessage && target || self;
       try {
         if (typeof methodName === "string" && methodName in services && services[methodName]) {
           const results = await services[methodName](arg, { ports });
-          sender.postMessage({ eventId, methodName, results });
+          emitter.postMessage({ eventId, methodName, results });
           return;
         }
         throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
       } catch (e) {
         console.debug("failed", e);
-        sender.postMessage({ eventId, methodName, error: e });
+        emitter.postMessage({ eventId, methodName, error: e });
       }
     }
   })
 );
 var combineHandlers = (...handlers) => {
-  return ({ data: { methodName, ...data } = {}, ports }) => {
+  return (message) => {
+    const methodName = String("methodName" in message.data ? message.data.methodName : "");
     for (const h of handlers) {
-      if (h.canHandle(String(methodName))) {
-        return h.handle({ data: { methodName, ...data }, ports });
+      if (h.canHandle(methodName)) {
+        return h.handle(message);
       }
     }
     console.error("no handlers matched", methodName);
   };
 };
+var clearCache = async (mode) => caches.delete(`LLS_OFFLINE_${mode}`);
 
 // src/hooks/useOfflineWorker.ts
 import { useCallback, useEffect, useState } from "react";
 var offlineWorker = new Worker("/src/worker/offline-worker.js", { type: "module" });
 var { handler, ...offlineWorkerSync } = makeSyncWorker(
   offlineWorker,
-  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook"],
+  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook", "reset"],
   "app:offlineWorker"
 );
 var fetchWorkerPromise = new Promise(
@@ -112,14 +131,6 @@ var fetchWorkerPromise = new Promise(
     return fetchWorker;
   })
 );
-var setWorkersReady;
-var workersReadyPromise = new Promise((resolve) => {
-  setWorkersReady = resolve;
-});
-var setBooksLoaded;
-var setBooksLoadedPromise = new Promise((resolve) => {
-  setBooksLoaded = resolve;
-});
 var installWorker = async ({
   skipLoadBooks = false,
   primaryOnly = false,
@@ -134,7 +145,7 @@ var installWorker = async ({
   const fetchWorker = await fetchWorkerPromise;
   const configureOptions = { storage, zipBaseUrl, checkUpdates, confEnv };
   if (nativeReadFile) {
-    const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
+    const wwHandler = makeSyncHandler({ nativeReadFile, nativeWriteFile, nativeListZips });
     offlineWorker.onmessage = combineHandlers(handler, wwHandler);
     if (storage !== "native") {
       console.warn("nativeReadFile given, ignoring storage", storage);
@@ -142,13 +153,17 @@ var installWorker = async ({
     offlineWorkerSync.configure({ ...configureOptions, storage: "native" });
   } else {
     offlineWorker.onmessage = handler.handle;
-    offlineWorkerSync.configure(configureOptions);
+    await offlineWorkerSync.configure(configureOptions);
   }
-  offlineWorkerSync.on("ready", setWorkersReady);
   const channel = new MessageChannel();
-  offlineWorkerSync.initChannel({ ports: [channel.port1] });
-  fetchWorker.postMessage({ methodName: "initChannel" }, [channel.port2]);
-  fetchWorker.postMessage({ methodName: "configure", arg: { storage, confEnv } });
+  await offlineWorkerSync.initChannel({ ports: [channel.port1] });
+  const { handler: fetchWorkerHandler, ...fetchWorkerSync } = makeSyncWorker(fetchWorker, [
+    "initChannel",
+    "configure"
+  ]);
+  navigator.serviceWorker.onmessage = combineHandlers(fetchWorkerHandler);
+  await fetchWorkerSync.initChannel({ ports: [channel.port2] });
+  await fetchWorkerSync.configure({ storage, confEnv });
   offlineWorkerSync.on("opfsProgress", () => {
   });
   if (!primaryOnly) {
@@ -157,9 +172,9 @@ var installWorker = async ({
   if (!skipLoadBooks) {
     await offlineWorkerSync.loadBooks({ primaryOnly });
   }
-  setBooksLoaded();
 };
 var useOfflineWorker_default = ({
+  skipLoadBooks,
   primaryOnly = false,
   nativeReadFile,
   nativeWriteFile,
@@ -173,6 +188,7 @@ var useOfflineWorker_default = ({
   useEffect(() => {
     const fn = async () => {
       await installWorker({
+        skipLoadBooks,
         primaryOnly,
         nativeReadFile,
         nativeWriteFile,
@@ -182,24 +198,73 @@ var useOfflineWorker_default = ({
         checkUpdates,
         confEnv
       });
-      await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
       fetch(window.location.href.replace(window.location.search, ""));
       setReady(true);
     };
     fn();
-  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
+  }, [
+    skipLoadBooks,
+    primaryOnly,
+    nativeReadFile,
+    nativeWriteFile,
+    nativeListZips,
+    storage,
+    zipBaseUrl,
+    checkUpdates,
+    confEnv
+  ]);
   const loadBook = useCallback(
-    async ({ id, forceRefresh }, cbk) => {
-      offlineWorkerSync.on("opfsProgress", cbk);
-      return await offlineWorkerSync.loadBook({ id, forceRefresh });
+    async ({ forceRefresh, ...idOrUri }, cbk) => {
+      cbk && offlineWorkerSync.on("opfsProgress", cbk);
+      return await offlineWorkerSync.loadBook({ id: "id" in idOrUri ? idOrUri.id : idOrUri.uri, forceRefresh });
     },
     []
   );
+  const reset = useCallback(async () => {
+    await offlineWorkerSync.reset();
+    await clearCache(confEnv || "development");
+    console.debug("reset: keys:", await caches.keys());
+  }, [confEnv]);
   return {
     ready,
-    loadBook
+    loadBook,
+    reset
   };
 };
+
+// src/store/index.ts
+import { persistReducer } from "redux-persist";
+var persistEntitiesReducer = (entitiesReducer, CONF_ENV) => {
+  const getKey = (key) => `store:${CONF_ENV}:${key}`;
+  return persistReducer(
+    {
+      key: "entities",
+      storage: {
+        getItem: async (key) => localStorage.getItem(getKey(key)) || "{}",
+        setItem: async (key, item) => localStorage.setItem(getKey(key), item),
+        removeItem: async (key) => localStorage.removeItem(getKey(key))
+      },
+      whitelist: ["lexicalFlowers"],
+      version: 1,
+      debug: true,
+      throttle: 1e3
+      // lexicalFlowers is small, we may persist it fast
+    },
+    entitiesReducer
+  );
+};
+
+// src/store/offlinePersist.tsx
+import { persistStore } from "redux-persist";
+import { PersistGate } from "redux-persist/integration/react";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var OfflinePersist = ({ store, children }) => {
+  const persistor = useMemo(() => persistStore(store), [store]);
+  return /* @__PURE__ */ jsx(PersistGate, { loading: null, persistor, children });
+};
 export {
+  OfflinePersist,
+  persistEntitiesReducer,
   useOfflineWorker_default as useOfflineWorker
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.27.0",
+  "version": "24.28.0-0854ed80",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -48,14 +48,15 @@
     "nock": "14.0.5",
     "react": "18.3.1",
     "react-dom": "18.3.1",
+    "redux": "5.0.1",
     "typescript": "5.8.3",
     "vite": "7.0.7",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.27.0"
+    "@lls/vitescripts": "24.28.0-0854ed80"
   },
   "dependencies": {
-    "fflate": "0.8.2"
+    "redux-persist": "6.0.0"
   },
   "scripts": {
     "start": "pnpm ladle serve",