shelving 1.30.3 → 1.32.0

package/db/Database.d.ts

@@ -55,12 +55,19 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      */
     get count(): number | PromiseLike<number>;
     /**
-     * Get an entry for the first document matching this query.
+     * Get an entry for the first document matched by this query or `undefined` if this query has no results.
      *
      * @return Entry in `[id, data]` format for the first document.
      * @throws RequiredError if there were no results for this query.
      */
-    get first(): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+    get result(): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+    /**
+     * Get an entry for the first document matched by this query.
+     *
+     * @return Entry in `[id, data]` format for the first document.
+     * @throws RequiredError if there were no results for this query.
+     */
+    get data(): Entry<T> | PromiseLike<Entry<T>>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -103,7 +110,7 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
     toString(): string;
 }
 /** Get the data for a document from a result for that document. */
-export declare function getQueryFirst<T extends Data>(results: Results<T>, ref: DataQuery<T>): Entry<T>;
+export declare function getQueryData<T extends Data>(results: Results<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

@@ -80,13 +80,22 @@ export class DataQuery extends Query {
         return callAsync(countItems, this.results);
     }
     /**
-     * Get an entry for the first document matching this query.
+     * Get an entry for the first document matched by this query or `undefined` if this query has no results.
      *
      * @return Entry in `[id, data]` format for the first document.
      * @throws RequiredError if there were no results for this query.
      */
-    get first() {
-        return callAsync(getQueryFirst, this.max(1).results, this);
+    get result() {
+        return callAsync(getFirstItem, this.max(1).results);
+    }
+    /**
+     * Get an entry for the first document matched by this query.
+     *
+     * @return Entry in `[id, data]` format for the first document.
+     * @throws RequiredError if there were no results for this query.
+     */
+    get data() {
+        return callAsync(getQueryData, this.max(1).results, this);
     }
     /**
      * Subscribe to all matching documents.
@@ -161,7 +170,7 @@ export class DataQuery extends Query {
     }
 }
 /** Get the data for a document from a result for that document. */
-export function getQueryFirst(results, ref) {
+export function getQueryData(results, ref) {
     const first = getFirstItem(results);
     if (first)
         return first;

package/firestore/client/FirestoreClientProvider.js

@@ -1,5 +1,5 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
-import { Provider, dispatchNext, dispatchError, Update, EntriesUpdate, Increment, DataUpdate, AssertionError, ItemsUpdate, UnsupportedError, } from "../../index.js";
+import { Provider, dispatchNext, dispatchError, Update, ObjectUpdate, Increment, DataUpdate, AssertionError, ArrayUpdate, UnsupportedError, } from "../../index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -56,9 +56,9 @@ function* yieldFieldValues(updates, prefix = "") {
             yield [`${prefix}${key}`, update !== undefined ? update : firestoreDeleteField()];
         else if (update instanceof Increment)
             yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
-        else if (update instanceof DataUpdate || update instanceof EntriesUpdate)
+        else if (update instanceof DataUpdate || update instanceof ObjectUpdate)
             yield* yieldFieldValues(update, `${prefix}${key}.`);
-        else if (update instanceof ItemsUpdate) {
+        else if (update instanceof ArrayUpdate) {
             if (update.adds.length && update.deletes.length)
                 throw new UnsupportedError("Cannot add/delete array items in one update");
             if (update.adds.length)
@@ -82,11 +82,10 @@ export class FirestoreClientProvider extends Provider {
         this.firestore = firestore;
     }
     async get(ref) {
-        const snapshot = await getDoc(getDocument(this.firestore, ref));
-        return snapshot.data();
+        return (await getDoc(getDocument(this.firestore, ref))).data() || null;
     }
     subscribe(ref, observer) {
-        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
+        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(observer, snapshot.data() || null), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
         const reference = await addDoc(getCollection(this.firestore, ref), data);

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,5 +1,5 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, setDoc, addDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore/lite";
-import { Provider, Update, EntriesUpdate, Increment, AssertionError, DataUpdate, ItemsUpdate, UnsupportedError, } from "../../index.js";
+import { Provider, Update, ObjectUpdate, Increment, AssertionError, DataUpdate, ArrayUpdate, UnsupportedError, } from "../../index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -56,9 +56,9 @@ function* yieldFieldValues(updates, prefix = "") {
             yield [`${prefix}${key}`, update !== undefined ? update : firestoreDeleteField()];
         else if (update instanceof Increment)
             yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
-        else if (update instanceof DataUpdate || update instanceof EntriesUpdate)
+        else if (update instanceof DataUpdate || update instanceof ObjectUpdate)
             yield* yieldFieldValues(update, `${prefix}${key}.`);
-        else if (update instanceof ItemsUpdate) {
+        else if (update instanceof ArrayUpdate) {
             if (update.adds.length && update.deletes.length)
                 throw new UnsupportedError("Cannot add/delete array items in one update");
             if (update.adds.length)
@@ -83,7 +83,7 @@ export class FirestoreClientProvider extends Provider {
     }
     async get(ref) {
         const snapshot = await getDoc(getDocument(this.firestore, ref));
-        return snapshot.data();
+        return snapshot.data() || null;
     }
     subscribe() {
         throw new Error("FirestoreLiteProvider does not support realtime subscriptions");

package/firestore/server/FirestoreServerProvider.js

@@ -1,5 +1,5 @@
 import { Firestore, FieldValue } from "@google-cloud/firestore";
-import { Provider, dispatchNext, dispatchError, Update, Increment, DataUpdate, AssertionError, ItemsUpdate, UnsupportedError, EntriesUpdate, } from "../../index.js";
+import { Provider, dispatchNext, dispatchError, Update, Increment, DataUpdate, AssertionError, ArrayUpdate, UnsupportedError, ObjectUpdate, } from "../../index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -56,9 +56,9 @@ function* yieldFieldValues(updates, prefix = "") {
             yield [`${prefix}${key}`, update !== undefined ? update : FieldValue.delete()];
         if (update instanceof Increment)
             yield [`${prefix}${key}`, FieldValue.increment(update.amount)];
-        else if (update instanceof DataUpdate || update instanceof EntriesUpdate)
+        else if (update instanceof DataUpdate || update instanceof ObjectUpdate)
             yield* yieldFieldValues(update, `${prefix}${key}.`);
-        else if (update instanceof ItemsUpdate) {
+        else if (update instanceof ArrayUpdate) {
             if (update.adds.length && update.deletes.length)
                 throw new UnsupportedError("Cannot add/delete array items in one update");
             if (update.adds.length)
@@ -80,10 +80,10 @@ export class FirestoreServerProvider extends Provider {
         this.firestore = firestore;
     }
     async get(ref) {
-        return (await getDocument(this.firestore, ref).get()).data();
+        return (await getDocument(this.firestore, ref).get()).data() || null;
     }
     subscribe(ref, observer) {
-        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
+        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, snapshot.data() || null), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
         return (await getCollection(this.firestore, ref).add(data)).id;

package/markup/helpers.js

@@ -37,13 +37,7 @@ export function nodeToHtml(node) {
     }
     return "";
 }
-const propToString = ([key, value]) => value === true
-    ? key
-    : typeof value === "number" && Number.isFinite(value)
-        ? `${key}="${value.toString()}"`
-        : typeof value === "string"
-            ? `${key}=${serialise(value)}`
-            : "";
+const propToString = ([key, value]) => (value === true ? key : typeof value === "number" && Number.isFinite(value) ? `${key}="${value.toString()}"` : typeof value === "string" ? `${key}=${serialise(value)}` : "");
 /**
  * Iterate through all elements in a node.
  * - This is useful if you, e.g. want to apply a `className` to all `<h1>` elements, or make a list of all URLs found in a Node.

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.30.3",
+	"version": "1.32.0",
 	"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, TransformObserver, 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. */

package/provider/MemoryProvider.js

@@ -1,4 +1,4 @@
-import { randomId, dispatchNext, isMapEqual, } from "../util/index.js";
+import { getRandomKey, dispatchNext, isMapEqual } from "../util/index.js";
 import { DocumentRequiredError } from "../db/index.js";
 import { Provider } from "./Provider.js";
 /**
@@ -18,23 +18,23 @@ export class MemoryProvider extends Provider {
         return ((_a = this._tables)[collection] || (_a[collection] = new Table()));
     }
     get(ref) {
-        return this._table(ref).data.get(ref.id);
+        return this._table(ref).data.get(ref.id) || null;
     }
     subscribe(ref, observer) {
         const table = this._table(ref);
         const id = ref.id;
         // Call next() immediately with initial results.
-        dispatchNext(observer, table.data.get(id));
+        dispatchNext(observer, table.data.get(id) || null);
         // Call next() every time the collection changes.
         return table.on(changes => {
-            changes.has(id) && dispatchNext(observer, changes.get(id));
+            changes.has(id) && dispatchNext(observer, changes.get(id) || null);
         });
     }
     add(ref, data) {
         const table = this._table(ref);
-        let id = randomId();
+        let id = getRandomKey();
         while (table.data.get(id))
-            id = randomId(); // Regenerate ID until unique.
+            id = getRandomKey(); // Regenerate ID until unique.
         table.write(id, data);
         return id;
     }
@@ -54,7 +54,7 @@ export class MemoryProvider extends Provider {
     delete(ref) {
         const table = this._table(ref);
         const id = ref.id;
-        table.write(id, undefined);
+        table.write(id, null);
     }
     getQuery(ref) {
         return ref.transform(this._table(ref).data);
@@ -110,7 +110,7 @@ export class MemoryProvider extends Provider {
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
         let count = 0;
         for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
-            table.write(id, undefined);
+            table.write(id, null);
             count++;
         }
         return count;

package/provider/ValidationProvider.js

@@ -1,10 +1,10 @@
-import { validate, ValidateObserver, callAsync } from "../util/index.js";
+import { validate, ValidateObserver, callAsync, validateResult } from "../util/index.js";
 import { validateUpdate } from "../update/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Validates any values that are read from or written to a source provider. */
 export class ValidationProvider extends ThroughProvider {
     get(ref) {
-        return callAsync(validate, super.get(ref), ref);
+        return callAsync(validateResult, super.get(ref), ref);
     }
     subscribe(ref, observer) {
         return super.subscribe(ref, new ValidateObserver(ref, observer));

package/query/Filter.d.ts

@@ -1,4 +1,4 @@
-import { Data, Entry, Matchable, Matcher, Results } from "../util/index.js";
+import { Data, Entry, Matchable, Results, ImmutableArray } from "../util/index.js";
 import { Rule } from "./Rule.js";
 import { FilterOperator, QueryKey } from "./types.js";
 /**
@@ -8,39 +8,53 @@ import { FilterOperator, QueryKey } from "./types.js";
  * @param type MatchType reference, e.g. `is` or `contains`
  * @param value Value the specified property should be matched against.
  */
-export interface Filter<T extends Data> {
-    readonly operator: FilterOperator;
-    readonly matcher: Matcher<unknown, unknown>;
-}
-export declare abstract class Filter<T extends Data> extends Rule<T> implements Matchable<Entry<T>, void> {
+export declare abstract class Filter<T extends Data, V extends unknown = unknown> extends Rule<T> implements Matchable<Entry<T>, void> {
+    abstract readonly operator: FilterOperator;
     readonly key: QueryKey<T>;
-    readonly value: unknown;
-    constructor(key: QueryKey<T>, value: unknown);
-    match([id, data]: Entry<T>): boolean;
+    readonly value: V;
+    constructor(key: QueryKey<T>, value: V);
+    abstract match([id, data]: Entry<T>, target: void): boolean;
     transform(results: Results<T>): Results<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. */
 export declare class NotEqualFilter<T extends Data> extends Filter<T> {
+    readonly operator = "NOT";
+    match([id, data]: Entry<T>): boolean;
 }
 /** Filter a set of values with an `IS` clause. */
-export declare class InArrayFilter<T extends Data> extends Filter<T> {
+export declare class InArrayFilter<T extends Data> extends Filter<T, ImmutableArray> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    readonly operator = "GTE";
+    match([id, data]: Entry<T>): boolean;
 }

package/query/Filter.js

@@ -1,15 +1,19 @@
 import { match, CONTAINS, IS, GT, GTE, IN, LT, LTE, NOT, yieldFiltered } from "../util/index.js";
 import { Rule } from "./Rule.js";
 import { getQueryProp } from "./helpers.js";
+/**
+ * Filter: filters a list of documents.
+ *
+ * @param key The name of a property that might exist on documents in the collection.
+ * @param type MatchType reference, e.g. `is` or `contains`
+ * @param value Value the specified property should be matched against.
+ */
 export class Filter extends Rule {
     constructor(key, value) {
         super();
         this.key = key;
         this.value = value;
     }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), this.matcher, this.value);
-    }
     transform(results) {
         return yieldFiltered(results, this);
     }
@@ -19,33 +23,82 @@ export class Filter extends Rule {
 }
 /** Filter a set of values with an `IS` clause. */
 export class EqualFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "IS";
+        this.matcher = IS;
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), IS, this.value);
+    }
 }
-Object.assign(EqualFilter.prototype, { direction: "IS", matcher: IS });
 /** Filter a set of values with an `NOT` clause. */
 export class NotEqualFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "NOT";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), NOT, this.value);
+    }
 }
-Object.assign(NotEqualFilter.prototype, { direction: "NOT", matcher: NOT });
 /** Filter a set of values with an `IS` clause. */
 export class InArrayFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "IN";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), IN, this.value);
+    }
 }
-Object.assign(InArrayFilter.prototype, { direction: "IN", matcher: IN });
 /** Filter a set of values with an `CONTAINS` clause. */
 export class ArrayContainsFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "CONTAINS";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), CONTAINS, this.value);
