shelving 1.45.1 → 1.47.1

package/db/Database.d.ts

@@ -1,7 +1,7 @@
 import { Entry, Observable, Observer, Result, Unsubscriber, Results, Validatable, Validator, Key, Data, Entries, Datas, Validators, ValidatorType, Dispatcher } 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";
+import { Filters, Sorts, Query, FilterProps, SortKeys } from "../query/index.js";
 /**
  * Combines a database model and a provider.
  *
@@ -14,7 +14,7 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     readonly provider: Provider;
     constructor(validators: V, provider: Provider);
     /** Create a query on a collection in this model. */
-    query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DatabaseQuery<ValidatorType<V[K]>>;
+    query<K extends Key<V>>(collection: K, filters?: FilterProps<ValidatorType<V[K]>>, sorts?: SortKeys<ValidatorType<V[K]>>, limit?: number | null): DatabaseQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DatabaseDocument<ValidatorType<V[K]>>;
     /**
@@ -69,14 +69,14 @@ export declare class DatabaseQuery<T extends Data = Data> extends Query<T> imple
      * @return Entry in `[id, data]` format for the first document.
      * @throws RequiredError if there were no results for this query.
      */
-    get result(): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+    get result(): DocumentResult<T> | PromiseLike<DocumentResult<T>>;
     /**
      * 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>>;
+    get data(): DocumentData<T> | PromiseLike<DocumentData<T>>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -111,7 +111,9 @@ export declare class DatabaseQuery<T extends Data = Data> extends Query<T> imple
     toString(): string;
 }
 /** Get the data for a document from a result for that document. */
-export declare function getQueryData<T extends Data>(entries: Entries<T>, ref: DatabaseQuery<T>): Entry<T>;
+export declare function getQueryData<T extends Data>(entries: Entries<T>, ref: DatabaseQuery<T>): DocumentData<T>;
+/** Get the data for a document from a result for that document. */
+export declare function getQueryResult<T extends Data>(entries: Entries<T>, ref: DatabaseQuery<T>): DocumentResult<T>;
 /** A document reference within a specific database. */
 export declare class DatabaseDocument<T extends Data = Data> implements Observable<Result<T>>, Validatable<T> {
     readonly db: Database;
@@ -120,7 +122,7 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
     readonly id: string;
     constructor(db: Database, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null): DatabaseQuery<T>;
+    query(filters?: FilterProps<T>, sorts?: SortKeys<T>, limit?: number | null): DatabaseQuery<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional(): DatabaseQuery<T>;
     /**
@@ -132,7 +134,7 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
      * Get the result of this document.
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
-    get result(): Result<T> | PromiseLike<Result<T>>;
+    get result(): DocumentResult<T> | PromiseLike<DocumentResult<T>>;
     /**
      * Get the data of this document.
      * - Useful for destructuring, e.g. `{ name, title } = await documentThatMustExist.asyncData`
@@ -140,7 +142,7 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
      * @return Document's data (possibly promised).
      * @throws RequiredError if the document's result was undefined.
      */
-    get data(): T | PromiseLike<T>;
+    get data(): DocumentData<T> | PromiseLike<DocumentData<T>>;
     /**
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
@@ -159,5 +161,14 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
     validate(unsafeData: Data): T;
     toString(): string;
 }
+/** Database data embeds the corresponding `Document` instance and string ID into the data. */
+export declare type DocumentData<T extends Data> = T & {
+    _id: string;
+    _doc: DatabaseDocument<T>;
+};
+/** Get the data for a document from a result for that document. */
+export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DatabaseDocument<T>): DocumentData<T>;
+/** Database result embeds the corresponding `Document` instance and string ID into the result. */
+export declare type DocumentResult<T extends Data> = DocumentData<T> | null;
 /** Get the data for a document from a result for that document. */
-export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DatabaseDocument<T>): T;
+export declare function getDocumentResult<T extends Data>(result: Result<T>, ref: DatabaseDocument<T>): DocumentResult<T>;

package/db/Database.js

