shelving 1.142.0 → 1.143.1

package/error/BaseError.d.ts

@@ -1,7 +1,4 @@
-import type { AnyConstructor } from "../util/class.js";
-import type { AnyFunction } from "../util/function.js";
-/** Any calling function or constructor that can appear in a stack tracer. */
-export type AnyCaller = AnyFunction | AnyConstructor;
+import type { AnyCaller } from "../util/function.js";
 /** Options for `BaseError` that provide additional helpful error functionality. */
 export interface BaseErrorOptions extends ErrorOptions {
     /**
@@ -15,7 +12,7 @@ export interface BaseErrorOptions extends ErrorOptions {
 }
 /** An error that provides additional helpful functionality. */
 export declare abstract class BaseError extends Error {
-    /** Provide additional named contextual data that should be attached to the `Error` instance. */
-    [key: string]: unknown;
+    /** Provide additional named contextual data that is relevant to the `Error` instance. */
+    readonly [key: string]: unknown;
     constructor(message?: string, options?: BaseErrorOptions);
 }

package/error/BaseError.js

@@ -1,18 +1,11 @@
 /** An error that provides additional helpful functionality. */
 export class BaseError extends Error {
-    constructor(message, options) {
-        if (options) {
-            super(message, options);
-            const { cause, caller = BaseError, ...rest } = options;
-            for (const [key, value] of Object.entries(rest))
-                this[key] = value;
-            Error.captureStackTrace(this, caller);
-        }
-        else {
-            super(message);
-            Error.captureStackTrace(this, BaseError);
-        }
+    constructor(message, options = {}) {
+        super(message, options);
+        const { cause, caller = BaseError, ...rest } = options;
+        for (const [key, value] of Object.entries(rest))
+            this[key] = value;
+        Error.captureStackTrace(this, caller);
     }
 }
 BaseError.prototype.name = "BaseError";
-BaseError.prototype.message = "Unknown error";

package/error/NetworkError.js

@@ -6,4 +6,3 @@ export class NetworkError extends BaseError {
     }
 }
 NetworkError.prototype.name = "NetworkError";
-NetworkError.prototype.message = "Network error";

package/error/RequestError.d.ts

@@ -1,32 +1,27 @@
 import { BaseError, type BaseErrorOptions } from "./BaseError.js";
-/** Options for a `RequestError` */
-interface RequestErrorOptions extends BaseErrorOptions {
-    code?: number;
-}
 /** Error thrown when a request isn't well-formed. */
 export declare class RequestError extends BaseError {
     /** The corresponding HTTP status code for this error, in the range `400-499` */
-    code: number;
-    constructor(message?: string, options?: RequestErrorOptions);
+    readonly code: number;
+    constructor(message?: string, options?: BaseErrorOptions);
 }
 /** Thrown if an operation failed because the user is not logged in, or the login information is not well-formed. */
 export declare class UnauthorizedError extends RequestError {
     readonly code: number;
-    constructor(message?: string, options?: RequestErrorOptions);
+    constructor(message?: string, options?: BaseErrorOptions);
 }
 /** Thrown if the requested content is not found. */
 export declare class NotFoundError extends RequestError {
-    readonly code = 404;
-    constructor(message?: string, options?: RequestErrorOptions);
+    readonly code: number;
+    constructor(message?: string, options?: BaseErrorOptions);
 }
 /** Error thrown when a request is is valid and well-formed, but its actual data is not. */
 export declare class UnprocessableError extends RequestError {
     readonly code: number;
-    constructor(message?: string, options?: RequestErrorOptions);
+    constructor(message?: string, options?: BaseErrorOptions);
 }
 /** Thrown if an operation failed because the user is logged in, but does not have sufficient privileges to access this content. */
 export declare class ForbiddenError extends RequestError {
     readonly code: number;
-    constructor(message?: string, options?: RequestErrorOptions);
+    constructor(message?: string, options?: BaseErrorOptions);
 }
-export {};

package/error/RequestError.js

@@ -2,49 +2,41 @@ import { BaseError } from "./BaseError.js";
 /** Error thrown when a request isn't well-formed. */
 export class RequestError extends BaseError {
     /** The corresponding HTTP status code for this error, in the range `400-499` */
-    code;
-    constructor(message = RequestError.prototype.message, options) {
+    code = 400;
+    constructor(message, options) {
         super(message, { caller: RequestError, ...options });
-        this.code = options?.code || 400;
     }
 }
 RequestError.prototype.name = "RequestError";
-RequestError.prototype.message = "Invalid request";
 /** Thrown if an operation failed because the user is not logged in, or the login information is not well-formed. */
 export class UnauthorizedError extends RequestError {
     code = 401;
-    constructor(message = UnauthorizedError.prototype.message, options) {
-        super(message, { caller: UnauthorizedError, code: 401, ...options });
+    constructor(message, options) {
+        super(message, { caller: UnauthorizedError, ...options });
     }
 }
 UnauthorizedError.prototype.name = "UnauthorizedError";
-UnauthorizedError.prototype.message = "Authorization is required";
 /** Thrown if the requested content is not found. */
 export class NotFoundError extends RequestError {
     code = 404;
-    constructor(message = NotFoundError.prototype.message, options) {
-        super(message, { caller: NotFoundError, code: 404, ...options });
-        Error.captureStackTrace(this, NotFoundError);
+    constructor(message, options) {
+        super(message, { caller: NotFoundError, ...options });
     }
 }
 NotFoundError.prototype.name = "NotFoundError";
-NotFoundError.prototype.message = "Cannot find requested content";
 /** Error thrown when a request is is valid and well-formed, but its actual data is not. */
 export class UnprocessableError extends RequestError {
     code = 422;
-    constructor(message = UnprocessableError.prototype.message, options) {
-        super(message, { caller: UnprocessableError, code: 422, ...options });
-        Error.captureStackTrace(this, UnprocessableError);
+    constructor(message, options) {
+        super(message, { caller: UnprocessableError, ...options });
     }
 }
 UnprocessableError.prototype.name = "UnprocessableError";
-UnprocessableError.prototype.message = "Input data is invalid";
 /** Thrown if an operation failed because the user is logged in, but does not have sufficient privileges to access this content. */
 export class ForbiddenError extends RequestError {
     code = 403;
-    constructor(message = ForbiddenError.prototype.message, options) {
-        super(message, { caller: ForbiddenError, code: 403, ...options });
+    constructor(message, options) {
+        super(message, { caller: ForbiddenError, ...options });
     }
 }
 ForbiddenError.prototype.name = "ForbiddenError";
-ForbiddenError.prototype.message = "Insufficient privileges to access this content";

package/error/RequiredError.js

@@ -9,4 +9,3 @@ export class RequiredError extends BaseError {
     }
 }
 RequiredError.prototype.name = "RequiredError";
-RequiredError.prototype.message = "Value is required";

package/error/ResponseError.js

@@ -6,4 +6,3 @@ export class ResponseError extends BaseError {
     }
 }
 ResponseError.prototype.name = "ResponseError";
-ResponseError.prototype.message = "Invalid response";

package/error/UnexpectedError.js

@@ -6,4 +6,3 @@ export class UnexpectedError extends BaseError {
     }
 }
 UnexpectedError.prototype.name = "UnexpectedError";
-UnexpectedError.prototype.message = "Unexpected error";

package/error/UnimplementedError.js

@@ -6,4 +6,3 @@ export class UnimplementedError extends BaseError {
     }
 }
 UnimplementedError.prototype.name = "UnimplementedError";
-UnimplementedError.prototype.message = "Not implemented";

package/error/ValueError.js

@@ -6,4 +6,3 @@ export class ValueError extends BaseError {
     }
 }
 ValueError.prototype.name = "ValueError";
-ValueError.prototype.message = "Invalid value";

package/markup/util/internal.js

@@ -1,2 +1,2 @@
 /** React security symbol — see https://github.com/facebook/react/pull/4832 */
-export const REACT_ELEMENT_TYPE = Symbol.for("react.element");
+export const REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.142.0",
+	"version": "1.143.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -57,19 +57,19 @@
 		"build:test:unit": "bun test ./dist/**/*.test.js --bail"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^1.8.3",
-		"@google-cloud/firestore": "^7.9.0",
-		"@types/bun": "^1.1.6",
-		"@types/react": "^18.3.3",
-		"@types/react-dom": "^18.3.0",
-		"firebase": "^10.12.5",
-		"react": "^18.3.1",
-		"react-dom": "^18.3.1",
-		"typescript": "^5.8.2"
+		"@biomejs/biome": "^1.9.4",
+		"@google-cloud/firestore": "^7.11.3",
+		"@types/bun": "^1.2.18",
+		"@types/react": "^19.1.8",
+		"@types/react-dom": "^19.1.6",
+		"firebase": "^11.10.0",
+		"react": "^19.1.0",
+		"react-dom": "^19.1.0",
+		"typescript": "^5.8.3"
 	},
 	"peerDependencies": {
-		"@google-cloud/firestore": ">=4.0.0",
-		"firebase": ">=9.0.0",
-		"react": ">=17.0.0"
+		"@google-cloud/firestore": ">=7.0.0",
+		"firebase": ">=11.0.0",
+		"react": ">=19.0.0"
 	}
 }

