shelving 1.78.0 → 1.80.1

package/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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. */