@lls/offline 24.27.0-ff4d6c28 → 24.28.0-0854ed80

package/lib/assets/fetch-worker.js

@@ -1,8 +1,26 @@
+// 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) => {
+var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
   const dic = {};
   const cbks = {};
-  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+  const fn = ({ source, data: { eventId, methodName, results, error, arg } = {} }) => {
     if (eventId && eventId in dic) {
       if (error) {
         dic[eventId].reject(error);
@@ -10,22 +28,38 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
         dic[eventId].resolve(results);
       }
     } else {
-      if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
+      if (methodName && !(methodName in cbks)) {
         console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
       }
     }
-    methodName && cbks[methodName]?.(arg);
+    methodName && cbks[methodName]?.({ source, ...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 };
-        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          console.warn("slow request for", methodName, arg, eventId);
+        }, 3e3);
+        const doResolve = (arg2) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            resolve(arg2);
+          }
+        };
+        dic[eventId] = { resolve: doResolve, reject };
+        if (ports) {
+          offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+        } else {
+          offlineWorker.postMessage({ eventId, methodName, arg });
+        }
       });
     };
   };
-  const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
+  const fns = Object.fromEntries(methodNames.map((name) => [name, makeFn(name)]));
+  const obj = Object.assign(fns, {
     on: (key, fn2) => {
       cbks[key] = fn2;
     }
@@ -42,26 +76,38 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => ({
+  (services) => ({
     canHandle: (methodName) => {
       return methodName in services;
     },
-    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+    handle: async ({ data: { eventId, methodName, arg } = {}, source, ports, target }) => {
+      const emitter = source?.postMessage && source || target?.postMessage && target || self;
       try {
         if (typeof methodName === "string" && methodName in services && services[methodName]) {
           const results = await services[methodName](arg, { ports });
-          sender.postMessage({ eventId, methodName, results });
+          emitter.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 });
+        emitter.postMessage({ eventId, methodName, error: e });
       }
     }
   })
 );
 var jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
+var combineHandlers = (...handlers) => {
+  return (message) => {
+    const methodName = String("methodName" in message.data ? message.data.methodName : "");
+    for (const h of handlers) {
+      if (h.canHandle(methodName)) {
+        return h.handle(message);
+      }
+    }
+    console.error("no handlers matched", methodName);
+  };
+};
 var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
 var isStoryZip = (name) => /story-.*?\.zip/.test(name);
 var isValidZipName = (name) => {
@@ -77,7 +123,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,22 +248,90 @@ 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 cocoreCreateLexicalFlower = async (_ev, { variables }) => {
+  const flower = variables.flower;
+  if (!flower) {
+    throw new Error("invalid flower");
+  }
+  const back = {
+    viewer: {
+      createLexicalFlower: {
+        ...flower,
+        id: Date.now(),
+        user: null,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  };
+  return {
+    data: back
+  };
+};
+var cocoreUpdateLexicalFlower = async (_ev, { variables }) => {
+  const flower = variables.flower;
+  if (!flower) {
+    throw new Error("invalid flower");
+  }
+  const back = {
+    viewer: {
+      updateLexicalFlower: {
+        ...flower,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  };
+  return {
+    data: back
+  };
+};
+var cocoreDeleteLexicalFlower = async (_ev, { variables }) => {
+  const flower = variables.flower;
+  if (!flower) {
+    throw new Error("invalid flower");
+  }
+  const back = {
+    viewer: {
+      deleteLexicalFlower: flower
+    }
+  };
+  return {
+    data: back
+  };
+};
 var handles = {
   coreFetchBookDrawerScreen,
   cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
-  cocoreFetchPartialPageSiblingsScreen
+  cocoreFetchPartialPageSiblingsScreen,
+  cocoreFetchPrimaryMethod,
+  cocoreCreateLexicalFlower,
+  cocoreUpdateLexicalFlower,
+  cocoreDeleteLexicalFlower
 };
 var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).test(url);
 var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
   try {
-    const variables = (
-      // @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);
+    let variables;
+    const searchParamsVariables = new URLSearchParams(new URL(ev.request.url).search).get("variables");
+    if (searchParamsVariables) {
+      variables = JSON.parse(searchParamsVariables);
+    } else {
+      const body = await new Response(ev.request.body).json();
+      variables = body.variables;
+    }
     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 +352,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 (!hasStreamingExtension(ev.request.url)) {
+        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) {
@@ -301,27 +437,35 @@ var ACCEPTED_EXTENSIONS = {
   ".riv": "application/octet-stream",
   ".pdf": "application/pdf"
 };
+var hasStreamingExtension = (str) => /\.(mp3|mp4|webm|m4a)$/.test(str);
 var putInCache = async (request, response) => {
   const cache = await openCache(CONF_ENV);
   await cache.put(request, response);
 };
+var tryOnline = async (request, event) => {
+  const responseFromNetwork = await fetch(request);
+  if (isValidZipName(request.url) && !isValidS3Zip(responseFromNetwork)) {
+    throw new Error(`zip is invalid: got ${responseFromNetwork.headers.get("Content-Length")} bytes`);
+  }
+  const cached = request.method === "GET" || request.method === "OPTIONS" ? putInCache(request, responseFromNetwork.clone()) : Promise.resolve();
+  if (request.url.endsWith(".zip")) {
+    await cached;
+    event.waitUntil(Promise.resolve());
+  } else {
+    event.waitUntil(cached);
+  }
+  return responseFromNetwork;
+};
+var tryOffline = async (request, _event) => {
+  const over = /\/\?story=basic/.test(request.url) ? request.url.replace(/\/\?story=.*$/, "") : request;
+  const responseFromCache = await caches.match(over);
+  return responseFromCache;
+};
 var onlineFirst = async (request, event) => {
   try {
-    const responseFromNetwork = await fetch(request);
-    if (isValidZipName(request.url) && !isValidS3Zip(responseFromNetwork)) {
-      throw new Error(`zip is invalid: got ${responseFromNetwork.headers.get("Content-Length")} bytes`);
-    }
-    const cached = request.method === "HEAD" ? Promise.resolve() : putInCache(request, responseFromNetwork.clone());
-    if (request.url.endsWith(".zip")) {
-      await cached;
-      event.waitUntil(Promise.resolve());
-    } else {
-      event.waitUntil(cached);
-    }
-    return responseFromNetwork;
+    return await tryOnline(request, event);
   } catch (e) {
-    const over = /\/\?story=basic/.test(request.url) ? request.url.replace(/\/\?story=.*$/, "") : request;
-    const responseFromCache = await caches.match(over);
+    const responseFromCache = await tryOffline(request, event);
     if (!responseFromCache) {
       return new Response(
         `FAILED fetch ${e && typeof e === "object" && "message" in e ? e.message : e?.toString?.()}`,
@@ -343,18 +487,23 @@ swSelf.addEventListener("fetch", (ev) => {
   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")) {
+  if (url.endsWith(".zip")) {
+    if (STORAGE === "cache") {
+      return ev.respondWith(onlineFirst(ev.request, ev));
+    }
     return;
   }
   if (!mimeType && !isValidScreenCall) {
-    if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
+    if (!/\.(css|tsx?|[mj]sx?|woff2|wasm|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 +512,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) => {
@@ -371,20 +521,23 @@ swSelf.addEventListener("install", (_event) => {
 swSelf.addEventListener("activate", (event) => {
   event.waitUntil(swSelf.clients.claim());
 });
-var offlineWorker;
+var setKnownLinks2 = (arg) => setKnownLinks(knownLinks, arg);
 var offlineWorkerSync;
 var initChannel = async (__, { ports }) => {
   console.info(`FETCH WORKER innitChannel v${/* @__PURE__ */ new Date()}`);
-  offlineWorker = ports[0];
-  const { handler, ...sender } = makeSyncWorker(
+  const offlineWorker = ports[0];
+  const { handler: syncHandler, ...sender } = makeSyncWorker(
     offlineWorker,
-    ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks"],
+    ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks", "ensureAppReady"],
     "fetchworker"
   );
+  const onHandler = makeSyncHandler({ setKnownLinks: setKnownLinks2 });
   offlineWorkerSync = sender;
-  offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
-  offlineWorker.postMessage({ methodName: "sendAppReady" });
+  offlineWorker.onmessage = combineHandlers(syncHandler, onHandler);
+  offlineWorker.onclose = () => {
+    console.error("socket to ow has been closed!");
+  };
+  await offlineWorkerSync.ensureAppReady();
 };
 var knownLinks = /* @__PURE__ */ new Map();
 var configure = ({
@@ -401,28 +554,4 @@ var configure = ({
   }
   console.info("sw::configure", { STORAGE, CONF_ENV });
 };
-swSelf.onmessage = async ({
-  data: { methodName, arg } = {},
-  ports
-}) => {
-  const services = {
-    initChannel,
-    configure
-  };
-  try {
-    if (methodName === "configure") {
-      await services[methodName](arg);
-      return;
-    }
-    if (methodName === "initChannel") {
-      if (!ports.length) {
-        throw new Error("fetchworker::missing port!");
-      }
-      await services[methodName](arg, { ports });
-      return;
-    }
-    throw new Error(`fetchworker:invalid methodName ${Object.keys(services)} ${methodName}`);
-  } catch (e) {
-    console.error("failed", methodName, arg, e);
-  }
-};
+swSelf.onmessage = combineHandlers(makeSyncHandler({ initChannel, configure }));