@lls/offline 24.22.0-bfdb7edf → 24.22.0-debug

package/lib/assets/fetch-worker.js

@@ -11,15 +11,16 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       }
     } else {
       if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
-        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
+        console.error(`syncWorker: ${dbg}`, eventId, methodName, error);
       }
     }
     methodName && cbks[methodName]?.(arg);
   };
+  offlineWorker2.onmessage = fn;
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
+        const eventId = `${methodName}:${Date.now()}`;
         dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -30,39 +31,25 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       cbks[key] = fn2;
     }
   });
-  return {
-    ...obj,
-    handler: {
-      canHandle: (methodName) => {
-        return methodName in cbks || methodNames.includes(methodName);
-      },
-      handle: fn
-    }
-  };
+  return obj;
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (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 });
+  (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;
       }
+      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));
-var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
 
 // src/worker/swFetchScreenCall.ts
 var zipSlugName = (str) => str.replace(/[^a-zA-Z0-9-.]/g, "");
@@ -75,15 +62,6 @@ var cocoreFetchPartialPageScreen = async (_ev, { offlineWorkerSync: offlineWorke
   const gqlPage = await offlineWorkerSync2.loadPageContent({ entryId });
   return { data: gqlPage };
 };
-var cocoreFetchBookScreen = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables, knownLinks: knownLinks2 }) => {
-  const key = `gqls/${zipSlugName(variables.uris[0] || "")}.json`;
-  const entryId = knownLinks2.get(key);
-  if (!entryId) {
-    throw new Error(`uri not found ${key}`);
-  }
-  const gqlBook = await offlineWorkerSync2.loadPageContent({ entryId });
-  return { data: gqlBook };
-};
 var cocoreFetchPartialPageSiblingsScreen = async (_ev) => {
   return { data: { viewer: {} } };
 };
@@ -198,7 +176,6 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
 };
 var handles = {
   coreFetchBookDrawerScreen,
-  cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
   cocoreFetchPartialPageSiblingsScreen
@@ -207,7 +184,7 @@ var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).te
 var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
   try {
     const variables = (
-      // @ts-expect-error TODO: handle variables from body(stream) properly!!
+      // @ts-ignore TODO: handle variables from body(stream) properly!!
       ev.request.body?.variables || JSON.parse(new URLSearchParams(new URL(ev.request.url).search).get("variables") || "{}")
     );
     console.debug("variables are", variables, "vs", ev.request.body);
@@ -222,28 +199,23 @@ var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, known
     return { status: 500, json: JSON.stringify(e) };
   }
 };
-var setKnownLinks = (knownLinks2, { entryNames, bookId }) => {
-  entryNames.forEach((entryName) => {
-    const link = entryName.replace(new RegExp(`^\\d+/media/|^${bookId}/medias/`), "").replace(new RegExp(`^${bookId}/gqls/`), "gqls/");
-    knownLinks2.set(link, { entryName, bookId });
-  });
-};
 
 // src/worker/fetch-worker.ts
-var STORAGE = "cache";
-var CONF_ENV = "development";
-var fetchAsset = async (_ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
+var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
   try {
     const buf = await offlineWorkerSync2.readZipEntry(entryId);
+    const url = ev.request.url;
     return new Response(buf, {
       headers: {
         "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
-        "Content-Length": buf.byteLength,
         "Content-Type": mimeType
       },
       // @ts-ignore: poor ts typing
+      ok: true,
+      redirected: false,
       status: 200,
-      statusText: "OK"
+      type: "cors",
+      url
     });
   } catch (e) {
     console.error("FAILED fetchAsset", e);
@@ -251,7 +223,8 @@ var fetchAsset = async (_ev, { entryId, mimeType, offlineWorkerSync: offlineWork
       // @ts-ignore: poor ts typing
       ok: false,
       status: 500,
-      statusText: e?.toString?.() || "fail fetch"
+      type: "cors",
+      url: ev.request.url
     });
   }
 };
@@ -293,113 +266,65 @@ var ACCEPTED_EXTENSIONS = {
   ".m4a": "audio/mp4",
   ".webp": "image/webp"
 };
