shelving 1.91.0 → 1.91.2

package/util/activity.d.ts

@@ -1,4 +1,4 @@
-import { Handler, Arguments, Dispatch, Start } from "./function.js";
+import type { Arguments, Dispatch, Handler, Start } from "./function.js";
 /** Something that can be started and stopped. */
 export interface Activity<A extends Arguments = []> {
     /** Start this activity. */

package/util/array.d.ts

@@ -1,5 +1,3 @@
-import type { Arguments } from "./function.js";
-import type { Matcher } from "./match.js";
 /**
  * Mutable array: an array that can be changed.
  * - Consistency with `MutableObject<T>` and `ImmutableArray<T>`
@@ -28,8 +26,6 @@ export declare function withArrayItems<T>(arr: ImmutableArray<T>, ...items: T[])
 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 omitArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...omit: T[]): ImmutableArray<T>;
-/** Filter an array using a matcher (and optionally a target value). */
-export declare function filterArray<T, A extends Arguments = []>(input: ImmutableArray<T>, matcher: Matcher<[T, ...A]>, ...args: A): ImmutableArray<T>;
 /** Clear an array (immutably) and return a new empty array (or the same array if no changes were made). */
 export declare const clearArray: <T>(input: ImmutableArray<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). */

package/util/array.js

@@ -1,6 +1,6 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
-import { filterItems, omitItems, pickItems } from "./iterate.js";
+import { omitItems, pickItems } from "./iterate.js";
 import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
 export const isArray = (value) => Array.isArray(value);
@@ -33,13 +33,6 @@ export function omitArrayItems(input, ...omit) {
     const output = Array.from(omitItems(input, ...omit));
     return isArray(input) && output.length === input.length ? input : output;
 }
-/** Filter an array using a matcher (and optionally a target value). */
-export function filterArray(input, matcher, ...args) {
-    if (!input.length)
-        return input;
-    const output = Array.from(filterItems(input, matcher, ...args));
-    return output.length === input.length ? input : output;
-}
 /** Clear an array (immutably) and return a new empty array (or the same array if no changes were made). */
 export const clearArray = (input) => (input.length ? [] : input);
 /** 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). */

package/util/async.d.ts

@@ -1,5 +1,5 @@
+import type { Dispatch, Handler } from "./function.js";
 import { SIGNAL } from "./constants.js";
-import type { Handler, Dispatch } from "./function.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export declare const isAsync: <T>(value: T | PromiseLike<T>) => value is PromiseLike<T>;
 /** Is a value a synchronous value. */

package/util/class.d.ts

@@ -1,4 +1,4 @@
-import { Arguments } from "./function.js";
+import type { Arguments } from "./function.js";
 /** Class that has a public `constructor()` function. */
 export type Constructor<T, A extends Arguments> = new (...args: A) => T;
 /** Any function arguments (designed for use with `extends Arguments` guards). */

package/util/class.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { AssertionError } from "../error/AssertionError.js";
-import { assertFunction } from "./function.js";
 import { debug } from "./debug.js";
+import { assertFunction } from "./function.js";
 export const abc = String;
 /** Is a given value a class constructor? */
 export const isConstructor = (value) => typeof value === "function" && value.toString().startsWith("class");

package/util/diff.d.ts

@@ -1,5 +1,5 @@
-import { ImmutableArray } from "./array.js";
-import { ImmutableObject, DeepPartial } from "./object.js";
+import type { ImmutableArray } from "./array.js";
+import type { DeepPartial, ImmutableObject } from "./object.js";
 /** The `SAME` symbol indicates sameness. */
 export declare const SAME: unique symbol;
 /**

package/util/duration.d.ts

@@ -1,4 +1,4 @@
-import { PossibleDate } from "./date.js";
+import type { PossibleDate } from "./date.js";
 /** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
 export declare function pluralizeDuration(ms: number): string;
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */

package/util/duration.js

@@ -1,4 +1,4 @@
-import { MONTH, WEEK, DAY, HOUR, SECOND } from "./constants.js";
+import { DAY, HOUR, MONTH, SECOND, WEEK } from "./constants.js";
 import { getDuration } from "./date.js";
 import { TIME_UNITS } from "./units.js";
 /** Get an appropriate time unit based on an amount in milliseconds. */

package/util/entry.d.ts

@@ -1,6 +1,6 @@
-import { ImmutableArray } from "./array.js";
-import { ImmutableObject } from "./object.js";
-import { ImmutableSet } from "./set.js";
+import type { ImmutableArray } from "./array.js";
+import type { ImmutableObject } from "./object.js";
+import type { ImmutableSet } from "./set.js";
 /**
  * Single entry from a map-like object.
  * - Consistency with `UnknownObject`

package/util/equal.d.ts

@@ -1,7 +1,7 @@
+import type { ImmutableArray } from "./array.js";
+import type { ImmutableMap } from "./map.js";
 import type { Match } from "./match.js";
-import { ImmutableArray } from "./array.js";
-import { ImmutableObject } from "./object.js";
-import { ImmutableMap } from "./map.js";
+import type { ImmutableObject } from "./object.js";
 /** Is unknown value `left` exactly equal to `right`? */
 export declare const isEqual: <T>(left: unknown, right: T) => left is T;
 /** Is unknown value `left` not exactly equal to `right`? */

package/util/equal.js

@@ -1,6 +1,6 @@
 import { isArray } from "./array.js";
-import { isObject, isProp } from "./object.js";
 import { isMap } from "./map.js";
+import { isObject, isProp } from "./object.js";
 import { rankAsc } from "./sort.js";
 /** Is unknown value `left` exactly equal to `right`? */
 export const isEqual = (left, right) => left === right;

package/util/hydrate.d.ts

@@ -1,6 +1,6 @@
-import type { ImmutableDictionary } from "./dictionary.js";
 import type { Class } from "./class.js";
-import { Transformable } from "./transform.js";
+import type { ImmutableDictionary } from "./dictionary.js";
+import type { Transformable } from "./transform.js";
 /**
  * A set of hydrations describes a set of string keys and the class constructor to be dehydrated and rehydrated.
  * - We can't use `class.name` because we don't know that the name of the class will survive minification.

package/util/hydrate.js

@@ -5,7 +5,7 @@ import { isMap } from "./map.js";
 import { getPrototype, isObject, isPlainObject } from "./object.js";
 import { isSet } from "./set.js";
 import { isString } from "./string.js";
-import { mapArray, mapObject, mapEntries, mapItems } from "./transform.js";
+import { mapArray, mapEntries, mapItems, mapObject } from "./transform.js";
 /**
  * Deeply dehydrate a class instance based on a set of `Hydrations`
  * - Dehydration allows you to pass class instances from a server back to a client.

package/util/iterate.d.ts

@@ -3,8 +3,6 @@
  * - Any object with a `Symbol.iterator` property is iterable.
  * - Note: Array and Map instances etc will return true because they implement `Symbol.iterator`
  */
-import type { Arguments } from "./function.js";
-import { Matcher } from "./match.js";
 /** Is an unknown value an iterable? */
 export declare const isIterable: <T extends Iterable<unknown>>(value: unknown) => value is T;
 /** An iterable containing items or nested iterables of items. */
@@ -37,8 +35,6 @@ export declare function omitItems<T>(items: Iterable<T>, ...omit: T[]): Iterable
 /** 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;
-/** Filter an iterable set of items using a matcher (and optionally a target value). */
-export declare function filterItems<T, A extends Arguments = []>(items: Iterable<T>, matcher: Matcher<[T, ...A]>, ...args: A): Iterable<T>;
 /** Yield chunks of a given size. */
 export declare function getChunks<T>(items: Iterable<T>, size: 1): Iterable<readonly [T]>;
 export declare function getChunks<T>(items: Iterable<T>, size: 2): Iterable<readonly [T, T]>;

package/util/iterate.js

@@ -1,4 +1,8 @@
-import { match } from "./match.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`
+ */
 /** Is an unknown value an iterable? */
 export const isIterable = (value) => typeof value === "object" && !!value && Symbol.iterator in value;
 /** Flatten one or more iterables. */
@@ -77,12 +81,6 @@ export function reduceItems(items, reducer, initial) {
         current = reducer(current, item);
     return current;
 }
-/** Filter an iterable set of items using a matcher (and optionally a target value). */
-export function* filterItems(items, matcher, ...args) {
-    for (const item of items)
-        if (match(matcher, item, ...args))
-            yield item;
-}
 export function* getChunks(items, size) {
     let chunk = [];
     for (const item of items) {

package/util/lazy.d.ts

@@ -1,4 +1,4 @@
-import { Arguments } from "./function.js";
+import type { Arguments } from "./function.js";
 /**
  * Lazy value: a plain value, or an initialiser function that returns that value.
  * @param ...args Any arguments the lazy value needs if it's a function.

package/util/map.d.ts

@@ -1,4 +1,4 @@
-import { Entry } from "./entry.js";
+import type { Entry } from "./entry.js";
 /** `Map` that cannot be changed. */
 export type ImmutableMap<K = unknown, T = unknown> = ReadonlyMap<K, T>;
 /** Class for a `Map` that cannot be changed (so you can extend `Map` while implementing `ImmutableMap`). */

package/util/match.d.ts

@@ -1,4 +1,5 @@
-import { Arguments } from "./function.js";
+import type { ImmutableArray } from "./array.js";
+import type { Arguments } from "./function.js";
 /** Object that can match an item against a target with its `match()` function. */
 export interface Matchable<A extends Arguments = unknown[]> {
     match(...args: A): boolean;
@@ -9,3 +10,7 @@ export type Match<A extends Arguments = unknown[]> = (...args: A) => boolean;
 export type Matcher<A extends Arguments = unknown[]> = Matchable<A> | Match<A>;
 /** Match two values using a `Matcher`. */
 export declare function match<A extends Arguments>(matcher: Matcher<A>, ...args: A): boolean;
+/** Filter an iterable set of items using a matcher. */
+export declare function filterItems<T, A extends Arguments = []>(items: Iterable<T>, matcher: Matcher<[T, ...A]>, ...args: A): Iterable<T>;
+/** Filter an array (immutably) using a matcher. */
+export declare function filterArray<T, A extends Arguments = []>(input: ImmutableArray<T>, matcher: Matcher<[T, ...A]>, ...args: A): ImmutableArray<T>;

package/util/match.js

@@ -2,3 +2,16 @@
 export function match(matcher, ...args) {
     return typeof matcher === "function" ? matcher(...args) : matcher.match(...args);
 }
+/** Filter an iterable set of items using a matcher. */
+export function* filterItems(items, matcher, ...args) {
+    for (const item of items)
+        if (match(matcher, item, ...args))
+            yield item;
+}
+/** Filter an array (immutably) using a matcher. */
+export function filterArray(input, matcher, ...args) {
+    if (!input.length)
+        return input;
+    const output = Array.from(filterItems(input, matcher, ...args));
+    return output.length === input.length ? input : output;
+}

package/util/merge.d.ts

@@ -1,5 +1,5 @@
-import { ImmutableArray } from "./array.js";
-import { ImmutableObject } from "./object.js";
+import type { ImmutableArray } from "./array.js";
+import type { ImmutableObject } from "./object.js";
 type MergeRecursor = (left: unknown, right: unknown) => unknown;
 /**
  * Exact merge two unknown values.

package/util/object.d.ts

@@ -1,4 +1,4 @@
-import { ImmutableArray } from "./array.js";
+import type { ImmutableArray } from "./array.js";
 /** Any readonly object. */
 export type ImmutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
     readonly [KK in K]: T;

package/util/regexp.d.ts

@@ -1,5 +1,5 @@
-import { Match } from "./match.js";
-import { NotString } from "./string.js";
+import type { Match } from "./match.js";
+import type { NotString } from "./string.js";
 /** Regular expression that always matches everything. */
 export declare const ALWAYS_REGEXP: RegExp;
 /** Regular expression that never matches anything. */

package/util/sequence.d.ts

@@ -1,5 +1,5 @@
+import type { AsyncDispatch, Dispatch, Handler, Stop } from "./function.js";
 import { SIGNAL } from "./constants.js";
-import { Handler, Stop, AsyncDispatch, Dispatch } from "./function.js";
 /**
  * Is a value an async iterable object?
  * - Any object with a `Symbol.iterator` property is iterable.

package/util/sort.d.ts

@@ -1,4 +1,4 @@
-import { ImmutableArray } from "./array.js";
+import type { ImmutableArray } from "./array.js";
 /** Object that can rank two values using its `rank()` function. */
 export interface Rankable<T> {
     rank(left: T, right: T): number;

package/util/string.d.ts

@@ -1,4 +1,4 @@
-import { ImmutableArray } from "./array.js";
+import type { ImmutableArray } from "./array.js";
 /**
  * Type that never matches the `string` type.
  * - `string` itself is iterable (iterating over its individual characters) and implements `Iterable<string>`

package/util/string.js

@@ -1,9 +1,9 @@
 /* eslint-disable no-control-regex */
 import { AssertionError } from "../error/AssertionError.js";
-import { formatDate, isDate } from "./date.js";
-import { formatObject, isObject } from "./object.js";
 import { getArray, isArray } from "./array.js";
+import { formatDate, isDate } from "./date.js";
 import { formatNumber, formatRange, isBetween } from "./number.js";
+import { formatObject, isObject } from "./object.js";
 /** Is a value a string? */
 export const isString = (value) => typeof value === "string";
 /** Assert that a value is a string. */

package/util/template.d.ts

@@ -1,5 +1,5 @@
-import type { NotString } from "./string.js";
 import type { ImmutableDictionary } from "./dictionary.js";
+import type { NotString } from "./string.js";
 /** Template values in `{ placeholder: value }` format. */
 type TemplateValues = ImmutableDictionary<string>;
 /** Things that can be converted to the value for a named placeholder. */

package/util/template.js

@@ -1,6 +1,6 @@
-import { isObject } from "./object.js";
-import { setMapItem } from "./map.js";
 import { EMPTY_DATA } from "./data.js";
+import { setMapItem } from "./map.js";
+import { isObject } from "./object.js";
 // RegExp to find named variables in several formats e.g. `:a`, `${b}`, `{{c}}` or `{d}`
 const R_PLACEHOLDERS = /(\*|:[a-z][a-z0-9]*|\$\{[a-z][a-z0-9]*\}|\{\{[a-z][a-z0-9]*\}\}|\{[a-z][a-z0-9]*\})/i;
 // Find actual name within template placeholder e.g. `${name}` → `name`

package/util/transform.d.ts

@@ -1,8 +1,8 @@
 import type { ArrayItem, ImmutableArray } from "./array.js";
+import type { ImmutableDictionary, PossibleDictionary } from "./dictionary.js";
 import type { Entry } from "./entry.js";
-import { Arguments } from "./function.js";
-import { ImmutableObject, ObjectValue } from "./object.js";
-import { ImmutableDictionary, PossibleDictionary } from "./dictionary.js";
+import type { Arguments } from "./function.js";
+import type { ImmutableObject, ObjectValue } from "./object.js";
 /** Object that transforms an input value into an output value with its `transform()` method. */
 export interface Transformable<I, O, A extends Arguments = []> {
     transform(input: I, ...args: A): O;

package/util/units.d.ts

@@ -1,6 +1,7 @@
-import { ImmutableObject } from "./object.js";
-import { MapKey, ImmutableMap } from "./map.js";
-import { NumberOptions } from "./number.js";
+import type { MapKey } from "./map.js";
+import type { NumberOptions } from "./number.js";
+import type { ImmutableObject } from "./object.js";
+import { ImmutableMap } from "./map.js";
 /** Conversion from one unit to another (either an amount to multiple by, or a function to convert). */
 type Conversion = number | ((num: number) => number);
 /** Set of possible conversions for a set of items. */

package/util/units.js

@@ -1,9 +1,9 @@
 import { ConditionError } from "../error/ConditionError.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { DAY, HOUR, MILLION, MINUTE, MONTH, NNBSP, SECOND, WEEK, YEAR } from "./constants.js";
-import { getProps } from "./object.js";
 import { ImmutableMap } from "./map.js";
-import { pluralizeQuantity, formatQuantity } from "./number.js";
+import { formatQuantity, pluralizeQuantity } from "./number.js";
+import { getProps } from "./object.js";
 /** Convert an amount using a `Conversion. */
 const _convert = (amount, conversion) => (typeof conversion === "function" ? conversion(amount) : conversion === 1 ? amount : amount * conversion);
 /** Represent a unit. */

package/util/validate.d.ts

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

package/util/validate.js

@@ -1,8 +1,8 @@
-import { isFeedback } from "../feedback/Feedback.js";
+import { Feedback } from "../feedback/Feedback.js";
 import { Feedbacks } from "../feedback/Feedbacks.js";
-import { getDictionaryItems } from "./dictionary.js";
-import { getDataProps } from "./data.js";
 import { getLastItem, isArray } from "./array.js";
+import { getDataProps } from "./data.js";
+import { getDictionaryItems } from "./dictionary.js";
 import { isIterable } from "./iterate.js";
 /** Validate an unknown value with a validator. */
 export function validate(unsafeValue, validator) {
@@ -24,7 +24,7 @@ export function* validateItems(unsafeItems, validator) {
             yield validate(unsafeItem, validator);
         }
         catch (thrown) {
-            if (!isFeedback(thrown))
+            if (!(thrown instanceof Feedback))
                 throw thrown;
             feedbacks[index] = thrown;
             valid = false;
@@ -55,7 +55,7 @@ export function validateArray(unsafeArray, validator) {
                 changed = true;
         }
         catch (thrown) {
-            if (!isFeedback(thrown))
+            if (!(thrown instanceof Feedback))
                 throw thrown;
             feedbacks[index] = thrown;
             valid = false;
@@ -85,7 +85,7 @@ export function validateDictionary(unsafeDictionary, validator) {
                 changed = true;
         }
         catch (thrown) {
-            if (!isFeedback(thrown))
+            if (!(thrown instanceof Feedback))
                 throw thrown;
             feedbacks[key] = thrown;
             valid = false;
@@ -121,7 +121,7 @@ export function validateData(unsafeData, validators) {
                 changed = true;
         }
         catch (thrown) {
-            if (!isFeedback(thrown))
+            if (!(thrown instanceof Feedback))
                 throw thrown;
             feedbacks[key] = thrown;
             valid = false;