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

package/dist/esm/client/Client.js

@@ -1,224 +1,224 @@
-import { debounce, EventSubscriber, } from '@verdant-web/common';
-import { DocumentManager } from '../DocumentManager.js';
-import { FileManager } from '../files/FileManager.js';
-import { closeDatabase, deleteAllDatabases, getSizeOfObjectStore, } from '../idb.js';
-import { openDocumentDatabase } from '../migration/openDatabase.js';
-import { EntityStore } from '../entities/EntityStore.js';
-import { NoSync, ServerSync } from '../sync/Sync.js';
-import { CollectionQueries } from '../queries/CollectionQueries.js';
-import { QueryCache } from '../queries/QueryCache.js';
-export class Client extends EventSubscriber {
-    get sync() {
-        return this._sync;
-    }
-    get entities() {
-        return this._entities;
-    }
-    get documentManager() {
-        return this._documentManager;
-    }
-    constructor(config, context, components) {
-        super();
-        this.config = config;
-        this.context = context;
-        this.addData = (data) => {
-            return this._entities.addData(data);
-        };
-        this.stats = async () => {
-            const collectionNames = Object.keys(this.schema.collections);
-            let collections = {};
-            for (const collectionName of collectionNames) {
-                collections[collectionName] = await getSizeOfObjectStore(this.documentDb, collectionName);
-            }
-            const meta = await this.meta.stats();
-            const storage = typeof navigator !== 'undefined' &&
-                typeof navigator.storage !== 'undefined' &&
-                'estimate' in navigator.storage
-                ? await navigator.storage.estimate()
-                : undefined;
-            // determine data:metadata ratio for total size of all collections vs metadata
-            const totalCollectionsSize = Object.values(collections).reduce((acc, { size }) => acc + size, 0);
-            const totalMetaSize = meta.baselinesSize.size + meta.operationsSize.size;
-            const metaToDataRatio = totalMetaSize / totalCollectionsSize;
-            return {
-                collections,
-                meta,
-                storage,
-                totalMetaSize,
-                totalCollectionsSize,
-                metaToDataRatio,
-                quotaUsage: (storage === null || storage === void 0 ? void 0 : storage.usage) && (storage === null || storage === void 0 ? void 0 : storage.quota)
-                    ? storage.usage / storage.quota
-                    : undefined,
-            };
-        };
-        this.close = async () => {
-            var _a, _b;
-            this.sync.stop();
-            this.sync.dispose();
-            // this step does have the potential to flush
-            // changes to storage, so don't close metadata db yet
-            await this._entities.destroy();
-            this.meta.close();
-            // the idea here is to flush the microtask queue -
-            // we may have queued tasks related to queries that
-            // we want to settle before closing the databases
-            // to avoid invalid state errors
-            await new Promise(async (resolve) => {
-                await closeDatabase(this.documentDb);
-                await closeDatabase(this.metaDb);
-                resolve();
-            });
-            (_b = (_a = this.context).log) === null || _b === void 0 ? void 0 : _b.call(_a, 'Client closed');
-        };
-        this.__dangerous__resetLocal = async () => {
-            this.sync.stop();
-            await deleteAllDatabases(this.namespace, indexedDB);
-        };
-        this.export = async () => {
-            const metaExport = await this.meta.export();
-            return Buffer.from(JSON.stringify(metaExport));
-        };
-        this.import = async (buffer) => {
-            this.context.log('Importing data...');
-            // close the document DB
-            await closeDatabase(this.context.documentDb);
-            const metaExport = JSON.parse(buffer.toString());
-            await this.meta.resetFrom(metaExport);
-            // now reset the document DB to the specified version
-            // and run migrations to get it to the latest version
-            const version = metaExport.schema.version;
-            const deleteReq = indexedDB.deleteDatabase([this.namespace, 'collections'].join('_'));
-            await new Promise((resolve, reject) => {
-                deleteReq.onsuccess = resolve;
-                deleteReq.onerror = reject;
-            });
-            // reset our context to the imported schema for now
-            const currentSchema = this.context.schema;
-            this.context.schema = metaExport.schema;
-            // now open the document DB empty at the specified version
-            // and initialize it from the meta DB
-            this.context.documentDb = await openDocumentDatabase({
-                meta: this.meta,
-                migrations: this.config.migrations,
-                context: this.context,
-                version,
-            });
-            // re-initialize data
-            this.context.log('Re-initializing data from imported data...');
-            await this._entities.addData({
-                operations: metaExport.operations,
-                baselines: metaExport.baselines,
-                reset: true,
-            });
-            // close the database and reopen to latest version, applying
-            // migrations
-            await closeDatabase(this.context.documentDb);
-            this.context.log('Migrating up to latest schema...');
-            // put the schema back
-            this.context.schema = currentSchema;
-            this.context.documentDb = await openDocumentDatabase({
-                meta: this.meta,
-                migrations: this.config.migrations,
-                context: this.context,
-                version: currentSchema.version,
-            });
-        };
-        this.meta = components.meta;
-        this.collectionNames = Object.keys(context.schema.collections);
-        this._sync =
-            this.config.syncConfig && !context.schema.wip
-                ? new ServerSync(this.config.syncConfig, {
-                    meta: this.meta,
-                    onData: this.addData,
-                    log: this.context.log,
-                })
-                : new NoSync();
-        if (context.schema.wip && this.config.syncConfig) {
-            context.log('warn', '⚠️⚠️ Sync is disabled for WIP schemas. Commit your schema changes to start syncing again. ⚠️⚠️');
-        }
-        this._fileManager = new FileManager({
-            db: this.metaDb,
-            sync: this.sync,
-            context: this.context,
-            config: this.config.files,
-            meta: this.meta,
-        });
-        this._entities = new EntityStore({
-            context: this.context,
-            meta: this.meta,
-            files: this._fileManager,
-        });
-        this._queryCache = new QueryCache({
-            context,
-        });
-        this._documentManager = new DocumentManager(this.meta, this.schema, this._entities);
-        const notifyFutureSeen = debounce(() => {
-            this.emit('futureSeen');
-        }, 300);
-        this.context.globalEvents.subscribe('futureSeen', notifyFutureSeen);
-        this.documentDb.addEventListener('versionchange', () => {
-            var _a, _b;
-            (_b = (_a = this.context).log) === null || _b === void 0 ? void 0 : _b.call(_a, `Another tab has requested a version change for ${this.namespace}`);
-            this.documentDb.close();
-            if (typeof window !== 'undefined') {
-                window.location.reload();
-            }
-        });
-        this.metaDb.addEventListener('versionchange', () => {
-            var _a, _b;
-            (_b = (_a = this.context).log) === null || _b === void 0 ? void 0 : _b.call(_a, `Another tab has requested a version change for ${this.namespace}`);
-            this.metaDb.close();
-            if (typeof window !== 'undefined') {
-                window.location.reload();
-            }
-        });
-        // self-assign collection shortcuts. these are not typed
-        // here but are typed in the generated code...
-        for (const [name, _collection] of Object.entries(context.schema.collections)) {
-            const collectionName = name;
-            this[collectionName] = new CollectionQueries({
-                collection: collectionName,
-                cache: this._queryCache,
-                context: this.context,
-                entities: this.entities,
-                documentManager: this.documentManager,
-            });
-        }
-    }
-    get documentDb() {
-        return this.context.documentDb;
-    }
-    get metaDb() {
-        return this.context.metaDb;
-    }
-    get schema() {
-        return this.context.schema;
-    }
-    get namespace() {
-        return this.context.namespace;
-    }
-    get undoHistory() {
-        return this.context.undoHistory;
-    }
-    /**
-     * @deprecated - use client.sync.presence instead
-     */
-    get presence() {
-        return this.sync.presence;
-    }
-    /**
-     * Batch multiple operations together to be executed in a single transaction.
-     * The changes made will not be included in the same undo history step as
-     * any other changes made outside of the batch. You can also disable undo
-     * for your batch to omit changes from undo history.
-     *
-     * Provide a batch name to apply multiple changes to the same batch
-     * across different invocations. Batches will automatically flush after
-     * a short delay or if they reach a maximum size.
-     */
-    get batch() {
-        return this.entities.batch;
-    }
-}
+import { debounce, EventSubscriber, } from '@verdant-web/common';
+import { DocumentManager } from '../DocumentManager.js';
+import { FileManager } from '../files/FileManager.js';
+import { closeDatabase, deleteAllDatabases, getSizeOfObjectStore, } from '../idb.js';
+import { openDocumentDatabase } from '../migration/openDatabase.js';
+import { EntityStore } from '../entities/EntityStore.js';
+import { NoSync, ServerSync } from '../sync/Sync.js';
+import { CollectionQueries } from '../queries/CollectionQueries.js';
+import { QueryCache } from '../queries/QueryCache.js';
+export class Client extends EventSubscriber {
+    get sync() {
+        return this._sync;
+    }
+    get entities() {
+        return this._entities;
+    }
+    get documentManager() {
+        return this._documentManager;
+    }
+    constructor(config, context, components) {
+        super();
+        this.config = config;
+        this.context = context;
+        this.addData = (data) => {
+            return this._entities.addData(data);
+        };
+        this.stats = async () => {
+            const collectionNames = Object.keys(this.schema.collections);
+            let collections = {};
+            for (const collectionName of collectionNames) {
+                collections[collectionName] = await getSizeOfObjectStore(this.documentDb, collectionName);
+            }
+            const meta = await this.meta.stats();
+            const storage = typeof navigator !== 'undefined' &&
+                typeof navigator.storage !== 'undefined' &&
+                'estimate' in navigator.storage
+                ? await navigator.storage.estimate()
+                : undefined;
+            // determine data:metadata ratio for total size of all collections vs metadata
+            const totalCollectionsSize = Object.values(collections).reduce((acc, { size }) => acc + size, 0);
+            const totalMetaSize = meta.baselinesSize.size + meta.operationsSize.size;
+            const metaToDataRatio = totalMetaSize / totalCollectionsSize;
+            return {
+                collections,
+                meta,
+                storage,
+                totalMetaSize,
+                totalCollectionsSize,
+                metaToDataRatio,
+                quotaUsage: (storage === null || storage === void 0 ? void 0 : storage.usage) && (storage === null || storage === void 0 ? void 0 : storage.quota)
+                    ? storage.usage / storage.quota
+                    : undefined,
+            };
+        };
+        this.close = async () => {
+            var _a, _b;
+            this.sync.stop();
+            this.sync.dispose();
+            // this step does have the potential to flush
+            // changes to storage, so don't close metadata db yet
+            await this._entities.destroy();
+            this.meta.close();
+            // the idea here is to flush the microtask queue -
+            // we may have queued tasks related to queries that
+            // we want to settle before closing the databases
+            // to avoid invalid state errors
+            await new Promise(async (resolve) => {
+                await closeDatabase(this.documentDb);
+                await closeDatabase(this.metaDb);
+                resolve();
+            });
+            (_b = (_a = this.context).log) === null || _b === void 0 ? void 0 : _b.call(_a, 'Client closed');
+        };
+        this.__dangerous__resetLocal = async () => {
+            this.sync.stop();
+            await deleteAllDatabases(this.namespace, indexedDB);
+        };
+        this.export = async () => {
+            const metaExport = await this.meta.export();
+            return Buffer.from(JSON.stringify(metaExport));
+        };
+        this.import = async (buffer) => {
+            this.context.log('Importing data...');
+            // close the document DB
+            await closeDatabase(this.context.documentDb);
+            const metaExport = JSON.parse(buffer.toString());
+            await this.meta.resetFrom(metaExport);
+            // now reset the document DB to the specified version
+            // and run migrations to get it to the latest version
+            const version = metaExport.schema.version;
+            const deleteReq = indexedDB.deleteDatabase([this.namespace, 'collections'].join('_'));
+            await new Promise((resolve, reject) => {
+                deleteReq.onsuccess = resolve;
+                deleteReq.onerror = reject;
+            });
+            // reset our context to the imported schema for now
+            const currentSchema = this.context.schema;
+            this.context.schema = metaExport.schema;
+            // now open the document DB empty at the specified version
+            // and initialize it from the meta DB
+            this.context.documentDb = await openDocumentDatabase({
+                meta: this.meta,
+                migrations: this.config.migrations,
+                context: this.context,
+                version,
+            });
+            // re-initialize data
+            this.context.log('Re-initializing data from imported data...');
+            await this._entities.addData({
+                operations: metaExport.operations,
+                baselines: metaExport.baselines,
+                reset: true,
+            });
+            // close the database and reopen to latest version, applying
+            // migrations
+            await closeDatabase(this.context.documentDb);
+            this.context.log('Migrating up to latest schema...');
+            // put the schema back
+            this.context.schema = currentSchema;
+            this.context.documentDb = await openDocumentDatabase({
+                meta: this.meta,
+                migrations: this.config.migrations,
+                context: this.context,
+                version: currentSchema.version,
+            });
+        };
+        this.meta = components.meta;
+        this.collectionNames = Object.keys(context.schema.collections);
+        this._sync =
+            this.config.syncConfig && !context.schema.wip
+                ? new ServerSync(this.config.syncConfig, {
+                    meta: this.meta,
+                    onData: this.addData,
+                    log: this.context.log,
+                })
+                : new NoSync();
+        if (context.schema.wip && this.config.syncConfig) {
+            context.log('warn', '⚠️⚠️ Sync is disabled for WIP schemas. Commit your schema changes to start syncing again. ⚠️⚠️');
+        }
+        this._fileManager = new FileManager({
+            db: this.metaDb,
+            sync: this.sync,
+            context: this.context,
+            config: this.config.files,
+            meta: this.meta,
+        });
+        this._entities = new EntityStore({
+            context: this.context,
+            meta: this.meta,
+            files: this._fileManager,
+        });
+        this._queryCache = new QueryCache({
+            context,
+        });
+        this._documentManager = new DocumentManager(this.meta, this.schema, this._entities);
+        const notifyFutureSeen = debounce(() => {
+            this.emit('futureSeen');
+        }, 300);
+        this.context.globalEvents.subscribe('futureSeen', notifyFutureSeen);
+        this.documentDb.addEventListener('versionchange', () => {
+            var _a, _b;
+            (_b = (_a = this.context).log) === null || _b === void 0 ? void 0 : _b.call(_a, `Another tab has requested a version change for ${this.namespace}`);
+            this.documentDb.close();
+            if (typeof window !== 'undefined') {
+                window.location.reload();
+            }
+        });
+        this.metaDb.addEventListener('versionchange', () => {
+            var _a, _b;
+            (_b = (_a = this.context).log) === null || _b === void 0 ? void 0 : _b.call(_a, `Another tab has requested a version change for ${this.namespace}`);
+            this.metaDb.close();
+            if (typeof window !== 'undefined') {
+                window.location.reload();
+            }
+        });
+        // self-assign collection shortcuts. these are not typed
+        // here but are typed in the generated code...
+        for (const [name, _collection] of Object.entries(context.schema.collections)) {
+            const collectionName = name;
+            this[collectionName] = new CollectionQueries({
+                collection: collectionName,
+                cache: this._queryCache,
+                context: this.context,
+                entities: this.entities,
+                documentManager: this.documentManager,
+            });
+        }
+    }
+    get documentDb() {
+        return this.context.documentDb;
+    }
+    get metaDb() {
+        return this.context.metaDb;
+    }
+    get schema() {
+        return this.context.schema;
+    }
+    get namespace() {
+        return this.context.namespace;
+    }
+    get undoHistory() {
+        return this.context.undoHistory;
+    }
+    /**
+     * @deprecated - use client.sync.presence instead
+     */
+    get presence() {
+        return this.sync.presence;
+    }
+    /**
+     * Batch multiple operations together to be executed in a single transaction.
+     * The changes made will not be included in the same undo history step as
+     * any other changes made outside of the batch. You can also disable undo
+     * for your batch to omit changes from undo history.
+     *
+     * Provide a batch name to apply multiple changes to the same batch
+     * across different invocations. Batches will automatically flush after
+     * a short delay or if they reach a maximum size.
+     */
+    get batch() {
+        return this.entities.batch;
+    }
+}
 //# sourceMappingURL=Client.js.map

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

