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

package/dist/esm/queries/CollectionQueries.d.ts

@@ -1,55 +1,55 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { EntityStore } from '../entities/EntityStore.js';
-import { GetQuery } from './GetQuery.js';
-import { QueryCache } from './QueryCache.js';
-import { FindOneQuery } from './FindOneQuery.js';
-import { FindPageQuery } from './FindPageQuery.js';
-import { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import { FindAllQuery } from './FindAllQuery.js';
-import { DocumentManager } from '../DocumentManager.js';
-import { ObjectEntity } from '../index.js';
-export declare class CollectionQueries<T extends ObjectEntity<any, any>, Init, Filter extends CollectionFilter> {
-    private cache;
-    private collection;
-    private hydrate;
-    private context;
-    private documentManager;
-    put: (init: Init, options?: {
-        undoable?: boolean;
-    }) => Promise<T>;
-    delete: (id: string, options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    deleteAll: (ids: string[], options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    constructor({ collection, cache, entities, context, documentManager, }: {
-        collection: string;
-        cache: QueryCache;
-        entities: EntityStore;
-        context: Context;
-        documentManager: DocumentManager<any>;
-    });
-    private serializeIndex;
-    get: (id: string) => GetQuery<T>;
-    findOne: ({ index, key: providedKey, }?: {
-        index?: Filter | undefined;
-        key?: string | undefined;
-    }) => FindOneQuery<T>;
-    findAll: ({ index, key: providedKey, }?: {
-        index?: Filter | undefined;
-        key?: string | undefined;
-    }) => FindAllQuery<T>;
-    findPage: ({ index, pageSize, page, key: providedKey, }: {
-        index?: Filter | undefined;
-        pageSize: number;
-        page: number;
-        key?: string | undefined;
-    }) => FindPageQuery<T>;
-    findAllInfinite: ({ index, pageSize, key: providedKey, }: {
-        index?: Filter | undefined;
-        pageSize: number;
-        key?: string | undefined;
-    }) => FindInfiniteQuery<T>;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { EntityStore } from '../entities/EntityStore.js';
+import { GetQuery } from './GetQuery.js';
+import { QueryCache } from './QueryCache.js';
+import { FindOneQuery } from './FindOneQuery.js';
+import { FindPageQuery } from './FindPageQuery.js';
+import { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import { FindAllQuery } from './FindAllQuery.js';
+import { DocumentManager } from '../DocumentManager.js';
+import { ObjectEntity } from '../index.js';
+export declare class CollectionQueries<T extends ObjectEntity<any, any>, Init, Filter extends CollectionFilter> {
+    private cache;
+    private collection;
+    private hydrate;
+    private context;
+    private documentManager;
+    put: (init: Init, options?: {
+        undoable?: boolean;
+    }) => Promise<T>;
+    delete: (id: string, options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    deleteAll: (ids: string[], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    constructor({ collection, cache, entities, context, documentManager, }: {
+        collection: string;
+        cache: QueryCache;
+        entities: EntityStore;
+        context: Context;
+        documentManager: DocumentManager<any>;
+    });
+    private serializeIndex;
+    get: (id: string) => GetQuery<T>;
+    findOne: ({ index, key: providedKey, }?: {
+        index?: Filter | undefined;
+        key?: string | undefined;
+    }) => FindOneQuery<T>;
+    findAll: ({ index, key: providedKey, }?: {
+        index?: Filter | undefined;
+        key?: string | undefined;
+    }) => FindAllQuery<T>;
+    findPage: ({ index, pageSize, page, key: providedKey, }: {
+        index?: Filter | undefined;
+        pageSize: number;
+        page: number;
+        key?: string | undefined;
+    }) => FindPageQuery<T>;
+    findAllInfinite: ({ index, pageSize, key: providedKey, }: {
+        index?: Filter | undefined;
+        pageSize: number;
+        key?: string | undefined;
+    }) => FindInfiniteQuery<T>;
+}

package/dist/esm/queries/CollectionQueries.js

@@ -1,88 +1,88 @@
-import { hashObject } from '@verdant-web/common';
-import { GetQuery } from './GetQuery.js';
-import { FindOneQuery } from './FindOneQuery.js';
-import { FindPageQuery } from './FindPageQuery.js';
-import { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import { FindAllQuery } from './FindAllQuery.js';
-import { UPDATE } from './BaseQuery.js';
-export class CollectionQueries {
-    constructor({ collection, cache, entities, context, documentManager, }) {
-        this.serializeIndex = (index) => {
-            if (!index)
-                return '';
-            return hashObject(index);
-        };
-        this.get = (id) => {
-            const key = `get:${this.collection}:${id}`;
-            return this.cache.getOrSet(key, () => new GetQuery({
-                id,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }));
-        };
-        this.findOne = ({ index, key: providedKey, } = {}) => {
-            const key = providedKey || `findOne:${this.collection}:${this.serializeIndex(index)}`;
-            return this.cache.getOrSet(key, () => new FindOneQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.findAll = ({ index, key: providedKey, } = {}) => {
-            const key = providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
-            return this.cache.getOrSet(key, () => new FindAllQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.findPage = ({ index, pageSize, page, key: providedKey, }) => {
-            const key = providedKey ||
-                `findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
-            return this.cache.getOrSet(key, () => new FindPageQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-                pageSize,
-                page,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.findAllInfinite = ({ index, pageSize, key: providedKey, }) => {
-            const key = providedKey ||
-                `findAllInfinite:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
-            return this.cache.getOrSet(key, () => new FindInfiniteQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-                pageSize,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.cache = cache;
-        this.collection = collection;
-        this.hydrate = entities.get;
-        this.context = context;
-        this.documentManager = documentManager;
-        this.put = this.documentManager.create.bind(this.documentManager, this.collection);
-        this.delete = this.documentManager.delete.bind(this.documentManager, this.collection);
-        this.deleteAll = this.documentManager.deleteAllFromCollection.bind(this.documentManager, this.collection);
-    }
-}
+import { hashObject } from '@verdant-web/common';
+import { GetQuery } from './GetQuery.js';
+import { FindOneQuery } from './FindOneQuery.js';
+import { FindPageQuery } from './FindPageQuery.js';
+import { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import { FindAllQuery } from './FindAllQuery.js';
+import { UPDATE } from './BaseQuery.js';
+export class CollectionQueries {
+    constructor({ collection, cache, entities, context, documentManager, }) {
+        this.serializeIndex = (index) => {
+            if (!index)
+                return '';
+            return hashObject(index);
+        };
+        this.get = (id) => {
+            const key = `get:${this.collection}:${id}`;
+            return this.cache.getOrSet(key, () => new GetQuery({
+                id,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }));
+        };
+        this.findOne = ({ index, key: providedKey, } = {}) => {
+            const key = providedKey || `findOne:${this.collection}:${this.serializeIndex(index)}`;
+            return this.cache.getOrSet(key, () => new FindOneQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.findAll = ({ index, key: providedKey, } = {}) => {
+            const key = providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
+            return this.cache.getOrSet(key, () => new FindAllQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.findPage = ({ index, pageSize, page, key: providedKey, }) => {
+            const key = providedKey ||
+                `findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+            return this.cache.getOrSet(key, () => new FindPageQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+                pageSize,
+                page,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.findAllInfinite = ({ index, pageSize, key: providedKey, }) => {
+            const key = providedKey ||
+                `findAllInfinite:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+            return this.cache.getOrSet(key, () => new FindInfiniteQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+                pageSize,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.cache = cache;
+        this.collection = collection;
+        this.hydrate = entities.get;
+        this.context = context;
+        this.documentManager = documentManager;
+        this.put = this.documentManager.create.bind(this.documentManager, this.collection);
+        this.delete = this.documentManager.delete.bind(this.documentManager, this.collection);
+        this.deleteAll = this.documentManager.deleteAllFromCollection.bind(this.documentManager, this.collection);
+    }
+}
 //# sourceMappingURL=CollectionQueries.js.map

package/dist/esm/queries/FindAllQuery.d.ts

@@ -1,12 +1,12 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindAllQuery<T> extends BaseQuery<T[]> {
-    private index;
-    private hydrate;
-    constructor({ index, hydrate, ...rest }: {
-        index?: CollectionFilter;
-        hydrate: (oid: string) => Promise<T>;
-    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
-    protected run: () => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
+export declare class FindAllQuery<T> extends BaseQuery<T[]> {
+    private index;
+    private hydrate;
+    constructor({ index, hydrate, ...rest }: {
+        index?: CollectionFilter;
+        hydrate: (oid: string) => Promise<T>;
+    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
+    protected run: () => Promise<void>;
+    [UPDATE]: (index: CollectionFilter | undefined) => void;
+}

package/dist/esm/queries/FindAllQuery.js

@@ -1,39 +1,39 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var _a;
-import { BaseQuery, UPDATE } from './BaseQuery.js';
-import { findAllOids } from './dbQueries.js';
-import { areIndexesEqual } from './utils.js';
-export class FindAllQuery extends BaseQuery {
-    constructor(_b) {
-        var { index, hydrate } = _b, rest = __rest(_b, ["index", "hydrate"]);
-        super(Object.assign({ initial: [] }, rest));
-        this.run = async () => {
-            const oids = await findAllOids({
-                collection: this.collection,
-                index: this.index,
-                context: this.context,
-            });
-            this.setValue(await Promise.all(oids.map(this.hydrate)));
-        };
-        this[_a] = (index) => {
-            if (areIndexesEqual(this.index, index))
-                return;
-            this.index = index;
-            this.execute();
-        };
-        this.index = index;
-        this.hydrate = hydrate;
-    }
-}
-_a = UPDATE;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _a;
+import { BaseQuery, UPDATE } from './BaseQuery.js';
+import { findAllOids } from './dbQueries.js';
+import { areIndexesEqual } from './utils.js';
+export class FindAllQuery extends BaseQuery {
+    constructor(_b) {
+        var { index, hydrate } = _b, rest = __rest(_b, ["index", "hydrate"]);
+        super(Object.assign({ initial: [] }, rest));
+        this.run = async () => {
+            const oids = await findAllOids({
+                collection: this.collection,
+                index: this.index,
+                context: this.context,
+            });
+            this.setValue(await Promise.all(oids.map(this.hydrate)));
+        };
+        this[_a] = (index) => {
+            if (areIndexesEqual(this.index, index))
+                return;
+            this.index = index;
+            this.execute();
+        };
+        this.index = index;
+        this.hydrate = hydrate;
+    }
+}
+_a = UPDATE;
 //# sourceMappingURL=FindAllQuery.js.map

package/dist/esm/queries/FindInfiniteQuery.d.ts

@@ -1,19 +1,19 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindInfiniteQuery<T> extends BaseQuery<T[]> {
-    private index;
-    private hydrate;
-    private _upToPage;
-    private _pageSize;
-    private _hasNextPage;
-    get pageSize(): number;
-    get hasMore(): boolean;
-    constructor({ hydrate, pageSize, index, ...rest }: {
-        hydrate: (oid: string) => Promise<T>;
-        pageSize: number;
-        index?: CollectionFilter;
-    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
-    protected run: () => Promise<void>;
-    loadMore: () => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
+export declare class FindInfiniteQuery<T> extends BaseQuery<T[]> {
+    private index;
+    private hydrate;
+    private _upToPage;
+    private _pageSize;
+    private _hasNextPage;
+    get pageSize(): number;
+    get hasMore(): boolean;
+    constructor({ hydrate, pageSize, index, ...rest }: {
+        hydrate: (oid: string) => Promise<T>;
+        pageSize: number;
+        index?: CollectionFilter;
+    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
+    protected run: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    [UPDATE]: (index: CollectionFilter | undefined) => void;
+}

package/dist/esm/queries/FindInfiniteQuery.js

@@ -1,66 +1,66 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var _a;
-import { BaseQuery, UPDATE } from './BaseQuery.js';
-import { findPageOfOids } from './dbQueries.js';
-import { areIndexesEqual } from './utils.js';
-export class FindInfiniteQuery extends BaseQuery {
-    get pageSize() {
-        return this._pageSize;
-    }
-    get hasMore() {
-        return this._hasNextPage;
-    }
-    constructor(_b) {
-        var { hydrate, pageSize, index } = _b, rest = __rest(_b, ["hydrate", "pageSize", "index"]);
-        super(Object.assign({ initial: [] }, rest));
-        this._upToPage = 1;
-        this._hasNextPage = false;
-        this.run = async () => {
-            const { result, hasNextPage } = await findPageOfOids({
-                collection: this.collection,
-                context: this.context,
-                limit: this._pageSize * this._upToPage,
-                offset: 0,
-                index: this.index,
-            });
-            this._hasNextPage = hasNextPage;
-            this.setValue(await Promise.all(result.map(this.hydrate)));
-        };
-        this.loadMore = async () => {
-            const { result, hasNextPage } = await findPageOfOids({
-                collection: this.collection,
-                context: this.context,
-                limit: this._pageSize,
-                offset: this._pageSize * this._upToPage,
-                index: this.index,
-            });
-            this._hasNextPage = hasNextPage;
-            this._upToPage++;
-            this.setValue([
-                ...this.current,
-                ...(await Promise.all(result.map(this.hydrate))),
-            ]);
-        };
-        this[_a] = (index) => {
-            if (areIndexesEqual(this.index, index))
-                return;
-            this.index = index;
-            this.execute();
-        };
-        this.index = index;
-        this.hydrate = hydrate;
-        this._pageSize = pageSize;
-    }
-}
-_a = UPDATE;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _a;
+import { BaseQuery, UPDATE } from './BaseQuery.js';
+import { findPageOfOids } from './dbQueries.js';
+import { areIndexesEqual } from './utils.js';
+export class FindInfiniteQuery extends BaseQuery {
+    get pageSize() {
+        return this._pageSize;
+    }
+    get hasMore() {
+        return this._hasNextPage;
+    }
+    constructor(_b) {
+        var { hydrate, pageSize, index } = _b, rest = __rest(_b, ["hydrate", "pageSize", "index"]);
+        super(Object.assign({ initial: [] }, rest));
+        this._upToPage = 1;
+        this._hasNextPage = false;
+        this.run = async () => {
+            const { result, hasNextPage } = await findPageOfOids({
+                collection: this.collection,
+                context: this.context,
+                limit: this._pageSize * this._upToPage,
+                offset: 0,
+                index: this.index,
+            });
+            this._hasNextPage = hasNextPage;
+            this.setValue(await Promise.all(result.map(this.hydrate)));
+        };
+        this.loadMore = async () => {
+            const { result, hasNextPage } = await findPageOfOids({
+                collection: this.collection,
+                context: this.context,
+                limit: this._pageSize,
+                offset: this._pageSize * this._upToPage,
+                index: this.index,
+            });
+            this._hasNextPage = hasNextPage;
+            this._upToPage++;
+            this.setValue([
+                ...this.current,
+                ...(await Promise.all(result.map(this.hydrate))),
+            ]);
+        };
+        this[_a] = (index) => {
+            if (areIndexesEqual(this.index, index))
+                return;
+            this.index = index;
+            this.execute();
+        };
+        this.index = index;
+        this.hydrate = hydrate;
+        this._pageSize = pageSize;
+    }
+}
+_a = UPDATE;
 //# sourceMappingURL=FindInfiniteQuery.js.map

package/dist/esm/queries/FindOneQuery.d.ts

@@ -1,12 +1,12 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindOneQuery<T> extends BaseQuery<T | null> {
-    private index;
-    private hydrate;
-    constructor({ index, hydrate, ...rest }: {
-        index?: CollectionFilter;
-        hydrate: (oid: string) => Promise<T>;
-    } & Omit<BaseQueryOptions<T | null>, 'initial'>);
-    protected run: () => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
+export declare class FindOneQuery<T> extends BaseQuery<T | null> {
+    private index;
+    private hydrate;
+    constructor({ index, hydrate, ...rest }: {
+        index?: CollectionFilter;
+        hydrate: (oid: string) => Promise<T>;
+    } & Omit<BaseQueryOptions<T | null>, 'initial'>);
+    protected run: () => Promise<void>;
+    [UPDATE]: (index: CollectionFilter | undefined) => void;
+}