@verdant-web/store 2.7.7-next.0 → 2.7.7

package/dist/esm/client/ClientDescriptor.js

@@ -1,194 +1,194 @@
-import { EventSubscriber, hashObject, } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { openMetadataDatabase, openWIPMetadataDatabase, } from '../metadata/openMetadataDatabase.js';
-import { openDocumentDatabase, openWIPDocumentDatabase, } from '../migration/openDatabase.js';
-import { UndoHistory } from '../UndoHistory.js';
-import { Client } from './Client.js';
-import { deleteAllDatabases, deleteDatabase, getAllDatabaseNamesAndVersions, } from '../idb.js';
-import { FakeWeakRef } from '../FakeWeakRef.js';
-import { METADATA_VERSION_KEY } from './constants.js';
-/**
- * Since storage initialization is async, this class wraps the core
- * Storage creation promise and exposes some metadata which can
- * be useful immediately.
- */
-export class ClientDescriptor {
-    get namespace() {
-        return this._namespace;
-    }
-    constructor(init) {
-        this.init = init;
-        this._initializing = false;
-        this.initialize = async (init) => {
-            // if server-side and no alternative IndexedDB implementation was provided,
-            // we can't initialize the storage
-            if (typeof window === 'undefined' && !init.indexedDb) {
-                throw new Error('A verdant client was initialized in an environment without IndexedDB. If you are using verdant in a server-rendered framework, you must enforce that all clients are initialized on the client-side, or you must provide some mock interface of IDBFactory to the ClientDescriptor options.');
-            }
-            if (this._initializing || this._resolvedValue) {
-                return this._readyPromise;
-            }
-            this._initializing = true;
-            try {
-                let storage;
-                if (init.schema.wip) {
-                    storage = await this.initializeWIPDatabases(init);
-                }
-                else {
-                    storage = await this.initializeDatabases(init);
-                    this.cleanupWIPDatabases(init);
-                }
-                this.resolveReady(storage);
-                this._resolvedValue = storage;
-                return storage;
-            }
-            catch (err) {
-                this.rejectReady(err);
-                throw err;
-            }
-            finally {
-                this._initializing = false;
-            }
-        };
-        this.initializeDatabases = async (init) => {
-            const metadataVersion = init[METADATA_VERSION_KEY];
-            const { db: metaDb } = await openMetadataDatabase({
-                indexedDB: init.indexedDb,
-                log: init.log,
-                namespace: init.namespace,
-                metadataVersion,
-            });
-            const context = {
-                namespace: this._namespace,
-                metaDb,
-                schema: init.schema,
-                log: init.log || (() => { }),
-                undoHistory: init.undoHistory || new UndoHistory(),
-                entityEvents: new EventSubscriber(),
-                globalEvents: new EventSubscriber(),
-                weakRef: (value) => {
-                    if (init.EXPERIMENTAL_weakRefs) {
-                        return new WeakRef(value);
-                    }
-                    else {
-                        return new FakeWeakRef(value);
-                    }
-                },
-            };
-            const meta = new Metadata({
-                context,
-                disableRebasing: init.disableRebasing,
-            });
-            // verify schema integrity
-            await meta.updateSchema(init.schema, init.overrideSchemaConflict);
-            const documentDb = await openDocumentDatabase({
-                context,
-                version: init.schema.version,
-                meta,
-                migrations: init.migrations,
-                indexedDB: init.indexedDb,
-            });
-            const fullContext = Object.assign(context, { documentDb });
-            const storage = new Client({
-                syncConfig: init.sync,
-                migrations: init.migrations,
-                files: init.files,
-            }, fullContext, {
-                meta,
-            });
-            return storage;
-        };
-        this.initializeWIPDatabases = async (init) => {
-            const schemaHash = hashObject(init.schema);
-            console.info(`WIP schema in use. Opening database with hash ${schemaHash}`);
-            const wipNamespace = `@@wip_${init.namespace}_${schemaHash}`;
-            const { db: metaDb } = await openWIPMetadataDatabase({
-                indexedDB: init.indexedDb,
-                log: init.log,
-                namespace: init.namespace,
-                wipNamespace: wipNamespace,
-            });
-            const context = {
-                namespace: this._namespace,
-                metaDb,
-                schema: init.schema,
-                log: init.log || (() => { }),
-                undoHistory: init.undoHistory || new UndoHistory(),
-                entityEvents: new EventSubscriber(),
-                globalEvents: new EventSubscriber(),
-                weakRef: (value) => {
-                    if (init.EXPERIMENTAL_weakRefs) {
-                        return new WeakRef(value);
-                    }
-                    else {
-                        return new FakeWeakRef(value);
-                    }
-                },
-            };
-            const meta = new Metadata({
-                context,
-                disableRebasing: init.disableRebasing,
-            });
-            // verify schema integrity
-            await meta.updateSchema(init.schema, init.overrideSchemaConflict);
-            const documentDb = await openWIPDocumentDatabase({
-                context,
-                version: init.schema.version,
-                meta,
-                migrations: init.migrations,
-                indexedDB: init.indexedDb,
-                wipNamespace,
-            });
-            const fullContext = Object.assign(context, { documentDb });
-            const storage = new Client({
-                syncConfig: init.sync,
-                migrations: init.migrations,
-                files: init.files,
-            }, fullContext, {
-                meta,
-            });
-            return storage;
-        };
-        this.cleanupWIPDatabases = async (init) => {
-            const databaseInfo = await getAllDatabaseNamesAndVersions(init.indexedDb);
-            const wipDatabases = databaseInfo
-                .filter((db) => { var _a; return (_a = db.name) === null || _a === void 0 ? void 0 : _a.startsWith('@@wip_'); })
-                .map((db) => db.name);
-            // don't clear a current WIP database.
-            const wipDatabasesToDelete = wipDatabases.filter((db) => !db.startsWith(`@@wip_${init.namespace}_${hashObject(init.schema)}`));
-            for (const db of wipDatabasesToDelete) {
-                await deleteDatabase(db, init.indexedDb);
-            }
-        };
-        this.open = () => this.initialize(this.init);
-        this.close = async () => {
-            if (this._resolvedValue) {
-                this._resolvedValue.close();
-            }
-            if (this._initializing) {
-                (await this._readyPromise).close();
-            }
-        };
-        this.__dangerous__resetLocal = async () => {
-            await deleteAllDatabases(this.namespace);
-        };
-        this._readyPromise = new Promise((resolve, reject) => {
-            this.resolveReady = resolve;
-            this.rejectReady = reject;
-        });
-        this._namespace = init.namespace;
-    }
-    get current() {
-        // exposing an immediate value if already resolved lets us
-        // skip the promise microtask when accessing this externally if
-        // the initialization has been completed.
-        return this._resolvedValue;
-    }
-    get readyPromise() {
-        return this._readyPromise;
-    }
-    get schema() {
-        return this.init.schema;
-    }
-}
+import { EventSubscriber, hashObject, } from '@verdant-web/common';
+import { Metadata } from '../metadata/Metadata.js';
+import { openMetadataDatabase, openWIPMetadataDatabase, } from '../metadata/openMetadataDatabase.js';
+import { openDocumentDatabase, openWIPDocumentDatabase, } from '../migration/openDatabase.js';
+import { UndoHistory } from '../UndoHistory.js';
+import { Client } from './Client.js';
+import { deleteAllDatabases, deleteDatabase, getAllDatabaseNamesAndVersions, } from '../idb.js';
+import { FakeWeakRef } from '../FakeWeakRef.js';
+import { METADATA_VERSION_KEY } from './constants.js';
+/**
+ * Since storage initialization is async, this class wraps the core
+ * Storage creation promise and exposes some metadata which can
+ * be useful immediately.
+ */
+export class ClientDescriptor {
+    get namespace() {
+        return this._namespace;
+    }
+    constructor(init) {
+        this.init = init;
+        this._initializing = false;
+        this.initialize = async (init) => {
+            // if server-side and no alternative IndexedDB implementation was provided,
+            // we can't initialize the storage
+            if (typeof window === 'undefined' && !init.indexedDb) {
+                throw new Error('A verdant client was initialized in an environment without IndexedDB. If you are using verdant in a server-rendered framework, you must enforce that all clients are initialized on the client-side, or you must provide some mock interface of IDBFactory to the ClientDescriptor options.');
+            }
+            if (this._initializing || this._resolvedValue) {
+                return this._readyPromise;
+            }
+            this._initializing = true;
+            try {
+                let storage;
+                if (init.schema.wip) {
+                    storage = await this.initializeWIPDatabases(init);
+                }
+                else {
+                    storage = await this.initializeDatabases(init);
+                    this.cleanupWIPDatabases(init);
+                }
+                this.resolveReady(storage);
+                this._resolvedValue = storage;
+                return storage;
+            }
+            catch (err) {
+                this.rejectReady(err);
+                throw err;
+            }
+            finally {
+                this._initializing = false;
+            }
+        };
+        this.initializeDatabases = async (init) => {
+            const metadataVersion = init[METADATA_VERSION_KEY];
+            const { db: metaDb } = await openMetadataDatabase({
+                indexedDB: init.indexedDb,
+                log: init.log,
+                namespace: init.namespace,
+                metadataVersion,
+            });
+            const context = {
+                namespace: this._namespace,
+                metaDb,
+                schema: init.schema,
+                log: init.log || (() => { }),
+                undoHistory: init.undoHistory || new UndoHistory(),
+                entityEvents: new EventSubscriber(),
+                globalEvents: new EventSubscriber(),
+                weakRef: (value) => {
+                    if (init.EXPERIMENTAL_weakRefs) {
+                        return new WeakRef(value);
+                    }
+                    else {
+                        return new FakeWeakRef(value);
+                    }
+                },
+            };
+            const meta = new Metadata({
+                context,
+                disableRebasing: init.disableRebasing,
+            });
+            // verify schema integrity
+            await meta.updateSchema(init.schema, init.overrideSchemaConflict);
+            const documentDb = await openDocumentDatabase({
+                context,
+                version: init.schema.version,
+                meta,
+                migrations: init.migrations,
+                indexedDB: init.indexedDb,
+            });
+            const fullContext = Object.assign(context, { documentDb });
+            const storage = new Client({
+                syncConfig: init.sync,
+                migrations: init.migrations,
+                files: init.files,
+            }, fullContext, {
+                meta,
+            });
+            return storage;
+        };
+        this.initializeWIPDatabases = async (init) => {
+            const schemaHash = hashObject(init.schema);
+            console.info(`WIP schema in use. Opening database with hash ${schemaHash}`);
+            const wipNamespace = `@@wip_${init.namespace}_${schemaHash}`;
+            const { db: metaDb } = await openWIPMetadataDatabase({
+                indexedDB: init.indexedDb,
+                log: init.log,
+                namespace: init.namespace,
+                wipNamespace: wipNamespace,
+            });
+            const context = {
+                namespace: this._namespace,
+                metaDb,
+                schema: init.schema,
+                log: init.log || (() => { }),
+                undoHistory: init.undoHistory || new UndoHistory(),
+                entityEvents: new EventSubscriber(),
+                globalEvents: new EventSubscriber(),
+                weakRef: (value) => {
+                    if (init.EXPERIMENTAL_weakRefs) {
+                        return new WeakRef(value);
+                    }
+                    else {
+                        return new FakeWeakRef(value);
+                    }
+                },
+            };
+            const meta = new Metadata({
+                context,
+                disableRebasing: init.disableRebasing,
+            });
+            // verify schema integrity
+            await meta.updateSchema(init.schema, init.overrideSchemaConflict);
+            const documentDb = await openWIPDocumentDatabase({
+                context,
+                version: init.schema.version,
+                meta,
+                migrations: init.migrations,
+                indexedDB: init.indexedDb,
+                wipNamespace,
+            });
+            const fullContext = Object.assign(context, { documentDb });
+            const storage = new Client({
+                syncConfig: init.sync,
+                migrations: init.migrations,
+                files: init.files,
+            }, fullContext, {
+                meta,
+            });
+            return storage;
+        };
+        this.cleanupWIPDatabases = async (init) => {
+            const databaseInfo = await getAllDatabaseNamesAndVersions(init.indexedDb);
+            const wipDatabases = databaseInfo
+                .filter((db) => { var _a; return (_a = db.name) === null || _a === void 0 ? void 0 : _a.startsWith('@@wip_'); })
+                .map((db) => db.name);
+            // don't clear a current WIP database.
+            const wipDatabasesToDelete = wipDatabases.filter((db) => !db.startsWith(`@@wip_${init.namespace}_${hashObject(init.schema)}`));
+            for (const db of wipDatabasesToDelete) {
+                await deleteDatabase(db, init.indexedDb);
+            }
+        };
+        this.open = () => this.initialize(this.init);
+        this.close = async () => {
+            if (this._resolvedValue) {
+                this._resolvedValue.close();
+            }
+            if (this._initializing) {
+                (await this._readyPromise).close();
+            }
+        };
+        this.__dangerous__resetLocal = async () => {
+            await deleteAllDatabases(this.namespace);
+        };
+        this._readyPromise = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+        this._namespace = init.namespace;
+    }
+    get current() {
+        // exposing an immediate value if already resolved lets us
+        // skip the promise microtask when accessing this externally if
+        // the initialization has been completed.
+        return this._resolvedValue;
+    }
+    get readyPromise() {
+        return this._readyPromise;
+    }
+    get schema() {
+        return this.init.schema;
+    }
+}
 //# sourceMappingURL=ClientDescriptor.js.map

