@lls/offline 24.28.0-fd6a3fbf → 24.29.0-038ff270

package/lib/assets/fetch-worker.js

@@ -17,10 +17,10 @@ var parseRange = (range, size) => {
 };
 
 // src/utils/worker.ts
-var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
+var makeSyncWorker = (offlineWorker, 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);
@@ -28,11 +28,11 @@ 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 } = {}) => {
@@ -40,7 +40,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         let resolved = false;
         const timeout = setTimeout(() => {
-          console.warn("slow request for", methodName, arg);
+          console.warn("slow request for", methodName, arg, eventId);
         }, 3e3);
         const doResolve = (arg2) => {
           if (!resolved) {
@@ -50,11 +50,16 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
           }
         };
         dic[eventId] = { resolve: doResolve, reject };
-        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+        if (ports) {
+          offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+        } else {
+          offlineWorker.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;
     }
@@ -71,26 +76,38 @@ 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 jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
+var combineHandlers = (...handlers) => {
+  return (message) => {
+    const methodName = String("methodName" in message.data ? message.data.methodName : "");
+    for (const h of handlers) {
+      if (h.canHandle(methodName)) {
+        return h.handle(message);
+      }
+    }
+    console.error("no handlers matched", methodName);
+  };
+};
 var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
 var isStoryZip = (name) => /story-.*?\.zip/.test(name);
 var isValidZipName = (name) => {
@@ -339,7 +356,7 @@ var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorke
   try {
     const [buf, maybeRangeHeaders] = await offlineWorkerSync2.readZipEntry(entryId).then((buf2) => {
       const range = ev.request.headers.get("Range");
-      if (!ev.request.url.endsWith(".mp4") && !ev.request.url.endsWith(".webm")) {
+      if (!hasStreamingExtension(ev.request.url)) {
         return [buf2, {}];
       }
       if (!range) {
@@ -420,6 +437,7 @@ var ACCEPTED_EXTENSIONS = {
   ".riv": "application/octet-stream",
   ".pdf": "application/pdf"
 };
+var hasStreamingExtension = (str) => /\.(mp3|mp4|webm|m4a)$/.test(str);
 var putInCache = async (request, response) => {
   const cache = await openCache(CONF_ENV);
   await cache.put(request, response);
@@ -429,7 +447,7 @@ var tryOnline = async (request, event) => {
   if (isValidZipName(request.url) && !isValidS3Zip(responseFromNetwork)) {
     throw new Error(`zip is invalid: got ${responseFromNetwork.headers.get("Content-Length")} bytes`);
   }
-  const cached = request.method === "HEAD" ? Promise.resolve() : putInCache(request, responseFromNetwork.clone());
+  const cached = request.method === "GET" || request.method === "OPTIONS" ? putInCache(request, responseFromNetwork.clone()) : Promise.resolve();
   if (request.url.endsWith(".zip")) {
     await cached;
     event.waitUntil(Promise.resolve());
@@ -450,7 +468,7 @@ var onlineFirst = async (request, event) => {
     const responseFromCache = await tryOffline(request, event);
     if (!responseFromCache) {
       return new Response(
-        `FAILED fetch ${e && typeof e === "object" && "message" in e ? e.message : e?.toString?.()}`,
+        `FAILED onlineFirst fetch ${e && typeof e === "object" && "message" in e ? e.message : e?.toString?.()} | ${event.request.url}`,
         {
           // @ts-ignore: poor ts typing
           ok: false,
@@ -475,6 +493,9 @@ swSelf.addEventListener("fetch", (ev) => {
     }
     return;
   }
+  if (/api(-dev|-preprod)?\.lelivrescolaire\.fr\/?$/.test(url) && ev.request.method === "HEAD") {
+    return;
+  }
   if (!mimeType && !isValidScreenCall) {
     if (!/\.(css|tsx?|[mj]sx?|woff2|wasm|fr|(web)?manifest)(\??|$)|@(vite|react|id)|(:6019\/?$)/.test(url)) {
       console.debug("no ext", extension || url);
@@ -503,23 +524,23 @@ swSelf.addEventListener("install", (_event) => {
 swSelf.addEventListener("activate", (event) => {
   event.waitUntil(swSelf.clients.claim());
 });
-var offlineWorker;
+var setKnownLinks2 = (arg) => setKnownLinks(knownLinks, arg);
 var offlineWorkerSync;
 var initChannel = async (__, { ports }) => {
   console.info(`FETCH WORKER innitChannel v${/* @__PURE__ */ new Date()}`);
-  offlineWorker = ports[0];
-  const { handler, ...sender } = makeSyncWorker(
+  const offlineWorker = ports[0];
+  const { handler: syncHandler, ...sender } = makeSyncWorker(
     offlineWorker,
-    ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks"],
+    ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks", "ensureAppReady"],
     "fetchworker"
   );
+  const onHandler = makeSyncHandler({ setKnownLinks: setKnownLinks2 });
   offlineWorkerSync = sender;
-  offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", ({ entryNames, bookId, eventId }) => {
-    setKnownLinks(knownLinks, { entryNames, bookId });
-    offlineWorker.postMessage({ methodName: "setKnownLinks:back", eventId });
-  });
-  offlineWorker.postMessage({ methodName: "sendAppReady" });
+  offlineWorker.onmessage = combineHandlers(syncHandler, onHandler);
+  offlineWorker.onclose = () => {
+    console.error("socket to ow has been closed!");
+  };
+  await offlineWorkerSync.ensureAppReady();
 };
 var knownLinks = /* @__PURE__ */ new Map();
 var configure = ({
@@ -536,28 +557,4 @@ var configure = ({
   }
   console.info("sw::configure", { STORAGE, CONF_ENV });
 };
-swSelf.onmessage = async ({
-  data: { methodName, arg } = {},
-  ports
-}) => {
-  const services = {
-    initChannel,
-    configure
-  };
-  try {
-    if (methodName === "configure") {
-      await services[methodName](arg);
-      return;
-    }
-    if (methodName === "initChannel") {
-      if (!ports.length) {
-        throw new Error("fetchworker::missing port!");
-      }
-      await services[methodName](arg, { ports });
-      return;
-    }
-    throw new Error(`fetchworker:invalid methodName ${Object.keys(services)} ${methodName}`);
-  } catch (e) {
-    console.error("failed", methodName, arg, e);
-  }
-};
+swSelf.onmessage = combineHandlers(makeSyncHandler({ initChannel, configure }));

package/lib/assets/offline-worker.js

@@ -13,7 +13,7 @@ var tryCatch = (fn) => {
 var makeSyncWorker = (offlineWorker, 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,11 +21,11 @@ var makeSyncWorker = (offlineWorker, 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 } = {}) => {
@@ -33,7 +33,7 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         let resolved = false;
         const timeout = setTimeout(() => {
-          console.warn("slow request for", methodName, arg);
+          console.warn("slow request for", methodName, arg, eventId);
         }, 3e3);
         const doResolve = (arg2) => {
           if (!resolved) {
@@ -43,11 +43,16 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
           }
         };
         dic[eventId] = { resolve: doResolve, reject };
-        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+        if (ports) {
+          offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+        } else {
+          offlineWorker.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: (key2, fn2) => {
       cbks[key2] = fn2;
     }
@@ -64,31 +69,33 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender2, 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 });
-          sender2.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);
-        sender2.postMessage({ eventId, methodName, error: e });
+        emitter.postMessage({ eventId, methodName, error: e });
       }
     }
   })
 );
 var bufToJson = (buf) => JSON.parse(new TextDecoder("UTF-8").decode(new Uint8Array(buf)));
 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);
@@ -401,6 +408,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       await accessHandle.close();
     } else {
       const cache = await openCache(CONF_ENV);
+      console.time("writing cache");
       const response2 = new Response(arrayBuffer, {
         headers: {
           "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
@@ -413,9 +421,12 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
         type: "cors",
         url: zipUrl
       });
-      await cache.put(zipUrl, response2);
+      console.debug("writing to cache asynchronously, because takes 4s");
+      cache.put(zipUrl, response2).then(() => {
+        console.timeEnd("writing cache");
+      });
     }
-    return await readArrayBuffer();
+    return arrayBuffer;
   }
 };
 var slugToFileMeta2 = async ({ slug }) => {
@@ -437,12 +448,7 @@ var loadBook2 = async ({ id: bookId, forceRefresh }) => {
         console.time("loadzip");
         const entryNames = await loadZip(new Uint8Array(buf), bookId);
         console.timeEnd("loadzip");
-        const eventId = `setKnownLinks:${Date.now()}-${Math.random().toFixed(5)}`;
-        const responseForEventId = new Promise((resolve, reject) => {
-          dicFetchWorkerCallback[eventId] = { resolve, reject };
-        });
-        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId, eventId } });
-        await responseForEventId;
+        await fetchWorkerSync.setKnownLinks({ entryNames, bookId });
         if (isOldZip(bookId)) {
           const json = await readZipEntry({
             entryName: `preload/${bookId}.json`,
@@ -485,43 +491,30 @@ var loadPageContent2 = async ({
   });
   return await loadPageContent({ chapterId, json });
 };
-var fetchWorker;
-var dicFetchWorkerCallback = {};
-var handleFetchWorkerCallback = ({ data: { eventId } }) => {
-  if (dicFetchWorkerCallback[eventId]) {
-    dicFetchWorkerCallback[eventId].resolve();
-  } else {
-    console.debug("unknown eventId", eventId);
-  }
+var ensureAppReady = () => {
 };
+var fetchWorker;
+var fetchWorkerSync;
 var initChannel = (__, { ports }) => {
   fetchWorker = ports[0];
-  const { canHandle, handle } = makeSyncHandler(fetchWorker, {
+  const onHandler = makeSyncHandler({
     readZipEntry,
     loadBook: loadBook2,
     slugToFileMeta: slugToFileMeta2,
     loadPageContent: loadPageContent2,
-    searchBooks
+    searchBooks,
+    ensureAppReady
   });
-  const fn = (dataObj) => {
-    if (dataObj.data?.methodName === "sendAppReady") {
-      self.postMessage({ methodName: "ready" });
-      return;
-    }
-    if (dataObj.data?.methodName === "setKnownLinks:back") {
-      if (typeof dataObj?.data?.eventId !== "string") {
-        console.debug("missing eventId to get response back for setKnownLinks:back");
-        return;
-      }
-      handleFetchWorkerCallback(dataObj);
-      return;
-    }
-    if (canHandle(dataObj.data?.methodName || "")) {
-      return handle(dataObj);
-    }
-    console.error("unknown methodName", dataObj.data?.methodName);
+  const { handler: syncHandler, ...sender2 } = makeSyncWorker(
+    fetchWorker,
+    ["setKnownLinks"],
+    "offline-worker"
+  );
+  fetchWorkerSync = sender2;
+  fetchWorker.onmessage = combineHandlers(syncHandler, onHandler);
+  fetchWorker.onclose = () => {
+    console.error("socket to sw has been closed!");
   };
-  fetchWorker.onmessage = fn;
 };
 var loadBooks = async ({ primaryOnly = false } = {}) => {
   let entries = [];
@@ -593,7 +586,7 @@ var reset = async () => {
   await (await navigator.storage.getDirectory()).remove({ recursive: true });
   console.info("opfs cleared");
 };
-var mainHandle = makeSyncHandler(self, {
+var mainHandle = makeSyncHandler({
   initChannel,
   loadPreload: loadPreload2,
   readZipEntry,

package/lib/builttypes/offline/src/hooks/useOfflineWorker.d.ts

@@ -0,0 +1,33 @@
+type UseOfflineProps = {
+    skipLoadBooks?: boolean;
+    primaryOnly?: boolean;
+    nativeReadFile?: (arg: {
+        fname: string;
+    }) => Promise<ArrayBuffer>;
+    nativeWriteFile?: (arg: {
+        fname: string;
+        buffer: ArrayBuffer;
+    }) => Promise<void>;
+    nativeListZips?: () => Promise<Array<{
+        name: string;
+    }>>;
+    checkUpdates?: boolean;
+    storage?: 'opfs' | 'native' | 'cache';
+    zipBaseUrl?: string;
+    confEnv?: 'development' | 'production';
+};
+declare const _default: ({ skipLoadBooks, primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, checkUpdates, storage, zipBaseUrl, confEnv }?: UseOfflineProps) => {
+    ready: boolean;
+    loadBook: ({ forceRefresh, ...idOrUri }: {
+        forceRefresh?: boolean;
+    } & ({
+        id: number;
+    } | {
+        uri: string;
+    }), cbk?: (arg: {
+        bytes: number;
+        total: number;
+    }) => void) => Promise<void>;
+    reset: () => Promise<void>;
+};
+export default _default;

package/lib/builttypes/offline/src/index.d.ts

@@ -0,0 +1,3 @@
+export { default as useOfflineWorker } from '#offline/hooks/useOfflineWorker';
+export * from '#offline/store/index';
+export * from '#offline/store/offlinePersist';

package/lib/builttypes/offline/src/store/index.d.ts

@@ -0,0 +1,3 @@
+import type { AnyFunction } from '@lls/typings/utils';
+import type { Reducer } from 'redux';
+export declare const persistEntitiesReducer: (entitiesReducer: AnyFunction, CONF_ENV: string) => Reducer;

package/lib/builttypes/offline/src/store/offlinePersist.d.ts

@@ -0,0 +1,8 @@
+import { persistStore } from 'redux-persist';
+type Store = Parameters<typeof persistStore>[0];
+import { type ReactNode } from 'react';
+export declare const OfflinePersist: ({ store, children }: {
+    store: Store;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/builttypes/offline/src/utils/error.d.ts

@@ -0,0 +1,2 @@
+import type { AnyFunction } from '@lls/typings/utils';
+export declare const tryCatch: (fn: (...args: any[]) => Promise<unknown>) => (resolve: AnyFunction, reject: AnyFunction) => void | Promise<void>;

package/lib/builttypes/offline/src/utils/stream.d.ts

@@ -0,0 +1,5 @@
+export declare const parseRange: (range: string, size: number) => {
+    start: number;
+    end: number;
+    chunkSize: number;
+};

package/lib/builttypes/offline/src/utils/worker.d.ts

@@ -0,0 +1,29 @@
+import type { AnyFunction } from '@lls/typings/utils';
+type OnMessageEvent = (m: MessageEvent) => void;
+type Handler = {
+    canHandle: (methodName: string) => boolean;
+    handle: OnMessageEvent;
+};
+export declare const makeSyncWorker: <WorkerApi extends {
+    [k: string]: AnyFunction;
+}>(offlineWorker: {
+    postMessage: Worker["postMessage"];
+}, methodNames: string[], dbg?: string) => WorkerApi & {
+    on: (key: string, fn: AnyFunction) => void;
+} & {
+    handler: Handler;
+};
+export declare const makeSyncHandler: (services: {
+    [k: string]: (...args: any[]) => any;
+}) => {
+    canHandle: (methodName: string) => boolean;
+    handle: OnMessageEvent;
+};
+export declare const bufToJson: (buf: ArrayBuffer) => any;
+export declare const jsonToBuf: (json: {}) => Uint8Array<ArrayBuffer>;
+export declare const combineHandlers: (...handlers: Handler[]) => (message: MessageEvent) => void;
+export declare const openCache: (mode: string) => Promise<Cache>;
+export declare const clearCache: (mode: string) => Promise<boolean>;
+export declare const isValidZipName: (name: string) => boolean;
+export declare const isValidS3Zip: (response: Response) => boolean;
+export {};

package/lib/builttypes/offline/src/utils/zipDecoder.d.ts

@@ -0,0 +1,7 @@
+type Record = {
+    sofh: number;
+    name: Uint8Array;
+};
+export declare const readRecordData: (buf: Uint8Array, { sofh }: Record) => Uint8Array<ArrayBuffer>;
+export declare const getHeaders: (buf: Uint8Array) => Record[];
+export {};

package/lib/builttypes/offline/src/worker/fetch-worker.d.ts

@@ -0,0 +1,16 @@
+import { setKnownLinks as handleSetKnownLinks } from '#offline/worker/swFetchScreenCall.ts';
+declare const setKnownLinks: (arg: Parameters<typeof handleSetKnownLinks>[1]) => void;
+export type FetchWorkerSync = {
+    setKnownLinks: typeof setKnownLinks;
+};
+declare const configure: ({ storage, confEnv }?: {
+    storage?: "native" | "opfs" | "cache";
+    confEnv?: "development" | "production";
+}) => void;
+export type FetchWorkerMain = {
+    initChannel: (d: {
+        ports: [MessagePort];
+    }) => void;
+    configure: typeof configure;
+};
+export {};

package/lib/builttypes/offline/src/worker/offline-worker.d.ts

@@ -0,0 +1,67 @@
+import type { EntryId } from './types.js';
+import { searchBooks } from './wwApi.js';
+import { readZipEntry } from './wwZip.js';
+declare const slugToFileMeta: ({ slug }: {
+    slug: string;
+}) => Promise<{
+    pageId: number | undefined;
+    chapterId: number | undefined;
+}>;
+type BookId = number | string;
+declare const loadBook: ({ id: bookId, forceRefresh }: {
+    id: BookId;
+    forceRefresh?: boolean;
+}) => Promise<void>;
+declare const loadPageContent: ({ bookId: iBookId, chapterId, pageId, entryId }: {
+    bookId?: number;
+    chapterId?: number;
+    pageId?: number;
+    entryId?: EntryId;
+}) => Promise<{
+    viewer: {
+        pages: {
+            hits: [{
+                id: number;
+                book: {
+                    slug: string;
+                    urlLite: string;
+                };
+                chapter: {
+                    id: number;
+                };
+            }];
+        };
+    };
+}>;
+declare const ensureAppReady: () => void;
+export type OfflineWorkerSync = {
+    readZipEntry: typeof readZipEntry;
+    loadBook: typeof loadBook;
+    slugToFileMeta: typeof slugToFileMeta;
+    loadPageContent: typeof loadPageContent;
+    searchBooks: typeof searchBooks;
+    ensureAppReady: typeof ensureAppReady;
+};
+declare const loadBooks: ({ primaryOnly }?: {
+    primaryOnly?: boolean | undefined;
+}) => Promise<void>;
+declare const configure: ({ storage, checkUpdates, zipBaseUrl, confEnv }: {
+    storage?: "native" | "opfs" | "cache";
+    checkUpdates?: boolean;
+    zipBaseUrl?: string;
+    confEnv?: "development" | "production";
+}) => void;
+declare const loadPreload: () => Promise<void>;
+declare const reset: () => Promise<void>;
+export type OfflineWorkerSyncMain = {
+    initChannel: (d: {
+        ports: [MessagePort];
+    }) => void;
+    loadPreload: typeof loadPreload;
+    readZipEntry: typeof readZipEntry;
+    loadBooks: typeof loadBooks;
+    loadBook: typeof loadBook;
+    configure: typeof configure;
+    reset: typeof reset;
+};
+export {};

package/lib/builttypes/offline/src/worker/swFetchScreenCall.d.ts

@@ -0,0 +1,14 @@
+import type { OfflineWorkerSync } from './offline-worker';
+import type { EntryId, SwEvent } from './types';
+export declare const canHandleScreenCall: (url: string) => boolean;
+export declare const handleScreenCall: (ev: SwEvent, { offlineWorkerSync, knownLinks }: {
+    offlineWorkerSync: OfflineWorkerSync;
+    knownLinks: Map<string, EntryId>;
+}) => Promise<{
+    status: number;
+    json: any;
+}>;
+export declare const setKnownLinks: (knownLinks: Map<string, EntryId>, { entryNames, bookId }: {
+    entryNames: string[];
+    bookId: number | string;
+}) => void;

package/lib/builttypes/offline/src/worker/wwApi.d.ts

@@ -0,0 +1,58 @@
+type Book = {
+    id: number;
+    chapters: {
+        id: number;
+    }[];
+    uri: string;
+    slug: string;
+    urlLite: string;
+};
+type Page = {
+    id: number;
+    book: {
+        slug: string;
+        urlLite: string;
+    };
+    chapter: {
+        id: number;
+    };
+};
+type GqlBook = {
+    viewer: {
+        books: {
+            hits: [Book];
+        };
+    };
+};
+type GqlPage = {
+    viewer: {
+        pages: {
+            hits: [Page];
+        };
+    };
+};
+export declare const loadBook: (json: GqlBook) => void;
+type SlugFile = {
+    [pageId: string]: `${number};${number}`;
+};
+export declare const slugToFileMeta: ({ slug, json }: {
+    slug: string;
+    json: SlugFile;
+}) => Promise<{
+    pageId: number | undefined;
+    chapterId: number | undefined;
+}>;
+export declare const loadPageContent: ({ chapterId, json }: {
+    chapterId?: number;
+    json: GqlPage;
+}) => Promise<GqlPage>;
+export declare const searchBooks: ({ uris, slugs, ids, chapterIds }: {
+    uris?: string[];
+    slugs?: string[];
+    ids?: number[];
+    chapterIds?: (number | undefined)[];
+}) => Promise<(Omit<Book, "chapters"> & {
+    chapters: number[];
+})[]>;
+export declare const loadPreload: (json: GqlBook) => void;
+export {};

package/lib/builttypes/offline/src/worker/wwZip.d.ts

@@ -0,0 +1,9 @@
+type BookId = number | string;
+export declare const readZipEntry: ({ bookId, entryName, asJson }: {
+    bookId: number | string;
+    entryName: string;
+    asJson?: boolean;
+}) => Promise<any>;
+export declare const hasZip: (bookId: BookId | string) => boolean;
+export declare const loadZip: (buf: Uint8Array, bookId: BookId) => Promise<string[]>;
+export {};

package/lib/index.js

@@ -1,3 +1,6 @@
+// src/hooks/useOfflineWorker.ts
+import { useCallback, useEffect, useState } from "react";
+
 // src/utils/error.ts
 var tryCatch = (fn) => {
   return (resolve, reject) => {
@@ -13,7 +16,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,11 +24,11 @@ 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 } = {}) => {
@@ -33,7 +36,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         let resolved = false;
         const timeout = setTimeout(() => {
-          console.warn("slow request for", methodName, arg);
+          console.warn("slow request for", methodName, arg, eventId);
         }, 3e3);
         const doResolve = (arg2) => {
           if (!resolved) {
@@ -43,11 +46,16 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
           }
         };
         dic[eventId] = { resolve: doResolve, reject };
-        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+        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;
     }
@@ -64,30 +72,32 @@ 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);
@@ -96,7 +106,6 @@ var combineHandlers = (...handlers) => {
 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,
@@ -124,14 +133,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,
@@ -146,7 +147,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);
@@ -154,13 +155,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) {
@@ -169,7 +174,6 @@ var installWorker = async ({
   if (!skipLoadBooks) {
     await offlineWorkerSync.loadBooks({ primaryOnly });
   }
-  setBooksLoaded();
 };
 var useOfflineWorker_default = ({
   skipLoadBooks,
@@ -196,8 +200,9 @@ var useOfflineWorker_default = ({
         checkUpdates,
         confEnv
       });
-      await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
-      fetch(window.location.href.replace(window.location.search, ""));
+      if (process.env.DESKTOP_FLOWER_OFFLINE !== "1") {
+        fetch(window.location.href.replace(window.location.search, ""));
+      }
       setReady(true);
     };
     fn();

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@lls/offline",
-  "version": "24.28.0-fd6a3fbf",
+  "version": "24.29.0-038ff270",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
   "types": "./lib/builttypes/offline/src/index.d.ts",
   "exports": {
-    ".": "./lib/index.js"
+    "import": "./lib/index.js",
+    "types": "./lib/builttypes/offline/src/index.d.ts"
   },
   "files": [
     "lib/",
@@ -53,7 +54,7 @@
     "vite": "7.0.7",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.28.0-fd6a3fbf"
+    "@lls/vitescripts": "24.29.0-038ff270"
   },
   "dependencies": {
     "redux-persist": "6.0.0"
@@ -67,5 +68,8 @@
     "test": "bun test --bail __tests__/unit __tests__/e2e",
     "lint": "pnpm biome check --apply src __tests__ stories",
     "precommit": "pnpm lint"
+  },
+  "imports": {
+    "#offline/*": "./lib/builttypes/offline/src/*.d.ts"
   }
 }

package/lib/index.d.ts

@@ -1 +0,0 @@
-declare module "@lls/offline"