shelving 1.45.0 → 1.47.0

package/query/Query.js

@@ -3,7 +3,7 @@ import { Filters } from "./Filters.js";
 import { Sorts } from "./Sorts.js";
 import { Rule } from "./Rule.js";
 import { getQueryProp } from "./helpers.js";
-import { EqualGreaterFilter as GTE, GreaterFilter as GT, EqualLessFilter as LTE, LessFilter as LT } from "./Filter.js";
+import { Filter } from "./Filter.js";
 // Instances to save resources for the default case (empty query).
 const EMPTY_FILTERS = new Filters(); // eslint-disable-line @typescript-eslint/no-explicit-any
 const EMPTY_SORTS = new Sorts(); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -15,46 +15,25 @@ export class Query extends Rule {
         this.sorts = sorts;
         this.limit = limit;
     }
-    // Implement `Filterable`
-    is(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.is(key, value) };
+    /** Create a new `Query` object from a set of `QueryProps` */
+    static on(filters, sorts, limit) {
+        return new Query(filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
     }
-    not(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.not(key, value) };
+    filter(input, value) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.filter(input, value) };
     }
-    in(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.in(key, value) };
-    }
-    contains(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.contains(key, value) };
-    }
-    lt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.lt(key, value) };
-    }
-    lte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.lte(key, value) };
-    }
-    gt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.gt(key, value) };
-    }
-    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 };
+    get unfilter() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, filters: EMPTY_FILTERS };
     }
     match(entry) {
         return this.filters.match(entry);
     }
     // Implement `Sortable`
-    asc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.asc(key) };
-    }
-    desc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.desc(key) };
+    sort(...keys) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.sort(...keys) };
     }
-    get unsorted() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.unsorted };
+    get unsort() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: EMPTY_SORTS };
     }
     rank(left, right) {
         return this.sorts.rank(left, right);
@@ -69,8 +48,8 @@ export class Query extends Rule {
         const lastSort = this.sorts.last;
         assert(lastSort);
         for (const sort of this.sorts) {
-            const AppliedFilter = sort.direction === "ASC" ? (sort === lastSort ? GT : GTE) : sort === lastSort ? LT : LTE;
-            filters.push(new AppliedFilter(sort.key, getQueryProp(id, data, sort.key)));
+            const { key, direction } = sort;
+            filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "GT" : "GTE") : sort === lastSort ? "LT" : "LTE", getQueryProp(id, data, key)));
         }
         return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
     }
@@ -79,8 +58,8 @@ export class Query extends Rule {
         const lastSort = this.sorts.last;
         assert(lastSort);
         for (const sort of this.sorts) {
-            const AppliedFilter = sort.direction === "ASC" ? (sort === lastSort ? LT : LTE) : sort === lastSort ? GT : GTE;
-            filters.push(new AppliedFilter(sort.key, getQueryProp(id, data, sort.key)));
+            const { key, direction } = sort;
+            filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "LT" : "LTE") : sort === lastSort ? "GT" : "GTE", getQueryProp(id, data, key)));
         }
         return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
     }

package/query/Rules.d.ts

@@ -1,8 +1,8 @@
-import { Data, MutableArray } from "../util/index.js";
+import { Data, ImmutableArray } from "../util/index.js";
 import { Rule } from "./Rule.js";
 /** Type of Rule that is powered by several sub-rules (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export declare abstract class Rules<T extends Data, R extends Rule<T>> extends Rule<T> implements Iterable<R> {
-    protected readonly _rules: MutableArray<R>;
+    protected readonly _rules: ImmutableArray<R>;
     /** Get the first rule. */
     get first(): R | undefined;
     /** Get the last rule. */
@@ -11,6 +11,10 @@ export declare abstract class Rules<T extends Data, R extends Rule<T>> extends R
     get size(): number;
     constructor(...rules: R[]);
     toString(): string;
+    /** Clone this set of rules but add additional rules. */
+    with(...rules: R[]): this;
+    /** Clone this set of rules but remove specific rules. */
+    without(...rules: R[]): this;
     /** Iterate over the rules. */
     [Symbol.iterator](): Iterator<R, void>;
 }

package/query/Rules.js