package/dist/esm/client/constants.d.ts

@@ -1 +1 @@
-export declare const METADATA_VERSION_KEY: unique symbol;
+export declare const METADATA_VERSION_KEY: unique symbol;

package/dist/esm/client/constants.js

@@ -1,2 +1,2 @@
-export const METADATA_VERSION_KEY = Symbol('metadataVersion');
+export const METADATA_VERSION_KEY = Symbol('metadataVersion');
 //# sourceMappingURL=constants.js.map

package/dist/esm/constants.d.ts

@@ -1 +1 @@
-export declare const TEST_API = "__unsafe__test_api__";
+export declare const TEST_API = "__unsafe__test_api__";

package/dist/esm/constants.js

@@ -1,2 +1,2 @@
-export const TEST_API = '__unsafe__test_api__';
+export const TEST_API = '__unsafe__test_api__';
 //# sourceMappingURL=constants.js.map

package/dist/esm/context.d.ts

@@ -1,29 +1,29 @@
-import { EventSubscriber, StorageSchema } from '@verdant-web/common';
-import { UndoHistory } from './UndoHistory.js';
-/**
- * Common components utilized across various client
- * services.
- */
-export interface Context {
-    namespace: string;
-    metaDb: IDBDatabase;
-    documentDb: IDBDatabase;
-    undoHistory: UndoHistory;
-    schema: StorageSchema;
-    log: (...args: any[]) => void;
-    entityEvents: EventSubscriber<{
-        collectionsChanged: (names: string[]) => void;
-    }>;
-    globalEvents: EventSubscriber<{
-        /**
-         * A change from a future version of the application has been
-         * witnessed. These changes are not applied but it indicates
-         * the app has been updated and we should prompt the user
-         * to reload or have their app user manually reload.
-         *
-         * The parameter is the timestamp of the future change.
-         */
-        futureSeen: (timestamp: string) => void;
-    }>;
-    weakRef<T extends object>(value: T): WeakRef<T>;
-}
+import { EventSubscriber, StorageSchema } from '@verdant-web/common';
+import { UndoHistory } from './UndoHistory.js';
+/**
+ * Common components utilized across various client
+ * services.
+ */
+export interface Context {
+    namespace: string;
+    metaDb: IDBDatabase;
+    documentDb: IDBDatabase;
+    undoHistory: UndoHistory;
+    schema: StorageSchema;
+    log: (...args: any[]) => void;
+    entityEvents: EventSubscriber<{
+        collectionsChanged: (names: string[]) => void;
+    }>;
+    globalEvents: EventSubscriber<{
+        /**
+         * A change from a future version of the application has been
+         * witnessed. These changes are not applied but it indicates
+         * the app has been updated and we should prompt the user
+         * to reload or have their app user manually reload.
+         *
+         * The parameter is the timestamp of the future change.
+         */
+        futureSeen: (timestamp: string) => void;
+    }>;
+    weakRef<T extends object>(value: T): WeakRef<T>;
+}

