@verdant-web/store 2.0.1 → 2.0.2

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

@@ -1,85 +1,85 @@
-import { assert } from '@verdant-web/common';
-import { describe, it, expect } from 'vitest';
-import { createTestStorage } from './fixtures/testStorage.js';
-describe('undoing operations', () => {
-    it('should undo deletes', async () => {
-        const storage = await createTestStorage();
-        const item = await storage.todos.put({
-            content: 'item',
-            category: 'general',
-            attachments: [
-                {
-                    name: 'thing',
-                },
-            ],
-        });
-        await storage.todos.delete(item.get('id'));
-        expect(await storage.todos.get(item.get('id')).resolved).toBeNull();
-        await storage.undoHistory.undo();
-        const restored = await storage.todos.get(item.get('id')).resolved;
-        expect(restored).toBeTruthy();
-        assert(!!restored);
-        expect(restored.get('id')).toBe(item.get('id'));
-        expect(restored.get('content')).toBe('item');
-        expect(restored.get('category')).toBe('general');
-        expect(restored.get('attachments').get(0).get('name')).toBe('thing');
-    });
-    it('should undo field deletes', async () => {
-        const storage = await createTestStorage();
-        const item = await storage.todos.put({
-            content: 'item',
-            category: 'general',
-            attachments: [
-                {
-                    name: 'thing',
-                },
-            ],
-        });
-        item.subscribe('change', () => { });
-        item.get('attachments').delete(0);
-        await storage.entities.flushPatches();
-        expect(item.get('attachments').length).toBe(0);
-        await storage.undoHistory.undo();
-        expect(item.get('attachments').length).toBe(1);
-        expect(item.get('attachments').get(0).get('name')).toBe('thing');
-    });
-    it('should create batches without undo', async () => {
-        const storage = await createTestStorage();
-        const item = await storage.todos.put({
-            content: 'item',
-            category: 'general',
-            attachments: [
-                {
-                    name: 'thing',
-                },
-            ],
-        });
-        await storage
-            .batch()
-            .run(() => {
-            item.set('content', 'hello world');
-        })
-            .flush();
-        await storage
-            .batch({
-            undoable: false,
-        })
-            .run(() => {
-            item.set('content', 'hello world 2');
-            item.set('category', 'sticky');
-        })
-            .flush();
-        expect(item.get('content')).toBe('hello world 2');
-        expect(item.get('category')).toBe('sticky');
-        expect(storage.undoHistory.canUndo).toBe(true);
-        await storage.undoHistory.undo();
-        expect(item.get('content')).toBe('item');
-        // was not undone!
-        expect(item.get('category')).toBe('sticky');
-        // the next undo will undo the creation
-        await storage.undoHistory.undo();
-        expect(item.deleted).toBe(true);
-    });
-    // more definitive undo tests require syncing multiple clients
-});
+import { assert } from '@verdant-web/common';
+import { describe, it, expect } from 'vitest';
+import { createTestStorage } from './fixtures/testStorage.js';
+describe('undoing operations', () => {
+    it('should undo deletes', async () => {
+        const storage = await createTestStorage();
+        const item = await storage.todos.put({
+            content: 'item',
+            category: 'general',
+            attachments: [
+                {
+                    name: 'thing',
+                },
+            ],
+        });
+        await storage.todos.delete(item.get('id'));
+        expect(await storage.todos.get(item.get('id')).resolved).toBeNull();
+        await storage.undoHistory.undo();
+        const restored = await storage.todos.get(item.get('id')).resolved;
+        expect(restored).toBeTruthy();
+        assert(!!restored);
+        expect(restored.get('id')).toBe(item.get('id'));
+        expect(restored.get('content')).toBe('item');
+        expect(restored.get('category')).toBe('general');
+        expect(restored.get('attachments').get(0).get('name')).toBe('thing');
+    });
+    it('should undo field deletes', async () => {
+        const storage = await createTestStorage();
+        const item = await storage.todos.put({
+            content: 'item',
+            category: 'general',
+            attachments: [
+                {
+                    name: 'thing',
+                },
+            ],
+        });
+        item.subscribe('change', () => { });
+        item.get('attachments').delete(0);
+        await storage.entities.flushPatches();
+        expect(item.get('attachments').length).toBe(0);
+        await storage.undoHistory.undo();
+        expect(item.get('attachments').length).toBe(1);
+        expect(item.get('attachments').get(0).get('name')).toBe('thing');
+    });
+    it('should create batches without undo', async () => {
+        const storage = await createTestStorage();
+        const item = await storage.todos.put({
+            content: 'item',
+            category: 'general',
+            attachments: [
+                {
+                    name: 'thing',
+                },
+            ],
+        });
+        await storage
+            .batch()
+            .run(() => {
+            item.set('content', 'hello world');
+        })
+            .flush();
+        await storage
+            .batch({
+            undoable: false,
+        })
+            .run(() => {
+            item.set('content', 'hello world 2');
+            item.set('category', 'sticky');
+        })
+            .flush();
+        expect(item.get('content')).toBe('hello world 2');
+        expect(item.get('category')).toBe('sticky');
+        expect(storage.undoHistory.canUndo).toBe(true);
+        await storage.undoHistory.undo();
+        expect(item.get('content')).toBe('item');
+        // was not undone!
+        expect(item.get('category')).toBe('sticky');
+        // the next undo will undo the creation
+        await storage.undoHistory.undo();
+        expect(item.deleted).toBe(true);
+    });
+    // more definitive undo tests require syncing multiple clients
+});
 //# sourceMappingURL=undo.test.js.map

