@lls/offline 24.22.0-debug → 24.22.0-eaf69c80

package/lib/assets/fetch-worker.js

@@ -11,12 +11,11 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       }
     } else {
       if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
-        console.error(`syncWorker: ${dbg}`, eventId, methodName, error);
+        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
       }
     }
     methodName && cbks[methodName]?.(arg);
   };
-  offlineWorker2.onmessage = fn;
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
@@ -31,23 +30,36 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       cbks[key] = fn2;
     }
   });
-  return obj;
+  return {
+    ...obj,
+    handler: {
+      canHandle: (methodName) => {
+        return methodName in cbks || methodNames.includes(methodName);
+      },
+      handle: fn
+    }
+  };
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
-    try {
-      if (typeof methodName === "string" && methodName in services && services[methodName]) {
-        const results = await services[methodName](arg, { ports });
-        sender.postMessage({ eventId, methodName, results });
-        return;
+  (sender, services) => ({
+    canHandle: (methodName) => {
+      return methodName in services;
+    },
+    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+      try {
+        if (typeof methodName === "string" && methodName in services && services[methodName]) {
+          const results = await services[methodName](arg, { ports });
+          sender.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 });
       }
-      throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
-    } catch (e) {
-      console.debug("failed", e);
-      sender.postMessage({ eventId, methodName, error: e });
     }
-  }
+  })
 );
 var jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
 
