@lls/offline 24.27.0-8446b483 → 24.27.0-9f297e77

package/lib/assets/fetch-worker.js

@@ -1,3 +1,21 @@
+// 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 = {};
@@ -77,7 +95,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}`);
+    throw new Error(`slug not found ${key}, links size: ${knownLinks2.size}`);
   }
   const gqlPage = await offlineWorkerSync2.loadPageContent({ entryId });
   return { data: gqlPage };
@@ -202,12 +220,23 @@ 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
+  cocoreFetchPartialPageSiblingsScreen,
+  cocoreFetchPrimaryMethod
 };
 var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).test(url);
 var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
@@ -216,8 +245,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");
     }
@@ -238,17 +267,39 @@ 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 = await offlineWorkerSync2.readZipEntry(entryId);
+    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];
+    });
     return new Response(buf, {
       headers: {
         "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
         "Content-Length": buf.byteLength,
-        "Content-Type": mimeType
+        "Content-Type": mimeType,
+        ...maybeRangeHeaders
       },
       // @ts-ignore: poor ts typing
-      status: 200,
+      status: maybeRangeHeaders["Content-Range"] ? 206 : 200,
       statusText: "OK"
     });
   } catch (e) {
@@ -347,14 +398,16 @@ swSelf.addEventListener("fetch", (ev) => {
     return;
   }
   if (!mimeType && !isValidScreenCall) {
-    if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
+    if (!/\.(css|tsx?|[mj]sx?|woff2|fr|(web)?manifest)(\??|$)|@(vite|react|id)|(:6019\/?$)/.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) {
@@ -363,6 +416,7 @@ 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) => {
@@ -383,7 +437,10 @@ var initChannel = async (__, { ports }) => {
   );
   offlineWorkerSync = sender;
   offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
+  offlineWorkerSync.on("setKnownLinks", ({ entryNames, bookId, eventId }) => {
+    setKnownLinks(knownLinks, { entryNames, bookId });
+    offlineWorker.postMessage({ methodName: "setKnownLinks:back", eventId });
+  });
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();

package/lib/assets/offline-worker.js

@@ -802,12 +802,14 @@ var readZipEntry = async ({
       const originalName = manifest.medias[zipName];
       overridenName = `medias/${originalName}`;
     } else {
-      console.error("any media should exist in manifest", zipName, entryName, bookId);
+      if (entryName !== "manifest.json") {
+        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, "found", overridenName);
+    console.info("no bookEntry", entryName, "overridingName:", overridenName, "for book", bookId);
     return null;
   }
   if (!bookEntry.decoded) {
@@ -886,7 +888,8 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       return back;
     }
     if (STORAGE === "cache") {
-      const response = await caches.match(zipUrl);
+      const cache = await openCache(CONF_ENV);
+      const response = await cache.match(zipUrl);
       if (!response) {
         throw new Error(`missing zip ${zipUrl}`);
       }
@@ -910,7 +913,11 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     const buf = await readArrayBuffer();
     if (CHECK_UPDATES) {
       const response = await fetch(zipUrl, { method: "HEAD" });
-      const remoteSize = Number.parseInt(response.headers.get("content-length") || "0", 10);
+      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;
+      }
       if (remoteSize !== buf.byteLength) {
         const error = `new ${fileName} available, refetching (opfs:${buf.byteLength} vs remote:${remoteSize})`;
         console.debug(error);
@@ -918,6 +925,7 @@ 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")) {
@@ -947,6 +955,7 @@ 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") {
@@ -992,7 +1001,12 @@ 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);
-        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, 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;
         if (isOldZip(bookId)) {
           const json = await readZipEntry({
             entryName: `preload/${bookId}.json`,
@@ -1000,6 +1014,13 @@ 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) {
@@ -1029,6 +1050,14 @@ 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, {
@@ -1043,6 +1072,14 @@ 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,6 +161,7 @@ var installWorker = async ({
   setBooksLoaded();
 };
 var useOfflineWorker_default = ({
+  skipLoadBooks,
   primaryOnly = false,
   nativeReadFile,
   nativeWriteFile,
@@ -174,6 +175,7 @@ var useOfflineWorker_default = ({
   useEffect(() => {
     const fn = async () => {
       await installWorker({
+        skipLoadBooks,
         primaryOnly,
         nativeReadFile,
         nativeWriteFile,
@@ -188,11 +190,21 @@ var useOfflineWorker_default = ({
       setReady(true);
     };
     fn();
-  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
+  }, [
+    skipLoadBooks,
+    primaryOnly,
+    nativeReadFile,
+    nativeWriteFile,
+    nativeListZips,
+    storage,
+    zipBaseUrl,
+    checkUpdates,
+    confEnv
+  ]);
   const loadBook = useCallback(
-    async ({ id, forceRefresh }, cbk) => {
-      offlineWorkerSync.on("opfsProgress", cbk);
-      return await offlineWorkerSync.loadBook({ id, forceRefresh });
+    async ({ forceRefresh, ...idOrUri }, cbk) => {
+      cbk && offlineWorkerSync.on("opfsProgress", cbk);
+      return await offlineWorkerSync.loadBook({ id: "id" in idOrUri ? idOrUri.id : idOrUri.uri, forceRefresh });
     },
     []
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.27.0-8446b483",
+  "version": "24.27.0-9f297e77",
   "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-8446b483"
+    "@lls/vitescripts": "24.27.0-9f297e77"
   },
   "dependencies": {
     "fflate": "0.8.2"