shelving 1.130.1 → 1.131.0

package/api/Resource.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { UNDEFINED_VALIDATOR } from "../util/validate.js";
 /**
@@ -41,7 +41,7 @@ export class Resource {
         }
         catch (thrown) {
             if (thrown instanceof Feedback)
-                throw new ValueError("Invalid result for resource", thrown);
+                throw new ValidationError("Invalid result for resource", thrown);
             throw thrown;
         }
     }

package/db/ItemStore.js

@@ -1,4 +1,4 @@
-import { RequiredError } from "../error/RequiredError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { OptionalDataStore } from "../store/DataStore.js";
 import { NONE } from "../util/constants.js";
@@ -14,7 +14,7 @@ export class ItemStore extends OptionalDataStore {
     get data() {
         const item = this.value;
         if (!item)
-            throw new RequiredError(`Item must exist in "${this.collection}"`, this.id);
+            throw new NotFoundError(`Item must exist in "${this.collection}"`, this.id);
         return item;
     }
     /** Set the data of this store. */

package/db/Provider.js

@@ -1,11 +1,11 @@
-import { RequiredError } from "../error/RequiredError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
 import { countArray, getOptionalFirstItem } from "../util/array.js";
 /** Provider with a fully synchronous interface */
 export class Provider {
     requireItem(collection, id) {
         const item = this.getItem(collection, id);
         if (!item)
-            throw new RequiredError(`Item must exist in "${collection}"`, id);
+            throw new NotFoundError(`Item must exist in "${collection}"`, id);
         return item;
     }
     countQuery(collection, query) {
@@ -17,7 +17,7 @@ export class Provider {
     requireFirst(collection, query) {
         const first = this.getFirst(collection, query);
         if (!first)
-            throw new RequiredError(`First item must exist in "${collection}"`, query);
+            throw new NotFoundError(`First item must exist in "${collection}"`, query);
         return first;
     }
 }
@@ -26,7 +26,7 @@ export class AsyncProvider {
     async requireItem(collection, id) {
         const item = await this.getItem(collection, id);
         if (!item)
-            throw new RequiredError(`Item must exist in "${collection}"`, id);
+            throw new NotFoundError(`Item must exist in "${collection}"`, id);
         return item;
     }
     async countQuery(collection, query) {
@@ -38,7 +38,7 @@ export class AsyncProvider {
     async requireFirst(collection, query) {
         const first = await this.getFirst(collection, query);
         if (!first)
-            throw new RequiredError(`First item must exist in "${collection}"`, query);
+            throw new NotFoundError(`First item must exist in "${collection}"`, query);
         return first;
     }
 }

package/db/QueryStore.js

@@ -1,5 +1,5 @@
 import { collection, query } from "firebase/firestore";
-import { RequiredError } from "../error/RequiredError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
 import { ArrayStore } from "../store/ArrayStore.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { NONE } from "../util/constants.js";
@@ -21,14 +21,14 @@ export class QueryStore extends ArrayStore {
     get first() {
         const first = this.optionalFirst;
         if (!first)
-            throw new RequiredError(`First item must exist in "${collection}"`, query);
+            throw new NotFoundError(`First item must exist in "${collection}"`, query);
         return first;
     }
     /** Get the last item in this store. */
     get last() {
         const last = this.optionalLast;
         if (!last)
-            throw new RequiredError(`Last item must exist in "${collection}"`, query);
+            throw new NotFoundError(`Last item must exist in "${collection}"`, query);
         return last;
     }
     constructor(collection, query, provider, memory) {

package/db/ValidationProvider.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { updateData } from "../util/update.js";
 import { validateWithContext } from "../util/validate.js";
@@ -124,7 +124,7 @@ function _validateItem(collection, unsafeEntity, schema) {
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ValueError(`Invalid data for "${collection}"`, thrown.message);
+        throw new ValidationError(`Invalid data for "${collection}"`, thrown.message);
     }
 }
 /** Validate a set of entities for this query reference. */
@@ -146,5 +146,5 @@ function* _yieldValidItems(collection, unsafeEntities, schema) {
         }
     }
     if (invalid)
-        throw new ValueError(`Invalid data for "${collection}"`, messages);
+        throw new ValidationError(`Invalid data for "${collection}"`, messages);
 }

package/error/ConflictError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if the state of the program is not correct to execute a given operation. */
+export declare class ConflictError extends EnhancedError {
+    readonly code = 509;
+    constructor(message?: string, context?: unknown);
+}

package/error/ConflictError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if the state of the program is not correct to execute a given operation. */
+export class ConflictError extends EnhancedError {
+    code = 509;
+    constructor(message = "Conflict", context) {
+        super(message, context);
+    }
+}
+ConflictError.prototype.name = "ConflictError";

package/error/EnhancedError.d.ts

@@ -4,6 +4,7 @@
  * - Context is converted to a string using `debug()`
  */
 export declare class EnhancedError extends Error {
+    readonly code: number;
     readonly context: unknown;
     constructor(message: string, context?: unknown);
 }

package/error/EnhancedError.js

@@ -5,6 +5,7 @@ import { debug } from "../util/debug.js";
  * - Context is converted to a string using `debug()`
  */
 export class EnhancedError extends Error {
+    code = 500;
     context;
     constructor(message, context) {
         const debugged = context !== undefined ? debug(context, 2) : "";

package/error/ForbiddenError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export declare class ForbiddenError extends EnhancedError {
+    readonly code = 403;
+    constructor(message?: string, context?: unknown);
+}

package/error/ForbiddenError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export class ForbiddenError extends EnhancedError {
+    code = 403;
+    constructor(message = "Forbidden", context) {
+        super(message, context);
+    }
+}
+ForbiddenError.prototype.name = "ForbiddenError";

package/error/NotFoundError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if if a value is required but doesn't exist. */
+export declare class NotFoundError extends EnhancedError {
+    readonly code = 404;
+    constructor(message?: string, context?: unknown);
+}

package/error/NotFoundError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if if a value is required but doesn't exist. */
+export class NotFoundError extends EnhancedError {
+    code = 404;
+    constructor(message = "Not found", context) {
+        super(message, context);
+    }
+}
+NotFoundError.prototype.name = "NotFoundError";

package/error/{UnimplementedError.d.ts → NotImplementedError.d.ts}

@@ -1,5 +1,6 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when functionality is called but is not implemented by an interface. */
-export declare class UnimplementedError extends EnhancedError {
+export declare class NotImplementedError extends EnhancedError {
+    readonly code = 501;
     constructor(message?: string, value?: unknown);
 }

package/error/{UnimplementedError.js → NotImplementedError.js}

@@ -1,8 +1,9 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when functionality is called but is not implemented by an interface. */
-export class UnimplementedError extends EnhancedError {
+export class NotImplementedError extends EnhancedError {
+    code = 501;
     constructor(message = "Not implemented", value) {
         super(message, value);
     }
 }
-UnimplementedError.prototype.name = "UnimplementedError";
+NotImplementedError.prototype.name = "NotImplementedError";

package/error/UnauthorizedError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export declare class UnauthorizedError extends EnhancedError {
+    readonly code = 403;
+    constructor(message?: string, context?: unknown);
+}

package/error/UnauthorizedError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export class UnauthorizedError extends EnhancedError {
+    code = 403;
+    constructor(message = "Unauthorized", context) {
+        super(message, context);
+    }
+}
+UnauthorizedError.prototype.name = "UnauthorizedError";

package/error/{ValueError.d.ts → ValidationError.d.ts}

@@ -1,5 +1,6 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when a value isn't valid. */
-export declare class ValueError extends EnhancedError {
+export declare class ValidationError extends EnhancedError {
+    readonly code = 422;
     constructor(message?: string, context?: unknown);
 }

package/error/{ValueError.js → ValidationError.js}

@@ -1,8 +1,9 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when a value isn't valid. */
-export class ValueError extends EnhancedError {
+export class ValidationError extends EnhancedError {
+    code = 422;
     constructor(message = "Invalid value", context) {
         super(message, context);
     }
 }
-ValueError.prototype.name = "ValidationError";
+ValidationError.prototype.name = "ValidationError";

package/error/index.d.ts

@@ -1,7 +1,8 @@
 export * from "./EnhancedError.js";
-export * from "./StateError.js";
+export * from "./ConflictError.js";
 export * from "./ConnectionError.js";
-export * from "./PermissionError.js";
-export * from "./RequiredError.js";
-export * from "./UnimplementedError.js";
-export * from "./ValueError.js";
+export * from "./ForbiddenError.js";
+export * from "./UnauthorizedError.js";
+export * from "./NotFoundError.js";
+export * from "./NotImplementedError.js";
+export * from "./ValidationError.js";

package/error/index.js

@@ -1,7 +1,8 @@
 export * from "./EnhancedError.js";
-export * from "./StateError.js";
+export * from "./ConflictError.js";
 export * from "./ConnectionError.js";
-export * from "./PermissionError.js";
-export * from "./RequiredError.js";
-export * from "./UnimplementedError.js";
-export * from "./ValueError.js";
+export * from "./ForbiddenError.js";
+export * from "./UnauthorizedError.js";
+export * from "./NotFoundError.js";
+export * from "./NotImplementedError.js";
+export * from "./ValidationError.js";

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +1,6 @@
 import { addDoc, arrayRemove, arrayUnion, collection, deleteDoc, doc, documentId, getCount, getDoc, getDocs, increment, limit, orderBy, query, setDoc, updateDoc, where, } from "firebase/firestore/lite";
 import { AsyncProvider } from "../../db/Provider.js";
-import { UnimplementedError } from "../../error/UnimplementedError.js";
+import { NotImplementedError } from "../../error/NotImplementedError.js";
 import { getItem } from "../../util/item.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
@@ -76,7 +76,7 @@ export class FirestoreLiteProvider extends AsyncProvider {
         return _getOptionalItem(snapshot);
     }
     getItemSequence() {
-        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new NotImplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async addItem(c, data) {
         const reference = await addDoc(collection(this._firestore, c), data);
@@ -100,7 +100,7 @@ export class FirestoreLiteProvider extends AsyncProvider {
         return snapshot.docs.map(_getItem);
     }
     getQuerySequence() {
-        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new NotImplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(c, q, data) {
         const snapshot = await getDocs(_getQuery(this._firestore, c, q));

package/iterate/InspectIterator.js

@@ -1,4 +1,4 @@
-import { StateError } from "../error/StateError.js";
+import { ConflictError } from "../error/ConflictError.js";
 import { ThroughIterator } from "./ThroughIterator.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectIterator extends ThroughIterator {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new StateError("Iteration not started");
+            throw new ConflictError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new StateError("Iteration not started");
+            throw new ConflictError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new StateError("Iteration not done");
+            throw new ConflictError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/package.json

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

package/react/createCacheContext.js

@@ -1,5 +1,5 @@
 import { createContext, createElement, useContext, useRef } from "react";
-import { StateError } from "../error/StateError.js";
+import { ConflictError } from "../error/ConflictError.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.
@@ -10,7 +10,7 @@ export function createCacheContext() {
         useCache() {
             const cache = useContext(context);
             if (!cache)
-                throw new StateError("useCache() must be used inside <Cache>");
+                throw new ConflictError("useCache() must be used inside <Cache>");
             return cache;
         },
         CacheContext({ children }) {

package/sequence/InspectSequence.js

@@ -1,4 +1,4 @@
-import { StateError } from "../error/StateError.js";
+import { ConflictError } from "../error/ConflictError.js";
 import { ThroughSequence } from "./ThroughSequence.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectSequence.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectSequence extends ThroughSequence {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new StateError("Iteration not started");
+            throw new ConflictError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new StateError("Iteration not started");
+            throw new ConflictError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new StateError("Iteration not done");
+            throw new ConflictError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/util/array.js

@@ -1,5 +1,5 @@
-import { RequiredError } from "../error/RequiredError.js";
-import { ValueError } from "../error/ValueError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { omitItems, pickItems } from "./iterate.js";
 import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
@@ -9,7 +9,7 @@ export function isArray(value) {
 /** Assert that an unknown value is an array. */
 export function assertArray(arr) {
     if (!isArray(arr))
-        throw new ValueError("Must be array", arr);
+        throw new ValidationError("Must be array", arr);
 }
 /** Is an unknown value an item in a specified array? */
 export function isArrayItem(arr, item) {
@@ -18,7 +18,7 @@ export function isArrayItem(arr, item) {
 /** Assert that an unknown value is an item in a specified array. */
 export function assertArrayItem(arr, item) {
     if (!isArrayItem(arr, item))
-        throw new ValueError("Must be array item", item);
+        throw new ValidationError("Must be array item", item);
 }
 /** Convert an iterable to an array (if its not already an array). */
 export function getArray(items) {
@@ -57,7 +57,7 @@ export function getOptionalFirstItem(items) {
 export function getFirstItem(items) {
     const item = getOptionalFirstItem(items);
     if (item === undefined)
-        throw new RequiredError("First item is required");
+        throw new NotFoundError("First item is required");
     return item;
 }
 /** Get the last item from an array or iterable, or `undefined` if it didn't exist. */
@@ -71,7 +71,7 @@ export function getOptionalLastItem(items) {
 export function getLastItem(items) {
     const item = getOptionalLastItem(items);
     if (item === undefined)
-        throw new RequiredError("Last item is required");
+        throw new NotFoundError("Last item is required");
     return item;
 }
 /** Get the next item in an array or iterable. */
@@ -144,7 +144,7 @@ export function isArrayLength(arr, min = 1, max = Number.POSITIVE_INFINITY) {
 }
 export function assertArrayLength(arr, min = 1, max = Number.POSITIVE_INFINITY) {
     if (!isArray(arr) || !isArrayLength(arr, min, max))
-        throw new ValueError(`Must be array with length ${formatRange(min, max)}`, arr);
+        throw new ValidationError(`Must be array with length ${formatRange(min, max)}`, arr);
 }
 export function getArrayLength(arr, min = 1, max = Number.POSITIVE_INFINITY) {
     assertArrayLength(arr, min, max);

package/util/assert.js

@@ -1,11 +1,11 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 /** Assert two values are equal. */
 export function assertEqual(left, right) {
     if (left !== right)
-        throw new ValueError("Must be equal", { left, right });
+        throw new ValidationError("Must be equal", { left, right });
 }
 /** Assert two values are equal. */
 export function assertNot(left, right) {
     if (left === right)
-        throw new ValueError("Must not be equal", { left, right });
+        throw new ValidationError("Must not be equal", { left, right });
 }

package/util/async.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export function isAsync(value) {
     return typeof value === "object" && value !== null && typeof value.then === "function";
@@ -20,17 +20,17 @@ export function throwAsync(value) {
 /** Assert a synchronous value. */
 export function assertNotAsync(value) {
     if (isAsync(value))
-        throw new ValueError("Must be synchronous", value);
+        throw new ValidationError("Must be synchronous", value);
 }
 /** Assert an asynchronous value. */
 export function assertAsync(value) {
     if (!isAsync(value))
-        throw new ValueError("Must be asynchronous", value);
+        throw new ValidationError("Must be asynchronous", value);
 }
 /** Assert a promise. */
 export function assertPromise(value) {
     if (!(value instanceof Promise))
-        throw new ValueError("Must be promise", value);
+        throw new ValidationError("Must be promise", value);
 }
 /** Run any queued microtasks now. */
 export function runMicrotasks() {

package/util/boolean.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 /** Is a value a boolean? */
 export function isBoolean(value) {
     return typeof value === "boolean";
@@ -22,25 +22,25 @@ export function isFalsey(value) {
 /** Assert that a value is a boolean. */
 export function assertBoolean(value) {
     if (typeof value !== "boolean")
-        throw new ValueError("Must be boolean", value);
+        throw new ValidationError("Must be boolean", value);
 }
 /** Assert that a value is true. */
 export function assertTrue(value) {
     if (value !== true)
-        throw new ValueError("Must be true", value);
+        throw new ValidationError("Must be true", value);
 }
 /** Assert that a value is false. */
 export function assertFalse(value) {
     if (value !== false)
-        throw new ValueError("Must be false", value);
+        throw new ValidationError("Must be false", value);
 }
 /** Assert that a value is truthy. */
 export function assertTruthy(value) {
     if (!value)
-        throw new ValueError("Must be truthy", value);
+        throw new ValidationError("Must be truthy", value);
 }
 /** Assert that a value is falsy. */
 export function assertFalsy(value) {
     if (value)
-        throw new ValueError("Must be falsy", value);
+        throw new ValidationError("Must be falsy", value);
 }

package/util/class.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { debug } from "./debug.js";
 /** Is a given value a class constructor? */
 export function isConstructor(value) {
@@ -11,5 +11,5 @@ export function isInstance(value, type) {
 /** Assert that a value is an instance of something. */
 export function assertInstance(value, type) {
     if (!(value instanceof type))
-        throw new ValueError(`Must be instance of ${debug(type)}`, value);
+        throw new ValidationError(`Must be instance of ${debug(type)}`, value);
 }

package/util/color.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { boundNumber, roundNumber } from "./number.js";
 // Constants.
 const DARK = 140; // Anything with a luminance > 140 is considered light.
@@ -71,7 +71,7 @@ export function isColor(value) {
 /** Assert that an unknown value is a `Color` instance. */
 export function assertColor(value) {
     if (!isColor(value))
-        throw new ValueError("Must be color", value);
+        throw new ValidationError("Must be color", value);
 }
 /** Convert a possible color to a `Color` instance or `undefined` */
 export function getOptionalColor(possible) {
@@ -81,6 +81,6 @@ export function getOptionalColor(possible) {
 export function getColor(possible) {
     const color = getOptionalColor(possible);
     if (!color)
-        throw new ValueError("Invalid color", possible);
+        throw new ValidationError("Invalid color", possible);
     return color;
 }

package/util/data.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { isIterable } from "./iterate.js";
 import { isObject, isPlainObject } from "./object.js";
 /** Is an unknown value a data object? */
@@ -8,14 +8,14 @@ export function isData(value) {
 /** Assert that an unknown value is a data object. */
 export function assertData(value) {
     if (!isPlainObject(value))
-        throw new ValueError("Must be data", value);
+        throw new ValidationError("Must be data", value);
 }
 /** Is an unknown value the key for an own prop of a data object. */
 export const isDataProp = (data, key) => typeof key === "string" && Object.hasOwn(data, key);
 /** Assert that an unknown value is the key for an own prop of a data object. */
 export function assertDataProp(data, key) {
     if (!isDataProp(data, key))
-        throw new ValueError("Must be data prop", key);
+        throw new ValidationError("Must be data prop", key);
 }
 export function getData(input) {
     return isIterable(input) ? Object.fromEntries(input) : input;

package/util/date.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 /** Is a value a date? */
 export function isDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
@@ -6,7 +6,7 @@ export function isDate(value) {
 /** Assert that a value is a `Date` instance. */
 export function assertDate(value) {
     if (!isDate(value))
-        throw new ValueError("Must be date", value);
+        throw new ValidationError("Must be date", value);
 }
 /**
  * Convert an unknown value to a valid `Date` instance, or return `undefined` if it couldn't be converted.
@@ -52,7 +52,7 @@ export function getOptionalDate(possible) {
 export function getDate(possible = "now") {
     const date = getOptionalDate(possible);
     if (!date)
-        throw new ValueError("Invalid date", possible);
+        throw new ValidationError("Invalid date", possible);
     return date;
 }
 /** Convert an unknown value to a timestamp (milliseconds past Unix epoch), or `undefined` if it couldn't be converted. */