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

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

@@ -1,319 +1,319 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const testStorage_js_1 = require("./fixtures/testStorage.js");
-const common_1 = require("@verdant-web/common");
-async function addTestingItems(storage) {
-    let items = [];
-    for (const item of [
-        {
-            id: '1',
-            content: 'item 1',
-            done: false,
-            tags: ['a'],
-            category: 'general',
-        },
-        {
-            id: '2',
-            content: 'item 2',
-            done: true,
-            tags: ['a', 'b'],
-            category: 'general',
-        },
-        {
-            id: '3',
-            content: 'item 3',
-            done: false,
-            tags: ['b', 'c'],
-            category: 'general',
-        },
-        {
-            id: '4',
-            content: 'something else',
-            done: true,
-            tags: [],
-            category: 'specific',
-        },
-        {
-            id: '5',
-            content: 'item 5',
-            done: false,
-            tags: ['a', 'b'],
-            category: 'specific',
-        },
-        {
-            id: '6',
-            content: 'not an item!',
-            done: true,
-            tags: ['a'],
-            category: 'specific',
-        },
-    ]) {
-        items.push(await storage.todos.put(item));
-    }
-    return items;
-}
-(0, vitest_1.describe)('storage queries', () => {
-    (0, vitest_1.it)('can query synthetic indexes', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const query = storage.todos.findAll({
-            index: {
-                where: 'example',
-                equals: 'something else',
-            },
-        });
-        const results = await query.resolved;
-        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([items[3].get('id')]);
-    });
-    (0, vitest_1.it)('can query simple compound indexes by match and order', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const query = storage.todos.findAll({
-            index: {
-                where: 'categorySortedByDone',
-                match: {
-                    category: 'general',
-                },
-                order: 'asc',
-            },
-        });
-        const results = await query.resolved;
-        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[2].get('id'),
-            items[1].get('id'),
-        ]);
-    });
-    (0, vitest_1.it)('can query array-based compound indexes by match and order', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const query = storage.todos.findAll({
-            index: {
-                where: 'tagsSortedByDone',
-                match: {
-                    tags: 'a',
-                },
-                order: 'asc',
-            },
-        });
-        const results = await query.resolved;
-        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[4].get('id'),
-            items[1].get('id'),
-            items[5].get('id'),
-        ]);
-    });
-    (0, vitest_1.it)('can query starts-with on a string', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const query = storage.todos.findAll({
-            index: {
-                where: 'content',
-                startsWith: 'item',
-            },
-        });
-        const results = await query.resolved;
-        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[1].get('id'),
-            items[2].get('id'),
-            items[4].get('id'),
-        ]);
-    });
-    (0, vitest_1.it)('can do a paginated query', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const query = storage.todos.findPage({
-            index: {
-                where: 'categorySortedByDone',
-                match: {
-                    category: 'general',
-                },
-                order: 'asc',
-            },
-            pageSize: 2,
-            page: 0,
-        });
-        const results = await query.resolved;
-        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[2].get('id'),
-        ]);
-        (0, vitest_1.expect)(query.hasNextPage).toBe(true);
-        await query.nextPage();
-        (0, vitest_1.expect)(query.current.map((i) => i.get('id'))).toEqual([
-            items[1].get('id'),
-        ]);
-        (0, vitest_1.expect)(query.hasNextPage).toBe(false);
-    });
-    (0, vitest_1.it)('can do an infinite query', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const query = storage.todos.findAllInfinite({
-            index: {
-                where: 'categorySortedByDone',
-                match: {
-                    category: 'general',
-                },
-                order: 'asc',
-            },
-            pageSize: 2,
-        });
-        const results = await query.resolved;
-        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[2].get('id'),
-        ]);
-        (0, vitest_1.expect)(query.hasMore).toBe(true);
-        await query.loadMore();
-        (0, vitest_1.expect)(query.current.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[2].get('id'),
-            items[1].get('id'),
-        ]);
-        (0, vitest_1.expect)(query.hasMore).toBe(false);
-    });
-    (0, vitest_1.it)('caches queries by user key and updates their filters', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        const items = await addTestingItems(storage);
-        const firstQuery = storage.todos.findAll({
-            key: 'customKey',
-            index: {
-                where: 'categorySortedByDone',
-                match: {
-                    category: 'general',
-                },
-                order: 'asc',
-            },
-        });
-        const firstResults = await firstQuery.resolved;
-        (0, vitest_1.expect)(firstResults.map((i) => i.get('id'))).toEqual([
-            items[0].get('id'),
-            items[2].get('id'),
-            items[1].get('id'),
-        ]);
-        const secondQuery = storage.todos.findAll({
-            key: 'customKey',
-            index: {
-                where: 'categorySortedByDone',
-                match: {
-                    category: 'specific',
-                },
-                order: 'asc',
-            },
-        });
-        // doesn't remove old results until ready
-        (0, vitest_1.expect)(firstQuery.current.length).toBe(3);
-        const secondResults = await secondQuery.resolved;
-        (0, vitest_1.expect)(secondResults.map((i) => i.get('id'))).toEqual([
-            items[4].get('id'),
-            items[3].get('id'),
-            items[5].get('id'),
-        ]);
-        (0, vitest_1.expect)(firstQuery.current.map((i) => i.get('id'))).toEqual([
-            items[4].get('id'),
-            items[3].get('id'),
-            items[5].get('id'),
-        ]);
-    });
-});
-(0, vitest_1.describe)('query reactivity', () => {
-    async function getQuery(storage) {
-        const item = await storage.todos.put({
-            id: '1',
-            content: 'item 1',
-            done: false,
-            tags: ['a'],
-            category: 'general',
-        });
-        return storage.todos.get('1');
-    }
-    (0, vitest_1.it)('does not requery a get query when the item changes', async () => {
-        const query = await getQuery(await (0, testStorage_js_1.createTestStorage)());
-        const item = await query.resolved;
-        (0, vitest_1.expect)(item).toBeTruthy();
-        (0, common_1.assert)(item);
-        (0, vitest_1.expect)(item.get('content')).toBe('item 1');
-        item.update({ content: 'updated' });
-        (0, vitest_1.expect)(query.status).toBe('ready');
-    });
-    (0, vitest_1.it)('returns the initial result set after status changes to ready', async () => {
-        const storage = await (0, testStorage_js_1.createTestStorage)();
-        await addTestingItems(storage);
-        const query = storage.todos.findAll();
-        (0, vitest_1.expect)(query.status).toBe('initial');
-        const resolved = query.resolved;
-        // accessing resolved begins initializing
-        (0, vitest_1.expect)(query.status).toBe('initializing');
-        await resolved;
-        (0, vitest_1.expect)(query.status).toBe('ready');
-        (0, vitest_1.expect)(query.current.length).toBe(6);
-        // revalidating on change is tested elsewhere below.
-    });
-    (0, vitest_1.it)('updates a get query when the item is deleted', async () => {
-        const client = await (0, testStorage_js_1.createTestStorage)();
-        const query = await getQuery(client);
-        const item = await query.resolved;
-        (0, vitest_1.expect)(item).toBeTruthy();
-        (0, common_1.assert)(item);
-        await client.todos.delete(item.get('id'));
-        (0, vitest_1.expect)(query.current).toBe(null);
-    });
-    (0, vitest_1.it)('updates list queries when a document is added to the collection', async () => {
-        const client = await (0, testStorage_js_1.createTestStorage)();
-        await addTestingItems(client);
-        const queries = [
-            client.todos.findAll(),
-            client.todos.findAllInfinite({
-                pageSize: 10,
-            }),
-            client.todos.findPage({
-                pageSize: 2,
-                page: 0,
-            }),
-        ];
-        await Promise.all(queries.map((q) => q.resolved));
-        (0, vitest_1.expect)(queries[0].current.length).toBe(6);
-        await client.todos.put({
-            id: '7',
-            content: 'item 7',
-            done: false,
-            tags: ['a'],
-            category: 'general',
-        });
-        for (const query of queries) {
-            (0, vitest_1.expect)(query.status).toBe('revalidating');
-        }
-        await Promise.all(queries.map((q) => q.resolved));
-        (0, vitest_1.expect)(queries[0].current.length).toBe(7);
-        (0, vitest_1.expect)(queries[1].current.length).toBe(7);
-        (0, vitest_1.expect)(queries[2].current.length).toBe(2);
-    });
-    (0, vitest_1.it)('updates list queries when a document is removed from the collection', async () => {
-        const client = await (0, testStorage_js_1.createTestStorage)();
-        await addTestingItems(client);
-        const queries = [
-            client.todos.findAll(),
-            client.todos.findAllInfinite({
-                pageSize: 10,
-            }),
-            client.todos.findPage({
-                pageSize: 2,
-                page: 2,
-            }),
-        ];
-        await Promise.all(queries.map((q) => q.resolved));
-        (0, vitest_1.expect)(queries[0].current.length).toBe(6);
-        await client.todos.delete('1');
-        for (const query of queries) {
-            (0, vitest_1.expect)(query.status).toBe('revalidating');
-        }
-        await Promise.all(queries.map((q) => q.resolved));
-        (0, vitest_1.expect)(queries[0].current.length).toBe(5);
-        (0, vitest_1.expect)(queries[1].current.length).toBe(5);
-        (0, vitest_1.expect)(queries[2].current.length).toBe(1);
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const testStorage_js_1 = require("./fixtures/testStorage.js");
+const common_1 = require("@verdant-web/common");
+async function addTestingItems(storage) {
+    let items = [];
+    for (const item of [
+        {
+            id: '1',
+            content: 'item 1',
+            done: false,
+            tags: ['a'],
+            category: 'general',
+        },
+        {
+            id: '2',
+            content: 'item 2',
+            done: true,
+            tags: ['a', 'b'],
+            category: 'general',
+        },
+        {
+            id: '3',
+            content: 'item 3',
+            done: false,
+            tags: ['b', 'c'],
+            category: 'general',
+        },
+        {
+            id: '4',
+            content: 'something else',
+            done: true,
+            tags: [],
+            category: 'specific',
+        },
+        {
+            id: '5',
+            content: 'item 5',
+            done: false,
+            tags: ['a', 'b'],
+            category: 'specific',
+        },
+        {
+            id: '6',
+            content: 'not an item!',
+            done: true,
+            tags: ['a'],
+            category: 'specific',
+        },
+    ]) {
+        items.push(await storage.todos.put(item));
+    }
+    return items;
+}
+(0, vitest_1.describe)('storage queries', () => {
+    (0, vitest_1.it)('can query synthetic indexes', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const query = storage.todos.findAll({
+            index: {
+                where: 'example',
+                equals: 'something else',
+            },
+        });
+        const results = await query.resolved;
+        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([items[3].get('id')]);
+    });
+    (0, vitest_1.it)('can query simple compound indexes by match and order', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const query = storage.todos.findAll({
+            index: {
+                where: 'categorySortedByDone',
+                match: {
+                    category: 'general',
+                },
+                order: 'asc',
+            },
+        });
+        const results = await query.resolved;
+        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[2].get('id'),
+            items[1].get('id'),
+        ]);
+    });
+    (0, vitest_1.it)('can query array-based compound indexes by match and order', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const query = storage.todos.findAll({
+            index: {
+                where: 'tagsSortedByDone',
+                match: {
+                    tags: 'a',
+                },
+                order: 'asc',
+            },
+        });
+        const results = await query.resolved;
+        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[4].get('id'),
+            items[1].get('id'),
+            items[5].get('id'),
+        ]);
+    });
+    (0, vitest_1.it)('can query starts-with on a string', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const query = storage.todos.findAll({
+            index: {
+                where: 'content',
+                startsWith: 'item',
+            },
+        });
+        const results = await query.resolved;
+        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[1].get('id'),
+            items[2].get('id'),
+            items[4].get('id'),
+        ]);
+    });
+    (0, vitest_1.it)('can do a paginated query', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const query = storage.todos.findPage({
+            index: {
+                where: 'categorySortedByDone',
+                match: {
+                    category: 'general',
+                },
+                order: 'asc',
+            },
+            pageSize: 2,
+            page: 0,
+        });
+        const results = await query.resolved;
+        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[2].get('id'),
+        ]);
+        (0, vitest_1.expect)(query.hasNextPage).toBe(true);
+        await query.nextPage();
+        (0, vitest_1.expect)(query.current.map((i) => i.get('id'))).toEqual([
+            items[1].get('id'),
+        ]);
+        (0, vitest_1.expect)(query.hasNextPage).toBe(false);
+    });
+    (0, vitest_1.it)('can do an infinite query', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const query = storage.todos.findAllInfinite({
+            index: {
+                where: 'categorySortedByDone',
+                match: {
+                    category: 'general',
+                },
+                order: 'asc',
+            },
+            pageSize: 2,
+        });
+        const results = await query.resolved;
+        (0, vitest_1.expect)(results.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[2].get('id'),
+        ]);
+        (0, vitest_1.expect)(query.hasMore).toBe(true);
+        await query.loadMore();
+        (0, vitest_1.expect)(query.current.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[2].get('id'),
+            items[1].get('id'),
+        ]);
+        (0, vitest_1.expect)(query.hasMore).toBe(false);
+    });
+    (0, vitest_1.it)('caches queries by user key and updates their filters', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        const items = await addTestingItems(storage);
+        const firstQuery = storage.todos.findAll({
+            key: 'customKey',
+            index: {
+                where: 'categorySortedByDone',
+                match: {
+                    category: 'general',
+                },
+                order: 'asc',
+            },
+        });
+        const firstResults = await firstQuery.resolved;
+        (0, vitest_1.expect)(firstResults.map((i) => i.get('id'))).toEqual([
+            items[0].get('id'),
+            items[2].get('id'),
+            items[1].get('id'),
+        ]);
+        const secondQuery = storage.todos.findAll({
+            key: 'customKey',
+            index: {
+                where: 'categorySortedByDone',
+                match: {
+                    category: 'specific',
+                },
+                order: 'asc',
+            },
+        });
+        // doesn't remove old results until ready
+        (0, vitest_1.expect)(firstQuery.current.length).toBe(3);
+        const secondResults = await secondQuery.resolved;
+        (0, vitest_1.expect)(secondResults.map((i) => i.get('id'))).toEqual([
+            items[4].get('id'),
+            items[3].get('id'),
+            items[5].get('id'),
+        ]);
+        (0, vitest_1.expect)(firstQuery.current.map((i) => i.get('id'))).toEqual([
+            items[4].get('id'),
+            items[3].get('id'),
+            items[5].get('id'),
+        ]);
+    });
+});
+(0, vitest_1.describe)('query reactivity', () => {
+    async function getQuery(storage) {
+        const item = await storage.todos.put({
+            id: '1',
+            content: 'item 1',
+            done: false,
+            tags: ['a'],
+            category: 'general',
+        });
+        return storage.todos.get('1');
+    }
+    (0, vitest_1.it)('does not requery a get query when the item changes', async () => {
+        const query = await getQuery(await (0, testStorage_js_1.createTestStorage)());
+        const item = await query.resolved;
+        (0, vitest_1.expect)(item).toBeTruthy();
+        (0, common_1.assert)(item);
+        (0, vitest_1.expect)(item.get('content')).toBe('item 1');
+        item.update({ content: 'updated' });
+        (0, vitest_1.expect)(query.status).toBe('ready');
+    });
+    (0, vitest_1.it)('returns the initial result set after status changes to ready', async () => {
+        const storage = await (0, testStorage_js_1.createTestStorage)();
+        await addTestingItems(storage);
+        const query = storage.todos.findAll();
+        (0, vitest_1.expect)(query.status).toBe('initial');
+        const resolved = query.resolved;
+        // accessing resolved begins initializing
+        (0, vitest_1.expect)(query.status).toBe('initializing');
+        await resolved;
+        (0, vitest_1.expect)(query.status).toBe('ready');
+        (0, vitest_1.expect)(query.current.length).toBe(6);
+        // revalidating on change is tested elsewhere below.
+    });
+    (0, vitest_1.it)('updates a get query when the item is deleted', async () => {
+        const client = await (0, testStorage_js_1.createTestStorage)();
+        const query = await getQuery(client);
+        const item = await query.resolved;
+        (0, vitest_1.expect)(item).toBeTruthy();
+        (0, common_1.assert)(item);
+        await client.todos.delete(item.get('id'));
+        (0, vitest_1.expect)(query.current).toBe(null);
+    });
+    (0, vitest_1.it)('updates list queries when a document is added to the collection', async () => {
+        const client = await (0, testStorage_js_1.createTestStorage)();
+        await addTestingItems(client);
+        const queries = [
+            client.todos.findAll(),
+            client.todos.findAllInfinite({
+                pageSize: 10,
+            }),
+            client.todos.findPage({
+                pageSize: 2,
+                page: 0,
+            }),
+        ];
+        await Promise.all(queries.map((q) => q.resolved));
+        (0, vitest_1.expect)(queries[0].current.length).toBe(6);
+        await client.todos.put({
+            id: '7',
+            content: 'item 7',
+            done: false,
+            tags: ['a'],
+            category: 'general',
+        });
+        for (const query of queries) {
+            (0, vitest_1.expect)(query.status).toBe('revalidating');
+        }
+        await Promise.all(queries.map((q) => q.resolved));
+        (0, vitest_1.expect)(queries[0].current.length).toBe(7);
+        (0, vitest_1.expect)(queries[1].current.length).toBe(7);
+        (0, vitest_1.expect)(queries[2].current.length).toBe(2);
+    });
+    (0, vitest_1.it)('updates list queries when a document is removed from the collection', async () => {
+        const client = await (0, testStorage_js_1.createTestStorage)();
+        await addTestingItems(client);
+        const queries = [
+            client.todos.findAll(),
+            client.todos.findAllInfinite({
+                pageSize: 10,
+            }),
+            client.todos.findPage({
+                pageSize: 2,
+                page: 2,
+            }),
+        ];
+        await Promise.all(queries.map((q) => q.resolved));
+        (0, vitest_1.expect)(queries[0].current.length).toBe(6);
+        await client.todos.delete('1');
+        for (const query of queries) {
+            (0, vitest_1.expect)(query.status).toBe('revalidating');
+        }
+        await Promise.all(queries.map((q) => q.resolved));
+        (0, vitest_1.expect)(queries[0].current.length).toBe(5);
+        (0, vitest_1.expect)(queries[1].current.length).toBe(5);
+        (0, vitest_1.expect)(queries[2].current.length).toBe(1);
+    });
+});
 //# sourceMappingURL=queries.test.js.map

package/dist/cjs/__tests__/setup/indexedDB.d.ts

@@ -1 +1 @@
-import 'fake-indexeddb/auto/index.mjs';
+import 'fake-indexeddb/auto/index.mjs';

package/dist/cjs/__tests__/setup/indexedDB.js

@@ -1,4 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("fake-indexeddb/auto/index.mjs");
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("fake-indexeddb/auto/index.mjs");
 //# sourceMappingURL=indexedDB.js.map

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

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