@@ -1,4 +1,4 @@
-import { toString } from "../util/index.js";
+import { toString, withItems, withoutItems } from "../util/index.js";
 import { Rule } from "./Rule.js";
 /** Type of Rule that is powered by several sub-rules (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export class Rules extends Rule {
@@ -21,6 +21,16 @@ export class Rules extends Rule {
     toString() {
         return this._rules.map(toString).join("&");
     }
+    /** Clone this set of rules but add additional rules. */
+    with(...rules) {
+        const _rules = withItems(this._rules, rules);
+        return _rules !== this._rules ? { __proto__: Object.getPrototypeOf(this), ...this, _rules } : this;
+    }
+    /** Clone this set of rules but remove specific rules. */
+    without(...rules) {
+        const _rules = withoutItems(this._rules, rules);
+        return _rules !== this._rules ? { __proto__: Object.getPrototypeOf(this), ...this, _rules } : this;
+    }
     /** Iterate over the rules. */
     [Symbol.iterator]() {
         return this._rules.values();

package/query/Sort.d.ts

@@ -1,22 +1,14 @@
-import { Data, Entry, Rankable, Entries } from "../util/index.js";
+import { Data, Entry, Rankable, Entries, Key } from "../util/index.js";
 import { Rule } from "./Rule.js";
-import { QueryKey, SortDirection } from "./types.js";
+import { SortDirection, SortKey } from "./types.js";
 /** Sort a list of values. */
-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>);
-    abstract rank(left: Entry<T>, right: Entry<T>): number;
+export declare class Sort<T extends Data> extends Rule<T> implements Rankable<Entry<T>> {
+    /** Create a sort on a specified field. */
+    static on<X extends Data>(sort: SortKey<X> | Sort<X>): Sort<X>;
+    readonly key: "id" | Key<T>;
+    readonly direction: SortDirection;
+    constructor(key: "id" | Key<T>, direction: SortDirection);
+    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
     transform(iterable: Entries<T>): Entries<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,36 +1,24 @@
-import { rankAscending, rank, rankDesc, sortItems } from "../util/index.js";
+import { rankAsc, rank, sortItems, rankDesc } 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) {
+    constructor(key, direction) {
         super();
         this.key = key;
+        this.direction = direction;
     }
-    transform(iterable) {
-        return sortItems(iterable, this);
-    }
-    toString() {
-        return `${this.key}:${this.direction}`;
-    }
-}
-/** Sort a list of values in ascending order. */
-export class AscendingSort extends Sort {
-    constructor() {
-        super(...arguments);
-        this.direction = "ASC";
+    /** Create a sort on a specified field. */
+    static on(sort) {
+        return sort instanceof Sort ? sort : sort.startsWith("!") ? new Sort(sort.slice(1), "DESC") : new Sort(sort, "ASC");
     }
     rank([leftId, leftData], [rightId, rightData]) {
-        return rank(getQueryProp(leftId, leftData, this.key), rankAscending, getQueryProp(rightId, rightData, this.key));
+        return rank(getQueryProp(leftId, leftData, this.key), this.direction === "ASC" ? rankAsc : rankDesc, getQueryProp(rightId, rightData, this.key));
     }
-}
-/** Sort a list of values in descending order. */
-export class DescendingSort extends Sort {
-    constructor() {
-        super(...arguments);
-        this.direction = "DESC";
+    transform(iterable) {
+        return sortItems(iterable, this);
     }
-    rank([leftId, leftData], [rightId, rightData]) {
-        return rank(getQueryProp(leftId, leftData, this.key), rankDesc, getQueryProp(rightId, rightData, this.key));
+    toString() {
+        return `${this.direction === "DESC" ? "!" : ""}${this.key}`;
     }
 }

package/query/Sorts.d.ts

@@ -1,12 +1,12 @@
 import { Entry, Data, Entries } from "../util/index.js";
-import type { QueryKey, Sortable } from "./types.js";
+import type { Sortable, SortKeys } from "./types.js";
 import { Sort } from "./Sort.js";
 import { Rules } from "./Rules.js";
 /** A set of sorts. */
 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;
+    /** Create a new `Sorts` object from an array of `SortKey` strings. */
+    static on<X extends Data>(...keys: SortKeys<X>[]): Sorts<X>;
+    sort(...keys: SortKeys<T>[]): this;
     rank(left: Entry<T>, right: Entry<T>): number;
     transform(iterable: Entries<T>): Entries<T>;
 }

package/query/Sorts.js

@@ -1,17 +1,15 @@
 import { sortItems } from "../util/index.js";
-import { AscendingSort, DescendingSort } from "./Sort.js";
+import { Sort } from "./Sort.js";
 import { Rules } from "./Rules.js";
 /** A set of sorts. */
 export class Sorts extends Rules {
-    // Implement `Sortable`
-    asc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new AscendingSort(key)] };
-    }
-    desc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new DescendingSort(key)] };
+    /** Create a new `Sorts` object from an array of `SortKey` strings. */
+    static on(...keys) {
+        return new Sorts(...keys.flat().map(Sort.on));
     }
