shelving 1.86.8 → 1.88.0

package/constraint/FilterConstraint.d.ts

@@ -1,19 +1,19 @@
-import type { Data, DataKey } from "../util/data.js";
+import { Data, DataKey, FlatDataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { ImmutableArray } from "../util/array.js";
-import { Matchable } from "../util/match.js";
+import type { Matchable } from "../util/match.js";
 import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
 export 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 type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
+export type FilterKey<T extends Data> = DataKey<FilterProps<T>>;
 /** Format that allows multiple filters to be specified as a plain object. */
 export type FilterProps<T extends Data> = {
-    [K in DataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+    [K in FlatDataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
-    [K in DataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
+    [K in FlatDataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 } & {
-    [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
+    [K in FlatDataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
 };
 /** List of filters in a flexible format. */
 export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<Nullish<FilterProps<T> | FilterConstraint<T>>>;
@@ -25,9 +25,10 @@ export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> |
  * @param value Value the specified property should be matched against.
  */
 export declare class FilterConstraint<T extends Data = Data> implements Constraint<T>, Matchable<[T]> {
-    readonly key: string;
+    readonly keys: readonly [string, ...string[]];
     readonly operator: FilterOperator;
     readonly value: unknown;
+    get key(): string;
     get filterKey(): string;
     constructor(filterKey: FilterKey<T>, value: unknown);
     match(item: T): boolean;

package/constraint/FilterConstraint.js

@@ -1,6 +1,9 @@
+import { getDataProps } from "../util/data.js";
 import { isArray } from "../util/array.js";
-import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "../util/match.js";
+import { isArrayWith, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notInArray, isEqual, notEqual } from "../util/equal.js";
 import { filterItems, isIterable } from "../util/iterate.js";
+import { getProp } from "../util/object.js";
+import { splitString } from "../util/string.js";
 /** Map `FilterOperator` to its corresponding `Match` function. */
 const MATCHERS = {
     IS: isEqual,
@@ -21,56 +24,60 @@ const MATCHERS = {
  * @param value Value the specified property should be matched against.
  */
 export class FilterConstraint {
+    get key() {
+        return this.keys.join(".");
+    }
     get filterKey() {
         const { operator, key } = this;
-        if (operator === "NOT" || operator === "OUT")
-            return `!${key}`;
-        else if (operator === "CONTAINS")
-            return `${key}[]`;
-        else if (operator === "LT")
-            return `${key}<`;
-        else if (operator === "LTE")
-            return `${key}<=`;
-        else if (operator === "GT")
-            return `${key}>`;
-        else if (operator === "GTE")
-            return `${key}>=`;
-        else
-            return key;
+        return operator === "IS" || operator === "IN"
+            ? key
+            : operator === "NOT" || operator === "OUT"
+                ? `!${key}`
+                : operator === "CONTAINS"
+                    ? `${key}[]`
+                    : operator === "LT"
+                        ? `${key}<`
+                        : operator === "LTE"
+                            ? `${key}<=`
+                            : operator === "GT"
+                                ? `${key}>`
+                                : operator === "GTE"
+                                    ? `${key}>=`
+                                    : operator; // Never.
     }
     constructor(filterKey, value) {
         if (filterKey.startsWith("!")) {
-            this.key = filterKey.slice(1);
+            this.keys = splitString(filterKey.slice(1), ".");
             this.operator = isArray(value) ? "OUT" : "NOT";
         }
+        else if (filterKey.endsWith("[]")) {
+            this.keys = splitString(filterKey.slice(0, -2), ".");
+            this.operator = "CONTAINS";
+        }
         else if (filterKey.endsWith(">")) {
-            this.key = filterKey.slice(0, -1);
+            this.keys = splitString(filterKey.slice(0, -1), ".");
             this.operator = "GT";
         }
         else if (filterKey.endsWith(">=")) {
-            this.key = filterKey.slice(0, -2);
+            this.keys = splitString(filterKey.slice(0, -2), ".");
             this.operator = "GTE";
         }
         else if (filterKey.endsWith("<")) {
-            this.key = filterKey.slice(0, -1);
+            this.keys = splitString(filterKey.slice(0, -1), ".");
             this.operator = "LT";
         }
         else if (filterKey.endsWith("<=")) {
-            this.key = filterKey.slice(0, -2);
+            this.keys = splitString(filterKey.slice(0, -2), ".");
             this.operator = "LTE";
         }
-        else if (filterKey.endsWith("[]")) {
-            this.key = filterKey.slice(0, -2);
-            this.operator = "CONTAINS";
-        }
         else {
-            this.key = filterKey;
+            this.keys = splitString(filterKey, ".");
             this.operator = isArray(value) ? "IN" : "IS";
         }
         this.value = value;
     }
     match(item) {
-        return MATCHERS[this.operator](item[this.key], this.value);
+        return MATCHERS[this.operator](getProp(item, ...this.keys), this.value);
     }
     transform(items) {
         return filterItems(items, this);
@@ -90,7 +97,7 @@ export function* getFilters(list) {
                 yield* getFilters(filter);
     }
     else {
-        for (const [key, value] of Object.entries(list))
+        for (const [key, value] of getDataProps(list))
             yield new FilterConstraint(key, value);
     }
 }

package/constraint/QueryConstraints.js

@@ -94,17 +94,17 @@ function* _getAfterFilters(sorts, item) {
     const lastSort = sorts.last;
     assert(lastSort);
     for (const sort of sorts) {
-        const { key, direction } = sort;
-        const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`;
-        yield new FilterConstraint(filterKey, getProp(item, key));
+        const { key, keys, direction } = sort;
+        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`);
+        yield new FilterConstraint(filterKey, getProp(item, ...keys));
     }
 }
 function* _getBeforeFilters(sorts, item) {
     const lastSort = sorts.last;
     assert(lastSort);
     for (const sort of sorts) {
-        const { key, direction } = sort;
-        const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`;
-        yield new FilterConstraint(filterKey, getProp(item, key));
+        const { key, keys, direction } = sort;
+        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`);
+        yield new FilterConstraint(filterKey, getProp(item, ...keys));
     }
 }

package/constraint/SortConstraint.d.ts

@@ -1,10 +1,10 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { Data, DataKey } from "../util/data.js";
+import type { Data, FlatDataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
 import type { Constraint } from "./Constraint.js";
 /** 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 type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
+export type SortKey<T extends Data> = FlatDataKey<T> | `${FlatDataKey<T>}` | `!${FlatDataKey<T>}`;
 /** One or more sort keys. */
 export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
@@ -13,8 +13,9 @@ export type SortDirection = "ASC" | "DESC";
 export type SortList<T extends Data> = SortKey<T> | SortConstraint<T> | Iterable<Nullish<SortKey<T> | SortConstraint<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
-    readonly key: string;
+    readonly keys: readonly [string, ...string[]];
     readonly direction: SortDirection;
+    get key(): string;
     get sortKey(): string;
     constructor(sortKey: SortKey<T>);
     rank(left: T, right: T): number;

package/constraint/SortConstraint.js

@@ -1,21 +1,26 @@
+import { getProp } from "../util/object.js";
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
+import { splitString } from "../util/string.js";
 /** Sort a list of values. */
 export class SortConstraint {
+    get key() {
+        return this.keys.join(".");
+    }
     get sortKey() {
         return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
     }
     constructor(sortKey) {
         if (sortKey.startsWith("!")) {
-            this.key = sortKey.slice(1);
+            this.keys = splitString(sortKey.slice(1), ".");
             this.direction = "DESC";
         }
         else {
-            this.key = sortKey;
+            this.keys = splitString(sortKey, ".");
             this.direction = "ASC";
         }
     }
     rank(left, right) {
-        return rank(left[this.key], this.direction === "ASC" ? rankAsc : rankDesc, right[this.key]);
+        return rank(getProp(left, ...this.keys), this.direction === "ASC" ? rankAsc : rankDesc, getProp(right, ...this.keys));
     }
     transform(items) {
         return sortItems(items, this);

package/db/Change.d.ts

@@ -1,10 +1,9 @@
-import type { Data, Datas, DataKey } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { Updates } from "../update/DataUpdate.js";
 import { Nullish } from "../util/null.js";
 import { DeepIterable } from "../util/iterate.js";
-import type { ItemConstraints, ItemData } from "./Item.js";
 /** Change on a collection. */
 export interface Change<T extends Datas, K extends DataKey<T> = DataKey<T>> {
     readonly action: string;
@@ -44,4 +43,3 @@ export type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = I
 export declare function changeProvider<T extends Datas, K extends DataKey<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
 /** Apply a set of changes to an asynchronous provider. */
 export declare function changeAsyncProvider<T extends Datas, K extends DataKey<T>>(provider: AsyncProvider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
-export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Change.js

@@ -1,7 +1,7 @@
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { FilterConstraint } from "../constraint/FilterConstraint.js";
 import { notNullish } from "../util/null.js";
 import { flattenItems } from "../util/iterate.js";
+import { getItemFilterConstraints } from "./Item.js";
 /** Apply a set of changes to a synchronous provider. */
 export function changeProvider(provider, ...changes) {
     return Array.from(flattenItems(changes)).filter(notNullish).map(_changeItem, provider);
@@ -13,7 +13,7 @@ function _changeItem(change) {
     else if (action === "SET")
         this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        this.updateQuery(collection, _getItemConstraint(change.id), change.updates);
+        this.updateQuery(collection, new QueryConstraints(getItemFilterConstraints(change.id), undefined, 1), change.updates);
     else if (action === "DELETE")
         this.deleteItem(collection, change.id);
     return change;
@@ -29,11 +29,8 @@ async function _changeAsyncItem(change) {
     else if (action === "SET")
         await this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        await this.updateQuery(collection, _getItemConstraint(change.id), change.updates);
+        await this.updateQuery(collection, new QueryConstraints(getItemFilterConstraints(change.id), undefined, 1), change.updates);
     else if (action === "DELETE")
         await this.deleteItem(collection, change.id);
     return change;
 }
-export function _getItemConstraint(id) {
-    return new QueryConstraints(new FilterConstraint("id", id), undefined, 1);
-}

package/db/Item.d.ts

@@ -3,6 +3,7 @@ import type { Stop, Handler, Dispatch } from "../util/function.js";
 import type { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { Data, Datas, DataKey } from "../util/data.js";
 import { DataUpdate, Updates } from "../update/DataUpdate.js";
+import { FilterConstraints } from "../constraint/FilterConstraints.js";
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncQuery, Query } from "./Query.js";
 import type { AsyncDatabase, Database } from "./Database.js";
@@ -90,4 +91,6 @@ export declare class AsyncItem<T extends Datas = Datas, K extends DataKey<T> = D
 export declare const getID: <T extends Data>({ id }: ItemData<T>) => string;
 /** Get the IDs of an iterable set item data. */
 export declare function getIDs<T extends Data>(entities: Iterable<ItemData<T>>): Iterable<string>;
+/** Get a `FilterConstraints` instance that targets a single item by its ID. */
+export declare function getItemFilterConstraints<T extends Data>(id: string): FilterConstraints<ItemData<T>>;
 export {};

package/db/Item.js

@@ -1,6 +1,7 @@
 import { getData } from "../util/data.js";
-import { FilterConstraint } from "../constraint/FilterConstraint.js";
 import { runSequence } from "../util/sequence.js";
+import { FilterConstraint } from "../constraint/FilterConstraint.js";
+import { FilterConstraints } from "../constraint/FilterConstraints.js";
 /** Reference to an item in a synchronous or asynchronous database. */
 class BaseItem {
     /** Get a set change for this item. */
@@ -37,7 +38,7 @@ export class Item extends BaseItem {
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
+        return this.db.query(this.collection, getItemFilterConstraints(this.id), undefined, 1);
     }
     get exists() {
         return !!this.db.get(this.collection, this.id);
@@ -67,7 +68,7 @@ export class AsyncItem extends BaseItem {
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
+        return this.db.query(this.collection, { id: this.id }, undefined, 1);
     }
     get exists() {
         return this.db.get(this.collection, this.id).then(Boolean);
@@ -95,3 +96,7 @@ export function* getIDs(entities) {
     for (const { id } of entities)
         yield id;
 }
+/** Get a `FilterConstraints` instance that targets a single item by its ID. */
+export function getItemFilterConstraints(id) {
+    return new FilterConstraints(new FilterConstraint("id", id));
+}

package/{react/useItem.d.ts → db/ItemState.d.ts}

@@ -1,8 +1,8 @@
-import type { ItemValue, ItemData, AsyncItem, Item } from "../db/Item.js";
-import type { Dispatch } from "../util/function.js";
-import { Datas, DataKey } from "../util/data.js";
+import { DataKey, Datas } from "../util/data.js";
+import { Dispatch } from "../util/function.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
+import { ItemValue, Item, AsyncItem, ItemData } from "./Item.js";
 /** Hold the current state of a item. */
 export declare class ItemState<T extends Datas, K extends DataKey<T> = DataKey<T>> extends State<ItemValue<T[K]>> {
     readonly ref: Item<T, K> | AsyncItem<T, K>;
@@ -20,9 +20,3 @@ export declare class ItemState<T extends Datas, K extends DataKey<T> = DataKey<T
     /** Subscribe this state to the source provider. */
     connectSource(): Dispatch;
 }
-/**
- * Use an item in a React component.
- * - Uses the default cache, so will error if not used inside `<Cache>`
- */
-export declare function useItem<T extends Datas, K extends DataKey<T>>(ref: Item<T, K> | AsyncItem<T, K>): ItemState<T, K>;
-export declare function useItem<T extends Datas, K extends DataKey<T>>(ref?: Item<T, K> | AsyncItem<T, K>): ItemState<T, K> | undefined;

package/{react/useItem.js → db/ItemState.js}

@@ -1,12 +1,9 @@
 import { getData } from "../util/data.js";
-import { getOptionalSource } from "../util/source.js";
-import { setMapItem } from "../util/map.js";
-import { CacheProvider } from "../provider/CacheProvider.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
+import { getOptionalSource } from "../util/source.js";
 import { LazyDeferredSequence } from "../sequence/LazyDeferredSequence.js";
-import { useState } from "./useState.js";
-import { useCache } from "./useCache.js";
+import { CacheProvider } from "../provider/CacheProvider.js";
 /** Hold the current state of a item. */
 export class ItemState extends State {
     /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
@@ -58,9 +55,3 @@ export class ItemState extends State {
         return this.from(this.ref);
     }
 }
-export function useItem(ref) {
-    const cache = useCache();
-    const key = ref === null || ref === void 0 ? void 0 : ref.toString();
-    const state = ref && key ? cache.get(key) || setMapItem(cache, key, new ItemState(ref)) : undefined;
-    return useState(state);
-}

package/{react/useQuery.d.ts → db/QueryState.d.ts}

@@ -41,9 +41,3 @@ export declare class QueryState<T extends Datas, K extends DataKey<T> = DataKey<
     /** Iterate over the items. */
     [Symbol.iterator](): Iterator<ItemData<T[K]>>;
 }
-/**
- * Use a query in a React component.
- * - Uses the default cache, so will error if not used inside `<Cache>`
- */
-export declare function useQuery<T extends Datas, K extends DataKey<T>>(ref: Query<T, K> | AsyncQuery<T, K>): QueryState<T, K>;
-export declare function useQuery<T extends Datas, K extends DataKey<T>>(ref?: Query<T, K> | AsyncQuery<T, K>): QueryState<T, K> | undefined;

package/{react/useQuery.js → db/QueryState.js}

@@ -1,12 +1,9 @@
-import { setMapItem } from "../util/map.js";
 import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
 import { getOptionalSource } from "../util/source.js";
 import { CacheProvider } from "../provider/CacheProvider.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { LazyDeferredSequence } from "../sequence/LazyDeferredSequence.js";
-import { useState } from "./useState.js";
-import { useCache } from "./useCache.js";
 /** Hold the current state of a query. */
 export class QueryState extends State {
     /** Can more items be loaded after the current result. */
@@ -110,8 +107,3 @@ export class QueryState extends State {
         return this.value.values();
     }
 }
-export function useQuery(ref) {
-    const cache = useCache();
-    const key = ref === null || ref === void 0 ? void 0 : ref.toString();
-    return useState(ref && key ? cache.get(key) || setMapItem(cache, key, new QueryState(ref)) : undefined);
-}

package/db/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./Database.js";
 export * from "./Collection.js";
 export * from "./Item.js";
+export * from "./ItemState.js";
 export * from "./Query.js";
+export * from "./QueryState.js";
 export * from "./Change.js";

package/db/index.js

@@ -1,5 +1,7 @@
 export * from "./Database.js";
 export * from "./Collection.js";
 export * from "./Item.js";
+export * from "./ItemState.js";
 export * from "./Query.js";
+export * from "./QueryState.js";
 export * from "./Change.js";

package/feedback/Feedback.d.ts

@@ -19,7 +19,7 @@ export declare class Feedback<T = unknown> {
     constructor(feedback: string, value?: T);
 }
 /** Is an unknown value a `Feedback` object. */
-export declare const isFeedback: <T extends Feedback<unknown>>(v: unknown) => v is Feedback<unknown>;
+export declare const isFeedback: <T extends Feedback<unknown>>(value: unknown) => value is Feedback<unknown>;
 /**
  * Yield the sub-messages in `[key: string, message: string]` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.

package/feedback/Feedback.js

@@ -29,7 +29,7 @@ __decorate([
     setPrototype("name", "Feedback")
 ], Feedback.prototype, "name", void 0);
 /** Is an unknown value a `Feedback` object. */
-export const isFeedback = (v) => isObject(v) && typeof v.name === "string" && v.name.endsWith("Feedback") && typeof v.message === "string";
+export const isFeedback = (value) => isObject(value) && typeof value.name === "string" && value.name.endsWith("Feedback") && typeof value.message === "string";
 /**
  * Yield the sub-messages in `[key: string, message: string]` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Firestore } from "firebase/firestore";
+import { Firestore } from "firebase/firestore";
 import type { Data } from "../../util/data.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../../db/Item.js";

package/firestore/client/FirestoreClientProvider.js

@@ -9,11 +9,11 @@ const OPERATORS = {
     NOT: "!=",
     IN: "in",
     OUT: "not-in",
+    CONTAINS: "array-contains",
     GT: ">",
     GTE: ">=",
     LT: "<",
     LTE: "<=",
-    CONTAINS: "array-contains",
 };
 // Map `Filter.types` to `OrderByDirection`
 const DIRECTIONS = {
@@ -28,7 +28,7 @@ function* _yieldQueryConstraints({ sorts, filters, limit }) {
     for (const { key, direction } of sorts)
         yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
     for (const { operator, key, value } of filters)
-        yield firestoreWhere(key === "id" ? ID : key, OPERATORS[operator], value);
+        yield firestoreWhere(key, OPERATORS[operator], value);
     if (typeof limit === "number")
         yield firestoreLimit(limit);
 }

package/firestore/lite/FirestoreLiteProvider.js

@@ -2,8 +2,6 @@ import { documentId as firestoreDocumentId, orderBy as firestoreOrderBy, where a
 import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/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.
 const ID = firestoreDocumentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
@@ -11,11 +9,11 @@ const OPERATORS = {
     NOT: "!=",
     IN: "in",
     OUT: "not-in",
+    CONTAINS: "array-contains",
     GT: ">",
     GTE: ">=",
     LT: "<",
     LTE: "<=",
-    CONTAINS: "array-contains",
 };
 // Map `Filter.types` to `OrderByDirection`
 const DIRECTIONS = {

package/firestore/server/FirestoreServerProvider.js

@@ -9,11 +9,11 @@ const OPERATORS = {
     NOT: "!=",
     IN: "in",
     OUT: "not-in",
+    CONTAINS: "array-contains",
     GT: ">",
     GTE: ">=",
     LT: "<",
     LTE: "<=",
-    CONTAINS: "array-contains",
 };
 // Map `Filter.types` to `OrderByDirection`
 const DIRECTIONS = {

package/package.json

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

package/react/index.d.ts

@@ -4,5 +4,4 @@ export * from "./useInstance.js";
 export * from "./useCache.js";
 export * from "./useSequence.js";
 export * from "./useState.js";
-export * from "./useItem.js";
-export * from "./useQuery.js";
+export * from "./useData.js";

package/react/index.js

@@ -6,5 +6,4 @@ export * from "./useCache.js";
 // Integration.
 export * from "./useSequence.js";
 export * from "./useState.js";
-export * from "./useItem.js";
-export * from "./useQuery.js";
+export * from "./useData.js";

package/react/useData.d.ts

@@ -0,0 +1,15 @@
+import type { ImmutableArray } from "../util/array.js";
+import { DataKey, Datas } from "../util/data.js";
+import { AsyncItem } from "../db/Item.js";
+import { ItemState } from "../db/ItemState.js";
+import { AsyncQuery } from "../db/Query.js";
+import { QueryState } from "../db/QueryState.js";
+type Reference<T extends Datas, K extends DataKey<T>> = AsyncItem<T, K> | AsyncQuery<T, K>;
+type ReferenceReferenceState<T extends Reference<Datas, string>> = T extends AsyncItem<infer D, infer K> ? ItemState<D, K> : T extends AsyncQuery<infer D, infer K> ? QueryState<D, K> : never;
+/** Use one or more data items or queries. */
+export declare function useData<T extends Reference<Datas, string>>(ref: T): ReferenceReferenceState<T>;
+export declare function useData<T extends Reference<Datas, string>>(ref: T | undefined): ReferenceReferenceState<T> | undefined;
+export declare function useData<T extends ImmutableArray<Reference<Datas, string>>>(...refs: T): {
+    [K in keyof T]: ReferenceReferenceState<T[K]>;
+};
+export {};

package/react/useData.js

@@ -0,0 +1,17 @@
+import { setMapItem } from "../util/map.js";
+import { mapArray } from "../util/transform.js";
+import { AsyncItem } from "../db/Item.js";
+import { ItemState } from "../db/ItemState.js";
+import { QueryState } from "../db/QueryState.js";
+import { useState } from "./useState.js";
+import { useCache } from "./useCache.js";
+export function useData(...refs) {
+    const cache = useCache();
+    const states = mapArray(refs, _getReferenceState, cache);
+    return useState(...states);
+}
+/** Get the corresponding `ItemState` or `QueryState` instance from the cache for a given `Item` or `Query`. */
+function _getReferenceState(ref, cache) {
+    const key = ref === null || ref === void 0 ? void 0 : ref.toString();
+    return ref && key ? cache.get(key) || setMapItem(cache, key, ref instanceof AsyncItem ? new ItemState(ref) : new QueryState(ref)) : undefined;
+}

package/react/useState.d.ts

@@ -1,11 +1,13 @@
-import { AnyState } from "../state/State.js";
+import type { AnyState } from "../state/State.js";
+import { ImmutableArray } from "../util/array.js";
 /**
- * Subscribe to a Shelving `State` instance.
+ * Subscribe to one or more `State` instances.
  *
- * @param state Shelving `State` instance.
- * - Subscription is recreated every time this value changes.
+ * @param state `State` instance.
+ * - Subscription is recreated every time the state instance changes.
  * - Memoise this value to persist the subscription for the lifetime of the component.
  * - If the value is a `State` instance
  */
-export declare function useState<S extends AnyState>(state: S): S;
-export declare function useState<S extends AnyState>(state?: S | undefined): S | undefined;
+export declare function useState<T extends AnyState>(state: T): T;
+export declare function useState<T extends AnyState>(state?: T | undefined): T | undefined;
+export declare function useState<T extends ImmutableArray<AnyState | undefined>>(...states: T): T;

package/react/useState.js

@@ -1,12 +1,20 @@
 import { useEffect, useState as useReactState } from "react";
-import { State } from "../state/State.js";
-import { BLACKHOLE } from "../util/function.js";
-import { runSequence } from "../util/sequence.js";
-export function useState(state) {
-    const setState = useReactState(state && !state.loading ? state.value : State.NOVALUE)[1];
+import { dispatch } from "../util/function.js";
+import { mapArray } from "../util/transform.js";
+import { isDefined } from "../util/undefined.js";
+export function useState(...states) {
+    const setValue = useReactState(undefined)[1];
     const [error, setError] = useReactState(undefined);
-    useEffect(state ? () => runSequence(state.next, setState, setError) : BLACKHOLE, [state]);
+    useEffect(() => {
+        const forceRerender = () => setValue({});
+        const stops = mapArray(states, _startState, forceRerender, setError);
+        return () => stops.filter(isDefined).forEach(dispatch);
+    }, states);
     if (error)
         throw error;
-    return state;
+    return states.length <= 1 ? states[0] : states;
+}
+/** Start a subscription to a `ReferenceState` instance. */
+function _startState(state, setValue, setError) {
+    return state === null || state === void 0 ? void 0 : state.next.to(setValue, setError);
 }