@@ -273,8 +285,8 @@ swSelf.addEventListener("fetch", (ev) => {
   const mimeType = extension && extension in ACCEPTED_EXTENSIONS ? ACCEPTED_EXTENSIONS[extension] : "";
   const isValidScreenCall = canHandleScreenCall(url);
   if (!mimeType && !isValidScreenCall) {
-    if (!/\.(css|tsx?|jsx?|woff2|fr)/.test(url)) {
-      console.debug("no ext", url.match(/\.[^.]+$/)?.[0]);
+    if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
+      console.debug("no ext", extension || url);
     }
     return;
   }
@@ -300,13 +312,15 @@ swSelf.addEventListener("activate", (_event) => {
 var offlineWorker;
 var offlineWorkerSync;
 var initChannel = async (__, { ports }) => {
-  console.info(`FETCH WORKER innitChannel v${13}`);
+  console.info(`FETCH WORKER innitChannel v${/* @__PURE__ */ new Date()}`);
   offlineWorker = ports[0];
-  offlineWorkerSync = makeSyncWorker(
+  const { handler, ...sender } = makeSyncWorker(
     offlineWorker,
     ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks"],
     "fetchworker"
   );
+  offlineWorkerSync = sender;
+  offlineWorker.onmessage = handler.handle;
   offlineWorkerSync.on("setKnownLinks", setKnownLinks);
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };

package/lib/assets/offline-worker.js

@@ -1,21 +1,77 @@
 // src/utils/worker.ts
+var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
+  const dic = {};
+  const cbks = {};
+  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+    if (eventId && eventId in dic) {
+      if (error) {
+        dic[eventId].reject(error);
+      } else {
+        dic[eventId].resolve(results);
+      }
+    } else {
+      if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
+        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
+      }
+    }
+    methodName && cbks[methodName]?.(arg);
+  };
+  const makeFn = (methodName) => {
+    return ({ ports, ...arg } = {}) => {
+      return new Promise((resolve, reject) => {
+        const eventId = `${methodName}:${Date.now()}`;
+        dic[eventId] = { resolve, reject };
+        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+      });
+    };
+  };
+  const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
+    on: (key2, fn2) => {
+      cbks[key2] = fn2;
+    }
+  });
+  return {
+    ...obj,
+    handler: {
+      canHandle: (methodName) => {
+        return methodName in cbks || methodNames.includes(methodName);
+      },
+      handle: fn
+    }
+  };
+};
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
-    try {
-      if (typeof methodName === "string" && methodName in services && services[methodName]) {
-        const results = await services[methodName](arg, { ports });
-        sender.postMessage({ eventId, methodName, results });
-        return;
+  (sender2, services) => ({
+    canHandle: (methodName) => {
+      return methodName in services;
+    },
+    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+      try {
+        if (typeof methodName === "string" && methodName in services && services[methodName]) {
+          const results = await services[methodName](arg, { ports });
+          sender2.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 });
       }
-      throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
-    } catch (e) {
-      console.debug("failed", e);
-      sender.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 }) => {
+    for (const h of handlers) {
+      if (h.canHandle(String(methodName))) {
+        return h.handle({ data: { methodName, ...data }, ports });
+      }
+    }
+    console.error("no handlers matched", methodName);
+  };
+};
 
 // src/worker/wwApi.ts
 var STATE = {
@@ -734,6 +790,9 @@ var loadZip = async (buf, bookId) => {
   const unzipper = new Unzip();
   unzipper.register(UnzipInflate);
   unzipper.onfile = (file) => {
+    if (!file.name.includes(".")) {
+      return;
+    }
     m.set(file.name, {
       decoded: null,
       zipEntry: {
@@ -771,10 +830,18 @@ var loadZip = async (buf, bookId) => {
 
 // src/worker/offline-worker.ts
 var CHECK_UPDATES = true;
-var fetchZipFile = async (zipUrl, forceRefresh) => {
-  const opfsRoot = await navigator.storage.getDirectory();
+var NATIVE = false;
+var LOADED_BOOKS = /* @__PURE__ */ new Set();
+var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
   const fileName = zipUrl.split("/").slice(-1)[0];
   const readArrayBuffer = async () => {
+    if (NATIVE) {
+      console.debug("try reading native", fileName);
+      const back = await sender.nativeReadFile({ fname: fileName });
+      console.debug("done readnig");
+      return back;
+    }
+    const opfsRoot = await navigator.storage.getDirectory();
     const handle = await opfsRoot.getFileHandle(fileName);
     const accessHandle = await handle.createSyncAccessHandle();
     const size = accessHandle.getSize();
@@ -800,7 +867,7 @@ var fetchZipFile = async (zipUrl, forceRefresh) => {
     }
     return buf;
   } catch (e) {
-    if (e.message !== "forceRefresh" && !e.message.includes("refetching")) {
+    if (e instanceof Error && e.message !== "forceRefresh" && !e.message.includes("refetching")) {
       console.debug("opfs db not found, creating it", e, zipUrl);
     }
     const response = await fetch(zipUrl);
@@ -826,6 +893,11 @@ var fetchZipFile = async (zipUrl, forceRefresh) => {
       console.debug(error);
       throw new Error(error);
     }
+    if (NATIVE) {
+      await sender.nativeWriteFile({ fname: fileName, buffer: arrayBuffer });
+      return await readArrayBuffer();
+    }
+    const opfsRoot = await navigator.storage.getDirectory();
     const handle = await opfsRoot.getFileHandle(fileName, { create: true });
     const accessHandle = await handle.createSyncAccessHandle();
     await accessHandle.truncate(0);
@@ -843,7 +915,12 @@ var slugToFileMeta2 = async ({ slug }) => {
 var PRELOAD_AS_BOOK_ID = "preload";
 var isOldZip = (bookId) => typeof bookId === "number";
 var loadBook2 = async ({ id: bookId, forceRefresh }) => {
-  const buf = await fetchZipFile(`https://ci.lls.fr/artefacts/content/development/${bookId}.zip`, forceRefresh);
+  if (LOADED_BOOKS.has(bookId)) {
+    self.postMessage({ methodName: "opfsProgress", arg: { total: 1, bytes: 1 } });
+    return;
+  }
+  LOADED_BOOKS.add(bookId);
+  const buf = await fetchZipFile(`https://ci.lls.fr/artefacts/content/development/${bookId}.zip`, { forceRefresh });
   try {
     const entryNames = await loadZip(new Uint8Array(buf), bookId);
     fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
@@ -875,7 +952,7 @@ var loadPageContent2 = async ({
 var fetchWorker;
 var initChannel = (__, { ports }) => {
   fetchWorker = ports[0];
-  const defaultHandler = makeSyncHandler(fetchWorker, {
+  const { canHandle, handle } = makeSyncHandler(fetchWorker, {
     readZipEntry,
     loadBook: loadBook2,
     slugToFileMeta: slugToFileMeta2,
@@ -887,23 +964,47 @@ var initChannel = (__, { ports }) => {
       self.postMessage({ methodName: "ready" });
       return;
     }
-    defaultHandler(dataObj);
+    if (canHandle(dataObj.data?.methodName || "")) {
+      return handle(dataObj);
+    }
+    console.error("unknown methodName", dataObj.data?.methodName);
   };
   fetchWorker.onmessage = fn;
 };
-var loadBooks = async () => {
-  const opfsRoot = await navigator.storage.getDirectory();
-  const entries = await opfsRoot.values();
+var loadBooks = async ({ primaryOnly = false } = {}) => {
+  let entries = [];
+  if (NATIVE) {
+    entries = await sender.nativeListZips();
+  } else {
+    const opfsRoot = await navigator.storage.getDirectory();
+    entries = await opfsRoot.values();
+  }
   for await (const entry of entries) {
+    if (/preload/.test(entry.name)) {
+      continue;
+    }
     if (/\d+\.zip$/.test(entry.name)) {
-      const bookId = entry.name.match(/\d+/)[0];
-      await loadBook2({ id: Number.parseInt(bookId, 10) });
+      if (!primaryOnly) {
+        const bookId = entry.name.match(/\d+/)[0];
+        await loadBook2({ id: Number.parseInt(bookId, 10) });
+      }
     } else if (/zip$/.test(entry.name)) {
       const methodUri = entry.name.replace(".zip", "");
       await loadBook2({ id: methodUri });
+    } else {
+      console.info(`invalid book entry ${entry.name}`);
     }
   }
 };
+var configure = ({ native, checkUpdates }) => {
+  console.info("configuring!!", native, checkUpdates);
+  if (typeof native !== "undefined") {
+    NATIVE = !!native;
+  }
+  if (typeof native !== "undefined") {
+    CHECK_UPDATES = !!checkUpdates;
+  }
+};
 var loadPreload2 = async () => {
   const zipUrl = "https://lls-ci-fr.s3.eu-west-3.amazonaws.com/artefacts/content/development/preload.zip";
   const buf = await fetchZipFile(zipUrl);
@@ -916,10 +1017,13 @@ var loadPreload2 = async () => {
     console.error("failed", e);
   }
 };
-self.onmessage = makeSyncHandler(self, {
+var mainHandle = makeSyncHandler(self, {
   initChannel,
   loadPreload: loadPreload2,
   readZipEntry,
   loadBooks,
-  loadBook: loadBook2
+  loadBook: loadBook2,
+  configure
 });
+var { handler, ...sender } = makeSyncWorker(self, ["nativeWriteFile", "nativeReadFile", "nativeListZips"]);
+self.onmessage = combineHandlers(mainHandle, handler);

package/lib/index.js

@@ -1,8 +1,8 @@
 // src/utils/worker.ts
-var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
+var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const dic = {};
   const cbks = {};
-  const fn2 = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
     if (eventId && eventId in dic) {
       if (error) {
         dic[eventId].reject(error);
@@ -11,51 +11,74 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
       }
     } else {
       if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
-        console.error(`syncWorker: ${dbg}`, eventId, methodName, error);
+        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
       }
     }
     methodName && cbks[methodName]?.(arg);
   };
-  offlineWorker.onmessage = fn2;
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
         const eventId = `${methodName}:${Date.now()}`;
         dic[eventId] = { resolve, reject };
-        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
     };
   };
   const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
-    on: (key, fn3) => {
-      cbks[key] = fn3;
+    on: (key, fn2) => {
+      cbks[key] = fn2;
     }
   });
-  return obj;
+  return {
+    ...obj,
+    handler: {
+      canHandle: (methodName) => {
+        return methodName in cbks || methodNames.includes(methodName);
+      },
+      handle: fn
+    }
+  };
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
-    try {
-      if (typeof methodName === "string" && methodName in services && services[methodName]) {
-        const results = await services[methodName](arg, { ports });
-        sender.postMessage({ eventId, methodName, results });
-        return;
+  (sender, services) => ({
+    canHandle: (methodName) => {
+      return methodName in services;
+    },
+    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+      try {
+        if (typeof methodName === "string" && methodName in services && services[methodName]) {
+          const results = await services[methodName](arg, { ports });
+          sender.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 });
       }
-      throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
-    } catch (e) {
-      console.debug("failed", e);
-      sender.postMessage({ eventId, methodName, error: e });
     }
-  }
+  })
 );
+var combineHandlers = (...handlers) => {
+  return ({ data: { methodName, ...data } = {}, ports }) => {
+    for (const h of handlers) {
+      if (h.canHandle(String(methodName))) {
+        return h.handle({ data: { methodName, ...data }, ports });
+      }
+    }
+    console.error("no handlers matched", methodName);
+  };
+};
 
 // src/hooks/useOfflineWorker.ts
 import { useCallback, useEffect, useState } from "react";
-var offlineWorkerSync = makeSyncWorker(
+var offlineWorker = new Worker("/src/worker/offline-worker.js", { type: "module" });
+var { handler, ...offlineWorkerSync } = makeSyncWorker(
   // @ts-ignore: TODO
-  new Worker("/src/worker/offline-worker.js", { type: "module" }),
-  ["initChannel", "readZipEntry", "loadPreload", "loadBooks", "loadBook"],
+  offlineWorker,
+  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook"],
   "app:offlineWorker"
 );
 var setWorkersReady;
@@ -66,7 +89,13 @@ var setBooksLoaded;
 var setBooksLoadedPromise = new Promise((resolve) => {
   setBooksLoaded = resolve;
 });
-var fn = async () => {
+var installWorker = async ({
+  primaryOnly = false,
+  nativeReadFile,
+  nativeWriteFile,
+  nativeListZips,
+  checkUpdates
+} = {}) => {
   let fetchWorker = null;
   await navigator.serviceWorker.getRegistrations().then(async (registrations) => {
     for (const registration of registrations) {
@@ -82,30 +111,49 @@ var fn = async () => {
     console.debug("failed to get fetch worker");
     return;
   }
+  if (nativeReadFile) {
+    const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
+    offlineWorker.onmessage = combineHandlers(handler, wwHandler);
+    offlineWorkerSync.configure({ native: true, checkUpdates });
+  } else {
+    offlineWorkerSync.configure({ native: false, checkUpdates });
+    offlineWorker.onmessage = handler.handle;
+  }
   offlineWorkerSync.on("ready", setWorkersReady);
   const channel = new MessageChannel();
   offlineWorkerSync.initChannel({ ports: [channel.port1] });
   fetchWorker.postMessage({ methodName: "initChannel" }, [channel.port2]);
   offlineWorkerSync.on("opfsProgress", () => {
   });
-  await offlineWorkerSync.loadPreload();
+  if (!primaryOnly) {
+    await offlineWorkerSync.loadPreload();
+  }
   await offlineWorkerSync.loadBooks();
   setBooksLoaded();
 };
-fn();
-var useOfflineWorker_default = () => {
+var useOfflineWorker_default = ({
+  primaryOnly = false,
+  nativeReadFile,
+  nativeWriteFile,
+  nativeListZips,
+  checkUpdates
+} = {}) => {
   const [ready, setReady] = useState(false);
   useEffect(() => {
-    const fn2 = async () => {
+    const fn = async () => {
+      await installWorker({ primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, checkUpdates });
       await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
       setReady(true);
     };
-    fn2();
-  }, []);
-  const loadBook = useCallback(async ({ id, forceRefresh }, cbk) => {
-    offlineWorkerSync.on("opfsProgress", cbk);
-    return await offlineWorkerSync.loadBook({ id, forceRefresh });
-  }, []);
+    fn();
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, checkUpdates]);
+  const loadBook = useCallback(
+    async ({ id, forceRefresh }, cbk) => {
+      offlineWorkerSync.on("opfsProgress", cbk);
+      return await offlineWorkerSync.loadBook({ id, forceRefresh });
+    },
+    []
+  );
   return {
     ready,
     loadBook

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.22.0-debug",
+  "version": "24.22.0-eaf69c80",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -36,10 +36,12 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@happy-dom/global-registrator": "15.11.0",
+    "@ladle/react": "5.0.3",
     "@testing-library/react": "16.3.0",
     "@types/react": "18.3.12",
     "@types/react-dom": "18.3.1",
     "@vitejs/plugin-react": "4.5.1",
+    "@vitejs/plugin-react-swc": "3.10.1",
     "esbuild": "0.24.0",
     "happy-dom": "15.11.0",
     "lodash": "4.17.21",
@@ -48,17 +50,21 @@
     "react-dom": "18.3.1",
     "typescript": "5.8.3",
     "vite": "7.0.0",
+    "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.22.0"
+    "@lls/vitescripts": "24.22.0-eaf69c80"
   },
   "dependencies": {
     "fflate": "0.8.2"
   },
   "scripts": {
-    "start": "echo no devserver",
+    "start": "pnpm ladle serve",
     "dts": "pnpm tsc --project tsconfig.production.json",
-    "build": "node build",
-    "test": "bun test --bail",
-    "lint": "pnpm biome check --apply src __tests__"
+    "build": "NODE_ENV=production node build.js",
+    "deploy-ladle": "PUBLISH=1 pnpm ladle build",
+    "deploy-ladle-pr": "pnpm ladle build && s5cmd sync --delete --acl public-read --destination-region eu-west-1 'dist/*' s3://build.lelivrescolaire.fr/storybook/viewer-pr-$PR_NUMBER/",
+    "test": "bun test --bail __tests__/unit __tests__/e2e",
+    "lint": "pnpm biome check --apply src __tests__ stories",
+    "precommit": "pnpm lint"
   }
 }