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

package/dist/esm/BackoffScheduler.js

@@ -1,40 +1,40 @@
-import { EventSubscriber } from '@verdant-web/common';
-export class BackoffScheduler extends 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;
-    }
-}
-export 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;
-    }
-}
+import { EventSubscriber } from '@verdant-web/common';
+export class BackoffScheduler extends 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;
+    }
+}
+export 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;
+    }
+}
 //# sourceMappingURL=BackoffScheduler.js.map

package/dist/esm/DocumentManager.d.ts

@@ -1,28 +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/esm/DocumentManager.js

@@ -1,41 +1,41 @@
-import { addFieldDefaults, assert, createOid, } from '@verdant-web/common';
-/**
- * Exposes functionality for creating documents,
- * the only mutation which is available as an entry
- * point in the storage system.
- */
-export 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];
-            assert(primaryKey, `Document must have a primary key: ${primaryKeyName.toString()} (got: ${JSON.stringify(init)})`);
-            return createOid(collection, primaryKey);
-        };
-        this.addDefaults = (collectionName, init) => {
-            const collection = this.schema.collections[collectionName];
-            return 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 = createOid(collection, primaryKey);
-            return this.entities.delete(oid, options);
-        };
-        this.deleteAll = async (ids, options = {}) => {
-            return this.entities.deleteAll(ids.map(([collection, primaryKey]) => createOid(collection, primaryKey)), options);
-        };
-        this.deleteAllFromCollection = async (collection, ids, options = {}) => {
-            return this.entities.deleteAll(ids.map((primaryKey) => createOid(collection, primaryKey)), options);
-        };
-    }
-}
+import { addFieldDefaults, assert, createOid, } from '@verdant-web/common';
+/**
+ * Exposes functionality for creating documents,
+ * the only mutation which is available as an entry
+ * point in the storage system.
+ */
+export 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];
+            assert(primaryKey, `Document must have a primary key: ${primaryKeyName.toString()} (got: ${JSON.stringify(init)})`);
+            return createOid(collection, primaryKey);
+        };
+        this.addDefaults = (collectionName, init) => {
+            const collection = this.schema.collections[collectionName];
+            return 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 = createOid(collection, primaryKey);
+            return this.entities.delete(oid, options);
+        };
+        this.deleteAll = async (ids, options = {}) => {
+            return this.entities.deleteAll(ids.map(([collection, primaryKey]) => createOid(collection, primaryKey)), options);
+        };
+        this.deleteAllFromCollection = async (collection, ids, options = {}) => {
+            return this.entities.deleteAll(ids.map((primaryKey) => createOid(collection, primaryKey)), options);
+        };
+    }
+}
 //# sourceMappingURL=DocumentManager.js.map

package/dist/esm/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/esm/FakeWeakRef.js

@@ -1,15 +1,15 @@
-/**
- * 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 class FakeWeakRef {
-    constructor(value) {
-        this.value = value;
-    }
-    deref() {
-        return this.value;
-    }
-}
+/**
+ * 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 class FakeWeakRef {
+    constructor(value) {
+        this.value = value;
+    }
+    deref() {
+        return this.value;
+    }
+}
 //# sourceMappingURL=FakeWeakRef.js.map

package/dist/esm/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/esm/IDBService.js

@@ -1,60 +1,60 @@
-import { storeRequestPromise } from './idb.js';
-export 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 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(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');
-        };
-    }
-}
+import { storeRequestPromise } from './idb.js';
+export 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 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(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');
+        };
+    }
+}
 //# sourceMappingURL=IDBService.js.map

package/dist/esm/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/esm/UndoHistory.js

@@ -1,47 +1,47 @@
-import { EventSubscriber } from '@verdant-web/common';
-export class UndoHistory extends 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;
-    }
-}
+import { EventSubscriber } from '@verdant-web/common';
+export class UndoHistory extends 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;
+    }
+}
 //# sourceMappingURL=UndoHistory.js.map

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

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

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

@@ -1,43 +1,43 @@
-import { describe, it, expect } from 'vitest';
-import { createTestStorage } from './fixtures/testStorage.js';
-describe('batching operations', () => {
-    it('should allow multiple runs with manual flush', async () => {
-        const storage = await 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();
-        expect(item.get('content')).toBe('hello world 3');
-        expect(item.get('category')).toBe('general');
-        expect(item.get('attachments').length).toBe(2);
-        expect(storage.undoHistory.canUndo).toBe(true);
-        await storage.undoHistory.undo();
-        expect(item.get('content')).toBe('hello world');
-        expect(item.get('category')).toBe('general');
-        expect(item.get('attachments').length).toBe(1);
-        // the next undo will undo the creation
-        await storage.undoHistory.undo();
-        expect(storage.undoHistory.canUndo).toBe(false);
-        expect(item.deleted).toBe(true);
-    });
-});
+import { describe, it, expect } from 'vitest';
+import { createTestStorage } from './fixtures/testStorage.js';
+describe('batching operations', () => {
+    it('should allow multiple runs with manual flush', async () => {
+        const storage = await 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();
+        expect(item.get('content')).toBe('hello world 3');
+        expect(item.get('category')).toBe('general');
+        expect(item.get('attachments').length).toBe(2);
+        expect(storage.undoHistory.canUndo).toBe(true);
+        await storage.undoHistory.undo();
+        expect(item.get('content')).toBe('hello world');
+        expect(item.get('category')).toBe('general');
+        expect(item.get('attachments').length).toBe(1);
+        // the next undo will undo the creation
+        await storage.undoHistory.undo();
+        expect(storage.undoHistory.canUndo).toBe(false);
+        expect(item.deleted).toBe(true);
+    });
+});
 //# sourceMappingURL=batching.test.js.map

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

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