shelving 1.150.4 → 1.150.6

package/db/Change.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
-import { type Optional } from "../util/optional.js";
+import { type Nullish } from "../util/null.js";
 import type { Updates } from "../util/update.js";
 import type { AsyncProvider, Provider } from "./Provider.js";
 /** A change to a database. */
@@ -68,8 +68,8 @@ export type DatabaseChanges<T extends Database> = ImmutableArray<DatabaseChange<
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
 export declare function writeChange<T extends Database>(provider: Provider<T>, change: DatabaseChange<T>): DatabaseChange<T>;
 /** Write a set of changes to a synchronous provider. */
-export declare function writeChanges<T extends Database>(provider: Provider<T>, ...changes: Optional<DatabaseChange<T>>[]): DatabaseChanges<T>;
+export declare function writeChanges<T extends Database>(provider: Provider<T>, ...changes: Nullish<DatabaseChange<T>>[]): DatabaseChanges<T>;
 /** Write a single change to an asynchronous provider and return the change that was written. */
 export declare function writeAsyncChange<T extends Database>(provider: AsyncProvider<T>, change: DatabaseChange<T>): Promise<DatabaseChange<T>>;
 /** Write a set of changes to an asynchronous provider. */
-export declare function writeAsyncChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Optional<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;
+export declare function writeAsyncChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Nullish<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;

package/db/Change.js

