@verdant-web/store 2.0.1 → 2.0.3

package/dist/esm/client/ClientDescriptor.js

@@ -1,105 +1,105 @@
-import { EventSubscriber } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { openMetadataDatabase } from '../metadata/openMetadataDatabase.js';
-import { openDocumentDatabase } from '../openDocumentDatabase.js';
-import { UndoHistory } from '../UndoHistory.js';
-import { Client } from './Client.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 (!('indexedDB' in window) && !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 {
-                const metaDbName = [init.namespace, 'meta'].join('_');
-                const { db: metaDb } = await openMetadataDatabase(this._namespace, {
-                    indexedDB: init.indexedDb,
-                    log: init.log,
-                    databaseName: metaDbName,
-                });
-                const context = {
-                    namespace: this._namespace,
-                    metaDb,
-                    schema: init.schema,
-                    log: init.log || (() => { }),
-                    undoHistory: init.undoHistory || new UndoHistory(),
-                    entityEvents: new EventSubscriber(),
-                };
-                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,
-                });
-                this.resolveReady(storage);
-                this._resolvedValue = storage;
-                return storage;
-            }
-            catch (err) {
-                this.rejectReady(err);
-                throw err;
-            }
-            finally {
-                this._initializing = false;
-            }
-        };
-        this.open = () => this.initialize(this.init);
-        this.close = async () => {
-            if (this._resolvedValue) {
-                this._resolvedValue.close();
-            }
-            if (this._initializing) {
-                (await this._readyPromise).close();
-            }
-        };
-        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 } from '@verdant-web/common';
+import { Metadata } from '../metadata/Metadata.js';
+import { openMetadataDatabase } from '../metadata/openMetadataDatabase.js';
+import { openDocumentDatabase } from '../openDocumentDatabase.js';
+import { UndoHistory } from '../UndoHistory.js';
+import { Client } from './Client.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 (!('indexedDB' in window) && !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 {
+                const metaDbName = [init.namespace, 'meta'].join('_');
+                const { db: metaDb } = await openMetadataDatabase(this._namespace, {
+                    indexedDB: init.indexedDb,
+                    log: init.log,
+                    databaseName: metaDbName,
+                });
+                const context = {
+                    namespace: this._namespace,
+                    metaDb,
+                    schema: init.schema,
+                    log: init.log || (() => { }),
+                    undoHistory: init.undoHistory || new UndoHistory(),
+                    entityEvents: new EventSubscriber(),
+                };
+                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,
+                });
+                this.resolveReady(storage);
+                this._resolvedValue = storage;
+                return storage;
+            }
+            catch (err) {
+                this.rejectReady(err);
+                throw err;
+            }
+            finally {
+                this._initializing = false;
+            }
+        };
+        this.open = () => this.initialize(this.init);
+        this.close = async () => {
+            if (this._resolvedValue) {
+                this._resolvedValue.close();
+            }
+            if (this._initializing) {
+                (await this._readyPromise).close();
+            }
+        };
+        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/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,17 +1,17 @@
-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;
-    }>;
-}
+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;
+    }>;
+}

package/dist/esm/context.js

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

package/dist/esm/files/EntityFile.d.ts

@@ -1,27 +1,27 @@
-import { EventSubscriber, FileData } from '@verdant-web/common';
-export type EntityFileEvents = {
-    change: () => void;
-};
-export declare const UPDATE: unique symbol;
-export declare const MARK_FAILED: unique symbol;
-/**
- * Provides a consistent interface for files used in an app via
- * Entity access.
- */
-export declare class EntityFile extends EventSubscriber<EntityFileEvents> {
-    readonly id: string;
-    private _objectUrl;
-    private _fileData;
-    private _loading;
-    private _failed;
-    private _disposed;
-    constructor(id: string);
-    [UPDATE]: (fileData: FileData) => void;
-    [MARK_FAILED]: () => void;
-    get url(): string | null;
-    get name(): string | null;
-    get type(): string | null;
-    get loading(): boolean;
-    get failed(): boolean;
-    dispose: () => void;
-}
+import { EventSubscriber, FileData } from '@verdant-web/common';
+export type EntityFileEvents = {
+    change: () => void;
+};
+export declare const UPDATE: unique symbol;
+export declare const MARK_FAILED: unique symbol;
+/**
+ * Provides a consistent interface for files used in an app via
+ * Entity access.
+ */
+export declare class EntityFile extends EventSubscriber<EntityFileEvents> {
+    readonly id: string;
+    private _objectUrl;
+    private _fileData;
+    private _loading;
+    private _failed;
+    private _disposed;
+    constructor(id: string);
+    [UPDATE]: (fileData: FileData) => void;
+    [MARK_FAILED]: () => void;
+    get url(): string | null;
+    get name(): string | null;
+    get type(): string | null;
+    get loading(): boolean;
+    get failed(): boolean;
+    dispose: () => void;
+}

package/dist/esm/files/EntityFile.js

