shelving 1.82.0 → 1.83.0

package/util/object.js

@@ -1,16 +1,13 @@
 import { AssertionError } from "../error/AssertionError.js";
-/**
- * Is a value an unknown object?
- * - This is a TypeScript assertion object that asserts the value extends `ImmutableObject`
- * - Note: Arrays and other complex objects will return true.
- */
+import { isIterable } from "./iterate.js";
+/** Is an unknown value an unknown object? */
 export const isObject = (value) => typeof value === "object" && value !== null;
 /** Assert that a value is an object */
 export function assertObject(value) {
     if (!isObject(value))
         throw new AssertionError(`Must be object`, value);
 }
-/** Is a value a plain object? */
+/** is an unknown value an unknown plain object? */
 export function isPlainObject(value) {
     if (isObject(value)) {
         const proto = Object.getPrototypeOf(value);
@@ -18,107 +15,57 @@ export function isPlainObject(value) {
     }
     return false;
 }
-/** Assert that a value is a plain object */
+/** Assert that a value is an object */
 export function assertPlainObject(value) {
     if (!isPlainObject(value))
         throw new AssertionError(`Must be plain object`, value);
 }
-/** Is an unknown string an own prop of an object. */
-export const isProp = (obj, key) => (typeof key === "string" || typeof key === "number" || typeof key === "symbol") && Object.prototype.hasOwnProperty.call(obj, key);
-export function getProps(data) {
-    return Object.entries(data);
+/** Is an unknown value the key for an own prop of an object. */
+export const isProp = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+export function getProps(obj) {
+    return isIterable(obj) ? obj : Object.entries(obj);
 }
 export function getProp(data, k1, k2, k3, k4) {
     return k2 === undefined ? data[k1] : k3 === undefined ? data[k1][k2] : k4 === undefined ? data[k1][k2][k3] : data[k1][k2][k3][k4];
 }
-/**
- * Set a prop on an object (immutably).
- *
- * @param input The input data object.
- * @param key The key of the entry to add.
- * @param value The value of the entry to add. If set, the entry will only be added if its current value is not `value`
- *
- * @return New object without the specified prop (or same object if prop value didn't change).
- */
+/** Set a prop on an object (immutably) and return a new object including that prop. */
 export function withProp(input, key, value) {
     return input[key] === value ? input : { ...input, [key]: value };
 }
-/**
- * Set several props on an object (immutably).
- *
- * @param input The input data object.
- * @param props Set of props to add to the object.
- * @return New object with the specified prop added (or same object if no props changed).
- */
+/** Set several props on an object (immutably) and return a new object including those props. */
 export function withProps(input, props) {
-    for (const [k, v] of Object.entries(props))
+    for (const [k, v] of getProps(props))
         if (input[k] !== v)
             return { ...input, ...props };
     return input;
 }
-/**
- * Remove several key/value entries from an object (immutably).
- *
- * @param input The input object.
- * @param keys Set of keys for props to remove.
- *
- * @return New object without the specified entries (or same object if none of the entries existed).
- */
-export function withoutProps(input, ...keys) {
+export function omitProps(input, ...keys) {
     for (const key of keys)
         if (key in input)
-            return Object.fromEntries(Object.entries(input).filter(_doesntHaveKey, keys));
+            return Object.fromEntries(Object.entries(input).filter(_hasntKey, keys));
     return input;
 }
-function _doesntHaveKey([key]) {
+function _hasntKey([key]) {
     return !this.includes(key);
 }
-/**
- * Pick several props from an object (immutably).
- *
- * @param input The input object.
- * @param keys Set of keys for props to pick.
- *
- * @return New object with only the specified props.
- */
 export function pickProps(input, ...keys) {
-    return Object.fromEntries(Object.entries(input).filter(_doesHaveKey, keys));
+    return Object.fromEntries(Object.entries(input).filter(_hasKey, keys));
 }
-function _doesHaveKey([key]) {
+function _hasKey([key]) {
     return this.includes(key);
 }
-/**
- * Set a single named prop on an object (by reference).
- *
- * @param data The target data object to modify.
- * @param key The key of the prop in the object to set.
- * @param value The value to set the prop to.
- */
-export function setProp(data, key, value) {
-    data[key] = value;
+/** Set a single named prop on an object (by reference) and return its value. */
+export function setProp(obj, key, value) {
+    obj[key] = value;
     return value;
 }
-/**
- * Set several named props on an object (by reference).
- *
- * @param obj The target object to modify.
- * @param props An object containing new props to set on the object.
- */
-export function setProps(obj, props) {
-    for (const [k, v] of getProps(props))
+/** Set several named props on an object (by reference). */
+export function setProps(obj, entries) {
+    for (const [k, v] of getProps(entries))
         obj[k] = v;
 }
-/**
- * Remove several key/value entries from an object (by reference).
- *
- * @param obj The target object to modify.
- * @param keys Set of keys or keys to remove.
- */
+/** Remove several key/value entries from an object (by reference). */
 export function deleteProps(obj, ...keys) {
     for (const key of keys)
         delete obj[key];
 }
-/** An empty object. */
-export const EMPTY_OBJECT = {};
-/** Function that returns an an empty object. */
-export const getEmptyObject = () => EMPTY_OBJECT;

package/util/set.d.ts

@@ -4,11 +4,21 @@ export declare type ImmutableSet<T = unknown> = ReadonlySet<T>;
 export declare type MutableSet<T = unknown> = Set<T>;
 /** Things that can be converted to sets. */
 export declare type PossibleSet<T> = ImmutableSet<T> | Iterable<T>;
+/** Get the type of the _items_ in a set. */
+export declare type SetItem<X> = X extends ReadonlySet<infer Y> ? Y : never;
 /** Is an unknown value a set? */
 export declare const isSet: <T extends ImmutableSet<unknown>>(v: unknown) => v is T;
+/** Is an unknown value an item in a set? */
+export declare const isSetItem: <T>(set: ImmutableSet<T>, item: unknown) => item is T;
 /** Assert that a value is a `Set` instance. */
 export declare function assertSet<T extends ImmutableSet>(v: T | unknown): asserts v is T;
 /** Convert an iterable to a `Set` (if it's already a `Set` it passes through unchanged). */
 export declare function getSet<T>(iterable: PossibleSet<T>): ImmutableSet<T>;
+/** Add an item to a set (by reference) and return the set item. */
+export declare function addSetItem<T>(set: MutableSet<T>, item: T): T;
+/** Add multiple items to a set (by reference). */
+export declare function addSetItems<T>(set: MutableSet<T>, ...items: T[]): void;
+/** Remove multiple items from a set (by reference). */
+export declare function removeSetItems<T>(set: MutableSet<T>, ...items: T[]): void;
 /** Apply a limit to a set. */
 export declare function limitSet<T>(set: ImmutableSet<T>, limit: number): ImmutableSet<T>;

package/util/set.js

@@ -2,6 +2,8 @@ import { AssertionError } from "../error/AssertionError.js";
 import { limitItems } from "./iterate.js";
 /** Is an unknown value a set? */
 export const isSet = (v) => v instanceof Set;
+/** Is an unknown value an item in a set? */
+export const isSetItem = (set, item) => set.has(item);
 /** Assert that a value is a `Set` instance. */
 export function assertSet(v) {
     if (!isSet(v))
@@ -11,6 +13,21 @@ export function assertSet(v) {
 export function getSet(iterable) {
     return isSet(iterable) ? iterable : new Set(iterable);
 }
+/** Add an item to a set (by reference) and return the set item. */
+export function addSetItem(set, item) {
+    set.add(item);
+    return item;
+}
+/** Add multiple items to a set (by reference). */
+export function addSetItems(set, ...items) {
+    for (const item of items)
+        set.add(item);
+}
+/** Remove multiple items from a set (by reference). */
+export function removeSetItems(set, ...items) {
+    for (const item of items)
+        set.delete(item);
+}
 /** Apply a limit to a set. */
 export function limitSet(set, limit) {
     return limit > set.size ? set : new Set(limitItems(set, limit));

package/util/template.d.ts

@@ -1,7 +1,7 @@
 import type { NotString } from "./string.js";
-import { ImmutableObject } from "./object.js";
+import type { ImmutableDictionary } from "./dictionary.js";
 /** Template values in `{ placeholder: value }` format. */
-declare type TemplateValues = ImmutableObject<string>;
+declare type TemplateValues = ImmutableDictionary<string>;
 /** Things that can be converted to the value for a named placeholder. */
 declare type PlaceholderValues = string | ((name: string) => string) | string[] | TemplateValues;
 /**
@@ -29,7 +29,7 @@ export declare function matchTemplates(templates: Iterable<string> & NotString,
  * Turn ":year-:month" and `{ year: "2016"... }` etc into "2016-06..." etc.
  *
  * @param template The template including template placeholders, e.g. `:name-${country}/{city}`
- * @param values An object containing values, e.g. `{ name: "Dave", country: "UK", city: "Manchester" }` (functions are called, everything else converted to string), or a function or string to use for all placeholders.
+ * @param value An object containing values, e.g. `{ name: "Dave", country: "UK", city: "Manchester" }` (functions are called, everything else converted to string), or a function or string to use for all placeholders.
  * @return The rendered string, e.g. `Dave-UK/Manchester`
  *
  * @throws {ReferenceError} If a placeholder in the template string is not specified in values.

package/util/template.js

@@ -26,7 +26,7 @@ const _split = (template) => {
         const placeholder = matches[i];
         const post = matches[i + 1];
         if (i > 1 && !pre.length)
-            throw new SyntaxError("shelving/template: Placeholders must be separated by at least one character");
+            throw new SyntaxError("Placeholders must be separated by at least one character");
         const name = placeholder === "*" ? String(asterisks++) : ((_a = R_NAME.exec(placeholder)) === null || _a === void 0 ? void 0 : _a[0]) || "";
         chunks.push({ pre, placeholder, name, post });
     }
@@ -90,7 +90,7 @@ export function matchTemplates(templates, target) {
  * Turn ":year-:month" and `{ year: "2016"... }` etc into "2016-06..." etc.
  *
  * @param template The template including template placeholders, e.g. `:name-${country}/{city}`
- * @param values An object containing values, e.g. `{ name: "Dave", country: "UK", city: "Manchester" }` (functions are called, everything else converted to string), or a function or string to use for all placeholders.
+ * @param value An object containing values, e.g. `{ name: "Dave", country: "UK", city: "Manchester" }` (functions are called, everything else converted to string), or a function or string to use for all placeholders.
  * @return The rendered string, e.g. `Dave-UK/Manchester`
  *
  * @throws {ReferenceError} If a placeholder in the template string is not specified in values.
@@ -114,5 +114,5 @@ const _replace = (name, value) => {
         if (typeof v === "string")
             return v;
     }
-    throw new ReferenceError(`renderTemplate(): values.${name}: Must be defined`);
+    throw new ReferenceError(`Template "value.${name}" must be defined`);
 };

package/util/transform.d.ts

@@ -1,7 +1,7 @@
-import type { ArrayType, ImmutableArray } from "./array.js";
-import type { Data, Prop, Value } from "./data.js";
-import { Entry } from "./entry.js";
-import { ImmutableObject } from "./object.js";
+import type { ArrayItem, ImmutableArray } from "./array.js";
+import type { Entry } from "./entry.js";
+import { ImmutableObject, ObjectValue } from "./object.js";
+import { ImmutableDictionary } from "./dictionary.js";
 /** Object that transforms an input value into an output value with its `transform()` method. */
 export interface Transformable<I, O> {
     transform(input: I): O;
@@ -12,49 +12,26 @@ export declare const isTransformable: <T extends Transformable<unknown, unknown>
 export declare type Transform<I, O> = (input: I) => O;
 /** Something that can transform an input value into an output value (or a plain value). */
 export declare type Transformer<I, O> = Transformable<I, O> | Transform<I, O> | O;
-/** Transform a value using a transform. */
+/** Transform a value using a transformer. */
 export declare function transform<I, O>(input: I, transformer: (v: I) => O): O;
 export declare function transform<I, O>(input: I, transformer: Transformer<I, O>): O;
+/** Modify a set of items using a transformer. */
+export declare function mapItems<I, O>(items: Iterable<I>, transformer: Transformer<I, O>): Iterable<O>;
+/** Modify the items of an array using a transformer. */
+export declare function mapArray<T extends ImmutableArray>(arr: T, transformer: Transformer<ArrayItem<T>, ArrayItem<T>>): T;
+export declare function mapArray<I, O>(arr: Iterable<I>, transformer: Transformer<I, O>): ImmutableArray<O>;
+/** Modify the values of the props of an object using a transformer. */
+export declare function mapObject<T extends ImmutableObject>(obj: T, transformer: Transformer<ObjectValue<T>, ObjectValue<T>>): T;
+export declare function mapObject<I extends ImmutableObject, O extends ImmutableObject>(obj: I, transformer: Transformer<ObjectValue<I>, ObjectValue<O>>): O;
+/** Modify the values of a dictionary using a transformer. */
+export declare const mapDictionary: <I, O>(dictionary: ImmutableDictionary<I>, transformer: Transformer<I, O>) => ImmutableDictionary<O>;
+/** Modify the values of a set of entries using a transformer. */
+export declare function mapEntries<K, I, O>(entries: Iterable<Entry<K, I>>, transformer: Transformer<I, O>): Iterable<Entry<K, O>>;
 /** Set of named transformers for a data object. */
-export declare type Transformers<T extends Data> = {
+export declare type Transformers<T extends ImmutableObject> = {
     readonly [K in keyof T]?: Transformer<T[K], T[K]>;
 };
-/**
- * Transform the props of a data object using a set of named transformers.
- * @returns New object with changed props.
- */
-export declare function transformData<T extends Data>(data: T, transforms: Transformers<T>): T;
-/**
- * Transform the props of a data object using a set of named transformers.
- * @yield Transformed prop entries after calling the corresponding transformer.
- */
-export declare function transformProps<T extends Data>(obj: T, transforms: Transformers<T>): Iterable<Prop<T>>;
-/**
- * Transform the _values_ of an iterable set of entries using a transformer.
- * @yield Transformed entry after calling transforming the new value for each entry.
- */
-export declare function mapEntries<K, I, O>(entries: Iterable<Entry<K, I>>, transformer: Transformer<I, O>): Iterable<Entry<K, O>>;
-/**
- * Transform the _values_ of a map-like object using a transformer.
- * @return New object after transforming its entries.
- */
-export declare function mapObject<I, O>(obj: ImmutableObject<I>, transformer: Transformer<I, O>): ImmutableObject<O>;
-/**
- * Transform the _values_ of an data object using a transformer.
- * @return New object after transforming its entries.
- */
-export declare function mapData<T extends Data>(data: T, transformer: Transformer<Value<T>, Value<T>>): T;
-export declare function mapData<I extends Data, O extends {
-    [K in keyof I]: unknown;
-}>(data: I, transformer: Transformer<Value<I>, Value<O>>): O;
-/**
- * Map an iterable set of items using a transformer.
- * @yield Transformed items after calling `transformer()` on each.
- */
-export declare function mapItems<I, O>(items: Iterable<I>, transformer: Transformer<I, O>): Iterable<O>;
-/**
- * Apply a transformer to each item in an array and return the transformed array.
- * @return The transformed array.
- */
-export declare function mapArray<T extends ImmutableArray>(arr: T, transformer: Transformer<ArrayType<T>, ArrayType<T>>): T;
-export declare function mapArray<I, O>(arr: Iterable<I>, transformer: Transformer<I, O>): ImmutableArray<O>;
+/** Transform an object using a set of named transformers. */
+export declare function transformObject<T extends ImmutableObject>(obj: T, transforms: Transformers<T>): T;
+/** Transform a dictionary object using a set of named transformers. */
+export declare const transformDictionary: <T>(dict: ImmutableDictionary<T>, transforms: Transformers<ImmutableDictionary<T>>) => ImmutableDictionary<T>;

package/util/transform.js

@@ -1,52 +1,35 @@
 import { isFunction } from "./function.js";
-import { getEntries } from "./entry.js";
 import { getProps, isObject } from "./object.js";
 /** Is an unknown value a transformable. */
 export const isTransformable = (v) => isObject(v) && typeof v.transform === "function";
 export function transform(input, transformer) {
     return isFunction(transformer) ? transformer(input) : isTransformable(transformer) ? transformer.transform(input) : transformer;
 }
-/**
- * Transform the props of a data object using a set of named transformers.
- * @returns New object with changed props.
- */
-export function transformData(data, transforms) {
-    return { ...data, ...Object.fromEntries(transformProps(data, transforms)) };
+/** Modify a set of items using a transformer. */
+export function* mapItems(items, transformer) {
+    for (const item of items)
+        yield transform(item, transformer);
 }
-/**
- * Transform the props of a data object using a set of named transformers.
- * @yield Transformed prop entries after calling the corresponding transformer.
- */
-export function* transformProps(obj, transforms) {
-    for (const [k, v] of getProps(transforms))
-        yield [k, transform(obj[k], v)];
+export function mapArray(arr, transformer) {
+    return Array.from(mapItems(arr, transformer));
 }
-/**
- * Transform the _values_ of an iterable set of entries using a transformer.
- * @yield Transformed entry after calling transforming the new value for each entry.
- */
+export function mapObject(obj, transformer) {
+    return Object.fromEntries(mapEntries(getProps(obj), transformer));
+}
+/** Modify the values of a dictionary using a transformer. */
+export const mapDictionary = mapObject;
+/** Modify the values of a set of entries using a transformer. */
 export function* mapEntries(entries, transformer) {
     for (const [k, v] of entries)
         yield [k, transform(v, transformer)];
 }
-/**
- * Transform the _values_ of a map-like object using a transformer.
- * @return New object after transforming its entries.
- */
-export function mapObject(obj, transformer) {
-    return Object.fromEntries(mapEntries(getEntries(obj), transformer));
+/** Transform an object using a set of named transformers. */
+export function transformObject(obj, transforms) {
+    return { ...obj, ...Object.fromEntries(_transformObjectProps(obj, transforms)) };
 }
-export function mapData(data, transformer) {
-    return mapObject(data, transformer);
-}
-/**
- * Map an iterable set of items using a transformer.
- * @yield Transformed items after calling `transformer()` on each.
- */
-export function* mapItems(items, transformer) {
-    for (const item of items)
-        yield transform(item, transformer);
-}
-export function mapArray(arr, transformer) {
-    return Array.from(mapItems(arr, transformer));
+function* _transformObjectProps(obj, transforms) {
+    for (const [k, v] of getProps(transforms))
+        yield [k, transform(obj[k], v)];
 }
+/** Transform a dictionary object using a set of named transformers. */
+export const transformDictionary = transformObject;

package/util/units.d.ts

@@ -1,5 +1,6 @@
+import { ImmutableObject } from "./object.js";
 import { PossibleDate } from "./date.js";
-import { MapKey, RequiredMap } from "./map.js";
+import { MapKey, ImmutableRequiredMap } from "./map.js";
 /** Conversion from one unit to another (either a number to multiple by, or a function to convert). */
 declare type Conversion = number | ((num: number) => number);
 /** Set of possible conversions for a set of items. */
@@ -29,6 +30,8 @@ export declare class Unit<T extends string> {
     readonly singular: string;
     /** Plural name for this unit, e.g. `kilometers` (defaults to `singular` + "s"). */
     readonly plural: string;
+    /** Title for this unit (uses format `abbr (plural)`, e.g. `fl oz (US fluid ounces)`) */
+    get title(): string;
     constructor(
     /** `UnitList` this unit belongs to. */
     list: UnitList<T>, 
@@ -50,18 +53,9 @@ export declare class Unit<T extends string> {
     formatFull(amount: number, maxPrecision?: number, minPrecision?: number): string;
 }
 /** Represent a list of units. */
-export declare class UnitList<T extends string> extends RequiredMap<T, Unit<T>> {
+export declare class UnitList<T extends string> extends ImmutableRequiredMap<T, Unit<T>> {
     readonly base: Unit<T>;
-    constructor(units: {
-        [K in T]: UnitProps<T>;
-    });
-}
-export interface UnitList<T extends string> {
-    (units: {
-        [K in T]: UnitProps<T>;
-    }): UnitList<T>;
-    set: never;
-    delete: never;
+    constructor(units: ImmutableObject<T, UnitProps<T>>);
 }
 /** Percentage units. */
 export declare const PERCENTAGE_UNITS: UnitList<"percent">;

package/util/units.js

@@ -1,9 +1,9 @@
 import { ConditionError } from "../error/ConditionError.js";
 import { DAY, HOUR, MILLION, MINUTE, MONTH, NNBSP, SECOND, WEEK, YEAR } from "./constants.js";
+import { getProps } from "./object.js";
 import { getDuration } from "./date.js";
-import { RequiredMap } from "./map.js";
+import { ImmutableRequiredMap } from "./map.js";
 import { formatFullQuantity, formatQuantity, getPercent } from "./number.js";
-import { getProps } from "./object.js";
 /** Convert an amount using a `Conversion. */
 const _convert = (amount, conversion) => (typeof conversion === "function" ? conversion(amount) : conversion === 1 ? amount : amount * conversion);
 /** Represent a unit. */
@@ -22,6 +22,10 @@ export class Unit {
         this.plural = plural;
         this._to = to;
     }
+    /** Title for this unit (uses format `abbr (plural)`, e.g. `fl oz (US fluid ounces)`) */
+    get title() {
+        return `${this.abbr} (${this.plural})`;
+    }
     /** Convert an amount from this unit to another unit. */
     to(amount, ref = this.list.base) {
         return this._toUnit(amount, this._unit(ref));
@@ -66,14 +70,14 @@ export class Unit {
     }
 }
 /** Represent a list of units. */
-export class UnitList extends RequiredMap {
+export class UnitList extends ImmutableRequiredMap {
     constructor(units) {
         super();
         for (const [ref, props] of getProps(units)) {
             const unit = new Unit(this, ref, props);
             if (!this.base)
                 this.base = unit;
-            super.set(ref, unit);
+            Map.prototype.set.call(this, ref, unit);
         }
     }
 }

package/util/validate.d.ts

@@ -1,6 +1,6 @@
 import type { Entry } from "./entry.js";
-import type { Data, Prop } from "./data.js";
-import { ImmutableObject } from "./object.js";
+import type { ImmutableDictionary } from "./dictionary.js";
+import { Data, DataProp } from "./data.js";
 import { ImmutableArray } from "./array.js";
 /** Object that can validate an unknown value with its `validate()` method. */
 export interface Validatable<T> {
@@ -57,19 +57,20 @@ export declare function validateItems<T>(unsafeItems: Iterable<unknown>, validat
  */
 export declare function validateEntries<T>(unsafeValues: Iterable<Entry<string, unknown>>, validator: Validator<T>): Iterable<Entry<string, T>>;
 /**
- * Validate a map-like object.
+ * Validate the values of the entries in a dictionary object.
  *
  * @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 validateObject<T>(obj: ImmutableObject<T>, validator: Validator<T>): ImmutableObject<T>;
+export declare function validateDictionary<T>(obj: ImmutableDictionary<T>, validator: Validator<T>): ImmutableDictionary<T>;
 /**
  * Validate the props of a data object with a set of validators.
+ *
  * @yield Valid props for the data object.
  * @throw InvalidFeedback if one or more props did not validate.
  * - `feedback.details` will contain an entry for each invalid item (keyed by their count in the input iterable).
  */
-export declare function validateProps<T extends Data>(unsafeData: Data, validators: Validators<T>): Iterable<Prop<T>>;
+export declare function validateProps<T extends Data>(unsafeData: Data, validators: Validators<T>): Iterable<DataProp<T>>;
 /**
  * Validate a data object with a set of validators.
  * - Defined props in the object will be validated against the corresponding validator.

package/util/validate.js

@@ -1,6 +1,6 @@
 import { isFeedback } from "../feedback/Feedback.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { getProps } from "./object.js";
+import { getDataProps } from "./data.js";
 import { getArray } from "./array.js";
 /** Validate an unknown value with a validator. */
 export function validate(unsafeValue, validator) {
@@ -63,23 +63,24 @@ export function* validateEntries(unsafeValues, validator) {
         throw new InvalidFeedback("Invalid entries", feedbacks);
 }
 /**
- * Validate a map-like object.
+ * Validate the values of the entries in a dictionary object.
  *
  * @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 function validateObject(obj, validator) {
+export function validateDictionary(obj, validator) {
     return Object.fromEntries(validateEntries(Object.entries(obj), validator));
 }
 /**
  * Validate the props of a data object with a set of validators.
+ *
  * @yield Valid props for the data object.
  * @throw InvalidFeedback if one or more props did not validate.
  * - `feedback.details` will contain an entry for each invalid item (keyed by their count in the input iterable).
  */
 export function* validateProps(unsafeData, validators) {
     const feedbacks = new Map();
-    for (const [key, validator] of getProps(validators)) {
+    for (const [key, validator] of getDataProps(validators)) {
         try {
             yield [key, validate(unsafeData[key], validator)];
         }

package/schema/ObjectSchema.d.ts

@@ -1,19 +0,0 @@
-import { ImmutableObject } from "../util/object.js";
-import { Validator } from "../util/validate.js";
-import { Schema } from "./Schema.js";
-/** Validate a map-like object (whose props are all the same). */
-export declare class ObjectSchema<T> extends Schema<ImmutableObject<T>> {
-    readonly value: ImmutableObject;
-    readonly items: Validator<T>;
-    readonly min: number | null;
-    readonly max: number | null;
-    constructor({ value, items, min, max, ...rest }: ConstructorParameters<typeof Schema>[0] & {
-        readonly items: Validator<T>;
-        readonly value?: ImmutableObject;
-        readonly min?: number | null;
-        readonly max?: number | null;
-    });
-    validate(unsafeValue?: unknown): ImmutableObject<T>;
-}
-/** Valid map-like object with specifed items. */
-export declare const OBJECT: <T>(items: Validator<T>) => ObjectSchema<T>;

package/state/ObjectState.d.ts

@@ -1,16 +0,0 @@
-import type { Entry } from "../util/entry.js";
-import { ImmutableObject } from "../util/object.js";
-import { Transformers } from "../util/transform.js";
-import { State } from "./State.js";
-/** State that stores a map-like object and has additional methods to help with that. */
-export declare class ObjectState<T> extends State<ImmutableObject<T>> implements Iterable<Entry<string, T>> {
-    constructor(initial?: ImmutableObject<T>);
-    /** Get the length of the current value of this state. */
-    get count(): number;
-    /** Set a named entry in this object with a different value. */
-    update(updates: Transformers<ImmutableObject<T>>): void;
-    /** Remove a named entry from this object. */
-    delete(...keys: string[]): void;
-    /** Iterate over the entries of the object. */
-    [Symbol.iterator](): Iterator<Entry<string, T>>;
-}

package/update/ObjectUpdate.d.ts

@@ -1,29 +0,0 @@
-import type { Entry } from "../util/entry.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> | 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<string, 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> | 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>;
-    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. */
-    without(key: Nullish<string>): this;
-    /**
-     * Iterate over the changes in this object.
-     * - Updates are yielded first, then deletes.
-     * - Entries whose value is `undefined` indicate deletion.
-     */
-    [Symbol.iterator](): Iterator<Entry<string, T | Update<T> | Delete>, void>;
-}