@@ -1,4 +1,4 @@
-import { notOptional } from "../util/optional.js";
+import { notNullish } from "../util/null.js";
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
 export function writeChange(provider, change) {
     const { action, collection, id, query } = change;
@@ -26,7 +26,7 @@ export function writeChange(provider, change) {
 }
 /** Write a set of changes to a synchronous provider. */
 export function writeChanges(provider, ...changes) {
-    return changes.filter(notOptional).map(change => writeChange(provider, change));
+    return changes.filter(notNullish).map(change => writeChange(provider, change));
 }
 /** Write a single change to an asynchronous provider and return the change that was written. */
 export async function writeAsyncChange(provider, change) {
@@ -55,5 +55,5 @@ export async function writeAsyncChange(provider, change) {
 }
 /** Write a set of changes to an asynchronous provider. */
 export function writeAsyncChanges(provider, ...changes) {
-    return Promise.all(changes.filter(notOptional).map(change => writeAsyncChange(provider, change)));
+    return Promise.all(changes.filter(notNullish).map(change => writeAsyncChange(provider, change)));
 }

package/feedback/index.d.ts

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

package/feedback/index.js

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

package/package.json

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

package/react/createDataContext.d.ts

@@ -4,14 +4,14 @@ import type { AbstractProvider } from "../db/Provider.js";
 import { QueryStore } from "../db/QueryStore.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
-import type { Optional } from "../util/optional.js";
+import type { Nullish } from "../util/null.js";
 export interface DataContext<T extends Database> {
     /** Get an `ItemStore` for the specified collection item in the current `DataProvider` context and subscribe to any changes in it. */
     useItem<K extends DataKey<T>>(this: void, collection: K, id: string): ItemStore<T, K>;
-    useItem<K extends DataKey<T>>(this: void, collection: Optional<K>, id: Optional<string>): ItemStore<T, K> | undefined;
+    useItem<K extends DataKey<T>>(this: void, collection: Nullish<K>, id: Nullish<string>): ItemStore<T, K> | undefined;
     /** Get an `QueryStore` for the specified collection query in the current `DataProvider` context and subscribe to any changes in it. */
     useQuery<K extends DataKey<T>>(this: void, collection: K, query: ItemQuery<T[K]>): QueryStore<T, K>;
-    useQuery<K extends DataKey<T>>(this: void, collection: Optional<K>, query: Optional<ItemQuery<T[K]>>): QueryStore<T, K> | undefined;
+    useQuery<K extends DataKey<T>>(this: void, collection: Nullish<K>, query: Nullish<ItemQuery<T[K]>>): QueryStore<T, K> | undefined;
     readonly DataContext: ({ children }: {
         children: ReactNode;
     }) => ReactElement;

package/schema/DateSchema.d.ts

@@ -1,12 +1,12 @@
 import type { PossibleDate } from "../util/date.js";
-import type { Optional } from "../util/optional.js";
+import type { Nullish } from "../util/null.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DateSchema` */
 export interface DateSchemaOptions extends SchemaOptions {
     readonly value?: PossibleDate | undefined;
-    readonly min?: Optional<PossibleDate> | undefined;
-    readonly max?: Optional<PossibleDate> | undefined;
+    readonly min?: Nullish<PossibleDate>;
+    readonly max?: Nullish<PossibleDate>;
 }
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {

package/schema/TimeSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Optional } from "../util/optional.js";
+import type { Nullish } from "../util/null.js";
 import type { PossibleTime } from "../util/time.js";
 import { Time } from "../util/time.js";
 import type { SchemaOptions } from "./Schema.js";
@@ -6,8 +6,8 @@ import { Schema } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
 export interface TimeSchemaOptions extends SchemaOptions {
     readonly value?: PossibleTime | undefined;
-    readonly min?: Optional<PossibleTime> | undefined;
-    readonly max?: Optional<PossibleTime> | undefined;
+    readonly min?: Nullish<PossibleTime>;
+    readonly max?: Nullish<PossibleTime>;
     readonly step?: number | undefined;
 }
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */

package/store/DataStore.d.ts

@@ -1,4 +1,5 @@
 import type { Data, DataKey } from "../util/data.js";
+import type { AnyCaller } from "../util/function.js";
 import type { Updates } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a data object. */
@@ -22,6 +23,8 @@ export declare class OptionalDataStore<T extends Data> extends Store<T | undefin
     set data(data: T);
     /** Does the data exist or not? */
     get exists(): boolean;
+    /** Return the data for this data store, or throw `RequiredError` if it is not set. */
+    requireData(caller?: AnyCaller): T;
     /** Update several props in this data. */
     update(updates: Updates<T>): void;
     /** Update a single named prop in this data. */

package/store/DataStore.js

@@ -1,5 +1,6 @@
+import { RequiredError } from "../error/RequiredError.js";
+import { getGetter } from "../util/class.js";
 import { withProp } from "../util/object.js";
-import { getRequired } from "../util/optional.js";
 import { updateData } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a data object. */
@@ -29,7 +30,7 @@ export class DataStore extends Store {
 export class OptionalDataStore extends Store {
     /** Get current data value of this store (or throw `Promise` that resolves to the next required value). */
     get data() {
-        return getRequired(this.value);
+        return this.requireData(getGetter(this, "data"));
     }
     /** Set the data of this store. */
     set data(data) {
@@ -39,17 +40,24 @@ export class OptionalDataStore extends Store {
     get exists() {
         return !!this.value;
     }
+    /** Return the data for this data store, or throw `RequiredError` if it is not set. */
+    requireData(caller = this.requireData) {
+        const data = this.value;
+        if (!data)
+            throw new RequiredError("Data is empty", { caller });
+        return data;
+    }
     /** Update several props in this data. */
     update(updates) {
-        this.value = updateData(this.data, updates);
+        this.value = updateData(this.requireData(this.update), updates);
     }
     /** Update a single named prop in this data. */
     getProp(name) {
-        return this.data[name];
+        return this.requireData(this.getProp)[name];
     }
     /** Update a single named prop in this data. */
     setProp(name, value) {
-        this.value = withProp(this.data, name, value);
+        this.value = withProp(this.requireData(this.setProp), name, value);
     }
     /** Set the data to `undefined`. */
     unset() {

package/util/entity.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCaller } from "./function.js";
-import type { Optional } from "./optional.js";
+import type { Nullish } from "./null.js";
 /** Entity strings combine a type and ID, e.g. `challenge:a1b2c3` */
 export type Entity<T extends string = string> = `${T}:${string}`;
 /** Extract the type from an `Entity` string. */
@@ -10,8 +10,8 @@ export type EmptyEntity = [type: undefined, id: undefined];
 export declare const EMPTY_ENTITY: EmptyEntity;
 /** Split an optional entity tag like `challenge:a1b2c3` into `["challenge", "a1b2c3"]`, or return `EmptyEntity` if the entity was invalid. */
 export declare function getEntity<T extends string>(entity: Entity<T>): [type: T, id: string];
-export declare function getEntity<T extends string>(entity: Optional<Entity<T>>): [type: T, id: string] | EmptyEntity;
-export declare function getEntity(entity: Optional<string>): [type: string, id: string] | EmptyEntity;
+export declare function getEntity<T extends string>(entity: Nullish<Entity<T>>): [type: T, id: string] | EmptyEntity;
+export declare function getEntity(entity: Nullish<string>): [type: string, id: string] | EmptyEntity;
 /** Split an entity tag like `challenge:a1b2c3` into `type` and `id`, or throw `RequiredError` if the entity tag was invalid. */
 export declare function requireEntity<T extends string>(entity: Entity<T>, caller?: AnyCaller): [type: T, id: string];
 export declare function requireEntity(entity: string, caller?: AnyCaller): [type: string, id: string];

package/util/error.d.ts

@@ -1,6 +1,23 @@
+import type { ImmutableDictionary } from "./dictionary.js";
+import type { AnyCaller } from "./function.js";
 /** Log an error to the console. */
 export declare function logError(reason: unknown): void;
 /** Is an unknown value an `Error` instance? */
 export declare function isError(v: unknown): v is Error & {
     readonly code?: string | undefined;
 };
+/** Things that can be a message. */
+export type PossibleMessage = {
+    message: string;
+} | string;
+/** Return the string message from an unknown value, or return `undefined` if it could not be found. */
+export declare function getMessage(input: unknown): string | undefined;
+/** Require a message from an unknown value, or throw `RequiredError` if it could not be found. */
+export declare function requireMessage(input: PossibleMessage, caller?: AnyCaller): string;
+/**
+ * Split a string message into lines, look for prefixes like `name:`, and return a dictionary of those named messages.
+ * - Full messages strings can have multiple lines separated by `\n` newline.
+ * - Named messages are extracted into their own entries in the dictionary.
+ * - Unnamed messages are combined into a single entry with the key `""` (empty string).
+ */
+export declare function splitMessage(input: PossibleMessage): ImmutableDictionary<string>;

package/util/error.js

@@ -1,3 +1,5 @@
+import { RequiredError } from "../error/RequiredError.js";
+import { isObject } from "./object.js";
 /** Log an error to the console. */
 export function logError(reason) {
     console.error(reason);
@@ -6,3 +8,43 @@ export function logError(reason) {
 export function isError(v) {
     return typeof Error.isError === "function" ? Error.isError(v) : v instanceof Error;
 }
+/** Return the string message from an unknown value, or return `undefined` if it could not be found. */
+export function getMessage(input) {
+    return typeof input === "string" ? input : isObject(input) && typeof input.message === "string" ? input.message : undefined;
+}
+/** Require a message from an unknown value, or throw `RequiredError` if it could not be found. */
+export function requireMessage(input, caller = requireMessage) {
+    const message = getMessage(input);
+    if (message === undefined)
+        throw new RequiredError("Message is required", { received: input, caller });
+    return message;
+}
+/**
+ * Split a string message into lines, look for prefixes like `name:`, and return a dictionary of those named messages.
+ * - Full messages strings can have multiple lines separated by `\n` newline.
+ * - Named messages are extracted into their own entries in the dictionary.
+ * - Unnamed messages are combined into a single entry with the key `""` (empty string).
+ */
+export function splitMessage(input) {
+    const messages = requireMessage(input, splitMessage).split("\n");
+    const output = {};
+    for (const line of messages) {
+        const i = line.indexOf(": ");
+        if (i >= 0) {
+            const name = line.slice(0, i).trim();
+            const message = line.slice(i + 2).trim();
+            if (Object.hasOwn(output, name))
+                output[name] += `\n${message}`;
+            else
+                output[name] = message;
+        }
+        else {
+            const message = line.trim();
+            if (Object.hasOwn(output, ""))
+                output[""] += `\n${message}`;
+            else
+                output[""] = message;
+        }
+    }
+    return output;
+}

package/util/index.d.ts

@@ -39,7 +39,6 @@ export * from "./merge.js";
 export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
-export * from "./optional.js";
 export * from "./path.js";
 export * from "./query.js";
 export * from "./random.js";

package/util/index.js

@@ -39,7 +39,6 @@ export * from "./merge.js";
 export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
-export * from "./optional.js";
 export * from "./path.js";
 export * from "./query.js";
 export * from "./random.js";

package/util/link.d.ts

@@ -1,6 +1,6 @@
 import type { ImmutableArray } from "./array.js";
 import type { AnyCaller } from "./function.js";
-import type { Optional } from "./optional.js";
+import type { Nullish } from "./null.js";
 import type { Path } from "./path.js";
 import { type PossibleURL } from "./url.js";
 /**
@@ -53,7 +53,7 @@ export declare function isLinkURL(value: unknown, schemes?: LinkSchemes, hosts?:
  * Convert a possible URL to a link URL, or return `undefined` if conversion fails.
  * - A valid link URL is a `URL` instance with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.
  */
-export declare function getLinkURL(value: Optional<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLinkURL | undefined;
+export declare function getLinkURL(value: Nullish<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLinkURL | undefined;
 /**
  * Convert a possible URL to a link URL, or throw `RequiredError` if conversion fails.
  * - A valid link URL is a `URL` instance with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.
@@ -63,7 +63,7 @@ export declare function requireLinkURL(value: PossibleURL, base?: AbsoluteLinkUR
  * Convert a possible URL to an link URL string, or return `undefined` if conversion fails.
  * - A valid link URL string is an absolute URL string with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.
  */
-export declare function getLink(value: Optional<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLink | undefined;
+export declare function getLink(value: Nullish<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLink | undefined;
 /**
  * Convert a possible URL to an link URL string, or throw `RequiredError` if conversion fails.
  * - A valid link URL string is an absolute URL string with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.

package/util/path.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCaller } from "./function.js";
-import { type Optional } from "./optional.js";
+import { type Nullish } from "./null.js";
 /** Absolute path string starts with `/` slash. */
 export type AbsolutePath = `/` | `/${string}`;
 /** Relative path string starts with `./` or `../` */
@@ -19,7 +19,7 @@ export declare function isRelativePath(path: string): path is RelativePath;
  * @param base Absolute path used for resolving relative paths in `possible`
  * @return Absolute path with a leading trailing slash, e.g. `/a/c/b`
  */
-export declare function getPath(value: Optional<string | URL>, base?: AbsolutePath | undefined): AbsolutePath | undefined;
+export declare function getPath(value: Nullish<string | URL>, base?: AbsolutePath | undefined): AbsolutePath | undefined;
 /**
  * Resolve a relative or absolute path and return the path, or throw `RequiredError` if not a valid path.
  * - Internally uses `new URL` to do path processing but shouldn't ever reveal that fact.

package/util/path.js

@@ -1,5 +1,5 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { notOptional } from "./optional.js";
+import { notNullish } from "./null.js";
 /** Is a string path an absolute path? */
 export function isAbsolutePath(path) {
     return path.startsWith("/");
@@ -23,7 +23,7 @@ function _cleanPath(path) {
  * @return Absolute path with a leading trailing slash, e.g. `/a/c/b`
  */
 export function getPath(value, base = "/") {
-    if (notOptional(value)) {
+    if (notNullish(value)) {
         try {
             const { pathname, search, hash } = new URL(value, `http://j.com${base}/`);
             if (isAbsolutePath(pathname))

package/util/string.d.ts

@@ -101,3 +101,7 @@ export declare function splitString(str: string, separator: string, min: 2, max?
 export declare function splitString(str: string, separator: string, min: 3, max?: number, caller?: AnyCaller): readonly [string, string, string, ...string[]];
 export declare function splitString(str: string, separator: string, min: 4, max?: number, caller?: AnyCaller): readonly [string, string, string, string, ...string[]];
 export declare function splitString(str: string, separator: string, min?: number, max?: number, caller?: AnyCaller): ImmutableArray<string>;
+/** Trim a string (as a function, so it can be used in mapping. */
+export declare function trimString(str: string): string;
+/** Does a string have length? */
+export declare function isNonEmptyString(str: string): boolean;

package/util/string.js

@@ -167,3 +167,11 @@ export function splitString(str, separator, min = 1, max = Number.POSITIVE_INFIN
         });
     return segments;
 }
+/** Trim a string (as a function, so it can be used in mapping. */
+export function trimString(str) {
+    return str.trim();
+}
+/** Does a string have length? */
+export function isNonEmptyString(str) {
+    return str.length > 0;
+}

package/util/url.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCaller } from "./function.js";
-import { type Optional } from "./optional.js";
+import { type Nullish } from "./null.js";
 /** Values that can be converted to a URL instance. */
 export type PossibleURL = string | URL;
 /** Is an unknown value a URL object? */
@@ -7,6 +7,6 @@ export declare function isURL(value: unknown): value is URL;
 /** Assert that an unknown value is a URL object. */
 export declare function assertURL(value: unknown, caller?: AnyCaller): asserts value is URL;
 /** Convert a possible URL to a URL, or return `undefined` if conversion fails. */
-export declare function getURL(possible: Optional<PossibleURL>, base?: PossibleURL | undefined): URL | undefined;
+export declare function getURL(possible: Nullish<PossibleURL>, base?: PossibleURL | undefined): URL | undefined;
 /** Convert a possible URL to a URL, or throw `RequiredError` if conversion fails. */
 export declare function requireURL(possible: PossibleURL, base?: PossibleURL, caller?: AnyCaller): URL;

package/util/url.js

@@ -1,5 +1,5 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { notOptional } from "./optional.js";
+import { notNullish } from "./null.js";
 /** Is an unknown value a URL object? */
 export function isURL(value) {
     return value instanceof URL;
@@ -11,7 +11,7 @@ export function assertURL(value, caller = assertURL) {
 }
 /** Convert a possible URL to a URL, or return `undefined` if conversion fails. */
 export function getURL(possible, base = _BASE) {
-    if (notOptional(possible)) {
+    if (notNullish(possible)) {
         try {
             return isURL(possible) ? possible : new URL(possible, base);
         }

package/util/validate.js

@@ -1,6 +1,5 @@
 import { ValueError } from "../error/ValueError.js";
-import { Feedback } from "../feedback/Feedback.js";
-import { ValueFeedbacks } from "../feedback/Feedbacks.js";
+import { Feedback, ValueFeedback } from "../feedback/Feedback.js";
 import { isArray } from "./array.js";
 import { getDataKeys, getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
@@ -30,8 +29,7 @@ export function getValid(value, validator, ErrorConstructor = ValueError, caller
  */
 export function* validateItems(unsafeItems, validator) {
     let index = 0;
-    let valid = true;
-    const messages = {};
+    const messages = [];
     for (const unsafeItem of unsafeItems) {
         try {
             yield validator.validate(unsafeItem);
@@ -39,13 +37,12 @@ export function* validateItems(unsafeItems, validator) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            messages[index] = thrown.message;
-            valid = false;
+            messages.push(`${index}: ${thrown.message}`);
         }
         index++;
     }
-    if (!valid)
-        throw new ValueFeedbacks(messages, unsafeItems);
+    if (messages.length)
+        throw new ValueFeedback(messages.join("\n"), unsafeItems);
 }
 /**
  * Validate an array of items.
@@ -56,10 +53,9 @@ export function* validateItems(unsafeItems, validator) {
  */
 export function validateArray(unsafeArray, validator) {
     let index = 0;
-    let valid = true;
     let changed = false; // start false so we can reuse original if nothing changes
     const safeArray = [];
-    const messages = {};
+    const messages = [];
     for (const unsafeItem of unsafeArray) {
         try {
             const safeItem = validator.validate(unsafeItem);
@@ -70,13 +66,12 @@ export function validateArray(unsafeArray, validator) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            messages[index] = thrown.message;
-            valid = false;
+            messages.push(`${index}: ${thrown.message}`);
         }
         index++;
     }
-    if (!valid)
-        throw new ValueFeedbacks(messages, unsafeArray);
+    if (messages.length)
+        throw new ValueFeedback(messages.join("\n"), unsafeArray);
     return changed || !isArray(unsafeArray) ? safeArray : unsafeArray;
 }
 /**
@@ -86,10 +81,9 @@ export function validateArray(unsafeArray, validator) {
  * - `feedback.details` will contain an entry for each invalid item (keyed by their count in the input iterable).
  */
 export function validateDictionary(unsafeDictionary, validator) {
-    let valid = true;
     let changed = false;
     const safeDictionary = {};
-    const messages = {};
+    const messages = [];
     for (const [key, unsafeValue] of getDictionaryItems(unsafeDictionary)) {
         try {
             const safeValue = validator.validate(unsafeValue);
@@ -100,21 +94,19 @@ export function validateDictionary(unsafeDictionary, validator) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            messages[key] = thrown.message;
-            valid = false;
+            messages.push(`${key}: ${thrown.message}`);
         }
     }
-    if (!valid)
-        throw new ValueFeedbacks(messages, unsafeDictionary);
+    if (messages.length)
+        throw new ValueFeedback(messages.join("\n"), unsafeDictionary);
     return changed || isIterable(unsafeDictionary) ? safeDictionary : unsafeDictionary;
 }
 /** Keep track of whether we're doing a deep-partial match or not. */
 let isDeeplyPartial = false;
 export function validateData(unsafeData, validators, partial = isDeeplyPartial) {
-    let valid = true;
     let changed = false;
     const safeData = {};
-    const messages = {};
+    const messages = [];
     try {
         isDeeplyPartial = partial;
         const props = getDataProps(validators);
@@ -132,12 +124,11 @@ export function validateData(unsafeData, validators, partial = isDeeplyPartial)
             catch (thrown) {
                 if (!(thrown instanceof Feedback))
                     throw thrown;
-                messages[key] = thrown.message;
-                valid = false;
+                messages.push(`${key}: ${thrown.message}`);
             }
         }
-        if (!valid)
-            throw new ValueFeedbacks(messages, unsafeData);
+        if (messages.length)
+            throw new ValueFeedback(messages.join("\n"), unsafeData);
         if (changed || getDataKeys(unsafeData).length > props.length)
             return safeData;
         return unsafeData;

package/feedback/Feedbacks.d.ts

@@ -1,13 +0,0 @@
-import type { ImmutableDictionary } from "../util/dictionary.js";
-import { Feedback } from "./Feedback.js";
-/** Feedback with a set of named messages. */
-export declare class Feedbacks extends Feedback {
-    /** List of named messages. */
-    readonly messages: ImmutableDictionary<string>;
-    constructor(messages: ImmutableDictionary<string>);
-}
-/** Feedbacks with a known and typed `.value` field. */
-export declare class ValueFeedbacks<T> extends Feedbacks {
-    readonly value: T;
-    constructor(messages: ImmutableDictionary<string>, value: T);
-}

package/feedback/Feedbacks.js

@@ -1,18 +0,0 @@
-import { Feedback } from "./Feedback.js";
-/** Feedback with a set of named messages. */
-export class Feedbacks extends Feedback {
-    /** List of named messages. */
-    messages;
-    constructor(messages) {
-        super(Object.values(messages).join("\n"));
-        this.messages = messages;
-    }
-}
-/** Feedbacks with a known and typed `.value` field. */
-export class ValueFeedbacks extends Feedbacks {
-    value;
-    constructor(messages, value) {
-        super(messages);
-        this.value = value;
-    }
-}

package/util/optional.d.ts

@@ -1,7 +0,0 @@
-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. */
-export declare function getRequired<T>(value: Optional<T>, caller?: AnyCaller): T;
-/** Is a value not optional? */
-export declare function notOptional<T>(value: Optional<T>): value is T;

package/util/optional.js

@@ -1,11 +0,0 @@
-import { RequiredError } from "../error/RequiredError.js";
-/** Get a required value. */
-export function getRequired(value, caller = getRequired) {
-    if (value === null || value === undefined)
-        throw new RequiredError("Value is required", { received: value, caller });
-    return value;
-}
-/** Is a value not optional? */
-export function notOptional(value) {
-    return value !== null && value !== undefined;
-}