+    }
 }
-Object.assign(ArrayContainsFilter.prototype, { direction: "CONTAINS", matcher: CONTAINS });
 /** Filter a set of values with an `LT` clause. */
 export class LessThanFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "LT";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), LT, this.value);
+    }
 }
-Object.assign(LessThanFilter.prototype, { direction: "LT", matcher: LT });
 /** Filter a set of values with an `LTE` clause. */
 export class LessThanEqualFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "LTE";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), LTE, this.value);
+    }
 }
-Object.assign(LessThanEqualFilter.prototype, { direction: "LTE", matcher: LTE });
 /** Filter a set of values with an `GT` clause. */
 export class GreaterThanFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "GT";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), GT, this.value);
+    }
 }
-Object.assign(GreaterThanFilter.prototype, { direction: "GT", matcher: GT });
 /** Filter a set of values with an `GTE` clause. */
 export class GreaterThanEqualFilter extends Filter {
+    constructor() {
+        super(...arguments);
+        this.operator = "GTE";
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), GTE, this.value);
+    }
 }
-Object.assign(GreaterThanEqualFilter.prototype, { direction: "GTE", matcher: GTE });

package/query/Filters.d.ts

@@ -1,4 +1,4 @@
-import { Entry, ArrayType, ImmutableArray, Data, Key, Results } from "../util/index.js";
+import { Entry, Data, Key, Results, ImmutableArray, ArrayType } from "../util/index.js";
 import type { Filterable, QueryKey } from "./types.js";
 import { Filter } from "./Filter.js";
 import { Rules } from "./Rules.js";