-    get unsorted() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [] };
+    // Implement `Sortable`
+    sort(...keys) {
+        return this.with(...keys.flat().map(Sort.on));
     }
     rank(left, right) {
         for (const rule of this._rules) {

package/query/helpers.d.ts

@@ -1,9 +1,8 @@
-import { Data } from "../util/index.js";
-import type { QueryKey } from "./types.js";
+import { Data, Key } from "../util/index.js";
 /**
  * Get a named property value from some data.
  * - For using in `Query` and `Filter` and `Sort` etc.
  * - `"id"` is a special case and always returns the ID.
  * - Anything else assumes the entry value is an object and looks up that named prop in the data.
  */
-export declare const getQueryProp: <T extends Data, K extends QueryKey<T>>(id: string, data: T, key: K) => K extends "id" ? string : T[K];
+export declare const getQueryProp: <T extends Data, K extends "id" | Key<T>>(id: string, data: T, key: K) => K extends "id" ? string : T[K];

package/query/types.d.ts

@@ -1,40 +1,52 @@
 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. */
-export declare type FilterOperator = "IS" | "NOT" | "IN" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
+export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
+/** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
+export declare type FilterKey<T extends Data> = "id" | "!id" | "id>" | "id>=" | "id<" | "id<=" | Key<T> | `!${Key<T>}` | `${Key<T>}[]` | `${Key<T>}<` | `${Key<T>}<=` | `${Key<T>}>` | `${Key<T>}>=`;
+/** Format that allows multiple filters to be specified as a plain object. */
+export declare type FilterProps<T extends Data> = {
+    "id"?: string | ImmutableArray<string>;
+    "!id"?: string | ImmutableArray<string>;
+    "id>"?: string;
+    "id>="?: string;
+    "id<"?: string;
+    "id<="?: string;
+} & {
+    [K in Key<T> as K | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+} & {
+    [K in Key<T> as `${K}[]`]?: T[K] extends ImmutableArray ? ArrayType<T[K]> : never;
+} & {
+    [K in Key<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
+};
 /**
  * Interface to make sure an object implements all matchers.
  * - Extends `Matchable` so this object itself can be directly be used in `filterItems()` and `filterEntries()`
  */
 export interface Filterable<T extends Data> extends Matchable<Entry<T>, void> {
-    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;
-    /** Return a new instance of this class with no sorts specified. */
-    unfiltered: this;
+    /** Add a filter to this filterable. */
+    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 an entry against the filters specified for this object. */
     match(entry: Entry<T>): boolean;
 }
+/** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
+export declare type SortKey<T extends Data> = "id" | "!id" | Key<T> | `!${Key<T>}`;
+/** One or more sort keys. */
+export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
+/** Possible operator references. */
+export declare type SortDirection = "ASC" | "DESC";
 /**
  * Interface to make sure an object implements all directions.
  * - Extends `Matchable` so this object itself can be directly be used in `filterItems()` and `filterEntries()`
  */
 export interface Sortable<T extends Data> extends Rankable<Entry<T>> {
-    /** Return a new instance of this class with an ascending order sort defined. */
-    asc(key: QueryKey<T>): this;
-    /** Return a new instance of this class with a descending order sort defined. */
-    desc(key: QueryKey<T>): this;
-    /** Return a new instance of this class with no sorts specified. */
-    unsorted: this;
+    /** Add one or more sorts to this sortable. */
+    sort(...keys: SortKeys<T>[]): this;
 }
-/** Possible operator references. */
-export declare type SortDirection = "ASC" | "DESC";
 /** Interface for an object that can have a limit set. */
 export interface Limitable {
     /** The maximum number of items allowed by the limit. */
@@ -55,4 +67,8 @@ export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T>, L
     after(id: string, data: T): this;
     /** Return a new instance of this class with a before offset defined. */
     before(id: string, data: T): this;
+    /** Return a new instance of this class with no filters specified. */
+    unfilter: this;
+    /** Return a new instance of this class with no sorts specified. */
+    unsort: this;
 }

package/react/useDocument.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseDocument, Result, Data } from "../index.js";
+import { DatabaseDocument, Result, Data, DocumentData } 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,8 +33,8 @@ export declare function useAsyncDocument<T extends Data>(ref: DatabaseDocument<T
 export declare function useDocument<T extends Data>(ref: DatabaseDocument<T>, maxAge?: number | true): Result<T>;
 export declare function useDocument<T extends Data>(ref: DatabaseDocument<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: DatabaseDocument<T>, maxAge?: number | true): T | PromiseLike<T>;
-export declare function useAsyncDocumentData<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): T | PromiseLike<T> | undefined;
+export declare function useAsyncDocumentData<T extends Data>(ref: DatabaseDocument<T>, maxAge?: number | true): DocumentData<T> | PromiseLike<DocumentData<T>>;
+export declare function useAsyncDocumentData<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): DocumentData<T> | PromiseLike<DocumentData<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: DatabaseDocument<T>, maxAge?: number | true): T;
 export declare function useDocumentData<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): T | undefined;

