shelving 1.170.2 → 1.172.0

package/db/ValidationProvider.js

@@ -1,5 +1,4 @@
 import { ValueError } from "../error/ValueError.js";
-import { Feedback } from "../feedback/Feedback.js";
 import { PARTIAL } from "../schema/DataSchema.js";
 import { getNamedMessage } from "../util/error.js";
 import { validateData } from "../util/validate.js";
@@ -119,9 +118,9 @@ function _validateItem(collection, item, identifier, schema, caller) {
         return validateData(item, { id: identifier, ...schema.props });
     }
     catch (thrown) {
-        if (!(thrown instanceof Feedback))
+        if (typeof thrown !== "string")
             throw thrown;
-        throw new ValueError(`Invalid data for "${collection}"\n${thrown.message}`, { item, caller });
+        throw new ValueError(`Invalid data for "${collection}"\n${thrown}`, { item, caller });
     }
 }
 /**
@@ -138,9 +137,9 @@ function* _yieldValidItems(collection, items, validators, caller) {
             yield validateData(item, validators);
         }
         catch (thrown) {
-            if (!(thrown instanceof Feedback))
+            if (typeof thrown !== "string")
                 throw thrown;
-            messages.push(getNamedMessage(item.id, thrown.message));
+            messages.push(getNamedMessage(item.id, thrown));
         }
     }
     if (messages.length)
@@ -151,8 +150,8 @@ function _validateUpdates(collection, updates, schema, caller) {
         return validateData(updates, PARTIAL(schema).props);
     }
     catch (thrown) {
-        if (!(thrown instanceof Feedback))
+        if (typeof thrown !== "string")
             throw thrown;
-        throw new ValueError(`Invalid updates for "${collection}"\n${thrown.message}`, { updates, caller });
+        throw new ValueError(`Invalid updates for "${collection}"\n${thrown}`, { updates, caller });
     }
 }

package/endpoint/Endpoint.d.ts

@@ -34,7 +34,7 @@ export declare class Endpoint<P, R> {
      * @param unsafePayload The payload to pass into the callback (will be validated against this endpoint's payload schema).
      * @param request The entire HTTP request that is being handled (payload was possibly extracted from this somehow).
      *
-     * @throws `Feedback` if the payload is invalid.
+     * @throws `string` if the payload is invalid.
      * @throws `ValueError` if `callback()` returns an invalid result.
      */
     handle(callback: EndpointCallback<P, R>, unsafePayload: unknown, request: Request, caller?: AnyCaller): Promise<Response>;