package/query/Filters.js

@@ -1,5 +1,5 @@
 import { yieldFiltered } from "../util/index.js";
-import { ArrayContainsFilter, EqualFilter, GreaterThanEqualFilter, GreaterThanFilter, InArrayFilter, LessThanEqualFilter, LessThanFilter, NotEqualFilter, } from "./Filter.js";
+import { ArrayContainsFilter, EqualFilter, GreaterThanEqualFilter, GreaterThanFilter, InArrayFilter, LessThanEqualFilter, LessThanFilter, NotEqualFilter } from "./Filter.js";
 import { Rules } from "./Rules.js";
 /** A set of filters. */
 export class Filters extends Rules {

package/query/Query.d.ts

@@ -1,4 +1,4 @@
-import { Data, ArrayType, ImmutableArray, Entry, Key, Results } from "../util/index.js";
+import { Data, Entry, Key, Results, ArrayType, ImmutableArray } from "../util/index.js";
 import type { Queryable, QueryKey } from "./types.js";
 import { Filters } from "./Filters.js";
 import { Sorts } from "./Sorts.js";

package/query/Sort.d.ts

@@ -1,21 +1,22 @@
-import { Data, Entry, Rankable, Ranker, Results } from "../util/index.js";
+import { Data, Entry, Rankable, Results } from "../util/index.js";
 import { Rule } from "./Rule.js";
 import { QueryKey, SortDirection } from "./types.js";
 /** Sort a list of values. */
-export interface Sort<T extends Data> {
-    readonly direction: SortDirection;
-    readonly ranker: Ranker<unknown>;
-}
 export declare abstract class Sort<T extends Data> extends Rule<T> implements Rankable<Entry<T>> {
+    abstract readonly direction: SortDirection;
     readonly key: QueryKey<T>;
     constructor(key: QueryKey<T>);
-    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
+    abstract rank(left: Entry<T>, right: Entry<T>): number;
     transform(iterable: Results<T>): Results<T>;
     toString(): string;
 }
 /** Sort a list of values in ascending order. */
 export declare class AscendingSort<T extends Data> extends Sort<T> {
+    readonly direction = "ASC";
+    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
 }
 /** Sort a list of values in descending order. */
 export declare class DescendingSort<T extends Data> extends Sort<T> {
+    readonly direction = "DESC";
+    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
 }

package/query/Sort.js

@@ -1,14 +1,12 @@
 import { ASC, rank, DESC, sortItems } from "../util/index.js";
 import { getQueryProp } from "./helpers.js";
 import { Rule } from "./Rule.js";
+/** Sort a list of values. */
 export class Sort extends Rule {
     constructor(key) {
         super();
         this.key = key;
     }
-    rank([leftId, leftData], [rightId, rightData]) {
-        return rank(getQueryProp(leftId, leftData, this.key), this.ranker, getQueryProp(rightId, rightData, this.key));
-    }
     transform(iterable) {
         return sortItems(iterable, this);
     }
@@ -18,9 +16,21 @@ export class Sort extends Rule {
 }
 /** Sort a list of values in ascending order. */
 export class AscendingSort extends Sort {
+    constructor() {
+        super(...arguments);
+        this.direction = "ASC";
+    }
+    rank([leftId, leftData], [rightId, rightData]) {
+        return rank(getQueryProp(leftId, leftData, this.key), ASC, getQueryProp(rightId, rightData, this.key));
+    }
 }
-Object.assign(AscendingSort.prototype, { direction: "ASC", ranker: ASC });
 /** Sort a list of values in descending order. */
 export class DescendingSort extends Sort {
+    constructor() {
+        super(...arguments);
+        this.direction = "DESC";
+    }
+    rank([leftId, leftData], [rightId, rightData]) {
+        return rank(getQueryProp(leftId, leftData, this.key), DESC, getQueryProp(rightId, rightData, this.key));
+    }
 }
-Object.assign(DescendingSort.prototype, { direction: "DESC", ranker: DESC });

package/query/types.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayType, ImmutableArray, Data, Key, Matchable, Entry, Rankable } from "../util/index.js";
+import type { Data, Key, Matchable, Entry, Rankable, ImmutableArray, ArrayType } from "../util/index.js";
 /** Type for a key in a query, either `id` for the unique ID of the document or any other string key that exists in data. */
 export declare type QueryKey<T extends Data> = "id" | Key<T>;
 /** Possible operator references. */

package/react/index.d.ts

@@ -5,7 +5,5 @@ export * from "./useSubscribe.js";
 export * from "./useState.js";
 export * from "./useFetch.js";
 export * from "./useDocument.js";
-export * from "./useDocumentData.js";
 export * from "./useQuery.js";
-export * from "./useQueryFirst.js";
 export * from "./usePagination.js";

package/react/index.js

@@ -5,7 +5,5 @@ export * from "./useSubscribe.js";
 export * from "./useState.js";
 export * from "./useFetch.js";
 export * from "./useDocument.js";
-export * from "./useDocumentData.js";
 export * from "./useQuery.js";
-export * from "./useQueryFirst.js";
 export * from "./usePagination.js";

package/react/useDocument.d.ts

@@ -32,3 +32,9 @@ export declare function useAsyncDocument<T extends Data>(ref: DataDocument<T> |
  */
 export declare function useDocument<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): Result<T>;
 export declare function useDocument<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): Result<T> | undefined;