package/dist/esm/client/Client.d.ts

@@ -1,86 +1,86 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Migration } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { DocumentManager } from '../DocumentManager.js';
-import { FileManagerConfig } from '../files/FileManager.js';
-import { Metadata } from '../metadata/Metadata.js';
-import { EntityStore } from '../reactives/EntityStore.js';
-import { ServerSyncOptions, Sync } from '../sync/Sync.js';
-import { CollectionQueries } from '../queries2/CollectionQueries.js';
-interface ClientConfig<Presence = any> {
-    syncConfig?: ServerSyncOptions<Presence>;
-    migrations: Migration[];
-    files?: FileManagerConfig;
-}
-export type ClientWithCollections = Client & {
-    [key: string]: CollectionQueries<any, any, any>;
-};
-export declare class Client {
-    private config;
-    private context;
-    readonly meta: Metadata;
-    private _entities;
-    private _queryCache;
-    private _documentManager;
-    private _fileManager;
-    readonly collectionNames: string[];
-    private _sync;
-    get sync(): Sync;
-    get entities(): EntityStore;
-    get documentManager(): DocumentManager<any>;
-    constructor(config: ClientConfig, context: Context, components: {
-        meta: Metadata;
-    });
-    private addData;
-    get documentDb(): IDBDatabase;
-    get metaDb(): IDBDatabase;
-    get schema(): import("@verdant-web/common").StorageSchema<any>;
-    get namespace(): string;
-    get undoHistory(): import("../UndoHistory.js").UndoHistory;
-    /**
-     * @deprecated - use client.sync.presence instead
-     */
-    get presence(): import("../sync/PresenceManager.js").PresenceManager<any, any>;
-    /**
-     * Batch multiple operations together to be executed in a single transaction.
-     * The changes made will not be included in the same undo history step as
-     * any other changes made outside of the batch. You can also disable undo
-     * for your batch to omit changes from undo history.
-     *
-     * Provide a batch name to apply multiple changes to the same batch
-     * across different invocations. Batches will automatically flush after
-     * a short delay or if they reach a maximum size.
-     */
-    get batch(): ({ undoable, batchName, max, timeout, }?: {
-        undoable?: boolean | undefined;
-        batchName?: string | undefined;
-        max?: number | null | undefined;
-        timeout?: number | null | undefined;
-    }) => import("../reactives/EntityStore.js").OperationBatch;
-    stats: () => Promise<{
-        collections: Record<string, {
-            count: number;
-            size: number;
-        }>;
-        meta: {
-            operationsSize: {
-                count: number;
-                size: number;
-            };
-            baselinesSize: {
-                count: number;
-                size: number;
-            };
-        };
-        storage: StorageEstimate | undefined;
-        totalMetaSize: number;
-        totalCollectionsSize: number;
-        metaToDataRatio: number;
-        quotaUsage: number | undefined;
-    }>;
-    close: () => Promise<void>;
-    __dangerous__resetLocal: () => Promise<void>;
-    export: () => Promise<Buffer>;
-    import: (buffer: Buffer) => Promise<void>;
-}
-export {};
+/// <reference types="node" resolution-mode="require"/>
+import { Migration } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { DocumentManager } from '../DocumentManager.js';
+import { FileManagerConfig } from '../files/FileManager.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { EntityStore } from '../reactives/EntityStore.js';
+import { ServerSyncOptions, Sync } from '../sync/Sync.js';
+import { CollectionQueries } from '../queries2/CollectionQueries.js';
+interface ClientConfig<Presence = any> {
+    syncConfig?: ServerSyncOptions<Presence>;
+    migrations: Migration[];
+    files?: FileManagerConfig;
+}
+export type ClientWithCollections = Client & {
+    [key: string]: CollectionQueries<any, any, any>;
+};
+export declare class Client {
+    private config;
+    private context;
+    readonly meta: Metadata;
+    private _entities;
+    private _queryCache;
+    private _documentManager;
+    private _fileManager;
+    readonly collectionNames: string[];
+    private _sync;
+    get sync(): Sync;
+    get entities(): EntityStore;
+    get documentManager(): DocumentManager<any>;
+    constructor(config: ClientConfig, context: Context, components: {
+        meta: Metadata;
+    });
+    private addData;
+    get documentDb(): IDBDatabase;
+    get metaDb(): IDBDatabase;
+    get schema(): import("@verdant-web/common").StorageSchema<any>;
+    get namespace(): string;
+    get undoHistory(): import("../UndoHistory.js").UndoHistory;
+    /**
+     * @deprecated - use client.sync.presence instead
+     */
+    get presence(): import("../sync/PresenceManager.js").PresenceManager<any, any>;
+    /**
+     * Batch multiple operations together to be executed in a single transaction.
+     * The changes made will not be included in the same undo history step as
+     * any other changes made outside of the batch. You can also disable undo
+     * for your batch to omit changes from undo history.
+     *
+     * Provide a batch name to apply multiple changes to the same batch
+     * across different invocations. Batches will automatically flush after
+     * a short delay or if they reach a maximum size.
+     */
+    get batch(): ({ undoable, batchName, max, timeout, }?: {
+        undoable?: boolean | undefined;
+        batchName?: string | undefined;
+        max?: number | null | undefined;
+        timeout?: number | null | undefined;
+    }) => import("../reactives/EntityStore.js").OperationBatch;
+    stats: () => Promise<{
+        collections: Record<string, {
+            count: number;
+            size: number;
+        }>;
+        meta: {
+            operationsSize: {
+                count: number;
+                size: number;
+            };
+            baselinesSize: {
+                count: number;
+                size: number;
+            };
+        };
+        storage: StorageEstimate | undefined;
+        totalMetaSize: number;
+        totalCollectionsSize: number;
+        metaToDataRatio: number;
+        quotaUsage: number | undefined;
+    }>;
+    close: () => Promise<void>;
+    __dangerous__resetLocal: () => Promise<void>;
+    export: () => Promise<Buffer>;
+    import: (buffer: Buffer) => Promise<void>;
+}
+export {};