package/react/useQuery.d.ts

@@ -1,4 +1,4 @@
-import { Results, DatabaseQuery, Data, Entry } from "../index.js";
+import { Results, DatabaseQuery, Data, DocumentResult, DocumentData } 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.
@@ -34,14 +34,14 @@ export declare function useAsyncQuery<T extends Data>(ref: DatabaseQuery<T> | un
 export declare function useQuery<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Results<T>;
 export declare function useQuery<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Results<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: DatabaseQuery<T>, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
-export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentResult<T> | undefined | PromiseLike<DocumentResult<T> | undefined>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentResult<T> | undefined | PromiseLike<DocumentResult<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: DatabaseQuery<T>, maxAge?: number | true): Entry<T> | undefined;
-export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;
+export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentResult<T>;
+export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentResult<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: DatabaseQuery<T>, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>>;
-export declare function useAsyncQueryData<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>> | undefined;
+export declare function useAsyncQueryData<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentData<T> | PromiseLike<DocumentData<T>>;
+export declare function useAsyncQueryData<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentData<T> | PromiseLike<DocumentData<T>> | undefined;
 /** Use the first result of a query. */
-export declare function useQueryData<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Entry<T>;
-export declare function useQueryData<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;
+export declare function useQueryData<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentData<T>;
+export declare function useQueryData<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentData<T> | undefined;

package/react/useQuery.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, NOERROR, findSourceProvider, NOVALUE, getMap, callAsync, getQueryData, throwAsync, getFirstItem, ResultsObserver } from "../index.js";
+import { CacheProvider, NOERROR, findSourceProvider, NOVALUE, getMap, callAsync, getQueryData, throwAsync, ResultsObserver, getQueryResult, } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -60,7 +60,7 @@ export function useQuery(ref, maxAge) {
 }
 export function useAsyncQueryResult(ref, maxAge) {
     const results = useAsyncQuery(ref ? ref.max(1) : undefined, maxAge);
-    return ref && results ? callAsync(getFirstItem, results) : undefined;
+    return ref && results ? callAsync(getQueryResult, results, ref) : undefined;
 }
 export function useQueryResult(ref, maxAge) {
     return throwAsync(useAsyncQueryResult(ref, maxAge));

package/schema/PhoneSchema.js

@@ -21,7 +21,7 @@ export class PhoneSchema extends StringSchema {
         // Strip characters that aren't 0-9 or `+` plus (including whitespace).
         const digits = str.replace(/[^0-9+]/g, "");
         // Allow `+` plus only if it's first character.
-        return digits.substr(0, 1) + digits.substr(1).replace(/[^0-9]/g, "");
+        return digits.slice(0, 1) + digits.slice(1).replace(/[^0-9]/g, "");
     }
 }
 /** Valid phone number, e.g. `+441234567890` */

package/test/util.js