@@ -48,7 +48,7 @@ export declare class Endpoint<P, R> {
      * - Validates a payload against this endpoints payload schema
      * - Return an HTTP `Request` that will send it the valid payload to this endpoint.
      *
-     * @throws `Feedback` if the payload is invalid.
+     * @throws `string` if the payload is invalid.
      */
     request(payload: P, options?: RequestOptions, caller?: AnyCaller): Request;
     /**
@@ -63,7 +63,7 @@ export declare class Endpoint<P, R> {
      * - Validate the `payload` against this endpoint's payload schema.
      * - Validate the returned response against this endpoint's result schema.
      *
-     * @throws `Feedback` if the payload is invalid.
+     * @throws `string` if the payload is invalid.
      * @throws `ResponseError` if the response status is not ok (200-299)
      * @throws `ResponseError` if the response content is invalid.
      */

package/endpoint/Endpoint.js

@@ -1,6 +1,5 @@
 import { ResponseError } from "../error/ResponseError.js";
 import { ValueError } from "../error/ValueError.js";
-import { Feedback } from "../feedback/Feedback.js";
 import { UNDEFINED } from "../schema/Schema.js";
 import { assertDictionary } from "../util/dictionary.js";
 import { getMessage } from "../util/error.js";
@@ -44,7 +43,7 @@ export class Endpoint {
      * @param unsafePayload The payload to pass into the callback (will be validated against this endpoint's payload schema).
      * @param request The entire HTTP request that is being handled (payload was possibly extracted from this somehow).
      *
-     * @throws `Feedback` if the payload is invalid.
+     * @throws `string` if the payload is invalid.
      * @throws `ValueError` if `callback()` returns an invalid result.
      */
     async handle(callback, unsafePayload, request, caller = this.handle) {
@@ -57,8 +56,8 @@ export class Endpoint {
             return getResponse(this.result.validate(unsafeResult));
         }
         catch (thrown) {
-            if (thrown instanceof Feedback)
-                throw new ValueError(`Invalid result for ${this.toString()}:\n${thrown.message}`, {
+            if (typeof thrown === "string")
+                throw new ValueError(`Invalid result for ${this.toString()}:\n${thrown}`, {
                     endpoint: this,
                     callback,
                     cause: thrown,
@@ -87,7 +86,7 @@ export class Endpoint {
      * - Validates a payload against this endpoints payload schema
      * - Return an HTTP `Request` that will send it the valid payload to this endpoint.
      *
-     * @throws `Feedback` if the payload is invalid.
+     * @throws `string` if the payload is invalid.
      */
     request(payload, options = {}, caller = this.request) {
         return getRequest(this.method, this.url, this.payload.validate(payload), options, caller);
@@ -110,13 +109,8 @@ export class Endpoint {
             return this.result.validate(content);
         }
         catch (thrown) {
-            if (thrown instanceof Feedback)
-                throw new ResponseError(`Invalid result for ${this.toString()}:\n${thrown.message}`, {
-                    endpoint: this,
-                    code: 422,
-                    cause: thrown,
-                    caller,
-                });
+            if (typeof thrown === "string")
+                throw new ResponseError(`Invalid result for ${this.toString()}:\n${thrown}`, { endpoint: this, code: 422, caller });
             throw thrown;
         }
     }
@@ -125,7 +119,7 @@ export class Endpoint {
      * - Validate the `payload` against this endpoint's payload schema.
      * - Validate the returned response against this endpoint's result schema.
      *
-     * @throws `Feedback` if the payload is invalid.
+     * @throws `string` if the payload is invalid.
      * @throws `ResponseError` if the response status is not ok (200-299)
      * @throws `ResponseError` if the response content is invalid.
      */

package/index.d.ts

@@ -6,7 +6,6 @@
 export * from "./db/index.js";
 export * from "./endpoint/index.js";
 export * from "./error/index.js";
-export * from "./feedback/index.js";
 export * from "./markup/index.js";
 export * from "./schema/index.js";
 export * from "./sequence/index.js";

package/index.js

@@ -6,7 +6,6 @@
 export * from "./db/index.js";
 export * from "./endpoint/index.js";
 export * from "./error/index.js";
-export * from "./feedback/index.js";
 // export * from "./firestore/client/index.js"; // Not exported.
 // export * from "./firestore/lite/index.js"; // Not exported.
 // export * from "./firestore/server/index.js"; // Not exported.

package/markup/util/regexp.js

@@ -11,11 +11,11 @@ export const WORD_CONTENT_REGEXP = "[\\p{L}\\p{N}]+"; // Word content (at least
 export const WORD_START_REGEXP = "(?<![\\p{L}\\p{N}])"; // Start of word (previous character is not a letter or number).
 export const WORD_END_REGEXP = "(?![\\p{L}\\p{N}])"; // End of word (next character is not a letter or number).
 export function getBlockRegExp(content, start = BLOCK_START_REGEXP, end = BLOCK_END_REGEXP) {
-    return new RegExp(`${start}${getRegExpSource(content)}${end}`);
+    return new RegExp(`${start}${getRegExpSource(content)}${end}`, "u");
 }
 export function getLineRegExp(content = LINE_CONTENT_REGEXP, end = LINE_END_REGEXP, start = LINE_START_REGEXP) {
-    return new RegExp(`${start}${getRegExpSource(content)}${end}`);
+    return new RegExp(`${start}${getRegExpSource(content)}${end}`, "u");
 }
 export function getWordRegExp(content = WORD_CONTENT_REGEXP, start = WORD_START_REGEXP, end = WORD_END_REGEXP) {
-    return new RegExp(`${start}${getRegExpSource(content)}${end}`);
+    return new RegExp(`${start}${getRegExpSource(content)}${end}`, "u");
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.170.2",
+	"version": "1.172.0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/dhoulb/shelving.git"
@@ -27,7 +27,6 @@
 		"./api": "./api/index.js",
 		"./db": "./db/index.js",
 		"./error": "./error/index.js",
-		"./feedback": "./feedback/index.js",
 		"./firestore/client": "./firestore/client/index.js",
 		"./firestore/lite": "./firestore/lite/index.js",
 		"./firestore/server": "./firestore/server/index.js",

package/schema/ArraySchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { getUniqueArray, isArray } from "../util/array.js";
 import { validateArray } from "../util/validate.js";
 import { Schema } from "./Schema.js";
@@ -39,13 +38,13 @@ export class ArraySchema extends Schema {
     validate(unsafeValue = this.value) {
         const unsafeArray = typeof unsafeValue === "string" ? unsafeValue.split(this.separator).filter(Boolean) : unsafeValue;
         if (!isArray(unsafeArray))
-            throw new ValueFeedback("Must be array", unsafeValue);
+            throw "Must be array";
         const validArray = validateArray(unsafeArray, this.items);
         const uniqueArray = this.unique ? getUniqueArray(validArray) : validArray;
         if (uniqueArray.length < this.min)
-            throw new ValueFeedback(uniqueArray.length ? `Minimum ${this.min} ${this.many}` : "Required", uniqueArray);
+            throw uniqueArray.length ? `Minimum ${this.min} ${this.many}` : "Required";
         if (uniqueArray.length > this.max)
-            throw new ValueFeedback(`Maximum ${this.max} ${this.many}`, uniqueArray);
+            throw `Maximum ${this.max} ${this.many}`;
         return uniqueArray;
     }
 }

package/schema/BooleanSchema.js

@@ -1,4 +1,3 @@
-import { Feedback } from "../feedback/Feedback.js";
 import { Schema } from "./Schema.js";
 const NEGATIVE = ["", "false", "0", "no", "n", "off"];
 /** Define a valid boolean. */
@@ -10,7 +9,7 @@ export class BooleanSchema extends Schema {
     validate(unsafeValue = this.value) {
         const value = typeof unsafeValue === "string" ? !NEGATIVE.includes(unsafeValue.toLowerCase().trim()) : !!unsafeValue;
         if (this.required && !value)
-            throw new Feedback("Required");
+            throw "Required";
         return value;
     }
 }

package/schema/ChoiceSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { isArray, requireFirst } from "../util/array.js";
 import { getKeys, getProps, isProp } from "../util/object.js";
 import { Schema } from "./Schema.js";
@@ -27,7 +26,7 @@ export class ChoiceSchema extends Schema {
     validate(unsafeValue = this.value) {
         if (typeof unsafeValue === "string" && isOption(this.options, unsafeValue))
             return unsafeValue;
-        throw new ValueFeedback("Unknown value", unsafeValue);
+        throw "Unknown value";
     }
     // Implement iterable.
     *[Symbol.iterator]() {

package/schema/DataSchema.d.ts

@@ -16,7 +16,9 @@ export declare class DataSchema<T extends Data> extends Schema<unknown> {
     readonly props: Schemas<T>;
     constructor({ one, title, props, value: partialValue, ...options }: DataSchemaOptions<T>);
     validate(unsafeValue?: unknown): T;
+    /** Make a new `DataSchema` that only uses a defined subset of the current props. */
     pick<K extends Key<T>>(...keys: K[]): DataSchema<Pick<T, K>>;
+    /** Make a new `DataSchema` that omits one or more of the current props. */
     omit<K extends Key<T>>(...keys: K[]): DataSchema<Omit<T, K>>;
 }
 /** Set of named data schemas. */

package/schema/DataSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { isData } from "../util/data.js";
 import { omitProps, pickProps } from "../util/object.js";
 import { mapProps } from "../util/transform.js";
@@ -17,12 +16,14 @@ export class DataSchema extends Schema {
     }
     validate(unsafeValue = this.value) {
         if (!isData(unsafeValue))
-            throw new ValueFeedback("Must be object", unsafeValue);
+            throw "Must be object";
         return validateData(unsafeValue, this.props);
     }
+    /** Make a new `DataSchema` that only uses a defined subset of the current props. */
     pick(...keys) {
         return new DataSchema({ ...this, props: pickProps(this.props, ...keys) });
     }
+    /** Make a new `DataSchema` that omits one or more of the current props. */
     omit(...keys) {
         return new DataSchema({ ...this, props: omitProps(this.props, ...keys) });
     }

package/schema/DateSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { getDate, requireDateString } from "../util/date.js";
 import { formatDate } from "../util/format.js";
 import { roundStep } from "../util/number.js";
@@ -19,12 +18,12 @@ export class DateSchema extends Schema {
     validate(value = this.value) {
         const date = getDate(value);
         if (!date)
-            throw new ValueFeedback(value ? "Invalid date" : "Required", value);
+            throw value ? "Invalid date" : "Required";
         const rounded = typeof this.step === "number" ? new Date(roundStep(date.getTime(), this.step)) : date;
         if (this.min && rounded < this.min)
-            throw new ValueFeedback(`Minimum ${this.format(this.min)}`, rounded);
+            throw `Minimum ${this.format(this.min)}`;
         if (this.max && rounded > this.max)
-            throw new ValueFeedback(`Maximum ${this.format(this.max)}`, rounded);
+            throw `Maximum ${this.format(this.max)}`;
         return this.stringify(rounded);
     }
     stringify(value) {

package/schema/DictionarySchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { isDictionary } from "../util/dictionary.js";
 import { validateDictionary } from "../util/validate.js";
 import { Schema } from "./Schema.js";
@@ -15,13 +14,13 @@ export class DictionarySchema extends Schema {
     }
     validate(unsafeValue = this.value) {
         if (!isDictionary(unsafeValue))
-            throw new ValueFeedback("Must be object", unsafeValue);
+            throw "Must be object";
         const validDictionary = validateDictionary(unsafeValue, this.items);
         const length = Object.keys(validDictionary).length;
         if (length < this.min)
-            throw new ValueFeedback(length ? `Minimum ${this.min} ${this.many}` : "Required", validDictionary);
+            throw length ? `Minimum ${this.min} ${this.many}` : "Required";
         if (length > this.max)
-            throw new ValueFeedback(`Maximum ${this.max} ${this.many}`, validDictionary);
+            throw `Maximum ${this.max} ${this.many}`;
         return validDictionary;
     }
 }

package/schema/EntitySchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { isArrayItem } from "../util/array.js";
 import { getEntity } from "../util/entity.js";
 import { NULLABLE } from "./NullableSchema.js";
@@ -14,9 +13,9 @@ export class EntitySchema extends StringSchema {
         const entity = super.validate(unsafeValue);
         const [type] = getEntity(entity);
         if (!type)
-            throw new ValueFeedback("Must be entity", unsafeValue);
+            throw "Must be entity";
         if (this.types && !isArrayItem(this.types, type))
-            throw new ValueFeedback("Invalid entity type", type);
+            throw "Invalid entity type";
         return entity;
     }
 }

package/schema/FileSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { getFileExtension } from "../util/file.js";
 import { isProp } from "../util/object.js";
 import { NULLABLE } from "./NullableSchema.js";
@@ -14,9 +13,9 @@ export class FileSchema extends StringSchema {
         const path = super.validate(unsafeValue);
         const extension = getFileExtension(path);
         if (!extension)
-            throw new ValueFeedback("Must be file name with extension", unsafeValue);
+            throw "Must be file name with extension";
         if (this.types && !isProp(this.types, extension))
-            throw new ValueFeedback("Invalid file type", extension);
+            throw "Invalid file type";
         return path;
     }
 }

package/schema/NumberSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { formatNumber } from "../util/format.js";
 import { getNumber, roundStep } from "../util/number.js";
 import { NULLABLE } from "./NullableSchema.js";
@@ -17,12 +16,12 @@ export class NumberSchema extends Schema {
     validate(unsafeValue = this.value) {
         const optionalNumber = getNumber(unsafeValue);
         if (typeof optionalNumber !== "number")
-            throw new ValueFeedback("Must be number", unsafeValue);
+            throw "Must be number";
         const roundedNumber = typeof this.step === "number" ? roundStep(optionalNumber, this.step) : optionalNumber;
         if (roundedNumber < this.min)
-            throw new ValueFeedback(!optionalNumber ? "Required" : `Minimum ${formatNumber(this.min)}`, roundedNumber);
+            throw !optionalNumber ? "Required" : `Minimum ${formatNumber(this.min)}`;
         if (roundedNumber > this.max)
-            throw new ValueFeedback(`Maximum ${formatNumber(this.max)}`, roundedNumber);
+            throw `Maximum ${formatNumber(this.max)}`;
         return roundedNumber;
     }
 }

package/schema/RequiredSchema.d.ts

@@ -1,6 +1,6 @@
 import type { Schema } from "./Schema.js";
 import { ThroughSchema } from "./ThroughSchema.js";
-/** Validate a value of a specifed type, but throw `Feedback` if the validated value is falsy. */
+/** Validate a value of a specifed type, but throw `"Required"` if the validated value is falsy. */
 export declare class RequiredSchema<T> extends ThroughSchema<T> {
     validate(unsafeValue: unknown): T;
 }

package/schema/RequiredSchema.js

@@ -1,11 +1,10 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { ThroughSchema } from "./ThroughSchema.js";
-/** Validate a value of a specifed type, but throw `Feedback` if the validated value is falsy. */
+/** Validate a value of a specifed type, but throw `"Required"` if the validated value is falsy. */
 export class RequiredSchema extends ThroughSchema {
     validate(unsafeValue) {
         const safeValue = super.validate(unsafeValue);
         if (!safeValue)
-            throw new ValueFeedback("Required", safeValue);
+            throw "Required";
         return safeValue;
     }
 }

package/schema/Schema.d.ts

@@ -37,6 +37,8 @@ export declare abstract class Schema<T = unknown> implements Validator<T> {
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }
+/** Extract the type from a schema. */
+export type SchemaType<X> = X extends Schema<infer Y> ? Y : never;
 /** A set of named schemas in `{ name: schema }` format. */
 export type Schemas<T extends Data = Data> = {
     readonly [K in keyof T]: Schema<T[K]>;

package/schema/StringSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { sanitizeMultilineText, sanitizeText } from "../util/string.js";
 import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
@@ -36,14 +35,14 @@ export class StringSchema extends Schema {
     validate(unsafeValue = this.value) {
         const possibleString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
         if (typeof possibleString !== "string")
-            throw new ValueFeedback("Must be string", unsafeValue);
+            throw "Must be string";
         const saneString = this.sanitize(possibleString);
         if (saneString.length < this.min)
-            throw new ValueFeedback(possibleString.length ? `Minimum ${this.min} characters` : "Required", saneString);
+            throw possibleString.length ? `Minimum ${this.min} characters` : "Required";
         if (saneString.length > this.max)
-            throw new ValueFeedback(`Maximum ${this.max} characters`, saneString);
+            throw `Maximum ${this.max} characters`;
         if (this.match && !this.match.test(saneString))
-            throw new ValueFeedback(saneString ? "Invalid format" : "Required", saneString);
+            throw saneString ? "Invalid format" : "Required";
         return saneString;
     }
     /** Sanitize the string by removing unwanted characters. */

package/schema/URISchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { getURI, HTTP_SCHEMES } from "../util/uri.js";
 import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
@@ -26,9 +25,9 @@ export class URISchema extends StringSchema {
         const str = super.validate(unsafeValue);
         const uri = getURI(str);
         if (!uri)
-            throw new ValueFeedback(str ? "Invalid format" : "Required", str);
+            throw str ? "Invalid format" : "Required";
         if (this.schemes && !this.schemes.includes(uri.protocol))
-            throw new ValueFeedback("Invalid URI scheme", str);
+            throw "Invalid URI scheme";
         return uri.href;
     }
 }

package/schema/URLSchema.js

@@ -1,4 +1,3 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
 import { HTTP_SCHEMES } from "../util/uri.js";
 import { getURL } from "../util/url.js";
 import { NULLABLE } from "./NullableSchema.js";
@@ -29,9 +28,9 @@ export class URLSchema extends StringSchema {
         const str = super.validate(unsafeValue);
         const url = getURL(str, this.base);
         if (!url)
-            throw new ValueFeedback(str ? "Invalid format" : "Required", str);
+            throw str ? "Invalid format" : "Required";
         if (this.schemes && !this.schemes.includes(url.protocol))
-            throw new ValueFeedback("Invalid URL scheme", str);
+            throw "Invalid URL scheme";
         return url.href;
     }
 }

package/util/array.d.ts

@@ -105,6 +105,10 @@ export declare function countArray<T>(arr: ImmutableArray<T>): number;
 /** Interleave array items with a separator */
 export declare function interleaveArray<T>(items: PossibleArray<T>, separator: T): ImmutableArray<T>;
 export declare function interleaveArray<A, B>(items: PossibleArray<A>, separator: B): ImmutableArray<A | B>;
+/** Return a new array with a new value replacing a specific index in the array (or the same array if the value was unchanged). */
+export declare function withArrayIndex<T>(arr: ImmutableArray<T>, index: number, value: T): ImmutableArray<T>;
+/** Return a new array without a specific index in the array (or the same array if the value was unchanged). */
+export declare function omitArrayIndex<T>(arr: ImmutableArray<T>, index: number): ImmutableArray<T>;
 /** Get the first item from an array or iterable, or `undefined` if it didn't exist. */
 export declare function getFirst<T>(items: PossibleArray<T>): T | undefined;
 /** Get the first item from an array or iterable. */

package/util/array.js

@@ -124,6 +124,17 @@ export function interleaveArray(items, separator) {
         return items; // Return same empty array if empty or only one item.
     return Array.from(interleaveItems(items, separator));
 }
+/** Return a new array with a new value replacing a specific index in the array (or the same array if the value was unchanged). */
+export function withArrayIndex(arr, index, value) {
+    if (arr[index] === value)
+        return arr;
+    return [...arr.slice(0, index), value, ...arr.slice(index + 1)];
+}
+/** Return a new array without a specific index in the array (or the same array if the value was unchanged). */
+export function omitArrayIndex(arr, index) {
+    const output = [...arr.slice(0, index), ...arr.slice(index + 1)];
+    return arr.length !== output.length ? output : arr;
+}
 /** Get the first item from an array or iterable, or `undefined` if it didn't exist. */
 export function getFirst(items) {
     if (isArray(items))

package/util/http.d.ts

@@ -42,7 +42,7 @@ export declare function getResponse(value: unknown): Response;
  *
  * Returns the correct `Response` based on the type of error thrown:
  * - If `reason` is a `Response` instance, return it directly.
- * - If `reason` is a `Feedback` instance, return a 400 response with the feedback's message as JSON, e.g. `{ message: "Invalid input" }`
+ * - If `reason` is a string, return a 422 response with the string message, e.g. `"Invalid input"`
  * - If `reason` is an `RequestError` instance, return a response with the error's message and code (but only if `debug` is true so we don't leak error details to the client).
  * - If `reason` is an `Error` instance, return a 500 response with the error's message (but only if `debug` is true so we don't leak error details to the client).
  * - Anything else returns a 500 response.

package/util/http.js

@@ -1,6 +1,5 @@
 import { RequestError } from "../error/RequestError.js";
 import { ResponseError } from "../error/ResponseError.js";
-import { Feedback } from "../feedback/Feedback.js";
 import { assertDictionary } from "./dictionary.js";
 import { isError } from "./error.js";
 import { getPlaceholders, renderTemplate } from "./template.js";
@@ -89,7 +88,7 @@ export function getResponse(value) {
  *
  * Returns the correct `Response` based on the type of error thrown:
  * - If `reason` is a `Response` instance, return it directly.
- * - If `reason` is a `Feedback` instance, return a 400 response with the feedback's message as JSON, e.g. `{ message: "Invalid input" }`
+ * - If `reason` is a string, return a 422 response with the string message, e.g. `"Invalid input"`
  * - If `reason` is an `RequestError` instance, return a response with the error's message and code (but only if `debug` is true so we don't leak error details to the client).
  * - If `reason` is an `Error` instance, return a 500 response with the error's message (but only if `debug` is true so we don't leak error details to the client).
  * - Anything else returns a 500 response.
@@ -101,9 +100,9 @@ export function getErrorResponse(reason, debug = false) {
     // If it's already a `Response`, return it directly.
     if (reason instanceof Response)
         return reason;
-    // Throw 'Feedback' to return `{ message: "etc" }` to the client, e.g. for input validation.
-    if (reason instanceof Feedback)
-        return Response.json(reason, { status: 422 }); // HTTP 422 Unprocessable Entity
+    // Throw validation message strings to return `{ message: "etc" }` to the client.
+    if (typeof reason === "string")
+        return new Response(reason, { status: 422 }); // HTTP 422 Unprocessable Entity
     // Throw `RequestError` to set a custom status code (e.g. `UnauthorizedError`).
     const status = reason instanceof RequestError ? reason.code : 500;
     // Throw `Error` to return `{ message: "etc" }` to the client (but only if `debug` is true so we don't leak error details to the client).

package/util/validate.d.ts

@@ -12,7 +12,7 @@ export interface Validator<T> {
      * @return Valid value.
      *
      * @throws `Error` If the value is invalid and cannot be fixed.
-     * @throws `Feedback` If the value is invalid and cannot be fixed and we want to explain why to an end user.
+     * @throws `string` If the value is invalid and cannot be fixed and we want to explain why to an end user.
      */
     validate(unsafeValue: unknown): T;
 }
@@ -34,20 +34,20 @@ export declare function requireValid<T>(value: unknown, validator: Validator<T>,
  * Validate an iterable set of items with a validator.
  *
  * @yield Valid items.
- * @throw Feedback if one or more items did not validate.
+ * @throw string if one or more items did not validate.
  */
 export declare function validateItems<T>(unsafeItems: PossibleArray<unknown>, validator: Validator<T>): Iterable<T>;
 /**
  * Validate an array of items.
  *
  * @return Array with valid items.
- * @throw Feedback if one or more entry values did not validate.
+ * @throw string if one or more entry values did not validate.
  */
 export declare function validateArray<T>(unsafeArray: PossibleArray<unknown>, validator: Validator<T>): ImmutableArray<T>;
 /**
  * Validate the values of the entries in a dictionary object.
  *
- * @throw Feedback if one or more entry values did not validate.
+ * @throw string if one or more entry values did not validate.
  */
 export declare function validateDictionary<T>(unsafeDictionary: ImmutableDictionary<unknown>, validator: Validator<T>): ImmutableDictionary<T>;
 /**
@@ -57,6 +57,6 @@ export declare function validateDictionary<T>(unsafeDictionary: ImmutableDiction
  * - `undefined` props after validation will not be set in the output object.
  *
  * @return Valid object.
- * @throw Feedback if one or more props did not validate.
+ * @throw string if one or more props did not validate.
  */
 export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>): T;

package/util/validate.js

@@ -1,5 +1,4 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { Feedback, ValueFeedback } from "../feedback/Feedback.js";
 import { isArray } from "./array.js";
 import { getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
@@ -11,7 +10,7 @@ export function getValid(value, validator) {
         return validator.validate(value);
     }
     catch (thrown) {
-        if (thrown instanceof Feedback)
+        if (typeof thrown === "string")
             return undefined;
         throw thrown;
     }
@@ -22,8 +21,8 @@ export function requireValid(value, validator, caller = requireValid) {
         return validator.validate(value);
     }
     catch (thrown) {
-        if (thrown instanceof Feedback)
-            throw new RequiredError(thrown.message, { cause: thrown, caller });
+        if (typeof thrown === "string")
+            throw new RequiredError(thrown, { cause: thrown, caller });
         throw thrown;
     }
 }
@@ -31,7 +30,7 @@ export function requireValid(value, validator, caller = requireValid) {
  * Validate an iterable set of items with a validator.
  *
  * @yield Valid items.
- * @throw Feedback if one or more items did not validate.
+ * @throw string if one or more items did not validate.
  */
 export function* validateItems(unsafeItems, validator) {
     let index = 0;
@@ -41,20 +40,20 @@ export function* validateItems(unsafeItems, validator) {
             yield validator.validate(unsafeItem);
         }
         catch (thrown) {
-            if (!(thrown instanceof Feedback))
+            if (typeof thrown !== "string")
                 throw thrown;
-            messages.push(getNamedMessage(index.toString(), thrown.message));
+            messages.push(getNamedMessage(index.toString(), thrown));
         }
         index++;
     }
     if (messages.length)
-        throw new ValueFeedback(messages.join("\n"), unsafeItems);
+        throw messages.join("\n");
 }
 /**
  * Validate an array of items.
  *
  * @return Array with valid items.
- * @throw Feedback if one or more entry values did not validate.
+ * @throw string if one or more entry values did not validate.
  */
 export function validateArray(unsafeArray, validator) {
     let index = 0;
@@ -69,20 +68,20 @@ export function validateArray(unsafeArray, validator) {
                 changed = true;
         }
         catch (thrown) {
-            if (!(thrown instanceof Feedback))
+            if (typeof thrown !== "string")
                 throw thrown;
-            messages.push(getNamedMessage(index.toString(), thrown.message));
+            messages.push(getNamedMessage(index.toString(), thrown));
         }
         index++;
     }
     if (messages.length)
-        throw new ValueFeedback(messages.join("\n"), unsafeArray);
+        throw messages.join("\n");
     return changed || !isArray(unsafeArray) ? safeArray : unsafeArray;
 }
 /**
  * Validate the values of the entries in a dictionary object.
  *
- * @throw Feedback if one or more entry values did not validate.
+ * @throw string if one or more entry values did not validate.
  */
 export function validateDictionary(unsafeDictionary, validator) {
     let changed = false;
@@ -96,13 +95,13 @@ export function validateDictionary(unsafeDictionary, validator) {
                 changed = true;
         }
         catch (thrown) {
-            if (!(thrown instanceof Feedback))
+            if (typeof thrown !== "string")
                 throw thrown;
-            messages.push(getNamedMessage(key, thrown.message));
+            messages.push(getNamedMessage(key, thrown));
         }
     }
     if (messages.length)
-        throw new ValueFeedback(messages.join("\n"), unsafeDictionary);
+        throw messages.join("\n");
     return changed || isIterable(unsafeDictionary) ? safeDictionary : unsafeDictionary;
 }
 /**
@@ -112,7 +111,7 @@ export function validateDictionary(unsafeDictionary, validator) {
  * - `undefined` props after validation will not be set in the output object.
  *
  * @return Valid object.
- * @throw Feedback if one or more props did not validate.
+ * @throw string if one or more props did not validate.
  */
 export function validateData(unsafeData, validators) {
     let changes = 0;
@@ -137,13 +136,13 @@ export function validateData(unsafeData, validators) {
             }
         }
         catch (thrown) {
-            if (!(thrown instanceof Feedback))
+            if (typeof thrown !== "string")
                 throw thrown;
-            messages.push(getNamedMessage(key, thrown.message));
+            messages.push(getNamedMessage(key, thrown));
         }
     }
     if (messages.length)
-        throw new ValueFeedback(messages.join("\n"), unsafeData);
+        throw messages.join("\n");
     if (changes)
         return safeData;
     // Check that no excess keys exist.

package/feedback/Feedback.d.ts

@@ -1,19 +0,0 @@
-/**
- * The `Feedback` class represents a feedback message that should be shown to the user.
- * - Basic `Feedback` is neither good nor bad, `Feedback` indicates good news, and `Feedback` indicates bad news.
- *
- * Conceptually different to a Javascript `Error`...
- * - `Error`: a program error designed to help developers fix an issue in their code.
- * - `Feedback`: generated in reaction to something a user did, and helps them understand what to do next.
- */
-export declare class Feedback {
-    /** String feedback message that is safe to show to a user. */
-    readonly message: string;
-    constructor(message: string);
-    toString(): string;
-}
-/** Feedback with a known and typed `.value` field. */
-export declare class ValueFeedback<T> extends Feedback {
-    readonly value: T;
-    constructor(message: string, value: T);
-}

package/feedback/Feedback.js

@@ -1,26 +0,0 @@
-/**
- * The `Feedback` class represents a feedback message that should be shown to the user.
- * - Basic `Feedback` is neither good nor bad, `Feedback` indicates good news, and `Feedback` indicates bad news.
- *
- * Conceptually different to a Javascript `Error`...
- * - `Error`: a program error designed to help developers fix an issue in their code.
- * - `Feedback`: generated in reaction to something a user did, and helps them understand what to do next.
- */
-export class Feedback {
-    /** String feedback message that is safe to show to a user. */
-    message;
-    constructor(message) {
-        this.message = message;
-    }
-    toString() {
-        return this.message;
-    }
-}
-/** Feedback with a known and typed `.value` field. */
-export class ValueFeedback extends Feedback {
-    value;
-    constructor(message, value) {
-        super(message);
-        this.value = value;
-    }
-}

package/feedback/index.d.ts

@@ -1 +0,0 @@
-export * from "./Feedback.js";

package/feedback/index.js

@@ -1 +0,0 @@
-export * from "./Feedback.js";