@lls/offline 24.20.0-debug

package/lib/index.js

@@ -0,0 +1,430 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
+var require_react_production_min = __commonJS({
+  "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js"(exports) {
+    "use strict";
+    var l = Symbol.for("react.element");
+    var n = Symbol.for("react.portal");
+    var p = Symbol.for("react.fragment");
+    var q = Symbol.for("react.strict_mode");
+    var r = Symbol.for("react.profiler");
+    var t = Symbol.for("react.provider");
+    var u = Symbol.for("react.context");
+    var v = Symbol.for("react.forward_ref");
+    var w = Symbol.for("react.suspense");
+    var x = Symbol.for("react.memo");
+    var y = Symbol.for("react.lazy");
+    var z = Symbol.iterator;
+    function A(a2) {
+      if (null === a2 || "object" !== typeof a2) return null;
+      a2 = z && a2[z] || a2["@@iterator"];
+      return "function" === typeof a2 ? a2 : null;
+    }
+    var B = { isMounted: function() {
+      return false;
+    }, enqueueForceUpdate: function() {
+    }, enqueueReplaceState: function() {
+    }, enqueueSetState: function() {
+    } };
+    var C = Object.assign;
+    var D = {};
+    function E(a2, b, e) {
+      this.props = a2;
+      this.context = b;
+      this.refs = D;
+      this.updater = e || B;
+    }
+    E.prototype.isReactComponent = {};
+    E.prototype.setState = function(a2, b) {
+      if ("object" !== typeof a2 && "function" !== typeof a2 && null != a2) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, a2, b, "setState");
+    };
+    E.prototype.forceUpdate = function(a2) {
+      this.updater.enqueueForceUpdate(this, a2, "forceUpdate");
+    };
+    function F() {
+    }
+    F.prototype = E.prototype;
+    function G(a2, b, e) {
+      this.props = a2;
+      this.context = b;
+      this.refs = D;
+      this.updater = e || B;
+    }
+    var H = G.prototype = new F();
+    H.constructor = G;
+    C(H, E.prototype);
+    H.isPureReactComponent = true;
+    var I = Array.isArray;
+    var J = Object.prototype.hasOwnProperty;
+    var K = { current: null };
+    var L = { key: true, ref: true, __self: true, __source: true };
+    function M(a2, b, e) {
+      var d, c = {}, k = null, h = null;
+      if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+      var g = arguments.length - 2;
+      if (1 === g) c.children = e;
+      else if (1 < g) {
+        for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+        c.children = f;
+      }
+      if (a2 && a2.defaultProps) for (d in g = a2.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+      return { $$typeof: l, type: a2, key: k, ref: h, props: c, _owner: K.current };
+    }
+    function N(a2, b) {
+      return { $$typeof: l, type: a2.type, key: b, ref: a2.ref, props: a2.props, _owner: a2._owner };
+    }
+    function O(a2) {
+      return "object" === typeof a2 && null !== a2 && a2.$$typeof === l;
+    }
+    function escape(a2) {
+      var b = { "=": "=0", ":": "=2" };
+      return "$" + a2.replace(/[=:]/g, function(a3) {
+        return b[a3];
+      });
+    }
+    var P = /\/+/g;
+    function Q(a2, b) {
+      return "object" === typeof a2 && null !== a2 && null != a2.key ? escape("" + a2.key) : b.toString(36);
+    }
+    function R(a2, b, e, d, c) {
+      var k = typeof a2;
+      if ("undefined" === k || "boolean" === k) a2 = null;
+      var h = false;
+      if (null === a2) h = true;
+      else switch (k) {
+        case "string":
+        case "number":
+          h = true;
+          break;
+        case "object":
+          switch (a2.$$typeof) {
+            case l:
+            case n:
+              h = true;
+          }
+      }
+      if (h) return h = a2, c = c(h), a2 = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a2 && (e = a2.replace(P, "$&/") + "/"), R(c, b, e, "", function(a3) {
+        return a3;
+      })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a2)), b.push(c)), 1;
+      h = 0;
+      d = "" === d ? "." : d + ":";
+      if (I(a2)) for (var g = 0; g < a2.length; g++) {
+        k = a2[g];
+        var f = d + Q(k, g);
+        h += R(k, b, e, f, c);
+      }
+      else if (f = A(a2), "function" === typeof f) for (a2 = f.call(a2), g = 0; !(k = a2.next()).done; ) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
+      else if ("object" === k) throw b = String(a2), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+      return h;
+    }
+    function S(a2, b, e) {
+      if (null == a2) return a2;
+      var d = [], c = 0;
+      R(a2, d, "", "", function(a3) {
+        return b.call(e, a3, c++);
+      });
+      return d;
+    }
+    function T(a2) {
+      if (-1 === a2._status) {
+        var b = a2._result;
+        b = b();
+        b.then(function(b2) {
+          if (0 === a2._status || -1 === a2._status) a2._status = 1, a2._result = b2;
+        }, function(b2) {
+          if (0 === a2._status || -1 === a2._status) a2._status = 2, a2._result = b2;
+        });
+        -1 === a2._status && (a2._status = 0, a2._result = b);
+      }
+      if (1 === a2._status) return a2._result.default;
+      throw a2._result;
+    }
+    var U = { current: null };
+    var V = { transition: null };
+    var W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
+    function X() {
+      throw Error("act(...) is not supported in production builds of React.");
+    }
+    exports.Children = { map: S, forEach: function(a2, b, e) {
+      S(a2, function() {
+        b.apply(this, arguments);
+      }, e);
+    }, count: function(a2) {
+      var b = 0;
+      S(a2, function() {
+        b++;
+      });
+      return b;
+    }, toArray: function(a2) {
+      return S(a2, function(a3) {
+        return a3;
+      }) || [];
+    }, only: function(a2) {
+      if (!O(a2)) throw Error("React.Children.only expected to receive a single React element child.");
+      return a2;
+    } };
+    exports.Component = E;
+    exports.Fragment = p;
+    exports.Profiler = r;
+    exports.PureComponent = G;
+    exports.StrictMode = q;
+    exports.Suspense = w;
+    exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+    exports.act = X;
+    exports.cloneElement = function(a2, b, e) {
+      if (null === a2 || void 0 === a2) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + ".");
+      var d = C({}, a2.props), c = a2.key, k = a2.ref, h = a2._owner;
+      if (null != b) {
+        void 0 !== b.ref && (k = b.ref, h = K.current);
+        void 0 !== b.key && (c = "" + b.key);
+        if (a2.type && a2.type.defaultProps) var g = a2.type.defaultProps;
+        for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+      }
+      var f = arguments.length - 2;
+      if (1 === f) d.children = e;
+      else if (1 < f) {
+        g = Array(f);
+        for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+        d.children = g;
+      }
+      return { $$typeof: l, type: a2.type, key: c, ref: k, props: d, _owner: h };
+    };
+    exports.createContext = function(a2) {
+      a2 = { $$typeof: u, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
+      a2.Provider = { $$typeof: t, _context: a2 };
+      return a2.Consumer = a2;
+    };
+    exports.createElement = M;
+    exports.createFactory = function(a2) {
+      var b = M.bind(null, a2);
+      b.type = a2;
+      return b;
+    };
+    exports.createRef = function() {
+      return { current: null };
+    };
+    exports.forwardRef = function(a2) {
+      return { $$typeof: v, render: a2 };
+    };
+    exports.isValidElement = O;
+    exports.lazy = function(a2) {
+      return { $$typeof: y, _payload: { _status: -1, _result: a2 }, _init: T };
+    };
+    exports.memo = function(a2, b) {
+      return { $$typeof: x, type: a2, compare: void 0 === b ? null : b };
+    };
+    exports.startTransition = function(a2) {
+      var b = V.transition;
+      V.transition = {};
+      try {
+        a2();
+      } finally {
+        V.transition = b;
+      }
+    };
+    exports.unstable_act = X;
+    exports.useCallback = function(a2, b) {
+      return U.current.useCallback(a2, b);
+    };
+    exports.useContext = function(a2) {
+      return U.current.useContext(a2);
+    };
+    exports.useDebugValue = function() {
+    };
+    exports.useDeferredValue = function(a2) {
+      return U.current.useDeferredValue(a2);
+    };
+    exports.useEffect = function(a2, b) {
+      return U.current.useEffect(a2, b);
+    };
+    exports.useId = function() {
+      return U.current.useId();
+    };
+    exports.useImperativeHandle = function(a2, b, e) {
+      return U.current.useImperativeHandle(a2, b, e);
+    };
+    exports.useInsertionEffect = function(a2, b) {
+      return U.current.useInsertionEffect(a2, b);
+    };
+    exports.useLayoutEffect = function(a2, b) {
+      return U.current.useLayoutEffect(a2, b);
+    };
+    exports.useMemo = function(a2, b) {
+      return U.current.useMemo(a2, b);
+    };
+    exports.useReducer = function(a2, b, e) {
+      return U.current.useReducer(a2, b, e);
+    };
+    exports.useRef = function(a2) {
+      return U.current.useRef(a2);
+    };
+    exports.useState = function(a2) {
+      return U.current.useState(a2);
+    };
+    exports.useSyncExternalStore = function(a2, b, e) {
+      return U.current.useSyncExternalStore(a2, b, e);
+    };
+    exports.useTransition = function() {
+      return U.current.useTransition();
+    };
+    exports.version = "18.3.1";
+  }
+});
+
+// ../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js
+var require_react = __commonJS({
+  "../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js"(exports, module) {
+    "use strict";
+    if (true) {
+      module.exports = require_react_production_min();
+    } else {
+      module.exports = null;
+    }
+  }
+});
+
+// src/utils/worker.ts
+var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
+  const dic = {};
+  const cbks = {};
+  const fn2 = ({ 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);
+  };
+  offlineWorker.onmessage = fn2;
+  const makeFn = (methodName) => {
+    return ({ ports, ...arg } = {}) => {
+      return new Promise((resolve, reject) => {
+        const eventId = `${methodName}:${Date.now()}`;
+        dic[eventId] = { resolve, reject };
+        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+      });
+    };
+  };
+  const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
+    on: (key, fn3) => {
+      cbks[key] = fn3;
+    }
+  });
+  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 });
+    }
+  }
+);
+
+// src/hooks/useOfflineWorker.ts
+var import_react = __toESM(require_react(), 1);
+var offlineWorkerSync = makeSyncWorker(
+  // @ts-ignore: TODO
+  new Worker("/src/worker/offlineWorker.js", { type: "module" }),
+  ["initChannel", "readZipEntry", "loadPreload", "loadBooks"],
+  "app:offlineWorker"
+);
+var setWorkersReady;
+var workersReadyPromise = new Promise((resolve) => {
+  setWorkersReady = resolve;
+});
+var setBooksLoaded;
+var setBooksLoadedPromise = new Promise((resolve) => {
+  setBooksLoaded = resolve;
+});
+var fn = async () => {
+  let fetchWorker = null;
+  await navigator.serviceWorker.getRegistrations().then(async (registrations) => {
+    for (const registration of registrations) {
+      await registration.unregister();
+    }
+  });
+  await navigator.serviceWorker.register("/fetch.worker.js", { type: "module" }).then((reg) => reg.update());
+  await navigator.serviceWorker.ready.then(async (reg) => {
+    console.debug("Service Worker registered:", reg.scope);
+    fetchWorker = reg.active;
+  }).catch((err) => console.error("Service Worker registration failed:", err));
+  if (!fetchWorker) {
+    return;
+  }
+  offlineWorkerSync.on("ready", setWorkersReady);
+  const channel = new MessageChannel();
+  offlineWorkerSync.initChannel({ ports: [channel.port1] });
+  fetchWorker.postMessage({ methodName: "initChannel" }, [channel.port2]);
+  await offlineWorkerSync.loadPreload();
+  await offlineWorkerSync.loadBooks();
+  setBooksLoaded();
+};
+fn();
+var useOfflineWorker_default = () => {
+  const [ready, setReady] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    const fn2 = async () => {
+      await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
+      setReady(true);
+    };
+    fn2();
+  }, []);
+  return ready;
+};
+export {
+  useOfflineWorker_default as useOfflineWorker
+};
+/*! Bundled license information:
+
+react/cjs/react.production.min.js:
+  (**
+   * @license React
+   * react.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@lls/offline",
+  "version": "24.20.0-debug",
+  "description": "offline",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./lib/builttypes/offline/src/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "package.json",
+    "README.md"
+  ],
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lelivrescolaire/monorepo.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/lelivrescolaire/monorepo/issues"
+  },
+  "homepage": "https://github.com/lelivrescolaire/monorepo#readme",
+  "peerDependencies": {
+    "axios": "*",
+    "dayjs": "*",
+    "lodash": "*",
+    "react": "*",
+    "react-dom": "*",
+    "zod": "*"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.9.4",
+    "@happy-dom/global-registrator": "15.11.0",
+    "@testing-library/react": "16.3.0",
+    "@types/react": "18.3.12",
+    "@types/react-dom": "18.3.1",
+    "@vitejs/plugin-react": "4.5.1",
+    "esbuild": "0.24.0",
+    "happy-dom": "15.11.0",
+    "lodash": "4.17.21",
+    "nock": "14.0.5",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "typescript": "5.8.3",
+    "vite": "7.0.0",
+    "zod": "3.25.50",
+    "@lls/vitescripts": "24.20.0"
+  },
+  "dependencies": {
+    "fflate": "0.8.2"
+  },
+  "scripts": {
+    "start": "echo no devserver",
+    "dts": "pnpm tsc --project tsconfig.production.json",
+    "build": "node build",
+    "test": "bun test --bail",
+    "lint": "pnpm biome check --apply src __tests__"
+  }
+}