shelving 1.68.0 → 1.68.3

package/feedback/Feedback.js

@@ -1,5 +1,5 @@
 import { debug } from "../util/debug.js";
-import { toTitle } from "../util/string.js";
+import { getTitle } from "../util/string.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -27,7 +27,7 @@ export class Feedback {
             if (v instanceof Feedback)
                 messages[k] = v.feedback;
             else
-                messages[k] = toTitle(v);
+                messages[k] = getTitle(v);
         }
         return messages;
     }

package/firestore/client/FirestoreClientProvider.d.ts

@@ -2,9 +2,9 @@ import type { Firestore } from "firebase/firestore";
 import type { DocumentReference, QueryReference } from "../../db/Reference.js";
 import type { Data, Entities, OptionalEntity } from "../../util/data.js";
 import type { Unsubscribe } from "../../observe/Observable.js";
+import { Observer } from "../../observe/Observer.js";
 import { AsynchronousProvider, Provider } from "../../provider/Provider.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
-import { Observer } from "../../observe/Observer.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.

package/firestore/client/FirestoreClientProvider.js

@@ -1,11 +1,13 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
+import { dispatchError, dispatchNext } from "../../observe/Observer.js";
 import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { Provider } from "../../provider/Provider.js";
 import { ArrayUpdate } from "../../update/ArrayUpdate.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 import { Increment } from "../../update/Increment.js";
 import { ObjectUpdate } from "../../update/ObjectUpdate.js";
-import { dispatchError, dispatchNext } from "../../observe/Observer.js";
+import { Delete } from "../../update/Delete.js";
+import { Update } from "../../update/Update.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.
@@ -60,7 +62,9 @@ function getOptionalEntity(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* yieldFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update === undefined)
+        if (!(update instanceof Update))
+            yield [`${prefix}${key}`, update];
+        else if (update instanceof Delete)
             yield [`${prefix}${key}`, firestoreDeleteField()];
         else if (update instanceof Increment)
             yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
@@ -75,7 +79,7 @@ function* yieldFieldValues(updates, prefix = "") {
                 yield [`${prefix}${key}`, firestoreArrayRemove(...update.deletes)];
         }
         else
