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

package/dist/esm/metadata/OperationsStore.d.ts

@@ -1,53 +1,53 @@
-import { ObjectIdentifier, Operation } from '@verdant-web/common';
-import { IDBService } from '../IDBService.js';
-export type ClientOperation = Operation & {
-    isLocal: boolean;
-};
-export type StoredClientOperation = ClientOperation & {
-    oid_timestamp: string;
-    l_t: string;
-    d_t: string;
-};
-export declare class OperationsStore extends IDBService {
-    /**
-     * Iterates over every patch for the root and every sub-object
-     * of a given document. Optionally limit by timestamp.
-     */
-    iterateOverAllOperationsForDocument: (oid: ObjectIdentifier, iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void, { to, from, after, mode, transaction: providedTx, }?: {
-        to?: string | undefined;
-        from?: string | undefined;
-        after?: string | undefined;
-        mode?: "readonly" | "readwrite" | undefined;
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<void>;
-    iterateOverAllOperationsForEntity: (oid: ObjectIdentifier, iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void, { after, to, mode, transaction: providedTx, }: {
-        after?: string | undefined;
-        to?: string | undefined;
-        mode?: "readonly" | "readwrite" | undefined;
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<void>;
-    iterateOverAllLocalOperations: (iterator: (patch: ClientOperation, store: IDBObjectStore) => void, { before, after, mode, transaction: providedTx, }: {
-        before?: string | null | undefined;
-        after?: string | null | undefined;
-        mode?: "readonly" | "readwrite" | undefined;
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<void>;
-    iterateOverAllOperations: (iterator: (patch: ClientOperation, store: IDBObjectStore) => void, { before, transaction, mode, from, }: {
-        /** Ending timestamp, exclusive */
-        before?: string | null | undefined;
-        /** Starting timestamp, inclusive */
-        from?: string | null | undefined;
-        transaction?: IDBTransaction | undefined;
-        mode?: "readonly" | "readwrite" | undefined;
-    }) => Promise<void>;
-    /**
-     * Adds a set of patches to the database.
-     * @returns a list of affected root document OIDs.
-     */
-    addOperations: (patches: ClientOperation[], { transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<ObjectIdentifier[]>;
-    private addCompoundIndexes;
-    private insert;
-    reset: () => Promise<undefined>;
-}
+import { ObjectIdentifier, Operation } from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+export type ClientOperation = Operation & {
+    isLocal: boolean;
+};
+export type StoredClientOperation = ClientOperation & {
+    oid_timestamp: string;
+    l_t: string;
+    d_t: string;
+};
+export declare class OperationsStore extends IDBService {
+    /**
+     * Iterates over every patch for the root and every sub-object
+     * of a given document. Optionally limit by timestamp.
+     */
+    iterateOverAllOperationsForDocument: (oid: ObjectIdentifier, iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void, { to, from, after, mode, transaction: providedTx, }?: {
+        to?: string | undefined;
+        from?: string | undefined;
+        after?: string | undefined;
+        mode?: "readonly" | "readwrite" | undefined;
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    iterateOverAllOperationsForEntity: (oid: ObjectIdentifier, iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void, { after, to, mode, transaction: providedTx, }: {
+        after?: string | undefined;
+        to?: string | undefined;
+        mode?: "readonly" | "readwrite" | undefined;
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    iterateOverAllLocalOperations: (iterator: (patch: ClientOperation, store: IDBObjectStore) => void, { before, after, mode, transaction: providedTx, }: {
+        before?: string | null | undefined;
+        after?: string | null | undefined;
+        mode?: "readonly" | "readwrite" | undefined;
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    iterateOverAllOperations: (iterator: (patch: ClientOperation, store: IDBObjectStore) => void, { before, transaction, mode, from, }: {
+        /** Ending timestamp, exclusive */
+        before?: string | null | undefined;
+        /** Starting timestamp, inclusive */
+        from?: string | null | undefined;
+        transaction?: IDBTransaction | undefined;
+        mode?: "readonly" | "readwrite" | undefined;
+    }) => Promise<void>;
+    /**
+     * Adds a set of patches to the database.
+     * @returns a list of affected root document OIDs.
+     */
+    addOperations: (patches: ClientOperation[], { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<ObjectIdentifier[]>;
+    private addCompoundIndexes;
+    private insert;
+    reset: () => Promise<undefined>;
+}

package/dist/esm/metadata/OperationsStore.js

@@ -1,149 +1,149 @@
-import { createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, getOidRoot, assert, } from '@verdant-web/common';
-import { IDBService } from '../IDBService.js';
-export class OperationsStore extends IDBService {
-    constructor() {
-        super(...arguments);
-        /**
-         * Iterates over every patch for the root and every sub-object
-         * of a given document. Optionally limit by timestamp.
-         */
-        this.iterateOverAllOperationsForDocument = async (oid, iterator, { to, from, after, mode = 'readonly', transaction: providedTx, } = {}) => {
-            const transaction = providedTx || this.db.transaction('operations', mode);
-            const store = transaction.objectStore('operations');
-            const index = store.index('d_t');
-            const startTimestamp = from || after;
-            const start = startTimestamp
-                ? createCompoundIndexValue(oid, startTimestamp)
-                : createLowerBoundIndexValue(oid);
-            const end = to
-                ? createCompoundIndexValue(oid, to)
-                : createUpperBoundIndexValue(oid);
-            const range = IDBKeyRange.bound(start, end, !!after, false);
-            const request = index.openCursor(range, 'next');
-            return new Promise((resolve, reject) => {
-                let previousTimestamp;
-                request.onsuccess = (event) => {
-                    const cursor = request.result;
-                    if (cursor) {
-                        const value = cursor.value;
-                        assert(value.oid.startsWith(oid));
-                        assert(previousTimestamp === undefined ||
-                            previousTimestamp <= value.timestamp, `expected ${previousTimestamp} <= ${value.timestamp}`);
-                        iterator(value, store);
-                        previousTimestamp = value.timestamp;
-                        cursor.continue();
-                    }
-                    else {
-                        resolve();
-                    }
-                };
-                request.onerror = (event) => {
-                    reject(event);
-                };
-            });
-        };
-        this.iterateOverAllOperationsForEntity = async (oid, iterator, { after, to, mode, transaction: providedTx, }) => {
-            const transaction = providedTx || this.db.transaction('operations', mode);
-            const store = transaction.objectStore('operations');
-            const start = after
-                ? createCompoundIndexValue(oid, after)
-                : createLowerBoundIndexValue(oid);
-            const end = to
-                ? createCompoundIndexValue(oid, to)
-                : createUpperBoundIndexValue(oid);
-            const range = IDBKeyRange.bound(start, end, !!after, false);
-            const request = store.openCursor(range, 'next');
-            return new Promise((resolve, reject) => {
-                let previousTimestamp;
-                request.onsuccess = (event) => {
-                    const cursor = request.result;
-                    if (cursor) {
-                        const value = cursor.value;
-                        assert(value.oid.startsWith(oid));
-                        assert(previousTimestamp === undefined ||
-                            previousTimestamp <= value.timestamp, `expected ${previousTimestamp} <= ${value.timestamp}`);
-                        iterator(value, store);
-                        previousTimestamp = value.timestamp;
-                        cursor.continue();
-                    }
-                    else {
-                        resolve();
-                    }
-                };
-                request.onerror = (event) => {
-                    reject(event);
-                };
-            });
-        };
-        this.iterateOverAllLocalOperations = async (iterator, { before, after, mode = 'readonly', transaction: providedTx, }) => {
-            const transaction = providedTx || this.db.transaction('operations', mode);
-            const store = transaction.objectStore('operations');
-            const index = store.index('l_t');
-            const start = after
-                ? createCompoundIndexValue(true, after)
-                : createLowerBoundIndexValue(true);
-            const end = before
-                ? createCompoundIndexValue(true, before)
-                : createUpperBoundIndexValue(true);
-            const range = IDBKeyRange.bound(start, end, !!after, true);
-            const request = index.openCursor(range, 'next');
-            return new Promise((resolve, reject) => {
-                let previousTimestamp;
-                request.onsuccess = (event) => {
-                    const cursor = request.result;
-                    if (cursor) {
-                        const value = cursor.value;
-                        assert(previousTimestamp === undefined ||
-                            previousTimestamp <= value.timestamp, `expected ${previousTimestamp} <= ${value.timestamp}`);
-                        iterator(value, store);
-                        previousTimestamp = value.timestamp;
-                        cursor.continue();
-                    }
-                    else {
-                        resolve();
-                    }
-                };
-                request.onerror = (event) => {
-                    reject(event);
-                };
-            });
-        };
-        this.iterateOverAllOperations = async (iterator, { before, transaction, mode, from, }) => {
-            await this.iterate('operations', (store) => {
-                const start = from ? createLowerBoundIndexValue(from) : undefined;
-                const end = before ? createUpperBoundIndexValue(before) : undefined;
-                const range = start && end
-                    ? IDBKeyRange.bound(start, end, false, true)
-                    : start
-                        ? IDBKeyRange.lowerBound(start, false)
-                        : end
-                            ? IDBKeyRange.upperBound(end, true)
-                            : undefined;
-                const index = store.index('timestamp');
-                return index.openCursor(range, 'next');
-            }, iterator, mode, transaction);
-        };
-        /**
-         * Adds a set of patches to the database.
-         * @returns a list of affected root document OIDs.
-         */
-        this.addOperations = async (patches, { transaction } = {}) => {
-            return this.insert(patches.map(this.addCompoundIndexes), { transaction });
-        };
-        this.addCompoundIndexes = (patch) => {
-            return Object.assign(Object.assign({}, patch), { oid_timestamp: createCompoundIndexValue(patch.oid, patch.timestamp), l_t: createCompoundIndexValue(patch.isLocal, patch.timestamp), d_t: createCompoundIndexValue(getOidRoot(patch.oid), patch.timestamp) });
-        };
-        this.insert = async (operations, { transaction }) => {
-            const affected = new Set();
-            await this.runAll('operations', (store) => operations.map((op) => {
-                affected.add(getOidRoot(op.oid));
-                return store.put(op);
-            }), 'readwrite', transaction);
-            return Array.from(affected);
-        };
-        this.reset = () => {
-            return this.clear('operations');
-        };
-    }
-}
+import { createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, getOidRoot, assert, } from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+export class OperationsStore extends IDBService {
+    constructor() {
+        super(...arguments);
+        /**
+         * Iterates over every patch for the root and every sub-object
+         * of a given document. Optionally limit by timestamp.
+         */
+        this.iterateOverAllOperationsForDocument = async (oid, iterator, { to, from, after, mode = 'readonly', transaction: providedTx, } = {}) => {
+            const transaction = providedTx || this.db.transaction('operations', mode);
+            const store = transaction.objectStore('operations');
+            const index = store.index('d_t');
+            const startTimestamp = from || after;
+            const start = startTimestamp
+                ? createCompoundIndexValue(oid, startTimestamp)
+                : createLowerBoundIndexValue(oid);
+            const end = to
+                ? createCompoundIndexValue(oid, to)
+                : createUpperBoundIndexValue(oid);
+            const range = IDBKeyRange.bound(start, end, !!after, false);
+            const request = index.openCursor(range, 'next');
+            return new Promise((resolve, reject) => {
+                let previousTimestamp;
+                request.onsuccess = (event) => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        const value = cursor.value;
+                        assert(value.oid.startsWith(oid));
+                        assert(previousTimestamp === undefined ||
+                            previousTimestamp <= value.timestamp, `expected ${previousTimestamp} <= ${value.timestamp}`);
+                        iterator(value, store);
+                        previousTimestamp = value.timestamp;
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                request.onerror = (event) => {
+                    reject(event);
+                };
+            });
+        };
+        this.iterateOverAllOperationsForEntity = async (oid, iterator, { after, to, mode, transaction: providedTx, }) => {
+            const transaction = providedTx || this.db.transaction('operations', mode);
+            const store = transaction.objectStore('operations');
+            const start = after
+                ? createCompoundIndexValue(oid, after)
+                : createLowerBoundIndexValue(oid);
+            const end = to
+                ? createCompoundIndexValue(oid, to)
+                : createUpperBoundIndexValue(oid);
+            const range = IDBKeyRange.bound(start, end, !!after, false);
+            const request = store.openCursor(range, 'next');
+            return new Promise((resolve, reject) => {
+                let previousTimestamp;
+                request.onsuccess = (event) => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        const value = cursor.value;
+                        assert(value.oid.startsWith(oid));
+                        assert(previousTimestamp === undefined ||
+                            previousTimestamp <= value.timestamp, `expected ${previousTimestamp} <= ${value.timestamp}`);
+                        iterator(value, store);
+                        previousTimestamp = value.timestamp;
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                request.onerror = (event) => {
+                    reject(event);
+                };
+            });
+        };
+        this.iterateOverAllLocalOperations = async (iterator, { before, after, mode = 'readonly', transaction: providedTx, }) => {
+            const transaction = providedTx || this.db.transaction('operations', mode);
+            const store = transaction.objectStore('operations');
+            const index = store.index('l_t');
+            const start = after
+                ? createCompoundIndexValue(true, after)
+                : createLowerBoundIndexValue(true);
+            const end = before
+                ? createCompoundIndexValue(true, before)
+                : createUpperBoundIndexValue(true);
+            const range = IDBKeyRange.bound(start, end, !!after, true);
+            const request = index.openCursor(range, 'next');
+            return new Promise((resolve, reject) => {
+                let previousTimestamp;
+                request.onsuccess = (event) => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        const value = cursor.value;
+                        assert(previousTimestamp === undefined ||
+                            previousTimestamp <= value.timestamp, `expected ${previousTimestamp} <= ${value.timestamp}`);
+                        iterator(value, store);
+                        previousTimestamp = value.timestamp;
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                request.onerror = (event) => {
+                    reject(event);
+                };
+            });
+        };
+        this.iterateOverAllOperations = async (iterator, { before, transaction, mode, from, }) => {
+            await this.iterate('operations', (store) => {
+                const start = from ? createLowerBoundIndexValue(from) : undefined;
+                const end = before ? createUpperBoundIndexValue(before) : undefined;
+                const range = start && end
+                    ? IDBKeyRange.bound(start, end, false, true)
+                    : start
+                        ? IDBKeyRange.lowerBound(start, false)
+                        : end
+                            ? IDBKeyRange.upperBound(end, true)
+                            : undefined;
+                const index = store.index('timestamp');
+                return index.openCursor(range, 'next');
+            }, iterator, mode, transaction);
+        };
+        /**
+         * Adds a set of patches to the database.
+         * @returns a list of affected root document OIDs.
+         */
+        this.addOperations = async (patches, { transaction } = {}) => {
+            return this.insert(patches.map(this.addCompoundIndexes), { transaction });
+        };
+        this.addCompoundIndexes = (patch) => {
+            return Object.assign(Object.assign({}, patch), { oid_timestamp: createCompoundIndexValue(patch.oid, patch.timestamp), l_t: createCompoundIndexValue(patch.isLocal, patch.timestamp), d_t: createCompoundIndexValue(getOidRoot(patch.oid), patch.timestamp) });
+        };
+        this.insert = async (operations, { transaction }) => {
+            const affected = new Set();
+            await this.runAll('operations', (store) => operations.map((op) => {
+                affected.add(getOidRoot(op.oid));
+                return store.put(op);
+            }), 'readwrite', transaction);
+            return Array.from(affected);
+        };
+        this.reset = () => {
+            return this.clear('operations');
+        };
+    }
+}
 //# sourceMappingURL=OperationsStore.js.map

package/dist/esm/metadata/SchemaStore.d.ts

@@ -1,9 +1,9 @@
-import { StorageSchema } from '@verdant-web/common';
-export declare class SchemaStore {
-    private readonly db;
-    readonly currentVersion: number;
-    private cached;
-    constructor(db: IDBDatabase, currentVersion: number);
-    get: () => Promise<StorageSchema<any> | null>;
-    set: (schema: StorageSchema<any>) => Promise<void>;
-}
+import { StorageSchema } from '@verdant-web/common';
+export declare class SchemaStore {
+    private readonly db;
+    readonly currentVersion: number;
+    private cached;
+    constructor(db: IDBDatabase, currentVersion: number);
+    get: () => Promise<StorageSchema<any> | null>;
+    set: (schema: StorageSchema<any>) => Promise<void>;
+}

package/dist/esm/metadata/SchemaStore.js

@@ -1,35 +1,35 @@
-import { storeRequestPromise } from '../idb.js';
-export class SchemaStore {
-    constructor(db, currentVersion) {
-        this.db = db;
-        this.currentVersion = currentVersion;
-        this.cached = null;
-        this.get = async () => {
-            if (this.cached) {
-                return this.cached;
-            }
-            const db = this.db;
-            const transaction = db.transaction('info', 'readonly');
-            const store = transaction.objectStore('info');
-            const request = store.get('schema');
-            const value = (await storeRequestPromise(request));
-            if (!value) {
-                return null;
-            }
-            this.cached = JSON.parse(value.schema);
-            return this.cached;
-        };
-        this.set = async (schema) => {
-            const db = this.db;
-            const transaction = db.transaction('info', 'readwrite');
-            const store = transaction.objectStore('info');
-            const request = store.put({
-                type: 'schema',
-                schema: JSON.stringify(schema),
-            });
-            this.cached = schema;
-            await storeRequestPromise(request);
-        };
-    }
-}
+import { storeRequestPromise } from '../idb.js';
+export class SchemaStore {
+    constructor(db, currentVersion) {
+        this.db = db;
+        this.currentVersion = currentVersion;
+        this.cached = null;
+        this.get = async () => {
+            if (this.cached) {
+                return this.cached;
+            }
+            const db = this.db;
+            const transaction = db.transaction('info', 'readonly');
+            const store = transaction.objectStore('info');
+            const request = store.get('schema');
+            const value = (await storeRequestPromise(request));
+            if (!value) {
+                return null;
+            }
+            this.cached = JSON.parse(value.schema);
+            return this.cached;
+        };
+        this.set = async (schema) => {
+            const db = this.db;
+            const transaction = db.transaction('info', 'readwrite');
+            const store = transaction.objectStore('info');
+            const request = store.put({
+                type: 'schema',
+                schema: JSON.stringify(schema),
+            });
+            this.cached = schema;
+            await storeRequestPromise(request);
+        };
+    }
+}
 //# sourceMappingURL=SchemaStore.js.map

package/dist/esm/metadata/openMetadataDatabase.d.ts

@@ -1,17 +1,19 @@
-export declare function openMetadataDatabase({ indexedDB, namespace, log, }: {
-    indexedDB?: IDBFactory;
-    namespace: string;
-    log?: (...args: any[]) => void;
-}): Promise<{
-    wasInitialized: boolean;
-    db: IDBDatabase;
-}>;
-export declare function openWIPMetadataDatabase({ wipNamespace, namespace, indexedDB, log, }: {
-    indexedDB?: IDBFactory;
-    namespace: string;
-    wipNamespace: string;
-    log?: (...args: any[]) => void;
-}): Promise<{
-    wasInitialized: boolean;
-    db: IDBDatabase;
-}>;
+export declare function openMetadataDatabase({ indexedDB, namespace, log, metadataVersion, }: {
+    indexedDB?: IDBFactory;
+    namespace: string;
+    log?: (...args: any[]) => void;
+    metadataVersion?: number;
+}): Promise<{
+    wasInitialized: boolean;
+    db: IDBDatabase;
+}>;
+export declare function openWIPMetadataDatabase({ wipNamespace, namespace, indexedDB, log, metadataVersion, }: {
+    indexedDB?: IDBFactory;
+    namespace: string;
+    wipNamespace: string;
+    log?: (...args: any[]) => void;
+    metadataVersion?: number;
+}): Promise<{
+    wasInitialized: boolean;
+    db: IDBDatabase;
+}>;