package/dist/esm/context.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=context.js.map

package/dist/esm/entities/DocumentFamiliyCache.d.ts

@@ -1,90 +1,90 @@
-import { DocumentBaseline, EventSubscriber, ObjectIdentifier, Operation, StorageFieldSchema } from '@verdant-web/common';
-import { Entity } from './Entity.js';
-import type { EntityStore } from './EntityStore.js';
-import { Context } from '../context.js';
-import { TaggedOperation } from '../types.js';
-/**
- * Local operations: operations on this client that haven't
- * yet been synced and are only applied in-memory. These are
- * always applied after all other operations, they are conceptually
- * 'in the future' as they are not yet synced or stored.
- *
- * Confirmed operations: operations that have been synced and
- * stored in the database.
- *
- * Unconfirmed operations: operations received from sync which
- * have not been stored yet and are only in memory. These exist
- * because new incoming operations are synchronously applied to
- * cached entities while storage goes on async.
- */
-export declare class DocumentFamilyCache extends EventSubscriber<Record<`change:${string}`, () => void> & {
-    'change:*': (oid: ObjectIdentifier) => void;
-}> {
-    readonly oid: ObjectIdentifier;
-    private operationsMap;
-    private localOperationsMap;
-    private baselinesMap;
-    private entities;
-    private context;
-    private storeTools;
-    private _initialized;
-    get initializedPromise(): Promise<boolean>;
-    setInitialized: () => void;
-    constructor({ oid, store, context, }: {
-        oid: ObjectIdentifier;
-        store: EntityStore;
-        context: Context;
-    });
-    get weakRef(): <T extends object>(value: T) => WeakRef<T>;
-    insertLocalOperations: (operations: Operation[]) => void;
-    insertOperations: (operations: TaggedOperation[], info: {
-        isLocal: boolean;
-        affectedOids?: Set<ObjectIdentifier>;
-    }) => void;
-    /**
-     * Insert new baselines for objects in this family.
-     * Automatically drops operations before the new baseline.
-     */
-    insertBaselines: (baselines: DocumentBaseline[], { affectedOids, }: {
-        isLocal: boolean;
-        affectedOids?: Set<string> | undefined;
-    }) => void;
-    addData: ({ operations, baselines, reset, isLocal, }: {
-        operations: TaggedOperation[];
-        baselines: DocumentBaseline[];
-        reset?: boolean | undefined;
-        isLocal?: boolean | undefined;
-    }) => void;
-    private applyOperations;
-    computeView: (oid: ObjectIdentifier) => {
-        view: any;
-        deleted: boolean;
-        lastTimestamp: number | null;
-    };
-    computeConfirmedView: (oid: ObjectIdentifier) => {
-        view: any;
-        deleted: boolean;
-        empty: boolean;
-    };
-    getLastTimestamp: (oid: ObjectIdentifier) => number | null;
-    getEntity: (oid: ObjectIdentifier, schema: StorageFieldSchema, parent?: Entity, readonlyKeys?: string[]) => Entity;
-    hasOid: (oid: ObjectIdentifier) => boolean;
-    dispose: () => void;
-    reset: ({ operations, baselines, dropExistingUnconfirmed: dropUnconfirmed, unconfirmedOperations, dropAll, }: {
-        operations: TaggedOperation[];
-        unconfirmedOperations?: Operation[] | undefined;
-        baselines: DocumentBaseline[];
-        /**
-         * Whether to drop operations which are only in-memory. Unconfirmed operations
-         * will not be restored from storage until they are persisted, so it's not advisable
-         * to use this unless the intention is to completely clear the entities.
-         */
-        dropExistingUnconfirmed?: boolean | undefined;
-        /**
-         * Drop unconfirmed and confirmed data before resetting to incoming data.
-         * This is dangerous due to race conditions. Only use when a full reset is
-         * required.
-         */
-        dropAll?: boolean | undefined;
-    }) => void;
-}
+import { DocumentBaseline, EventSubscriber, ObjectIdentifier, Operation, StorageFieldSchema } from '@verdant-web/common';
+import { Entity } from './Entity.js';
+import type { EntityStore } from './EntityStore.js';
+import { Context } from '../context.js';
+import { TaggedOperation } from '../types.js';
+/**
+ * Local operations: operations on this client that haven't
+ * yet been synced and are only applied in-memory. These are
+ * always applied after all other operations, they are conceptually
+ * 'in the future' as they are not yet synced or stored.
+ *
+ * Confirmed operations: operations that have been synced and
+ * stored in the database.
+ *
+ * Unconfirmed operations: operations received from sync which
+ * have not been stored yet and are only in memory. These exist
+ * because new incoming operations are synchronously applied to
+ * cached entities while storage goes on async.
+ */
+export declare class DocumentFamilyCache extends EventSubscriber<Record<`change:${string}`, () => void> & {
+    'change:*': (oid: ObjectIdentifier) => void;
+}> {
+    readonly oid: ObjectIdentifier;
+    private operationsMap;
+    private localOperationsMap;
+    private baselinesMap;
+    private entities;
+    private context;
+    private storeTools;
+    private _initialized;
+    get initializedPromise(): Promise<boolean>;
+    setInitialized: () => void;
+    constructor({ oid, store, context, }: {
+        oid: ObjectIdentifier;
+        store: EntityStore;
+        context: Context;
+    });
+    get weakRef(): <T extends object>(value: T) => WeakRef<T>;
+    insertLocalOperations: (operations: Operation[]) => void;
+    insertOperations: (operations: TaggedOperation[], info: {
+        isLocal: boolean;
+        affectedOids?: Set<ObjectIdentifier>;
+    }) => void;
+    /**
+     * Insert new baselines for objects in this family.
+     * Automatically drops operations before the new baseline.
+     */
+    insertBaselines: (baselines: DocumentBaseline[], { affectedOids, }: {
+        isLocal: boolean;
+        affectedOids?: Set<string> | undefined;
+    }) => void;
+    addData: ({ operations, baselines, reset, isLocal, }: {
+        operations: TaggedOperation[];
+        baselines: DocumentBaseline[];
+        reset?: boolean | undefined;
+        isLocal?: boolean | undefined;
+    }) => void;
+    private applyOperations;
+    computeView: (oid: ObjectIdentifier) => {
+        view: any;
+        deleted: boolean;
+        lastTimestamp: number | null;
+    };
+    computeConfirmedView: (oid: ObjectIdentifier) => {
+        view: any;
+        deleted: boolean;
+        empty: boolean;
+    };
+    getLastTimestamp: (oid: ObjectIdentifier) => number | null;
+    getEntity: (oid: ObjectIdentifier, schema: StorageFieldSchema, parent?: Entity, readonlyKeys?: string[]) => Entity;
+    hasOid: (oid: ObjectIdentifier) => boolean;
+    dispose: () => void;
+    reset: ({ operations, baselines, dropExistingUnconfirmed: dropUnconfirmed, unconfirmedOperations, dropAll, }: {
+        operations: TaggedOperation[];
+        unconfirmedOperations?: Operation[] | undefined;
+        baselines: DocumentBaseline[];
+        /**
+         * Whether to drop operations which are only in-memory. Unconfirmed operations
+         * will not be restored from storage until they are persisted, so it's not advisable
+         * to use this unless the intention is to completely clear the entities.
+         */
+        dropExistingUnconfirmed?: boolean | undefined;
+        /**
+         * Drop unconfirmed and confirmed data before resetting to incoming data.
+         * This is dangerous due to race conditions. Only use when a full reset is
+         * required.
+         */
+        dropAll?: boolean | undefined;
+    }) => void;
+}