shelving 1.31.0 → 1.34.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.31.0",
+	"version": "1.34.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -63,20 +63,20 @@
 		"@types/jest": "^27.0.3",
 		"@types/react": "^17.0.37",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.6.0",
-		"@typescript-eslint/parser": "^5.6.0",
-		"eslint": "^8.4.1",
+		"@typescript-eslint/eslint-plugin": "^5.7.0",
+		"@typescript-eslint/parser": "^5.7.0",
+		"eslint": "^8.5.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-import": "^2.25.3",
 		"eslint-plugin-prettier": "^4.0.0",
 		"firebase": "^9.6.1",
-		"jest": "^27.4.4",
+		"jest": "^27.4.5",
 		"jest-ts-webcompat-resolver": "^1.0.0",
 		"prettier": "^2.5.1",
 		"react": "^17.0.2",
 		"react-dom": "^17.0.2",
-		"ts-jest": "^27.1.1",
-		"typescript": "^4.5.3"
+		"ts-jest": "^27.1.2",
+		"typescript": "^4.5.4"
 	},
 	"peerDependencies": {
 		"@google-cloud/firestore": ">=4.0.0",

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";
@@ -13,5 +13,6 @@ 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;
+    get unfiltered(): this;
     transform(iterable: Results<T>): Results<T>;
 }

package/query/Filters.js

@@ -1,8 +1,9 @@
 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 {
+    // Implement `Filterable`
     is(key, value) {
         return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new EqualFilter(key, value)] };
     }
@@ -33,6 +34,10 @@ export class Filters extends Rules {
                 return false;
         return true;
     }
+    get unfiltered() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [] };
+    }
+    // Implement `Rule`
     transform(iterable) {
         return this._rules.length ? yieldFiltered(iterable, this) : iterable;
     }

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";
@@ -17,9 +17,11 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     lte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
     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;
+    get unfiltered(): this;
     match(entry: Entry<T>): boolean;
-    asc(key?: QueryKey<T>): this;
-    desc(key?: QueryKey<T>): this;
+    asc(key: QueryKey<T>): this;
+    desc(key: QueryKey<T>): this;
+    get unsorted(): this;
     rank(left: Entry<T>, right: Entry<T>): number;
     /** Return a new instance of this class with a limit defined. */
     max(limit: number | null): this;

package/query/Query.js

@@ -40,16 +40,22 @@ export class Query extends Rule {
     gte(key, value) {
         return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.gte(key, value) };
     }
+    get unfiltered() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.unfiltered };
+    }
     match(entry) {
         return this.filters.match(entry);
     }
     // Implement `Sortable`
-    asc(key = "id") {
+    asc(key) {
         return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.asc(key) };
     }
-    desc(key = "id") {
+    desc(key) {
         return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.desc(key) };
     }
+    get unsorted() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.unsorted };
+    }
     rank(left, right) {
         return this.sorts.rank(left, right);
     }

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/Sorts.d.ts

@@ -6,6 +6,7 @@ import { Rules } from "./Rules.js";
 export declare class Sorts<T extends Data> extends Rules<T, Sort<T>> implements Sortable<T> {
     asc(key: QueryKey<T>): this;
     desc(key: QueryKey<T>): this;
+    get unsorted(): this;
     rank(left: Entry<T>, right: Entry<T>): number;
     transform(iterable: Results<T>): Results<T>;
 }