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

package/dist/cjs/BackoffScheduler.d.ts

@@ -1,19 +1,19 @@
-import { EventSubscriber } from '@verdant-web/common';
-export declare class BackoffScheduler extends EventSubscriber<{
-    trigger: () => void;
-}> {
-    private readonly backoff;
-    private timer;
-    private isScheduled;
-    constructor(backoff: Backoff);
-    next: () => void;
-    reset: () => void;
-}
-export declare class Backoff {
-    current: number;
-    private readonly max;
-    private readonly factor;
-    constructor(max: number, factor: number);
-    next: () => void;
-    reset: () => void;
-}
+import { EventSubscriber } from '@verdant-web/common';
+export declare class BackoffScheduler extends EventSubscriber<{
+    trigger: () => void;
+}> {
+    private readonly backoff;
+    private timer;
+    private isScheduled;
+    constructor(backoff: Backoff);
+    next: () => void;
+    reset: () => void;
+}
+export declare class Backoff {
+    current: number;
+    private readonly max;
+    private readonly factor;
+    constructor(max: number, factor: number);
+    next: () => void;
+    reset: () => void;
+}

package/dist/cjs/BackoffScheduler.js

@@ -1,45 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Backoff = exports.BackoffScheduler = void 0;
-const common_1 = require("@verdant-web/common");
-class BackoffScheduler extends common_1.EventSubscriber {
-    constructor(backoff) {
-        super();
-        this.timer = null;
-        this.isScheduled = false;
-        this.next = () => {
-            if (!this.isScheduled) {
-                this.isScheduled = true;
-                this.timer = setTimeout(() => {
-                    this.emit('trigger');
-                    this.isScheduled = false;
-                    this.backoff.next();
-                }, this.backoff.current);
-            }
-        };
-        this.reset = () => {
-            this.backoff.reset();
-            if (this.timer) {
-                clearTimeout(this.timer);
-                this.timer = null;
-            }
-        };
-        this.backoff = backoff;
-    }
-}
-exports.BackoffScheduler = BackoffScheduler;
-class Backoff {
-    constructor(max, factor) {
-        this.current = 0;
-        this.next = () => {
-            this.current = Math.min(this.max, this.current * this.factor);
-        };
-        this.reset = () => {
-            this.current = 0;
-        };
-        this.max = max;
-        this.factor = factor;
-    }
-}
-exports.Backoff = Backoff;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Backoff = exports.BackoffScheduler = void 0;
+const common_1 = require("@verdant-web/common");
+class BackoffScheduler extends common_1.EventSubscriber {
+    constructor(backoff) {
+        super();
+        this.timer = null;
+        this.isScheduled = false;
+        this.next = () => {
+            if (!this.isScheduled) {
+                this.isScheduled = true;
+                this.timer = setTimeout(() => {
+                    this.emit('trigger');
+                    this.isScheduled = false;
+                    this.backoff.next();
+                }, this.backoff.current);
+            }
+        };
+        this.reset = () => {
+            this.backoff.reset();
+            if (this.timer) {
+                clearTimeout(this.timer);
+                this.timer = null;
+            }
+        };
+        this.backoff = backoff;
+    }
+}
+exports.BackoffScheduler = BackoffScheduler;
+class Backoff {
+    constructor(max, factor) {
+        this.current = 0;
+        this.next = () => {
+            this.current = Math.min(this.max, this.current * this.factor);
+        };
+        this.reset = () => {
+            this.current = 0;
+        };
+        this.max = max;
+        this.factor = factor;
+    }
+}
+exports.Backoff = Backoff;
 //# sourceMappingURL=BackoffScheduler.js.map

package/dist/cjs/DocumentManager.d.ts

