@lls/offline 24.27.0-9f297e77 → 24.27.0-a1932716

package/lib/assets/fetch-worker.js

@@ -1,21 +1,3 @@
-// src/utils/stream.ts
-var parseRange = (range, size) => {
-  const parts = range.replace("bytes=", "").split("-");
-  let start = Number.parseInt(parts[0], 10);
-  let end = Number.parseInt(parts[1], 10);
-  if (isNaN(start)) {
-    start = size - end;
-    end = size - 1;
-  } else if (isNaN(end)) {
-    end = size - 1;
-  }
-  if (end > size - 1) {
-    end = size - 1;
-  }
-  const chunkSize = end - start + 1;
-  return { start, end, chunkSize };
-};
-
 // src/utils/worker.ts
 var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const dic = {};
@@ -95,7 +77,7 @@ var cocoreFetchPartialPageScreen = async (_ev, { offlineWorkerSync: offlineWorke
   const key = `gqls/${zipSlugName(variables.slugs[0] || "")}.json`;
   const entryId = knownLinks2.get(key);
   if (!entryId) {
-    throw new Error(`slug not found ${key}, links size: ${knownLinks2.size}`);
+    throw new Error(`slug not found ${key}`);
   }
   const gqlPage = await offlineWorkerSync2.loadPageContent({ entryId });
   return { data: gqlPage };
@@ -220,23 +202,12 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
     }
   }
 };
-var cocoreFetchPrimaryMethod = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables }) => {
-  const uri = variables.uris?.[0];
-  if (!uri) {
-    throw new Error("invalid uri");
-  }
-  const method = await offlineWorkerSync2.readZipEntry({ bookId: uri, entryName: "gqls/method.json", asJson: true });
-  return {
-    data: method
-  };
-};
 var handles = {
   coreFetchBookDrawerScreen,
   cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
-  cocoreFetchPartialPageSiblingsScreen,
-  cocoreFetchPrimaryMethod
+  cocoreFetchPartialPageSiblingsScreen
 };
 var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).test(url);
 var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
@@ -245,8 +216,8 @@ var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, known
       // @ts-expect-error 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);
     const key = ev.request.url.match(Object.keys(handles).join("|"))?.[0];
-    console.debug("screencall", key, "qs", variables, "vs body", ev.request.body);
     if (!key) {
       throw new Error("unknown ev");
     }