+/** Use the data of a document or `undefined` if the query has no matching results (or a promise indicating the result is loading). */
+export declare function useAsyncDocumentData<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): T | PromiseLike<T>;
+export declare function useAsyncDocumentData<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): T | PromiseLike<T> | undefined;
+/** Use the data of a document or `undefined` if the query has no matching results. */
+export declare function useDocumentData<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): T;
+export declare function useDocumentData<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): T | undefined;

package/react/useDocument.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE } from "../index.js";
+import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, callAsync, getDocumentData } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -57,3 +57,10 @@ function subscribeEffect(ref, maxAge, next, error) {
 export function useDocument(ref, maxAge) {
     return throwAsync(useAsyncDocument(ref, maxAge));
 }
+export function useAsyncDocumentData(ref, maxAge) {
+    const result = useAsyncDocument(ref, maxAge);
+    return ref && result !== undefined ? callAsync(getDocumentData, result, ref) : undefined;
+}
+export function useDocumentData(ref, maxAge) {
+    return throwAsync(useAsyncDocumentData(ref, maxAge));
+}

package/react/useQuery.d.ts

@@ -1,4 +1,4 @@
-import { DataQuery, ResultsMap, Data } from "../index.js";
+import { ResultsMap, DataQuery, Data, Entry } from "../index.js";
 /**
  * Use the cached result of a document in a React component (or a `Promise` to indicate the result is still loading).
  * - Requires database to use `CacheProvider` and will error if this does not exist.
@@ -33,3 +33,15 @@ export declare function useAsyncQuery<T extends Data>(ref: DataQuery<T> | undefi
  */
 export declare function useQuery<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): ResultsMap<T>;
 export declare function useQuery<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): ResultsMap<T> | undefined;
