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

package/dist/esm/migration/paths.d.ts

@@ -1,6 +1,6 @@
-import { Migration } from '@verdant-web/common';
-export declare function getMigrationPath({ currentVersion, targetVersion, migrations, }: {
-    currentVersion: number;
-    targetVersion: number;
-    migrations: Migration[];
-}): Migration<any, any>[];
+import { Migration } from '@verdant-web/common';
+export declare function getMigrationPath({ currentVersion, targetVersion, migrations, }: {
+    currentVersion: number;
+    targetVersion: number;
+    migrations: Migration[];
+}): Migration<any, any>[];

package/dist/esm/migration/paths.js

@@ -1,49 +1,49 @@
-import { MigrationPathError } from './errors.js';
-export function getMigrationPath({ currentVersion, targetVersion, migrations, }) {
-    const path = getNextPathStep({
-        currentVersion,
-        targetVersion,
-        migrations,
-    });
-    if (!path) {
-        throw new MigrationPathError(`No migration path found from ${currentVersion} to ${targetVersion}! This is a bug. If you're seeing this, contact the developer and provide them with the full contents of this message.`);
-    }
-    return path;
-}
-function getNextPathStep({ currentVersion, targetVersion, migrations, }) {
-    if (currentVersion === targetVersion) {
-        return [];
-    }
-    const fromHere = migrations
-        .filter((m) => m.oldSchema.version === currentVersion)
-        .sort((a, b) => b.newSchema.version - a.newSchema.version);
-    // keep trying next steps, starting from the largest step,
-    // until we find one that leads to the target version down the line
-    while (fromHere.length > 0) {
-        const next = fromHere.shift();
-        // this one goes too far (probably never relevant, but still)
-        if (next.newSchema.version > targetVersion) {
-            return null;
-        }
-        // exact match - we're done, return the path
-        if (next.newSchema.version === targetVersion) {
-            return [next];
-        }
-        // look ahead a down the line. do we reach the target? if so,
-        // we choose this path.
-        const nextPath = getNextPathStep({
-            currentVersion: next.newSchema.version,
-            targetVersion,
-            migrations,
-        });
-        if (nextPath) {
-            return [next, ...nextPath];
-        }
-        // otherwise, try the next one with a smaller increment
-    }
-    // no paths from here match at all! if another layer is calling this one,
-    // it will fallback to its next longest step. otherwise there may
-    // be no paths at all...
-    return null;
-}
+import { MigrationPathError } from './errors.js';
+export function getMigrationPath({ currentVersion, targetVersion, migrations, }) {
+    const path = getNextPathStep({
+        currentVersion,
+        targetVersion,
+        migrations,
+    });
+    if (!path) {
+        throw new MigrationPathError(`No migration path found from ${currentVersion} to ${targetVersion}! This is a bug. If you're seeing this, contact the developer and provide them with the full contents of this message.`);
+    }
+    return path;
+}
+function getNextPathStep({ currentVersion, targetVersion, migrations, }) {
+    if (currentVersion === targetVersion) {
+        return [];
+    }
+    const fromHere = migrations
+        .filter((m) => m.oldSchema.version === currentVersion)
+        .sort((a, b) => b.newSchema.version - a.newSchema.version);
+    // keep trying next steps, starting from the largest step,
+    // until we find one that leads to the target version down the line
+    while (fromHere.length > 0) {
+        const next = fromHere.shift();
+        // this one goes too far (probably never relevant, but still)
+        if (next.newSchema.version > targetVersion) {
+            return null;
+        }
+        // exact match - we're done, return the path
+        if (next.newSchema.version === targetVersion) {
+            return [next];
+        }
+        // look ahead a down the line. do we reach the target? if so,
+        // we choose this path.
+        const nextPath = getNextPathStep({
+            currentVersion: next.newSchema.version,
+            targetVersion,
+            migrations,
+        });
+        if (nextPath) {
+            return [next, ...nextPath];
+        }
+        // otherwise, try the next one with a smaller increment
+    }
+    // no paths from here match at all! if another layer is calling this one,
+    // it will fallback to its next longest step. otherwise there may
+    // be no paths at all...
+    return null;
+}
 //# sourceMappingURL=paths.js.map

package/dist/esm/migration/paths.test.d.ts

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

package/dist/esm/migration/paths.test.js

