shelving 1.101.0 → 1.102.1

package/db/ItemState.d.ts

@@ -1,4 +1,5 @@
 import type { AsyncItemReference, ItemData, ItemReference, ItemValue } from "./ItemReference.js";
+import type { AsyncProvider, Provider } from "../provider/Provider.js";
 import type { StopCallback } from "../util/callback.js";
 import type { Data } from "../util/data.js";
 import { BooleanState } from "../state/BooleanState.js";
@@ -15,10 +16,18 @@ export declare class ItemState<T extends Data = Data> extends State<ItemValue<T>
     get exists(): boolean;
     constructor(ref: ItemReference<T> | AsyncItemReference<T>);
     /** Refresh this state from the source provider. */
-    readonly refresh: () => void;
+    refresh(provider?: Provider | AsyncProvider): void;
     private _refresh;
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
-    refreshStale(maxAge: number): void;
-    /** Subscribe this state to the source provider. */
-    connectSource(): StopCallback;
+    refreshStale(maxAge: number, provider?: Provider | AsyncProvider): void;
+    /** Subscribe this state to a provider. */
+    connect(provider?: Provider | AsyncProvider): StopCallback;
+    [Symbol.asyncIterator](): AsyncGenerator<ItemValue<T>, void, void>;
+    private _iterating;
+    /** Start subscription to `MemoryProvider` if there is one. */
+    start(): void;
+    /** Stop subscription to `MemoryProvider` if there is one. */
+    stop(): void;
+    private _stop;
+    [Symbol.dispose](): void;
 }

package/db/ItemState.js

@@ -1,7 +1,7 @@
 import { CacheProvider } from "../provider/CacheProvider.js";
-import { SwitchingDeferredSequence } from "../sequence/SwitchingDeferredSequence.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
+import { call } from "../util/callback.js";
 import { getRequired } from "../util/null.js";
 import { getOptionalSource } from "../util/source.js";
 import { getItemData } from "./ItemReference.js";
@@ -17,31 +17,32 @@ export class ItemState extends State {
     }
     /** Does the item exist? */
     get exists() {
-        return !this.loading && !!this.value;
+        return !!this.value;
     }
     constructor(ref) {
         var _a;
         const { provider, collection, id } = ref;
-        const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
-        const time = table ? table.getQueryTime(ref) : null;
-        const next = table ? new SwitchingDeferredSequence(sequence => sequence.from(table.getCachedItemSequence(id))) : undefined;
-        super(table && typeof time === "number" ? { value: table.getItem(id), time, next } : { next });
+        const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+        const time = memory ? memory.getItemTime(collection, id) : undefined;
+        super(memory && typeof time === "number" ? memory.getItem(collection, id) : undefined, time);
         this.busy = new BooleanState();
-        /** Refresh this state from the source provider. */
-        this.refresh = () => {
-            if (!this.busy.value)
-                void this._refresh();
-        };
+        this._iterating = 0;
+        this._stop = undefined;
         this.ref = ref;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
             this.refresh();
     }
