shelving 1.93.0 → 1.94.0

package/error/AssertionError.d.ts

@@ -2,8 +2,11 @@
  * Thrown if the program receives a value it didn't expect.
  *
  * @param message Message that explains why the thing happened.
- * @param ...received One or more additional details that appears in a ` (received X, Y, Z)` part of the message.
+ * @param received The value that made the assertion fail.
+ * @param expected The value that made the assertion fail.
  */
 export declare class AssertionError extends Error {
-    constructor(message?: string, ...received: unknown[]);
+    readonly received: unknown;
+    readonly expected: unknown;
+    constructor(message?: string, ...receivedExpected: readonly [received?: unknown, expected?: unknown]);
 }

package/error/AssertionError.js

@@ -1,13 +1,20 @@
-import { debug } from "../util/debug.js";
+import { debug, indent } from "../util/debug.js";
 /**
  * Thrown if the program receives a value it didn't expect.
  *
  * @param message Message that explains why the thing happened.
- * @param ...received One or more additional details that appears in a ` (received X, Y, Z)` part of the message.
+ * @param received The value that made the assertion fail.
+ * @param expected The value that made the assertion fail.
  */
 export class AssertionError extends Error {
-    constructor(message = "Failed assertion", ...received) {
-        super(received.length ? `${message} (received ${received.map(debug).join(", ")})` : message);
+    constructor(message = "Failed assertion", ...receivedExpected) {
+        super(receivedExpected.length >= 2 //
+            ? `${message}\nReceived:${indent(debug(receivedExpected[0]))}\nExpected:${indent(debug(receivedExpected[0]))}`
+            : receivedExpected.length >= 1
+                ? `${message}\nReceived:${indent(debug(receivedExpected[0]))}`
+                : message);
+        this.received = receivedExpected[0];
+        this.expected = receivedExpected[1];
     }
 }
 AssertionError.prototype.name = "AssertionError";

package/feedback/Feedbacks.js

@@ -1,3 +1,4 @@
+import { indent } from "../util/debug.js";
 import { getProp } from "../util/object.js";
 import { mapDictionary } from "../util/transform.js";
 import { Feedback } from "./Feedback.js";
@@ -8,7 +9,8 @@ export class Feedbacks extends Feedback {
         return mapDictionary(this.feedbacks, getProp, "message");
     }
     constructor(feedbacks, value) {
-        super("Invalid format", value);
+        super(`${Object.entries(feedbacks).map(_mapMessages).join("\n")}`, value);
         this.feedbacks = feedbacks;
     }
 }
+const _mapMessages = ([name, { message }]) => `${name}:${indent(message)}`;

package/package.json

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

package/schema/AllowSchema.d.ts