@@ -1,89 +1,89 @@
-import { describe, expect, it } from 'vitest';
-import { getMigrationPath } from './paths.js';
-function mockMigration(from, to) {
-    return {
-        oldSchema: {
-            version: from,
-        },
-        newSchema: {
-            version: to,
-        },
-    };
-}
-describe('migration pathfinding', () => {
-    it('should follow a linear chain', () => {
-        const migrations = [
-            mockMigration(0, 1),
-            mockMigration(1, 2),
-            mockMigration(2, 3),
-            mockMigration(3, 4),
-            mockMigration(4, 5),
-        ];
-        const path = getMigrationPath({
-            currentVersion: 0,
-            targetVersion: 5,
-            migrations,
-        });
-        expect(path).toEqual(migrations);
-    });
-    it('should choose the shortest path', () => {
-        const migrations = [
-            mockMigration(0, 1),
-            mockMigration(1, 2),
-            mockMigration(2, 3),
-            mockMigration(3, 4),
-            mockMigration(4, 5),
-            mockMigration(0, 5),
-        ];
-        const path = getMigrationPath({
-            currentVersion: 0,
-            targetVersion: 5,
-            migrations,
-        });
-        expect(path).toEqual([mockMigration(0, 5)]);
-    });
-    it('should be resilient to dead ends', () => {
-        const migrations = [
-            mockMigration(0, 1),
-            mockMigration(1, 2),
-            mockMigration(4, 5),
-            mockMigration(5, 6),
-            mockMigration(1, 4),
-        ];
-        const path = getMigrationPath({
-            currentVersion: 0,
-            targetVersion: 6,
-            migrations,
-        });
-        expect(path).toEqual([
-            mockMigration(0, 1),
-            mockMigration(1, 4),
-            mockMigration(4, 5),
-            mockMigration(5, 6),
-        ]);
-    });
-    it('should error when no path exists to target', () => {
-        const migrations = [
-            mockMigration(0, 1),
-            mockMigration(2, 3),
-            mockMigration(3, 4),
-            mockMigration(4, 5),
-            mockMigration(5, 6),
-        ];
-        expect(() => {
-            getMigrationPath({
-                currentVersion: 0,
-                targetVersion: 6,
-                migrations,
-            });
-        }).toThrow();
-    });
-    it('should return empty when versions are the same', () => {
-        expect(getMigrationPath({
-            currentVersion: 1,
-            targetVersion: 1,
-            migrations: [],
-        })).toEqual([]);
-    });
-});
+import { describe, expect, it } from 'vitest';
+import { getMigrationPath } from './paths.js';
+function mockMigration(from, to) {
+    return {
+        oldSchema: {
+            version: from,
+        },
+        newSchema: {
+            version: to,
+        },
+    };
+}
+describe('migration pathfinding', () => {
+    it('should follow a linear chain', () => {
+        const migrations = [
+            mockMigration(0, 1),
+            mockMigration(1, 2),
+            mockMigration(2, 3),
+            mockMigration(3, 4),
+            mockMigration(4, 5),
+        ];
+        const path = getMigrationPath({
+            currentVersion: 0,
+            targetVersion: 5,
+            migrations,
+        });
+        expect(path).toEqual(migrations);
+    });
+    it('should choose the shortest path', () => {
+        const migrations = [
+            mockMigration(0, 1),
+            mockMigration(1, 2),
+            mockMigration(2, 3),
+            mockMigration(3, 4),
+            mockMigration(4, 5),
+            mockMigration(0, 5),
+        ];
+        const path = getMigrationPath({
+            currentVersion: 0,
+            targetVersion: 5,
+            migrations,
+        });
+        expect(path).toEqual([mockMigration(0, 5)]);
+    });
+    it('should be resilient to dead ends', () => {
+        const migrations = [
+            mockMigration(0, 1),
+            mockMigration(1, 2),
+            mockMigration(4, 5),
+            mockMigration(5, 6),
+            mockMigration(1, 4),
+        ];
+        const path = getMigrationPath({
+            currentVersion: 0,
+            targetVersion: 6,
+            migrations,
+        });
+        expect(path).toEqual([
+            mockMigration(0, 1),
+            mockMigration(1, 4),
+            mockMigration(4, 5),
+            mockMigration(5, 6),
+        ]);
+    });
+    it('should error when no path exists to target', () => {
+        const migrations = [
+            mockMigration(0, 1),
+            mockMigration(2, 3),
+            mockMigration(3, 4),
+            mockMigration(4, 5),
+            mockMigration(5, 6),
+        ];
+        expect(() => {
+            getMigrationPath({
+                currentVersion: 0,
+                targetVersion: 6,
+                migrations,
+            });
+        }).toThrow();
+    });
+    it('should return empty when versions are the same', () => {
+        expect(getMigrationPath({
+            currentVersion: 1,
+            targetVersion: 1,
+            migrations: [],
+        })).toEqual([]);
+    });
+});
 //# sourceMappingURL=paths.test.js.map

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