-var putInCache = async (request, response) => {
-  const cache = await openCache(CONF_ENV);
-  await cache.put(request, response);
-};
-var onlineFirst = async (request, event) => {
-  try {
-    const responseFromNetwork = await fetch(request);
-    const cached = putInCache(request, responseFromNetwork.clone());
-    if (request.url.endsWith(".zip")) {
-      await cached;
-      event.waitUntil(Promise.resolve());
-    } else {
-      event.waitUntil(cached);
-    }
-    return responseFromNetwork;
-  } catch (_e) {
-    const over = /\/\?story=basic/.test(request.url) ? request.url.replace(/\/\?story=.*$/, "") : request;
-    const responseFromCache = await caches.match(over);
-    if (!responseFromCache) {
-      return new Response("FAILED fetch", {
-        // @ts-ignore: poor ts typing
-        ok: false,
-        status: 500,
-        type: "cors",
-        url: event.request.url
-      });
-    }
-    return responseFromCache;
-  }
-};
 var swSelf = self;
 swSelf.addEventListener("fetch", (ev) => {
   const url = ev.request.url;
   const extension = url.match(/\.[^.]+$/)?.[0];
   const mimeType = extension && extension in ACCEPTED_EXTENSIONS ? ACCEPTED_EXTENSIONS[extension] : "";
   const isValidScreenCall = canHandleScreenCall(url);
-  if (STORAGE !== "cache" && url.endsWith(".zip")) {
-    return;
-  }
   if (!mimeType && !isValidScreenCall) {
-    if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
-      console.debug("no ext", extension || url);
+    if (!/\.(css|tsx?|jsx?|woff2|fr)/.test(url)) {
+      console.debug("no ext", url.match(/\.[^.]+$/)?.[0]);
     }
-    return ev.respondWith(onlineFirst(ev.request, ev));
+    return;
   }
   const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, "")) || knownLinks.get(`medias/${url.replace(/https:\/\/.*?\//, "")}`);
