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

package/dist/cjs/queries/ranges.js

@@ -1,70 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRange = void 0;
-const common_1 = require("@verdant-web/common");
-const matchIndexToIdbKeyRange = (filter) => {
-    return IDBKeyRange.only((0, common_1.sanitizeIndexValue)(filter.equals));
-};
-const sortIndexToIdbKeyRange = (filter) => {
-    return undefined;
-};
-const rangeIndexToIdbKeyRange = (filter) => {
-    const lower = filter.gte || filter.gt;
-    const upper = filter.lte || filter.lt;
-    if (lower === upper) {
-        return IDBKeyRange.only((0, common_1.sanitizeIndexValue)(lower));
-    }
-    if (!lower) {
-        return IDBKeyRange.upperBound((0, common_1.sanitizeIndexValue)(upper), !!filter.lt);
-    }
-    else if (!upper) {
-        return IDBKeyRange.lowerBound((0, common_1.sanitizeIndexValue)(lower), !!filter.gt);
-    }
-    else {
-        return IDBKeyRange.bound((0, common_1.sanitizeIndexValue)(lower), (0, common_1.sanitizeIndexValue)(upper), !!filter.gt, !!filter.lt);
-    }
-};
-const compoundIndexToIdbKeyRange = (
-// FIXME:
-schema, collection, filter) => {
-    // validate the usage of the compound index:
-    // - all match fields must be contiguous at the start of the compound order
-    const indexDefinition = schema.collections[collection].compounds[filter.where];
-    (0, common_1.assert)(indexDefinition, `Index ${filter.where} does not exist on collection ${collection}`);
-    const matchedKeys = Object.keys(filter.match).sort((a, b) => indexDefinition.of.indexOf(a) - indexDefinition.of.indexOf(b));
-    for (const key of matchedKeys) {
-        if (indexDefinition.of.indexOf(key) !== matchedKeys.indexOf(key)) {
-            throw new Error(`Compound index ${filter.where} does not have ${key} at the start of its order`);
-        }
-    }
-    const matchedValues = matchedKeys.map((key) => filter.match[key]);
-    // special case: all match fields are specified - we don't need a range
-    // query, just a single key query
-    if (matchedKeys.length === indexDefinition.of.length) {
-        return IDBKeyRange.only((0, common_1.createCompoundIndexValue)(...matchedValues));
-    }
-    // create our bounds for the matched values
-    const lower = (0, common_1.createLowerBoundIndexValue)(...matchedValues);
-    const upper = (0, common_1.createUpperBoundIndexValue)(...matchedValues);
-    return IDBKeyRange.bound(lower, upper);
-};
-function startsWithIndexToIdbKeyRange(filter) {
-    const lower = filter.startsWith;
-    const upper = filter.startsWith + '\uffff';
-    return IDBKeyRange.bound(lower, upper);
-}
-function getRange(schema, collection, index) {
-    if (!index)
-        return undefined;
-    if ((0, common_1.isRangeIndexFilter)(index))
-        return rangeIndexToIdbKeyRange(index);
-    if ((0, common_1.isMatchIndexFilter)(index))
-        return matchIndexToIdbKeyRange(index);
-    if ((0, common_1.isSortIndexFilter)(index))
-        return sortIndexToIdbKeyRange(index);
-    if ((0, common_1.isStartsWithIndexFilter)(index))
-        return startsWithIndexToIdbKeyRange(index);
-    return compoundIndexToIdbKeyRange(schema, collection, index);
-}
-exports.getRange = getRange;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRange = void 0;
+const common_1 = require("@verdant-web/common");
+const matchIndexToIdbKeyRange = (filter) => {
+    return IDBKeyRange.only((0, common_1.sanitizeIndexValue)(filter.equals));
+};
+const sortIndexToIdbKeyRange = (filter) => {
+    return undefined;
+};
+const rangeIndexToIdbKeyRange = (filter) => {
+    const lower = filter.gte || filter.gt;
+    const upper = filter.lte || filter.lt;
+    if (lower === upper) {
+        return IDBKeyRange.only((0, common_1.sanitizeIndexValue)(lower));
+    }
+    if (!lower) {
+        return IDBKeyRange.upperBound((0, common_1.sanitizeIndexValue)(upper), !!filter.lt);
+    }
+    else if (!upper) {
+        return IDBKeyRange.lowerBound((0, common_1.sanitizeIndexValue)(lower), !!filter.gt);
+    }
+    else {
+        return IDBKeyRange.bound((0, common_1.sanitizeIndexValue)(lower), (0, common_1.sanitizeIndexValue)(upper), !!filter.gt, !!filter.lt);
+    }
+};
+const compoundIndexToIdbKeyRange = (
+// FIXME:
+schema, collection, filter) => {
+    // validate the usage of the compound index:
+    // - all match fields must be contiguous at the start of the compound order
+    const indexDefinition = schema.collections[collection].compounds[filter.where];
+    (0, common_1.assert)(indexDefinition, `Index ${filter.where} does not exist on collection ${collection}`);
+    const matchedKeys = Object.keys(filter.match).sort((a, b) => indexDefinition.of.indexOf(a) - indexDefinition.of.indexOf(b));
+    for (const key of matchedKeys) {
+        if (indexDefinition.of.indexOf(key) !== matchedKeys.indexOf(key)) {
+            throw new Error(`Compound index ${filter.where} does not have ${key} at the start of its order`);
+        }
+    }
+    const matchedValues = matchedKeys.map((key) => filter.match[key]);
+    // special case: all match fields are specified - we don't need a range
+    // query, just a single key query
+    if (matchedKeys.length === indexDefinition.of.length) {
+        return IDBKeyRange.only((0, common_1.createCompoundIndexValue)(...matchedValues));
+    }
+    // create our bounds for the matched values
+    const lower = (0, common_1.createLowerBoundIndexValue)(...matchedValues);
+    const upper = (0, common_1.createUpperBoundIndexValue)(...matchedValues);
+    return IDBKeyRange.bound(lower, upper);
+};
+function startsWithIndexToIdbKeyRange(filter) {
+    const lower = filter.startsWith;
+    const upper = filter.startsWith + '\uffff';
+    return IDBKeyRange.bound(lower, upper);
+}
+function getRange(schema, collection, index) {
+    if (!index)
+        return undefined;
+    if ((0, common_1.isRangeIndexFilter)(index))
+        return rangeIndexToIdbKeyRange(index);
+    if ((0, common_1.isMatchIndexFilter)(index))
+        return matchIndexToIdbKeyRange(index);
+    if ((0, common_1.isSortIndexFilter)(index))
+        return sortIndexToIdbKeyRange(index);
+    if ((0, common_1.isStartsWithIndexFilter)(index))
+        return startsWithIndexToIdbKeyRange(index);
+    return compoundIndexToIdbKeyRange(schema, collection, index);
+}
+exports.getRange = getRange;
 //# sourceMappingURL=ranges.js.map

