@lls/offline 24.20.0-debug

package/README.md

@@ -0,0 +1,5 @@
+# offline
+
+handles offline as webworker for android/ios and desktop
+
+Likely used by core, cocore

package/lib/assets/fetch.worker.js

@@ -0,0 +1,323 @@
+// src/utils/worker.ts
+var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
+  const dic = {};
+  const cbks = {};
+  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+    if (eventId && eventId in dic) {
+      if (error) {
+        dic[eventId].reject(error);
+      } else {
+        dic[eventId].resolve(results);
+      }
+    } else {
+      if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
+        console.error(`syncWorker: ${dbg}`, eventId, methodName, error);
+      }
+    }
+    methodName && cbks[methodName]?.(arg);
+  };
+  offlineWorker2.onmessage = fn;
+  const makeFn = (methodName) => {
+    return ({ ports, ...arg } = {}) => {
+      return new Promise((resolve, reject) => {
+        const eventId = `${methodName}:${Date.now()}`;
+        dic[eventId] = { resolve, reject };
+        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
+      });
+    };
+  };
+  const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
+    on: (key, fn2) => {
+      cbks[key] = fn2;
+    }
+  });
+  return obj;
+};
+var a = (a2) => a2;
+var makeSyncHandler = a(
+  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+    try {
+      if (typeof methodName === "string" && methodName in services && services[methodName]) {
+        const results = await services[methodName](arg, { ports });
+        sender.postMessage({ eventId, methodName, results });
+        return;
+      }
+      throw new Error(`invalid methodName ${String(methodName)}`);
+    } catch (e) {
+      console.debug("failed", e);
+      sender.postMessage({ eventId, methodName, error: e });
+    }
+  }
+);
+var jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
+
+// src/worker/swFetchScreenCall.ts
+var coreFetchBookDrawerScreen = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables }) => {
+  const slug = variables.slugs?.[0];
+  const uris = variables.uris;
+  const bookIds = variables.bookIds;
+  console.debug("beforestuff", slug, uris, bookIds);
+  if (!slug && !uris?.length && !bookIds?.length) {
+    console.debug("empty payload", slug, uris?.length, bookIds?.length);
+    return {};
+  }
+  const preloadBook = await offlineWorkerSync2.searchBooks({
+    slugs: slug ? [slug] : void 0,
+    uris,
+    ids: bookIds
+  }).then((books) => books?.[0]);
+  if (!preloadBook) {
+    console.info("fetchBookEffect::no book found", { slug, uris, bookIds });
+    return {};
+  }
+  console.debug("backbook???", preloadBook);
+  const back = {
+    data: {
+      viewer: {
+        books: {
+          hits: [preloadBook]
+        }
+      }
+    }
+  };
+  console.debug("MAXIME/////", back);
+  return back;
+};
+var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, variables }) => {
+  const slug = variables.slugs?.[0];
+  let pageId = -1;
+  let chapterId = -1;
+  let bookId;
+  let bookSlug;
+  try {
+    if (!slug) {
+      throw new Error("invalid slug");
+    }
+    console.debug("slug");
+    const { pageId: aPageId, chapterId: aChapterId } = await offlineWorkerSync2.slugToFileMeta({ slug });
+    console.debug("searchBooks");
+    const book = await offlineWorkerSync2.searchBooks({ chapterIds: [aChapterId] }).then((books) => books?.[0]);
+    pageId = aPageId;
+    chapterId = aChapterId;
+    bookId = book?.id;
+    bookSlug = book?.slug;
+    if (!bookId) {
+      throw new Error(`book not found for slug:${slug}`);
+    }
+    console.debug("loadPageContent");
+    const pageResponse = await offlineWorkerSync2.loadPageContent({ bookId, chapterId, pageId });
+    if (Object.keys(pageResponse).length === 0) {
+      throw new Error("no offline page");
+    }
+    const rawPage = pageResponse?.viewer?.pages?.hits?.[0];
+    console.debug("before???", rawPage);
+    const page = {
+      ...rawPage,
+      book: {
+        ...rawPage.book,
+        slug: book?.slug,
+        urlLite: book?.urlLite
+      }
+    };
+    const backPage = page;
+    const backData = {
+      data: {
+        viewer: {
+          pages: {
+            hits: [backPage]
+          }
+        }
+      }
+    };
+    console.debug("back", backData);
+    return backData;
+  } catch (e) {
+    console.info("no offline page", e, JSON.stringify({ bookId, chapterId, pageId, e }).substring(0, 150));
+    try {
+      if (!slug) {
+        throw new Error("invalid slug");
+      }
+      return ev;
+    } catch (e2) {
+      console.info("failed offline and online", e2);
+      const backPage = {
+        book: {
+          id: bookId,
+          slug: bookSlug
+        },
+        slug,
+        id: pageId
+      };
+      const backData = {
+        data: {
+          viewer: {
+            pages: {
+              hits: [backPage]
+            }
+          }
+        }
+      };
+      return backData;
+    }
+  }
+};
+var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2 }) => {
+  try {
+    const variables = (
+      // @ts-ignore 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 handles = {
+      coreFetchBookDrawerScreen,
+      coreFetchPagesApi
+    };
+    const key = ev.request.url.match(Object.keys(handles).join("|"))?.[0];
+    if (!key) {
+      throw new Error("unknown ev");
+    }
+    const json = await handles[key](ev, { offlineWorkerSync: offlineWorkerSync2, variables });
+    return { status: 200, json };
+  } catch (e) {
+    console.error(e);
+    return { status: 500, json: JSON.stringify(e) };
+  }
+};
+
+// src/worker/fetch.worker.ts
+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-Type": mimeType
+      },
+      // @ts-ignore: poor ts typing
+      ok: true,
+      redirected: false,
+      status: 200,
+      type: "cors",
+      url
+    });
+  } catch (e) {
+    console.error("FAILED fetchAsset", e);
+    return new Response("FAILED fetchAsset", {
+      // @ts-ignore: poor ts typing
+      ok: false,
+      status: 500,
+      type: "cors",
+      url: ev.request.url
+    });
+  }
+};
+var fetchScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2 }) => {
+  try {
+    const { status, json } = await handleScreenCall(ev, { offlineWorkerSync: offlineWorkerSync2 });
+    return new Response(jsonToBuf(json), {
+      headers: {
+        "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
+        "Content-Type": "application/json"
+      },
+      // @ts-ignore: poor ts typing
+      ok: true,
+      redirected: false,
+      status,
+      type: "cors",
+      url: ev.request.url
+    });
+  } catch (e) {
+    console.error("FAILED screenCall", e);
+    return new Response("FAILED screenCall", {
+      // @ts-ignore: poor ts typing
+      ok: false,
+      status: 500,
+      type: "cors",
+      url: ev.request.url
+    });
+  }
+};
+var ACCEPTED_EXTENSIONS = {
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".mp4": "video/mpeg",
+  ".mp3": "audio/mpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webm": "video/webm",
+  ".m4a": "audio/mp4",
+  ".webp": "image/webp"
+};
+var swSelf = self;
+swSelf.addEventListener("fetch", (ev) => {
+  const url = ev.request.url;
+  const extension = url.match(/\.[^.]+$/)?.[0];
+  const mimeType = extension && extension in ACCEPTED_EXTENSIONS ? ACCEPTED_EXTENSIONS[extension] : "";
+  const screenCall = /coreFetchPagesApi|coreFetchBookDrawerScreen/.test(url);
+  if (!mimeType && !screenCall) {
+    if (!/\.(css|tsx?|jsx?|woff2|fr)/.test(url)) {
+      console.debug("no ext", url.match(/\.[^.]+$/)?.[0]);
+    }
+    return;
+  }
+  const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, ""));
+  if (!entryId && !screenCall) {
+    if (/lls|lelivrescolaire/.test(url)) {
+      console.info("no link for", url.replace(/https:\/\/.*?\//, ""));
+    }
+    return;
+  }
+  if (screenCall) {
+    console.debug("screencall!");
+    return ev.respondWith(fetchScreenCall(ev, { offlineWorkerSync }));
+  }
+  return ev.respondWith(fetchAsset(ev, { entryId, mimeType, offlineWorkerSync }));
+});
+swSelf.addEventListener("install", (_event) => {
+  swSelf.skipWaiting();
+});
+swSelf.addEventListener("activate", (_event) => {
+  return swSelf.clients.claim();
+});
+var offlineWorker;
+var offlineWorkerSync;
+var initChannel = async (__, { ports }) => {
+  console.info(`FETCH WORKER innitChannel v${13}`);
+  offlineWorker = ports[0];
+  offlineWorkerSync = makeSyncWorker(
+    offlineWorker,
+    ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks"],
+    "fetchworker"
+  );
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks);
+  offlineWorker.postMessage({ methodName: "sendAppReady" });
+};
+var knownLinks = /* @__PURE__ */ new Map();
+var setKnownLinks = ({ entryNames, bookId }) => {
+  entryNames.forEach((entryName) => {
+    const link = entryName.replace(/^\d+\/media\//, "");
+    knownLinks.set(link, { entryName, bookId });
+  });
+};
+swSelf.onmessage = async ({
+  data: { methodName, arg } = {},
+  ports
+}) => {
+  const services = {
+    initChannel
+  };
+  try {
+    if (methodName === "initChannel") {
+      if (!ports.length) {
+        throw new Error("fetchworker::missing port!");
+      }
+      await services[methodName](arg, { ports });
+      return;
+    }
+    throw new Error(`fetchworker:invalid methodName ${methodName}`);
+  } catch (e) {
+    console.error("failed", e);
+  }
+};