-    async _refresh() {
+    /** Refresh this state from the source provider. */
+    refresh(provider = this.ref.provider) {
+        if (!this.busy.value)
+            void this._refresh(provider);
+    }
+    async _refresh(provider) {
         this.busy.value = true;
         this.reason = undefined; // Optimistically clear the error.
         try {
-            this.value = await this.ref.value;
+            this.value = (await provider.getItem(this.ref.collection, this.ref.id));
         }
         catch (thrown) {
             this.reason = thrown;
@@ -51,12 +52,44 @@ export class ItemState extends State {
         }
     }
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
-    refreshStale(maxAge) {
+    refreshStale(maxAge, provider) {
         if (this.age > maxAge)
-            this.refresh();
+            this.refresh(provider);
+    }
+    /** Subscribe this state to a provider. */
+    connect(provider = this.ref.provider) {
+        return this.from(provider.getItemSequence(this.ref.collection, this.ref.id));
+    }
+    // Override to subscribe to `MemoryProvider` while things are iterating over this state.
+    async *[Symbol.asyncIterator]() {
+        this.start();
+        this._iterating++;
+        try {
+            yield* super[Symbol.asyncIterator]();
+        }
+        finally {
+            this._iterating--;
+            if (this._iterating < 1)
+                this.stop();
+        }
+    }
+    /** Start subscription to `MemoryProvider` if there is one. */
+    start() {
+        var _a;
+        if (!this._stop) {
+            const { collection, id, provider } = this.ref;
+            const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+            if (memory)
+                this._stop = this.from(memory.getCachedItemSequence(collection, id));
+        }
+    }
+    /** Stop subscription to `MemoryProvider` if there is one. */
+    stop() {
+        if (this._stop)
+            this._stop = void call(this._stop);
     }
-    /** Subscribe this state to the source provider. */
-    connectSource() {
-        return this.from(this.ref);
+    // Implement `Disposable`
+    [Symbol.dispose]() {
+        this.stop();
     }
 }

package/db/QueryState.d.ts

@@ -1,5 +1,6 @@
 import type { ItemArray, ItemData, ItemValue } from "./ItemReference.js";
 import type { AsyncQueryReference, QueryReference } from "./QueryReference.js";
+import type { AsyncProvider, Provider } from "../provider/Provider.js";
 import type { StopCallback } from "../util/callback.js";
 import type { Data } from "../util/data.js";
 import { BooleanState } from "../state/BooleanState.js";
@@ -26,18 +27,25 @@ export declare class QueryState<T extends Data = Data> extends State<ItemArray<T
     get count(): number;
     constructor(ref: QueryReference<T> | AsyncQueryReference<T>);
     /** Refresh this state from the source provider. */
-    readonly refresh: () => void;
+    refresh(provider?: Provider | AsyncProvider): void;
     private _refresh;
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
-    /** Subscribe this state to the source provider. */
-    connectSource(): StopCallback;
+    /** Subscribe this state to a provider. */
+    connect(provider?: Provider | AsyncProvider): StopCallback;
     /**
      * Load more items after the last once.
      * - Promise that needs to be handled.
      */
-    readonly loadMore: () => void;
+    loadMore(): void;
     private _loadMore;
-    /** Iterate over the items. */
+    [Symbol.asyncIterator](): AsyncGenerator<ItemArray<T>, void, void>;
+    private _iterating;
+    /** Start subscription to `MemoryProvider` if there is one. */
+    start(): void;
+    /** Stop subscription to `MemoryProvider` if there is one. */
+    stop(): void;
+    private _stop;
+    [Symbol.dispose](): void;
     [Symbol.iterator](): Iterator<ItemData<T>>;
 }

package/db/QueryState.js

@@ -1,8 +1,9 @@
 import { CacheProvider } from "../provider/CacheProvider.js";
-import { SwitchingDeferredSequence } from "../sequence/SwitchingDeferredSequence.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 import { getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
+import { call } from "../util/callback.js";
+import { NONE } from "../util/constants.js";
 import { getRequired } from "../util/null.js";
 import { getAfterQuery, getLimit } from "../util/query.js";
 import { getOptionalSource } from "../util/source.js";
@@ -30,7 +31,7 @@ export class QueryState extends State {
     }
     /** Does the document have at least one result. */
     get exists() {
-        return !this.loading && !!this.value.length;
+        return !!this.value.length;
     }
     /** Get the number of items matching this query. */
     get count() {
@@ -39,36 +40,29 @@ export class QueryState extends State {
     constructor(ref) {
         var _a, _b;
         const { provider, collection, query } = ref;
-        const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
-        const time = table ? table.getQueryTime(ref) : null;
-        const next = table ? new SwitchingDeferredSequence(sequence => sequence.from(table.getCachedQuerySequence(ref))) : undefined;
-        super(table && typeof time === "number" ? { value: table.getQuery(ref), time, next } : { next });
+        const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+        const time = memory ? memory.getQueryTime(collection, query) : undefined;
+        super(memory && typeof time === "number" ? memory.getQuery(collection, query) : NONE, time);
         this.busy = new BooleanState();
         this._hasMore = false;
-        /** Refresh this state from the source provider. */
-        this.refresh = () => {
-            if (!this.busy.value)
-                void this._refresh();
-        };
-        /**
-         * Load more items after the last once.
-         * - Promise that needs to be handled.
-         */
-        this.loadMore = () => {
-            if (!this.busy.value)
-                void this._loadMore();
-        };
+        this._iterating = 0;
+        this._stop = undefined;
         this.ref = ref;
         this.limit = (_b = getLimit(query)) !== null && _b !== void 0 ? _b : Infinity;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
             this.refresh();
     }
-    async _refresh() {
+    /** Refresh this state from the source provider. */
+    refresh(provider = this.ref.provider) {
+        if (!this.busy.value)
+            void this._refresh(provider);
+    }
+    async _refresh(provider) {
         this.busy.value = true;
         this.reason = undefined; // Optimistically clear the error.
         try {
-            const items = await this.ref.items;
+            const items = (await provider.getQuery(this.ref.collection, this.ref.query));
             this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
             this.value = items;
         }
@@ -84,9 +78,17 @@ export class QueryState extends State {
         if (this.age > maxAge)
             this.refresh();
     }
-    /** Subscribe this state to the source provider. */
-    connectSource() {
-        return this.from(this.ref);
+    /** Subscribe this state to a provider. */
+    connect(provider = this.ref.provider) {
+        return this.from(provider.getQuerySequence(this.ref.collection, this.ref.query));
+    }
+    /**
+     * Load more items after the last once.
+     * - Promise that needs to be handled.
+     */
+    loadMore() {
+        if (!this.busy.value)
+            void this._loadMore();
     }
     async _loadMore() {
         this.busy.value = true;
@@ -105,7 +107,39 @@ export class QueryState extends State {
             this.busy.value = false;
         }
     }
-    /** Iterate over the items. */
+    // Override to subscribe to `MemoryProvider` while things are iterating over this state.
+    async *[Symbol.asyncIterator]() {
+        this.start();
+        this._iterating++;
+        try {
+            yield* super[Symbol.asyncIterator]();
+        }
+        finally {
+            this._iterating--;
+            if (this._iterating < 1)
+                this.stop();
+        }
+    }
+    /** Start subscription to `MemoryProvider` if there is one. */
+    start() {
+        var _a;
+        if (!this._stop) {
+            const { collection, query, provider } = this.ref;
+            const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+            if (memory)
+                this._stop = this.from(memory.getCachedQuerySequence(collection, query));
+        }
+    }
+    /** Stop subscription to `MemoryProvider` if there is one. */
+    stop() {
+        if (this._stop)
+            this._stop = void call(this._stop);
+    }
+    // Implement `Disposable`
+    [Symbol.dispose]() {
+        this.stop();
+    }
+    // Implement `Iteratable`
     [Symbol.iterator]() {
         return this.value.values();
     }

package/firestore/client/FirestoreClientProvider.js

@@ -1,6 +1,6 @@
 import { addDoc, collection, deleteDoc, doc, documentId, getDoc, getDocs, increment, limit, onSnapshot, orderBy, query, setDoc, updateDoc, where } from "firebase/firestore";
 import { getItemData } from "../../db/ItemReference.js";
-import { SwitchingDeferredSequence } from "../../sequence/SwitchingDeferredSequence.js";
+import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
 import { mapItems } from "../../util/transform.js";
@@ -61,7 +61,7 @@ export class FirestoreClientProvider {
         return _getItemValue(await getDoc(doc(this._firestore, c, id)));
     }
     getItemSequence(c, id) {
-        return new SwitchingDeferredSequence(sequence => onSnapshot(doc(this._firestore, c, id), //
+        return new LazyDeferredSequence(sequence => onSnapshot(doc(this._firestore, c, id), //
         //
         snapshot => sequence.resolve(_getItemValue(snapshot)), reason => sequence.reject(reason)));
     }
@@ -82,7 +82,7 @@ export class FirestoreClientProvider {
         return _getItems(await getDocs(_getQuery(this._firestore, c, q)));
     }
     getQuerySequence(c, q) {
-        return new SwitchingDeferredSequence(sequence => onSnapshot(_getQuery(this._firestore, c, q), //
+        return new LazyDeferredSequence(sequence => onSnapshot(_getQuery(this._firestore, c, q), //
         //
         snapshot => sequence.resolve(_getItems(snapshot)), reason => sequence.reject(reason)));
     }

package/firestore/server/FirestoreServerProvider.js

@@ -1,6 +1,6 @@
 import { FieldPath, FieldValue, Firestore } from "@google-cloud/firestore";
 import { getItemData } from "../../db/ItemReference.js";
-import { SwitchingDeferredSequence } from "../../sequence/SwitchingDeferredSequence.js";
+import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
 import { mapItems } from "../../util/transform.js";
@@ -59,7 +59,7 @@ export class FirestoreServerProvider {
     }
     getItemSequence(c, id) {
         const ref = this._firestore.collection(c).doc(id);
-        return new SwitchingDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemValue(snapshot)), //
+        return new LazyDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemValue(snapshot)), //
         sequence.reject));
     }
     async addItem(c, data) {
@@ -79,7 +79,7 @@ export class FirestoreServerProvider {
     }
     getQuerySequence(c, q) {
         const ref = _getQuery(this._firestore, c, q);
-        return new SwitchingDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemArray(snapshot)), //
+        return new LazyDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemArray(snapshot)), //
         sequence.reject));
     }
     async setQuery(c, q, data) {

package/firestore/util/error.d.ts

@@ -0,0 +1,2 @@
+/** Convert a Firestore error (which use gRPC error codes) into a corresponding Shelving error. */
+export declare function convertFirestoreError(thrown: unknown): never;

package/firestore/util/error.js

@@ -0,0 +1,19 @@
+import { ConnectionError } from "../../error/ConnectionError.js";
+import { PermissionError } from "../../error/PermissionError.js";
+import { RequiredError } from "../../error/RequiredError.js";
+import { isObject } from "../../util/object.js";
+/** Convert a Firestore error (which use gRPC error codes) into a corresponding Shelving error. */
+export function convertFirestoreError(thrown) {
+    if (isObject(thrown)) {
+        const code = thrown.code;
+        if (typeof code === "string") {
+            if (code === "unavailable")
+                throw new ConnectionError();
+            if (code === "not-found")
+                throw new RequiredError();
+            if (code === "permission-denied")
+                throw new PermissionError();
+        }
+    }
+    throw thrown;
+}

package/iterate/ThroughGenerator.d.ts

@@ -1,7 +1,7 @@
 import { AbstractGenerator } from "./AbstractGenerator.js";
 /** Iterable that pulls values from a source iterable. */
 export declare class ThroughGenerator<T, R, N> extends AbstractGenerator<T, R, N> {
-    private readonly _iterator;
+    private readonly _source;
     constructor(iterator: Iterator<T, R, N>);
     next(value: N): IteratorResult<T, R>;
     throw(thrown: Error | unknown): IteratorResult<T, R>;

package/iterate/ThroughGenerator.js

@@ -3,16 +3,16 @@ import { AbstractGenerator } from "./AbstractGenerator.js";
 export class ThroughGenerator extends AbstractGenerator {
     constructor(iterator) {
         super();
-        this._iterator = iterator;
+        this._source = iterator;
     }
     // Implement `AbstractGenerator`
     next(value) {
-        return this._iterator.next(value);
+        return this._source.next(value);
     }
     throw(thrown) {
-        return this._iterator.throw ? this._iterator.throw(thrown) : super.throw(thrown);
+        return this._source.throw ? this._source.throw(thrown) : super.throw(thrown);
     }
     return(value) {
-        return this._iterator.return ? this._iterator.return(value) : super.return(value);
+        return this._source.return ? this._source.return(value) : super.return(value);
     }
 }

package/package.json

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

package/provider/DebugProvider.js

@@ -3,9 +3,9 @@
 class AbstractDebugProvider {
     async *getItemSequence(collection, id) {
         try {
-            console.debug("✔ ITERATE", collection, id);
+            console.debug("⋯ ITERATE", collection, id);
             for await (const item of this.source.getItemSequence(collection, id)) {
-                console.debug("✔ ITERATE", collection, id, "GOT", item);
+                console.debug("↩ ITERATE", collection, id, item);
                 yield item;
             }
             console.debug("✔ ITERATE", collection, id);
@@ -16,9 +16,9 @@ class AbstractDebugProvider {
     }
     async *getQuerySequence(collection, query) {
         try {
-            console.debug("✔ ITERATE", collection, query);
+            console.debug("⋯ ITERATE", collection, query);
             for await (const items of this.source.getQuerySequence(collection, query)) {
-                console.debug("✔ ITERATE", collection, query, items);
+                console.debug("↩ ITERATE", collection, query, items);
                 yield items;
             }
             console.debug("✔ ITERATE", collection, query);
@@ -37,7 +37,7 @@ export class DebugProvider extends AbstractDebugProvider {
     getItem(collection, id) {
         try {
             const item = this.source.getItem(collection, id);
-            console.debug("✔ GET", collection, id, "ITEM", item);
+            console.debug("↩ GET", collection, id, item);
             return item;
         }
         catch (reason) {
@@ -48,7 +48,7 @@ export class DebugProvider extends AbstractDebugProvider {
     addItem(collection, data) {
         try {
             const id = this.source.addItem(collection, data);
-            console.debug("✔ ADD", collection, data, "ID", id);
+            console.debug("✔ ADD", collection, data, id);
             return id;
         }
         catch (reason) {
@@ -68,8 +68,8 @@ export class DebugProvider extends AbstractDebugProvider {
     }
     updateItem(collection, id, updates) {
         try {
+            this.source.updateItem(collection, id, updates);
             console.debug("✔ UPDATE", collection, id, updates);
-            return this.source.updateItem(collection, id, updates);
         }
         catch (reason) {
             console.error("✘ UPDATE", collection, id, updates, reason);
@@ -89,7 +89,7 @@ export class DebugProvider extends AbstractDebugProvider {
     getQuery(collection, query) {
         try {
             const items = this.source.getQuery(collection, query);
-            console.debug("✔ GET", collection, query, "ITEMS", items);
+            console.debug("✔ GET", collection, query, items);
             return items;
         }
         catch (reason) {
@@ -141,7 +141,7 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
         try {
             console.debug("⋯ GET", collection, id);
             const item = await this.source.getItem(collection, id);
-            console.debug("✔ GET", collection, id, "ITEM", item);
+            console.debug("↩ GET", collection, id, item);
             return item;
         }
         catch (reason) {
@@ -198,7 +198,7 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
         try {
             console.debug("⋯ GET", collection, query);
             const items = await this.source.getQuery(collection, query);
-            console.debug("✔ GET", collection, query, "ITEMS", items);
+            console.debug("✔ GET", collection, query, items);
             return items;
         }
         catch (reason) {

package/provider/MemoryProvider.d.ts

@@ -16,6 +16,7 @@ export declare class MemoryProvider implements Provider {
     getItemTime(collection: string, id: string): number | undefined;
     getItem(collection: string, id: string): ItemValue;
     getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
+    getCachedItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
     addItem(collection: string, data: Data): string;
     setItem(collection: string, id: string, data: Data): boolean;
     updateItem(collection: string, id: string, updates: Updates): boolean;
@@ -23,6 +24,7 @@ export declare class MemoryProvider implements Provider {
     getQueryTime(collection: string, query: ItemQuery): number | undefined;
     getQuery(collection: string, query: ItemQuery): ItemArray;
     getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
+    getCachedQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
     setQuery(collection: string, query: ItemQuery, data: Data): number;
     updateQuery(collection: string, query: ItemQuery, updates: Updates): number;
     deleteQuery(collection: string, query: ItemQuery): number;
@@ -34,7 +36,7 @@ export declare class MemoryTable<T extends Data = Data> {
     /** Times data was last updated. */
     protected readonly _times: Map<string, number>;
     /** Deferred sequence of next values. */
-    readonly _changed: DeferredSequence<void, void>;
+    readonly _changed: DeferredSequence<void>;
     getItemTime(id: string): number | undefined;
     getItem(id: string): ItemValue<T>;
     getItemSequence(id: string): AsyncIterable<ItemValue<T>>;

package/provider/MemoryProvider.js

@@ -30,6 +30,9 @@ export class MemoryProvider {
     getItemSequence(collection, id) {
         return this.getTable(collection).getItemSequence(id);
     }
+    getCachedItemSequence(collection, id) {
+        return this.getTable(collection).getCachedItemSequence(id);
+    }
     addItem(collection, data) {
         return this.getTable(collection).addItem(data);
     }
@@ -51,6 +54,9 @@ export class MemoryProvider {
     getQuerySequence(collection, query) {
         return this.getTable(collection).getQuerySequence(query);
     }
+    getCachedQuerySequence(collection, query) {
+        return this.getTable(collection).getCachedQuerySequence(query);
+    }
     setQuery(collection, query, data) {
         return this.getTable(collection).setQuery(query, data);
     }

package/react/createCache.js

@@ -1,8 +1,5 @@
-import { createContext, createElement, useContext } from "react";
+import { createContext, createElement, useContext, useRef } from "react";
 import { ConditionError } from "../error/ConditionError.js";
-import { useReduce } from "./useReduce.js";
-/** Reducer that gets an existing `Map` instance or creates a new one. */
-const _reduceMap = (previous) => previous || new Map();
 /** Create a cache. */
 export function createCache() {
     const context = createContext(undefined);
@@ -14,7 +11,8 @@ export function createCache() {
             return cache;
         },
         Cache: ({ children }) => {
-            const cache = useReduce(_reduceMap);
+            var _a;
+            const cache = ((_a = useRef()).current || (_a.current = new Map()));
             return createElement(context.Provider, { children, value: cache });
         },
     };

package/react/useData.d.ts

@@ -1,18 +1,14 @@
 /// <reference types="react" />
 import type { AsyncQueryReference } from "../db/QueryReference.js";
-import type { ImmutableArray } from "../util/array.js";
-import type { Nullish } from "../util/null.js";
+import type { Data } from "../util/data.js";
 import { AsyncItemReference } from "../db/ItemReference.js";
 import { ItemState } from "../db/ItemState.js";
 import { QueryState } from "../db/QueryState.js";
-type NullishReferenceState<T> = T extends undefined | null ? undefined : T extends AsyncItemReference<infer X> ? ItemState<X> : T extends AsyncQueryReference<infer X> ? QueryState<X> : never;
-/** Use one or more data items or queries. */
-export declare function useData<T extends Nullish<AsyncItemReference | AsyncQueryReference>>(ref: T): NullishReferenceState<T>;
-export declare function useData<T extends ImmutableArray<Nullish<AsyncItemReference | AsyncQueryReference>>>(...refs: T): {
-    [K in keyof T]: NullishReferenceState<T[K]>;
-};
+export declare function useData<T extends Data>(ref: AsyncItemReference<T>): ItemState<T>;
+export declare function useData<T extends Data>(ref: AsyncItemReference<T> | undefined): ItemState<T> | undefined;
+export declare function useData<T extends Data>(ref: AsyncQueryReference<T>): QueryState<T>;
+export declare function useData<T extends Data>(ref: AsyncQueryReference<T> | undefined): QueryState<T> | undefined;
 /** Wrap components with `<DataProvider>` to allow the use of `useData()`. */
 export declare const DataProvider: ({ children }: {
     children: import("react").ReactNode;
 }) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-export {};

package/react/useData.js

@@ -2,20 +2,15 @@ import { AsyncItemReference } from "../db/ItemReference.js";
 import { ItemState } from "../db/ItemState.js";
 import { QueryState } from "../db/QueryState.js";
 import { setMapItem } from "../util/map.js";
-import { mapArray } from "../util/transform.js";
 import { createCache } from "./createCache.js";
 import { useState } from "./useState.js";
 /** Create a cache. */
 const { Cache, useCache } = createCache();
-export function useData(...refs) {
+export function useData(ref) {
     const cache = useCache();
-    const states = mapArray(refs, _getRefState, cache);
-    return useState(...states);
-}
-/** Get the corresponding `ItemState` or `QueryState` instance from the cache for a given `Item` or `Query`. */
-function _getRefState(ref, cache) {
     const key = ref === null || ref === void 0 ? void 0 : ref.toString();
-    return ref && key ? cache.get(key) || setMapItem(cache, key, ref instanceof AsyncItemReference ? new ItemState(ref) : new QueryState(ref)) : undefined;
+    const state = ref && key ? cache.get(key) || setMapItem(cache, key, ref instanceof AsyncItemReference ? new ItemState(ref) : new QueryState(ref)) : undefined;
+    return useState(state);
 }
 /** Wrap components with `<DataProvider>` to allow the use of `useData()`. */
 export const DataProvider = Cache;

package/react/useState.d.ts

@@ -1,14 +1,3 @@
 import type { AnyState } from "../state/State.js";
-import type { ImmutableArray } from "../util/array.js";
-import type { Nullish } from "../util/null.js";
-/**
- * Subscribe to one or more `State` instances.
- *
- * @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<T extends AnyState>(state: T): T;
-export declare function useState<T extends AnyState>(state?: Nullish<T>): Nullish<T>;
-export declare function useState<T extends ImmutableArray<Nullish<AnyState>>>(...states: T): T;
+export declare function useState<T extends AnyState>(state?: T | undefined): T | undefined;