package/dist/cjs/queries/types.d.ts

@@ -1,6 +1,6 @@
-import type { FindAllQuery } from './FindAllQuery.js';
-import type { FindPageQuery } from './FindPageQuery.js';
-import type { FindOneQuery } from './FindOneQuery.js';
-import type { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import type { GetQuery } from './GetQuery.js';
-export type Query<T> = FindAllQuery<T> | FindPageQuery<T> | FindOneQuery<T> | FindInfiniteQuery<T> | GetQuery<T>;
+import type { FindAllQuery } from './FindAllQuery.js';
+import type { FindPageQuery } from './FindPageQuery.js';
+import type { FindOneQuery } from './FindOneQuery.js';
+import type { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import type { GetQuery } from './GetQuery.js';
+export type Query<T> = FindAllQuery<T> | FindPageQuery<T> | FindOneQuery<T> | FindInfiniteQuery<T> | GetQuery<T>;

package/dist/cjs/queries/types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/dist/cjs/queries/utils.d.ts

@@ -1,3 +1,3 @@
-import { CollectionIndexFilter } from '@verdant-web/common';
-export declare function filterResultSet(results: any): any;
-export declare function areIndexesEqual(a?: CollectionIndexFilter, b?: CollectionIndexFilter): boolean | undefined;
+import { CollectionIndexFilter } from '@verdant-web/common';
+export declare function filterResultSet(results: any): any;
+export declare function areIndexesEqual(a?: CollectionIndexFilter, b?: CollectionIndexFilter): boolean | undefined;

package/dist/cjs/queries/utils.js

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.areIndexesEqual = exports.filterResultSet = void 0;
-const common_1 = require("@verdant-web/common");
-const Entity_js_1 = require("../entities/Entity.js");
-function existsFilter(x) {
-    return x !== null;
-}
-function filterResultSet(results) {
-    if (Array.isArray(results)) {
-        return results.map(filterResultSet).filter(existsFilter);
-    }
-    else if (results instanceof Entity_js_1.Entity) {
-        return results.deleted ? null : results;
-    }
-    else {
-        return results;
-    }
-}
-exports.filterResultSet = filterResultSet;
-function areIndexesEqual(a, b) {
-    return (!a && !b) || (a && b && (0, common_1.hashObject)(a) === (0, common_1.hashObject)(b));
-}
-exports.areIndexesEqual = areIndexesEqual;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areIndexesEqual = exports.filterResultSet = void 0;
+const common_1 = require("@verdant-web/common");
+const Entity_js_1 = require("../entities/Entity.js");
+function existsFilter(x) {
+    return x !== null;
+}
+function filterResultSet(results) {
+    if (Array.isArray(results)) {
+        return results.map(filterResultSet).filter(existsFilter);
+    }
+    else if (results instanceof Entity_js_1.Entity) {
+        return results.deleted ? null : results;
+    }
+    else {
+        return results;
+    }
+}
+exports.filterResultSet = filterResultSet;
+function areIndexesEqual(a, b) {
+    return (!a && !b) || (a && b && (0, common_1.hashObject)(a) === (0, common_1.hashObject)(b));
+}
+exports.areIndexesEqual = areIndexesEqual;
 //# sourceMappingURL=utils.js.map

package/dist/cjs/sync/FileSync.d.ts

@@ -1,23 +1,23 @@
-import { FileData } from '@verdant-web/common';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-export interface FileUploadResult {
-    success: boolean;
-    retry: boolean;
-}
-export type FilePullResult = {
-    success: true;
-    data: FileData;
-} | {
-    success: false;
-    retry: boolean;
-};
-export declare class FileSync {
-    private endpointProvider;
-    private log;
-    constructor({ endpointProvider, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        log: (...args: any[]) => any;
-    });
-    uploadFile: (data: FileData) => Promise<FileUploadResult>;
-    getFile: (id: string) => Promise<FilePullResult>;
-}
+import { FileData } from '@verdant-web/common';
+import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
+export interface FileUploadResult {
+    success: boolean;
+    retry: boolean;
+}
+export type FilePullResult = {
+    success: true;
+    data: FileData;
+} | {
+    success: false;
+    retry: boolean;
+};
+export declare class FileSync {
+    private endpointProvider;
+    private log;
+    constructor({ endpointProvider, log, }: {
+        endpointProvider: ServerSyncEndpointProvider;
+        log: (...args: any[]) => any;
+    });
+    uploadFile: (data: FileData) => Promise<FileUploadResult>;
+    getFile: (id: string) => Promise<FilePullResult>;
+}

package/dist/cjs/sync/FileSync.js

@@ -1,85 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSync = void 0;
-class FileSync {
-    constructor({ endpointProvider, log, }) {
-        this.uploadFile = async (data) => {
-            const file = data.file;
-            if (!file) {
-                throw new Error('Cannot upload a non-local file');
-            }
-            // multipart upload
-            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
-            const formData = new window.FormData();
-            formData.append('file', file);
-            try {
-                const response = await fetch(fileEndpoint + `/${data.id}`, {
-                    method: 'POST',
-                    body: formData,
-                    credentials: 'include',
-                    headers: {
-                        Authorization: `Bearer ${token}`,
-                    },
-                });
-                if (response.ok) {
-                    return {
-                        success: true,
-                        retry: false,
-                    };
-                }
-                else {
-                    this.log('error', 'File upload failed', response.status, await response.text());
-                    return {
-                        success: false,
-                        retry: response.status >= 500,
-                    };
-                }
-            }
-            catch (e) {
-                this.log('error', 'File upload failed', e);
-                return {
-                    success: false,
-                    retry: true,
-                };
-            }
-        };
-        this.getFile = async (id) => {
-            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
-            try {
-                const response = await fetch(fileEndpoint + `/${id}`, {
-                    method: 'GET',
-                    credentials: 'include',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${token}`,
-                    },
-                });
-                if (response.ok) {
-                    const data = await response.json();
-                    return {
-                        success: true,
-                        data,
-                    };
-                }
-                else {
-                    this.log('error', 'File information fetch failed', response.status, await response.text());
-                    return {
-                        success: false,
-                        retry: response.status >= 500 || response.status === 404,
-                    };
-                }
-            }
-            catch (e) {
-                this.log('error', 'File information fetch failed', e);
-                return {
-                    success: false,
-                    retry: true,
-                };
-            }
-        };
-        this.endpointProvider = endpointProvider;
-        this.log = log;
-    }
-}
-exports.FileSync = FileSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSync = void 0;
+class FileSync {
+    constructor({ endpointProvider, log, }) {
+        this.uploadFile = async (data) => {
+            const file = data.file;
+            if (!file) {
+                throw new Error('Cannot upload a non-local file');
+            }
+            // multipart upload
+            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
+            const formData = new window.FormData();
+            formData.append('file', file);
+            try {
+                const response = await fetch(fileEndpoint + `/${data.id}`, {
+                    method: 'POST',
+                    body: formData,
+                    credentials: 'include',
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                if (response.ok) {
+                    return {
+                        success: true,
+                        retry: false,
+                    };
+                }
+                else {
+                    this.log('error', 'File upload failed', response.status, await response.text());
+                    return {
+                        success: false,
+                        retry: response.status >= 500,
+                    };
+                }
+            }
+            catch (e) {
+                this.log('error', 'File upload failed', e);
+                return {
+                    success: false,
+                    retry: true,
+                };
+            }
+        };
+        this.getFile = async (id) => {
+            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
+            try {
+                const response = await fetch(fileEndpoint + `/${id}`, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    return {
+                        success: true,
+                        data,
+                    };
+                }
+                else {
+                    this.log('error', 'File information fetch failed', response.status, await response.text());
+                    return {
+                        success: false,
+                        retry: response.status >= 500 || response.status === 404,
+                    };
+                }
+            }
+            catch (e) {
+                this.log('error', 'File information fetch failed', e);
+                return {
+                    success: false,
+                    retry: true,
+                };
+            }
+        };
+        this.endpointProvider = endpointProvider;
+        this.log = log;
+    }
+}
+exports.FileSync = FileSync;
 //# sourceMappingURL=FileSync.js.map

package/dist/cjs/sync/Heartbeat.d.ts

@@ -1,25 +1,25 @@
-import { EventSubscriber } from '@verdant-web/common';
-export declare class Heartbeat extends EventSubscriber<{
-    missed: () => void;
-    beat: () => void;
-}> {
-    private _interval;
-    private deadlineLength;
-    private nextBeat;
-    private deadline;
-    get interval(): number;
-    constructor({ interval, deadlineLength, restartOnTabFocus, }?: {
-        interval?: number;
-        deadlineLength?: number;
-        restartOnTabFocus?: boolean;
-    });
-    keepAlive: () => void;
-    start: (immediate?: boolean) => void;
-    stop: () => void;
-    private beat;
-    private onDeadline;
-    /**
-     * Only takes affect after the next beat
-     */
-    setInterval: (interval: number) => void;
-}
+import { EventSubscriber } from '@verdant-web/common';
+export declare class Heartbeat extends EventSubscriber<{
+    missed: () => void;
+    beat: () => void;
+}> {
+    private _interval;
+    private deadlineLength;
+    private nextBeat;
+    private deadline;
+    get interval(): number;
+    constructor({ interval, deadlineLength, restartOnTabFocus, }?: {
+        interval?: number;
+        deadlineLength?: number;
+        restartOnTabFocus?: boolean;
+    });
+    keepAlive: () => void;
+    start: (immediate?: boolean) => void;
+    stop: () => void;
+    private beat;
+    private onDeadline;
+    /**
+     * Only takes affect after the next beat
+     */
+    setInterval: (interval: number) => void;
+}

package/dist/cjs/sync/Heartbeat.js

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heartbeat = void 0;
-const common_1 = require("@verdant-web/common");
-class Heartbeat extends common_1.EventSubscriber {
-    get interval() {
-        return this._interval;
-    }
-    constructor({ interval = 15 * 1000, deadlineLength = 3 * 1000, restartOnTabFocus = true, } = {}) {
-        super();
-        this.nextBeat = null;
-        this.deadline = null;
-        this.keepAlive = () => {
-            if (this.deadline) {
-                clearTimeout(this.deadline);
-                this.deadline = null;
-                this.start();
-            }
-        };
-        this.start = (immediate = false) => {
-            this.stop();
-            if (immediate) {
-                this.beat();
-            }
-            else {
-                this.nextBeat = setTimeout(this.beat, this._interval);
-            }
-        };
-        this.stop = () => {
-            if (this.nextBeat) {
-                clearTimeout(this.nextBeat);
-            }
-            if (this.deadline) {
-                clearTimeout(this.deadline);
-            }
-        };
-        this.beat = async () => {
-            this.emit('beat');
-            this.deadline = setTimeout(this.onDeadline, this.deadlineLength);
-        };
-        this.onDeadline = () => {
-            this.deadline = null;
-            this.emit('missed');
-        };
-        /**
-         * Only takes affect after the next beat
-         */
-        this.setInterval = (interval) => {
-            this._interval = interval;
-        };
-        this._interval = interval;
-        this.deadlineLength = deadlineLength;
-        if (typeof window !== 'undefined' && restartOnTabFocus) {
-            window.addEventListener('pageshow', () => this.start(true));
-            document.addEventListener('visibilitychange', () => {
-                if (document.visibilityState === 'visible') {
-                    this.start(true);
-                }
-            });
-        }
-    }
-}
-exports.Heartbeat = Heartbeat;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heartbeat = void 0;
+const common_1 = require("@verdant-web/common");
+class Heartbeat extends common_1.EventSubscriber {
+    get interval() {
+        return this._interval;
+    }
+    constructor({ interval = 15 * 1000, deadlineLength = 3 * 1000, restartOnTabFocus = true, } = {}) {
+        super();
+        this.nextBeat = null;
+        this.deadline = null;
+        this.keepAlive = () => {
+            if (this.deadline) {
+                clearTimeout(this.deadline);
+                this.deadline = null;
+                this.start();
+            }
+        };
+        this.start = (immediate = false) => {
+            this.stop();
+            if (immediate) {
+                this.beat();
+            }
+            else {
+                this.nextBeat = setTimeout(this.beat, this._interval);
+            }
+        };
+        this.stop = () => {
+            if (this.nextBeat) {
+                clearTimeout(this.nextBeat);
+            }
+            if (this.deadline) {
+                clearTimeout(this.deadline);
+            }
+        };
+        this.beat = async () => {
+            this.emit('beat');
+            this.deadline = setTimeout(this.onDeadline, this.deadlineLength);
+        };
+        this.onDeadline = () => {
+            this.deadline = null;
+            this.emit('missed');
+        };
+        /**
+         * Only takes affect after the next beat
+         */
+        this.setInterval = (interval) => {
+            this._interval = interval;
+        };
+        this._interval = interval;
+        this.deadlineLength = deadlineLength;
+        if (typeof window !== 'undefined' && restartOnTabFocus) {
+            window.addEventListener('pageshow', () => this.start(true));
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'visible') {
+                    this.start(true);
+                }
+            });
+        }
+    }
+}
+exports.Heartbeat = Heartbeat;
 //# sourceMappingURL=Heartbeat.js.map