@@ -267,39 +238,17 @@ var setKnownLinks = (knownLinks2, { entryNames, 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, 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")) {
-        return [buf2, {}];
-      }
-      if (!range) {
-        return [
-          buf2,
-          {
-            "Accept-Ranges": "bytes",
-            "Content-Range": `bytes ${0}-${buf2.byteLength}/${buf2.byteLength}`
-          }
-        ];
-      }
-      const { start, end, chunkSize } = parseRange(range, buf2.byteLength);
-      const rangeHeaders = {
-        "Content-Length": chunkSize,
-        "Accept-Ranges": "bytes",
-        "Content-Range": `bytes ${start}-${end}/${buf2.byteLength}`
-      };
-      return [buf2.slice(start, end + 1), rangeHeaders];
-    });
+    const buf = await offlineWorkerSync2.readZipEntry(entryId);
     return new Response(buf, {
       headers: {
         "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
         "Content-Length": buf.byteLength,
-        "Content-Type": mimeType,
-        ...maybeRangeHeaders
+        "Content-Type": mimeType
       },
       // @ts-ignore: poor ts typing
-      status: maybeRangeHeaders["Content-Range"] ? 206 : 200,
+      status: 200,
       statusText: "OK"
     });
   } catch (e) {
@@ -398,16 +347,14 @@ swSelf.addEventListener("fetch", (ev) => {
     return;
   }
   if (!mimeType && !isValidScreenCall) {
-    if (!/\.(css|tsx?|[mj]sx?|woff2|fr|(web)?manifest)(\??|$)|@(vite|react|id)|(:6019\/?$)/.test(url)) {
+    if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
       console.debug("no ext", extension || url);
     }
     return ev.respondWith(onlineFirst(ev.request, ev));
   }
-  if (/http:\/\/localhost:\d+\/(favicon\.svg|assets\/)/.test(url)) {
-    return;
-  }
   const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, "")) || knownLinks.get(`medias/${url.replace(/https:\/\/.*?\//, "")}`);
   if (isValidScreenCall) {
+    console.debug("screencall!");
     return ev.respondWith(fetchScreenCall(ev, { offlineWorkerSync, knownLinks }));
   }
   if (entryId) {
@@ -416,7 +363,6 @@ swSelf.addEventListener("fetch", (ev) => {
   if (/lls|lelivrescolaire/.test(url)) {
     console.info("no link for", url.replace(/https:\/\/.*?\//, ""), `medias/${url.replace(/https:\/\/.*?\//, "")}`);
   }
-  console.debug("unintercepted url", url);
   return;
 });
 swSelf.addEventListener("install", (_event) => {
@@ -437,10 +383,7 @@ var initChannel = async (__, { ports }) => {
   );
   offlineWorkerSync = sender;
   offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", ({ entryNames, bookId, eventId }) => {
-    setKnownLinks(knownLinks, { entryNames, bookId });
-    offlineWorker.postMessage({ methodName: "setKnownLinks:back", eventId });
-  });
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();

package/lib/assets/offline-worker.js

@@ -802,14 +802,12 @@ var readZipEntry = async ({
       const originalName = manifest.medias[zipName];
       overridenName = `medias/${originalName}`;
     } else {
-      if (entryName !== "manifest.json") {
-        console.error("any media should exist in manifest", zipName, entryName, bookId);
-      }
+      console.error("any media should exist in manifest", zipName, entryName, bookId);
     }
   }
   const bookEntry = BOOKS[bookId].map.get(overridenName);
   if (!bookEntry) {
-    console.info("no bookEntry", entryName, "overridingName:", overridenName, "for book", bookId);
+    console.info("no bookEntry", entryName, "found", overridenName);
     return null;
   }
   if (!bookEntry.decoded) {
@@ -888,8 +886,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       return back;
     }
     if (STORAGE === "cache") {
-      const cache = await openCache(CONF_ENV);
-      const response = await cache.match(zipUrl);
+      const response = await caches.match(zipUrl);
       if (!response) {
         throw new Error(`missing zip ${zipUrl}`);
       }
@@ -913,11 +910,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     const buf = await readArrayBuffer();
     if (CHECK_UPDATES) {
       const response = await fetch(zipUrl, { method: "HEAD" });
-      let remoteSize = Number.parseInt(response.headers.get("content-length") ?? "");
-      if (!remoteSize) {
-        console.info("remoteSize not found. will skip update. Is the server up at", zipUrl);
-        remoteSize = buf.byteLength;
-      }
+      const remoteSize = Number.parseInt(response.headers.get("content-length") || "0", 10);
       if (remoteSize !== buf.byteLength) {
         const error = `new ${fileName} available, refetching (opfs:${buf.byteLength} vs remote:${remoteSize})`;
         console.debug(error);
@@ -925,7 +918,6 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
         throw new Error(`new ${fileName} available, refetching`);
       }
     }
-    self.postMessage({ methodName: "opfsProgress", arg: { total: buf.byteLength, bytes: buf.byteLength } });
     return buf;
   } catch (e) {
     if (e instanceof Error && e.message !== "forceRefresh" && !e.message.includes("refetching")) {
@@ -955,7 +947,6 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
         self.postMessage({ methodName: "opfsProgress", arg: { total: contentLength, bytes: position } });
       }
     }
-    console.debug("zip loaded:", arrayBuffer.byteLength);
     if (STORAGE === "native") {
       await sender.nativeWriteFile({ fname: fileName, buffer: arrayBuffer });
     } else if (STORAGE === "opfs") {
@@ -1001,12 +992,7 @@ var loadBook2 = async ({ id: bookId, forceRefresh }) => {
       const buf = await fetchZipFile(`${ZIP_BASE_URL}/${bookId}.zip`, { forceRefresh });
       try {
         const entryNames = await loadZip(new Uint8Array(buf), bookId);
-        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;
+        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
         if (isOldZip(bookId)) {
           const json = await readZipEntry({
             entryName: `preload/${bookId}.json`,
@@ -1014,13 +1000,6 @@ var loadBook2 = async ({ id: bookId, forceRefresh }) => {
             asJson: true
           });
           loadBook(json);
-        } else {
-          try {
-            const { createdAt } = await readZipEntry({ bookId, entryName: "manifest.json", asJson: true });
-            console.debug("zipversion", createdAt);
-          } catch (e) {
-            console.debug("failed to read manifest.json", e);
-          }
         }
         return true;
       } catch (e) {
@@ -1050,14 +1029,6 @@ 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 initChannel = (__, { ports }) => {
   fetchWorker = ports[0];
   const { canHandle, handle } = makeSyncHandler(fetchWorker, {
@@ -1072,14 +1043,6 @@ var initChannel = (__, { ports }) => {
       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);
     }

package/lib/index.js

@@ -161,7 +161,6 @@ var installWorker = async ({
   setBooksLoaded();
 };
 var useOfflineWorker_default = ({
-  skipLoadBooks,
   primaryOnly = false,
   nativeReadFile,
   nativeWriteFile,
@@ -175,7 +174,6 @@ var useOfflineWorker_default = ({
   useEffect(() => {
     const fn = async () => {
       await installWorker({
-        skipLoadBooks,
         primaryOnly,
         nativeReadFile,
         nativeWriteFile,
@@ -190,21 +188,11 @@ var useOfflineWorker_default = ({
       setReady(true);
     };
     fn();
-  }, [
-    skipLoadBooks,
-    primaryOnly,
-    nativeReadFile,
-    nativeWriteFile,
-    nativeListZips,
-    storage,
-    zipBaseUrl,
-    checkUpdates,
-    confEnv
-  ]);
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
   const loadBook = useCallback(
-    async ({ forceRefresh, ...idOrUri }, cbk) => {
-      cbk && offlineWorkerSync.on("opfsProgress", cbk);
-      return await offlineWorkerSync.loadBook({ id: "id" in idOrUri ? idOrUri.id : idOrUri.uri, forceRefresh });
+    async ({ id, forceRefresh }, cbk) => {
+      offlineWorkerSync.on("opfsProgress", cbk);
+      return await offlineWorkerSync.loadBook({ id, forceRefresh });
     },
     []
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.27.0-9f297e77",
+  "version": "24.27.0-a1932716",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -52,7 +52,7 @@
     "vite": "7.0.7",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.27.0-9f297e77"
+    "@lls/vitescripts": "24.27.0-a1932716"
   },
   "dependencies": {
     "fflate": "0.8.2"