@@ -1,53 +1,53 @@
-import { Context } from '../context.js';
-import { Disposable } from '../utils/Disposable.js';
-export type BaseQueryEvents = {
-    change: (value: any) => void;
-    statusChange: (status: QueryStatus) => void;
-};
-export type BaseQueryOptions<T> = {
-    context: Context;
-    initial: T;
-    collection: string;
-    key: string;
-    shouldUpdate?: (updatedCollections: string[]) => boolean;
-};
-export type QueryStatus = 'initial' | 'initializing' | 'revalidating' | 'ready';
-export declare const ON_ALL_UNSUBSCRIBED: unique symbol;
-export declare const UPDATE: unique symbol;
-export declare abstract class BaseQuery<T> extends Disposable {
-    private _rawValue;
-    private _value;
-    private _events;
-    private _internalUnsubscribes;
-    private _allUnsubscribedHandler?;
-    private _status;
-    private _executionPromise;
-    protected context: Context;
-    readonly collection: string;
-    readonly key: string;
-    constructor({ initial, context, collection, key, shouldUpdate, }: BaseQueryOptions<T>);
-    get current(): T;
-    get resolved(): Promise<T>;
-    get subscribed(): boolean;
-    get status(): QueryStatus;
-    /**
-     * Subscribe to changes in the query value.
-     *
-     * @deprecated use the two parameter form instead
-     */
-    subscribe(callback: (value: T) => void): () => void;
-    /**
-     * Subscribe to changes in the query value.
-     */
-    subscribe(event: 'change', callback: (value: T) => void): () => void;
-    /**
-     * Subscribe to changes in the query state.
-     */
-    subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
-    protected setValue: (value: T) => void;
-    protected refreshValue: () => void;
-    private subscribeToDeleteAndRestore;
-    execute: () => Promise<T>;
-    protected abstract run(): Promise<void>;
-    [ON_ALL_UNSUBSCRIBED]: (handler: (query: BaseQuery<T>) => void) => void;
-}
+import { Context } from '../context.js';
+import { Disposable } from '../utils/Disposable.js';
+export type BaseQueryEvents = {
+    change: (value: any) => void;
+    statusChange: (status: QueryStatus) => void;
+};
+export type BaseQueryOptions<T> = {
+    context: Context;
+    initial: T;
+    collection: string;
+    key: string;
+    shouldUpdate?: (updatedCollections: string[]) => boolean;
+};
+export type QueryStatus = 'initial' | 'initializing' | 'revalidating' | 'ready';
+export declare const ON_ALL_UNSUBSCRIBED: unique symbol;
+export declare const UPDATE: unique symbol;
+export declare abstract class BaseQuery<T> extends Disposable {
+    private _rawValue;
+    private _value;
+    private _events;
+    private _internalUnsubscribes;
+    private _allUnsubscribedHandler?;
+    private _status;
+    private _executionPromise;
+    protected context: Context;
+    readonly collection: string;
+    readonly key: string;
+    constructor({ initial, context, collection, key, shouldUpdate, }: BaseQueryOptions<T>);
+    get current(): T;
+    get resolved(): Promise<T>;
+    get subscribed(): boolean;
+    get status(): QueryStatus;
+    /**
+     * Subscribe to changes in the query value.
+     *
+     * @deprecated use the two parameter form instead
+     */
+    subscribe(callback: (value: T) => void): () => void;
+    /**
+     * Subscribe to changes in the query value.
+     */
+    subscribe(event: 'change', callback: (value: T) => void): () => void;
+    /**
+     * Subscribe to changes in the query state.
+     */
+    subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
+    protected setValue: (value: T) => void;
+    protected refreshValue: () => void;
+    private subscribeToDeleteAndRestore;
+    execute: () => Promise<T>;
+    protected abstract run(): Promise<void>;
+    [ON_ALL_UNSUBSCRIBED]: (handler: (query: BaseQuery<T>) => void) => void;
+}

package/dist/esm/queries/BaseQuery.js

