@lls/offline 24.32.0 → 24.33.0-3e3c1cd5

package/lib/assets/offline-worker.js

@@ -247,9 +247,6 @@ async function decryptData(encryptedData, key2, iv2) {
   return decryptedData;
 }
 var BOOKS = {};
-var zipNameInMedias = (zipName) => {
-  return /^(pages|book)/.test(zipName);
-};
 var readZipEntry = async ({
   bookId,
   entryName,
@@ -263,8 +260,8 @@ var readZipEntry = async ({
   let overridenName = entryName;
   if (manifest && !entryName.includes("gqls/")) {
     const zipName = entryName.replace("medias/", "");
-    if (zipNameInMedias(zipName)) {
-      const originalName = manifest.medias[zipName];
+    const originalName = manifest.medias[zipName];
+    if (originalName) {
       overridenName = `medias/${originalName}`;
     } else {
       if (entryName !== "manifest.json") {

package/lib/builttypes/offline/src/hooks/useOfflineWorker.d.ts

@@ -0,0 +1,33 @@
+type UseOfflineProps = {
+    skipLoadBooks?: boolean;
+    primaryOnly?: boolean;
+    nativeReadFile?: (arg: {
+        fname: string;
+    }) => Promise<ArrayBuffer>;
+    nativeWriteFile?: (arg: {
+        fname: string;
+        buffer: ArrayBuffer;
+    }) => Promise<void>;
+    nativeListZips?: () => Promise<Array<{
+        name: string;
+    }>>;
+    checkUpdates?: boolean;
+    storage?: 'opfs' | 'native' | 'cache';
+    zipBaseUrl?: string;
+    confEnv?: 'development' | 'production';
+};
+declare const _default: ({ skipLoadBooks, primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, checkUpdates, storage, zipBaseUrl, confEnv }?: UseOfflineProps) => {
+    ready: boolean;
+    loadBook: ({ forceRefresh, ...idOrUri }: {
+        forceRefresh?: boolean;
+    } & ({
+        id: number;
+    } | {
+        uri: string;
+    }), cbk?: (arg: {
+        bytes: number;
+        total: number;
+    }) => void) => Promise<void>;
+    reset: () => Promise<void>;
+};
+export default _default;

package/lib/builttypes/offline/src/index.d.ts

@@ -0,0 +1,3 @@
+export { default as useOfflineWorker } from '#offline/hooks/useOfflineWorker';
+export * from '#offline/store/index';
+export * from '#offline/store/offlinePersist';

package/lib/builttypes/offline/src/store/index.d.ts

@@ -0,0 +1,3 @@
+import type { AnyFunction } from '@lls/typings/utils';
+import type { Reducer } from 'redux';
+export declare const persistEntitiesReducer: (entitiesReducer: AnyFunction, CONF_ENV: string) => Reducer;

package/lib/builttypes/offline/src/store/offlinePersist.d.ts

@@ -0,0 +1,8 @@
+import { persistStore } from 'redux-persist';
+type Store = Parameters<typeof persistStore>[0];
+import { type ReactNode } from 'react';
+export declare const OfflinePersist: ({ store, children }: {
+    store: Store;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/builttypes/offline/src/utils/error.d.ts

@@ -0,0 +1,2 @@
+import type { AnyFunction } from '@lls/typings/utils';
+export declare const tryCatch: (fn: (...args: any[]) => Promise<unknown>) => (resolve: AnyFunction, reject: AnyFunction) => void | Promise<void>;

package/lib/builttypes/offline/src/utils/stream.d.ts

@@ -0,0 +1,5 @@
+export declare const parseRange: (range: string, size: number) => {
+    start: number;
+    end: number;
+    chunkSize: number;
+};

package/lib/builttypes/offline/src/utils/worker.d.ts

@@ -0,0 +1,29 @@
+import type { AnyFunction } from '@lls/typings/utils';
+type OnMessageEvent = (m: MessageEvent) => void;
+type Handler = {
+    canHandle: (methodName: string) => boolean;
+    handle: OnMessageEvent;
+};
+export declare const makeSyncWorker: <WorkerApi extends {
+    [k: string]: AnyFunction;
+}>(offlineWorker: {
+    postMessage: Worker["postMessage"];
+}, methodNames: string[], dbg?: string) => WorkerApi & {
+    on: (key: string, fn: AnyFunction) => void;
+} & {
+    handler: Handler;
+};
+export declare const makeSyncHandler: (services: {
+    [k: string]: (...args: any[]) => any;
+}) => {
+    canHandle: (methodName: string) => boolean;
+    handle: OnMessageEvent;
+};
+export declare const bufToJson: (buf: ArrayBuffer) => any;
+export declare const jsonToBuf: (json: {}) => Uint8Array<ArrayBuffer>;
+export declare const combineHandlers: (...handlers: Handler[]) => (message: MessageEvent) => void;
+export declare const openCache: (mode: string) => Promise<Cache>;
+export declare const clearCache: (mode: string) => Promise<boolean>;
+export declare const isValidZipName: (name: string) => boolean;
+export declare const isValidS3Zip: (response: Response) => boolean;
+export {};

package/lib/builttypes/offline/src/utils/zipDecoder.d.ts

@@ -0,0 +1,7 @@
+type Record = {
+    sofh: number;
+    name: Uint8Array;
+};
+export declare const readRecordData: (buf: Uint8Array, { sofh }: Record) => Uint8Array<ArrayBuffer>;
+export declare const getHeaders: (buf: Uint8Array) => Record[];
+export {};

package/lib/builttypes/offline/src/worker/fetch-worker.d.ts

@@ -0,0 +1,16 @@
+import { setKnownLinks as handleSetKnownLinks } from '#offline/worker/swFetchScreenCall.ts';
+declare const setKnownLinks: (arg: Parameters<typeof handleSetKnownLinks>[1]) => void;
+export type FetchWorkerSync = {
+    setKnownLinks: typeof setKnownLinks;
+};
+declare const configure: ({ storage, confEnv }?: {
+    storage?: "native" | "opfs" | "cache";
+    confEnv?: "development" | "production";
+}) => void;
+export type FetchWorkerMain = {
+    initChannel: (d: {
+        ports: [MessagePort];
+    }) => void;
+    configure: typeof configure;
+};
+export {};

package/lib/builttypes/offline/src/worker/offline-worker.d.ts

@@ -0,0 +1,67 @@
+import type { EntryId } from './types.js';
+import { searchBooks } from './wwApi.js';
+import { readZipEntry } from './wwZip.js';
+declare const slugToFileMeta: ({ slug }: {
+    slug: string;
+}) => Promise<{
+    pageId: number | undefined;
+    chapterId: number | undefined;
+}>;
+type BookId = number | string;
+declare const loadBook: ({ id: bookId, forceRefresh }: {
+    id: BookId;
+    forceRefresh?: boolean;
+}) => Promise<void>;
+declare const loadPageContent: ({ bookId: iBookId, chapterId, pageId, entryId }: {
+    bookId?: number;
+    chapterId?: number;
+    pageId?: number;
+    entryId?: EntryId;
+}) => Promise<{
+    viewer: {
+        pages: {
+            hits: [{
+                id: number;
+                book: {
+                    slug: string;
+                    urlLite: string;
+                };
+                chapter: {
+                    id: number;
+                };
+            }];
+        };
+    };
+}>;
+declare const ensureAppReady: () => void;
+export type OfflineWorkerSync = {
+    readZipEntry: typeof readZipEntry;
+    loadBook: typeof loadBook;
+    slugToFileMeta: typeof slugToFileMeta;
+    loadPageContent: typeof loadPageContent;
+    searchBooks: typeof searchBooks;
+    ensureAppReady: typeof ensureAppReady;
+};
+declare const loadBooks: ({ primaryOnly }?: {
+    primaryOnly?: boolean | undefined;
+}) => Promise<void>;
+declare const configure: ({ storage, checkUpdates, zipBaseUrl, confEnv }: {
+    storage?: "native" | "opfs" | "cache";
+    checkUpdates?: boolean;
+    zipBaseUrl?: string;
+    confEnv?: "development" | "production";
+}) => void;
+declare const loadPreload: () => Promise<void>;
+declare const reset: () => Promise<void>;
+export type OfflineWorkerSyncMain = {
+    initChannel: (d: {
+        ports: [MessagePort];
+    }) => void;
+    loadPreload: typeof loadPreload;
+    readZipEntry: typeof readZipEntry;
+    loadBooks: typeof loadBooks;
+    loadBook: typeof loadBook;
+    configure: typeof configure;
+    reset: typeof reset;
+};
+export {};

package/lib/builttypes/offline/src/worker/swFetchScreenCall.d.ts

@@ -0,0 +1,14 @@
+import type { OfflineWorkerSync } from './offline-worker';
+import type { EntryId, SwEvent } from './types';
+export declare const canHandleScreenCall: (url: string) => boolean;
+export declare const handleScreenCall: (ev: SwEvent, { offlineWorkerSync, knownLinks }: {
+    offlineWorkerSync: OfflineWorkerSync;
+    knownLinks: Map<string, EntryId>;
+}) => Promise<{
+    status: number;
+    json: any;
+}>;
+export declare const setKnownLinks: (knownLinks: Map<string, EntryId>, { entryNames, bookId }: {
+    entryNames: string[];
+    bookId: number | string;
+}) => void;

package/lib/builttypes/offline/src/worker/wwApi.d.ts

@@ -0,0 +1,58 @@
+type Book = {
+    id: number;
+    chapters: {
+        id: number;
+    }[];
+    uri: string;
+    slug: string;
+    urlLite: string;
+};
+type Page = {
+    id: number;
+    book: {
+        slug: string;
+        urlLite: string;
+    };
+    chapter: {
+        id: number;
+    };
+};
+type GqlBook = {
+    viewer: {
+        books: {
+            hits: [Book];
+        };
+    };
+};
+type GqlPage = {
+    viewer: {
+        pages: {
+            hits: [Page];
+        };
+    };
+};
+export declare const loadBook: (json: GqlBook) => void;
+type SlugFile = {
+    [pageId: string]: `${number};${number}`;
+};
+export declare const slugToFileMeta: ({ slug, json }: {
+    slug: string;
+    json: SlugFile;
+}) => Promise<{
+    pageId: number | undefined;
+    chapterId: number | undefined;
+}>;
+export declare const loadPageContent: ({ chapterId, json }: {
+    chapterId?: number;
+    json: GqlPage;
+}) => Promise<GqlPage>;
+export declare const searchBooks: ({ uris, slugs, ids, chapterIds }: {
+    uris?: string[];
+    slugs?: string[];
+    ids?: number[];
+    chapterIds?: (number | undefined)[];
+}) => Promise<(Omit<Book, "chapters"> & {
+    chapters: number[];
+})[]>;
+export declare const loadPreload: (json: GqlBook) => void;
+export {};

package/lib/builttypes/offline/src/worker/wwZip.d.ts

@@ -0,0 +1,9 @@
+type BookId = number | string;
+export declare const readZipEntry: ({ bookId, entryName, asJson }: {
+    bookId: number | string;
+    entryName: string;
+    asJson?: boolean;
+}) => Promise<any>;
+export declare const hasZip: (bookId: BookId | string) => boolean;
+export declare const loadZip: (buf: Uint8Array, bookId: BookId) => Promise<string[]>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.32.0",
+  "version": "24.33.0-3e3c1cd5",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -41,8 +41,7 @@
     "@testing-library/react": "16.3.0",
     "@types/react": "18.3.12",
     "@types/react-dom": "18.3.1",
-    "@vitejs/plugin-react": "4.5.1",
-    "@vitejs/plugin-react-swc": "3.10.1",
+    "@vitejs/plugin-react": "5.1.1",
     "esbuild": "0.24.0",
     "happy-dom": "15.11.0",
     "lodash": "4.17.21",
@@ -51,10 +50,10 @@
     "react-dom": "18.3.1",
     "redux": "5.0.1",
     "typescript": "5.8.3",
-    "vite": "7.1.11",
+    "vite": "npm:rolldown-vite@7.2.7",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.32.0"
+    "@lls/vitescripts": "24.33.0-3e3c1cd5"
   },
   "dependencies": {
     "redux-persist": "6.0.0"