@@ -1,7 +1,7 @@
 import { callAsync, getFirstItem, throwAsync, validate, getMap, countItems, 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";
+import { Filters, Sorts, Query, Filter } from "../query/index.js";
 import { DocumentRequiredError, DocumentValidationError, QueryRequiredError, QueryValidationError } from "./errors.js";
 /**
  * Combines a database model and a provider.
@@ -18,7 +18,7 @@ export class Database {
     }
     /** Create a query on a collection in this model. */
     query(collection, filters, sorts, limit) {
-        return new DatabaseQuery(this, this.validators[collection], collection, filters, sorts, limit);
+        return new DatabaseQuery(this, this.validators[collection], collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {
@@ -93,7 +93,7 @@ export class DatabaseQuery extends Query {
      * @throws RequiredError if there were no results for this query.
      */
     get result() {
-        return callAsync(getFirstItem, this.db.provider.getQuery(this.max(1)));
+        return callAsync(getQueryResult, this.db.provider.getQuery(this.max(1)), this);
     }
     /**
      * Get an entry for the first document matched by this query.
@@ -170,7 +170,14 @@ export class DatabaseQuery extends Query {
 export function getQueryData(entries, ref) {
     const first = getFirstItem(entries);
     if (first)
-        return first;
+        return getDocumentData(first[1], ref.doc(first[0]));
+    throw new QueryRequiredError(ref);
+}
+/** Get the data for a document from a result for that document. */
+export function getQueryResult(entries, ref) {
+    const first = getFirstItem(entries);
+    if (first)
+        return getDocumentData(first[1], ref.doc(first[0]));
     throw new QueryRequiredError(ref);
 }
 /** A document reference within a specific database. */
@@ -183,11 +190,11 @@ export class DatabaseDocument {
     }
     /** Create a query on this document's collection. */
     query(filters, sorts, limit) {
-        return new DatabaseQuery(this.db, this.validator, this.collection, filters, sorts, limit);
+        return new DatabaseQuery(this.db, this.validator, this.collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
     }
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional() {
-        return new DatabaseQuery(this.db, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
+        return new DatabaseQuery(this.db, this.validator, this.collection, new Filters(new Filter("id", "IS", this.id)));
     }
     /**
      * Does this document exist?
@@ -201,7 +208,7 @@ export class DatabaseDocument {
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
     get result() {
-        return this.db.provider.get(this);
+        return callAsync(getDocumentResult, this.db.provider.get(this), this);
     }
     /**
      * Get the data of this document.
@@ -252,6 +259,10 @@ export class DatabaseDocument {
 /** Get the data for a document from a result for that document. */
 export function getDocumentData(result, ref) {
     if (result)
-        return result;
+        return { ...result, _id: ref.id, _doc: ref };
     throw new DocumentRequiredError(ref);
 }
+/** Get the data for a document from a result for that document. */
+export function getDocumentResult(result, ref) {
+    return result ? getDocumentData(result, ref) : null;
+}

package/db/Operation.d.ts

@@ -8,10 +8,8 @@ export declare abstract class Operation {
 }
 /** Represent a list of write operations on a database run in series. */
 export declare class Operations extends Operation {
-    /** Return a new write operations list with a set of write operations. */
-    static with(...operations: Nullish<Operation>[]): Operations;
     readonly operations: ImmutableArray<Operation>;
-    constructor(operations: ImmutableArray<Nullish<Operation>>);
+    constructor(...operations: Nullish<Operation>[]);
     run(db: Database): Promise<Operations>;
     /** Return a new write operations list with an additional write operation added. */
     with(...operations: Nullish<Operation>[]): {

package/db/Operation.js

@@ -1,26 +1,23 @@
-import { callAsyncSeries, isNotNullish, isNullish } from "../util/index.js";
+import { callAsyncSeries, notNullish, isNullish } from "../util/index.js";
 /** Represent a write operation on a database. */
 export class Operation {
 }
 /** Represent a list of write operations on a database run in series. */
 export class Operations extends Operation {
-    constructor(operations) {
+    constructor(...operations) {
         super();
-        this.operations = operations.filter(isNotNullish);
-    }
-    /** Return a new write operations list with a set of write operations. */
-    static with(...operations) {
-        return new Operations(operations);
+        this.operations = operations.filter(notNullish);
     }
     async run(db) {
-        return new Operations(await callAsyncSeries(_write, this.operations, db));
+        const ops = await callAsyncSeries(_run, this.operations, db);
+        return new Operations(...ops);
     }
     /** Return a new write operations list with an additional write operation added. */
     with(...operations) {
         return { __proto__: Object.getPrototypeOf(this), ...this, operations: [...this.operations, operations] };
     }
 }
-const _write = (operation, db) => operation.run(db);
+const _run = (operation, db) => operation.run(db);
 /** Represent a add operation made to a collection in a database. */
 export class AddOperation extends Operation {
     constructor(collection, data) {

package/firestore/client/FirestoreClientProvider.js

@@ -8,6 +8,7 @@ const OPERATORS = {
     IS: "==",
     NOT: "!=",
     IN: "in",
+    OUT: "not-in",
     GT: ">",
     GTE: ">=",
     LT: "<",

package/firestore/lite/FirestoreLiteProvider.js

@@ -8,6 +8,7 @@ const OPERATORS = {
     IS: "==",
     NOT: "!=",
     IN: "in",
+    OUT: "not-in",
     GT: ">",
     GTE: ">=",
     LT: "<",

package/firestore/server/FirestoreServerProvider.js

@@ -8,6 +8,7 @@ const OPERATORS = {
     IS: "==",
     NOT: "!=",
     IN: "in",
+    OUT: "not-in",
     GT: ">",
     GTE: ">=",
     LT: "<",

package/markup/render.js

@@ -40,7 +40,7 @@ function renderString(content, options) {
         if (matchedRule && matchedResult && matchedResult[0]) {
             // If index is more than zero, then add a string node before this one.
             if (matchedIndex) {
-                const prefix = content.substr(0, matchedIndex);
+                const prefix = content.slice(0, matchedIndex);
                 appendNode(nodes, renderString(prefix, options));
             }
             // Call the rule's `render()` function to generate the node.
@@ -49,7 +49,7 @@ function renderString(content, options) {
             element.rule = matchedRule;
             appendNode(nodes, renderNode(element, childOptions));
             // Decrement the content.
-            content = content.substr(matchedIndex + matchedResult[0].length);
+            content = content.slice(matchedIndex + matchedResult[0].length);
         }
         else {
             // If nothing else matched add the rest of the string as a node (presumably it doesn't have any punctuation).

package/markup/rules.js

@@ -82,9 +82,9 @@ const OL = {
 const SPLIT_OL_ITEMS = new RegExp(`\\n+(?=${ORDERED})`, "g");
 const mapOrderedItem = (item, key) => {
     const firstSpace = item.indexOf(" ");
-    const value = parseInt(item.substr(0, firstSpace), 10);
+    const value = parseInt(item.slice(0, firstSpace), 10);
     const children = item
-        .substr(firstSpace + 1)
+        .slice(firstSpace + 1)
         .trimStart()
         .replace(REPLACE_INDENT, "");
     return { type: "li", key, props: { value, children } };

package/package.json

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

package/query/Filter.d.ts

@@ -1,59 +1,21 @@
-import { Data, Entry, Matchable, Entries, ImmutableArray } from "../util/index.js";
+import { Data, Entry, Matchable, Entries, Key } from "../util/index.js";
 import { Rule } from "./Rule.js";
-import { FilterOperator, QueryKey } from "./types.js";
+import { FilterKey, FilterOperator } from "./types.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 operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-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: V;
-    constructor(key: QueryKey<T>, value: V);
-    abstract match([id, data]: Entry<T>, target: void): boolean;
+export declare class Filter<T extends Data> extends Rule<T> implements Matchable<Entry<T>, void> {
+    /** Parse a set of FilterProps and return the corresponding array of `Filter` instances. */
+    static on<X extends Data>(key: FilterKey<X>, value: unknown): Filter<X>;
+    readonly key: "id" | Key<T>;
+    readonly operator: FilterOperator;
+    readonly value: unknown;
+    constructor(key: "id" | Key<T>, operator: FilterOperator, value: unknown);
+    match([id, data]: Entry<T>): boolean;
     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";
-    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, ImmutableArray> {
-    readonly operator = "IN";
-    match([id, data]: Entry<T>): boolean;
-}
-/** 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 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 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 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 EqualGreaterFilter<T extends Data> extends Filter<T> {
-    readonly operator = "GTE";
-    match([id, data]: Entry<T>): boolean;
-}

package/query/Filter.js

@@ -1,103 +1,55 @@
-import { match, isArrayWith, isEqual, isGreater, isEqualGreater, isInArray, isLess, isEqualLess, isNotEqual, yieldFiltered } from "../util/index.js";
+import { match, isArrayWith, isEqual, isGreater, isEqualGreater, isLess, isEqualLess, notEqual, yieldFiltered, notInArray, isInArray } from "../util/index.js";
 import { Rule } from "./Rule.js";
 import { getQueryProp } from "./helpers.js";
+/** Map `FilterOperator` to its corresponding `Matcher` function. */
+const MATCHERS = {
+    IS: isEqual,
+    NOT: notEqual,
+    IN: isInArray,
+    OUT: notInArray,
+    CONTAINS: isArrayWith,
+    LT: isLess,
+    LTE: isEqualLess,
+    GT: isGreater,
+    GTE: isEqualGreater,
+};
 /**
  * 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 operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
 export class Filter extends Rule {
-    constructor(key, value) {
+    constructor(key, operator, value) {
         super();
         this.key = key;
+        this.operator = operator;
         this.value = value;
     }
+    /** Parse a set of FilterProps and return the corresponding array of `Filter` instances. */
+    static on(key, value) {
+        return key.startsWith("!")
+            ? new Filter(key.slice(1), value instanceof Array ? "OUT" : "NOT", value)
+            : key.endsWith(">")
+                ? new Filter(key.slice(0, -1), "GT", value)
+                : key.endsWith(">=")
+                    ? new Filter(key.slice(0, -2), "GTE", value)
+                    : key.endsWith("<")
+                        ? new Filter(key.slice(0, -1), "LT", value)
+                        : key.endsWith("<=")
+                            ? new Filter(key.slice(0, -2), "LTE", value)
+                            : key.endsWith("[]")
+                                ? new Filter(key.slice(0, -2), "CONTAINS", value)
+                                : new Filter(key, value instanceof Array ? "IN" : "IS", value);
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), MATCHERS[this.operator], this.value);
+    }
     transform(entries) {
         return yieldFiltered(entries, this);
     }
     toString() {
-        return `${this.key}:${this.operator}=${JSON.stringify(this.value)}`;
-    }
-}
-/** Filter a set of values with an `IS` clause. */
-export class EqualFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "IS";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isEqual, this.value);
-    }
-}
-/** 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), isNotEqual, this.value);
-    }
-}
-/** 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), isInArray, this.value);
-    }
-}
-/** Filter a set of values with a `CONTAINS` clause. */
-export class ArrayWithFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "CONTAINS";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isArrayWith, this.value);
-    }
-}
-/** Filter a set of values with an `LT` clause. */
-export class LessFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "LT";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isLess, this.value);
-    }
-}
-/** Filter a set of values with an `LTE` clause. */
-export class EqualLessFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "LTE";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isEqualLess, this.value);
-    }
-}
-/** Filter a set of values with an `GT` clause. */
-export class GreaterFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "GT";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isGreater, this.value);
-    }
-}
-/** Filter a set of values with an `GTE` clause. */
-export class EqualGreaterFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "GTE";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isEqualGreater, this.value);
+        return `${this.key}:${this.operator}:${JSON.stringify(this.value)}`;
     }
 }