@@ -10,7 +10,7 @@ export type AllowSchemaOptions<K, T> = Omit<SchemaOptions, "value"> & {
 export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
     readonly value: K;
     readonly allow: ImmutableMap<K, T>;
-    constructor({ allow, ...options }: AllowSchemaOptions<K, T>);
+    constructor(options: AllowSchemaOptions<K, T>);
     validate(unsafeValue?: unknown): K;
     /** Iterate over the the allowed options in `[key, value]` format. */
     [Symbol.iterator](): Iterator<Entry<K, T>>;

package/schema/AllowSchema.js

@@ -5,9 +5,9 @@ import { getString } from "../util/string.js";
 import { Schema } from "./Schema.js";
 /** Define a valid value from an allowed set of values. */
 export class AllowSchema extends Schema {
-    constructor({ allow, ...options }) {
+    constructor(options) {
         super(options);
-        this.allow = getMap(allow);
+        this.allow = getMap(options.allow);
         this.value = getFirstItem(this.allow.keys());
     }
     validate(unsafeValue = this.value) {

package/schema/ArraySchema.d.ts

@@ -43,7 +43,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly unique: boolean;
     readonly min: number;
     readonly max: number;
-    constructor({ value, items, unique, min, max, ...options }: ArraySchemaOptions<T>);
+    constructor(options: ArraySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }
 /** Valid array with specifed items. */

package/schema/ArraySchema.js

@@ -30,9 +30,9 @@ import { Schema } from "./Schema.js";
  *  schema.validate(["a", null], schema); // Throws Invalids({ "1": Invalid('Must be a string') });
  */
 export class ArraySchema extends Schema {
-    constructor({ value = [], items, unique = false, min = 0, max = Infinity, ...options }) {
-        super(options);
-        this.value = value;
+    constructor(options) {
+        super({ value: [], ...options });
+        const { items, unique = false, min = 0, max = Infinity } = options;
         this.items = items;
         this.unique = unique;
         this.min = min;

package/schema/BooleanSchema.d.ts

@@ -7,7 +7,7 @@ export type BooleanSchemaOptions = SchemaOptions & {
 /** Define a valid boolean. */
 export declare class BooleanSchema extends Schema<boolean> {
     readonly value: boolean;
-    constructor({ value, ...options }: BooleanSchemaOptions);
+    constructor(options: BooleanSchemaOptions);
     validate(unsafeValue?: unknown): boolean;
 }
 /** Valid boolean. */

package/schema/BooleanSchema.js

@@ -1,9 +1,8 @@
 import { Schema } from "./Schema.js";
 /** Define a valid boolean. */
 export class BooleanSchema extends Schema {
-    constructor({ value = false, ...options }) {
-        super(options);
-        this.value = value;
+    constructor(options) {
+        super({ value: false, ...options });
     }
     validate(unsafeValue = this.value) {
         return !!unsafeValue;

package/schema/ColorSchema.d.ts

@@ -1,3 +1,4 @@
+import type { StringSchemaOptions } from "./StringSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Define a valid color hex string, e.g `#00CCFF`
@@ -14,6 +15,7 @@ export declare class ColorSchema extends StringSchema {
     readonly max = 7;
     readonly multiline = false;
     readonly match: RegExp;
+    constructor(options: StringSchemaOptions);
     sanitize(insaneString: string): string;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */

package/schema/ColorSchema.js

@@ -12,8 +12,8 @@ const R_STRIP = /[^0-9A-F]/g;
  * Colors are limited to 512 characters (this can be changed with `max`), but generally these won't be data: URIs so this is a reasonable limit.
  */
 export class ColorSchema extends StringSchema {
-    constructor() {
-        super(...arguments);
+    constructor(options) {
+        super({ title: "Color", ...options });
         this.type = "color";
         this.min = 1;
         this.max = 7;

package/schema/DataSchema.d.ts

@@ -12,7 +12,7 @@ export type DataSchemaOptions<T extends Data> = SchemaOptions & {
 export declare class DataSchema<T extends Data> extends Schema<T> {
     readonly value: Partial<T>;
     readonly props: Validators<T>;
-    constructor({ value, props, ...options }: DataSchemaOptions<T>);
+    constructor(options: DataSchemaOptions<T>);
     validate(unsafeValue?: unknown): T;
 }
 /** Set of named data schemas. */

package/schema/DataSchema.js

@@ -5,10 +5,9 @@ import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Validate a data object. */
 export class DataSchema extends Schema {
-    constructor({ value = {}, props, ...options }) {
-        super(options);
-        this.props = props;
-        this.value = value;
+    constructor(options) {
+        super({ value: {}, ...options });
+        this.props = options.props;
     }
     validate(unsafeValue = this.value) {
         if (!isData(unsafeValue))

package/schema/DateSchema.d.ts

@@ -12,7 +12,7 @@ export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
     readonly min: Date | null;
     readonly max: Date | null;
-    constructor({ value, min, max, ...options }: DateSchemaOptions);
+    constructor(options: DateSchemaOptions);
     validate(unsafeValue?: unknown): string;
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/DateSchema.js

@@ -4,9 +4,9 @@ import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export class DateSchema extends Schema {
-    constructor({ value = "now", min = null, max = null, ...options }) {
-        super(options);
-        this.value = value;
+    constructor(options) {
+        super({ title: "Date", value: "now", ...options });
+        const { min = null, max = null } = options;
         this.min = getOptionalDate(min);
         this.max = getOptionalDate(max);
     }

package/schema/DictionarySchema.d.ts

@@ -15,7 +15,7 @@ export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>>
     readonly items: Validator<T>;
     readonly min: number;
     readonly max: number;
-    constructor({ value, items, min, max, ...rest }: DictionarySchemaOptions<T>);
+    constructor(options: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }
 /** Valid dictionary object with specifed items. */

package/schema/DictionarySchema.js

@@ -4,10 +4,10 @@ import { validateDictionary } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export class DictionarySchema extends Schema {
-    constructor({ value = {}, items, min = 0, max = Infinity, ...rest }) {
-        super(rest);
+    constructor(options) {
+        super({ value: {}, ...options });
+        const { items, min = 0, max = Infinity } = options;
         this.items = items;
-        this.value = value;
         this.min = min;
         this.max = max;
     }

package/schema/EmailSchema.d.ts

@@ -1,3 +1,4 @@
+import type { StringSchemaOptions } from "./StringSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Define a valid email address.
@@ -22,6 +23,7 @@ export declare class EmailSchema extends StringSchema {
     readonly max = 254;
     readonly match: RegExp;
     readonly multiline = false;
+    constructor(options: StringSchemaOptions);
     sanitize(uncleanString: string): string;
 }
 /** Valid email, e.g. `test@test.com` */

package/schema/EmailSchema.js

@@ -19,8 +19,8 @@ const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
 export class EmailSchema extends StringSchema {
-    constructor() {
-        super(...arguments);
+    constructor(options) {
+        super({ title: "Email", ...options });
         this.type = "email";
         this.min = 1;
         this.max = 254;

package/schema/LinkSchema.d.ts

@@ -17,7 +17,7 @@ export declare class LinkSchema extends StringSchema {
     readonly max = 512;
     readonly schemes: string[];
     readonly hosts: string[] | undefined;
-    constructor({ schemes, hosts, ...rest }: LinkSchemaOptions);
+    constructor(options: LinkSchemaOptions);
     validate(unsafeValue: unknown): string;
 }
 /** Valid link, e.g. `https://www.google.com` */

package/schema/LinkSchema.js

@@ -9,13 +9,13 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to `""` empty string.
  */
 export class LinkSchema extends StringSchema {
-    constructor({ schemes = ["http:", "https:"], hosts, ...rest }) {
-        super(rest);
+    constructor(options) {
+        super({ title: "Link", ...options });
         this.type = "url";
         this.min = 1;
         this.max = 512;
-        this.schemes = schemes;
-        this.hosts = hosts;
+        this.schemes = options.schemes || ["http:", "https:"];
+        this.hosts = options.hosts;
     }
     // Override to clean the URL using the builtin `URL` class and check the schemes and hosts against the whitelists.
     validate(unsafeValue) {

package/schema/NumberSchema.d.ts

@@ -13,7 +13,7 @@ export declare class NumberSchema extends Schema<number> {
     readonly min: number;
     readonly max: number;
     readonly step: number | null;
-    constructor({ value, min, max, step, ...rest }: NumberSchemaOptions);
+    constructor(options: NumberSchemaOptions);
     validate(unsafeValue?: unknown): number;
 }
 /** Valid number, e.g. `2048.12345` or `0` zero. */

package/schema/NumberSchema.js

@@ -4,9 +4,9 @@ import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Schema that defines a valid number. */
 export class NumberSchema extends Schema {
-    constructor({ value = 0, min = -Infinity, max = Infinity, step = null, ...rest }) {
-        super(rest);
-        this.value = value;
+    constructor(options) {
+        super({ title: "Number", value: 0, ...options });
+        const { min = -Infinity, max = Infinity, step = null } = options;
         this.min = min;
         this.max = max;
         this.step = step;
@@ -40,6 +40,6 @@ export const NON_POSITIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_
 /** Valid optional integer number, e.g. `2048` or `0` zero, or `null` */
 export const OPTIONAL_INTEGER = OPTIONAL(INTEGER);
 /** Valid Unix timestamp (including milliseconds). */
-export const TIMESTAMP = INTEGER;
+export const TIMESTAMP = new NumberSchema({ title: "Timestamp", step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER, value: 0 });
 /** Valid Unix timestamp (including milliseconds). */
 export const OPTIONAL_TIMESTAMP = OPTIONAL_INTEGER;

package/schema/OptionalSchema.d.ts

@@ -3,7 +3,7 @@ import { ThroughSchema } from "./ThroughSchema.js";
 /** Validate a value of a specific type or `null`. */
 export declare class OptionalSchema<T> extends ThroughSchema<T | null> {
     readonly value: T | null;
-    constructor({ value, ...rest }: ConstructorParameters<typeof Schema>[0] & {
+    constructor(options: ConstructorParameters<typeof Schema>[0] & {
         source: Schema<T>;
         value?: T | null;
     });

package/schema/OptionalSchema.js

@@ -1,10 +1,9 @@
 import { ThroughSchema } from "./ThroughSchema.js";
 /** Validate a value of a specific type or `null`. */
 export class OptionalSchema extends ThroughSchema {
-    constructor({ value = null, ...rest }) {
-        super(rest);
+    constructor(options) {
+        super({ value: null, ...options });
         this.value = null;
-        this.value = value;
     }
     validate(unsafeValue = this.value) {
         if (unsafeValue === null || unsafeValue === undefined || unsafeValue === "" || Number.isNaN(unsafeValue))

package/schema/PhoneSchema.d.ts

@@ -1,3 +1,4 @@
+import type { StringSchemaOptions } from "./StringSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid phone number.
@@ -9,6 +10,7 @@ export declare class PhoneSchema extends StringSchema {
     readonly match: RegExp;
     readonly min = 1;
     readonly max: number;
+    constructor(options: StringSchemaOptions);
     sanitize(insaneString: string): string;
 }
 /** Valid phone number, e.g. `+441234567890` */

package/schema/PhoneSchema.js

@@ -10,8 +10,8 @@ const R_MATCH = /^\+[1-9][0-9]{0,2}[0-9]{5,12}$/;
  * - Falsy values are converted to `""` empty string.
  */
 export class PhoneSchema extends StringSchema {
-    constructor() {
-        super(...arguments);
+    constructor(options) {
+        super({ title: "Phone", ...options });
         this.type = "tel";
         this.match = R_MATCH;
         this.min = 1;

package/schema/Schema.d.ts

@@ -2,11 +2,11 @@ import type { Validatable } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
 export type SchemaOptions = {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title?: string | undefined;
+    readonly title?: string;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description?: string | undefined;
+    readonly description?: string;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder?: string | undefined;
+    readonly placeholder?: string;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value?: unknown;
 };
@@ -17,11 +17,11 @@ export type SchemaOptions = {
  */
 export declare abstract class Schema<T extends unknown = unknown> implements Validatable<T> {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title: string | undefined;
+    readonly title: string;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description: string | undefined;
+    readonly description: string;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder: string | undefined;
+    readonly placeholder: string;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value: unknown;
     constructor({ title, description, placeholder, value }: SchemaOptions);

package/schema/Schema.js

@@ -4,7 +4,7 @@
  * - `validate()` returns `Invalid` if value was not valid.
  */
 export class Schema {
-    constructor({ title, description, placeholder, value }) {
+    constructor({ title = "", description = "", placeholder = "", value }) {
         this.title = title;
         this.description = description;
         this.placeholder = placeholder;

package/schema/StringSchema.d.ts

@@ -42,7 +42,7 @@ export declare class StringSchema extends Schema<string> {
     readonly match: RegExp | undefined;
     readonly sanitizer: Sanitizer | undefined;
     readonly multiline: boolean;
-    constructor({ value, type, min, max, match, sanitizer, multiline, ...rest }: StringSchemaOptions);
+    constructor(options: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;
     /**
      * Clean a string by removing characters that aren't digits.
@@ -55,3 +55,13 @@ export declare class StringSchema extends Schema<string> {
 export declare const STRING: StringSchema;
 /** Valid string, `Hello there!`, with more than one character. */
 export declare const REQUIRED_STRING: StringSchema;
+/** Title string, e.g. `Title of something` */
+export declare const TITLE: StringSchema;
+/** Optional name string, e.g. `Title of something` or `null` */
+export declare const OPTIONAL_TITLE: import("./OptionalSchema.js").OptionalSchema<string>;
+/** Name string, e.g. `Name of Something` */
+export declare const NAME: StringSchema;
+/** Optional name string, e.g. `Name of Something` or `null` */
+export declare const OPTIONAL_NAME: import("./OptionalSchema.js").OptionalSchema<string>;
+/** Password string. */
+export declare const PASSWORD: StringSchema;

package/schema/StringSchema.js

@@ -1,5 +1,6 @@
 import { Feedback } from "../feedback/Feedback.js";
 import { sanitizeLines, sanitizeString } from "../util/string.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /**
  * Schema that defines a valid string.
@@ -22,10 +23,10 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
-    constructor({ value = "", type = "text", min = 0, max = Infinity, match, sanitizer, multiline = false, ...rest }) {
-        super(rest);
+    constructor(options) {
+        super({ value: "", ...options });
+        const { type = "text", min = 0, max = Infinity, match, sanitizer, multiline = false } = options;
         this.type = type;
-        this.value = value;
         this.min = min;
         this.max = max;
         this.match = match;
@@ -58,3 +59,13 @@ export class StringSchema extends Schema {
 export const STRING = new StringSchema({});
 /** Valid string, `Hello there!`, with more than one character. */
 export const REQUIRED_STRING = new StringSchema({ min: 1 });
+/** Title string, e.g. `Title of something` */
+export const TITLE = new StringSchema({});
+/** Optional name string, e.g. `Title of something` or `null` */
+export const OPTIONAL_TITLE = OPTIONAL(TITLE);
+/** Name string, e.g. `Name of Something` */
+export const NAME = new StringSchema({ title: "Name" });
+/** Optional name string, e.g. `Name of Something` or `null` */
+export const OPTIONAL_NAME = OPTIONAL(NAME);
+/** Password string. */
+export const PASSWORD = new StringSchema({ title: "Password", min: 6, type: "password" });

package/schema/ThroughSchema.d.ts

@@ -8,6 +8,6 @@ export type ThroughSchemaOptions<T> = SchemaOptions & {
 /** Schema that passes through to a source schema. */
 export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Schema<T>> {
     readonly source: Schema<T>;
-    constructor({ source, ...props }: ThroughSchemaOptions<T>);
+    constructor(options: ThroughSchemaOptions<T>);
     validate(unsafeValue: unknown): T;
 }

package/schema/ThroughSchema.js

@@ -1,9 +1,9 @@
 import { Schema } from "./Schema.js";
 /** Schema that passes through to a source schema. */
 export class ThroughSchema extends Schema {
-    constructor({ source, ...props }) {
-        super({ ...source, ...props });
-        this.source = source;
+    constructor(options) {
+        super(options);
+        this.source = options.source;
     }
     validate(unsafeValue) {
         return this.source.validate(unsafeValue);

package/schema/TimeSchema.d.ts

@@ -19,7 +19,7 @@ export declare class TimeSchema extends Schema<string> {
      * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
      */
     readonly step: number | null;
-    constructor({ value, min, max, step, ...options }: TimeSchemaOptions);
+    constructor(options: TimeSchemaOptions);
     validate(unsafeValue?: unknown): string;
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/TimeSchema.js

@@ -5,9 +5,9 @@ import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export class TimeSchema extends Schema {
-    constructor({ value = "now", min = null, max = null, step = 60, ...options }) {
-        super(options);
-        this.value = value;
+    constructor(options) {
+        super({ title: "Time", value: "now", ...options });
+        const { min = null, max = null, step = 60 } = options;
         this.min = getOptionalTime(min);
         this.max = getOptionalTime(max);
         this.step = step;

package/util/assert.d.ts

@@ -1,5 +1,5 @@
 /** Assert a boolean condition is true. */
-export declare function assert(condition: unknown, ...received: unknown[]): asserts condition;
+export declare function assert(condition: unknown, ...receivedExpected: [received?: unknown, expected?: unknown]): asserts condition;
 /** Assert two values are equal. */
 export declare function assertEqual<T>(left: T | unknown, right: T): asserts left is T;
 /** Assert two values are equal. */

package/util/assert.js

@@ -1,8 +1,8 @@
 import { AssertionError } from "../error/AssertionError.js";
 /** Assert a boolean condition is true. */
-export function assert(condition, ...received) {
+export function assert(condition, ...receivedExpected) {
     if (!condition)
-        throw new AssertionError(`Must assert`, ...received);
+        throw new AssertionError(`Must assert`, ...receivedExpected);
 }
 /** Assert two values are equal. */
 export function assertEqual(left, right) {

package/util/debug.d.ts

@@ -14,3 +14,5 @@ export declare function debugSet(value: ImmutableSet, depth?: number): string;
 export declare function debugMap(value: ImmutableMap, depth?: number): string;
 /** Debug an object. */
 export declare function debugObject(value: object, depth?: number): string;
+/** If a string is multiline, push it onto the next line and prepend a tab to each line.. */
+export declare function indent(str: string): string;

package/util/debug.js

@@ -75,3 +75,8 @@ export function debugObject(value, depth = 1) {
         : "";
     return `${name ? `${name} ` : ""}${entries ? `{\n\t${entries}\n}` : "{}"}`;
 }
+/** If a string is multiline, push it onto the next line and prepend a tab to each line.. */
+export function indent(str) {
+    const lines = str.split("\n");
+    return lines.length > 1 ? `\n${lines.join("\n\t")}` : ` ${str}`;
+}

package/util/validate.d.ts

@@ -31,6 +31,10 @@ export type ValidatorsType<T> = {
 };
 /** Validate an unknown value with a validator. */
 export declare function validate<T>(unsafeValue: unknown, validator: Validator<T>): T;
+/** Get value that validates against a given `Validator`, or throw `ValidationError` */
+export declare function getValid<T>(unsafeValue: unknown, validator: Validator<T>): T;
+/** Assert that a value validates against a given `Validator`, or throw `ValidationError` */
+export declare function assertValid<T>(unsafeValue: unknown, validator: Validator<T>): asserts unsafeValue is T;
 /**
  * Validate an iterable set of items with a validator.
  *

package/util/validate.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { Feedbacks } from "../feedback/Feedbacks.js";
 import { getLastItem, isArray } from "./array.js";
@@ -8,6 +9,21 @@ import { isIterable } from "./iterate.js";
 export function validate(unsafeValue, validator) {
     return typeof validator === "function" ? validator(unsafeValue) : validator.validate(unsafeValue);
 }
+/** Get value that validates against a given `Validator`, or throw `ValidationError` */
+export function getValid(unsafeValue, validator) {
+    try {
+        return validate(unsafeValue, validator);
+    }
+    catch (thrown) {
+        if (thrown instanceof Feedback)
+            throw new ValidationError("Must validate", thrown);
+        throw thrown;
+    }
+}
+/** Assert that a value validates against a given `Validator`, or throw `ValidationError` */
+export function assertValid(unsafeValue, validator) {
+    getValid(unsafeValue, validator);
+}
 /**
  * Validate an iterable set of items with a validator.
  *