@verdant-web/store 2.0.1 → 2.0.2

package/dist/cjs/client/ClientDescriptor.js

@@ -1,109 +1,109 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientDescriptor = void 0;
-const common_1 = require("@verdant-web/common");
-const Metadata_js_1 = require("../metadata/Metadata.js");
-const openMetadataDatabase_js_1 = require("../metadata/openMetadataDatabase.js");
-const openDocumentDatabase_js_1 = require("../openDocumentDatabase.js");
-const UndoHistory_js_1 = require("../UndoHistory.js");
-const Client_js_1 = require("./Client.js");
-/**
- * Since storage initialization is async, this class wraps the core
- * Storage creation promise and exposes some metadata which can
- * be useful immediately.
- */
-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 (0, openMetadataDatabase_js_1.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_js_1.UndoHistory(),
-                    entityEvents: new common_1.EventSubscriber(),
-                };
-                const meta = new Metadata_js_1.Metadata({
-                    context,
-                    disableRebasing: init.disableRebasing,
-                });
-                // verify schema integrity
-                await meta.updateSchema(init.schema, init.overrideSchemaConflict);
-                const documentDb = await (0, openDocumentDatabase_js_1.openDocumentDatabase)({
-                    context,
-                    version: init.schema.version,
-                    meta,
-                    migrations: init.migrations,
-                    indexedDB: init.indexedDb,
-                });
-                const fullContext = Object.assign(context, { documentDb });
-                const storage = new Client_js_1.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;
-    }
-}
-exports.ClientDescriptor = ClientDescriptor;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDescriptor = void 0;
+const common_1 = require("@verdant-web/common");
+const Metadata_js_1 = require("../metadata/Metadata.js");
+const openMetadataDatabase_js_1 = require("../metadata/openMetadataDatabase.js");
+const openDocumentDatabase_js_1 = require("../openDocumentDatabase.js");
+const UndoHistory_js_1 = require("../UndoHistory.js");
+const Client_js_1 = require("./Client.js");
+/**
+ * Since storage initialization is async, this class wraps the core
+ * Storage creation promise and exposes some metadata which can
+ * be useful immediately.
+ */
+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 (0, openMetadataDatabase_js_1.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_js_1.UndoHistory(),
+                    entityEvents: new common_1.EventSubscriber(),
+                };
+                const meta = new Metadata_js_1.Metadata({
+                    context,
+                    disableRebasing: init.disableRebasing,
+                });
+                // verify schema integrity
+                await meta.updateSchema(init.schema, init.overrideSchemaConflict);
+                const documentDb = await (0, openDocumentDatabase_js_1.openDocumentDatabase)({
+                    context,
+                    version: init.schema.version,
+                    meta,
+                    migrations: init.migrations,
+                    indexedDB: init.indexedDb,
+                });
+                const fullContext = Object.assign(context, { documentDb });
+                const storage = new Client_js_1.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;
+    }
+}
+exports.ClientDescriptor = ClientDescriptor;
 //# sourceMappingURL=ClientDescriptor.js.map

package/dist/cjs/constants.d.ts

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

package/dist/cjs/constants.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEST_API = void 0;
-exports.TEST_API = '__unsafe__test_api__';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_API = void 0;
+exports.TEST_API = '__unsafe__test_api__';
 //# sourceMappingURL=constants.js.map

package/dist/cjs/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/cjs/context.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=context.js.map

package/dist/cjs/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/cjs/files/EntityFile.js

@@ -1,72 +1,72 @@
-"use strict";
-var _a, _b;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityFile = exports.MARK_FAILED = exports.UPDATE = void 0;
-const common_1 = require("@verdant-web/common");
-exports.UPDATE = Symbol('entity-file-update');
-exports.MARK_FAILED = Symbol('entity-file-mark-failed');
-/**
- * Provides a consistent interface for files used in an app via
- * Entity access.
- */
-class EntityFile extends common_1.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;
-    }
-}
-exports.EntityFile = EntityFile;
-_a = exports.UPDATE, _b = exports.MARK_FAILED;
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityFile = exports.MARK_FAILED = exports.UPDATE = void 0;
+const common_1 = require("@verdant-web/common");
+exports.UPDATE = Symbol('entity-file-update');
+exports.MARK_FAILED = Symbol('entity-file-mark-failed');
+/**
+ * Provides a consistent interface for files used in an app via
+ * Entity access.
+ */
+class EntityFile extends common_1.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;
+    }
+}
+exports.EntityFile = EntityFile;
+_a = exports.UPDATE, _b = exports.MARK_FAILED;
 //# sourceMappingURL=EntityFile.js.map

package/dist/cjs/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;
+}