shelving 1.38.0 → 1.39.0

package/api/Resource.js

@@ -1,4 +1,4 @@
-import { GET_UNDEFINED, validate } from "../util/index.js";
+import { UNDEFINED, validate } from "../util/index.js";
 import { Feedback } from "../feedback/index.js";
 import { ResourceValidationError } from "./errors.js";
 /**
@@ -37,6 +37,6 @@ export class Resource {
         }
     }
 }
-export function RESOURCE(payload = GET_UNDEFINED, result = GET_UNDEFINED) {
+export function RESOURCE(payload = UNDEFINED, result = UNDEFINED) {
     return new Resource(payload, result);
 }

package/db/Database.d.ts

@@ -1,4 +1,4 @@
-import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher, Nullish } from "../util/index.js";
+import { Entry, Observable, Observer, Result, Unsubscriber, Results, Validatable, Validator, Key, Data, Entries, Datas, Validators, ValidatorType, Dispatcher, Nullish } from "../util/index.js";
 import { PropUpdates, Update } from "../update/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
@@ -24,7 +24,7 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     write(...writes: Nullish<Write>[]): Promise<Write>;
 }
 /** 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>> {
+export declare class DataQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Entries<T>>, Iterable<Entry<T>> {
     readonly provider: Provider;
     readonly validator: Validator<T>;
     readonly collection: string;
@@ -43,12 +43,12 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get results(): Results<T> | PromiseLike<Results<T>>;
+    get entries(): Entries<T> | PromiseLike<Entries<T>>;
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get resultsMap(): ResultsMap<T> | PromiseLike<ResultsMap<T>>;
+    get results(): Results<T> | PromiseLike<Results<T>>;
     /**
      * Count the number of results of this set of documents.
      * @return Number of documents matching the query (possibly promised).
@@ -81,14 +81,6 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      * @return Function that ends the subscription.
      */
     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 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>]>): Unsubscriber;
     /**
      * Set all matching documents to the same exact value.
      *
@@ -111,11 +103,11 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator](): Iterator<Entry<T>, void>;
     /** Validate a set of results for this query reference. */
-    validate(unsafeEntries: Results): Results<T>;
+    validate(unsafeEntries: Entries): Entries<T>;
     toString(): string;
 }
 /** Get the data for a document from a result for that document. */
-export declare function getQueryData<T extends Data>(results: Results<T>, ref: DataQuery<T>): Entry<T>;
+export declare function getQueryData<T extends Data>(entries: Entries<T>, ref: DataQuery<T>): Entry<T>;
 /** A document reference within a specific database. */
 export declare class DataDocument<T extends Data = Data> implements Observable<Result<T>>, Validatable<T> {
     readonly provider: Provider;

package/db/Database.js

@@ -1,4 +1,4 @@
-import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, NOT_NULLISH, hasItems, } from "../util/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, getMap, countItems, isNotNullish, hasItems, ResultsObserver, } from "../util/index.js";
 import { DataUpdate, Update } from "../update/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
@@ -27,11 +27,11 @@ export class Database {
     }
     /** Create a writer for this database from a set of separate writes. */
     writer(...writes) {
-        return new Writes(...writes.filter(NOT_NULLISH));
+        return new Writes(...writes.filter(isNotNullish));
     }
     /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
     async write(...writes) {
-        const write = new Writes(...writes.filter(NOT_NULLISH));
+        const write = new Writes(...writes.filter(isNotNullish));
         await write.transform(this);
         return write;
     }
