shelving 1.22.1 → 1.23.2

package/db/Database.d.ts

@@ -1,7 +1,8 @@
-import { Dispatcher, Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType } from "../util/index.js";
+import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher } from "../util/index.js";
 import { Transform, Transforms } from "../transform/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
+import { DocumentWrite, Write } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -17,6 +18,8 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DataQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DataDocument<ValidatorType<V[K]>>;
+    /** Perform a write on this database. */
+    write(write: Write): void | PromiseLike<void>;
 }
 /** A documents reference within a specific database. */
 export declare class DataQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Results<T>>, Iterable<Entry<T>> {
@@ -58,26 +61,18 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next: Observer<Results<T>> | Dispatcher<Results<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribe(next: Observer<Results<T>> | Dispatcher<[Results<T>]>): Unsubscriber;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribeMap(next: Observer<ResultsMap<T>> | Dispatcher<ResultsMap<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribeMap(next: Observer<ResultsMap<T>> | Dispatcher<[ResultsMap<T>]>): Unsubscriber;
     /**
      * Set all matching documents to the same exact value.
      *
@@ -145,45 +140,26 @@ export declare class DataDocument<T extends Data = Data> implements Observable<R
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods.
-     * @param next Callback that is called once initially and again whenever the result changes.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next: Observer<Result<T>> | Dispatcher<Result<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
-    /**
-     * Set the complete data of this document.
-     *
-     * @param data Complete data to set the document to.
-     *
-     * @return Nothing (possibly promised).
-     */
+    subscribe(next: Observer<Result<T>> | Dispatcher<[Result<T>]>): Unsubscriber;
+    /** Set the complete data of this document. */
     set(data: T): void | PromiseLike<void>;
-    /**
-     * Update this document with partial data.
-     * - If the document exists, merge the partial data into it.
-     * - If the document doesn't exist, throw an error.
-     *
-     * @param transforms `Transform` instance or set of transforms to apply to the existing document.
-     * - Not all transforms may be supported by all providers.
-     *
-     * @return Nothing (possibly promised).
-     * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
-     */
+    /** Update this document. */
     update(transforms: Transform<T> | Transforms<T>): void | PromiseLike<void>;
-    /**
-     * Delete this document.
-     * - Will not throw an error if the document doesn't exist.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Delete this document. */
     delete(): void | PromiseLike<void>;
-    /**
-     * Combine `set()`, `update()`, `delete()` into a single method.
-     */
+    /** Set, update, or delete this document. */
     write(value: Result<T> | Transform<T>): void | PromiseLike<void>;
+    /** Represent a write that sets the complete data of this document in a database. */
+    setter(data: T): DocumentWrite<T>;
+    /** Represent a write that updates this document in a database. */
+    updater(transforms: Transform<T> | Transforms<T>): DocumentWrite<T>;
+    /** Represent a write that deletes this document in a database. */
+    deleter(): DocumentWrite<T>;
+    /** Represent a write that sets, updates, or deletes this document in a database. */
+    writer(value: Result<T> | Transform<T>): DocumentWrite<T>;
     /** Validate data for this query reference. */
     validate(unsafeData: Data): T;
     toString(): string;

package/db/Database.js

@@ -1,8 +1,9 @@
-import { callAsync, createObserver, getFirstItem, throwAsync, validate, toMap, countItems, DeriveObserver, } from "../util/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, } from "../util/index.js";
 import { DataTransform, Transform } from "../transform/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
 import { DocumentRequiredError, DocumentValidationError, QueryValidationError } from "./errors.js";
+import { DocumentWrite } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -24,6 +25,10 @@ export class Database {
     doc(collection, id) {
         return new DataDocument(this.provider, this.validators[collection], collection, id);
     }
+    /** Perform a write on this database. */
+    write(write) {
+        return write.transform(this);
+    }
 }
 /** A documents reference within a specific database. */
 export class DataQuery extends Query {
@@ -79,29 +84,21 @@ export class DataQuery extends Query {
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next, error, complete) {
-        return this.provider.subscribeQuery(this, createObserver(next, error, complete));
+    subscribe(next) {
+        return this.provider.subscribeQuery(this, typeof next === "function" ? { next } : next);
     }
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribeMap(next, error, complete) {
-        return this.provider.subscribeQuery(this, new DeriveObserver(toMap, createObserver(next, error, complete)));
+    subscribeMap(next) {
+        return this.provider.subscribeQuery(this, new TransformObserver(toMap, typeof next === "function" ? { next } : next));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -210,55 +207,44 @@ export class DataDocument {
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods.
-     * @param next Callback that is called once initially and again whenever the result changes.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next, error, complete) {
-        return this.provider.subscribe(this, createObserver(next, error, complete));
+    subscribe(next) {
+        return this.provider.subscribe(this, typeof next === "function" ? { next } : next);
     }
-    /**
-     * Set the complete data of this document.
-     *
-     * @param data Complete data to set the document to.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Set the complete data of this document. */
     set(data) {
         return this.write(data);
     }
-    /**
-     * Update this document with partial data.
-     * - If the document exists, merge the partial data into it.
-     * - If the document doesn't exist, throw an error.
-     *
-     * @param transforms `Transform` instance or set of transforms to apply to the existing document.
-     * - Not all transforms may be supported by all providers.
-     *
-     * @return Nothing (possibly promised).
-     * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
-     */
+    /** Update this document. */
     update(transforms) {
         return this.write(transforms instanceof Transform ? transforms : new DataTransform(transforms));
     }
-    /**
-     * Delete this document.
-     * - Will not throw an error if the document doesn't exist.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Delete this document. */
     delete() {
         return this.write(undefined);
     }
-    /**
-     * Combine `set()`, `update()`, `delete()` into a single method.
-     */
+    /** Set, update, or delete this document. */
     write(value) {
         return this.provider.write(this, value);
     }
+    /** Represent a write that sets the complete data of this document in a database. */
+    setter(data) {
+        return this.writer(data);
+    }
+    /** Represent a write that updates this document in a database. */
+    updater(transforms) {
+        return this.writer(transforms instanceof Transform ? transforms : new DataTransform(transforms));
+    }
+    /** Represent a write that deletes this document in a database. */
+    deleter() {
+        return this.writer(undefined);
+    }
+    /** Represent a write that sets, updates, or deletes this document in a database. */
+    writer(value) {
+        return new DocumentWrite(this, value);
+    }
     /** Validate data for this query reference. */
     validate(unsafeData) {
         try {

package/db/Pagination.js

@@ -71,7 +71,7 @@ export class Pagination extends State {
      * @return The change in the number of results.
      */
     merge(more) {
-        this.next(toMap(this.ref.sorts.derive(yieldMerged(more, this.value))));
+        this.next(toMap(this.ref.sorts.transform(yieldMerged(more, this.value))));
     }
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator]() {

package/db/Write.d.ts

@@ -0,0 +1,30 @@
+import { Transform } from "../transform/index.js";
+import { ImmutableArray, Data, Transformable } from "../util/index.js";
+import type { Database, DataDocument } from "./Database.js";
+/** Write to a database. */
+export declare abstract class Write implements Transformable<Database, void | PromiseLike<void>> {
+    abstract transform(db: Database): void | PromiseLike<void>;
+}
+/** Represent a write made to a single document in a database. */
+export declare class DocumentWrite<T extends Data> extends Write {
+    readonly collection: string;
+    readonly id: string;
+    readonly value: Data | Transform<Data> | undefined;
+    constructor({ collection, id }: DataDocument<T>, value: T | Transform<T> | undefined);
+    transform(db: Database): Promise<void>;
+}
+/**
+ * Represent a list of writes made to a database.
+ * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
+ * - Every write must be applied to a specific database document in a specific collection and are applied in the specified order.
+ */
+export declare class Writes extends Write {
+    readonly writes: ImmutableArray<Write>;
+    constructor(...writes: Write[]);
+    transform(db: Database): Promise<void>;
+}
+/** Set of hydrations for all change classes. */
+export declare const WRITE_HYDRATIONS: {
+    writes: typeof Writes;
+    write: typeof DocumentWrite;
+};

package/db/Write.js

@@ -0,0 +1,37 @@
+import { transform } from "../util/index.js";
+/** Write to a database. */
+export class Write {
+}
+/** Represent a write made to a single document in a database. */
+export class DocumentWrite extends Write {
+    constructor({ collection, id }, value) {
+        super();
+        this.collection = collection;
+        this.id = id;
+        this.value = value;
+    }
+    async transform(db) {
+        await db.doc(this.collection, this.id).write(this.value);
+    }
+}
+/**
+ * Represent a list of writes made to a database.
+ * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
+ * - Every write must be applied to a specific database document in a specific collection and are applied in the specified order.
+ */
+export class Writes extends Write {
+    constructor(...writes) {
+        super();
+        this.writes = writes;
+    }
+    async transform(db) {
+        for (const writes of this.writes)
+            await transform(db, writes);
+    }
+}
+/** Set of hydrations for all change classes. */
+export const WRITE_HYDRATIONS = {
+    writes: Writes,
+    write: DocumentWrite,
+};
+WRITE_HYDRATIONS;

package/db/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./Database.js";
-export * from "./Change.js";
 export * from "./Pagination.js";
+export * from "./Write.js";
 export * from "./errors.js";

package/db/index.js

@@ -1,4 +1,4 @@
 export * from "./Database.js";
-export * from "./Change.js";
 export * from "./Pagination.js";
+export * from "./Write.js";
 export * from "./errors.js";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore";
-import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data } from "../../index.js";
+import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -10,10 +10,10 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
     write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
     writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -88,7 +88,7 @@ export class FirestoreClientProvider extends Provider {
         return snapshot.data();
     }
     subscribe(ref, observer) {
-        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(snapshot.data(), observer), thrown => dispatchError(thrown, observer));
+        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
         const reference = await addDoc(getCollection(this.firestore, ref), data); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -106,7 +106,7 @@ export class FirestoreClientProvider extends Provider {
         return getResults(await getDocs(getQuery(this.firestore, ref)));
     }
     subscribeQuery(ref, observer) {
-        return onSnapshot(getQuery(this.firestore, ref), snapshot => dispatchNext(getResults(snapshot), observer), thrown => dispatchError(thrown, observer));
+        return onSnapshot(getQuery(this.firestore, ref), snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async writeQuery(ref, value) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results, Unsubscriber } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -10,10 +10,10 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe(): () => void;
+    subscribe(): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
     write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
-    subscribeQuery(): () => void;
+    subscribeQuery(): Unsubscriber;
     writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,5 +1,5 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results, Unsubscriber } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -8,10 +8,10 @@ export declare class FirestoreServerProvider extends Provider implements Asynchr
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
     write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
     writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.js

@@ -85,7 +85,7 @@ export class FirestoreServerProvider extends Provider {
         return (await getDocument(this.firestore, ref).get()).data();
     }
     subscribe(ref, observer) {
-        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(snapshot.data(), observer), thrown => dispatchError(thrown, observer));
+        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
         return (await getCollection(this.firestore, ref).add(data)).id;
@@ -102,7 +102,7 @@ export class FirestoreServerProvider extends Provider {
         return getResults(await getQuery(this.firestore, ref).get());
     }
     subscribeQuery(ref, observer) {
-        return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(getResults(snapshot), observer), thrown => dispatchError(thrown, observer));
+        return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async writeQuery(ref, value) {
         const writer = this.firestore.bulkWriter();

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.22.1",
+	"version": "1.23.2",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/BatchProvider.js

@@ -1,4 +1,4 @@
-import { isAsync, toMap, DeriveObserver, awaitNext, } from "../util/index.js";
+import { isAsync, toMap, TransformObserver, awaitNext, } from "../util/index.js";
 import { LazyState } from "../stream/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** How long to wait after all subscriptions have ended to close the source subscription. */
@@ -80,7 +80,7 @@ export class BatchProvider extends ThroughProvider {
         const sub = ((_a = this._subs)[key] || (_a[key] = new LazyState(STOP_DELAY).from(o => {
             var _a;
             // Convert the iterable to a map because it might be read multiple times.
-            const stop = super.subscribeQuery(ref, new DeriveObserver(toMap, o));
+            const stop = super.subscribeQuery(ref, new TransformObserver(toMap, o));
             // The first value from the subscription can be reused for any concurrent get requests.
             (_a = this._gets)[key] || (_a[key] = this._awaitDocuments(ref, awaitNext(sub)));
             return () => {

package/provider/CacheProvider.js

@@ -1,5 +1,5 @@
 import { Transform } from "../transform/index.js";
-import { DeriveObserver } from "../util/index.js";
+import { TransformObserver } from "../util/index.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
@@ -33,7 +33,7 @@ export class CacheProvider extends ThroughProvider {
     }
     // Override to cache any got results.
     subscribe(ref, observer) {
-        return super.subscribe(ref, new DeriveObserver(result => this._cacheResult(ref, result), observer));
+        return super.subscribe(ref, new TransformObserver(result => this._cacheResult(ref, result), observer));
     }
     async add(ref, data) {
         const id = await super.add(ref, data);
@@ -72,7 +72,7 @@ export class CacheProvider extends ThroughProvider {
     }
     // Override to cache any got results.
     subscribeQuery(ref, observer) {
-        return super.subscribeQuery(ref, new DeriveObserver(results => this._cacheResults(ref, results), observer));
+        return super.subscribeQuery(ref, new TransformObserver(results => this._cacheResults(ref, results), observer));
     }
     async writeQuery(ref, value) {
         await super.writeQuery(ref, value);

package/provider/MemoryProvider.js

@@ -1,4 +1,4 @@
-import { randomId, dispatch, dispatchNext, isMapEqual } from "../util/index.js";
+import { randomId, dispatchNext, isMapEqual, } from "../util/index.js";
 import { Transform } from "../transform/index.js";
 import { DocumentRequiredError } from "../db/index.js";
 import { Provider } from "./Provider.js";
@@ -25,10 +25,10 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         const id = ref.id;
         // Call next() immediately with initial results.
-        dispatchNext(table.data.get(id), observer);
+        dispatchNext(observer, table.data.get(id));
         // Call next() every time the collection changes.
         return table.on(changes => {
-            changes.has(id) && dispatchNext(changes.get(id), observer);
+            changes.has(id) && dispatchNext(observer, changes.get(id));
         });
     }
     add(ref, data) {
@@ -46,20 +46,20 @@ export class MemoryProvider extends Provider {
             const existing = table.data.get(id);
             if (!existing)
                 throw new DocumentRequiredError(ref);
-            table.write(id, value.derive(existing));
+            table.write(id, value.transform(existing));
         }
         else {
             table.write(id, value);
         }
     }
     getQuery(ref) {
-        return ref.derive(this._table(ref).data);
+        return ref.transform(this._table(ref).data);
     }
     subscribeQuery(ref, observer) {
         const table = this._table(ref);
         // Call `next()` immediately with the initial results.
-        let lastResults = new Map(ref.derive(table.data));
-        dispatchNext(lastResults, observer);
+        let lastResults = new Map(ref.transform(table.data));
+        dispatchNext(observer, lastResults);
         // Possibly call `next()` when the collection changes if any changes affect the subscription.
         return table.on(changes => {
             for (const [id, next] of changes) {
@@ -68,10 +68,10 @@ export class MemoryProvider extends Provider {
                 // 2) the next document matches the query so might be added to the next results.
                 // Re-running the entire query is not the most efficient way to do this, but itis the most simple!
                 if (lastResults.has(id) || (next && ref.match([id, next]))) {
-                    const nextResults = new Map(ref.derive(table.data));
+                    const nextResults = new Map(ref.transform(table.data));
                     if (!isMapEqual(lastResults, nextResults)) {
                         lastResults = nextResults;
-                        dispatchNext(lastResults, observer);
+                        dispatchNext(observer, lastResults);
                     }
                     return;
                 }
@@ -82,8 +82,8 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id, existing] of ref.limit ? ref.derive(table.data) : ref.filters.derive(table.data))
-            table.write(id, value instanceof Transform ? value.derive(existing) : value);
+        for (const [id, existing] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+            table.write(id, value instanceof Transform ? value.transform(existing) : value);
     }
     /** Reset this provider and clear all data. */
     reset() {
@@ -99,11 +99,11 @@ class Table {
     constructor() {
         this.data = new Map();
         this.changes = new Map();
-        this.dispatchers = new Set();
+        this.listeners = new Set();
         this.fire = () => {
             if (this.changes.size) {
-                for (const dispatcher of this.dispatchers)
-                    dispatch(this.changes, dispatcher);
+                for (const dispatcher of this.listeners)
+                    dispatcher(this.changes);
                 this.changes.clear();
             }
         };
@@ -120,16 +120,16 @@ class Table {
             this.changes.set(id, value);
         }
     }
-    on(dispatcher) {
-        this.dispatchers.add(dispatcher);
-        return this.off.bind(this, dispatcher);
+    on(listener) {
+        this.listeners.add(listener);
+        return this.off.bind(this, listener);
     }
-    off(dispatcher) {
-        this.dispatchers.delete(dispatcher);
+    off(listener) {
+        this.listeners.delete(listener);
     }
     reset() {
         this.data.clear();
         this.changes.clear();
-        this.dispatchers.clear();
+        this.listeners.clear();
     }
 }

package/query/Filter.d.ts

@@ -17,7 +17,7 @@ export declare abstract class Filter<T extends Data> extends Rule<T> implements
     readonly value: unknown;
     constructor(key: QueryKey<T>, value: unknown);
     match([id, data]: Entry<T>): boolean;
-    derive(results: Results<T>): Results<T>;
+    transform(results: Results<T>): Results<T>;
     toString(): string;
 }
 /** Filter a set of values with an `IS` clause. */

package/query/Filter.js

@@ -10,7 +10,7 @@ export class Filter extends Rule {
     match([id, data]) {
         return match(getQueryProp(id, data, this.key), this.matcher, this.value);
     }
-    derive(results) {
+    transform(results) {
         return filterItems(results, this);
     }
     toString() {

package/query/Filters.d.ts

@@ -13,5 +13,5 @@ export declare class Filters<T extends Data> extends Rules<T, Filter<T>> impleme
     gt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
     gte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
     match(entry: Entry<T>): boolean;
-    derive(iterable: Results<T>): Results<T>;
+    transform(iterable: Results<T>): Results<T>;
 }

package/query/Filters.js

@@ -33,7 +33,7 @@ export class Filters extends Rules {
                 return false;
         return true;
     }
-    derive(iterable) {
+    transform(iterable) {
         return this._rules.length ? filterItems(iterable, this) : iterable;
     }
 }

package/query/Query.d.ts

@@ -25,6 +25,6 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     max(limit: number | null): this;
     after(id: string, data: T): this;
     before(id: string, data: T): this;
-    derive(results: Results<T>): Results<T>;
+    transform(results: Results<T>): Results<T>;
     toString(): string;
 }