@the_library/public 1.0.0

package/dist/models/index.d.ts

@@ -0,0 +1,244 @@
+export { BOOK_PROP_IDS, Book, BookExtendedCols, BookInput, BookInstance, BookProvCols, BookSlimCols, ModelClass, ModelTypes, NewBookWithId, NewPersonWithId, NewTagWithId, PERSON_PROP_IDS, Person, PersonExtendedCols, PersonInput, PersonProvCols, PersonSlimCols, TAG_PROP_IDS, Tag, TagExtendedCols, TagInput, TagProvCols, TagSlimCols, serializeBookExtended, serializeBookProv, serializeBookSlim, serializePersonExtended, serializePersonProv, serializePersonSlim, serializeTagExtended, serializeTagProv, serializeTagSlim } from './models.js';
+import { V as VersionsFile, c as VersionLayout, u as uid, O as Orm, Q as QueueItem, d as IThread, E as EvmPayload, A as AnyPatch, F as FileRecord, B as BookData } from '../orm-BvkX0aBT.js';
+export { e as ActionTypes, a8 as AddInstanceObj, i as BaseLocalOp, a0 as BasePatch, C as CommonOrmJson, a7 as CreateRecordObj, D as DownloadState, ad as DownloadsByType, a4 as EditInstanceFieldNumberObj, a3 as EditInstanceFieldStringObj, a2 as EditPropertyNumberObj, a1 as EditPropertyStringObj, a5 as EditRelationObj, aa as EnumLayout, af as FavoritesByTypes, G as GetRecordPayload, q as InitPayload, I as InstanceData, h as LANG_AGNOSTIC, $ as LANG_ID_DECODE, _ as LANG_ID_ENCODE, L as Lang, s as LoadLanguagePayload, o as LocalOp, M as ModelDefinition, k as PartOp, N as PatchAction, K as PatchOperation, ac as PopulateStatsStore, ab as PropLayout, P as PropertyType, j as RateOp, l as RatePartOp, f as Rating, R as RecordIdentityCluster, J as Registry, r as SavePatchesPayload, x as SchemaInstanceField, w as SchemaProp, H as SchemaRegistry, y as SchemaRelation, b as SerializedCommonOrmJson, a6 as SetAliasObj, m as ShareOp, n as SharePartOp, S as SidecarType, a as SidecarUrls, v as StatSummary, ag as Stats, a9 as VersionEntry, ae as VisitsByType, W as WorkerCommands, g as WorkerEvent, t as WorkerPayload, Z as evmToPatch, p as isEvmPatch, T as packPatch, Y as patchToEvm, z as relationColName, X as resolveLayout, U as unpackPatch } from '../orm-BvkX0aBT.js';
+export { L as LevelState, g as getLevel, s as subscribeLevel } from '../level-state-J3pj64Tr.js';
+import '@the_library/db_schemas/enums';
+import '@the_library/standard-adapters/isni';
+import '@the_library/standard-adapters/orcid';
+import '@the_library/standard-adapters/lcc';
+import '@the_library/standard-adapters/ddc';
+import '@the_library/standard-adapters/udc';
+import '@the_library/standard-adapters/clc';
+import '@the_library/standard-adapters/bbk';
+import '@the_library/standard-adapters/tlc';
+import '@the_library/standard-adapters/cc';
+import '@the_library/standard-adapters/isbn';
+
+/** The compiled layout dictionary shipped with @the_library/db_schemas. */
+declare const versionsFile: VersionsFile;
+/** Schema version this build serializes with (EvmPayload.version). */
+declare const CURRENT_VERSION: number;
+/** Fully-merged layout for CURRENT_VERSION (memoized). */
+declare const currentLayout: () => VersionLayout;
+
+interface ReactivitySystem {
+    track: (obj: any) => void;
+    trigger: (obj: any) => void;
+}
+/**
+ * Registers a reactivity system, returning an unregister function. Use this to
+ * **compose** systems (multiple frameworks live at once). Idempotent for the
+ * same object.
+ */
+declare function addReactivitySystem(sys: ReactivitySystem): () => void;
+/**
+ * Replaces *all* registered systems with `sys` (or clears them with `null`).
+ * Single-framework convenience / test reset. For coexisting frameworks use
+ * `addReactivitySystem`.
+ */
+declare function setReactivitySystem(sys: ReactivitySystem | null): void;
+declare const dbReactivity: {
+    track(obj: any): void;
+    trigger(obj: any): void;
+};
+declare class LruCache<K, V> {
+    limit: number;
+    private map;
+    private _pinned;
+    private _warnedOverflow;
+    constructor(limit: number);
+    get size(): number;
+    get(key: K): V | undefined;
+    set(key: K, val: V): void;
+    pin(key: K): void;
+    unpin(key: K): void;
+    has(key: K): boolean;
+    delete(key: K): void;
+    clear(): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+}
+/** Set the per-objectType LRU limit (call before loading; 2 000 on mobile). */
+declare const configureDb: (opts: {
+    cacheLimit?: number;
+}) => void;
+declare const clear: () => void;
+declare const dump: () => Map<number, LruCache<string, any>>;
+declare function getRecordKey(wireId: number, creatorUsername?: string): string;
+declare const hasRecord: (objectType: number, id: uid, creatorUsername?: string) => boolean;
+/** Synchronous read. Throws on LRU miss — use the model's LoadAsync for re-hydration. */
+declare const getRecord: (objectType: number, id: uid, creatorUsername?: string) => any;
+declare const addRecord: (objectType: number, obj: {
+    id: uid;
+}, creatorUsername?: string) => void;
+declare const removeRecord: (objectType: number, id: uid, creatorUsername?: string) => void;
+declare const pinRecord: (objectType: number, id: uid, creatorUsername?: string) => void;
+declare const unpinRecord: (objectType: number, id: uid, creatorUsername?: string) => void;
+
+declare const inceptionDate: number;
+declare const DateUtils: {
+    now: () => number;
+    serialize: (d: number) => ArrayBuffer;
+    toNumber: (d: Date) => number;
+    fromNumber: (i: number) => Date;
+    findNowBucket: () => number;
+    findDateBucket: (d: Date) => number;
+};
+
+/**
+ * Checks if an Orm element is considered safe and not deleted.
+ *
+ * @param element - The Orm element to check.
+ * @returns A boolean indicating whether the element is safe and not deleted.
+ */
+declare const DSafeCheck: (element: Orm) => boolean;
+
+declare const delay: (ms: number) => Promise<unknown>;
+type ProResolver<A> = {
+    pro: Promise<A>;
+    resolve: (data: any) => void;
+    reject: (data: any) => void;
+    start: () => void;
+    isStarted: () => boolean;
+};
+declare const proResolver: <A>() => ProResolver<A>;
+
+/**
+ * Creates a debounced function that delays invoking the provided function
+ * until wait milliseconds have elapsed since the last time this debounced
+ * function was invoked. Each invocation returns a promise that resolves
+ * with the result of the ultimate single execution.
+ */
+declare function debouncePromise<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+declare class Patches {
+    username: string;
+    protected _patches: Array<QueueItem>;
+    protected thread: IThread;
+    static _replaying: boolean;
+    get patches(): Array<QueueItem>;
+    initThread(thread: IThread, debounceMs?: number): void;
+    get threadInstance(): IThread;
+    constructor(username: string);
+    static onSyncListeners: Array<(patches: QueueItem[]) => void>;
+    static onSync(callback: (patches: QueueItem[]) => void): void;
+    static setReplay(replay: boolean): void;
+    /** Drops all queued (not yet persisted) patches. Test/reset helper. */
+    clearQueue(): void;
+    addPatch(op: QueueItem): void;
+    /**
+     * Last-Writer-Wins consolidation. Walks the queue from the newest entry
+     * backwards and keeps only the latest edit per logical slot.
+     *
+     * The sub-key for property edits incorporates the language code
+     * (`${propertyId}:${langId ?? 0}`) so a French string edit never erases
+     * a previous English edit (SPEC §2.2). Instance field edits additionally
+     * key on the instance index.
+     */
+    static cleanData(data: Array<QueueItem>): Array<QueueItem>;
+    /**
+     * Syncs the queued patches to the worker (IndexedDB persistence).
+     * Before initThread, patches are retained in the queue (never dropped);
+     * initThread flushes them as soon as the worker is available.
+     */
+    sync(): Promise<any>;
+    static calculateLevel(username: string): Promise<number>;
+}
+declare const PatchInstance: Patches;
+/**
+ * Restores patches received from the blockchain into IndexedDB.
+ * Decoding is layout-driven: the payload's `version` selects the codec
+ * layout from versions.json (delta-merged via resolveLayout).
+ */
+declare const deserializePatches: (username: string, payload: EvmPayload) => Promise<void>;
+/**
+ * Serializes locally stored EVM-bound patches into the BackupStorage.sol
+ * payload format. Local analytics ops (ActionTypes) are skipped.
+ */
+declare const serializePatches: (fromIndex: number, toIndex: number) => Promise<EvmPayload>;
+declare const getPatchInstanceByAccount: (account: string) => Patches;
+
+/**
+ * Applies a decoded batch of patches to the **in-memory ORM** — the v2
+ * replacement for v1's `deserializeOp` + `SyncRestoredPatches`.
+ *
+ * The two v1 functions collapse in v2:
+ *  - **decode** is `evmToPatch(payload, versionsFile)` (whole batch, version-driven);
+ *  - **persist** is `deserializePatches()` (writes to IndexedDB);
+ *  - this function is the missing **routing + apply** step only.
+ *
+ * Each EVM edit op is routed to its target record by `(objectType, objectId)`
+ * and applied via `record.patch(op)`, which mutates in-memory state, fires
+ * reactivity, and propagates inverse relations. Records not currently
+ * materialized in the LRU are **skipped** (their ops remain in IndexedDB and
+ * are folded in when the record is next hydrated — the Direction-B path).
+ * Local analytics ops carry no object edit and are ignored here (they feed the
+ * stats store on boot).
+ *
+ * `setReplay(true)` brackets the loop so no apply is mistaken for user
+ * authoring (defensive: `record.patch()` does not itself queue, but inverse
+ * propagation and future code paths might).
+ *
+ * Idempotent: re-applying the same ops converges to the same state
+ * (`patch()` is a last-writer-wins assignment / Set add-remove).
+ *
+ * @returns counts of ops applied to live records vs. skipped (not materialized).
+ */
+declare const applyRestoredPatches: (ops: Array<AnyPatch>, creatorUsername?: string) => Promise<{
+    applied: number;
+    skipped: number;
+}>;
+
+interface TrashStore {
+    /** Merge ids across a set of usernames. Empty array (default) = every known username. */
+    list(objectType: number, usernames?: string[]): number[];
+    count(objectType: number, usernames?: string[]): number;
+    /** Usernames currently bucketed for this objectType (e.g. to populate a picker). */
+    usernames(objectType: number): string[];
+    subscribe(objectType: number, listener: () => void): () => void;
+}
+/**
+ * Full scan of every currently-hydrated record (dump()), across all object
+ * types — no per-type registration needed since `deleted`/`safe` are
+ * universal base properties (see dsafe.ts). Call after hydrateAll() (session.ts
+ * does this for both the initial boot and each loadLanguage() call).
+ *
+ * Batches persist()/notify() to once each (not once per record) — a bulk
+ * boot-time pass over a large corpus must not fire a synchronous localStorage
+ * write and a listener fan-out per changed record.
+ */
+declare function scanTrash(): void;
+/** Test-only: clears in-memory + localStorage state and any pending debounce timer. */
+declare function _resetForTest(): void;
+declare const trashStore: TrashStore;
+
+declare const version = 4;
+declare const dbName = "the_world_library";
+declare const patchStoreName = "patches";
+declare const jsonStoreName = "catalog_json";
+declare const keyValStoreName = "key_value";
+declare const pdfDataStoreName = "pdf_data";
+declare const deviceStateStoreName = "deviceState";
+declare const localRecordsStoreName = "localRecords";
+declare const instanceRemapsStoreName = "instanceRemaps";
+declare const Db: () => Promise<IDBDatabase>;
+declare const ClearDbData: () => Promise<unknown>;
+
+declare const hasFile: (id: string) => Promise<boolean>;
+declare const loadFile: (id: string) => Promise<FileRecord | undefined>;
+declare const storeFile: (record: FileRecord) => Promise<boolean>;
+/**
+ * Developer-friendly namespace bundling the file-storage ops. Replaces v1's
+ * `files` import — mechanical swap `files.x` → `fileStore.x`:
+ *   `fileStore.has(id)` · `fileStore.load(id)` · `fileStore.store(record)`
+ */
+declare const fileStore: {
+    has: (id: string) => Promise<boolean>;
+    load: (id: string) => Promise<FileRecord | undefined>;
+    store: (record: FileRecord) => Promise<boolean>;
+};
+
+declare const hasBookData: (fileId: string) => Promise<boolean>;
+declare const loadBookData: (fileId: string) => Promise<BookData | undefined>;
+declare const storeBookData: (record: BookData) => Promise<boolean>;
+
+export { AnyPatch, BookData, CURRENT_VERSION, ClearDbData, DSafeCheck, DateUtils, Db, EvmPayload, FileRecord, IThread, LruCache, PatchInstance, Patches, type ProResolver, QueueItem, type ReactivitySystem, type TrashStore, VersionLayout, VersionsFile, _resetForTest, addReactivitySystem, addRecord, applyRestoredPatches, clear, configureDb, currentLayout, dbName, dbReactivity, debouncePromise, delay, deserializePatches, deviceStateStoreName, dump, fileStore, getPatchInstanceByAccount, getRecord, getRecordKey, hasBookData, hasFile, hasRecord, inceptionDate, instanceRemapsStoreName, jsonStoreName, keyValStoreName, loadBookData, loadFile, localRecordsStoreName, patchStoreName, pdfDataStoreName, pinRecord, proResolver, removeRecord, scanTrash, serializePatches, setReactivitySystem, storeBookData, storeFile, trashStore, uid, unpinRecord, version, versionsFile };