-            yield [`${prefix}${key}`, update];
+            yield [`${prefix}${key}`, update.transform()];
     }
 }
 /**

package/firestore/lite/FirestoreLiteProvider.js

@@ -5,6 +5,8 @@ import { ArrayUpdate } from "../../update/ArrayUpdate.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 import { Increment } from "../../update/Increment.js";
 import { ObjectUpdate } from "../../update/ObjectUpdate.js";
+import { Update } from "../../update/Update.js";
+import { Delete } from "../../update/Delete.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.
@@ -59,7 +61,9 @@ function getOptionalData(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* yieldFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update === undefined)
+        if (!(update instanceof Update))
+            yield [`${prefix}${key}`, update];
+        else if (update instanceof Delete)
             yield [`${prefix}${key}`, firestoreDeleteField()];
         else if (update instanceof Increment)
             yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
@@ -74,7 +78,7 @@ function* yieldFieldValues(updates, prefix = "") {
                 yield [`${prefix}${key}`, firestoreArrayRemove(...update.deletes)];
         }
         else
-            yield [`${prefix}${key}`, update];
+            yield [`${prefix}${key}`, update.transform()];
     }
 }
 /**

package/firestore/server/FirestoreServerProvider.d.ts

@@ -2,9 +2,9 @@ import { Firestore } from "@google-cloud/firestore";
 import type { DocumentReference, QueryReference } from "../../db/Reference.js";
 import type { Data, Entities, OptionalEntity } from "../../util/data.js";
 import type { Unsubscribe } from "../../observe/Observable.js";
+import { Observer } from "../../observe/Observer.js";
 import { AsynchronousProvider, Provider } from "../../provider/Provider.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
-import { Observer } from "../../observe/Observer.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS

package/firestore/server/FirestoreServerProvider.js

@@ -1,11 +1,13 @@
 import { Firestore, FieldValue } from "@google-cloud/firestore";
+import { dispatchError, dispatchNext } from "../../observe/Observer.js";
 import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { Provider } from "../../provider/Provider.js";
 import { ArrayUpdate } from "../../update/ArrayUpdate.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 import { Increment } from "../../update/Increment.js";
 import { ObjectUpdate } from "../../update/ObjectUpdate.js";
-import { dispatchError, dispatchNext } from "../../observe/Observer.js";
+import { Delete } from "../../update/Delete.js";
+import { Update } from "../../update/Update.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.
@@ -60,7 +62,9 @@ function getOptionalEntity(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* yieldFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update === undefined)
+        if (!(update instanceof Update))
+            yield [`${prefix}${key}`, update];
+        else if (update instanceof Delete)
             yield [`${prefix}${key}`, FieldValue.delete()];
         else if (update instanceof Increment)
             yield [`${prefix}${key}`, FieldValue.increment(update.amount)];
@@ -75,7 +79,7 @@ function* yieldFieldValues(updates, prefix = "") {
                 yield [`${prefix}${key}`, FieldValue.arrayRemove(...update.deletes)];
         }
         else
-            yield [`${prefix}${key}`, update];
+            yield [`${prefix}${key}`, update.transform()];
     }
 }
 /**

package/index.js

@@ -19,5 +19,8 @@ export * from "./update/index.js";
 export * from "./util/index.js";
 // Integrations.
 // export * from "./react/index.js"; // Not exported.
+// export * from "./firestore/client/index.js"; // Not exported.
+// export * from "./firestore/lite/index.js"; // Not exported.
+// export * from "./firestore/server/index.js"; // Not exported.
 // Testing.
 // export * from "./test/index.js"; // Not exported.

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.68.0",
+	"version": "1.68.3",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -29,11 +29,12 @@
 		"./firestore/lite": "./firestore/lite/index.js",
 		"./firestore/server": "./firestore/server/index.js",
 		"./markup": "./markup/index.js",
+		"./observe": "./observe/index.js",
 		"./provider": "./provider/index.js",
 		"./query": "./query/index.js",
 		"./react": "./react/index.js",
 		"./schema": "./schema/index.js",
-		"./stream": "./stream/index.js",
+		"./state": "./state/index.js",
 		"./test": "./test/index.js",
 		"./update": "./update/index.js",
 		"./util": "./util/index.js"

package/provider/ThroughProvider.d.ts

@@ -31,5 +31,7 @@ export interface SynchronousThroughProvider extends SynchronousProvider {
 export interface AsynchronousThroughProvider extends AsynchronousProvider {
     new (source: AsynchronousProvider): AsynchronousProvider;
 }
-/** Find a specific source provider in a database's provider stack. */
-export declare function findSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P | undefined;
+/** Find a possible source provider in a database's provider stack (if it exists). */
+export declare function getOptionalSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P | undefined;
+/** Find a source provider in a database's provider stack. */
+export declare function getSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P;

package/provider/ThroughProvider.js