+  if (!entryId && !isValidScreenCall) {
+    if (/lls|lelivrescolaire/.test(url)) {
+      console.info("no link for", url.replace(/https:\/\/.*?\//, ""));
+    }
+    return;
+  }
   if (isValidScreenCall) {
     console.debug("screencall!");
     return ev.respondWith(fetchScreenCall(ev, { offlineWorkerSync, knownLinks }));
   }
-  if (entryId) {
-    return ev.respondWith(fetchAsset(ev, { entryId, mimeType, offlineWorkerSync }));
-  }
-  if (/lls|lelivrescolaire/.test(url)) {
-    console.info("no link for", url.replace(/https:\/\/.*?\//, ""), `medias/${url.replace(/https:\/\/.*?\//, "")}`);
-  }
-  return;
+  return ev.respondWith(fetchAsset(ev, { entryId, mimeType, offlineWorkerSync }));
 });
 swSelf.addEventListener("install", (_event) => {
   swSelf.skipWaiting();
 });
-swSelf.addEventListener("activate", (event) => {
-  event.waitUntil(swSelf.clients.claim());
+swSelf.addEventListener("activate", (_event) => {
+  return swSelf.clients.claim();
 });
 var offlineWorker;
 var offlineWorkerSync;
 var initChannel = async (__, { ports }) => {
-  console.info(`FETCH WORKER innitChannel v${/* @__PURE__ */ new Date()}`);
+  console.info(`FETCH WORKER innitChannel v${13}`);
   offlineWorker = ports[0];
-  const { handler, ...sender } = makeSyncWorker(
+  offlineWorkerSync = makeSyncWorker(
     offlineWorker,
     ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks"],
     "fetchworker"
   );
-  offlineWorkerSync = sender;
-  offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks);
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();
-var configure = ({
-  storage,
-  confEnv
-} = {}) => {
-  STORAGE = "cache";
-  CONF_ENV = "development";
-  if (typeof storage !== "undefined") {
-    STORAGE = storage;
-  }
-  if (typeof confEnv !== "undefined") {
-    CONF_ENV = confEnv;
-  }
-  console.info("sw::configure", { STORAGE, CONF_ENV });
+var setKnownLinks = ({ entryNames, bookId }) => {
+  entryNames.forEach((entryName) => {
+    const link = entryName.replace(/^\d+\/media\//, "");
+    knownLinks.set(link, { entryName, bookId });
+  });
 };
 swSelf.onmessage = async ({
   data: { methodName, arg } = {},
   ports
 }) => {
   const services = {
-    initChannel,
-    configure
+    initChannel
   };
   try {
-    if (methodName === "configure") {
-      await services[methodName](arg);
-      return;
-    }
     if (methodName === "initChannel") {
       if (!ports.length) {
         throw new Error("fetchworker::missing port!");

package/lib/assets/offline-worker.js

@@ -1,89 +1,21 @@
-// src/utils/error.ts
-var tryCatch = (fn) => {
-  return (resolve, reject) => {
-    try {
-      return fn().then(resolve);
-    } catch (e) {
-      return reject(e);
-    }
-  };
-};
-
 // 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()}-${Math.random().toFixed(5)}`;
-        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(
-  (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 });
+  (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;
       }
+      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);
-  };
-};
-var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
 
 // src/worker/wwApi.ts
 var STATE = {
@@ -802,9 +734,6 @@ 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: {
@@ -842,26 +771,10 @@ var loadZip = async (buf, bookId) => {
 
 // src/worker/offline-worker.ts
 var CHECK_UPDATES = true;
-var STORAGE = "cache";
-var ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
-var CONF_ENV = "development";
-var LOADED_BOOKS = /* @__PURE__ */ new Map();
-var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
+var fetchZipFile = async (zipUrl, forceRefresh) => {
+  const opfsRoot = await navigator.storage.getDirectory();
   const fileName = zipUrl.split("/").slice(-1)[0];
   const readArrayBuffer = async () => {
-    if (STORAGE === "native") {
-      const back = await sender.nativeReadFile({ fname: fileName });
-      return back;
-    }
-    if (STORAGE === "cache") {
-      const response = await caches.match(zipUrl);
-      if (!response) {
-        throw new Error(`missing zip ${zipUrl}`);
-      }
-      const buf = await response.arrayBuffer();
-      return buf;
-    }
-    const opfsRoot = await navigator.storage.getDirectory();
     const handle = await opfsRoot.getFileHandle(fileName);
     const accessHandle = await handle.createSyncAccessHandle();
     const size = accessHandle.getSize();
@@ -887,8 +800,8 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     }
     return buf;
   } catch (e) {
-    if (e instanceof Error && e.message !== "forceRefresh" && !e.message.includes("refetching")) {
-      console.debug(`${STORAGE} zip not found, creating it`, e, zipUrl);
+    if (e.message !== "forceRefresh" && !e.message.includes("refetching")) {
+      console.debug("opfs db not found, creating it", e, zipUrl);
     }
     const response = await fetch(zipUrl);
     const contentLength = +response.headers.get("Content-Length");
@@ -899,7 +812,6 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     while (true) {
       const { done, value: chunk } = await reader.read();
       if (done) {
-        self.postMessage({ methodName: "opfsProgress", arg: { total: contentLength, bytes: contentLength } });
         break;
       }
       arrayBuffer.set(chunk, position);
@@ -914,69 +826,34 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       console.debug(error);
       throw new Error(error);
     }
-    if (STORAGE === "native") {
-      await sender.nativeWriteFile({ fname: fileName, buffer: arrayBuffer });
-    } else if (STORAGE === "opfs") {
-      const opfsRoot = await navigator.storage.getDirectory();
-      const handle = await opfsRoot.getFileHandle(fileName, { create: true });
-      const accessHandle = await handle.createSyncAccessHandle();
-      await accessHandle.truncate(0);
-      await accessHandle.write(arrayBuffer);
-      await accessHandle.close();
-    } else {
-      const cache = await openCache(CONF_ENV);
-      const response2 = new Response(arrayBuffer, {
-        headers: {
-          "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
-          "Content-Type": "application/zip"
-        },
-        // @ts-ignore: poor ts typing
-        ok: true,
-        redirected: false,
-        status: 200,
-        type: "cors",
-        url: zipUrl
-      });
-      await cache.put(zipUrl, response2);
-    }
+    const handle = await opfsRoot.getFileHandle(fileName, { create: true });
+    const accessHandle = await handle.createSyncAccessHandle();
+    await accessHandle.truncate(0);
+    await accessHandle.write(arrayBuffer);
+    await accessHandle.close();
     return await readArrayBuffer();
   }
 };
 var slugToFileMeta2 = async ({ slug }) => {
+  console.debug("hereshit");
   const json = await readZipEntry({ bookId: "preload", entryName: "preload/hashmap_slugToMetaPage.json", asJson: true });
+  console.debug("hereshit2");
   return slugToFileMeta({ slug, json });
 };
 var PRELOAD_AS_BOOK_ID = "preload";
 var isOldZip = (bookId) => typeof bookId === "number";
 var loadBook2 = async ({ id: bookId, forceRefresh }) => {
-  if (LOADED_BOOKS.has(bookId)) {
-    await LOADED_BOOKS.get(bookId);
-    self.postMessage({ methodName: "opfsProgress", arg: { total: 1, bytes: 1 } });
-    return;
+  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 } });
+    if (isOldZip(bookId)) {
+      const json = await readZipEntry({ entryName: `preload/${bookId}.json`, bookId: PRELOAD_AS_BOOK_ID, asJson: true });
+      loadBook(json);
+    }
+  } catch (e) {
+    console.error("failed", e);
   }
-  const p = new Promise(
-    tryCatch(async () => {
-      const buf = await fetchZipFile(`${ZIP_BASE_URL}/${bookId}.zip`, { forceRefresh });
-      try {
-        const entryNames = await loadZip(new Uint8Array(buf), bookId);
-        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
-        if (isOldZip(bookId)) {
-          const json = await readZipEntry({
-            entryName: `preload/${bookId}.json`,
-            bookId: PRELOAD_AS_BOOK_ID,
-            asJson: true
-          });
-          loadBook(json);
-        }
-        return true;
-      } catch (e) {
-        console.error("failed", e);
-        return false;
-      }
-    })
-  );
-  LOADED_BOOKS.set(bookId, p);
-  await p;
 };
 var loadPageContent2 = async ({
   bookId: iBookId,
@@ -998,7 +875,7 @@ var loadPageContent2 = async ({
 var fetchWorker;
 var initChannel = (__, { ports }) => {
   fetchWorker = ports[0];
-  const { canHandle, handle } = makeSyncHandler(fetchWorker, {
+  const defaultHandler = makeSyncHandler(fetchWorker, {
     readZipEntry,
     loadBook: loadBook2,
     slugToFileMeta: slugToFileMeta2,
@@ -1010,69 +887,23 @@ var initChannel = (__, { ports }) => {
       self.postMessage({ methodName: "ready" });
       return;
     }
-    if (canHandle(dataObj.data?.methodName || "")) {
-      return handle(dataObj);
-    }
-    console.error("unknown methodName", dataObj.data?.methodName);
+    defaultHandler(dataObj);
   };
   fetchWorker.onmessage = fn;
 };
-var loadBooks = async ({ primaryOnly = false } = {}) => {
-  let entries = [];
-  if (STORAGE === "native") {
-    entries = await sender.nativeListZips();
-  } else if (STORAGE === "opfs") {
-    const opfsRoot = await navigator.storage.getDirectory();
-    entries = await opfsRoot.values();
-  } else {
-    const cache = await openCache(CONF_ENV);
-    const keys = await cache.keys();
-    const zips = keys.filter((key2) => {
-      return key2.url.match(/lecture-cp\.zip/);
-    });
-    entries = zips.map((zip) => ({ name: String(zip.url.split("/").pop()) }));
-  }
+var loadBooks = async () => {
+  const opfsRoot = await navigator.storage.getDirectory();
+  const entries = await opfsRoot.values();
   for await (const entry of entries) {
-    if (/preload/.test(entry.name)) {
-      continue;
-    }
     if (/\d+\.zip$/.test(entry.name)) {
-      if (!primaryOnly) {
-        const bookId = entry.name.match(/\d+/)[0];
-        await loadBook2({ id: Number.parseInt(bookId, 10) });
-      }
+      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 = ({
-  storage,
-  checkUpdates,
-  zipBaseUrl,
-  confEnv
-}) => {
-  CHECK_UPDATES = true;
-  STORAGE = "cache";
-  ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
-  CONF_ENV = "development";
-  if (typeof storage !== "undefined") {
-    STORAGE = storage;
-  }
-  if (typeof checkUpdates !== "undefined") {
-    CHECK_UPDATES = !!checkUpdates;
-  }
-  if (typeof zipBaseUrl !== "undefined") {
-    ZIP_BASE_URL = zipBaseUrl;
-  }
-  if (typeof confEnv !== "undefined") {
-    CONF_ENV = confEnv;
-  }
-  console.info("ow::configure", { STORAGE, CHECK_UPDATES, ZIP_BASE_URL, CONF_ENV });
-};
 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);
@@ -1085,13 +916,10 @@ var loadPreload2 = async () => {
     console.error("failed", e);
   }
 };
-var mainHandle = makeSyncHandler(self, {
+self.onmessage = makeSyncHandler(self, {
   initChannel,
   loadPreload: loadPreload2,
   readZipEntry,
   loadBooks,
-  loadBook: loadBook2,
-  configure
+  loadBook: loadBook2
 });
-var { handler, ...sender } = makeSyncWorker(self, ["nativeWriteFile", "nativeReadFile", "nativeListZips"]);
-self.onmessage = combineHandlers(mainHandle, handler);

package/lib/index.js

@@ -1,19 +1,8 @@
-// src/utils/error.ts
-var tryCatch = (fn) => {
-  return (resolve, reject) => {
-    try {
-      return fn().then(resolve);
-    } catch (e) {
-      return reject(e);
-    }
-  };
-};
-
 // 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 fn2 = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
     if (eventId && eventId in dic) {
       if (error) {
         dic[eventId].reject(error);
@@ -22,93 +11,53 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       }
     } else {
       if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
-        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
+        console.error(`syncWorker: ${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()}-${Math.random().toFixed(5)}`;
+        const eventId = `${methodName}:${Date.now()}`;
         dic[eventId] = { resolve, reject };
-        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
       });
     };
   };
   const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
-    on: (key, fn2) => {
-      cbks[key] = fn2;
+    on: (key, fn3) => {
+      cbks[key] = fn3;
     }
   });
-  return {
-    ...obj,
-    handler: {
-      canHandle: (methodName) => {
-        return methodName in cbks || methodNames.includes(methodName);
-      },
-      handle: fn
-    }
-  };
+  return obj;
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (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 });
+  (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;
       }
+      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 offlineWorker = new Worker("/src/worker/offline-worker.js", { type: "module" });
-var { handler, ...offlineWorkerSync } = makeSyncWorker(
-  offlineWorker,
-  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook"],
+var offlineWorkerSync = makeSyncWorker(
+  // @ts-ignore: TODO
+  new Worker("/src/worker/offline-worker.js", { type: "module" }),
+  ["initChannel", "readZipEntry", "loadPreload", "loadBooks", "loadBook"],
   "app:offlineWorker"
 );
-var fetchWorkerPromise = new Promise(
-  tryCatch(async () => {
-    let fetchWorker = null;
-    await navigator.serviceWorker.register("/fetch-worker.js", { type: "module" }).then((reg) => {
-      return reg.update().catch((e) => {
-        console.debug(e, "likely we are offline");
-      });
-    });
-    await navigator.serviceWorker.ready.then(async (reg) => {
-      console.debug("Service Worker registered:", reg.scope);
-      fetchWorker = reg.active;
-    }).catch((err) => console.error("Service Worker registration failed:", err));
-    if (!fetchWorker) {
-      console.debug("failed to get fetch worker");
-    }
-    return fetchWorker;
-  })
-);
 var setWorkersReady;
 var workersReadyPromise = new Promise((resolve) => {
   setWorkersReady = resolve;
@@ -117,81 +66,46 @@ var setBooksLoaded;
 var setBooksLoadedPromise = new Promise((resolve) => {
   setBooksLoaded = resolve;
 });
-var installWorker = async ({
-  skipLoadBooks = false,
-  primaryOnly = false,
-  nativeReadFile,
-  nativeWriteFile,
-  nativeListZips,
-  storage,
-  zipBaseUrl,
-  checkUpdates,
-  confEnv
-} = {}) => {
-  const fetchWorker = await fetchWorkerPromise;
-  const configureOptions = { storage, zipBaseUrl, checkUpdates, confEnv };
-  if (nativeReadFile) {
-    const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
-    offlineWorker.onmessage = combineHandlers(handler, wwHandler);
-    if (storage !== "native") {
-      console.warn("nativeReadFile given, ignoring storage", storage);
+var fn = async () => {
+  let fetchWorker = null;
+  await navigator.serviceWorker.getRegistrations().then(async (registrations) => {
+    for (const registration of registrations) {
+      await registration.unregister();
     }
-    offlineWorkerSync.configure({ ...configureOptions, storage: "native" });
-  } else {
-    offlineWorker.onmessage = handler.handle;
-    offlineWorkerSync.configure(configureOptions);
+  });
+  await navigator.serviceWorker.register("/fetch-worker.js", { type: "module" }).then((reg) => reg.update());
+  await navigator.serviceWorker.ready.then(async (reg) => {
+    console.debug("Service Worker registered:", reg.scope);
+    fetchWorker = reg.active;
+  }).catch((err) => console.error("Service Worker registration failed:", err));
+  if (!fetchWorker) {
+    console.debug("failed to get fetch worker");
+    return;
   }
   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 } });
   offlineWorkerSync.on("opfsProgress", () => {
   });
-  if (!primaryOnly) {
-    await offlineWorkerSync.loadPreload();
-  }
-  if (!skipLoadBooks) {
-    await offlineWorkerSync.loadBooks({ primaryOnly });
-  }
+  await offlineWorkerSync.loadPreload();
+  await offlineWorkerSync.loadBooks();
   setBooksLoaded();
 };
-var useOfflineWorker_default = ({
-  primaryOnly = false,
-  nativeReadFile,
-  nativeWriteFile,
-  nativeListZips,
-  checkUpdates,
-  storage,
-  zipBaseUrl,
-  confEnv
-} = {}) => {
+fn();
+var useOfflineWorker_default = () => {
   const [ready, setReady] = useState(false);
   useEffect(() => {
-    const fn = async () => {
-      await installWorker({
-        primaryOnly,
-        nativeReadFile,
-        nativeWriteFile,
-        nativeListZips,
-        storage,
-        zipBaseUrl,
-        checkUpdates,
-        confEnv
-      });
+    const fn2 = async () => {
       await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
-      fetch(window.location.href.replace(window.location.search, ""));
       setReady(true);
     };
-    fn();
-  }, [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 });
-    },
-    []
-  );
+    fn2();
+  }, []);
+  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-bfdb7edf",
+  "version": "24.22.0-debug",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -36,12 +36,10 @@
   "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",
@@ -50,21 +48,17 @@
     "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-bfdb7edf"
+    "@lls/vitescripts": "24.22.0"
   },
   "dependencies": {
     "fflate": "0.8.2"
   },
   "scripts": {
-    "start": "pnpm ladle serve",
+    "start": "echo no devserver",
     "dts": "pnpm tsc --project tsconfig.production.json",
-    "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"
+    "build": "node build",
+    "test": "bun test --bail",
+    "lint": "pnpm biome check --apply src __tests__"
   }
 }