@@ -34,7 +34,7 @@ function popErrorStack(error, count = 1) {
         const prefix = message ? `${name}: ${message}\n` : `${name}\n`;
         if (stack.startsWith(prefix)) {
             // In Chrome and Node the name and message of the error is the first line of the stack (so we need to skip over the first line).
-            const lines = stack.substr(prefix.length).split("\n");
+            const lines = stack.slice(prefix.length).split("\n");
             lines.splice(0, count);
             error.stack = prefix + lines.join("\n");
         }

package/util/date.js

@@ -64,11 +64,11 @@ export function getDate(target = "now") {
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `null` if it couldn't be converted. */
 export function toYmd(target) {
     const date = toDate(target);
-    return date ? date.toISOString().substr(0, 10) : null;
+    return date ? date.toISOString().slice(0, 10) : null;
 }
 /** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
 export function getYmd(target = "now") {
-    return getDate(target).toISOString().substr(0, 10);
+    return getDate(target).toISOString().slice(0, 10);
 }
 /** List of day-of-week strings. */
 export const days = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

package/util/debug.js

@@ -16,7 +16,7 @@ export const debug = (value) => typeof value === "function"
                         : typeof value === "string"
                             ? debugString(value)
                             : typeof value;
-const debugString = (value) => (value.length > DEBUG_STRING_MAX ? `"${value.substr(0, DEBUG_STRING_MAX)}…"` : `"${value}"`);
+const debugString = (value) => (value.length > DEBUG_STRING_MAX ? `"${value.slice(0, DEBUG_STRING_MAX)}…"` : `"${value}"`);
 const DEBUG_STRING_MAX = 23;
 const debugObject = (value) => {
     const prototype = Object.getPrototypeOf(value);

package/util/filter.d.ts

@@ -13,23 +13,26 @@ export declare type Matcher<L, R> = Matchable<L, R> | ((item: L, target: R) => b
 export declare function match<L>(item: L, matcher: Matcher<L, void>): boolean;
 export declare function match<L, R>(item: L, matcher: Matcher<L, R>, target: R): boolean;
 export declare const isEqual: <T>(item: unknown, target: T) => item is T;
-export declare const isNotEqual: <T, N>(item: T | N, target: T) => item is N;
+export declare const notEqual: <T, N>(item: T | N, target: T) => item is N;
 export declare const isInArray: <T>(item: unknown, targets: ImmutableArray<T>) => item is T;
+export declare const notInArray: <T, N>(item: T | N, targets: ImmutableArray<T>) => item is N;
 export declare const isArrayWith: (items: unknown, target: unknown) => boolean;
 export declare const isLess: (item: unknown, target: unknown) => boolean;
 export declare const isEqualLess: (item: unknown, target: unknown) => boolean;
 export declare const isGreater: (item: unknown, target: unknown) => boolean;
 export declare const isEqualGreater: (item: unknown, target: unknown) => boolean;
 export declare const isKeyEqual: ([key]: Entry<unknown>, target: string) => boolean;
-export declare const isKeyNotEqual: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
+export declare const notKeyEqual: ([key]: Entry<unknown>, targets: string) => boolean;
 export declare const isKeyInArray: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
+export declare const notKeyInArray: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
 export declare const isKeyLess: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isKeyEqualLess: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isKeyGreater: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isKeyEqualGreater: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueEqual: ([, value]: Entry<unknown>, target: unknown) => boolean;
-export declare const isValueNotEqual: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const notValueEqual: ([, value]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueInArray: ([, value]: Entry<unknown>, targets: ImmutableArray<unknown>) => boolean;
+export declare const notValueInArray: ([, value]: Entry<unknown>, targets: ImmutableArray<unknown>) => boolean;
 export declare const isValueLess: ([, value]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueEqualLess: ([, value]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueGreater: ([, value]: Entry<unknown>, target: unknown) => boolean;

package/util/filter.js

@@ -1,29 +1,32 @@
-import { rankAscending } from "./sort.js";
+import { rankAsc } from "./sort.js";
 import { transform } from "./transform.js";
 export function match(item, matcher, target) {
     return typeof matcher === "function" ? matcher(item, target) : matcher.match(item, target);
 }
 // Regular matchers.
 export const isEqual = (item, target) => item === target;
-export const isNotEqual = (item, target) => item !== target;
+export const notEqual = (item, target) => item !== target;
 export const isInArray = (item, targets) => targets.includes(item);
+export const notInArray = (item, targets) => !targets.includes(item);
 export const isArrayWith = (items, target) => items instanceof Array && items.includes(target);
-export const isLess = (item, target) => rankAscending(item, target) < 0;
-export const isEqualLess = (item, target) => rankAscending(item, target) <= 0;
-export const isGreater = (item, target) => rankAscending(item, target) > 0;
-export const isEqualGreater = (item, target) => rankAscending(item, target) >= 0;
+export const isLess = (item, target) => rankAsc(item, target) < 0;
+export const isEqualLess = (item, target) => rankAsc(item, target) <= 0;
+export const isGreater = (item, target) => rankAsc(item, target) > 0;
+export const isEqualGreater = (item, target) => rankAsc(item, target) >= 0;
 // Entry key matchers.
 export const isKeyEqual = ([key], target) => isEqual(key, target);
-export const isKeyNotEqual = ([key], targets) => isNotEqual(key, targets);
+export const notKeyEqual = ([key], targets) => notEqual(key, targets);
 export const isKeyInArray = ([key], targets) => isInArray(key, targets);
+export const notKeyInArray = ([key], targets) => notInArray(key, targets);
 export const isKeyLess = ([key], target) => isLess(key, target);
 export const isKeyEqualLess = ([key], target) => isEqualLess(key, target);
 export const isKeyGreater = ([key], target) => isGreater(key, target);
 export const isKeyEqualGreater = ([key], target) => isEqualGreater(key, target);
 // Entry value matchers.
 export const isValueEqual = ([, value], target) => isEqual(value, target);
-export const isValueNotEqual = ([, value], target) => isNotEqual(value, target);
+export const notValueEqual = ([, value], target) => notEqual(value, target);
 export const isValueInArray = ([, value], targets) => isInArray(value, targets);
+export const notValueInArray = ([, value], targets) => notInArray(value, targets);
 export const isValueLess = ([, value], target) => isLess(value, target);
 export const isValueEqualLess = ([, value], target) => isEqualLess(value, target);
 export const isValueGreater = ([, value], target) => isGreater(value, target);

package/util/null.d.ts

@@ -1,7 +1,7 @@
 /** Is a value null? */
 export declare const isNull: (v: unknown) => v is null;
 /** Is a value not null? */
-export declare const isNotNull: <T>(v: T | null) => v is T;
+export declare const notNull: <T>(v: T | null) => v is T;
 /** Function that always returns null. */
 export declare const NULL: () => null;
 /** Nullish is `null` or `undefined` */
@@ -11,7 +11,7 @@ export declare type NotNullish<T> = Exclude<T, null | undefined>;
 /** Is a value nullish? */
 export declare const isNullish: <T>(v: Nullish<T>) => v is null | undefined;
 /** Is a value not nullish? */
-export declare const isNotNullish: <T>(v: Nullish<T>) => v is T;
+export declare const notNullish: <T>(v: Nullish<T>) => v is T;
 /** Get a required value (returns value or throws `RequiredError` if value is `null` or `undefined`). */
 export declare function getRequired<T>(v: T): NotNullish<T>;
 export declare function getRequired<T>(v: Nullish<T>): T;

package/util/null.js

@@ -2,13 +2,13 @@ import { RequiredError } from "../error/index.js";
 /** Is a value null? */
 export const isNull = (v) => v === null;
 /** Is a value not null? */
-export const isNotNull = (v) => v !== null;
+export const notNull = (v) => v !== null;
 /** Function that always returns null. */
 export const NULL = () => null;
 /** Is a value nullish? */
 export const isNullish = (v) => v === null || v === undefined;
 /** Is a value not nullish? */
-export const isNotNullish = (v) => v !== null && v !== undefined;
+export const notNullish = (v) => v !== null && v !== undefined;
 export function getRequired(v) {
     if (v === undefined || v === null)
         throw new RequiredError("Required value is missing");

package/util/sort.d.ts

@@ -28,7 +28,7 @@ export declare function rank<T>(left: T, ranker: Ranker<T>, right: T): number;
  *
  * @returns Number below zero if `a` is higher, number above zero if `b` is higher, or `0` if they're equally sorted.
  */
-export declare function rankAscending(left: unknown, right: unknown): number;
+export declare function rankAsc(left: unknown, right: unknown): number;
 /** Rank two values in descending order. */
 export declare const rankDesc: (left: unknown, right: unknown) => number;
 /** Rank the keys of two entries in ascending order. */