@lls/offline 24.22.0-658f61a6 → 24.22.0-a4074e64

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()}-${Math.random().toFixed(5)}`;
+        const eventId = `${methodName}:${Date.now()}`;
         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 (mode) => caches.open(`LLS_OFFLINE_${mode}`);
+var openCache = async () => caches.open(`LLS_OFFLINE_${process.env.CONF_ENV}`);
 
 // src/worker/swFetchScreenCall.ts
 var zipSlugName = (str) => str.replace(/[^a-zA-Z0-9-.]/g, "");
@@ -75,15 +75,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 +189,6 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
 };
 var handles = {
   coreFetchBookDrawerScreen,
-  cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
   cocoreFetchPartialPageSiblingsScreen
@@ -230,20 +220,21 @@ 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 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 +242,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
     });
   }
 };
@@ -291,12 +283,10 @@ var ACCEPTED_EXTENSIONS = {
   ".gif": "image/gif",
   ".webm": "video/webm",
   ".m4a": "audio/mp4",
-  ".webp": "image/webp",
-  ".riv": "application/octet-stream",
-  ".pdf": "application/pdf"
+  ".webp": "image/webp"
 };
 var putInCache = async (request, response) => {
-  const cache = await openCache(CONF_ENV);
+  const cache = await openCache();
   await cache.put(request, response);
 };
 var onlineFirst = async (request, event) => {
@@ -310,24 +300,22 @@ 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 ${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 new Response("FAILED fetch", {
+        // @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;
@@ -374,23 +362,16 @@ var initChannel = async (__, { ports }) => {
   );
   offlineWorkerSync = sender;
   offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, setKnownLinks));
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();
-var configure = ({
-  storage,
-  confEnv
-} = {}) => {
+var configure = ({ storage } = {}) => {
   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 });
+  console.info("sw::configure", { STORAGE });
 };
 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()}-${Math.random().toFixed(5)}`;
+        const eventId = `${methodName}:${Date.now()}`;
         dic[eventId] = { resolve, reject };
         offlineWorker.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -83,17 +83,7 @@ var combineHandlers = (...handlers) => {
     console.error("no handlers matched", methodName);
   };
 };
-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;
-};
+var openCache = async () => caches.open(`LLS_OFFLINE_${process.env.CONF_ENV}`);
 
 // src/worker/wwApi.ts
 var STATE = {
@@ -775,9 +765,6 @@ async function decryptData(encryptedData, key2, iv2) {
   return decryptedData;
 }
 var BOOKS = {};
-var zipNameInMedias = (zipName) => {
-  return /^(pages|book)/.test(zipName);
-};
 var readZipEntry = async ({
   bookId,
   entryName,
@@ -787,20 +774,9 @@ var readZipEntry = async ({
     console.trace("no bookId", bookId, "found");
     return null;
   }
-  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);
+  const bookEntry = BOOKS[bookId].get(entryName);
   if (!bookEntry) {
-    console.info("no bookEntry", entryName, "found", overridenName);
+    console.info("no bookEntry", entryName, "found");
     return null;
   }
   if (!bookEntry.decoded) {
@@ -811,6 +787,16 @@ 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();
@@ -850,26 +836,14 @@ var loadZip = async (buf, bookId) => {
     await sleep;
   }
   unzipper.push(buf.slice((nChunks - 1) * chunkSize, buf.byteLength), true);
-  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;
+  BOOKS[bookId] = m;
+  return [...m.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];
@@ -949,7 +923,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       await accessHandle.write(arrayBuffer);
       await accessHandle.close();
     } else {
-      const cache = await openCache(CONF_ENV);
+      const cache = await openCache();
       const response2 = new Response(arrayBuffer, {
         headers: {
           "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
@@ -1050,11 +1024,9 @@ var loadBooks = async ({ primaryOnly = false } = {}) => {
     const opfsRoot = await navigator.storage.getDirectory();
     entries = await opfsRoot.values();
   } else {
-    const cache = await openCache(CONF_ENV);
+    const cache = await openCache();
     const keys = await cache.keys();
-    const zips = keys.filter((key2) => {
-      return key2.url.match(/lecture-cp\.zip|story-.*?\.zip/);
-    });
+    const zips = keys.filter((key2) => key2.url.endsWith(".zip"));
     entries = zips.map((zip) => ({ name: String(zip.url.split("/").pop()) }));
   }
   for await (const entry of entries) {
@@ -1077,13 +1049,11 @@ var loadBooks = async ({ primaryOnly = false } = {}) => {
 var configure = ({
   storage,
   checkUpdates,
-  zipBaseUrl,
-  confEnv
+  zipBaseUrl
 }) => {
   CHECK_UPDATES = true;
   STORAGE = "cache";
   ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
-  CONF_ENV = "development";
   if (typeof storage !== "undefined") {
     STORAGE = storage;
   }
@@ -1093,10 +1063,7 @@ var configure = ({
   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 });
+  console.info("ow::configure", { STORAGE, CHECK_UPDATES, ZIP_BASE_URL });
 };
 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()}-${Math.random().toFixed(5)}`;
+        const eventId = `${methodName}:${Date.now()}`;
         dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -94,9 +94,6 @@ 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");
@@ -128,11 +125,10 @@ var installWorker = async ({
   nativeListZips,
   storage,
   zipBaseUrl,
-  checkUpdates,
-  confEnv
+  checkUpdates
 } = {}) => {
   const fetchWorker = await fetchWorkerPromise;
-  const configureOptions = { storage, zipBaseUrl, checkUpdates, confEnv };
+  const configureOptions = { storage, zipBaseUrl, checkUpdates };
   if (nativeReadFile) {
     const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
     offlineWorker.onmessage = combineHandlers(handler, wwHandler);
@@ -166,8 +162,7 @@ var useOfflineWorker_default = ({
   nativeListZips,
   checkUpdates,
   storage,
-  zipBaseUrl,
-  confEnv
+  zipBaseUrl
 } = {}) => {
   const [ready, setReady] = useState(false);
   useEffect(() => {
@@ -179,15 +174,14 @@ var useOfflineWorker_default = ({
         nativeListZips,
         storage,
         zipBaseUrl,
-        checkUpdates,
-        confEnv
+        checkUpdates
       });
       await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
       fetch(window.location.href.replace(window.location.search, ""));
       setReady(true);
     };
     fn();
-  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates]);
   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-658f61a6",
+  "version": "24.22.0-a4074e64",
   "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-658f61a6"
+    "@lls/vitescripts": "24.22.0-a4074e64"
   },
   "dependencies": {
     "fflate": "0.8.2"