package/react/createCacheContext.js

@@ -1,21 +1,22 @@
-import { createContext, createElement, useContext, useRef } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
 import { UnexpectedError } from "../error/UnexpectedError.js";
+import { useMap } from "./useMap.js";
 /**
  * Create a cache context that can be provided to React elements and allows them to call `useCache()`
  * - Cache is a `Map` indexed by strings that can be used to store any value.
  */
 export function createCacheContext() {
-    const context = createContext(undefined);
+    const Context = createContext(undefined);
     const useCache = () => {
-        const cache = useContext(context);
+        const cache = useContext(Context);
         if (!cache)
-            throw new UnexpectedError("useCache() must be used inside <Cache>", { caller: useCache });
+            throw new UnexpectedError("useCache() must be used inside <CacheContext>", { caller: useCache });
         return cache;
     };
     const CacheContext = ({ children }) => {
-        // biome-ignore lint/suspicious/noAssignInExpressions: This is the most efficient way to do this.
-        const cache = (useRef().current ||= new Map());
-        return createElement(context.Provider, { children, value: cache });
+        const cache = useMap();
+        return _jsx(Context, { value: cache, children: children });
     };
     return { useCache, CacheContext };
 }

package/react/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./createCacheContext.js";
 export * from "./createDataContext.js";
