shelving 1.68.2 → 1.68.3

package/update/ObjectUpdate.d.ts

@@ -1,21 +1,21 @@
 import type { Entry } from "../util/entry.js";
-import type { ImmutableArray } from "../util/array.js";
 import { Nullish } from "../util/null.js";
 import { ImmutableObject } from "../util/object.js";
+import { Validator } from "../util/validate.js";
 import { Update } from "./Update.js";
+import { Delete } from "./Delete.js";
 /** Set of named transforms for the entries of a map-like object. */
-export declare type EntryUpdates<T> = ImmutableObject<T | Update<T>>;
+export declare type EntryUpdates<T> = ImmutableObject<T | Update<T> | Delete>;
 /** Update that can be applied to a map-like object to add/remove/update its entries. */
-export declare class ObjectUpdate<T> extends Update<ImmutableObject<T>> implements Iterable<Entry<T | Update<T> | undefined>> {
+export declare class ObjectUpdate<T> extends Update<ImmutableObject<T>> implements Iterable<Entry<T | Update<T> | Delete>> {
     /** Return an object update with a specific entry marked for update. */
-    static with<X>(key: Nullish<string>, value: X | Update<X>): ObjectUpdate<X>;
+    static with<X>(key: Nullish<string>, value: X | Update<X> | Delete): ObjectUpdate<X>;
     /** Return an object update with a specific entry marked for deletion. */
     static without<X>(key: Nullish<string>): ObjectUpdate<X>;
     readonly updates: EntryUpdates<T>;
-    readonly deletes: ImmutableArray<string>;
-    constructor(updates?: EntryUpdates<T>, deletes?: ImmutableArray<string>);
-    /** Transform an object with this object transform. */
+    constructor(updates?: EntryUpdates<T>);
     transform(obj?: ImmutableObject<T>): ImmutableObject<T>;
+    validate(validator: Validator<ImmutableObject<T>>): this;
     /** Return an object update with a specific entry marked for update. */
     with(key: Nullish<string>, value: T | Update<T>): this;
     /** Return an object update with a specific entry marked for deletion. */
@@ -25,5 +25,5 @@ export declare class ObjectUpdate<T> extends Update<ImmutableObject<T>> implemen
      * - Updates are yielded first, then deletes.
      * - Entries whose value is `undefined` indicate deletion.
      */
-    [Symbol.iterator](): Iterator<Entry<T | Update<T> | undefined>, void>;
+    [Symbol.iterator](): Iterator<Entry<T | Update<T> | Delete>, void>;
 }

package/update/ObjectUpdate.js

@@ -1,12 +1,14 @@
 import { isNullish } from "../util/null.js";
 import { transform } from "../util/transform.js";
+import { ObjectSchema } from "../schema/ObjectSchema.js";
+import { validate } from "../util/validate.js";
 import { Update } from "./Update.js";
+import { Delete, DELETE } from "./Delete.js";
 /** Update that can be applied to a map-like object to add/remove/update its entries. */
 export class ObjectUpdate extends Update {
-    constructor(updates = {}, deletes = []) {
+    constructor(updates = {}) {
         super();
         this.updates = updates;
-        this.deletes = deletes;
     }
     /** Return an object update with a specific entry marked for update. */
     static with(key, value) {
@@ -14,23 +16,39 @@ export class ObjectUpdate extends Update {
     }
     /** Return an object update with a specific entry marked for deletion. */
     static without(key) {
-        return new ObjectUpdate({}, isNullish(key) ? [] : [key]);
+        return new ObjectUpdate(isNullish(key) ? {} : { [key]: DELETE });
     }
-    /** Transform an object with this object transform. */
     transform(obj = {}) {
-        return Object.fromEntries(_getUpdatedEntries(obj, this.updates, this.deletes));
+        return Object.fromEntries(_transformEntries(obj, this.updates));
+    }
+    validate(validator) {
+        if (!(validator instanceof ObjectSchema))
+            return super.validate(validator);
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            updates: Object.fromEntries(_validateUpdates(this.updates, validator.items)),
+        };
     }
     /** Return an object update with a specific entry marked for update. */
     with(key, value) {
         if (isNullish(key))
             return this;
-        return { __proto__: Object.getPrototypeOf(this), ...this, sets: { ...this.updates, [key]: value } };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            updates: { ...this.updates, [key]: value },
+        };
     }
     /** Return an object update with a specific entry marked for deletion. */
     without(key) {
         if (isNullish(key))
             return this;
-        return { __proto__: Object.getPrototypeOf(this), ...this, deletes: [...this.deletes, key] };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            updates: { ...this.updates, [key]: DELETE },
+        };
     }
     /**
      * Iterate over the changes in this object.
@@ -40,17 +58,19 @@ export class ObjectUpdate extends Update {
     *[Symbol.iterator]() {
         for (const entry of Object.entries(this.updates))
             yield entry;
-        for (const key of this.deletes)
-            yield [key, undefined];
     }
 }
-function* _getUpdatedEntries(obj, updates, deletes) {
-    // Yield the entries from the original object (if they're not in deletes).
-    for (const [k, v] of Object.entries(obj))
-        if (!deletes.includes(k))
-            yield [k, v];
-    // Yield the transformed entries from the updates object (if they're not in deletes).
-    for (const [k, v] of Object.entries(updates))
-        if (!deletes.includes(k))
-            yield [k, transform(obj[k], v)];
+function* _transformEntries(obj, updates) {
+    for (const [k, v] of Object.entries({ ...obj, ...updates })) {
+        if (v instanceof Delete)
+            continue;
+        yield [k, transform(obj[k], v)];
+    }
+}
+function* _validateUpdates(updates, validator) {
+    for (const [k, v] of Object.entries(updates)) {
+        if (v instanceof Delete)
+            continue;
+        yield [k, v instanceof Update ? v.validate(validator) : validate(v, validator)];
+    }
 }

package/update/Update.d.ts

@@ -1,9 +1,12 @@
 import type { Transformable } from "../util/transform.js";
+import { Validator, Validatable } from "../util/validate.js";
 /**
  * An object that represents an update of an existing value.
  * - Implements `Transformable` for applying that update with its `transform()` method.
  */
-export declare abstract class Update<T> implements Transformable<T, T> {
+export declare abstract class Update<T> implements Transformable<T, T>, Validatable<Update<T>> {
     /** Apply this update to a value. */
     abstract transform(value?: unknown): T;
+    /** Validate this update's values against a validator. */
+    validate(validator: Validator<T>): this;
 }

package/update/Update.js

@@ -1,6 +1,12 @@
+import { validate } from "../util/validate.js";
 /**
  * An object that represents an update of an existing value.
  * - Implements `Transformable` for applying that update with its `transform()` method.
  */
 export class Update {
+    /** Validate this update's values against a validator. */
+    validate(validator) {
+        validate(this.transform(), validator);
+        return this;
+    }
 }

package/update/hydrations.js

@@ -1,10 +1,12 @@
+import { Delete } from "./Delete.js";
+import { Increment } from "./Increment.js";
 import { ArrayUpdate } from "./ArrayUpdate.js";
 import { ObjectUpdate } from "./ObjectUpdate.js";
-import { Increment } from "./Increment.js";
 import { DataUpdate } from "./DataUpdate.js";
 /** Set of hydrations for all transform classes. */
 export const TRANSFORM_HYDRATIONS = {
     Increment,
+    Delete,
     ArrayUpdate,
     ObjectUpdate,
     DataUpdate,

package/update/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./Update.js";
+export * from "./Delete.js";
 export * from "./Increment.js";
-export * from "./DataUpdate.js";
 export * from "./ArrayUpdate.js";
 export * from "./ObjectUpdate.js";
+export * from "./DataUpdate.js";
 export * from "./hydrations.js";
-export * from "./util.js";

package/update/index.js

@@ -1,7 +1,7 @@
 export * from "./Update.js";
+export * from "./Delete.js";
 export * from "./Increment.js";
-export * from "./DataUpdate.js";
 export * from "./ArrayUpdate.js";
 export * from "./ObjectUpdate.js";
+export * from "./DataUpdate.js";
 export * from "./hydrations.js";
-export * from "./util.js";

package/util/color.d.ts

@@ -18,12 +18,16 @@ export declare class Color {
     get luminance(): number;
     toString(): string;
 }
+/** Is an unknown value a `Color` instance. */
+export declare const isColor: (v: Color | unknown) => v is Color;
+/** Assert that an unknown value is a `Color` instance. */
+export declare function assertColor(v: Color | unknown): asserts v is Color;
 /** Convert a number or string to a color channel number that's within bounds (strings like `0a` or `ff` are parsed as hexadecimal). */
 export declare function getColorChannel(channel: number | string): number;
 /** Convert a possible color to a `Color` instance or `null` */
-export declare function toColor(color: unknown): Color | null;
+export declare function getOptionalColor(possibleColor: unknown): Color | null;
 /** Convert a possible color to a `Color` instance */
-export declare function getColor(input: PossibleColor): Color;
+export declare function getColor(possibleColor: PossibleColor): Color;
 /** Is a color light? */
 export declare const isLight: (input: PossibleColor) => boolean;
 /** Is a color dark? */

package/util/color.js

@@ -38,6 +38,13 @@ export class Color {
 }
 /** Convert number channel to a hex string (results will be unpredictable if number is outside 0-MAX). */
 const _hex = (channel) => channel.toString(16).padStart(2, "00");
+/** Is an unknown value a `Color` instance. */
+export const isColor = (v) => v instanceof Color;
+/** Assert that an unknown value is a `Color` instance. */
+export function assertColor(v) {
+    if (!isColor(v))
+        throw new AssertionError("Invalid color", v);
+}
 /** Convert a number or string to a color channel number that's within bounds (strings like `0a` or `ff` are parsed as hexadecimal). */
 export function getColorChannel(channel) {
     const num = typeof channel === "string" ? parseInt(channel.padStart(2, "00"), 16) : Math.round(channel);
@@ -46,25 +53,24 @@ export function getColorChannel(channel) {
     throw new AssertionError("Invalid color channel", channel);
 }
 /** Convert a possible color to a `Color` instance or `null` */
-export function toColor(color) {
-    if (color instanceof Color)
-        return color;
-    if (typeof color === "string") {
-        const hex3 = color.match(HEX3);
+export function getOptionalColor(possibleColor) {
+    if (possibleColor instanceof Color)
+        return possibleColor;
+    if (typeof possibleColor === "string") {
+        const hex3 = possibleColor.match(HEX3);
         if (hex3)
             return new Color(hex3[1], hex3[2], hex3[3]);
-        const hex6 = color.match(HEX6);
+        const hex6 = possibleColor.match(HEX6);
         if (hex6)
             return new Color(hex6[1], hex6[2], hex6[3], hex6[4]);
     }
     return null;
 }
 /** Convert a possible color to a `Color` instance */
-export function getColor(input) {
-    const color = toColor(input);
-    if (color)
-        return color;
-    throw new AssertionError("Invalid color", color);
+export function getColor(possibleColor) {
+    const color = getOptionalColor(possibleColor);
+    assertColor(color);
+    return color;
 }
 /** Is a color light? */
 export const isLight = (input) => getColor(input).luminance > DARK;

package/util/constants.d.ts

@@ -1,7 +1,5 @@
 /** The SAME symbol indicates sameness. */
 export declare const SAME: unique symbol;
-/** The SKIP symbol indicates something that should be skipped. */
-export declare const SKIP: unique symbol;
 /** The LOADING symbol indicates loading. */
 export declare const LOADING: unique symbol;
 /** The DONE symbol indicates doneness. */

package/util/constants.js

@@ -1,7 +1,5 @@
 /** The SAME symbol indicates sameness. */
 export const SAME = Symbol("shelving/SAME");
-/** The SKIP symbol indicates something that should be skipped. */
-export const SKIP = Symbol("shelving/SKIP");
 /** The LOADING symbol indicates loading. */
 export const LOADING = Symbol("shelving/LOADING");
 /** The DONE symbol indicates doneness. */

package/util/data.d.ts

@@ -26,8 +26,8 @@ export declare type OptionalEntity<T extends Data = Data> = Entity<T> | null;
 /** Is an unknown value a data object? */
 export declare const isData: <T extends Data>(value: unknown) => value is T;
 /** Turn a data object into an array of entries (if it isn't one already). */
-export declare function toProps<T extends Data>(data: T): ImmutableArray<Prop<T>>;
-export declare function toProps<T extends Data>(data: Partial<T>): ImmutableArray<Prop<T>>;
+export declare function getProps<T extends Data>(data: T): ImmutableArray<Prop<T>>;
+export declare function getProps<T extends Data>(data: Partial<T>): ImmutableArray<Prop<T>>;
 /** Get the data of a result (returns data or throws `RequiredError` if value is `null` or `undefined`). */
 export declare function getData<T extends Data>(result: OptionalData<T>): T;
 /**
@@ -53,10 +53,10 @@ export declare function getProp<T extends Data, K1 extends keyof T>(obj: T, k1:
  * @param k3 The sub-sub-key of the prop in the object to get.
  * @param k4 The sub-sub-sub-key of the prop in the object to get.
  */
-export declare function getProps<T extends Data, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(items: Iterable<T>, k1: K1, k2: K2, k3: K3, k4: K4): Iterable<T[K1][K2][K3][K4]>;
-export declare function getProps<T extends Data, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(items: Iterable<T>, k1: K1, k2: K2, k3: K3): Iterable<T[K1][K2][K3]>;
-export declare function getProps<T extends Data, K1 extends keyof T, K2 extends keyof T[K1]>(items: Iterable<T>, k1: K1, k2: K2): Iterable<T[K1][K2]>;
-export declare function getProps<T extends Data, K1 extends keyof T>(items: Iterable<T>, k1: K1): Iterable<T[K1]>;
+export declare function yieldProps<T extends Data, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(items: Iterable<T>, k1: K1, k2: K2, k3: K3, k4: K4): Iterable<T[K1][K2][K3][K4]>;
+export declare function yieldProps<T extends Data, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(items: Iterable<T>, k1: K1, k2: K2, k3: K3): Iterable<T[K1][K2][K3]>;
+export declare function yieldProps<T extends Data, K1 extends keyof T, K2 extends keyof T[K1]>(items: Iterable<T>, k1: K1, k2: K2): Iterable<T[K1][K2]>;
+export declare function yieldProps<T extends Data, K1 extends keyof T>(items: Iterable<T>, k1: K1): Iterable<T[K1]>;
 /** Get the ID of an entity. */
 export declare const getID: <T extends Data>({ id }: Entity<T>) => string;
 /** Yield the IDs of an iterable set of entities. */

package/util/data.js

@@ -1,7 +1,7 @@
 import { RequiredError } from "../error/RequiredError.js";
 /** Is an unknown value a data object? */
 export const isData = (value) => typeof value === "object" && value !== null;
-export function toProps(data) {
+export function getProps(data) {
     return Object.entries(data);
 }
 /** Get the data of a result (returns data or throws `RequiredError` if value is `null` or `undefined`). */
@@ -13,7 +13,7 @@ export function getData(result) {
 export function getProp(data, k1, k2, k3, k4) {
     return !k2 ? data[k1] : !k3 ? data[k1][k2] : !k4 ? data[k1][k2][k3] : data[k1][k2][k3][k4];
 }
-export function* getProps(items, k1, k2, k3, k4) {
+export function* yieldProps(items, k1, k2, k3, k4) {
     for (const data of items)
         yield !k2 ? data[k1] : !k3 ? data[k1][k2] : !k4 ? data[k1][k2][k3] : data[k1][k2][k3][k4];
 }
@@ -65,6 +65,6 @@ export function setProp(data, key, value) {
  * @param props An object containing new props to set on the object.
  */
 export function setProps(data, props) {
-    for (const [k, v] of toProps(props))
+    for (const [k, v] of getProps(props))
         data[k] = v;
 }

package/util/date.d.ts

@@ -21,16 +21,16 @@ export declare type PossibleOptionalDate = Date | number | string | null | (() =
  * - Numbers are return the corresponding date (using `new Date(number)`, i.e. milliseconds since 01/01/1970).
  * - Anything else is converted to `null`
  *
- * @param target Any value that we want to parse as a valid date.
+ * @param possibleDate Any value that we want to parse as a valid date.
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
-export declare function toDate(target: unknown): Date | null;
+export declare function getOptionalDate(possibleDate: unknown): Date | null;
 /** Convert a possible date to a `Date` instance, or throw `AssertionError` if it couldn't be converted. */
-export declare function getDate(target?: PossibleDate): Date;
+export declare function getDate(possibleDate?: PossibleDate): Date;
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `null` if it couldn't be converted. */
-export declare function toYmd(target: unknown): string | null;
+export declare function getOptionalYmd(possibleDate: unknown): string | null;
 /** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
-export declare function getYmd(target?: PossibleDate): string;
+export declare function getYmd(possibleDate?: PossibleDate): string;
 /** List of day-of-week strings. */
 export declare const days: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 /** Type listing day-of-week strings. */

package/util/date.js

@@ -22,42 +22,42 @@ export function assertDate(v) {
  * - Numbers are return the corresponding date (using `new Date(number)`, i.e. milliseconds since 01/01/1970).
  * - Anything else is converted to `null`
  *
- * @param target Any value that we want to parse as a valid date.
+ * @param possibleDate Any value that we want to parse as a valid date.
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
-export function toDate(target) {
-    if (target === undefined || target === "now")
+export function getOptionalDate(possibleDate) {
+    if (possibleDate === undefined || possibleDate === "now")
         return new Date();
-    if (target instanceof Date)
-        return !Number.isNaN(target.getTime()) ? target : null;
-    if (target === "today")
+    if (possibleDate instanceof Date)
+        return !Number.isNaN(possibleDate.getTime()) ? possibleDate : null;
+    if (possibleDate === "today")
         return getMidnight();
-    if (target === "tomorrow")
+    if (possibleDate === "tomorrow")
         return addDays(1, getMidnight());
-    if (target === "yesterday")
+    if (possibleDate === "yesterday")
         return addDays(-1, getMidnight());
-    if (target === null || target === "")
+    if (possibleDate === null || possibleDate === "")
         return null; // We know empty string is always an invalid date.
-    if (typeof target === "string" || typeof target === "number")
-        return toDate(new Date(target));
-    if (typeof target === "function")
-        return toDate(target());
+    if (typeof possibleDate === "string" || typeof possibleDate === "number")
+        return getOptionalDate(new Date(possibleDate));
+    if (typeof possibleDate === "function")
+        return getOptionalDate(possibleDate());
     return null;
 }
 /** Convert a possible date to a `Date` instance, or throw `AssertionError` if it couldn't be converted. */
-export function getDate(target = "now") {
-    const date = toDate(target);
+export function getDate(possibleDate = "now") {
+    const date = getOptionalDate(possibleDate);
     assertDate(date);
     return date;
 }
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `null` if it couldn't be converted. */
-export function toYmd(target) {
-    const date = toDate(target);
+export function getOptionalYmd(possibleDate) {
+    const date = getOptionalDate(possibleDate);
     return date ? date.toISOString().slice(0, 10) : null;
 }
 /** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
-export function getYmd(target = "now") {
-    return getDate(target).toISOString().slice(0, 10);
+export function getYmd(possibleDate = "now") {
+    return getDate(possibleDate).toISOString().slice(0, 10);
 }
 /** List of day-of-week strings. */
 export const days = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

package/util/number.d.ts

@@ -12,16 +12,16 @@ export declare function assertMax(v: number | unknown, max: number): asserts v i
 /** Assert that a value is a number less than. */
 export declare function assertMin(v: number | unknown, min: number): asserts v is number;
 /**
- * Convert an unknown value to a number or `null`
+ * Convert an unknown value to a finite number or `null`
  * - Note: numbers can be non-finite numbers like `NaN` or `Infinity`. These are detected and will always return `null`
  *
  * Conversion rules:
- * - Numbers (except `NaN`) return numbers.
+ * - Numbers (except `NaN` and `+Infinity` and `-Infinity`) return numbers.
  * - Strings are parsed as numbers.
  * - Dates return their milliseconds (e.g. `date.getTime()`)
  * - Everything else returns `null`
  */
-export declare function toNumber(value: unknown): number | null;
+export declare function getOptionalNumber(value: unknown): number | null;
 /**
  * Assertively convert an unknown value to a finite number.
  * @throws `AssertionError` if the value cannot be converted.

package/util/number.js

@@ -26,20 +26,20 @@ export function assertMin(v, min) {
         throw new AssertionError(`Must be number with minimum ${min}`, v);
 }
 /**
- * Convert an unknown value to a number or `null`
+ * Convert an unknown value to a finite number or `null`
  * - Note: numbers can be non-finite numbers like `NaN` or `Infinity`. These are detected and will always return `null`
  *
  * Conversion rules:
- * - Numbers (except `NaN`) return numbers.
+ * - Numbers (except `NaN` and `+Infinity` and `-Infinity`) return numbers.
  * - Strings are parsed as numbers.
  * - Dates return their milliseconds (e.g. `date.getTime()`)
  * - Everything else returns `null`
  */
-export function toNumber(value) {
+export function getOptionalNumber(value) {
     if (typeof value === "number")
         return !Number.isFinite(value) ? null : value === 0 ? 0 : value;
     else if (typeof value === "string")
-        return toNumber(parseFloat(value.replace(NUMERIC, "")));
+        return getOptionalNumber(parseFloat(value.replace(NUMERIC, "")));
     else if (value instanceof Date)
         return value.getTime();
     return null;
@@ -50,7 +50,7 @@ const NUMERIC = /[^0-9-.]/g;
  * @throws `AssertionError` if the value cannot be converted.
  */
 export function getNumber(value) {
-    const num = toNumber(value);
+    const num = getOptionalNumber(value);
     assertNumber(num);
     return num;
 }

package/util/search.js

@@ -1,4 +1,4 @@
-import { toWords, normalizeString } from "./string.js";
+import { getWords, normalizeString } from "./string.js";
 // Regular expressions.
 export const MATCH_SPACE = /\s+/; // Match the first run of one or more space characters.
 export const MATCH_SPACES = /\s+/g; // Match all runs of one or more space characters.
@@ -34,7 +34,7 @@ export const getWrapRegExp = (chars, middle = MATCH_WORDS.source) => new RegExp(
  * - Unquoted words match partially (starting with a word boundary).
  * - Quoted phrases match fully (starting and ending with a word boundary).
  */
-export const toWordRegExps = (query) => toWords(query).map(toWordRegExp);
+export const toWordRegExps = (query) => getWords(query).map(toWordRegExp);
 /** Convert a string to a regular expression matching the start of a word boundary. */
 export const toWordRegExp = (word) => new RegExp(`\\b${escapeRegExp(normalizeString(word))}`, "i");
 /**

package/util/string.d.ts

@@ -15,7 +15,7 @@ export declare function assertString(value: unknown): asserts value is string;
  * - Primitives return `true`, `false`, `null`, `undefined`
  * - Numbers return the stringified number.
  */
-export declare function toString(value: unknown): string;
+export declare function getString(value: unknown): string;
 /**
  * Convert an unknown value into a title string for user-facing use.
  * - Strings return the string.
@@ -29,7 +29,7 @@ export declare function toString(value: unknown): string;
  * - Falsy values like `null` and `undefined` return `"None"`
  * - Everything else returns `"Unknown"`
  */
-export declare function toTitle(value: unknown): string;
+export declare function getTitle(value: unknown): string;
 /** Concatenate an iterable set of strings together. */
 export declare const joinStrings: (strs: Iterable<string>, joiner?: string) => string;
 /**
@@ -65,7 +65,7 @@ export declare const normalizeString: (str: string) => string;
  * - Remove any characters not in the range `[a-z0-9-]`
  * - Change all spaces/separators/hyphens/dashes/underscores to `-` single hyphen.
  */
-export declare const toSlug: (str: string) => string;
+export declare const getSlug: (str: string) => string;
 /**
  * Split a string into its separate words.
  * - Words enclosed "in quotes" are a single word.
@@ -74,7 +74,7 @@ export declare const toSlug: (str: string) => string;
  * @param str The input string, e.g. `yellow dog   "Golden Retriever"`
  * @returns Array of the found words, e.g. `["yellow", "dog", "Golden Retriever"
  */
-export declare const toWords: (str: string) => ImmutableArray<string>;
+export declare const getWords: (str: string) => ImmutableArray<string>;
 /** Find and iterate over the words in a string. */
 export declare function yieldWords(value: string): Generator<string, void, void>;
 /** Is the first character of a string an uppercase letter? */

package/util/string.js

@@ -23,7 +23,7 @@ export function assertString(value) {
  * - Primitives return `true`, `false`, `null`, `undefined`
  * - Numbers return the stringified number.
  */
-export function toString(value) {
+export function getString(value) {
     if (typeof value === "string")
         return value;
     if (typeof value === "number")
@@ -49,7 +49,7 @@ export function toString(value) {
  * - Falsy values like `null` and `undefined` return `"None"`
  * - Everything else returns `"Unknown"`
  */
-export function toTitle(value) {
+export function getTitle(value) {
     if (typeof value === "string")
         return value ? value : "None";
     if (typeof value === "boolean")
@@ -59,12 +59,12 @@ export function toTitle(value) {
     if (value instanceof Date)
         return formatDate(value);
     if (isArray(value))
-        return value.map(toTitle).join(", ");
+        return value.map(getTitle).join(", ");
     if (isData(value)) {
         if ("name" in value)
-            return toTitle(value.name);
+            return getTitle(value.name);
         if ("title" in value)
-            return toTitle(value.title);
+            return getTitle(value.title);
     }
     if (!value)
         return "None";
@@ -113,7 +113,7 @@ const NORMAL_STRIP = /[^\p{L}\p{N}\s]+/gu; // Anything except letters, numbers,
  * - Remove any characters not in the range `[a-z0-9-]`
  * - Change all spaces/separators/hyphens/dashes/underscores to `-` single hyphen.
  */
-export const toSlug = (str) => str.toLowerCase().normalize("NFD").replace(SLUG_HYPHENS, "-").replace(SLUG_STRIP, "");
+export const getSlug = (str) => str.toLowerCase().normalize("NFD").replace(SLUG_HYPHENS, "-").replace(SLUG_STRIP, "");
 const SLUG_HYPHENS = /[\s\-–—_]+/gu; // Runs of spaces and hyphens.
 const SLUG_STRIP = /^[^a-z0-9]+|[^a-z0-9]+$|[^a-z0-9-]+/g; // Non-alphanumeric or hyphen anywhere, or non-alphanumeric at start and end.
 /**
@@ -124,7 +124,7 @@ const SLUG_STRIP = /^[^a-z0-9]+|[^a-z0-9]+$|[^a-z0-9-]+/g; // Non-alphanumeric o
  * @param str The input string, e.g. `yellow dog   "Golden Retriever"`
  * @returns Array of the found words, e.g. `["yellow", "dog", "Golden Retriever"
  */
-export const toWords = (str) => Array.from(yieldWords(str));
+export const getWords = (str) => Array.from(yieldWords(str));
 /** Find and iterate over the words in a string. */
 export function* yieldWords(value) {
     for (const matches of value.matchAll(MATCH_WORD)) {

package/util/transform.js

@@ -1,5 +1,5 @@
 import { isFunction } from "./function.js";
-import { toProps, isData } from "./data.js";
+import { getProps, isData } from "./data.js";
 /** Is an unknown value a derivable. */
 export const isTransformable = (v) => isData(v) && typeof v.transform === "function";
 export function transform(input, transformer) {
@@ -17,7 +17,7 @@ export function transformData(data, transforms) {
  * @yield Transformed prop entry after calling the corresponding prop transformer.
  */
 export function* transformProps(data, transforms) {
-    for (const [k, v] of toProps(transforms))
+    for (const [k, v] of getProps(transforms))
         yield [k, transform(data[k], v)];
 }
 export function* mapEntries(entries, transformer) {

package/util/validate.d.ts

@@ -1,6 +1,7 @@
 import type { Entry } from "./entry.js";
 import type { ImmutableObject } from "./object.js";
 import { Data, Prop } from "./data.js";
+import { ImmutableArray } from "./array.js";
 /** Object that can validate an unknown value with its `validate()` method. */
 export interface Validatable<T> {
     /**
@@ -31,6 +32,14 @@ export declare type ValidatorsType<T> = {
 };
 /** Validate an unknown value with a validator. */
 export declare function validate<T>(unsafeValue: unknown, validator: Validator<T>): T;
+/**
+ * Validate an array of items.
+ *
+ * @return Array with valid items.
+ * @throw InvalidFeedback if one or more entry values did not validate.
+ * - `feedback.details` will contain an entry for each invalid item (keyed by their count in the input iterable).
+ */
+export declare function validateArray<T>(unsafeItems: Iterable<unknown>, validator: Validator<T>): ImmutableArray<T>;
 /**
  * Validate an iterable set of items with a validator.
  *