@lls/offline 24.22.0-5c0809f5 → 24.22.0-658f61a6

package/lib/assets/fetch-worker.js

@@ -19,7 +19,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}`;
+        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -62,7 +62,7 @@ var makeSyncHandler = a(
   })
 );
 var jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
-var openCache = async () => caches.open(`LLS_OFFLINE_${process.env.CONF_ENV}`);
+var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
 
 // src/worker/swFetchScreenCall.ts
 var zipSlugName = (str) => str.replace(/[^a-zA-Z0-9-.]/g, "");
@@ -75,6 +75,15 @@ 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: {} } };
 };
@@ -189,6 +198,7 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
 };
 var handles = {
   coreFetchBookDrawerScreen,
+  cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
   cocoreFetchPartialPageSiblingsScreen
@@ -220,21 +230,20 @@ var setKnownLinks = (knownLinks2, { entryNames, bookId }) => {
 };
 
 // src/worker/fetch-worker.ts
-var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
+var STORAGE = "cache";
+var CONF_ENV = "development";
+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,
-      type: "cors",
-      url
+      statusText: "OK"
     });
   } catch (e) {
     console.error("FAILED fetchAsset", e);
@@ -242,8 +251,7 @@ var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorke
       // @ts-ignore: poor ts typing
       ok: false,
       status: 500,
-      type: "cors",
-      url: ev.request.url
+      statusText: e?.toString?.() || "fail fetch"
     });
   }
 };
@@ -283,10 +291,12 @@ var ACCEPTED_EXTENSIONS = {
   ".gif": "image/gif",
   ".webm": "video/webm",
   ".m4a": "audio/mp4",
-  ".webp": "image/webp"
+  ".webp": "image/webp",
+  ".riv": "application/octet-stream",
+  ".pdf": "application/pdf"
 };
 var putInCache = async (request, response) => {
-  const cache = await openCache();
+  const cache = await openCache(CONF_ENV);
   await cache.put(request, response);
 };
 var onlineFirst = async (request, event) => {
@@ -300,22 +310,24 @@ var onlineFirst = async (request, event) => {
       event.waitUntil(cached);
     }
     return responseFromNetwork;
-  } catch (_e) {
+  } 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 new Response(
+        `FAILED fetch ${e && typeof e === "object" && "message" in e ? e.message : e?.toString?.()}`,
+        {
+          // @ts-ignore: poor ts typing
+          ok: false,
+          status: 500,
+          type: "cors",
+          url: event.request.url
+        }
+      );
     }
     return responseFromCache;
   }
 };
-var STORAGE = "cache";
 var swSelf = self;
 swSelf.addEventListener("fetch", (ev) => {
   const url = ev.request.url;
@@ -362,16 +374,23 @@ var initChannel = async (__, { ports }) => {
   );
   offlineWorkerSync = sender;
   offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, setKnownLinks));
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();
-var configure = ({ storage } = {}) => {
+var configure = ({
+  storage,
+  confEnv
+} = {}) => {
   STORAGE = "cache";
+  CONF_ENV = "development";
   if (typeof storage !== "undefined") {
     STORAGE = storage;
   }
-  console.info("sw::configure", { STORAGE });
+  if (typeof confEnv !== "undefined") {
+    CONF_ENV = confEnv;
+  }
+  console.info("sw::configure", { STORAGE, CONF_ENV });
 };
 swSelf.onmessage = async ({
   data: { methodName, arg } = {},

package/lib/assets/offline-worker.js

@@ -30,7 +30,7 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}`;
+        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         dic[eventId] = { resolve, reject };
         offlineWorker.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -83,7 +83,17 @@ var combineHandlers = (...handlers) => {
     console.error("no handlers matched", methodName);
   };
 };