-export * from "./useInstance.js";
+export * from "./useProps.js";
+export * from "./useMap.js";
 export * from "./useLazy.js";
 export * from "./useReduce.js";
 export * from "./useSequence.js";

package/react/index.js

@@ -1,6 +1,7 @@
 export * from "./createCacheContext.js";
 export * from "./createDataContext.js";
-export * from "./useInstance.js";
+export * from "./useProps.js";
+export * from "./useMap.js";
 export * from "./useLazy.js";
 export * from "./useReduce.js";
 export * from "./useSequence.js";

package/react/useInstance.js

@@ -1,17 +1,16 @@
 import { isArrayEqual } from "../util/equal.js";
-import { useInternals } from "./useInternals.js";
+import { useProps } from "./useProps.js";
 /**
  * Use a memoised class instance.
  * - Creates a new instance of `Constructor` using `args`
  * - Returns same instance for as long as `args` is equal to previous `args`.
  */
 export function useInstance(Constructor, ...args) {
-    const internals = useInternals();
+    const internals = useProps();
     // Update `internals` if `args` changes or `instance` is not set.
-    if (!internals.args || !isArrayEqual(args, internals.args)) {
+    if (!internals.args || !internals.instance || !isArrayEqual(args, internals.args)) {
         internals.instance = new Constructor(...args);
         internals.args = args;
     }
-    // biome-ignore lint/style/noNonNullAssertion: We know this is set.
     return internals.instance;
 }

package/react/useLazy.js

@@ -1,13 +1,12 @@
 import { isArrayEqual } from "../util/equal.js";
 import { getLazy } from "../util/lazy.js";
-import { useInternals } from "./useInternals.js";
+import { useProps } from "./useProps.js";
 export function useLazy(value, ...args) {
-    const internals = useInternals();
+    const internals = useProps();
     // Update `internals` if `args` changes.
-    if (internals.args === undefined || !isArrayEqual(args, internals.args)) {
+    if (!internals.args || !isArrayEqual(args, internals.args)) {
         internals.value = getLazy(value, ...args);
         internals.args = args;
     }
-    // biome-ignore lint/style/noNonNullAssertion: We know this is set.
     return internals.value;
 }

package/react/useMap.d.ts

@@ -0,0 +1,2 @@
+/** Create a mutable Map that persist for the lifetime of the component. */
+export declare function useMap<K, V>(): Map<K, V>;

package/react/useMap.js

@@ -0,0 +1,8 @@
+import { useRef } from "react";
+/** Create a mutable Map that persist for the lifetime of the component. */
+export function useMap() {
+    const ref = useRef(undefined);
+    if (!ref.current)
+        ref.current = new Map();
+    return ref.current;
+}

package/react/useProps.d.ts

@@ -0,0 +1,6 @@
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+/** Create an object that persist for the lifetime of the component. */
+export declare function useProps<T>(): Partial<Mutable<T>>;
+export {};

package/react/useProps.js

@@ -0,0 +1,5 @@
+import { useRef } from "react";
+/** Create an object that persist for the lifetime of the component. */
+export function useProps() {
+    return useRef(undefined);
+}

package/react/useStore.js

@@ -2,17 +2,16 @@ import { useSyncExternalStore } from "react";
 import { NONE } from "../util/constants.js";
 import { BLACKHOLE } from "../util/function.js";
 import { runSequence } from "../util/sequence.js";
-import { useInternals } from "./useInternals.js";
+import { useProps } from "./useProps.js";
 export function useStore(store) {
     // Store memoized versions of `subscribe()` and `getSnapshot()` so `useSyncExternalStore()` doesn't re-subscribe on every render.
-    const internals = useInternals();
+    const internals = useProps();
     // Update `internals` if `store` changes.
-    if (store !== internals.store) {
+    if (store !== internals.store || !internals.subscribe || !internals.getSnapshot) {
         internals.subscribe = onStoreChange => (store ? runSequence(store, onStoreChange, onStoreChange) : BLACKHOLE);
         internals.getSnapshot = () => (!store ? undefined : store.loading ? NONE : store.value);
         internals.store = store;
     }
-    // biome-ignore lint/style/noNonNullAssertion: We know these are set.
     useSyncExternalStore(internals.subscribe, internals.getSnapshot);
     return store;
 }

package/util/array.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /**
  * Mutable array: an array that can be changed.
  * - Consistency with `MutableObject<T>` and `ImmutableArray<T>`

package/util/async.d.ts

@@ -1,6 +1,5 @@
 import type { ImmutableArray } from "./array.js";
-import type { ValueCallback } from "./callback.js";
-import type { Report } from "./error.js";
+import type { ErrorCallback, ValueCallback } from "./callback.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export declare function isAsync<T>(value: PromiseLike<T> | T): value is PromiseLike<T>;
 /** Is a value a synchronous value. */
@@ -39,14 +38,14 @@ export declare abstract class AbstractPromise<T> extends Promise<T> {
     /** Resolve this promise with a value. */
     protected readonly _resolve: ValueCallback<T>;
     /** Reject this promise with a reason. */
-    protected readonly _reject: Report;
+    protected readonly _reject: ErrorCallback;
     constructor();
 }
 /** Deferred allows you to access the internal resolve/reject callbacks of a `Promise` */
 export type Deferred<T> = {
     promise: Promise<T>;
     resolve: ValueCallback<T>;
-    reject: Report;
+    reject: ErrorCallback;
 };
 /**
  * Get a deferred to access the `resolve()` and `reject()` functions of a promise.

package/util/boolean.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Is a value a boolean? */
 export declare function isBoolean(value: unknown): value is boolean;
 /** Is a value true? */

package/util/bytes.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Types that can be converted to a `Uint8Array` byte sequence. */
 export type PossibleBytes = Uint8Array | ArrayBuffer | string;
 /** Assert that an unknown value is a `Uint8Array` byte sequence. */

package/util/callback.d.ts

@@ -11,6 +11,8 @@ export type AsyncValueCallback<T = void> = (value: T) => void | PromiseLike<void
 export type ValuesCallback<T extends Arguments = []> = (...values: T) => void;
 /** Callback function that receives multiple values and possibly returns a promise that must be handled. */
 export type AsyncValuesCallback<T extends Arguments = []> = (...values: T) => void | PromiseLike<void>;
+/** Callback function that receives an error. */
+export type ErrorCallback = (reason: unknown) => void;
 /** Safely call a callback function (possibly with a value). */
 export declare function call<A extends Arguments = []>(callback: (...v: A) => unknown, ...values: A): void;
 /** Return a callback function that safely calls a callback function (possibly with a value). */

package/util/color.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 export declare const HEX3_REGEXP: RegExp;
 export declare const HEX6_REGEXP: RegExp;
 /** Things that can be converted to a `Color` instance. */

package/util/data.d.ts

@@ -1,6 +1,6 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import type { ImmutableArray } from "./array.js";
 import type { EntryObject } from "./entry.js";
+import type { AnyCaller } from "./function.js";
 import type { DeepPartial } from "./object.js";
 /** Data object. */
 export type Data = {

package/util/date.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Values that can be converted to dates. */
 export type PossibleDate = "now" | "today" | "tomorrow" | "yesterday" | Date | number | string;
 /**

package/util/dictionary.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Readonly dictionary object. */
 export type ImmutableDictionary<T = unknown> = {
     readonly [K in string]: T;

package/util/entity.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 import type { Optional } from "./optional.js";
 /** Entity strings combine a type and ID, e.g. `challenge:a1b2c3` */
 export type Entity<T extends string = string> = `${T}:${string}`;

package/util/equal.d.ts

@@ -1,6 +1,6 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import type { ImmutableArray } from "./array.js";
 import type { Match } from "./filter.js";
+import type { AnyCaller } from "./function.js";
 import type { ImmutableMap } from "./map.js";
 import type { ImmutableObject } from "./object.js";
 /** Assert two values are equal. */

package/util/error.d.ts

@@ -1,5 +1,3 @@
-/** Callback function that reports an error. */
-export type Report = (reason: unknown) => void;
 /** Log an error to the console. */
 export declare function logError(reason: unknown): void;
 /** Is an unknown value an `Error` instance? */

package/util/error.js

@@ -4,5 +4,5 @@ export function logError(reason) {
 }
 /** Is an unknown value an `Error` instance? */
 export function isError(v) {
-    return v instanceof Error;
+    return typeof Error.isError === "function" ? Error.isError(v) : v instanceof Error;
 }

package/util/file.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** List of file types in `extension: mime` format. */
 export type FileTypes = {
     [extension: string]: string;

package/util/function.d.ts

@@ -1,7 +1,10 @@
+import type { AnyConstructor } from "./class.js";
 /** Unknown function. */
 export type UnknownFunction = (...args: unknown[]) => unknown;
 /** Any function (purposefully as wide as possible for use with `extends X` or `is X` statements). */
 export type AnyFunction = (...args: any) => any;
+/** Any calling function or constructor, usually referring to something that can call in the current scope that can appear in a stack trace. */
+export type AnyCaller = AnyFunction | AnyConstructor;
 /** Is a value a function? */
 export declare function isFunction(value: unknown): value is AnyFunction;
 /** Assert that a value is a function. */

package/util/http.d.ts

@@ -1,6 +1,6 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import { RequestError } from "../error/RequestError.js";
 import { ResponseError } from "../error/ResponseError.js";
+import type { AnyCaller } from "./function.js";
 /** A handler function takes a `Request` and returns a `Response` (possibly asynchronously). */
 export type RequestHandler = (request: Request) => Response | Promise<Response>;
 export declare function _getMessageJSON(message: Request | Response, MessageError: typeof RequestError | typeof ResponseError, caller: AnyCaller): Promise<unknown>;

package/util/jwt.d.ts

@@ -1,6 +1,6 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import { type PossibleBytes } from "./bytes.js";
 import type { Data } from "./data.js";
+import type { AnyCaller } from "./function.js";
 /**
  * Encode a JWT and return the string token.
  * - Currently only supports HMAC SHA-512 signing.

package/util/link.d.ts

@@ -1,5 +1,5 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import type { ImmutableArray } from "./array.js";
+import type { AnyCaller } from "./function.js";
 import type { Optional } from "./optional.js";
 import type { Path } from "./path.js";
 import { type PossibleURL } from "./url.js";

package/util/map.d.ts

@@ -1,5 +1,5 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import type { Entry } from "./entry.js";
+import type { AnyCaller } from "./function.js";
 /** `Map` that cannot be changed. */
 export type ImmutableMap<K = unknown, T = unknown> = ReadonlyMap<K, T>;
 /** Class for a `Map` that cannot be changed (so you can extend `Map` while implementing `ImmutableMap`). */

package/util/null.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Function that always returns null. */
 export declare function getNull(): null;
 /** Nullable is the value or `null` */

package/util/number.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Values that can be converted to a number. */
 export type PossibleNumber = number | string | Date;
 /** Is a value a finite number? */

package/util/optional.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Optional is the value or `null` or `undefined` (synonym for `Nullish`). */
 export type Optional<T> = T | null | undefined;
 /** Get a required value. */

package/util/path.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 import { type Optional } from "./optional.js";
 /** Absolute path string starts with `/` slash. */
 export type AbsolutePath = `/` | `/${string}`;

package/util/sequence.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncValueCallback, ValueCallback } from "./callback.js";
+import type { ErrorCallback } from "./callback.js";
 import { STOP } from "./constants.js";
-import type { Report } from "./error.js";
 import type { Stop } from "./start.js";
 /**
  * Is a value an async iterable object?
@@ -15,4 +15,4 @@ export declare function repeatDelay(ms: number): AsyncIterable<number>;
 /** Dispatch items in a sequence to a (possibly async) callback. */
 export declare function callSequence<T>(sequence: AsyncIterable<T>, callback: AsyncValueCallback<T>): AsyncIterable<T>;
 /** Pull values from a sequence until the returned function is called. */
-export declare function runSequence<T>(sequence: AsyncIterable<T>, onNext?: ValueCallback<T>, onError?: Report): Stop;
+export declare function runSequence<T>(sequence: AsyncIterable<T>, onNext?: ValueCallback<T>, onError?: ErrorCallback): Stop;

package/util/set.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** `Set` that cannot be changed. */
 export type ImmutableSet<T = unknown> = ReadonlySet<T>;
 /** `Set` that can be changed. */

package/util/source.d.ts

@@ -1,4 +1,5 @@
 import type { Class } from "./class.js";
+import type { AnyCaller } from "./function.js";
 /** Something that has a source of a specified type. */
 export interface Sourceable<T> {
     readonly source: T;
@@ -6,4 +7,4 @@ export interface Sourceable<T> {
 /** Recurse through `Sourceable` objects and return the first one that is an instance of `type`, or `undefined` if no source object matches. */
 export declare function getSource<T>(type: Class<T>, value: unknown): T | undefined;
 /** Recurse through `Sourceable` objects and return the first one that is an instance of `type`, or throw `RequiredError` if no source object matches. */
-export declare function requireSource<T>(type: Class<T>, data: unknown): T;
+export declare function requireSource<T>(type: Class<T>, data: unknown, caller?: AnyCaller): T;

package/util/source.js

@@ -10,9 +10,9 @@ export function getSource(type, value) {
     }
 }
 /** Recurse through `Sourceable` objects and return the first one that is an instance of `type`, or throw `RequiredError` if no source object matches. */
-export function requireSource(type, data) {
+export function requireSource(type, data, caller = requireSource) {
     const source = getSource(type, data);
     if (!source)
-        throw new RequiredError(`Source "${type.name}" not found`, { received: data, expected: type, caller: requireSource });
+        throw new RequiredError(`Source "${type.name}" not found`, { received: data, expected: type, caller });
     return source;
 }

package/util/string.d.ts

@@ -1,5 +1,5 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import type { ImmutableArray } from "./array.js";
+import type { AnyCaller } from "./function.js";
 /**
  * Type that never matches the `string` type.
  * - `string` itself is iterable (iterating over its individual characters) and implements `Iterable<string>`

package/util/template.d.ts

@@ -1,6 +1,6 @@
-import type { AnyCaller } from "../error/BaseError.js";
 import type { ImmutableArray } from "./array.js";
 import { type ImmutableDictionary } from "./dictionary.js";
+import type { AnyCaller } from "./function.js";
 import type { NotString } from "./string.js";
 /** Dictionary of named template values in `{ myPlaceholder: "value" }` format. */
 export type TemplateDictionary = ImmutableDictionary<string>;

package/util/time.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Class representing a time in the day in 24 hour format in the user's current locale. */
 export declare class Time {
     /** Make a new `Time` instance from a time string. */

package/util/undefined.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 /** Function that always returns undefined. */
 export declare function getUndefined(): undefined;
 /** Is a value undefined? */

package/util/url.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCaller } from "../error/BaseError.js";
+import type { AnyCaller } from "./function.js";
 import { type Optional } from "./optional.js";
 /** Values that can be converted to a URL instance. */
 export type PossibleURL = string | URL;

package/util/validate.d.ts

@@ -1,8 +1,9 @@
-import type { AnyCaller, BaseError, BaseErrorOptions } from "../error/BaseError.js";
+import type { BaseError, BaseErrorOptions } from "../error/BaseError.js";
 import type { ImmutableArray, PossibleArray } from "./array.js";
 import type { Constructor } from "./class.js";
 import type { Data } from "./data.js";
 import type { ImmutableDictionary } from "./dictionary.js";
+import type { AnyCaller } from "./function.js";
 import type { DeepPartial } from "./object.js";
 /** Object that can validate an unknown value with its `validate()` method. */
 export interface Validator<T> {

package/react/useInternals.d.ts

@@ -1,5 +0,0 @@
-import type { Data } from "../util/data.js";
-/** Store internal implementation details for a hook that persist for the lifetime of the component. */
-export declare const useInternals: <T extends Data>() => T | {
-    [K in keyof T]: undefined;
-};

package/react/useInternals.js

@@ -1,3 +0,0 @@
-import { useRef } from "react";
-/** Store internal implementation details for a hook that persist for the lifetime of the component. */
-export const useInternals = useRef;