package/dist/models/index.js

@@ -0,0 +1,340 @@
+import {
+  getLevel,
+  subscribeLevel
+} from "../chunk-4CWVFPBN.js";
+import {
+  _resetForTest,
+  applyRestoredPatches,
+  scanTrash,
+  trashStore
+} from "../chunk-Y7RS6RTM.js";
+import {
+  ActionTypes,
+  BOOK_PROP_IDS,
+  Book,
+  BookInstance,
+  CURRENT_VERSION,
+  DateUtils,
+  DownloadState,
+  DownloadsByType,
+  FavoritesByTypes,
+  LANG_AGNOSTIC,
+  LANG_ID_DECODE,
+  LANG_ID_ENCODE,
+  LruCache,
+  ModelTypes,
+  NewBookWithId,
+  NewPersonWithId,
+  NewTagWithId,
+  PERSON_PROP_IDS,
+  PatchAction,
+  PatchInstance,
+  PatchOperation,
+  Patches,
+  Person,
+  PopulateStatsStore,
+  Rating,
+  Registry,
+  SchemaRegistry,
+  SidecarType,
+  Stats,
+  TAG_PROP_IDS,
+  Tag,
+  VisitsByType,
+  WorkerCommands,
+  WorkerEvent,
+  addReactivitySystem,
+  addRecord,
+  clear,
+  configureDb,
+  currentLayout,
+  dbReactivity,
+  debouncePromise,
+  deserializePatches,
+  dump,
+  evmToPatch,
+  getPatchInstanceByAccount,
+  getRecord,
+  getRecordKey,
+  hasRecord,
+  inceptionDate,
+  isEvmPatch,
+  packPatch,
+  patchToEvm,
+  pinRecord,
+  relationColName,
+  removeRecord,
+  resolveLayout,
+  serializeBookExtended,
+  serializeBookProv,
+  serializeBookSlim,
+  serializePatches,
+  serializePersonExtended,
+  serializePersonProv,
+  serializePersonSlim,
+  serializeTagExtended,
+  serializeTagProv,
+  serializeTagSlim,
+  setReactivitySystem,
+  unpackPatch,
+  unpinRecord,
+  versionsFile
+} from "../chunk-JDUYLUDJ.js";
+import {
+  ClearDbData,
+  Db,
+  dbName,
+  delay,
+  deviceStateStoreName,
+  instanceRemapsStoreName,
+  jsonStoreName,
+  keyValStoreName,
+  localRecordsStoreName,
+  patchStoreName,
+  pdfDataStoreName,
+  proResolver,
+  version
+} from "../chunk-ZEZGI2TP.js";
+
+// src/models/dsafe.ts
+var safePropId = 5;
+var deletedPropId = 6;
+var DSafeCheck = (element) => {
+  return element.getProp(deletedPropId) === false && element.getProp(safePropId) === true;
+};
+
+// src/models/indexdb/file_storage.ts
+var storeName = jsonStoreName;
+var hasFile = (id) => {
+  const deferred = proResolver();
+  Db().then((db) => {
+    try {
+      const tx = db.transaction(storeName, "readonly");
+      const req = tx.objectStore(storeName).count(id);
+      req.onsuccess = function(e) {
+        const count = e.target.result;
+        if (count > 0) {
+          deferred.resolve(true);
+        } else {
+          deferred.resolve(false);
+        }
+      };
+      req.onerror = function(e) {
+        console.error("worker: error", e.target);
+        deferred.reject(e.target);
+      };
+    } catch (e) {
+      console.error(e);
+      debugger;
+    }
+  }).catch((e) => {
+    console.error(`[indexdb error:] hasFile(): ${e.message}`);
+    deferred.reject(e);
+  });
+  return deferred.pro;
+};
+var loadFile = (id) => {
+  const deferred = proResolver();
+  Db().then((db) => {
+    const tx = db.transaction(storeName, "readonly");
+    let result = void 0;
+    tx.objectStore(storeName).get(id).addEventListener("success", function(event) {
+      result = event.target.result;
+      deferred.resolve(result);
+    });
+    tx.onerror = function(event) {
+      console.error("worker: error", event.target);
+      deferred.reject(event.target);
+    };
+  }).catch(deferred.reject);
+  return deferred.pro;
+};
+var storeFile = async (record) => {
+  const deferred = proResolver();
+  const db = await Db();
+  const has = await hasFile(record.id);
+  const tx = db.transaction(storeName, "readwrite");
+  if (has) {
+    tx.objectStore(storeName).put(record).onsuccess = function() {
+    };
+  } else {
+    tx.objectStore(storeName).add(record).onsuccess = function() {
+    };
+  }
+  tx.oncomplete = function() {
+    deferred.resolve(true);
+  };
+  tx.onerror = function(event) {
+    console.error("worker: error", event.target);
+    deferred.reject(event.target);
+  };
+  return deferred.pro;
+};
+var fileStore = { has: hasFile, load: loadFile, store: storeFile };
+
+// src/models/indexdb/book_data.ts
+var hasBookData = (fileId) => {
+  const deferred = proResolver();
+  Db().then((db) => {
+    try {
+      const tx = db.transaction(pdfDataStoreName, "readonly");
+      const req = tx.objectStore(pdfDataStoreName).openCursor(fileId);
+      req.onsuccess = function(e) {
+        const cursor = e.target.result;
+        if (cursor) {
+          deferred.resolve(true);
+        } else {
+          deferred.resolve(false);
+        }
+      };
+      req.onerror = function(e) {
+        console.error("worker: error", e.target);
+        deferred.reject(e.target);
+      };
+    } catch (e) {
+      console.error(e);
+      debugger;
+    }
+  }).catch((e) => {
+    console.error(`[indexdb error:] hasFile(): ${e.message}`);
+    deferred.reject(e);
+  });
+  return deferred.pro;
+};
+var loadBookData = (fileId) => {
+  const deferred = proResolver();
+  Db().then((db) => {
+    const tx = db.transaction(pdfDataStoreName, "readonly");
+    let result = void 0;
+    tx.objectStore(pdfDataStoreName).get(fileId).addEventListener("success", function(event) {
+      result = event.target.result;
+    });
+    tx.oncomplete = function() {
+      deferred.resolve(result);
+    };
+    tx.onerror = function(event) {
+      deferred.reject(event.target);
+    };
+  }).catch(deferred.reject);
+  return deferred.pro;
+};
+var storeBookData = (record) => {
+  const deferred = proResolver();
+  Db().then(async (db) => {
+    const has = await hasBookData(record.fileId);
+    const tx = db.transaction(pdfDataStoreName, "readwrite");
+    if (has) {
+      tx.objectStore(pdfDataStoreName).put(record);
+    } else {
+      tx.objectStore(pdfDataStoreName).add(record);
+    }
+    tx.oncomplete = function() {
+      deferred.resolve(true);
+    };
+    tx.onerror = function(event) {
+      console.error("worker: error", event.target);
+      deferred.reject(event.target);
+    };
+  }).catch(deferred.reject);
+  return deferred.pro;
+};
+export {
+  ActionTypes,
+  BOOK_PROP_IDS,
+  Book,
+  BookInstance,
+  CURRENT_VERSION,
+  ClearDbData,
+  DSafeCheck,
+  DateUtils,
+  Db,
+  DownloadState,
+  DownloadsByType,
+  FavoritesByTypes,
+  LANG_AGNOSTIC,
+  LANG_ID_DECODE,
+  LANG_ID_ENCODE,
+  LruCache,
+  ModelTypes,
+  NewBookWithId,
+  NewPersonWithId,
+  NewTagWithId,
+  PERSON_PROP_IDS,
+  PatchAction,
+  PatchInstance,
+  PatchOperation,
+  Patches,
+  Person,
+  PopulateStatsStore,
+  Rating,
+  Registry,
+  SchemaRegistry,
+  SidecarType,
+  Stats,
+  TAG_PROP_IDS,
+  Tag,
+  VisitsByType,
+  WorkerCommands,
+  WorkerEvent,
+  _resetForTest,
+  addReactivitySystem,
+  addRecord,
+  applyRestoredPatches,
+  clear,
+  configureDb,
+  currentLayout,
+  dbName,
+  dbReactivity,
+  debouncePromise,
+  delay,
+  deserializePatches,
+  deviceStateStoreName,
+  dump,
+  evmToPatch,
+  fileStore,
+  getLevel,
+  getPatchInstanceByAccount,
+  getRecord,
+  getRecordKey,
+  hasBookData,
+  hasFile,
+  hasRecord,
+  inceptionDate,
+  instanceRemapsStoreName,
+  isEvmPatch,
+  jsonStoreName,
+  keyValStoreName,
+  loadBookData,
+  loadFile,
+  localRecordsStoreName,
+  packPatch,
+  patchStoreName,
+  patchToEvm,
+  pdfDataStoreName,
+  pinRecord,
+  proResolver,
+  relationColName,
+  removeRecord,
+  resolveLayout,
+  scanTrash,
+  serializeBookExtended,
+  serializeBookProv,
+  serializeBookSlim,
+  serializePatches,
+  serializePersonExtended,
+  serializePersonProv,
+  serializePersonSlim,
+  serializeTagExtended,
+  serializeTagProv,
+  serializeTagSlim,
+  setReactivitySystem,
+  storeBookData,
+  storeFile,
+  subscribeLevel,
+  trashStore,
+  unpackPatch,
+  unpinRecord,
+  version,
+  versionsFile
+};
+//# sourceMappingURL=index.js.map

package/dist/models/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/models/dsafe.ts","../../src/models/indexdb/file_storage.ts","../../src/models/indexdb/book_data.ts"],"mappings":"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","names":[]}