shelving 1.143.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/package.json

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

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,5 +1,5 @@
-import type { AnyCaller } from "../error/BaseError.js";
 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;

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> {