@@ -1,76 +1,76 @@
-import { Migration, StorageSchema } from '@verdant-web/common';
-import { FileManagerConfig } from '../files/FileManager.js';
-import { ServerSyncOptions } from '../sync/Sync.js';
-import { UndoHistory } from '../UndoHistory.js';
-import { Client } from './Client.js';
-import { METADATA_VERSION_KEY } from './constants.js';
-export interface ClientDescriptorOptions<Presence = any, Profile = any> {
-    /** The schema used to create this client */
-    schema: StorageSchema<any>;
-    /** Migrations, in order, to upgrade to each successive version of the schema */
-    migrations: Migration<any>[];
-    /** Provide a sync config to turn on synchronization with a server */
-    sync?: ServerSyncOptions<Profile, Presence>;
-    /** Optionally override the IndexedDB implementation */
-    indexedDb?: IDBFactory;
-    /**
-     * Namespaces are used to separate data from different clients in IndexedDB.
-     */
-    namespace: string;
-    /**
-     * Provide your own UndoHistory to have a unified undo system across multiple
-     * clients if you so desire.
-     */
-    undoHistory?: UndoHistory;
-    /**
-     * Provide a log function to log internal debug messages
-     */
-    log?: (...args: any[]) => void;
-    disableRebasing?: boolean;
-    /**
-     * Provide a specific schema number to override the schema version
-     * in the database. This is useful for testing migrations or recovering
-     * from a mistakenly deployed incorrect schema. A specific version is required
-     * so that you don't leave this on accidentally for all new schemas.
-     */
-    overrideSchemaConflict?: number;
-    /**
-     * Configuration for file management
-     */
-    files?: FileManagerConfig;
-    /**
-     * Enables experimental WeakRef usage to cull documents
-     * from cache that aren't being used. This is a performance
-     * optimization which has been tested under all Verdant's test
-     * suites but I still want to keep testing it in the real world
-     * before turning it on.
-     */
-    EXPERIMENTAL_weakRefs?: boolean;
-    [METADATA_VERSION_KEY]?: number;
-}
-/**
- * Since storage initialization is async, this class wraps the core
- * Storage creation promise and exposes some metadata which can
- * be useful immediately.
- */
-export declare class ClientDescriptor<Presence = any, Profile = any, ClientImpl extends Client = Client> {
-    private readonly init;
-    private readonly _readyPromise;
-    private resolveReady;
-    private rejectReady;
-    private _resolvedValue;
-    private _initializing;
-    private _namespace;
-    get namespace(): string;
-    constructor(init: ClientDescriptorOptions<Presence, Profile>);
-    private initialize;
-    private initializeDatabases;
-    private initializeWIPDatabases;
-    private cleanupWIPDatabases;
-    get current(): ClientImpl | undefined;
-    get readyPromise(): Promise<ClientImpl>;
-    get schema(): StorageSchema<any>;
-    open: () => Promise<ClientImpl>;
-    close: () => Promise<void>;
-    __dangerous__resetLocal: () => Promise<void>;
-}
+import { Migration, StorageSchema } from '@verdant-web/common';
+import { FileManagerConfig } from '../files/FileManager.js';
+import { ServerSyncOptions } from '../sync/Sync.js';
+import { UndoHistory } from '../UndoHistory.js';
+import { Client } from './Client.js';
+import { METADATA_VERSION_KEY } from './constants.js';
+export interface ClientDescriptorOptions<Presence = any, Profile = any> {
+    /** The schema used to create this client */
+    schema: StorageSchema<any>;
+    /** Migrations, in order, to upgrade to each successive version of the schema */
+    migrations: Migration<any>[];
+    /** Provide a sync config to turn on synchronization with a server */
+    sync?: ServerSyncOptions<Profile, Presence>;
+    /** Optionally override the IndexedDB implementation */
+    indexedDb?: IDBFactory;
+    /**
+     * Namespaces are used to separate data from different clients in IndexedDB.
+     */
+    namespace: string;
+    /**
+     * Provide your own UndoHistory to have a unified undo system across multiple
+     * clients if you so desire.
+     */
+    undoHistory?: UndoHistory;
+    /**
+     * Provide a log function to log internal debug messages
+     */
+    log?: (...args: any[]) => void;
+    disableRebasing?: boolean;
+    /**
+     * Provide a specific schema number to override the schema version
+     * in the database. This is useful for testing migrations or recovering
+     * from a mistakenly deployed incorrect schema. A specific version is required
+     * so that you don't leave this on accidentally for all new schemas.
+     */
+    overrideSchemaConflict?: number;
+    /**
+     * Configuration for file management
+     */
+    files?: FileManagerConfig;
+    /**
+     * Enables experimental WeakRef usage to cull documents
+     * from cache that aren't being used. This is a performance
+     * optimization which has been tested under all Verdant's test
+     * suites but I still want to keep testing it in the real world
+     * before turning it on.
+     */
+    EXPERIMENTAL_weakRefs?: boolean;
+    [METADATA_VERSION_KEY]?: number;
+}
+/**
+ * Since storage initialization is async, this class wraps the core
+ * Storage creation promise and exposes some metadata which can
+ * be useful immediately.
+ */
+export declare class ClientDescriptor<Presence = any, Profile = any, ClientImpl extends Client = Client> {
+    private readonly init;
+    private readonly _readyPromise;
+    private resolveReady;
+    private rejectReady;
+    private _resolvedValue;
+    private _initializing;
+    private _namespace;
+    get namespace(): string;
+    constructor(init: ClientDescriptorOptions<Presence, Profile>);
+    private initialize;
+    private initializeDatabases;
+    private initializeWIPDatabases;
+    private cleanupWIPDatabases;
+    get current(): ClientImpl | undefined;
+    get readyPromise(): Promise<ClientImpl>;
+    get schema(): StorageSchema<any>;
+    open: () => Promise<ClientImpl>;
+    close: () => Promise<void>;
+    __dangerous__resetLocal: () => Promise<void>;
+}