shelving 1.83.0 → 1.83.2

package/constraint/Constraints.d.ts

@@ -14,7 +14,7 @@ export declare abstract class Constraints<T extends Data, C extends Constraint<P
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints: C[]): this;
     /** Clone this set of constraints but remove specific constraints. */
-    without(...constraints: C[]): this;
+    omit(...constraints: C[]): this;
     /** Iterate over the constraints. */
     [Symbol.iterator](): Iterator<C, void>;
 }

package/constraint/Constraints.js

@@ -1,4 +1,4 @@
-import { withArrayItems, withoutArrayItems } from "../util/array.js";
+import { withArrayItems, omitArrayItems } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export class Constraints extends Constraint {
@@ -24,8 +24,8 @@ export class Constraints extends Constraint {
         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 = withoutArrayItems(this._constraints, ...constraints);
+    omit(...constraints) {
+        const _constraints = omitArrayItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Iterate over the constraints. */

package/constraint/QueryConstraints.js

@@ -1,6 +1,6 @@
 import { getProp } from "../util/object.js";
 import { assert } from "../util/assert.js";
-import { limitItems } from "../util/iterate.js";
+import { limitArray } from "../util/array.js";
 import { FilterConstraints } from "./FilterConstraints.js";
 import { SortConstraints } from "./SortConstraints.js";
 import { Constraint } from "./Constraint.js";
@@ -83,7 +83,7 @@ export class QueryConstraints extends Constraint {
     // Implement `Rule`
     transform(items) {
         const sorted = this.sorts.transform(this.filters.transform(items));
-        return typeof this.limit === "number" ? limitItems(sorted, this.limit) : sorted;
+        return typeof this.limit === "number" ? limitArray(sorted, this.limit) : sorted;
     }
     // Implement toString()
     toString() {

package/db/Query.js

@@ -1,5 +1,4 @@
-import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
-import { countItems, hasItems } from "../util/iterate.js";
+import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem, isArrayMin, countArray } from "../util/array.js";
 import { runSequence } from "../util/sequence.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
 /** Reference to a set of items in a sync or async provider. */
@@ -31,7 +30,7 @@ export class Query extends BaseQuery {
         return this.value.length;
     }
     get exists() {
-        return hasItems(this.max(1).value);
+        return !!this.max(1).value.length;
     }
     get firstValue() {
         return getOptionalFirstItem(this.max(1).value);
@@ -66,10 +65,10 @@ export class AsyncQuery extends BaseQuery {
         return this.db.provider.getQuery(this.collection, this);
     }
     get count() {
-        return this.value.then(countItems);
+        return this.value.then(countArray);
     }
     get exists() {
-        return this.max(1).value.then(hasItems);
+        return this.max(1).value.then(isArrayMin);
     }
     get firstValue() {
         return this.max(1).value.then(getOptionalFirstItem);

package/feedback/Feedback.d.ts

@@ -1,4 +1,4 @@
-import type { ImmutableDictionary } from "../util/dictionary.js";
+import { Entry } from "../util/entry.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -21,7 +21,7 @@ export declare class Feedback<T = unknown> {
 /** Is an unknown value a `Feedback` object. */
 export declare const isFeedback: <T extends Feedback<unknown>>(v: unknown) => v is Feedback<unknown>;
 /**
- * Get an object of sub-messages in `{ key: message }` format from a feedback's value.
+ * Yield the sub-messages in `[key: string, message: string]` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.
  */
-export declare const getFeedbackMessages: ({ value }: Feedback) => ImmutableDictionary<string>;
+export declare function getFeedbackMessages({ value }: Feedback): Iterable<Entry<string, string>>;

package/feedback/Feedback.js

@@ -31,11 +31,10 @@ __decorate([
 /** Is an unknown value a `Feedback` object. */
 export const isFeedback = (v) => isObject(v) && typeof v.name === "string" && v.name.endsWith("Feedback") && typeof v.message === "string";
 /**
- * Get an object of sub-messages in `{ key: message }` format from a feedback's value.
+ * Yield the sub-messages in `[key: string, message: string]` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.
  */
-export const getFeedbackMessages = ({ value }) => Object.fromEntries(_yieldFeedbackMessages(value));
-function* _yieldFeedbackMessages(value) {
+export function* getFeedbackMessages({ value }) {
     if (isObject(value))
         for (const [k, v] of getEntries(value))
             if (isFeedback(v))

package/package.json

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

package/schema/Schema.d.ts

@@ -15,13 +15,13 @@ export declare type SchemaOptions = {
  */
 export declare abstract class Schema<T extends unknown = unknown> implements Validatable<T> {
     /** Title, e.g. for showing in fields. */
-    readonly title: string;
+    readonly title?: string;
     /** Description, e.g. for showing in fields. */
-    readonly description: string;
+    readonly description?: string;
     /** Placeholder, e.g. for showing in fields. */
-    readonly placeholder: string;
+    readonly placeholder?: string;
     /** Default value. */
-    readonly value: unknown;
+    readonly value?: unknown;
     constructor({ title, description, placeholder }: SchemaOptions);
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;

package/state/ArrayState.js

@@ -1,4 +1,4 @@
-import { toggleArrayItems, withArrayItems, withoutArrayItems } from "../util/array.js";
+import { toggleArrayItems, withArrayItems, omitArrayItems } 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 {
@@ -15,7 +15,7 @@ export class ArrayState extends State {
     }
     /** Remove items from this array. */
     delete(...items) {
-        this.set(withoutArrayItems(this.value, ...items));
+        this.set(omitArrayItems(this.value, ...items));
     }
     /** Toggle items in this array. */
     toggle(...items) {

package/state/DictionaryState.js

@@ -1,4 +1,4 @@
-import { withoutDictionaryItems } from "../util/dictionary.js";
+import { omitDictionaryItems } from "../util/dictionary.js";
 import { transformDictionary } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a dictionary object and has additional methods to help with that. */
@@ -16,7 +16,7 @@ export class DictionaryState extends State {
     }
     /** Remove a named entry from this object. */
     delete(...keys) {
-        this.set(withoutDictionaryItems(this.value, ...keys));
+        this.set(omitDictionaryItems(this.value, ...keys));
     }
     /** Iterate over the entries of the object. */
     [Symbol.iterator]() {

package/update/ArrayUpdate.d.ts

@@ -4,16 +4,16 @@ import { Update } from "./Update.js";
 /** Update that can be applied to an array to add/remove items. */
 export declare class ArrayUpdate<T> extends Update<ImmutableArray<T>> {
     /** Return an array update with an item marked for addition. */
-    static with<X>(...adds: X[]): ArrayUpdate<X>;
+    static add<X>(...adds: X[]): ArrayUpdate<X>;
     /** Return an array update with an item marked for deletion. */
-    static without<X>(...deletes: X[]): ArrayUpdate<X>;
+    static delete<X>(...deletes: X[]): ArrayUpdate<X>;
     readonly adds: ImmutableArray<T>;
     readonly deletes: ImmutableArray<T>;
     constructor(adds?: ImmutableArray<T>, deletes?: ImmutableArray<T>);
-    transform(arr?: ImmutableArray<T>): ImmutableArray<T>;
-    validate(validator: Validator<ImmutableArray<T>>): this;
     /** Return an array update with an additional item marked for addition. */
-    with(...adds: T[]): this;
+    add(...adds: T[]): this;
     /** Return an array update with an additional item marked for deletion. */
-    without(...deletes: T[]): this;
+    delete(...deletes: T[]): this;
+    transform(arr?: ImmutableArray<T>): ImmutableArray<T>;
+    validate(validator: Validator<ImmutableArray<T>>): this;
 }

package/update/ArrayUpdate.js

@@ -1,5 +1,5 @@
 import { ArraySchema } from "../schema/ArraySchema.js";
-import { withArrayItems, withoutArrayItems } from "../util/array.js";
+import { withArrayItems, omitArrayItems } from "../util/array.js";
 import { validateArray } from "../util/validate.js";
 import { Update } from "./Update.js";
 /** Update that can be applied to an array to add/remove items. */
@@ -10,40 +10,42 @@ export class ArrayUpdate extends Update {
         this.deletes = deletes;
     }
     /** Return an array update with an item marked for addition. */
-    static with(...adds) {
+    static add(...adds) {
         return new ArrayUpdate(adds);
     }
     /** Return an array update with an item marked for deletion. */
-    static without(...deletes) {
+    static delete(...deletes) {
         return new ArrayUpdate([], deletes);
     }
-    transform(arr = []) {
-        return withoutArrayItems(withArrayItems(arr, ...this.adds), ...this.deletes);
-    }
-    validate(validator) {
-        if (!(validator instanceof ArraySchema))
-            return super.validate(validator);
+    /** Return an array update with an additional item marked for addition. */
+    add(...adds) {
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            adds: validateArray(this.adds, validator.items),
-            deletes: validateArray(this.deletes, validator.items),
+            adds: [...this.adds, ...adds],
         };
     }
-    /** Return an array update with an additional item marked for addition. */
-    with(...adds) {
+    /** Return an array update with an additional item marked for deletion. */
+    delete(...deletes) {
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            adds: [...this.adds, ...adds],
+            deletes: [...this.deletes, ...deletes],
         };
     }
-    /** Return an array update with an additional item marked for deletion. */
-    without(...deletes) {
+    // Implement `Transformable`
+    transform(arr = []) {
+        return omitArrayItems(withArrayItems(arr, ...this.adds), ...this.deletes);
+    }
+    // Implement `Validatable`
+    validate(validator) {
+        if (!(validator instanceof ArraySchema))
+            return super.validate(validator);
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            deletes: [...this.deletes, ...deletes],
+            adds: validateArray(this.adds, validator.items),
+            deletes: validateArray(this.deletes, validator.items),
         };
     }
 }

package/update/DataUpdate.d.ts

@@ -23,13 +23,12 @@ export declare const updateData: <T extends Data>(data: T, updates: Updates<T>)
  */
 export declare class DataUpdate<T extends Data = Data> extends Update<T> implements Iterable<DataProp<Updates<T>>>, Transformable<T, T> {
     /** Return a data update with a specific prop marked for update. */
-    static with<X extends Data, K extends DataKey<X>>(key: Nullish<K>, value: X[K] | Update<X[K]>): DataUpdate<X>;
+    static update<X extends Data, K extends DataKey<X>>(key: Nullish<K>, value: X[K] | Update<X[K]>): DataUpdate<X>;
     readonly updates: Updates<T>;
     constructor(props: Updates<T>);
+    /** Return a data update with a specific prop marked for update. */
+    update<K extends DataKey<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
     transform(data: T): T;
     validate(validator: Validator<T>): this;
-    /** Return a data update with a specific prop marked for update. */
-    with<K extends DataKey<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
-    /** Iterate over the transforms in this object. */
     [Symbol.iterator](): Iterator<DataProp<Updates<T>>, void>;
 }

package/update/DataUpdate.js

@@ -41,12 +41,24 @@ export class DataUpdate extends Update {
         this.updates = props;
     }
     /** Return a data update with a specific prop marked for update. */
-    static with(key, value) {
+    static update(key, value) {
         return new DataUpdate(!isNullish(key) ? { [key]: value } : {});
     }
+    /** Return a data update with a specific prop marked for update. */
+    update(key, value) {
+        if (isNullish(key))
+            return this;
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            updates: { ...this.updates, [key]: value },
+        };
+    }
+    // Implement `Transformable`
     transform(data) {
         return updateData(data, this.updates);
     }
+    // Implement `Validatable`
     validate(validator) {
         if (!(validator instanceof DataSchema))
             return super.validate(validator);
@@ -56,17 +68,7 @@ export class DataUpdate extends Update {
             updates: validateUpdates(this.updates, validator.props),
         };
     }
-    /** Return a data update with a specific prop marked for update. */
-    with(key, value) {
-        if (isNullish(key))
-            return this;
-        return {
-            __proto__: Object.getPrototypeOf(this),
-            ...this,
-            updates: { ...this.updates, [key]: value },
-        };
-    }
-    /** Iterate over the transforms in this object. */
+    // Implement `Iterable`
     [Symbol.iterator]() {
         return Object.entries(this.updates).values();
     }

package/update/DictionaryUpdate.d.ts

@@ -9,21 +9,16 @@ export declare type DictionaryUpdates<T> = ImmutableDictionary<T | Update<T> | D
 /** Update that can be applied to a dictionary object to add/remove/update its entries. */
 export declare class DictionaryUpdate<T> extends Update<ImmutableDictionary<T>> implements Iterable<Entry<string, T | Update<T> | Delete>> {
     /** Return a dictionary update with a specific entry marked for update. */
-    static with<X>(key: Nullish<string>, value: X | Update<X> | Delete): DictionaryUpdate<X>;
+    static update<X>(key: Nullish<string>, value: X | Update<X> | Delete): DictionaryUpdate<X>;
     /** Return a dictionary update with a specific entry marked for deletion. */
-    static without<X>(key: Nullish<string>): DictionaryUpdate<X>;
+    static delete<X>(key: Nullish<string>): DictionaryUpdate<X>;
     readonly updates: DictionaryUpdates<T>;
     constructor(updates?: DictionaryUpdates<T>);
-    transform(obj?: ImmutableDictionary<T>): ImmutableDictionary<T>;
-    validate(validator: Validator<ImmutableDictionary<T>>): this;
     /** Return a dictionary update with a specific entry marked for update. */
-    with(key: Nullish<string>, value: T | Update<T>): this;
+    update(key: Nullish<string>, value: T | Update<T>): this;
     /** Return a dictionary 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.
-     */
+    delete(key: Nullish<string>): this;
+    transform(obj?: ImmutableDictionary<T>): ImmutableDictionary<T>;
+    validate(validator: Validator<ImmutableDictionary<T>>): this;
     [Symbol.iterator](): Iterator<Entry<string, T | Update<T> | Delete>, void>;
 }

package/update/DictionaryUpdate.js

@@ -13,27 +13,15 @@ export class DictionaryUpdate extends Update {
         this.updates = updates;
     }
     /** Return a dictionary update with a specific entry marked for update. */
-    static with(key, value) {
+    static update(key, value) {
         return new DictionaryUpdate(isNullish(key) ? {} : { [key]: value });
     }
     /** Return a dictionary update with a specific entry marked for deletion. */
-    static without(key) {
+    static delete(key) {
         return new DictionaryUpdate(isNullish(key) ? {} : { [key]: DELETE });
     }
-    transform(obj = {}) {
-        return Object.fromEntries(_transformDictionaryEntries(obj, this.updates));
-    }
-    validate(validator) {
-        if (!(validator instanceof DictionarySchema))
-            return super.validate(validator);
-        return {
-            __proto__: Object.getPrototypeOf(this),
-            ...this,
-            updates: Object.fromEntries(_validateDictionaryUpdates(this.updates, validator.items)),
-        };
-    }
     /** Return a dictionary update with a specific entry marked for update. */
-    with(key, value) {
+    update(key, value) {
         if (isNullish(key))
             return this;
         return {
@@ -43,7 +31,7 @@ export class DictionaryUpdate extends Update {
         };
     }
     /** Return a dictionary update with a specific entry marked for deletion. */
-    without(key) {
+    delete(key) {
         if (isNullish(key))
             return this;
         return {
@@ -52,11 +40,21 @@ export class DictionaryUpdate extends Update {
             updates: { ...this.updates, [key]: DELETE },
         };
     }
-    /**
-     * Iterate over the changes in this object.
-     * - Updates are yielded first, then deletes.
-     * - Entries whose value is `undefined` indicate deletion.
-     */
+    // Implement `Transformable`
+    transform(obj = {}) {
+        return Object.fromEntries(_transformDictionaryEntries(obj, this.updates));
+    }
+    // Implement `Validatable`
+    validate(validator) {
+        if (!(validator instanceof DictionarySchema))
+            return super.validate(validator);
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            updates: Object.fromEntries(_validateDictionaryUpdates(this.updates, validator.items)),
+        };
+    }
+    // Implement `Iterable`
     *[Symbol.iterator]() {
         for (const entry of Object.entries(this.updates))
             yield entry;

package/update/Increment.js

@@ -8,6 +8,7 @@ export class Increment extends Update {
         super();
         this.amount = amount;
     }
+    // Implement `Transformable`
     transform(existing) {
         return typeof existing === "number" ? existing + this.amount : this.amount;
     }

package/update/Update.d.ts

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

package/update/Update.js

@@ -4,7 +4,7 @@ import { validate } from "../util/validate.js";
  * - Implements `Transformable` for applying that update with its `transform()` method.
  */
 export class Update {
-    /** Validate this update's values against a validator. */
+    // Implement `Validatable`
     validate(validator) {
         validate(this.transform(), validator);
         return this;

package/util/array.d.ts

@@ -10,6 +10,8 @@ export declare type MutableArray<T = unknown> = T[];
 export declare type ImmutableArray<T = unknown> = readonly T[];
 /** Get the type of the _items_ in an array. */
 export declare type ArrayItem<T extends ImmutableArray> = T[number];
+/** Things that can be converted to arrays. */
+export declare type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
 /** Is an unknown value an array? */
 export declare const isArray: <T extends ImmutableArray<unknown>>(v: unknown) => v is T;
 /** Assert that a value is an array. */
@@ -17,14 +19,14 @@ export declare function assertArray<T>(arr: ImmutableArray<T> | unknown): assert
 /** Is an unknown value an item in a specified array? */
 export declare const isArrayItem: <T>(arr: ImmutableArray<T>, item: unknown) => item is T;
 export declare const isItem: <T>(arr: ImmutableArray<T>, item: unknown) => item is T;
-/** Things that can be converted to arrays. */
-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 multiple items to an array (immutably) and return a new array with those items (or the same array if no changes were made). */
 export declare function withArrayItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
+/** Pick multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
+export declare function pickArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...pick: T[]): ImmutableArray<T>;
 /** Remove multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
-export declare function withoutArrayItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
+export declare function omitArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...omit: T[]): ImmutableArray<T>;
 /** Toggle an item in and out of an array (immutably) and return a new array with or without the specified items (or the same array if no changes were made). */
 export declare function toggleArrayItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
 /** Get the first item from an array or iterable, or `null` if it didn't exist. */
@@ -46,11 +48,13 @@ export declare function addArrayItem<T>(arr: MutableArray<T>, item: T): T;
 /** Add multiple items to an array (by reference). */
 export declare function addArrayItems<T>(arr: MutableArray<T>, ...items: T[]): void;
 /** Remove multiple items from an array (by reference). */
-export declare function removeArrayItems<T>(arr: MutableArray<T>, ...items: T[]): void;
+export declare function deleteArrayItems<T>(arr: MutableArray<T>, ...items: T[]): void;
 /** Return an array of the unique items in an array. */
 export declare function uniqueArray<T>(input: Iterable<T>): ImmutableArray<T>;
 /** Apply a limit to an array. */
-export declare function limitArray<T>(arr: ImmutableArray<T>, limit: number): ImmutableArray<T>;
+export declare function limitArray<T>(items: Iterable<T>, limit: number): ImmutableArray<T>;
+/** Count the items in an array. */
+export declare function countArray<T>(arr: ImmutableArray<T>): number;
 /** Does an array have the specified minimum length.  */
 export declare function isArrayMin<T>(arr: ImmutableArray<T>, min?: 1): arr is [T, ...T[]];
 export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: 2): arr is [T, T, ...T[]];

package/util/array.js

@@ -1,5 +1,6 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
+import { omitItems, pickItems } from "./iterate.js";
 /** Is an unknown value an array? */
 export const isArray = (v) => Array.isArray(v);
 /** Assert that a value is an array. */
@@ -19,14 +20,19 @@ export function withArrayItems(input, ...items) {
     const extras = items.filter(_doesNotInclude, input);
     return extras.length ? [...input, ...extras] : input;
 }
-/** Remove multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
-export function withoutArrayItems(input, ...items) {
-    const output = input.filter(_doesNotInclude, items);
-    return output.length === input.length ? input : output;
-}
 function _doesNotInclude(value) {
     return !this.includes(value);
 }
+/** Pick multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
+export function pickArrayItems(input, ...pick) {
+    const output = Array.from(pickItems(input, ...pick));
+    return isArray(input) && output.length === input.length ? input : output;
+}
+/** Remove multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
+export function omitArrayItems(input, ...omit) {
+    const output = Array.from(omitItems(input, ...omit));
+    return isArray(input) && output.length === input.length ? input : output;
+}
 /** Toggle an item in and out of an array (immutably) and return a new array with or without the specified items (or the same array if no changes were made). */
 export function toggleArrayItems(input, ...items) {
     const extras = items.filter(_doesNotInclude, input);
@@ -102,7 +108,7 @@ export function addArrayItems(arr, ...items) {
             arr.push(item);
 }
 /** Remove multiple items from an array (by reference). */
-export function removeArrayItems(arr, ...items) {
+export function deleteArrayItems(arr, ...items) {
     for (let i = arr.length - 1; i >= 0; i--)
         if (i in arr && items.includes(arr[i]))
             arr.splice(i, 1);
@@ -116,9 +122,14 @@ export function uniqueArray(input) {
     return output;
 }
 /** Apply a limit to an array. */
-export function limitArray(arr, limit) {
+export function limitArray(items, limit) {
+    const arr = getArray(items);
     return limit > arr.length ? arr : arr.slice(0, limit);
 }
+/** Count the items in an array. */
+export function countArray(arr) {
+    return arr.length;
+}
 export function isArrayMin(arr, min = 1) {
     return arr.length >= min;
 }

package/util/dictionary.d.ts

@@ -28,12 +28,12 @@ export declare const withDictionaryItem: <T>(input: ImmutableDictionary<T>, key:
 /** Set several props on a dictionary object (immutably) and return a new object including those props. */
 export declare const withDictionaryItems: <T>(input: ImmutableDictionary<T>, props: PossibleDictionary<T>) => ImmutableDictionary<T>;
 /** Remove several key/value entries from a dictionary object (immutably) and return a new object without those props. */
-export declare const withoutDictionaryItems: <T>(input: ImmutableDictionary<T>, ...keys: string[]) => ImmutableDictionary<T>;
+export declare const omitDictionaryItems: <T>(input: ImmutableDictionary<T>, ...keys: string[]) => ImmutableDictionary<T>;
 /** Pick several props from a dictionary object and return a new object with only thos props. */
 export declare const pickDictionaryItems: <T>(input: ImmutableDictionary<T>, ...keys: string[]) => ImmutableDictionary<T>;
 /** Set a single named prop on a dictionary object (by reference) and return its value. */
-export declare const setDictionaryEntry: <T>(dict: MutableDictionary<T>, key: string, value: T) => T;
+export declare const setDictionaryItem: <T>(dict: MutableDictionary<T>, key: string, value: T) => T;
 /** Set several named props on a dictionary object (by reference). */
-export declare const setDictionaryEntries: <T>(dict: MutableDictionary<T>, entries: PossibleDictionary<T>) => void;
+export declare const setDictionaryItems: <T>(dict: MutableDictionary<T>, entries: PossibleDictionary<T>) => void;
 /** Remove several key/value entries from a dictionary object (by reference). */
-export declare const deleteDictionaryEntries: <T extends MutableDictionary>(dict: T, ...keys: string[]) => void;
+export declare const deleteDictionaryItems: <T extends MutableDictionary>(dict: T, ...keys: string[]) => void;

package/util/dictionary.js

@@ -22,12 +22,12 @@ export const withDictionaryItem = withProp;
 /** Set several props on a dictionary object (immutably) and return a new object including those props. */
 export const withDictionaryItems = withProps;
 /** Remove several key/value entries from a dictionary object (immutably) and return a new object without those props. */
-export const withoutDictionaryItems = omitProps;
+export const omitDictionaryItems = omitProps;
 /** Pick several props from a dictionary object and return a new object with only thos props. */
 export const pickDictionaryItems = pickProps;
 /** Set a single named prop on a dictionary object (by reference) and return its value. */
-export const setDictionaryEntry = setProp;
+export const setDictionaryItem = setProp;
 /** Set several named props on a dictionary object (by reference). */
-export const setDictionaryEntries = setProps;
+export const setDictionaryItems = setProps;
 /** Remove several key/value entries from a dictionary object (by reference). */
-export const deleteDictionaryEntries = deleteProps;
+export const deleteDictionaryItems = deleteProps;

package/util/iterate.d.ts

@@ -1,15 +1,9 @@
-import type { ImmutableArray } from "./array.js";
 /**
  * Is a value an iterable object?
  * - Any object with a `Symbol.iterator` property is iterable.
  * - Note: Array and Map instances etc will return true because they implement `Symbol.iterator`
  */
 export declare const isIterable: <T extends Iterable<unknown>>(value: unknown) => value is T;
-/**
- * Count the number items of an iterable.
- * - Checks `items.size` or `items.length` first, or consumes the iterable and counts its iterations.
- */
-export declare function countItems(items: Iterable<unknown>): number;
 /** An iterable containing items or nested iterables of items. */
 export declare type DeepIterable<T> = T | Iterable<DeepIterable<T>>;
 /** Flatten one or more iterables. */
@@ -19,6 +13,8 @@ export declare function flattenItems<T>(items: DeepIterable<T>): Iterable<T>;
  * - Checks `items.size` or `items.length` first, or consumes the iterable and counts its iterations.
  */
 export declare function hasItems(items: Iterable<unknown>): boolean;
+/** Count the number of items in an iterable. */
+export declare function countItems(items: Iterable<unknown>): number;
 /**
  * Yield a range of numbers from `start` to `end`
  * - Yields in descending order if `end` is lower than `start`
@@ -29,6 +25,10 @@ export declare function getRange(start: number, end: number): Iterable<number>;
  * - Checks `items.size` or `items.length` first to see if the limit is necessary.
  */
 export declare function limitItems<T>(items: Iterable<T>, limit: number): Iterable<T>;
+/** Pick items from an iterable set of items. */
+export declare function pickItems<T>(items: Iterable<T>, ...pick: T[]): Iterable<T>;
+/** Omit items from an iterable set of items. */
+export declare function omitItems<T>(items: Iterable<T>, ...omit: T[]): Iterable<T>;
 /** Reduce an iterable set of items using a reducer function. */
 export declare function reduceItems<T>(items: Iterable<T>, reducer: (previous: T, item: T) => T, initial: T): T;
 export declare function reduceItems<T>(items: Iterable<T>, reducer: (previous: T | undefined, item: T) => T, initial?: T): T | undefined;
@@ -37,6 +37,6 @@ export declare function getChunks<T>(input: Iterable<T>, size: 1): Iterable<read
 export declare function getChunks<T>(input: Iterable<T>, size: 2): Iterable<readonly [T, T]>;
 export declare function getChunks<T>(input: Iterable<T>, size: 3): Iterable<readonly [T, T, T]>;
 export declare function getChunks<T>(input: Iterable<T>, size: 4): Iterable<readonly [T, T, T, T]>;
-export declare function getChunks<T>(input: Iterable<T>, size: number): Iterable<ImmutableArray<T>>;
+export declare function getChunks<T>(input: Iterable<T>, size: number): Iterable<readonly T[]>;
 /** Merge two or more iterables into a single iterable set. */
 export declare function mergeItems<T>(...inputs: [Iterable<T>, Iterable<T>, ...Iterable<T>[]]): Iterable<T>;

package/util/iterate.js

@@ -4,27 +4,6 @@
  * - Note: Array and Map instances etc will return true because they implement `Symbol.iterator`
  */
 export const isIterable = (value) => typeof value === "object" && !!value && Symbol.iterator in value;
-/** Get the known size or length of an object (e.g. `Array`, `Map`, and `Set` have known size), or return `undefined` if the size cannot be established. */
-function _getKnownSize(obj) {
-    if ("size" in obj && typeof obj.size === "number")
-        return obj.size;
-    if ("length" in obj && typeof obj.length === "number")
-        return obj.length;
-}
-/**
- * Count the number items of an iterable.
- * - Checks `items.size` or `items.length` first, or consumes the iterable and counts its iterations.
- */
-export function countItems(items) {
-    var _a;
-    return (_a = _getKnownSize(items)) !== null && _a !== void 0 ? _a : _countItems(items);
-}
-function _countItems(items) {
-    let count = 0;
-    for (const unused of items)
-        count++;
-    return count;
-}
 /** Flatten one or more iterables. */
 export function* flattenItems(items) {
     if (isIterable(items))
@@ -38,14 +17,17 @@ export function* flattenItems(items) {
  * - Checks `items.size` or `items.length` first, or consumes the iterable and counts its iterations.
  */
 export function hasItems(items) {
-    var _a;
-    return !!((_a = _getKnownSize(items)) !== null && _a !== void 0 ? _a : _hasItems(items));
-}
-function _hasItems(items) {
     for (const unused of items)
         return true;
     return false;
 }
+/** Count the number of items in an iterable. */
+export function countItems(items) {
+    let count = 0;
+    for (const unused of items)
+        count++;
+    return count;
+}
 /**
  * Yield a range of numbers from `start` to `end`
  * - Yields in descending order if `end` is lower than `start`
@@ -62,22 +44,29 @@ export function* getRange(start, end) {
  * Apply a limit to an iterable set of items.
  * - Checks `items.size` or `items.length` first to see if the limit is necessary.
  */
-export function limitItems(items, limit) {
-    var _a;
-    const size = (_a = _getKnownSize(items)) !== null && _a !== void 0 ? _a : Infinity;
-    return size <= limit ? items : _limitItems(items, limit);
-}
-function* _limitItems(source, limit) {
+export function* limitItems(items, limit) {
     let count = 0;
     if (count >= limit)
         return;
-    for (const item of source) {
+    for (const item of items) {
         yield item;
         count++;
         if (count >= limit)
-            break;
+            return;
     }
 }
+/** Pick items from an iterable set of items. */
+export function* pickItems(items, ...pick) {
+    for (const item of items)
+        if (pick.includes(item))
+            yield item;
+}
+/** Omit items from an iterable set of items. */
+export function* omitItems(items, ...omit) {
+    for (const item of items)
+        if (!omit.includes(item))
+            yield item;
+}
 export function reduceItems(items, reducer, initial) {
     let current = initial;
     for (const item of items)

package/util/object.d.ts

@@ -88,7 +88,7 @@ export declare function withProps<T extends ImmutableObject>(input: T, props: T
 /** Remove several props from an object (immutably) and return a new object without those props. */
 export declare function omitProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Omit<T, K>;
 /** Pick several props from an object and return a new object with only thos props. */
-export declare function pickProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Pick<T, K>;
+export declare function pickProps<T extends ImmutableObject, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K>;
 /** Set a single named prop on an object (by reference) and return its value. */
 export declare function setProp<T extends MutableObject, K extends keyof T>(obj: T, key: K, value: T[K]): T[K];
 /** Set several named props on an object (by reference). */

package/util/set.d.ts

@@ -19,6 +19,6 @@ 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;
+export declare function deleteSetItems<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

@@ -24,7 +24,7 @@ export function addSetItems(set, ...items) {
         set.add(item);
 }
 /** Remove multiple items from a set (by reference). */
-export function removeSetItems(set, ...items) {
+export function deleteSetItems(set, ...items) {
     for (const item of items)
         set.delete(item);
 }

package/util/validate.d.ts

@@ -24,11 +24,11 @@ export declare type Validator<T = unknown> = Validatable<T> | Validate<T>;
 export declare type ValidatorType<X> = X extends Validator<infer Y> ? Y : never;
 /** A set of named validators in `{ name: Validator }` format. */
 export declare type Validators<T extends Data = Data> = {
-    [K in keyof T]: Validator<T[K]>;
+    readonly [K in keyof T]: Validator<T[K]>;
 };
 /** Extract the type from a set of validators. */
 export declare type ValidatorsType<T> = {
-    [K in keyof T]: ValidatorType<T[K]>;
+    readonly [K in keyof T]: ValidatorType<T[K]>;
 };
 /** Validate an unknown value with a validator. */
 export declare function validate<T>(unsafeValue: unknown, validator: Validator<T>): T;