shelving 1.79.0 → 1.80.0

package/modules/constraint/Constraints.js

@@ -20,12 +20,12 @@ export class Constraints extends Constraint {
     }
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
-        const _constraints = withItems(this._constraints, constraints);
+        const _constraints = withItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Clone this set of constraints but remove specific constraints. */
     without(...constraints) {
-        const _constraints = withoutItems(this._constraints, constraints);
+        const _constraints = withoutItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Iterate over the constraints. */

package/modules/constraint/QueryConstraints.d.ts

@@ -1,4 +1,4 @@
-import { Data } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import { Filterable, FilterConstraints } from "./FilterConstraints.js";
 import { Sortable, SortConstraints } from "./SortConstraints.js";
 import { Constraint } from "./Constraint.js";

package/modules/constraint/QueryConstraints.js

@@ -1,4 +1,4 @@
-import { getProp } from "../util/data.js";
+import { getProp } from "../util/object.js";
 import { assert } from "../util/assert.js";
 import { limitItems } from "../util/iterate.js";
 import { FilterConstraints } from "./FilterConstraints.js";

package/modules/schema/AllowSchema.js

@@ -2,7 +2,7 @@ import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { getString } from "../util/string.js";
 import { isArray, isItem } from "../util/array.js";
 import { getOptionalNumber } from "../util/number.js";
-import { isEntry } from "../util/object.js";
+import { isProp } from "../util/object.js";
 import { Schema } from "./Schema.js";
 /** Validate a value against a specific set of allowed values. */
 export function validateAllowed(value, allowed) {
@@ -11,7 +11,7 @@ export function validateAllowed(value, allowed) {
             return value;
     }
     else {
-        if (isEntry(allowed, value))
+        if (isProp(allowed, value))
             return value;
     }
     throw new InvalidFeedback("Unknown value", { value });

package/modules/state/ArrayState.d.ts

@@ -5,14 +5,12 @@ export declare class ArrayState<T> extends State<ImmutableArray<T>> implements I
     constructor(initial?: ImmutableArray<T>);
     /** Get the length of the current value of this state. */
     get count(): number;
-    /** Add an item to this array. */
-    add(item: T): void;
-    /** Remove an item from this array. */
-    delete(item: T): void;
-    /** Swap an item in this array with a different item. */
-    swap(oldItem: T, newItem: T): void;
-    /** Toggle an item in this array. */
-    toggle(item: T): void;
+    /** Add items to this array. */
+    add(...items: T[]): void;
+    /** Remove items from this array. */
+    delete(...items: T[]): void;
+    /** Toggle items in this array. */
+    toggle(...items: T[]): void;
     /** Iterate over the items. */
     [Symbol.iterator](): Iterator<T, void>;
 }

package/modules/state/ArrayState.js

@@ -1,4 +1,4 @@
-import { swapItem, toggleItem, withItem, withoutItem } from "../util/array.js";
+import { toggleItems, withItems, withoutItems } from "../util/array.js";
 import { State } from "./State.js";
 /** State that stores an array and has additional methods to help with that. */
 export class ArrayState extends State {
@@ -9,21 +9,17 @@ export class ArrayState extends State {
     get count() {
         return this.value.length;
     }
-    /** Add an item to this array. */
-    add(item) {
-        this.next(withItem(this.value, item));
+    /** Add items to this array. */
+    add(...items) {
+        this.next(withItems(this.value, ...items));
     }
-    /** Remove an item from this array. */
-    delete(item) {
-        this.next(withoutItem(this.value, item));
+    /** Remove items from this array. */
+    delete(...items) {
+        this.next(withoutItems(this.value, ...items));
     }
-    /** Swap an item in this array with a different item. */
-    swap(oldItem, newItem) {
-        this.next(swapItem(this.value, oldItem, newItem));
-    }
-    /** Toggle an item in this array. */
-    toggle(item) {
-        this.next(toggleItem(this.value, item));
+    /** Toggle items in this array. */
+    toggle(...items) {
+        this.next(toggleItems(this.value, ...items));
     }
     /** Iterate over the items. */
     [Symbol.iterator]() {

package/modules/state/DataState.js

@@ -1,4 +1,5 @@
-import { getData, withProp } from "../util/data.js";
+import { getData } from "../util/data.js";
+import { withProp } from "../util/object.js";
 import { transformData } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */

package/modules/state/ObjectState.d.ts

@@ -7,7 +7,7 @@ export declare class ObjectState<T> extends State<ImmutableObject<T>> implements
     /** Get the length of the current value of this state. */
     get count(): number;
     /** Remove a named entry from this object. */
-    delete(key: string): void;
+    delete(...keys: string[]): void;
     /** Set a named entry in this object with a different value. */
     set(key: string, value: T): void;
     /** Iterate over the items. */

package/modules/state/ObjectState.js

@@ -1,4 +1,4 @@
-import { withEntry, withoutEntry } from "../util/object.js";
+import { withProp, withoutProps } from "../util/object.js";
 import { State } from "./State.js";
 /** State that stores a map-like object and has additional methods to help with that. */
 export class ObjectState extends State {
@@ -10,12 +10,12 @@ export class ObjectState extends State {
         return Object.keys(this.value).length;
     }
     /** Remove a named entry from this object. */
-    delete(key) {
-        this.next(withoutEntry(this.value, key));
+    delete(...keys) {
+        this.next(withoutProps(this.value, ...keys));
     }
     /** Set a named entry in this object with a different value. */
     set(key, value) {
-        this.next(withEntry(this.value, key, value));
+        this.next(withProp(this.value, key, value));
     }
     /** Iterate over the items. */
     [Symbol.iterator]() {

package/modules/update/ArrayUpdate.js

@@ -18,7 +18,7 @@ export class ArrayUpdate extends Update {
         return new ArrayUpdate([], deletes);
     }
     transform(arr = []) {
-        return withoutItems(withItems(arr, this.adds), this.deletes);
+        return withoutItems(withItems(arr, ...this.adds), ...this.deletes);
     }
     validate(validator) {
         if (!(validator instanceof ArraySchema))

package/modules/update/DataUpdate.d.ts

@@ -16,9 +16,7 @@ export declare type Updates<T extends Data = Data> = {
 /**
  * Validate a set of updates against a set of validators.
  */
-export declare function validateUpdates<T extends Data>(unsafeUpdates: Updates<T>, validators: Validators<T>): {
-    [k: string]: import("../util/data.js").Value<Updates<T>>;
-};
+export declare function validateUpdates<T extends Data>(unsafeUpdates: Updates<T>, validators: Validators<T>): Updates<T>;
 /**
  * Update that can be applied to a data object to update its props.
  */

package/modules/update/DataUpdate.js

@@ -1,7 +1,7 @@
 import { isFeedback } from "../feedback/Feedback.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { DataSchema } from "../schema/DataSchema.js";
-import { getProps } from "../util/data.js";
+import { getProps } from "../util/object.js";
 import { isNullish } from "../util/null.js";
 import { transformData } from "../util/transform.js";
 import { validate } from "../util/validate.js";

package/modules/update/hydrations.d.ts

@@ -1,3 +1,3 @@
 import { Hydrations } from "../util/hydrate.js";
-/** Set of hydrations for all transform classes. */
-export declare const TRANSFORM_HYDRATIONS: Hydrations;
+/** Set of hydrations for all update classes. */
+export declare const UPDATE_HYDRATIONS: Hydrations;

package/modules/update/hydrations.js

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

package/modules/util/array.d.ts

@@ -23,17 +23,6 @@ export declare const isItem: <T>(arr: ImmutableArray<T>, item: unknown) => item
 export declare type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
 /** Convert an iterable to an array (if its not already an array). */
 export declare function getArray<T>(items: PossibleArray<T>): ImmutableArray<T>;
-/**
- * Add an item to an array (immutably).
- * - Returns an array that definitely contains the specified item.
- *
- * @param input The input array to add items to.
- * @param item The item to add.
- *
- * @return New array with the specified item.
- * - If the item already exists in the array (using `indexOf()`) then the item won't be added again and the exact same input array will be returned.
- */
-export declare function withItem<T>(input: ImmutableArray<T>, item: T): ImmutableArray<T>;
 /**
  * Add multiple items to an array (immutably).
  * - Returns an array that definitely contains the specified item.
@@ -41,21 +30,9 @@ export declare function withItem<T>(input: ImmutableArray<T>, item: T): Immutabl
  * @param input The input array to add items to.
  * @param items The array of items to add.
  *
- * @return New array with the specified item.
- * - If all items already exist in the array (using `indexOf()`) then the items won't be added again and the exact same input array will be returned.
+ * @return New array with the specified item (or same array if no items were added).
  */
-export declare function withItems<T>(input: ImmutableArray<T>, items: Iterable<T>): ImmutableArray<T>;
-/**
- * Remove an item from an array (immutably).
- * - Finds all instances of the item from the array and returns an array that definitely does not contain it.
- *
- * @param input The input array to remove items from.
- * @param item The item to remove.
- *
- * @return New array without the specified item.
- * - If the item does not already exist in the array (using `indexOf()`) then the exact same input array will be returned.
- */
-export declare function withoutItem<T>(input: ImmutableArray<T>, item: T): ImmutableArray<T>;
+export declare function withItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
 /**
  * Remove multiple items from an array (immutably).
  * - Finds all instances of a number of items from an array and returns an array that definitely does not contain them.
@@ -63,20 +40,9 @@ export declare function withoutItem<T>(input: ImmutableArray<T>, item: T): Immut
  * @param input The input array to remove items from.
  * @param items The array of items to add.
  *
- * @return New array without the specified item.
- * - If the items do not already exist in the array (using `indexOf()`) then the exact same input array will be returned.
+ * @return New array without the specified items (or same array if no items were removed).
  */
-export declare function withoutItems<T>(input: ImmutableArray<T>, items: Iterable<T>): ImmutableArray<T>;
-/**
- * Toggle an item in and out of an array (immutably).
- * - If the item is being removed from the array ALL instances of that item in the array will be removed.
- *
- * @param input The input array to toggle items from.
- * @param item The items to toggle.
- *
- * @return New array with or without the specified item.
- */
-export declare function toggleItem<T>(input: ImmutableArray<T>, item: T): ImmutableArray<T>;
+export declare function withoutItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
 /**
  * Toggle an item in and out of an array (immutably).
  * - If an item is being removed from the array ALL instances of that item in the array will be removed.
@@ -84,21 +50,9 @@ export declare function toggleItem<T>(input: ImmutableArray<T>, item: T): Immuta
  * @param input The input array to toggle items from.
  * @param items The array of items to toggle.
  *
- * @return New array with or without the specified item.
- */
-export declare function toggleItems<T>(input: ImmutableArray<T>, items: Iterable<T>): ImmutableArray<T>;
-/**
- * Swap an item in an array for a new item (immutably).
- * - All instances of the item in the array will be swapped for the new item.
- *
- * @param input The input array to swap items in.
- * @param oldItem The item to replace with `newItem`
- * @param newItem The item to replace `oldItem` with.
- *
- * @return New array with or without the specified item.
- * - If the item does not already exist in the array (using `indexOf()`) then the exact same input array will be returned.
+ * @return New array with or without the specified items (or same array if no items were toggled).
  */
-export declare function swapItem<T>(input: ImmutableArray<T>, oldItem: T, newItem: T): ImmutableArray<T>;
+export declare function toggleItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
 /** Get the first item from an array or iterable, or `null` if it didn't exist. */
 export declare function getOptionalFirstItem<T>(items: ImmutableArray<T> | Iterable<T>): T | null;
 /** Get the first item from an array or iterable. */

package/modules/util/array.js

@@ -13,20 +13,6 @@ export const isItem = (arr, item) => arr.includes(item);
 export function getArray(items) {
     return isArray(items) ? items : Array.from(items);
 }
-/**
- * Add an item to an array (immutably).
- * - Returns an array that definitely contains the specified item.
- *
- * @param input The input array to add items to.
- * @param item The item to add.
- *
- * @return New array with the specified item.
- * - If the item already exists in the array (using `indexOf()`) then the item won't be added again and the exact same input array will be returned.
- */
-export function withItem(input, item) {
-    const i = input.indexOf(item);
-    return i >= 0 ? input : [...input, item];
-}
 /**
  * Add multiple items to an array (immutably).
  * - Returns an array that definitely contains the specified item.
@@ -34,35 +20,11 @@ export function withItem(input, item) {
  * @param input The input array to add items to.
  * @param items The array of items to add.
  *
- * @return New array with the specified item.
- * - If all items already exist in the array (using `indexOf()`) then the items won't be added again and the exact same input array will be returned.
- */
-export function withItems(input, items) {
-    let output = input;
-    for (const item of items)
-        output = withItem(output, item);
-    return output;
-}
-/**
- * Remove an item from an array (immutably).
- * - Finds all instances of the item from the array and returns an array that definitely does not contain it.
- *
- * @param input The input array to remove items from.
- * @param item The item to remove.
- *
- * @return New array without the specified item.
- * - If the item does not already exist in the array (using `indexOf()`) then the exact same input array will be returned.
+ * @return New array with the specified item (or same array if no items were added).
  */
-export function withoutItem(input, item) {
-    let i = input.indexOf(item);
-    if (i < 0)
-        return input;
-    const output = input.slice();
-    while (i >= 0) {
-        output.splice(i, 1);
-        i = output.indexOf(item, i);
-    }
-    return output;
+export function withItems(input, ...items) {
+    const extras = items.filter(_doesNotInclude, input);
+    return extras.length ? [...input, ...extras] : input;
 }
 /**
  * Remove multiple items from an array (immutably).
@@ -71,27 +33,14 @@ export function withoutItem(input, item) {
  * @param input The input array to remove items from.
  * @param items The array of items to add.
  *
- * @return New array without the specified item.
- * - If the items do not already exist in the array (using `indexOf()`) then the exact same input array will be returned.
+ * @return New array without the specified items (or same array if no items were removed).
  */
-export function withoutItems(input, items) {
-    let output = input;
-    for (const item of items)
-        output = withoutItem(output, item);
-    return output;
+export function withoutItems(input, ...items) {
+    const output = input.filter(_doesNotInclude, items);
+    return output.length === input.length ? input : output;
 }
-/**
- * Toggle an item in and out of an array (immutably).
- * - If the item is being removed from the array ALL instances of that item in the array will be removed.
- *
- * @param input The input array to toggle items from.
- * @param item The items to toggle.
- *
- * @return New array with or without the specified item.
- */
-export function toggleItem(input, item) {
-    const i = input.indexOf(item);
-    return i >= 0 ? withoutItem(input, item) : [...input, item];
+function _doesNotInclude(value) {
+    return !this.includes(value);
 }
 /**
  * Toggle an item in and out of an array (immutably).
@@ -100,35 +49,12 @@ export function toggleItem(input, item) {
  * @param input The input array to toggle items from.
  * @param items The array of items to toggle.
  *
- * @return New array with or without the specified item.
+ * @return New array with or without the specified items (or same array if no items were toggled).
  */
-export function toggleItems(input, items) {
-    let output = input;
-    for (const item of items)
-        output = toggleItem(output, item);
-    return output;
-}
-/**
- * Swap an item in an array for a new item (immutably).
- * - All instances of the item in the array will be swapped for the new item.
- *
- * @param input The input array to swap items in.
- * @param oldItem The item to replace with `newItem`
- * @param newItem The item to replace `oldItem` with.
- *
- * @return New array with or without the specified item.
- * - If the item does not already exist in the array (using `indexOf()`) then the exact same input array will be returned.
- */
-export function swapItem(input, oldItem, newItem) {
-    let i = input.indexOf(oldItem);
-    if (i < 0)
-        return input;
-    const output = input.slice();
-    while (i >= 0) {
-        output[i] = newItem;
-        i = output.indexOf(newItem, i + 1);
-    }
-    return output;
+export function toggleItems(input, ...items) {
+    const extras = items.filter(_doesNotInclude, input);
+    const output = input.filter(_doesNotInclude, items);
+    return extras.length ? [...output, ...extras] : output.length !== input.length ? output : input;
 }
 /** Get the first item from an array or iterable, or `null` if it didn't exist. */
 export function getOptionalFirstItem(items) {

package/modules/util/data.d.ts

@@ -1,79 +1,27 @@
-import type { ImmutableArray } from "./array.js";
 /** Data object. */
 export declare type Data = {
-    readonly [key: string]: unknown;
+    readonly [K in string]: unknown;
 };
+/** Key from a data object. */
+export declare type Key<T extends Data> = keyof T & string;
+/** Value from a data object. */
+export declare type Value<T extends Data> = T[keyof T & string];
+/** Prop from a data object in entry format. */
+export declare type Prop<T extends Data> = readonly [Key<T>, Value<T>];
 /** Data or `null` to indicate the data doesn't exist. */
 export declare type OptionalData<T extends Data> = T | null;
 /** Empty data object. */
 export declare type EmptyData = {
     readonly [K in never]: never;
 };
-/** Key for a prop in a data object. */
-export declare type Key<T extends Data> = keyof T & string;
-/** Value for a prop in a data object. */
-export declare type Value<T extends Data> = T[Key<T>];
-/** Prop of a data object in entry format. */
-export declare type Prop<T extends Data> = readonly [Key<T>, Value<T>];
 /** Set of named data objects. */
 export declare type Datas = {
-    readonly [key: string]: Data;
+    readonly [K in string]: Data;
 };
 /** 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 props. */
-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;
-/**
- * Extract the value of a named prop from a data object.
- * - Extraction is possibly deep if deeper keys are specified.
- *
- * @param obj The target object to get from.
- * @param k1 The key of the prop in the object to get.
- * @param k2 The sub-key of the prop in the object to get.
- * @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 getProp<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]>(obj: T, k1: K1, k2: K2, k3: K3, k4: K4): T[K1][K2][K3][K4];
-export declare function getProp<T extends Data, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, k1: K1, k2: K2, k3: K3): T[K1][K2][K3];
-export declare function getProp<T extends Data, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, k1: K1, k2: K2): T[K1][K2];
-export declare function getProp<T extends Data, K1 extends keyof T>(obj: T, k1: K1): T[K1];
-/**
- * Set a prop on a data object with known shape (immutably).
- *
- * @param data 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).
- */
-export declare function withProp<T extends Data, K extends Key<T>>(data: T, key: K, value: T[K]): T;
-/**
- * Set several props on a data object with known shape (immutably).
- *
- * @param data The input data object.
- * @return New object with the specified prop added (or same object if no props changed).
- */
-export declare function withProps<T extends Data>(data: T, props: T | Partial<T>): T;
-/**
- * Set a single named prop on an object with a known shape (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 declare function setProp<T extends Data, K extends keyof T>(data: T, key: K, value: T[K]): T[K];
-/**
- * Set several named props on a data object with a known shape (by reference).
- *
- * @param data The target data object to modify.
- * @param props An object containing new props to set on the object.
- */
-export declare function setProps<T extends Data>(data: T, props: {
-    [K in keyof T]?: T[K];
-}): void;
 /**
  * Mutable type is the opposite of `Readonly<T>` helper type.
  * - See https://github.com/microsoft/TypeScript/issues/24509

package/modules/util/data.js

@@ -1,63 +1,12 @@
 import { RequiredError } from "../error/RequiredError.js";
 /** Is an unknown value a data object? */
 export const isData = (value) => typeof value === "object" && value !== null;
-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`). */
 export function getData(result) {
     if (!result)
         throw new RequiredError("Data is required");
     return 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];
-}
-/**
- * Set a prop on a data object with known shape (immutably).
- *
- * @param data 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).
- */
-export function withProp(data, key, value) {
-    return data[key] === value ? data : { ...data, [key]: value };
-}
-/**
- * Set several props on a data object with known shape (immutably).
- *
- * @param data The input data object.
- * @return New object with the specified prop added (or same object if no props changed).
- */
-export function withProps(data, props) {
-    for (const [k, v] of Object.entries(props))
-        if (data[k] !== v)
-            return { ...data, ...props };
-    return data;
-}
-/**
- * Set a single named prop on an object with a known shape (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;
-    return value;
-}
-/**
- * Set several named props on a data object with a known shape (by reference).
- *
- * @param data The target data object to modify.
- * @param props An object containing new props to set on the object.
- */
-export function setProps(data, props) {
-    for (const [k, v] of getProps(props))
-        data[k] = v;
-}
 /**
  * Format a data object as a string.
  * - Use the custom `.toString()` function if it exists (don't use built in `Object.prototype.toString` because it's useless.

package/modules/util/entry.d.ts

@@ -8,9 +8,9 @@ import { ImmutableMap } from "./map.js";
  */
 export declare type Entry<K, T> = readonly [K, T];
 /** Extract the type for the value of an entry. */
-export declare type EntryKeyType<X> = X extends Entry<infer Y, unknown> ? Y : never;
+export declare type EntryKey<X> = X extends Entry<infer Y, unknown> ? Y : never;
 /** Extract the type for the value of an entry. */
-export declare type EntryValueType<X> = X extends Entry<unknown, infer Y> ? Y : never;
+export declare type EntryValue<X> = X extends Entry<unknown, infer Y> ? Y : never;
 /** Extract the key from an object entry. */
 export declare const getEntryKey: <K, T>([k]: Entry<K, T>) => K;
 /** Extract the value from an object entry. */

package/modules/util/object.d.ts

@@ -1,5 +1,6 @@
 import type { ImmutableArray } from "./array.js";
-import type { NotString } from "./string.js";
+import type { Data, Prop } from "./data.js";
+import type { Entry } from "./entry.js";
 /** Readonly object with string keys. */
 export declare type ImmutableObject<T = unknown> = {
     readonly [key: string | number]: T;
@@ -8,8 +9,6 @@ export declare type ImmutableObject<T = unknown> = {
 export declare type MutableObject<T = unknown> = {
     [key: string | number]: T;
 };
-/** Extract the type for the values of an object. */
-export declare type ObjectType<T extends ImmutableObject> = T[keyof T];
 /**
  * Is a value an unknown object?
  * - This is a TypeScript assertion object that asserts the value extends `ImmutableObject`
@@ -23,75 +22,84 @@ export declare function isPlainObject<T extends ImmutableObject>(value: T | unkn
 /** Assert that a value is a plain object */
 export declare function assertPlainObject<T extends ImmutableObject>(value: T | unknown): asserts value is T;
 /** Is an unknown string an own prop of an object. */
-export declare const isEntry: <T extends ImmutableObject<unknown>>(obj: T, key: unknown) => key is keyof T;
+export declare const isProp: <T extends ImmutableObject<unknown>>(obj: T, key: unknown) => key is keyof T;
+/** Turn a data object into an array of props. */
+export declare function getProps<T extends Data>(data: T): ImmutableArray<Prop<T>>;
+export declare function getProps<T extends Data>(data: T | Partial<T>): ImmutableArray<Prop<T>>;
+export declare function getProps<T extends ImmutableObject>(data: T): ImmutableArray<Entry<keyof T, T[keyof T]>>;
+export declare function getProps<T extends ImmutableObject>(data: T | Partial<T>): ImmutableArray<Entry<keyof T, T[keyof T]>>;
 /**
- * Add a key/value entry to a map-like object (immutably).
+ * Extract the value of a named prop from a data object.
+ * - Extraction is possibly deep if deeper keys are specified.
  *
- * @param input The input object.
+ * @param obj The target object to get from.
+ * @param k1 The key of the prop in the object to get.
+ * @param k2 The sub-key of the prop in the object to get.
+ * @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 getProp<T extends ImmutableObject, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(obj: T, k1: K1, k2: K2, k3: K3, k4: K4): T[K1][K2][K3][K4];
+export declare function getProp<T extends ImmutableObject, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, k1: K1, k2: K2, k3: K3): T[K1][K2][K3];
+export declare function getProp<T extends ImmutableObject, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, k1: K1, k2: K2): T[K1][K2];
+export declare function getProp<T extends ImmutableObject, K1 extends keyof T>(obj: T, k1: K1): T[K1];
+/**
+ * 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 entry (or same object if entry value didn't change).
+ * @return New object without the specified prop (or same object if prop value didn't change).
  */
-export declare const withEntry: <T>(input: ImmutableObject<T>, key: string, value: T) => ImmutableObject<T>;
+export declare function withProp<T extends ImmutableObject, K extends keyof T>(input: T, key: K, value: T[K]): T;
 /**
- * Add several key/value entries on a map-like object (immutably).
+ * Set several props on an object (immutably).
  *
- * @param input The input object.
- * @return New object with the specified entries added (or same object if no entries changed).
+ * @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).
  */
-export declare const withEntries: <T>(input: ImmutableObject<T>, entries: ImmutableObject<T>) => ImmutableObject<T>;
+export declare function withProps<T extends ImmutableObject>(input: T, props: T | Partial<T>): T;
 /**
- * Remove a key/value entry from a map-like object (immutably).
+ * Remove several key/value entries from an object (immutably).
  *
  * @param input The input object.
- * @param key The key of the entry to remove.
- * @param value The value of the entry to remove. If not undefined, the entry will only be removed if its current value is exactly `value`
+ * @param keys Set of keys for props to remove.
  *
- * @return New object without the specified entries (or same object if the entry didn't exist).
- * - If `key` doesn't already exist in `obj` then the exact same input object will be returned.
+ * @return New object without the specified entries (or same object if none of the entries existed).
  */
-export declare function withoutEntry<T>(input: ImmutableObject<T>, key: string, value?: T): ImmutableObject<T>;
+export declare function withoutProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Omit<T, K>;
 /**
- * Remove several key/value entries from a map-like object (immutably).
+ * Pick several props from an object (immutably).
  *
  * @param input The input object.
- * @param keys Set of keys or entries to remove.
+ * @param keys Set of keys for props to pick.
  *
- * @return New object without the specified entries (or same object if none of the entries existed).
- * - If every entry already exists and has the exact same input object will be returned.
+ * @return New object with only the specified props.
  */
-export declare function withoutEntries<T>(input: ImmutableObject<T>, keys: Iterable<string> & NotString): ImmutableObject<T>;
+export declare function pickProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: (keyof T)[]): Pick<T, K>;
 /**
- * Set a key/value entry on a map-like object (by reference).
+ * Set a single named prop on an object (by reference).
  *
- * @param obj The target object to modify.
+ * @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 declare const setEntry: <T>(obj: MutableObject<T>, key: string, value: T) => T;
-/**
- * Set several key/value entries on a map-like object (by reference).
- *
- * @param obj The target object to modify.
- * @param entries An object containing new props to set on the object.
- */
-export declare const setEntries: <T>(obj: MutableObject<T>, entries: ImmutableObject<T>) => void;
+export declare function setProp<T extends MutableObject, K extends keyof T>(data: T, key: K, value: T[K]): T[K];
 /**
- * Remove a key/value entry from a map-like object (by reference).
+ * Set several named props on an object (by reference).
  *
  * @param obj The target object to modify.
- * @param key The key of the entry to remove.
- * @param value The value of the entry to remove. If set, the entry will only be removed if its current value is exactly `value`
+ * @param props An object containing new props to set on the object.
  */
-export declare function deleteEntry<T>(obj: MutableObject<T>, key: string, value?: T): void;
+export declare function setProps<T extends MutableObject>(obj: T, props: Partial<T>): void;
 /**
- * Remove several key/value entries from a map-like object (by reference).
+ * Remove several key/value entries from an object (by reference).
  *
  * @param obj The target object to modify.
- * @param entries Set of keys or entries to remove.
+ * @param keys Set of keys or keys to remove.
  */
-export declare function deleteEntries<T>(obj: MutableObject<T>, keys: ImmutableArray<string>): void;
+export declare function deleteProps<T extends MutableObject>(obj: T, ...keys: (keyof T)[]): void;
 /** Type that represents an empty object. */
 export declare type EmptyObject = {
     readonly [K in never]: never;
@@ -99,4 +107,4 @@ export declare type EmptyObject = {
 /** An empty object. */
 export declare const EMPTY_OBJECT: EmptyObject;
 /** Function that returns an an empty object. */
-export declare const GET_EMPTY_OBJECT: () => EmptyObject;
+export declare const getEmptyObject: () => EmptyObject;

package/modules/util/object.js

@@ -1,5 +1,4 @@
 import { AssertionError } from "../error/AssertionError.js";
-import { setProp, setProps, withProp, withProps } from "./data.js";
 /**
  * Is a value an unknown object?
  * - This is a TypeScript assertion object that asserts the value extends `ImmutableObject`
@@ -25,97 +24,101 @@ export function assertPlainObject(value) {
         throw new AssertionError(`Must be plain object`, value);
 }
 /** Is an unknown string an own prop of an object. */
-export const isEntry = (obj, key) => (typeof key === "string" || typeof key === "number" || typeof key === "symbol") && Object.prototype.hasOwnProperty.call(obj, key);
+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);
+}
+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];
+}
 /**
- * Add a key/value entry to a map-like object (immutably).
+ * Set a prop on an object (immutably).
  *
- * @param input The input object.
+ * @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 entry (or same object if entry value didn't change).
+ * @return New object without the specified prop (or same object if prop value didn't change).
  */
-export const withEntry = withProp;
+export function withProp(input, key, value) {
+    return input[key] === value ? input : { ...input, [key]: value };
+}
 /**
- * Add several key/value entries on a map-like object (immutably).
+ * Set several props on an object (immutably).
  *
- * @param input The input object.
- * @return New object with the specified entries added (or same object if no entries changed).
+ * @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).
  */
-export const withEntries = withProps;
+export function withProps(input, props) {
+    for (const [k, v] of Object.entries(props))
+        if (input[k] !== v)
+            return { ...input, ...props };
+    return input;
+}
 /**
- * Remove a key/value entry from a map-like object (immutably).
+ * Remove several key/value entries from an object (immutably).
  *
  * @param input The input object.
- * @param key The key of the entry to remove.
- * @param value The value of the entry to remove. If not undefined, the entry will only be removed if its current value is exactly `value`
+ * @param keys Set of keys for props to remove.
  *
- * @return New object without the specified entries (or same object if the entry didn't exist).
- * - If `key` doesn't already exist in `obj` then the exact same input object will be returned.
+ * @return New object without the specified entries (or same object if none of the entries existed).
  */
-export function withoutEntry(input, key, value) {
-    if (isEntry(input, key) && (value === undefined || input[key] === value)) {
-        const { [key]: unused, ...output } = input;
-        return output;
-    }
+export function withoutProps(input, ...keys) {
+    for (const key of keys)
+        if (key in input)
+            return Object.fromEntries(Object.entries(input).filter(_doesntHaveKey, keys));
     return input;
 }
+function _doesntHaveKey([key]) {
+    return !this.includes(key);
+}
 /**
- * Remove several key/value entries from a map-like object (immutably).
+ * Pick several props from an object (immutably).
  *
  * @param input The input object.
- * @param keys Set of keys or entries to remove.
+ * @param keys Set of keys for props to pick.
  *
- * @return New object without the specified entries (or same object if none of the entries existed).
- * - If every entry already exists and has the exact same input object will be returned.
+ * @return New object with only the specified props.
  */
-export function withoutEntries(input, keys) {
-    let changed = false;
-    const output = { ...input };
-    for (const key of keys)
-        if (isEntry(input, key)) {
-            delete output[key];
-            changed = true;
-        }
-    return changed ? output : input;
+export function pickProps(input, ...keys) {
+    return Object.fromEntries(Object.entries(input).filter(_doesHaveKey, keys));
+}
+function _doesHaveKey([key]) {
+    return this.includes(key);
 }
 /**
- * Set a key/value entry on a map-like object (by reference).
+ * Set a single named prop on an object (by reference).
  *
- * @param obj The target object to modify.
+ * @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 const setEntry = setProp;
-/**
- * Set several key/value entries on a map-like object (by reference).
- *
- * @param obj The target object to modify.
- * @param entries An object containing new props to set on the object.
- */
-export const setEntries = setProps;
+export function setProp(data, key, value) {
+    data[key] = value;
+    return value;
+}
 /**
- * Remove a key/value entry from a map-like object (by reference).
+ * Set several named props on an object (by reference).
  *
  * @param obj The target object to modify.
- * @param key The key of the entry to remove.
- * @param value The value of the entry to remove. If set, the entry will only be removed if its current value is exactly `value`
+ * @param props An object containing new props to set on the object.
  */
-export function deleteEntry(obj, key, value) {
-    if (value === undefined || obj[key] === value)
-        delete obj[key];
+export function setProps(obj, props) {
+    for (const [k, v] of getProps(props))
+        obj[k] = v;
 }
 /**
- * Remove several key/value entries from a map-like object (by reference).
+ * Remove several key/value entries from an object (by reference).
  *
  * @param obj The target object to modify.
- * @param entries Set of keys or entries to remove.
+ * @param keys Set of keys or keys to remove.
  */
-export function deleteEntries(obj, keys) {
+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 GET_EMPTY_OBJECT = () => EMPTY_OBJECT;
+export const getEmptyObject = () => EMPTY_OBJECT;

package/modules/util/transform.d.ts

@@ -1,7 +1,7 @@
-import { Data, Value, Prop } from "./data.js";
-import { Entry } from "./entry.js";
-import type { ImmutableObject } from "./object.js";
 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";
 /** Object that transforms an input value into an output value with its `transform()` method. */
 export interface Transformable<I, O> {
     transform(input: I): O;
@@ -20,26 +20,24 @@ export declare type Transformers<T extends Data> = {
     readonly [K in keyof T]?: Transformer<T[K], T[K]>;
 };
 /**
- * Transform the props of a data object using a set of transformers for its props.
- * @returns New object with changed props (or the same object if no changes were made).
+ * 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 prop transformers.
- * @yield Transformed prop entry after calling the corresponding prop transformer.
+ * 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>(data: T, transforms: Transformers<T>): Iterable<Prop<T>>;
+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: (v: I) => O): Iterable<Entry<K, O>>;
 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: (v: I) => O): ImmutableObject<O>;
 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.
@@ -53,12 +51,10 @@ export declare function mapData<I extends Data, O extends {
  * 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: (input: I) => O): Iterable<O>;
 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: (v: I) => O): ImmutableArray<O>;
 export declare function mapArray<I, O>(arr: Iterable<I>, transformer: Transformer<I, O>): ImmutableArray<O>;

package/modules/util/transform.js

@@ -1,36 +1,48 @@
 import { isFunction } from "./function.js";
-import { getProps, isData } from "./data.js";
 import { getEntries } from "./entry.js";
+import { getProps, isObject } from "./object.js";
 /** Is an unknown value a transformable. */
-export const isTransformable = (v) => isData(v) && typeof v.transform === "function";
+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 transformers for its props.
- * @returns New object with changed props (or the same object if no changes were made).
+ * 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)) };
 }
 /**
- * Transform the props of a data object using a set of prop transformers.
- * @yield Transformed prop entry after calling the corresponding prop 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(data, transforms) {
+export function* transformProps(obj, transforms) {
     for (const [k, v] of getProps(transforms))
-        yield [k, transform(data[k], v)];
+        yield [k, transform(obj[k], v)];
 }
+/**
+ * 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* 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));
 }
 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);

package/modules/util/validate.d.ts

@@ -1,6 +1,6 @@
 import type { Entry } from "./entry.js";
-import type { ImmutableObject } from "./object.js";
-import { Data, Prop } from "./data.js";
+import type { Data, Prop } from "./data.js";
+import { ImmutableObject } from "./object.js";
 import { ImmutableArray } from "./array.js";
 /** Object that can validate an unknown value with its `validate()` method. */
 export interface Validatable<T> {

package/modules/util/validate.js

@@ -1,6 +1,6 @@
 import { isFeedback } from "../feedback/Feedback.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { getProps } from "./data.js";
+import { getProps } from "./object.js";
 import { getArray } from "./array.js";
 /** Validate an unknown value with a validator. */
 export function validate(unsafeValue, validator) {

package/package.json

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