@@ -1,3 +1,4 @@
+import { AssertionError } from "../error/AssertionError.js";
 import { Provider } from "./Provider.js";
 /**
  * Pass all reads and writes through to a source provider.
@@ -41,10 +42,17 @@ export class ThroughProvider extends Provider {
         return this.source.deleteQuery(ref);
     }
 }
-/** Find a specific source provider in a database's provider stack. */
-export function findSourceProvider(provider, type) {
+/** Find a possible source provider in a database's provider stack (if it exists). */
+export function getOptionalSourceProvider(provider, type) {
     if (provider instanceof type)
         return provider;
     if (provider instanceof ThroughProvider)
-        return findSourceProvider(provider.source, type);
+        return getSourceProvider(provider.source, type);
+}
+/** Find a source provider in a database's provider stack. */
+export function getSourceProvider(provider, type) {
+    const source = getOptionalSourceProvider(provider, type);
+    if (!source)
+        throw new AssertionError(`Source provider ${type.name} not found`, provider);
+    return source;
 }

package/provider/ValidationProvider.js

@@ -1,6 +1,5 @@
 import { callAsync } from "../util/async.js";
 import { validate } from "../util/validate.js";
-import { validateUpdate } from "../update/util.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { ValidationError } from "../error/ValidationError.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
@@ -21,7 +20,7 @@ export class ValidationProvider extends ThroughProvider {
         return super.setDocument(ref, validate(value, ref.validator));
     }
     updateDocument(ref, update) {
-        return super.updateDocument(ref, validateUpdate(update, ref.validator));
+        return super.updateDocument(ref, update.validate(ref.validator));
     }
     getQuery(ref) {
         return callAsync(_validateEntities, super.getQuery(ref), ref);
@@ -33,7 +32,7 @@ export class ValidationProvider extends ThroughProvider {
         return super.setQuery(ref, validate(value, ref.validator));
     }
     updateQuery(ref, update) {
-        return super.updateQuery(ref, validateUpdate(update, ref.validator));
+        return super.updateQuery(ref, update.validate(ref.validator));
     }
 }
 /** Validate an entity for a document reference. */

package/react/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./useLazy.js";
 export * from "./useReduce.js";
 export * from "./useInstance.js";
+export * from "./useCache.js";
 export * from "./useSubscribe.js";
 export * from "./useDocument.js";
 export * from "./useQuery.js";

package/react/index.js

@@ -2,6 +2,7 @@
 export * from "./useLazy.js";
 export * from "./useReduce.js";
 export * from "./useInstance.js";
+export * from "./useCache.js";
 // Observables.
 export * from "./useSubscribe.js";
 // DB.

package/react/useCache.d.ts

@@ -15,12 +15,32 @@ export declare class CacheController<T> {
 /**
  * Default cache
  * - This is a flexible generic cache intended to be the default.
- * - Use this cache unless
+ * - Use this cache unless you want to cache a completely independent set of items without interference.
  */
 export declare const CACHE: CacheController<any>;
-/** Use a global cache in a component. */
+/**
+ * Use a global cache in a component.
+ * - Throws an error if used outside of `<Cache>`
+ */
 export declare const useCache: () => Map<string, any>;
-/** Component that provides a global cache to its children. */
+/**
+ * Component that provides a global cache to its children.
+ *
+ * Note: If mounted globally this cache will bloat over time, so you need a strategy to clear or reset the cache occasionally.
+ *
+ * A good strategy is to wrap a separate `<Cache>` around each page of your app.
+ * This means the cache can only grow to the size of each page and the memory is released when the user navigates to a new page.
+ * You might need to use `<Cache key="something unique to the page">` to ensure the cache component is destroyed and remounted for each page.
+ *
+ * Put a `<Suspense>` boundary _inside_ `<Cache>`
+ * - This prevents promises being thrown up through the cache causing it to be destroyed.
+ * - When the promise resolves and the render is tried again the data would not exist (because the cache was destroyed).
+ * - This will cause an infinite loading loop.
+ *
+ * Put your error boundary _outside_ your `<Cache>`
+ * - The error being thrown up through the cache causes it to be destroyed.
+ * - This means when the uses tells the error boundary to try again (if supported) all data on the page will be retried.
+ */
 export declare const Cache: ({ children }: {
     children: React.ReactNode;
 }) => React.ReactElement | null;

package/react/useCache.js

@@ -27,10 +27,30 @@ const _reduceMap = (previous) => previous || new Map();
 /**
  * Default cache
  * - This is a flexible generic cache intended to be the default.
- * - Use this cache unless
+ * - Use this cache unless you want to cache a completely independent set of items without interference.
  */
 export const CACHE = new CacheController(); // eslint-disable-line @typescript-eslint/no-explicit-any
-/** Use a global cache in a component. */
+/**
+ * Use a global cache in a component.
+ * - Throws an error if used outside of `<Cache>`
+ */
 export const useCache = CACHE.useCache;
-/** Component that provides a global cache to its children. */
+/**
+ * Component that provides a global cache to its children.
+ *
+ * Note: If mounted globally this cache will bloat over time, so you need a strategy to clear or reset the cache occasionally.
+ *
+ * A good strategy is to wrap a separate `<Cache>` around each page of your app.
+ * This means the cache can only grow to the size of each page and the memory is released when the user navigates to a new page.
+ * You might need to use `<Cache key="something unique to the page">` to ensure the cache component is destroyed and remounted for each page.
+ *
+ * Put a `<Suspense>` boundary _inside_ `<Cache>`
+ * - This prevents promises being thrown up through the cache causing it to be destroyed.
+ * - When the promise resolves and the render is tried again the data would not exist (because the cache was destroyed).
+ * - This will cause an infinite loading loop.
+ *
+ * Put your error boundary _outside_ your `<Cache>`
+ * - The error being thrown up through the cache causes it to be destroyed.
+ * - This means when the uses tells the error boundary to try again (if supported) all data on the page will be retried.
+ */
 export const Cache = CACHE.Cache;

package/react/useDocument.d.ts

@@ -13,7 +13,8 @@ export declare class DocumentState<T extends Data> extends State<OptionalEntity<
     get exists(): boolean;
     constructor(ref: DocumentReference<T>);
     /** Refresh this state from the source provider. */
-    readonly refresh: () => Promise<void>;
+    readonly refresh: () => void;
+    _refresh(): Promise<void>;
     /** 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. */
@@ -23,6 +24,9 @@ export declare class DocumentState<T extends Data> extends State<OptionalEntity<
     protected _addFirstObserver(): void;
     protected _removeLastObserver(): void;
 }
-/** Use a document in a React component. */
+/**
+ * Use a document in a React component.
+ * - Uses the default cache, so will error if not used inside `<Cache>`
+ */
 export declare function useDocument<T extends Data>(ref: DocumentReference<T>): DocumentState<T>;
 export declare function useDocument<T extends Data>(ref?: DocumentReference<T>): DocumentState<T> | undefined;

package/react/useDocument.js

@@ -1,7 +1,7 @@
 import { reduceMapItem } from "../util/map.js";
-import { getDocumentData, isSameReference } from "../db/Reference.js";
+import { getDocumentData } from "../db/Reference.js";
 import { CacheProvider } from "../provider/CacheProvider.js";
-import { findSourceProvider } from "../provider/ThroughProvider.js";
+import { getOptionalSourceProvider } from "../provider/ThroughProvider.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { ConditionError } from "../error/ConditionError.js";
@@ -12,34 +12,23 @@ import { useCache } from "./useCache.js";
 export class DocumentState extends State {
     constructor(ref) {
         var _a;
-        const table = (_a = findSourceProvider(ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(ref);
+        const table = (_a = getOptionalSourceProvider(ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(ref);
         const time = table ? table.getDocumentTime(ref.id) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getDocument(ref.id) : NOVALUE);
         this.busy = new BooleanState();
         /** Refresh this state from the source provider. */
-        this.refresh = async () => {
+        this.refresh = () => {
             if (this.closed)
                 throw new ConditionError("State is closed");
-            if (!this.busy.value) {
-                this.busy.next(true);
-                try {
-                    const result = await this.ref.value;
-                    this.next(result);
-                }
-                catch (thrown) {
-                    this.error(thrown);
-                }
-                finally {
-                    this.busy.next(false);
-                }
-            }
+            if (!this.busy.value)
+                void this._refresh();
         };
         this._time = time;
         this.ref = ref;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
-            void this.refresh();
+            this.refresh();
     }
     /** Get the data of the document (throws `RequiredError` if document doesn't exist). */
     get data() {
@@ -49,10 +38,23 @@ export class DocumentState extends State {
     get exists() {
         return !!this.value;
     }
+    async _refresh() {
+        this.busy.next(true);
+        try {
+            const result = await this.ref.value;
+            this.next(result);
+        }
+        catch (thrown) {
+            this.error(thrown);
+        }
+        finally {
+            this.busy.next(false);
+        }
+    }
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge) {
         if (this.age > maxAge)
-            void this.refresh();
+            this.refresh();
     }
     /** Subscribe this state to the source provider. */
     connectSource() {
@@ -61,7 +63,7 @@ export class DocumentState extends State {
     /** Subscribe this state to any `CacheProvider` that exists in the provider chain. */
     connectCache() {
         var _a;
-        const table = (_a = findSourceProvider(this.ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(this.ref);
+        const table = (_a = getOptionalSourceProvider(this.ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(this.ref);
         table && this.connect(() => table.subscribeCachedDocument(this.ref.id, this));
     }
     // Override to subscribe to the cache when an observer is added.
@@ -75,7 +77,7 @@ export class DocumentState extends State {
     }
 }
 /** Reuse the previous `DocumentState` or create a new one. */
-const _reduceDocumentState = (existing, ref) => (existing && isSameReference(existing.ref, ref) ? existing : new DocumentState(ref));
+const _reduceDocumentState = (existing, ref) => existing || new DocumentState(ref);
 export function useDocument(ref) {
     const cache = useCache();
     const state = ref ? reduceMapItem(cache, ref.toString(), _reduceDocumentState, ref) : undefined;

package/react/useQuery.d.ts

@@ -25,7 +25,8 @@ export declare class QueryState<T extends Data> extends State<Entities<T>> {
     get count(): number;
     constructor(ref: QueryReference<T>);
     /** Refresh this state from the source provider. */
-    readonly refresh: () => Promise<void>;
+    readonly refresh: () => void;
+    _refresh(): Promise<void>;
     /** 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. */
@@ -38,8 +39,12 @@ export declare class QueryState<T extends Data> extends State<Entities<T>> {
      * Load more items after the last once.
      * - Promise that needs to be handled.
      */
-    readonly loadMore: () => Promise<void>;
+    readonly loadMore: () => void;
+    _loadMore(): Promise<void>;
 }
-/** Use a query in a React component. */
+/**
+ * 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 Data>(ref: QueryReference<T>): QueryState<T>;
 export declare function useQuery<T extends Data>(ref?: QueryReference<T>): QueryState<T> | undefined;

package/react/useQuery.js

@@ -1,7 +1,7 @@
 import { reduceMapItem } from "../util/map.js";
-import { getQueryFirstData, getQueryFirstValue, isSameReference } from "../db/Reference.js";
+import { getQueryFirstData, getQueryFirstValue } from "../db/Reference.js";
 import { CacheProvider } from "../provider/CacheProvider.js";
-import { findSourceProvider } from "../provider/ThroughProvider.js";
+import { getOptionalSourceProvider } from "../provider/ThroughProvider.js";
 import { State } from "../state/State.js";
 import { ConditionError } from "../error/ConditionError.js";
 import { BooleanState } from "../state/BooleanState.js";
@@ -12,59 +12,35 @@ import { useCache } from "./useCache.js";
 export class QueryState extends State {
     constructor(ref) {
         var _a, _b;
-        const table = (_a = findSourceProvider(ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(ref);
+        const table = (_a = getOptionalSourceProvider(ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(ref);
         const time = table ? table.getQueryTime(ref) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getQuery(ref) : NOVALUE);
         this.busy = new BooleanState();
         this._hasMore = false;
         /** Refresh this state from the source provider. */
-        this.refresh = async () => {
+        this.refresh = () => {
             if (this.closed)
                 throw new ConditionError("State is closed");
-            if (!this.busy.value) {
-                this.busy.next(true);
-                try {
-                    const result = await this.ref.value;
-                    this._hasMore = result.length < this.limit;
-                    this.next(result);
-                }
-                catch (thrown) {
-                    this.error(thrown);
-                }
-                finally {
-                    this.busy.next(false);
-                }
-            }
+            if (!this.busy.value)
+                void this._refresh();
         };
         /**
          * Load more items after the last once.
          * - Promise that needs to be handled.
          */
-        this.loadMore = async () => {
+        this.loadMore = () => {
             if (this.closed)
                 throw new ConditionError("State is closed");
-            if (!this.busy.value) {
-                this.busy.next(true);
-                try {
-                    const items = await this.ref.after(this.lastData).value;
-                    this.next([...this.value, ...items]);
-                    this._hasMore = items.length < this.limit;
-                }
-                catch (thrown) {
-                    this.error(thrown);
-                }
-                finally {
-                    this.busy.next(false);
-                }
-            }
+            if (!this.busy.value)
+                void this._loadMore();
         };
         this._time = time;
         this.ref = ref;
         this.limit = (_b = ref.limit) !== null && _b !== void 0 ? _b : Infinity;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
-            void this.refresh();
+            this.refresh();
     }
     /** Can more items be loaded after the current result. */
     get hasMore() {
@@ -94,10 +70,24 @@ export class QueryState extends State {
     get count() {
         return this.value.length;
     }
+    async _refresh() {
+        this.busy.next(true);
+        try {
+            const result = await this.ref.value;
+            this._hasMore = result.length < this.limit;
+            this.next(result);
+        }
+        catch (thrown) {
+            this.error(thrown);
+        }
+        finally {
+            this.busy.next(false);
+        }
+    }
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge) {
         if (this.age > maxAge)
-            void this.refresh();
+            this.refresh();
     }
     /** Subscribe this state to the source provider. */
     connectSource() {
@@ -106,7 +96,7 @@ export class QueryState extends State {
     /** Subscribe this state to any `CacheProvider` that exists in the provider chain. */
     connectCache() {
         var _a;
-        const table = (_a = findSourceProvider(this.ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(this.ref);
+        const table = (_a = getOptionalSourceProvider(this.ref.db.provider, CacheProvider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(this.ref);
         return table && this.connect(() => table.subscribeCachedQuery(this.ref, this));
     }
     // Override to subscribe to the cache when an observer is added.
@@ -118,9 +108,23 @@ export class QueryState extends State {
         // Disconnect all sources.
         this.disconnect();
     }
+    async _loadMore() {
+        this.busy.next(true);
+        try {
+            const items = await this.ref.after(this.lastData).value;
+            this.next([...this.value, ...items]);
+            this._hasMore = items.length < this.limit;
+        }
+        catch (thrown) {
+            this.error(thrown);
+        }
+        finally {
+            this.busy.next(false);
+        }
+    }
 }
 /** Reuse the previous `QueryState` or create a new one. */
-const _reduceQueryState = (existing, ref) => (existing && isSameReference(existing.ref, ref) ? existing : new QueryState(ref));
+const _reduceQueryState = (existing, ref) => existing || new QueryState(ref);
 export function useQuery(ref) {
     const cache = useCache();
     const state = ref ? reduceMapItem(cache, ref.toString(), _reduceQueryState, ref) : undefined;

package/schema/AllowSchema.js

@@ -1,7 +1,7 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { toString } from "../util/string.js";
+import { getString } from "../util/string.js";
 import { isItem } from "../util/array.js";
-import { toNumber } from "../util/number.js";
+import { getOptionalNumber } from "../util/number.js";
 import { isKey } from "../util/object.js";
 import { Schema } from "./Schema.js";
 /** Validate a value against a specific set of allowed values. */
@@ -27,13 +27,13 @@ export class AllowSchema extends Schema {
 /** Define a valid string from an allowed set of strings. */
 export class AllowStringSchema extends AllowSchema {
     validate(unsafeValue = this.value) {
-        return validateAllowed(toString(unsafeValue), this.allow);
+        return validateAllowed(getString(unsafeValue), this.allow);
     }
 }
 /** Define a valid number from an allowed set of numbers. */
 export class AllowNumberSchema extends AllowSchema {
     validate(unsafeValue = this.value) {
-        return validateAllowed(toNumber(unsafeValue), this.allow);
+        return validateAllowed(getOptionalNumber(unsafeValue), this.allow);
     }
 }
 /** Valid string from an allowed set of strings. */

package/schema/ArraySchema.js

@@ -1,6 +1,6 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { getArray, uniqueArray } from "../util/array.js";
-import { validateItems } from "../util/validate.js";
+import { uniqueArray } from "../util/array.js";
+import { validateArray } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /**
  * Define a valid array.
@@ -41,7 +41,7 @@ export class ArraySchema extends Schema {
     validate(unsafeValue = this.value) {
         if (!(unsafeValue instanceof Array))
             throw new InvalidFeedback("Must be array", { value: unsafeValue });
-        const safeArray = getArray(validateItems(unsafeValue, this.items));
+        const safeArray = validateArray(unsafeValue, this.items);
         const dedupedArray = this.unique ? uniqueArray(safeArray) : safeArray;
         if (typeof this.min === "number" && dedupedArray.length < this.min)
             throw new InvalidFeedback(dedupedArray.length ? `Minimum ${this.min} items` : "Required", { value: dedupedArray });