@@ -62,29 +62,29 @@ export class DataQuery extends Query {
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get results() {
+    get entries() {
         return this.provider.getQuery(this);
     }
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get resultsMap() {
-        return callAsync(toMap, this.provider.getQuery(this));
+    get results() {
+        return callAsync(getMap, this.provider.getQuery(this));
     }
     /**
      * Count the number of results of this set of documents.
      * @return Number of documents matching the query (possibly promised).
      */
     get count() {
-        return callAsync(countItems, this.results);
+        return callAsync(countItems, this.entries);
     }
     /**
      * Does at least one document exist for this query?
      * @return `true` if a document exists or `false` otherwise (possibly promised).
      */
     get exists() {
-        return callAsync(hasItems, this.max(1).results);
+        return callAsync(hasItems, this.provider.getQuery(this.max(1)));
     }
     /**
      * Get an entry for the first document matched by this query or `undefined` if this query has no results.
@@ -93,7 +93,7 @@ export class DataQuery extends Query {
      * @throws RequiredError if there were no results for this query.
      */
     get result() {
-        return callAsync(getFirstItem, this.max(1).results);
+        return callAsync(getFirstItem, this.provider.getQuery(this.max(1)));
     }
     /**
      * Get an entry for the first document matched by this query.
@@ -102,7 +102,7 @@ export class DataQuery extends Query {
      * @throws RequiredError if there were no results for this query.
      */
     get data() {
-        return callAsync(getQueryData, this.max(1).results, this);
+        return callAsync(getQueryData, this.provider.getQuery(this.max(1)), this);
     }
     /**
      * Subscribe to all matching documents.
@@ -112,17 +112,7 @@ export class DataQuery extends Query {
      * @return Function that ends the subscription.
      */
     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 next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
-     * @return Function that ends the subscription.
-     */
-    subscribeMap(next) {
-        return this.provider.subscribeQuery(this, new TransformObserver(toMap, typeof next === "function" ? { next } : next));
+        return this.provider.subscribeQuery(this, new ResultsObserver(typeof next === "function" ? { next } : next));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -151,7 +141,7 @@ export class DataQuery extends Query {
     }
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator]() {
-        return throwAsync(this.results)[Symbol.iterator]();
+        return throwAsync(this.entries)[Symbol.iterator]();
     }
     /** Validate a set of results for this query reference. */
     *validate(unsafeEntries) {
@@ -177,8 +167,8 @@ export class DataQuery extends Query {
     }
 }
 /** Get the data for a document from a result for that document. */
-export function getQueryData(results, ref) {
-    const first = getFirstItem(results);
+export function getQueryData(entries, ref) {
+    const first = getFirstItem(entries);
     if (first)
         return first;
     throw new QueryRequiredError(ref);

package/db/Pagination.d.ts

@@ -1,4 +1,4 @@
-import { ResultsMap, Entry, Results, Data } from "../util/index.js";
+import { Results, Entry, Entries, Data } from "../util/index.js";
 import { State } from "../stream/index.js";
 import { DataQuery } from "./Database.js";
 /**
@@ -6,7 +6,7 @@ import { DataQuery } from "./Database.js";
  * - If you pass in initial values, it will use that as the first page.
  * - If you don't pass in initial values, it will autoload the first page.
  */
-export declare class Pagination<T extends Data> extends State<ResultsMap<T>> implements Iterable<Entry<T>> {
+export declare class Pagination<T extends Data> extends State<Results<T>> implements Iterable<Entry<T>> {
     protected _pending: boolean;
     readonly ref: DataQuery<T>;
     readonly limit: number;
@@ -20,7 +20,7 @@ export declare class Pagination<T extends Data> extends State<ResultsMap<T>> imp
      * Merge more results into this pagination.
      * @return The change in the number of results.
      */
-    merge(more: Results<T>): void;
+    merge(more: Entries<T>): void;
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator](): Iterator<Entry<T>>;
 }

package/db/Pagination.js

@@ -1,4 +1,4 @@
-import { getLastItem, assertNumber, yieldMerged, toMap, LOADING, assertMaximum } from "../util/index.js";
+import { getLastItem, assertNumber, yieldMerged, getMap, LOADING, assertMax } from "../util/index.js";
 import { State } from "../stream/index.js";
 import { ConditionError } from "../index.js";
 /**
@@ -22,7 +22,7 @@ export class Pagination extends State {
                 if (!this.loading) {
                     const lastItem = getLastItem(this.value);
                     if (lastItem) {
-                        const next = await this.ref.after(lastItem[0], lastItem[1]).resultsMap;
+                        const next = await this.ref.after(lastItem[0], lastItem[1]).results;
                         this.merge(next);
                         if (next.size < this.limit)
                             this.complete();
@@ -31,7 +31,7 @@ export class Pagination extends State {
                     }
                 }
                 this._value === LOADING;
-                const next = await this.ref.resultsMap;
+                const next = await this.ref.results;
                 this.next(next);
                 if (next.size < this.limit)
                     this.complete();
@@ -40,7 +40,7 @@ export class Pagination extends State {
         };
         this.ref = ref;
         assertNumber(ref.limit); // Collection must have a numeric limit to paginate (otherwise you'd be retrieving the entire set of documents).
-        assertMaximum(ref.sorts.size, 1); // Collection must have at least one sort order to paginate.
+        assertMax(ref.sorts.size, 1); // Collection must have at least one sort order to paginate.
         this.limit = ref.limit;
     }
     /**
@@ -48,7 +48,7 @@ export class Pagination extends State {
      * @return The change in the number of results.
      */
     merge(more) {
-        this.next(toMap(this.ref.sorts.transform(yieldMerged(more, this.value))));
+        this.next(getMap(this.ref.sorts.transform(yieldMerged(more, this.value))));
     }
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator]() {

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore";
-import { Results, Provider, DataDocument, DataQuery, Result, Observer, Update, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
+import { Entries, Provider, DataDocument, DataQuery, Result, Observer, Update, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -15,8 +15,8 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
     deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Provider, DataDocument, DataQuery, Result, Update, AsynchronousProvider, Data, Results, Unsubscriber } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Result, Update, AsynchronousProvider, Data, Entries, Unsubscriber } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -15,7 +15,7 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Entries<T>>;
     subscribeQuery(): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,5 +1,5 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Provider, DataDocument, DataQuery, Observer, Result, Update, Data, AsynchronousProvider, Entry, Results, Unsubscriber } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Observer, Result, Update, Data, AsynchronousProvider, Entry, Entries, Unsubscriber } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -14,7 +14,7 @@ export declare class FirestoreServerProvider extends Provider implements Asynchr
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
     deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;

package/package.json

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

package/provider/BatchProvider.d.ts

@@ -1,4 +1,4 @@
-import { MutableObject, Result, Observer, Unsubscriber, Observable, Results, ResultsMap, Data } from "../util/index.js";
+import { MutableObject, Result, Observer, Unsubscriber, Observable, Entries, Results, Data } from "../util/index.js";
 import type { DataDocument, DataQuery } from "../db/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /**
@@ -19,8 +19,8 @@ export declare class BatchProvider extends ThroughProvider {
     /** Await a result and delete it from get requests when done. */
     private _awaitDocument;
     subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | Promise<Results<T>>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | Promise<Entries<T>>;
     /** Await a set of results and delete from get requests when done. */
     private _awaitDocuments;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<ResultsMap<T>>): Unsubscriber;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
 }

package/provider/BatchProvider.js

@@ -1,4 +1,4 @@
-import { isAsync, toMap, TransformObserver, awaitNext } from "../util/index.js";
+import { isAsync, getMap, awaitNext, ResultsObserver } 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. */
@@ -66,7 +66,7 @@ export class BatchProvider extends ThroughProvider {
     /** Await a set of results and delete from get requests when done. */
     async _awaitDocuments(ref, asyncResults) {
         // Convert the iterable to a map because it might be read multiple times.
-        const results = toMap(await asyncResults);
+        const results = getMap(await asyncResults);
         const key = ref.toString();
         delete this._gets[key];
         return results;
@@ -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 TransformObserver(toMap, o));
+            const stop = super.subscribeQuery(ref, new ResultsObserver(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.d.ts

@@ -1,6 +1,6 @@
 import type { DataDocument, DataQuery } from "../db/index.js";
 import { Update } from "../update/index.js";
-import { Result, Unsubscriber, Observer, Results, Data } from "../util/index.js";
+import { Result, Unsubscriber, Observer, Entries, Data } from "../util/index.js";
 import type { Provider, AsynchronousProvider } from "./Provider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
@@ -23,10 +23,10 @@ export declare class CacheProvider extends ThroughProvider implements Asynchrono
     set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
-    /** Cache a set of document results. */
-    private _cacheResults;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    /** Cache a set of document entries. */
+    private _cacheEntries;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
     deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;

package/provider/CacheProvider.js

@@ -53,17 +53,17 @@ export class CacheProvider extends ThroughProvider {
         await super.delete(ref);
         this.cache.delete(ref);
     }
-    /** Cache a set of document results. */
-    *_cacheResults(ref, results) {
+    /** Cache a set of document entries. */
+    *_cacheEntries(ref, entries) {
         // We know the received set of results is the 'complete' set of results for this query.
         // So for correctness any documents matching this query that aren't in the new set of results should be deleted.
         // None of this applies if there's a query limit, because the document could have been moved to a different page so shouldn't be deleted.
         if (!ref.limit)
             for (const id of Object.keys(this.cache.getQuery(ref)))
-                if (!(id in results))
+                if (!(id in entries))
                     this.cache.delete(ref.doc(id));
         // Save new results to the cache.
-        for (const [id, data] of results) {
+        for (const [id, data] of entries) {
             this.cache.set(ref.doc(id), data);
             yield [id, data];
         }
@@ -72,11 +72,11 @@ export class CacheProvider extends ThroughProvider {
     }
     // Override to cache any got results.
     async getQuery(ref) {
-        return this._cacheResults(ref, await super.getQuery(ref));
+        return this._cacheEntries(ref, await super.getQuery(ref));
     }
     // Override to cache any got results.
     subscribeQuery(ref, observer) {
-        return super.subscribeQuery(ref, new TransformObserver(results => this._cacheResults(ref, results), observer));
+        return super.subscribeQuery(ref, new TransformObserver(entries => this._cacheEntries(ref, entries), observer));
     }
     async setQuery(ref, data) {
         const count = await super.setQuery(ref, data);

package/provider/MemoryProvider.d.ts

@@ -1,4 +1,4 @@
-import { Data, Result, Results, Unsubscriber, Observer } from "../util/index.js";
+import { Data, Result, Entries, Unsubscriber, Observer } from "../util/index.js";
 import { Update } from "../update/index.js";
 import { DataQuery, DataDocument } from "../db/index.js";
 import { Provider, SynchronousProvider } from "./Provider.js";
@@ -17,8 +17,8 @@ export declare class MemoryProvider extends Provider implements SynchronousProvi
     set<T extends Data>(ref: DataDocument<T>, data: T): void;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void;
     delete<T extends Data>(ref: DataDocument<T>): void;
-    getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, data: T): number;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
     deleteQuery<T extends Data>(ref: DataQuery<T>): number;

package/provider/Provider.d.ts

@@ -1,4 +1,4 @@
-import type { Observer, Unsubscriber, Result, Results, Data } from "../util/index.js";
+import type { Observer, Unsubscriber, Result, Entries, Data } from "../util/index.js";
 import type { DataDocument, DataQuery } from "../db/Database.js";
 import type { Update } from "../update/index.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
@@ -61,7 +61,7 @@ export declare abstract class Provider {
      * @param ref Documents reference specifying which collection to get documents from.
      * @return Set of results in `id: data` format.
      */
-    abstract getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
+    abstract getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -71,7 +71,7 @@ export declare abstract class Provider {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    abstract subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     /**
      * Set the data of all matching documents.
      *
@@ -102,7 +102,7 @@ export interface SynchronousProvider extends Provider {
     set<T extends Data>(ref: DataDocument<T>, value: T): void;
     update<T extends Data>(ref: DataDocument<T>, value: Update<T>): void;
     delete<T extends Data>(ref: DataDocument<T>): void;
-    getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T>;
     setQuery<T extends Data>(ref: DataQuery<T>, value: T): number;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
     deleteQuery<T extends Data>(ref: DataQuery<T>): number;
@@ -114,7 +114,7 @@ export interface AsynchronousProvider extends Provider {
     set<T extends Data>(ref: DataDocument<T>, value: T): PromiseLike<void>;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): PromiseLike<void>;
     delete<T extends Data>(ref: DataDocument<T>): PromiseLike<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<Results<T>>;
+    getQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<Entries<T>>;
     setQuery<T extends Data>(ref: DataQuery<T>, value: T): PromiseLike<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): PromiseLike<number>;
     deleteQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<number>;

package/provider/ThroughProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Result, Results, Unsubscriber, Observer, Class, Data } from "../util/index.js";
+import type { Result, Entries, Unsubscriber, Observer, Class, Data } from "../util/index.js";
 import type { DataDocument, DataQuery } from "../db/index.js";
 import type { Update } from "../update/index.js";
 import { Provider } from "./Provider.js";
@@ -14,8 +14,8 @@ export declare class ThroughProvider extends Provider {
     set<T extends Data>(ref: DataDocument<T>, data: T): void | PromiseLike<void>;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
     delete<T extends Data>(ref: DataDocument<T>): void | PromiseLike<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
     deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;

package/provider/ValidationProvider.d.ts

@@ -1,5 +1,5 @@
 import type { DataDocument, DataQuery } from "../db/index.js";
-import { Data, Result, Unsubscriber, Observer, Results } from "../util/index.js";
+import { Data, Result, Unsubscriber, Observer, Entries } from "../util/index.js";
 import { Update } from "../update/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Validates any values that are read from or written to a source provider. */
@@ -9,8 +9,8 @@ export declare class ValidationProvider extends ThroughProvider {
     add<T extends Data>(ref: DataQuery<T>, data: T): string | PromiseLike<string>;
     set<T extends Data>(ref: DataDocument<T>, value: T): void | PromiseLike<void>;
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     setQuery<T extends Data>(ref: DataQuery<T>, value: T): number | PromiseLike<number>;
     updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
 }

package/query/Filter.d.ts

@@ -1,4 +1,4 @@
-import { Data, Entry, Matchable, Results, ImmutableArray } from "../util/index.js";
+import { Data, Entry, Matchable, Entries, ImmutableArray } from "../util/index.js";
 import { Rule } from "./Rule.js";
 import { FilterOperator, QueryKey } from "./types.js";
 /**
@@ -14,13 +14,12 @@ export declare abstract class Filter<T extends Data, V extends unknown = unknown
     readonly value: V;
     constructor(key: QueryKey<T>, value: V);
     abstract match([id, data]: Entry<T>, target: void): boolean;
-    transform(results: Results<T>): Results<T>;
+    transform(entries: Entries<T>): Entries<T>;
     toString(): string;
 }
 /** Filter a set of values with an `IS` clause. */
 export declare class EqualFilter<T extends Data> extends Filter<T> {
     readonly operator = "IS";
-    readonly matcher: (item: unknown, target: unknown) => boolean;
     match([id, data]: Entry<T>): boolean;
 }
 /** Filter a set of values with an `NOT` clause. */
@@ -33,28 +32,28 @@ export declare class InArrayFilter<T extends Data> extends Filter<T, ImmutableAr
     readonly operator = "IN";
     match([id, data]: Entry<T>): boolean;
 }
-/** Filter a set of values with an `CONTAINS` clause. */
-export declare class ArrayContainsFilter<T extends Data> extends Filter<T> {
+/** Filter a set of values with a `CONTAINS` clause. */
+export declare class ArrayWithFilter<T extends Data> extends Filter<T> {
     readonly operator = "CONTAINS";
     match([id, data]: Entry<T>): boolean;
 }
 /** Filter a set of values with an `LT` clause. */
-export declare class LessThanFilter<T extends Data> extends Filter<T> {
+export declare class LessFilter<T extends Data> extends Filter<T> {
     readonly operator = "LT";
     match([id, data]: Entry<T>): boolean;
 }
 /** Filter a set of values with an `LTE` clause. */
-export declare class LessThanEqualFilter<T extends Data> extends Filter<T> {
+export declare class EqualLessFilter<T extends Data> extends Filter<T> {
     readonly operator = "LTE";
     match([id, data]: Entry<T>): boolean;
 }
 /** Filter a set of values with an `GT` clause. */
-export declare class GreaterThanFilter<T extends Data> extends Filter<T> {
+export declare class GreaterFilter<T extends Data> extends Filter<T> {
     readonly operator = "GT";
     match([id, data]: Entry<T>): boolean;
 }
 /** Filter a set of values with an `GTE` clause. */
-export declare class GreaterThanEqualFilter<T extends Data> extends Filter<T> {
+export declare class EqualGreaterFilter<T extends Data> extends Filter<T> {
     readonly operator = "GTE";
     match([id, data]: Entry<T>): boolean;
 }