@@ -1,68 +1,68 @@
-var _a, _b;
-import { EventSubscriber } from '@verdant-web/common';
-export const UPDATE = Symbol('entity-file-update');
-export const MARK_FAILED = Symbol('entity-file-mark-failed');
-/**
- * Provides a consistent interface for files used in an app via
- * Entity access.
- */
-export class EntityFile extends EventSubscriber {
-    constructor(id) {
-        super();
-        this.id = id;
-        // cached object URL for a local blob file, if applicable
-        this._objectUrl = null;
-        this._fileData = null;
-        this._loading = true;
-        this._failed = false;
-        this._disposed = false;
-        this[_a] = (fileData) => {
-            this._loading = false;
-            this._failed = false;
-            this._disposed = false;
-            this._fileData = fileData;
-            if (fileData.file) {
-                if (this._objectUrl) {
-                    URL.revokeObjectURL(this._objectUrl);
-                }
-                this._objectUrl = URL.createObjectURL(fileData.file);
-            }
-            this.emit('change');
-        };
-        this[_b] = () => {
-            this._failed = true;
-            this._loading = false;
-            this.emit('change');
-        };
-        this.dispose = () => {
-            if (this._objectUrl) {
-                URL.revokeObjectURL(this._objectUrl);
-            }
-            this._disposed = true;
-        };
-    }
-    get url() {
-        var _c, _d;
-        if (this.loading)
-            return null;
-        if (this._objectUrl)
-            return this._objectUrl;
-        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : null;
-    }
-    get name() {
-        var _c, _d;
-        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null;
-    }
-    get type() {
-        var _c, _d;
-        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : null;
-    }
-    get loading() {
-        return this._loading;
-    }
-    get failed() {
-        return this._failed;
-    }
-}
-_a = UPDATE, _b = MARK_FAILED;
+var _a, _b;
+import { EventSubscriber } from '@verdant-web/common';
+export const UPDATE = Symbol('entity-file-update');
+export const MARK_FAILED = Symbol('entity-file-mark-failed');
+/**
+ * Provides a consistent interface for files used in an app via
+ * Entity access.
+ */
+export class EntityFile extends EventSubscriber {
+    constructor(id) {
+        super();
+        this.id = id;
+        // cached object URL for a local blob file, if applicable
+        this._objectUrl = null;
+        this._fileData = null;
+        this._loading = true;
+        this._failed = false;
+        this._disposed = false;
+        this[_a] = (fileData) => {
+            this._loading = false;
+            this._failed = false;
+            this._disposed = false;
+            this._fileData = fileData;
+            if (fileData.file) {
+                if (this._objectUrl) {
+                    URL.revokeObjectURL(this._objectUrl);
+                }
+                this._objectUrl = URL.createObjectURL(fileData.file);
+            }
+            this.emit('change');
+        };
+        this[_b] = () => {
+            this._failed = true;
+            this._loading = false;
+            this.emit('change');
+        };
+        this.dispose = () => {
+            if (this._objectUrl) {
+                URL.revokeObjectURL(this._objectUrl);
+            }
+            this._disposed = true;
+        };
+    }
+    get url() {
+        var _c, _d;
+        if (this.loading)
+            return null;
+        if (this._objectUrl)
+            return this._objectUrl;
+        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : null;
+    }
+    get name() {
+        var _c, _d;
+        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null;
+    }
+    get type() {
+        var _c, _d;
+        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : null;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get failed() {
+        return this._failed;
+    }
+}
+_a = UPDATE, _b = MARK_FAILED;
 //# sourceMappingURL=EntityFile.js.map

package/dist/esm/files/FileManager.d.ts

@@ -1,42 +1,42 @@
-import { FileData } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { Metadata } from '../metadata/Metadata.js';
-import { Sync } from '../sync/Sync.js';
-import { EntityFile } from './EntityFile.js';
-import { ReturnedFileData } from './FileStorage.js';
-export interface FileManagerConfig {
-    /**
-     * Override the heuristic for deciding when a deleted file can be cleaned up.
-     * By default this waits 3 days since deletion, then deletes the file data.
-     * If the file has been synchronized to a server, it could still be restored
-     * if the server has not yet deleted it.
-     */
-    canCleanupDeletedFile?: (file: ReturnedFileData) => boolean;
-}
-export declare class FileManager {
-    private storage;
-    private sync;
-    private context;
-    private files;
-    private config;
-    private meta;
-    constructor({ db, sync, context, meta, config, }: {
-        db: IDBDatabase;
-        sync: Sync;
-        context: Context;
-        config?: FileManagerConfig;
-        meta: Metadata;
-    });
-    add: (fileInput: Omit<FileData, 'remote'>) => Promise<void>;
-    private uploadFile;
-    /**
-     * Immediately returns an EntityFile to use, then either loads
-     * the file from cache, local database, or the server.
-     */
-    get: (id: string) => EntityFile;
-    private load;
-    listUnsynced: () => Promise<ReturnedFileData[]>;
-    private onOnlineChange;
-    private tryCleanupDeletedFiles;
-    private handleFileRefsDeleted;
-}
+import { FileData } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { Sync } from '../sync/Sync.js';
+import { EntityFile } from './EntityFile.js';
+import { ReturnedFileData } from './FileStorage.js';
+export interface FileManagerConfig {
+    /**
+     * Override the heuristic for deciding when a deleted file can be cleaned up.
+     * By default this waits 3 days since deletion, then deletes the file data.
+     * If the file has been synchronized to a server, it could still be restored
+     * if the server has not yet deleted it.
+     */
+    canCleanupDeletedFile?: (file: ReturnedFileData) => boolean;
+}
+export declare class FileManager {
+    private storage;
+    private sync;
+    private context;
+    private files;
+    private config;
+    private meta;
+    constructor({ db, sync, context, meta, config, }: {
+        db: IDBDatabase;
+        sync: Sync;
+        context: Context;
+        config?: FileManagerConfig;
+        meta: Metadata;
+    });
+    add: (fileInput: Omit<FileData, 'remote'>) => Promise<void>;
+    private uploadFile;
+    /**
+     * Immediately returns an EntityFile to use, then either loads
+     * the file from cache, local database, or the server.
+     */
+    get: (id: string) => EntityFile;
+    private load;
+    listUnsynced: () => Promise<ReturnedFileData[]>;
+    private onOnlineChange;
+    private tryCleanupDeletedFiles;
+    private handleFileRefsDeleted;
+}