@verdant-web/store 2.0.1 → 2.0.2

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,28 +1,28 @@
-import { StorageSchema } from '@verdant-web/common';
-import { EntityStore } from './reactives/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 './reactives/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/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, 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, iterator: (value: T, store: IDBObjectStore) => void, mode?: 'readonly' | 'readwrite', transaction?: IDBTransaction) => Promise<void>;
+    clear: (storeName: string) => Promise<undefined>;
+}

package/dist/cjs/IDBService.js

@@ -1,47 +1,47 @@
-"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);
-            return new Promise((resolve, reject) => {
-                request.onsuccess = (event) => {
-                    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);
+            return new Promise((resolve, reject) => {
+                request.onsuccess = (event) => {
+                    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 {};

package/dist/cjs/__tests__/batching.test.js

@@ -1,45 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const testStorage_js_1 = require("./fixtures/testStorage.js");
-(0, vitest_1.describe)('batching operations', () => {
-    (0, vitest_1.it)('should allow multiple runs with manual flush', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const item = await storage.todos.put({
-            content: 'hello world',
-            category: 'general',
-            attachments: [
-                {
-                    name: 'thing',
-                },
-            ],
-        });
-        // disable timeout for manual control
-        const batch = storage.batch({ timeout: null });
-        batch.run(() => {
-            item.set('content', 'hello world 2');
-            item.set('category', 'never');
-        });
-        // fake some async work
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        batch.run(() => {
-            item.set('content', 'hello world 3');
-            item.set('category', 'general');
-            item.get('attachments').push({ name: 'other thing' });
-        });
-        await batch.flush();
-        (0, vitest_1.expect)(item.get('content')).toBe('hello world 3');
-        (0, vitest_1.expect)(item.get('category')).toBe('general');
-        (0, vitest_1.expect)(item.get('attachments').length).toBe(2);
-        (0, vitest_1.expect)(storage.undoHistory.canUndo).toBe(true);
-        await storage.undoHistory.undo();
-        (0, vitest_1.expect)(item.get('content')).toBe('hello world');
-        (0, vitest_1.expect)(item.get('category')).toBe('general');
-        (0, vitest_1.expect)(item.get('attachments').length).toBe(1);
-        // the next undo will undo the creation
-        await storage.undoHistory.undo();
-        (0, vitest_1.expect)(storage.undoHistory.canUndo).toBe(false);
-        (0, vitest_1.expect)(item.deleted).toBe(true);
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const testStorage_js_1 = require("./fixtures/testStorage.js");
+(0, vitest_1.describe)('batching operations', () => {
+    (0, vitest_1.it)('should allow multiple runs with manual flush', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const item = await storage.todos.put({
+            content: 'hello world',
+            category: 'general',
+            attachments: [
+                {
+                    name: 'thing',
+                },
+            ],
+        });
+        // disable timeout for manual control
+        const batch = storage.batch({ timeout: null });
+        batch.run(() => {
+            item.set('content', 'hello world 2');
+            item.set('category', 'never');
+        });
+        // fake some async work
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        batch.run(() => {
+            item.set('content', 'hello world 3');
+            item.set('category', 'general');
+            item.get('attachments').push({ name: 'other thing' });
+        });
+        await batch.flush();
+        (0, vitest_1.expect)(item.get('content')).toBe('hello world 3');
+        (0, vitest_1.expect)(item.get('category')).toBe('general');
+        (0, vitest_1.expect)(item.get('attachments').length).toBe(2);
+        (0, vitest_1.expect)(storage.undoHistory.canUndo).toBe(true);
+        await storage.undoHistory.undo();
+        (0, vitest_1.expect)(item.get('content')).toBe('hello world');
+        (0, vitest_1.expect)(item.get('category')).toBe('general');
+        (0, vitest_1.expect)(item.get('attachments').length).toBe(1);
+        // the next undo will undo the creation
+        await storage.undoHistory.undo();
+        (0, vitest_1.expect)(storage.undoHistory.canUndo).toBe(false);
+        (0, vitest_1.expect)(item.deleted).toBe(true);
+    });
+});
 //# sourceMappingURL=batching.test.js.map

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

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