package/query/Filters.d.ts

@@ -1,18 +1,17 @@
 import { Entry, Data, Key, Entries, ImmutableArray, ArrayType } from "../util/index.js";
-import type { Filterable, QueryKey } from "./types.js";
+import type { Filterable, FilterProps } from "./types.js";
 import { Filter } from "./Filter.js";
 import { Rules } from "./Rules.js";
 /** A set of filters. */
 export declare class Filters<T extends Data> extends Rules<T, Filter<T>> implements Filterable<T> {
-    is<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    not<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    in<K extends QueryKey<T>>(key: K, value: K extends "id" ? readonly string[] : readonly T[K][]): this;
-    contains<K extends Key<T>>(key: K, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
-    lt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    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;
+    /** Create a `Filters` instance from a set of `FilterProps` */
+    static on<X extends Data>(filters: FilterProps<X>): Filters<X>;
+    filter(props: FilterProps<T>): this;
+    filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
+    filter(key: "id" | "!id", value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
     match(entry: Entry<T>): boolean;
-    get unfiltered(): this;
     transform(iterable: Entries<T>): Entries<T>;
 }

package/query/Filters.js

@@ -1,32 +1,18 @@
 import { yieldFiltered } from "../util/index.js";
-import { ArrayWithFilter, EqualFilter, EqualGreaterFilter, GreaterFilter, InArrayFilter, EqualLessFilter, LessFilter, NotEqualFilter } from "./Filter.js";
+import { Filter } from "./Filter.js";
 import { Rules } from "./Rules.js";
+function* _yieldFilters(props) {
+    for (const [key, value] of Object.entries(props))
+        yield Filter.on(key, value);
+}
 /** 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)] };
-    }
-    not(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new NotEqualFilter(key, value)] };
-    }
-    in(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new InArrayFilter(key, value)] };
-    }
-    contains(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new ArrayWithFilter(key, value)] };
+    /** Create a `Filters` instance from a set of `FilterProps` */
+    static on(filters) {
+        return new Filters(..._yieldFilters(filters));
     }
-    lt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new LessFilter(key, value)] };
-    }
-    lte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new EqualLessFilter(key, value)] };
-    }
-    gt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new GreaterFilter(key, value)] };
-    }
-    gte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new EqualGreaterFilter(key, value)] };
+    filter(input, value) {
+        return typeof input === "string" ? this.with(Filter.on(input, value)) : this.with(..._yieldFilters(input));
     }
     match(entry) {
         for (const rule of this._rules)
@@ -34,9 +20,6 @@ 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,27 +1,26 @@
 import { Data, Entry, Key, Entries, ArrayType, ImmutableArray } from "../util/index.js";
-import type { Queryable, QueryKey } from "./types.js";
+import type { Queryable, SortKey, FilterProps, SortKeys } from "./types.js";
 import { Filters } from "./Filters.js";
 import { Sorts } from "./Sorts.js";
 import { Rule } from "./Rule.js";
 /** Allows filtering, sorting, and limiting on a set of results. */
 export declare class Query<T extends Data> extends Rule<T> implements Queryable<T> {
+    /** Create a new `Query` object from a set of `QueryProps` */
+    static on<X extends Data>(filters?: FilterProps<X>, sorts?: SortKey<X> | ImmutableArray<SortKey<X>>, limit?: number | null): Query<X>;
     readonly filters: Filters<T>;
     readonly sorts: Sorts<T>;
     readonly limit: number | null;
     constructor(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null);
-    is<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    not<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    in<K extends QueryKey<T>>(key: K, value: K extends "id" ? readonly string[] : readonly T[K][]): this;
-    contains<K extends Key<T>>(key: K, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
-    lt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    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;
+    filter(props: FilterProps<T>): this;
+    filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
+    filter(key: "id" | "!id", value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<T[K]>): this;
+    filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
+    get unfilter(): this;
     match(entry: Entry<T>): boolean;
-    asc(key: QueryKey<T>): this;
-    desc(key: QueryKey<T>): this;
-    get unsorted(): this;
+    sort(...keys: SortKeys<T>[]): this;
+    get unsort(): 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;