@@ -1,132 +1,132 @@
-var _a;
-import { EventSubscriber } from '@verdant-web/common';
-import { Entity } from '../entities/Entity.js';
-import { Disposable } from '../utils/Disposable.js';
-import { filterResultSet } from './utils.js';
-export const ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
-export const UPDATE = Symbol('UPDATE');
-// export interface BaseQuery<T> {
-// 	subscribe(event: 'change', callback: (value: T) => void): () => void;
-// 	subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
-// 	subscribe(callback: (value: T) => void): () => void;
-// }
-export class BaseQuery extends Disposable {
-    constructor({ initial, context, collection, key, shouldUpdate, }) {
-        super();
-        this._internalUnsubscribes = [];
-        this._status = 'initial';
-        this._executionPromise = null;
-        this.setValue = (value) => {
-            this._rawValue = value;
-            this.subscribeToDeleteAndRestore(this._rawValue);
-            this._value = filterResultSet(value);
-            this._status = 'ready';
-            this._events.emit('change', this._value);
-        };
-        // re-applies filtering if results have changed
-        this.refreshValue = () => {
-            this.setValue(this._rawValue);
-        };
-        this.subscribeToDeleteAndRestore = (value) => {
-            var _b;
-            while (this._internalUnsubscribes.length) {
-                (_b = this._internalUnsubscribes.pop()) === null || _b === void 0 ? void 0 : _b();
-            }
-            if (Array.isArray(value)) {
-                value.forEach((entity) => {
-                    if (entity instanceof Entity) {
-                        this._internalUnsubscribes.push(entity.subscribe('delete', this.refreshValue));
-                        this._internalUnsubscribes.push(entity.subscribe('restore', this.refreshValue));
-                    }
-                });
-            }
-            else if (value instanceof Entity) {
-                this._internalUnsubscribes.push(value.subscribe('delete', this.refreshValue));
-                this._internalUnsubscribes.push(value.subscribe('restore', () => {
-                    this.refreshValue();
-                }));
-            }
-        };
-        this.execute = () => {
-            this.context.log('debug', 'Executing query', this.key);
-            if (this._status === 'initial') {
-                this._status = 'initializing';
-            }
-            else if (this._status === 'ready') {
-                this._status = 'revalidating';
-            }
-            // no status change needed if already in a 'running' status.
-            this._executionPromise = this.run()
-                .then(() => this._value)
-                .catch((err) => {
-                if (err instanceof Error) {
-                    if (err.name === 'InvalidStateError' ||
-                        err.name === 'InvalidAccessError') {
-                        // possibly accessing db while it's closed. not much we can do.
-                        return this._value;
-                    }
-                }
-                throw err;
-            });
-            return this._executionPromise;
-        };
-        this[_a] = (handler) => {
-            this._allUnsubscribedHandler = handler;
-        };
-        this._rawValue = initial;
-        this._value = initial;
-        this._events = new EventSubscriber((event) => {
-            var _b;
-            if (event === 'change')
-                (_b = this._allUnsubscribedHandler) === null || _b === void 0 ? void 0 : _b.call(this, this);
-        });
-        this.context = context;
-        this.key = key;
-        this.collection = collection;
-        const shouldUpdateFn = shouldUpdate ||
-            ((collections) => collections.includes(collection));
-        this.addDispose(this.context.entityEvents.subscribe('collectionsChanged', (collections) => {
-            if (shouldUpdateFn(collections)) {
-                this.context.log('info', 'Updating query', this.key);
-                this.execute();
-            }
-        }));
-    }
-    get current() {
-        return this._value;
-    }
-    get resolved() {
-        var _b;
-        if (this.status === 'ready')
-            return Promise.resolve(this._value);
-        return (_b = this._executionPromise) !== null && _b !== void 0 ? _b : this.execute();
-    }
-    get subscribed() {
-        return this._events.totalSubscriberCount() > 0;
-    }
-    get status() {
-        return this._status;
-    }
-    subscribe(eventOrCallback, callback) {
-        // change subscription has special behavior...
-        if (callback === undefined && typeof eventOrCallback === 'function') {
-            // accessing for side effects... eh
-            this.resolved;
-            return this._events.subscribe('change', eventOrCallback);
-        }
-        else if (eventOrCallback === 'change' && callback !== undefined) {
-            // accessing for side effects... eh
-            this.resolved;
-            return this._events.subscribe('change', callback);
-        }
-        else if (eventOrCallback === 'statusChange' &&
-            typeof callback === 'function') {
-            return this._events.subscribe(eventOrCallback, callback);
-        }
-        else {
-            throw new Error('Invalid invocation of Query.subscribe');
-        }
-    }
-}
-_a = ON_ALL_UNSUBSCRIBED;
+var _a;
+import { EventSubscriber } from '@verdant-web/common';
+import { Entity } from '../entities/Entity.js';
+import { Disposable } from '../utils/Disposable.js';
+import { filterResultSet } from './utils.js';
+export const ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
+export const UPDATE = Symbol('UPDATE');
+// export interface BaseQuery<T> {
+// 	subscribe(event: 'change', callback: (value: T) => void): () => void;
+// 	subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
+// 	subscribe(callback: (value: T) => void): () => void;
+// }
+export class BaseQuery extends Disposable {
+    constructor({ initial, context, collection, key, shouldUpdate, }) {
+        super();
+        this._internalUnsubscribes = [];
+        this._status = 'initial';
+        this._executionPromise = null;
+        this.setValue = (value) => {
+            this._rawValue = value;
+            this.subscribeToDeleteAndRestore(this._rawValue);
+            this._value = filterResultSet(value);
+            this._status = 'ready';
+            this._events.emit('change', this._value);
+        };
+        // re-applies filtering if results have changed
+        this.refreshValue = () => {
+            this.setValue(this._rawValue);
+        };
+        this.subscribeToDeleteAndRestore = (value) => {
+            var _b;
+            while (this._internalUnsubscribes.length) {
+                (_b = this._internalUnsubscribes.pop()) === null || _b === void 0 ? void 0 : _b();
+            }
+            if (Array.isArray(value)) {
+                value.forEach((entity) => {
+                    if (entity instanceof Entity) {
+                        this._internalUnsubscribes.push(entity.subscribe('delete', this.refreshValue));
+                        this._internalUnsubscribes.push(entity.subscribe('restore', this.refreshValue));
+                    }
+                });
+            }
+            else if (value instanceof Entity) {
+                this._internalUnsubscribes.push(value.subscribe('delete', this.refreshValue));
+                this._internalUnsubscribes.push(value.subscribe('restore', () => {
+                    this.refreshValue();
+                }));
+            }
+        };
+        this.execute = () => {
+            this.context.log('debug', 'Executing query', this.key);
+            if (this._status === 'initial') {
+                this._status = 'initializing';
+            }
+            else if (this._status === 'ready') {
+                this._status = 'revalidating';
+            }
+            // no status change needed if already in a 'running' status.
+            this._executionPromise = this.run()
+                .then(() => this._value)
+                .catch((err) => {
+                if (err instanceof Error) {
+                    if (err.name === 'InvalidStateError' ||
+                        err.name === 'InvalidAccessError') {
+                        // possibly accessing db while it's closed. not much we can do.
+                        return this._value;
+                    }
+                }
+                throw err;
+            });
+            return this._executionPromise;
+        };
+        this[_a] = (handler) => {
+            this._allUnsubscribedHandler = handler;
+        };
+        this._rawValue = initial;
+        this._value = initial;
+        this._events = new EventSubscriber((event) => {
+            var _b;
+            if (event === 'change')
+                (_b = this._allUnsubscribedHandler) === null || _b === void 0 ? void 0 : _b.call(this, this);
+        });
+        this.context = context;
+        this.key = key;
+        this.collection = collection;
+        const shouldUpdateFn = shouldUpdate ||
+            ((collections) => collections.includes(collection));
+        this.addDispose(this.context.entityEvents.subscribe('collectionsChanged', (collections) => {
+            if (shouldUpdateFn(collections)) {
+                this.context.log('info', 'Updating query', this.key);
+                this.execute();
+            }
+        }));
+    }
+    get current() {
+        return this._value;
+    }
+    get resolved() {
+        var _b;
+        if (this.status === 'ready')
+            return Promise.resolve(this._value);
+        return (_b = this._executionPromise) !== null && _b !== void 0 ? _b : this.execute();
+    }
+    get subscribed() {
+        return this._events.totalSubscriberCount() > 0;
+    }
+    get status() {
+        return this._status;
+    }
+    subscribe(eventOrCallback, callback) {
+        // change subscription has special behavior...
+        if (callback === undefined && typeof eventOrCallback === 'function') {
+            // accessing for side effects... eh
+            this.resolved;
+            return this._events.subscribe('change', eventOrCallback);
+        }
+        else if (eventOrCallback === 'change' && callback !== undefined) {
+            // accessing for side effects... eh
+            this.resolved;
+            return this._events.subscribe('change', callback);
+        }
+        else if (eventOrCallback === 'statusChange' &&
+            typeof callback === 'function') {
+            return this._events.subscribe(eventOrCallback, callback);
+        }
+        else {
+            throw new Error('Invalid invocation of Query.subscribe');
+        }
+    }
+}
+_a = ON_ALL_UNSUBSCRIBED;
 //# sourceMappingURL=BaseQuery.js.map