@@ -1,31 +1,28 @@
-import { StorageSchema } from '@verdant-web/common';
-import { EntityStore } from './entities/EntityStore.js';
-import { Metadata } from './metadata/Metadata.js';
-/**
- * Exposes functionality for creating documents,
- * the only mutation which is available as an entry
- * point in the storage system.
- */
-export declare class DocumentManager<Schema extends StorageSchema<any>> {
-    private meta;
-    private schema;
-    private entities;
-    constructor(meta: Metadata, schema: Schema, entities: EntityStore);
-    private getOid;
-    private addDefaults;
-    create: (collection: string, init: any, options?: {
-        undoable?: boolean;
-    }) => Promise<any>;
-    delete: (collection: string, primaryKey: string, options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    deleteAll: (ids: [
-        string,
-        string
-    ][], options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    deleteAllFromCollection: (collection: string, ids: string[], options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-}
+import { StorageSchema } from '@verdant-web/common';
+import { EntityStore } from './entities/EntityStore.js';
+import { Metadata } from './metadata/Metadata.js';
+/**
+ * Exposes functionality for creating documents,
+ * the only mutation which is available as an entry
+ * point in the storage system.
+ */
+export declare class DocumentManager<Schema extends StorageSchema<any>> {
+    private meta;
+    private schema;
+    private entities;
+    constructor(meta: Metadata, schema: Schema, entities: EntityStore);
+    private getOid;
+    private addDefaults;
+    create: (collection: string, init: any, options?: {
+        undoable?: boolean;
+    }) => Promise<any>;
+    delete: (collection: string, primaryKey: string, options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    deleteAll: (ids: [string, string][], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    deleteAllFromCollection: (collection: string, ids: string[], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+}

package/dist/cjs/DocumentManager.js

@@ -1,45 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentManager = void 0;
-const common_1 = require("@verdant-web/common");
-/**
- * Exposes functionality for creating documents,
- * the only mutation which is available as an entry
- * point in the storage system.
- */
-class DocumentManager {
-    constructor(meta, schema, entities) {
-        this.meta = meta;
-        this.schema = schema;
-        this.entities = entities;
-        this.getOid = (collection, init) => {
-            const primaryKeyName = this.schema.collections[collection]
-                .primaryKey;
-            const primaryKey = init[primaryKeyName];
-            (0, common_1.assert)(primaryKey, `Document must have a primary key: ${primaryKeyName.toString()} (got: ${JSON.stringify(init)})`);
-            return (0, common_1.createOid)(collection, primaryKey);
-        };
-        this.addDefaults = (collectionName, init) => {
-            const collection = this.schema.collections[collectionName];
-            return (0, common_1.addFieldDefaults)(collection, init);
-        };
-        this.create = async (collection, init, options = {}) => {
-            const defaulted = this.addDefaults(collection, init);
-            const oid = this.getOid(collection, defaulted);
-            // documents are always objects at the root
-            return this.entities.create(defaulted, oid, options);
-        };
-        this.delete = async (collection, primaryKey, options = {}) => {
-            const oid = (0, common_1.createOid)(collection, primaryKey);
-            return this.entities.delete(oid, options);
-        };
-        this.deleteAll = async (ids, options = {}) => {
-            return this.entities.deleteAll(ids.map(([collection, primaryKey]) => (0, common_1.createOid)(collection, primaryKey)), options);
-        };
-        this.deleteAllFromCollection = async (collection, ids, options = {}) => {
-            return this.entities.deleteAll(ids.map((primaryKey) => (0, common_1.createOid)(collection, primaryKey)), options);
-        };
-    }
-}
-exports.DocumentManager = DocumentManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentManager = void 0;
+const common_1 = require("@verdant-web/common");
+/**
+ * Exposes functionality for creating documents,
+ * the only mutation which is available as an entry
+ * point in the storage system.
+ */
+class DocumentManager {
+    constructor(meta, schema, entities) {
+        this.meta = meta;
+        this.schema = schema;
+        this.entities = entities;
+        this.getOid = (collection, init) => {
+            const primaryKeyName = this.schema.collections[collection]
+                .primaryKey;
+            const primaryKey = init[primaryKeyName];
+            (0, common_1.assert)(primaryKey, `Document must have a primary key: ${primaryKeyName.toString()} (got: ${JSON.stringify(init)})`);
+            return (0, common_1.createOid)(collection, primaryKey);
+        };
+        this.addDefaults = (collectionName, init) => {
+            const collection = this.schema.collections[collectionName];
+            return (0, common_1.addFieldDefaults)(collection, init);
+        };
+        this.create = async (collection, init, options = {}) => {
+            const defaulted = this.addDefaults(collection, init);
+            const oid = this.getOid(collection, defaulted);
+            // documents are always objects at the root
+            return this.entities.create(defaulted, oid, options);
+        };
+        this.delete = async (collection, primaryKey, options = {}) => {
+            const oid = (0, common_1.createOid)(collection, primaryKey);
+            return this.entities.delete(oid, options);
+        };
+        this.deleteAll = async (ids, options = {}) => {
+            return this.entities.deleteAll(ids.map(([collection, primaryKey]) => (0, common_1.createOid)(collection, primaryKey)), options);
+        };
+        this.deleteAllFromCollection = async (collection, ids, options = {}) => {
+            return this.entities.deleteAll(ids.map((primaryKey) => (0, common_1.createOid)(collection, primaryKey)), options);
+        };
+    }
+}
+exports.DocumentManager = DocumentManager;
 //# sourceMappingURL=DocumentManager.js.map

package/dist/cjs/FakeWeakRef.d.ts

@@ -1,11 +1,11 @@
-/**
- * This exists since I'm a little anxious about using WeakRef in production
- * and want to be able to roll it back quickly to debug issues. Basically by adding
- * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
- * to using a simple object reference.
- */
-export declare class FakeWeakRef<T extends symbol | object> {
-    constructor(value: T);
-    value: T;
-    deref(): T | undefined;
-}
+/**
+ * This exists since I'm a little anxious about using WeakRef in production
+ * and want to be able to roll it back quickly to debug issues. Basically by adding
+ * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
+ * to using a simple object reference.
+ */
+export declare class FakeWeakRef<T extends symbol | object> {
+    constructor(value: T);
+    value: T;
+    deref(): T | undefined;
+}

package/dist/cjs/FakeWeakRef.js

@@ -1,19 +1,19 @@
-"use strict";
-/**
- * This exists since I'm a little anxious about using WeakRef in production
- * and want to be able to roll it back quickly to debug issues. Basically by adding
- * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
- * to using a simple object reference.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FakeWeakRef = void 0;
-class FakeWeakRef {
-    constructor(value) {
-        this.value = value;
-    }
-    deref() {
-        return this.value;
-    }
-}
-exports.FakeWeakRef = FakeWeakRef;
+"use strict";
+/**
+ * This exists since I'm a little anxious about using WeakRef in production
+ * and want to be able to roll it back quickly to debug issues. Basically by adding
+ * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
+ * to using a simple object reference.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeWeakRef = void 0;
+class FakeWeakRef {
+    constructor(value) {
+        this.value = value;
+    }
+    deref() {
+        return this.value;
+    }
+}
+exports.FakeWeakRef = FakeWeakRef;
 //# sourceMappingURL=FakeWeakRef.js.map

package/dist/cjs/IDBService.d.ts

@@ -1,9 +1,9 @@
-export declare class IDBService {
-    protected readonly db: IDBDatabase;
-    constructor(db: IDBDatabase);
-    createTransaction: (storeNames: string[], mode: 'readonly' | 'readwrite') => IDBTransaction;
-    run: <T>(storeName: string, getRequest: (store: IDBObjectStore) => IDBRequest<T>, mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<T>;
-    runAll: <T>(storeName: string, getRequests: (store: IDBObjectStore) => IDBRequest<T>[], mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<T[]>;
-    iterate: <T>(storeName: string, getRequest: (store: IDBObjectStore) => IDBRequest | IDBRequest[], iterator: (value: T, store: IDBObjectStore) => void, mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<void>;
-    clear: (storeName: string) => Promise<undefined>;
-}
+export declare class IDBService {
+    protected readonly db: IDBDatabase;
+    constructor(db: IDBDatabase);
+    createTransaction: (storeNames: string[], mode: 'readonly' | 'readwrite') => IDBTransaction;
+    run: <T>(storeName: string, getRequest: (store: IDBObjectStore) => IDBRequest<T>, mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<T>;
+    runAll: <T>(storeName: string, getRequests: (store: IDBObjectStore) => IDBRequest<T>[], mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<T[]>;
+    iterate: <T>(storeName: string, getRequest: (store: IDBObjectStore) => IDBRequest | IDBRequest[], iterator: (value: T, store: IDBObjectStore) => void, mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<void>;
+    clear: (storeName: string) => Promise<undefined>;
+}

package/dist/cjs/IDBService.js

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IDBService = void 0;
-const idb_js_1 = require("./idb.js");
-class IDBService {
-    constructor(db) {
-        this.db = db;
-        this.createTransaction = (storeNames, mode) => {
-            return this.db.transaction(storeNames, mode);
-        };
-        this.run = async (storeName, getRequest, mode = 'readonly', transaction) => {
-            const tx = transaction || this.db.transaction(storeName, mode);
-            const store = tx.objectStore(storeName);
-            const request = getRequest(store);
-            return (0, idb_js_1.storeRequestPromise)(request);
-        };
-        this.runAll = async (storeName, getRequests, mode = 'readonly', transaction) => {
-            const tx = transaction || this.db.transaction(storeName, mode);
-            const store = tx.objectStore(storeName);
-            const requests = getRequests(store);
-            return Promise.all(requests.map(idb_js_1.storeRequestPromise));
-        };
-        this.iterate = async (storeName, getRequest, iterator, mode = 'readonly', transaction) => {
-            const tx = transaction || this.db.transaction(storeName, mode);
-            const store = tx.objectStore(storeName);
-            const request = getRequest(store);
-            if (Array.isArray(request)) {
-                return Promise.all(request.map((req) => {
-                    return new Promise((resolve, reject) => {
-                        req.onsuccess = () => {
-                            const cursor = req.result;
-                            if (cursor) {
-                                iterator(cursor.value, store);
-                                cursor.continue();
-                            }
-                            else {
-                                resolve();
-                            }
-                        };
-                        req.onerror = reject;
-                    });
-                })).then(() => undefined);
-            }
-            return new Promise((resolve, reject) => {
-                request.onsuccess = () => {
-                    const cursor = request.result;
-                    if (cursor) {
-                        iterator(cursor.value, store);
-                        cursor.continue();
-                    }
-                    else {
-                        resolve();
-                    }
-                };
-                request.onerror = reject;
-            });
-        };
-        this.clear = (storeName) => {
-            return this.run(storeName, (store) => store.clear(), 'readwrite');
-        };
-    }
-}
-exports.IDBService = IDBService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDBService = void 0;
+const idb_js_1 = require("./idb.js");
+class IDBService {
+    constructor(db) {
+        this.db = db;
+        this.createTransaction = (storeNames, mode) => {
+            return this.db.transaction(storeNames, mode);
+        };
+        this.run = async (storeName, getRequest, mode = 'readonly', transaction) => {
+            const tx = transaction || this.db.transaction(storeName, mode);
+            const store = tx.objectStore(storeName);
+            const request = getRequest(store);
+            return (0, idb_js_1.storeRequestPromise)(request);
+        };
+        this.runAll = async (storeName, getRequests, mode = 'readonly', transaction) => {
+            const tx = transaction || this.db.transaction(storeName, mode);
+            const store = tx.objectStore(storeName);
+            const requests = getRequests(store);
+            return Promise.all(requests.map(idb_js_1.storeRequestPromise));
+        };
+        this.iterate = async (storeName, getRequest, iterator, mode = 'readonly', transaction) => {
+            const tx = transaction || this.db.transaction(storeName, mode);
+            const store = tx.objectStore(storeName);
+            const request = getRequest(store);
+            if (Array.isArray(request)) {
+                return Promise.all(request.map((req) => {
+                    return new Promise((resolve, reject) => {
+                        req.onsuccess = () => {
+                            const cursor = req.result;
+                            if (cursor) {
+                                iterator(cursor.value, store);
+                                cursor.continue();
+                            }
+                            else {
+                                resolve();
+                            }
+                        };
+                        req.onerror = reject;
+                    });
+                })).then(() => undefined);
+            }
+            return new Promise((resolve, reject) => {
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        iterator(cursor.value, store);
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                request.onerror = reject;
+            });
+        };
+        this.clear = (storeName) => {
+            return this.run(storeName, (store) => store.clear(), 'readwrite');
+        };
+    }
+}
+exports.IDBService = IDBService;
 //# sourceMappingURL=IDBService.js.map

package/dist/cjs/UndoHistory.d.ts

@@ -1,16 +1,16 @@
-import { EventSubscriber } from '@verdant-web/common';
-type Undoable = () => Undoable | Promise<Undoable>;
-export declare class UndoHistory extends EventSubscriber<{
-    change: () => void;
-}> {
-    private _undoable;
-    private _undone;
-    get canUndo(): boolean;
-    get canRedo(): boolean;
-    undo: () => Promise<boolean>;
-    redo: () => Promise<boolean>;
-    addUndo: (undoPoint: Undoable) => void;
-    addRedo: (redoPoint: Undoable) => void;
-    clear: () => void;
-}
-export {};
+import { EventSubscriber } from '@verdant-web/common';
+type Undoable = () => Undoable | Promise<Undoable>;
+export declare class UndoHistory extends EventSubscriber<{
+    change: () => void;
+}> {
+    private _undoable;
+    private _undone;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    addUndo: (undoPoint: Undoable) => void;
+    addRedo: (redoPoint: Undoable) => void;
+    clear: () => void;
+}
+export {};

package/dist/cjs/UndoHistory.js

@@ -1,51 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UndoHistory = void 0;
-const common_1 = require("@verdant-web/common");
-class UndoHistory extends common_1.EventSubscriber {
-    constructor() {
-        super(...arguments);
-        this._undoable = [];
-        this._undone = [];
-        this.undo = async () => {
-            const next = this._undoable.pop();
-            if (next) {
-                this._undone.push(await next());
-                this.emit('change');
-                return true;
-            }
-            return false;
-        };
-        this.redo = async () => {
-            const next = this._undone.pop();
-            if (next) {
-                this._undoable.push(await next());
-                this.emit('change');
-                return true;
-            }
-            return false;
-        };
-        this.addUndo = (undoPoint) => {
-            this._undoable.push(undoPoint);
-            this._undone = [];
-            this.emit('change');
-        };
-        this.addRedo = (redoPoint) => {
-            this._undone.push(redoPoint);
-            this.emit('change');
-        };
-        this.clear = () => {
-            this._undoable = [];
-            this._undone = [];
-            this.emit('change');
-        };
-    }
-    get canUndo() {
-        return this._undoable.length > 0;
-    }
-    get canRedo() {
-        return this._undone.length > 0;
-    }
-}
-exports.UndoHistory = UndoHistory;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndoHistory = void 0;
+const common_1 = require("@verdant-web/common");
+class UndoHistory extends common_1.EventSubscriber {
+    constructor() {
+        super(...arguments);
+        this._undoable = [];
+        this._undone = [];
+        this.undo = async () => {
+            const next = this._undoable.pop();
+            if (next) {
+                this._undone.push(await next());
+                this.emit('change');
+                return true;
+            }
+            return false;
+        };
+        this.redo = async () => {
+            const next = this._undone.pop();
+            if (next) {
+                this._undoable.push(await next());
+                this.emit('change');
+                return true;
+            }
+            return false;
+        };
+        this.addUndo = (undoPoint) => {
+            this._undoable.push(undoPoint);
+            this._undone = [];
+            this.emit('change');
+        };
+        this.addRedo = (redoPoint) => {
+            this._undone.push(redoPoint);
+            this.emit('change');
+        };
+        this.clear = () => {
+            this._undoable = [];
+            this._undone = [];
+            this.emit('change');
+        };
+    }
+    get canUndo() {
+        return this._undoable.length > 0;
+    }
+    get canRedo() {
+        return this._undone.length > 0;
+    }
+}
+exports.UndoHistory = UndoHistory;
 //# sourceMappingURL=UndoHistory.js.map

package/dist/cjs/__tests__/batching.test.d.ts

@@ -1 +1 @@
-export {};
+export {};