-var openCache = async () => caches.open(`LLS_OFFLINE_${process.env.CONF_ENV}`);
+var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
+var concatArrayBuffers = (buffers) => {
+  const totalLength = buffers.reduce((sum, buf) => sum + buf.byteLength, 0);
+  const concatenated = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buffer of buffers) {
+    concatenated.set(new Uint8Array(buffer), offset);
+    offset += buffer.byteLength;
+  }
+  return concatenated.buffer;
+};
 
 // src/worker/wwApi.ts
 var STATE = {
@@ -765,6 +775,9 @@ async function decryptData(encryptedData, key2, iv2) {
   return decryptedData;
 }
 var BOOKS = {};
+var zipNameInMedias = (zipName) => {
+  return /^(pages|book)/.test(zipName);
+};
 var readZipEntry = async ({
   bookId,
   entryName,
@@ -774,9 +787,20 @@ var readZipEntry = async ({
     console.trace("no bookId", bookId, "found");
     return null;
   }
-  const bookEntry = BOOKS[bookId].get(entryName);
+  const manifest = BOOKS[bookId].manifest;
+  let overridenName = entryName;
+  if (manifest && !entryName.includes("gqls/")) {
+    const zipName = entryName.replace("medias/", "");
+    if (zipNameInMedias(zipName)) {
+      const originalName = manifest.medias[zipName];
+      overridenName = `medias/${originalName}`;
+    } else {
+      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");
+    console.info("no bookEntry", entryName, "found", overridenName);
     return null;
   }
   if (!bookEntry.decoded) {
@@ -787,16 +811,6 @@ var readZipEntry = async ({
 var hasZip = (bookId) => {
   return !!BOOKS[bookId];
 };
-function concatArrayBuffers(buffers) {
-  const totalLength = buffers.reduce((sum, buf) => sum + buf.byteLength, 0);
-  const concatenated = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const buffer of buffers) {
-    concatenated.set(new Uint8Array(buffer), offset);
-    offset += buffer.byteLength;
-  }
-  return concatenated.buffer;
-}
 var loadZip = async (buf, bookId) => {
   const m = /* @__PURE__ */ new Map();
   const unzipper = new Unzip();
@@ -836,14 +850,26 @@ var loadZip = async (buf, bookId) => {
     await sleep;
   }
   unzipper.push(buf.slice((nChunks - 1) * chunkSize, buf.byteLength), true);
-  BOOKS[bookId] = m;
-  return [...m.keys()];
+  BOOKS[bookId] = {
+    map: m,
+    manifest: null
+  };
+  const manifestEntry = m.get("manifest.json");
+  const keys = [...m.keys()];
+  if (manifestEntry) {
+    manifestEntry.decoded = await decryptData(await manifestEntry.zipEntry.getData(), key, iv);
+    BOOKS[bookId].manifest = bufToJson(manifestEntry.decoded);
+    const { medias } = BOOKS[bookId].manifest;
+    keys.push(...Object.keys(medias).map((entryName) => `medias/${entryName}`));
+  }
+  return keys;
 };
 
 // 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 } = {}) => {
   const fileName = zipUrl.split("/").slice(-1)[0];
@@ -923,7 +949,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       await accessHandle.write(arrayBuffer);
       await accessHandle.close();
     } else {
-      const cache = await openCache();
+      const cache = await openCache(CONF_ENV);
       const response2 = new Response(arrayBuffer, {
         headers: {
           "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
@@ -1024,9 +1050,11 @@ var loadBooks = async ({ primaryOnly = false } = {}) => {
     const opfsRoot = await navigator.storage.getDirectory();
     entries = await opfsRoot.values();
   } else {
-    const cache = await openCache();
+    const cache = await openCache(CONF_ENV);
     const keys = await cache.keys();
-    const zips = keys.filter((key2) => key2.url.endsWith(".zip"));
+    const zips = keys.filter((key2) => {
+      return key2.url.match(/lecture-cp\.zip|story-.*?\.zip/);
+    });
     entries = zips.map((zip) => ({ name: String(zip.url.split("/").pop()) }));
   }
   for await (const entry of entries) {
@@ -1049,11 +1077,13 @@ var loadBooks = async ({ primaryOnly = false } = {}) => {
 var configure = ({
   storage,
   checkUpdates,
-  zipBaseUrl
+  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;
   }
@@ -1063,7 +1093,10 @@ var configure = ({
   if (typeof zipBaseUrl !== "undefined") {
     ZIP_BASE_URL = zipBaseUrl;
   }
-  console.info("ow::configure", { STORAGE, CHECK_UPDATES, ZIP_BASE_URL });
+  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";

package/lib/index.js

@@ -30,7 +30,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}`;
+        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -94,6 +94,9 @@ var { handler, ...offlineWorkerSync } = makeSyncWorker(
 var fetchWorkerPromise = new Promise(
   tryCatch(async () => {
     let fetchWorker = null;
+    await navigator.serviceWorker.getRegistrations().then((registrations) => {
+      return Promise.all(registrations.map((reg) => reg.unregister()));
+    });
     await navigator.serviceWorker.register("/fetch-worker.js", { type: "module" }).then((reg) => {
       return reg.update().catch((e) => {
         console.debug(e, "likely we are offline");
@@ -125,10 +128,11 @@ var installWorker = async ({
   nativeListZips,
   storage,
   zipBaseUrl,
-  checkUpdates
+  checkUpdates,
+  confEnv
 } = {}) => {
   const fetchWorker = await fetchWorkerPromise;
-  const configureOptions = { storage, zipBaseUrl, checkUpdates };
+  const configureOptions = { storage, zipBaseUrl, checkUpdates, confEnv };
   if (nativeReadFile) {
     const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
     offlineWorker.onmessage = combineHandlers(handler, wwHandler);
@@ -162,7 +166,8 @@ var useOfflineWorker_default = ({
   nativeListZips,
   checkUpdates,
   storage,
-  zipBaseUrl
+  zipBaseUrl,
+  confEnv
 } = {}) => {
   const [ready, setReady] = useState(false);
   useEffect(() => {
@@ -174,14 +179,15 @@ var useOfflineWorker_default = ({
         nativeListZips,
         storage,
         zipBaseUrl,
-        checkUpdates
+        checkUpdates,
+        confEnv
       });
       await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
       fetch(window.location.href.replace(window.location.search, ""));
       setReady(true);
     };
     fn();
-  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates]);
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
   const loadBook = useCallback(
     async ({ id, forceRefresh }, cbk) => {
       offlineWorkerSync.on("opfsProgress", cbk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.22.0-5c0809f5",
+  "version": "24.22.0-658f61a6",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -52,7 +52,7 @@
     "vite": "7.0.0",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.22.0-5c0809f5"
+    "@lls/vitescripts": "24.22.0-658f61a6"
   },
   "dependencies": {
     "fflate": "0.8.2"