+/** Use the first result of a query or `undefined` if the query has no matching results (or a promise indicating the result is loading). */
+export declare function useAsyncQueryResult<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+/** Use the first result of a query or `undefined` if the query has no matching results */
+export declare function useQueryResult<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T> | undefined;
+export declare function useQueryResult<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;
+/** Use the first result of a query (or a promise indicating the result is loading). */
+export declare function useAsyncQueryData<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>>;
+export declare function useAsyncQueryData<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>> | undefined;
+/** Use the first result of a query. */
+export declare function useQueryData<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T>;
+export declare function useQueryData<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;

package/react/useQuery.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, TransformObserver, toMap, } from "../index.js";
+import { CacheProvider, NOERROR, findSourceProvider, NOVALUE, TransformObserver, toMap, callAsync, getQueryData, throwAsync, getFirstItem } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -58,3 +58,17 @@ function subscribeEffect(ref, maxAge, next, error) {
 export function useQuery(ref, maxAge) {
     return throwAsync(useAsyncQuery(ref, maxAge));
 }
+export function useAsyncQueryResult(ref, maxAge) {
+    const results = useAsyncQuery(ref ? ref.max(1) : undefined, maxAge);
+    return ref && results ? callAsync(getFirstItem, results) : undefined;
+}
+export function useQueryResult(ref, maxAge) {
+    return throwAsync(useAsyncQueryResult(ref, maxAge));
+}
+export function useAsyncQueryData(ref, maxAge) {
+    const results = useAsyncQuery(ref ? ref.max(1) : undefined, maxAge);
+    return ref && results ? callAsync(getQueryData, results, ref) : undefined;
+}
+export function useQueryData(ref, maxAge) {
+    return throwAsync(useAsyncQueryData(ref, maxAge));
+}