shelving 1.84.0 → 1.84.2

package/constraint/FilterConstraint.d.ts

@@ -24,7 +24,7 @@ export declare type FilterList<T extends Data> = Nullish<FilterProps<T> | Filter
  * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-export declare class FilterConstraint<T extends Data = Data> implements Constraint<T>, Matchable<T, void> {
+export declare class FilterConstraint<T extends Data = Data> implements Constraint<T>, Matchable<[T]> {
     readonly key: string;
     readonly operator: FilterOperator;
     readonly value: unknown;

package/constraint/FilterConstraint.js

@@ -1,7 +1,6 @@
 import { isArray } from "../util/array.js";
 import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "../util/match.js";
-import { filterItems } from "../util/filter.js";
-import { isIterable } from "../util/iterate.js";
+import { filterItems, isIterable } from "../util/iterate.js";
 /** Map `FilterOperator` to its corresponding `Match` function. */
 const MATCHERS = {
     IS: isEqual,

package/constraint/FilterConstraints.d.ts

@@ -6,7 +6,7 @@ import { Constraints } from "./Constraints.js";
  * Interface to make sure an object implements all matchers.
  * - Extends `Matchable` so this object itself can be directly be used in `filterItems()` and `filterEntries()`
  */
-export interface Filterable<T extends Data> extends Matchable<T, void> {
+export interface Filterable<T extends Data> extends Matchable<[T]> {
     /** Add a filter to this filterable. */
     filter(...filters: FilterList<Partial<T>>[]): this;
     /** Match an item against the filters specified for this object. */

package/constraint/FilterConstraints.js

@@ -1,4 +1,4 @@
-import { filterItems } from "../util/filter.js";
+import { filterItems } from "../util/iterate.js";
 import { getFilters } from "./FilterConstraint.js";
 import { Constraints } from "./Constraints.js";
 /** A set of filters. */

package/package.json

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

package/schema/AllowSchema.d.ts

@@ -1,16 +1,14 @@
 import type { Entry } from "../util/entry.js";
 import { ImmutableRequiredMap, PossibleMap, PossibleStringMap } from "../util/map.js";
 import { Schema, SchemaOptions } from "./Schema.js";
-/** Options for an `AllowSchema` instance. */
-declare type AllowSchemaOptions<K, T> = SchemaOptions & {
-    allow: PossibleMap<K, T>;
-    value?: K | null;
-};
 /** Define a valid value from an allowed set of values. */
 export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
     readonly value: K | null;
     readonly allow: ImmutableRequiredMap<K, T>;
-    constructor({ allow, value, ...options }: AllowSchemaOptions<K, T>);
+    constructor({ allow, value, ...options }: SchemaOptions & {
+        allow: PossibleMap<K, T>;
+        value?: K | null;
+    });
     validate(value?: unknown): K;
     /** Iterate over the the allowed options in `[key, value]` format. */
     [Symbol.iterator](): Iterator<Entry<K, T>>;
@@ -19,6 +17,7 @@ export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Ent
 export declare class AllowStringSchema<K extends string, T> extends AllowSchema<K, T> {
     constructor({ allow, ...options }: SchemaOptions & {
         allow: PossibleStringMap<K, T>;
+        value?: K | null;
     });
     validator(value?: unknown): K;
 }
@@ -26,4 +25,3 @@ export declare class AllowStringSchema<K extends string, T> extends AllowSchema<
 export declare function ALLOW<K, T>(allow: PossibleMap<K, T>): AllowSchema<K, T>;
 /** Valid string from an allowed set of values. */
 export declare function ALLOW_STRING<K extends string, T>(allow: PossibleStringMap<K, T>): AllowSchema<K, T>;
-export {};

package/schema/DateSchema.d.ts

@@ -3,8 +3,8 @@ import { Schema, SchemaOptions } from "./Schema.js";
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
-    readonly min: PossibleDate | null;
-    readonly max: PossibleDate | null;
+    readonly min: Date | null;
+    readonly max: Date | null;
     constructor({ value, min, max, ...options }: SchemaOptions & {
         readonly value?: PossibleDate;
         readonly min?: PossibleDate | null;

package/schema/DateSchema.js

@@ -1,4 +1,4 @@
-import { getOptionalDate, getYmd } from "../util/date.js";
+import { formatDate, getDate, getOptionalDate, getYMD } from "../util/date.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -7,20 +7,18 @@ export class DateSchema extends Schema {
     constructor({ value = "now", min = null, max = null, ...options }) {
         super(options);
         this.value = value;
-        this.min = min;
-        this.max = max;
+        this.min = min !== null ? getDate(min) : null;
+        this.max = max !== null ? getDate(max) : null;
     }
     validate(unsafeValue = this.value) {
         const date = getOptionalDate(unsafeValue);
         if (!date)
             throw new InvalidFeedback(unsafeValue ? "Invalid date" : "Required", { value: unsafeValue });
-        const minDate = getOptionalDate(this.min);
-        if (minDate && date.getTime() < minDate.getTime())
-            throw new InvalidFeedback(`Minimum ${minDate.toLocaleDateString()}`, { value: date });
-        const maxDate = getOptionalDate(this.max);
-        if (maxDate && date.getTime() > maxDate.getTime())
-            throw new InvalidFeedback(`Maximum ${maxDate.toLocaleDateString()}`, { value: date });
-        return getYmd(date);
+        if (this.min && date < this.min)
+            throw new InvalidFeedback(`Minimum ${formatDate(this.min)}`, { value: date });
+        if (this.max && date > this.max)
+            throw new InvalidFeedback(`Maximum ${formatDate(this.max)}`, { value: date });
+        return getYMD(date);
     }
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/NumberSchema.d.ts

@@ -13,7 +13,11 @@ export declare class NumberSchema extends Schema<number> {
     });
     validate(unsafeValue?: unknown): number;
 }
-/** Valid number, e.g. `2048` or `0` zero. */
+/** Valid number, e.g. `2048.12345` or `0` zero. */
 export declare const NUMBER: NumberSchema;
-/** Valid number, e.g. `#2048` or `0` zero, or `null` */
+/** Valid number, e.g. `2048.12345` or `0` zero, or `null` */
 export declare const OPTIONAL_NUMBER: import("./OptionalSchema.js").OptionalSchema<number>;
+/** Valid integer number, e.g. `2048` or `0` zero. */
+export declare const INTEGER: NumberSchema;
+/** Valid integer number, e.g. `2048` or `0` zero, or `null` */
+export declare const OPTIONAL_INTEGER: import("./OptionalSchema.js").OptionalSchema<number>;

package/schema/NumberSchema.js

@@ -23,7 +23,11 @@ export class NumberSchema extends Schema {
         return safeNumber;
     }
 }
-/** Valid number, e.g. `2048` or `0` zero. */
+/** Valid number, e.g. `2048.12345` or `0` zero. */
 export const NUMBER = new NumberSchema({});
-/** Valid number, e.g. `#2048` or `0` zero, or `null` */
+/** Valid number, e.g. `2048.12345` or `0` zero, or `null` */
 export const OPTIONAL_NUMBER = OPTIONAL(NUMBER);
+/** Valid integer number, e.g. `2048` or `0` zero. */
+export const INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MIN_SAFE_INTEGER });
+/** Valid integer number, e.g. `2048` or `0` zero, or `null` */
+export const OPTIONAL_INTEGER = OPTIONAL(INTEGER);

package/schema/TimeSchema.d.ts

@@ -1,10 +1,20 @@
-import { PossibleTime } from "../util/time.js";
+import { PossibleTime, Time } from "../util/time.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export declare class TimeSchema extends Schema<string> {
     readonly value: PossibleTime;
-    constructor({ value, ...options }: SchemaOptions & {
+    readonly min: Time | null;
+    readonly max: Time | null;
+    /**
+     * Rounding step (in milliseconds, because that's the base unit for time), e.g. `60000` will round to the nearest second.
+     * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
+     */
+    readonly step: number | null;
+    constructor({ value, min, max, step, ...options }: SchemaOptions & {
         readonly value?: PossibleTime;
+        readonly min?: PossibleTime | null;
+        readonly max?: PossibleTime | null;
+        readonly step?: number | null;
     });
     validate(unsafeValue?: unknown): string;
 }

package/schema/TimeSchema.js

@@ -1,18 +1,27 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { getOptionalTime } from "../util/time.js";
+import { roundStep } from "../util/number.js";
+import { getOptionalTime, Time, getTime } from "../util/time.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export class TimeSchema extends Schema {
-    constructor({ value = "now", ...options }) {
+    constructor({ value = "now", min = null, max = null, step = 60, ...options }) {
         super(options);
         this.value = value;
+        this.min = min !== null ? getTime(min) : null;
+        this.max = max !== null ? getTime(max) : null;
+        this.step = step;
     }
     validate(unsafeValue = this.value) {
-        const time = getOptionalTime(unsafeValue);
-        if (!time)
+        const unsafeTime = getOptionalTime(unsafeValue);
+        if (!unsafeTime)
             throw new InvalidFeedback(unsafeValue ? "Invalid time" : "Required", { value: unsafeValue });
-        return time.long;
+        const safeTime = typeof this.step === "number" ? new Time(roundStep(unsafeTime.time, this.step)) : unsafeTime;
+        if (this.max && safeTime > this.max)
+            throw new InvalidFeedback(`Maximum ${this.max.format()}`, { value: safeTime });
+        if (this.min && safeTime < this.min)
+            throw new InvalidFeedback(`Minimum ${this.min.format()}`, { value: safeTime });
+        return safeTime.long;
     }
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */

package/util/array.d.ts

@@ -1,3 +1,5 @@
+import { Arguments } from "./function.js";
+import { Matcher } from "./match.js";
 /**
  * Mutable array: an array that can be changed.
  * - Consistency with `MutableObject<T>` and `ImmutableArray<T>`
@@ -27,6 +29,8 @@ export declare function withArrayItems<T>(input: 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>;
 /** 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. */

package/util/array.js

@@ -1,6 +1,6 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
-import { omitItems, pickItems } from "./iterate.js";
+import { filterItems, 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. */
@@ -33,6 +33,13 @@ 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;
+}
 /** 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);

package/util/date.d.ts

@@ -1,14 +1,14 @@
 /** Things that converted to dates. */
-export declare type PossibleDate = Date | number | string | (() => Date | number | string);
+export declare type PossibleDate = Date | number | string;
 /** Things that converted to dates or `null` */
-export declare type PossibleOptionalDate = Date | number | string | null | (() => Date | number | string | null | null);
+export declare type PossibleOptionalDate = Date | number | string | null;
 /** Is a value a date? */
 export declare const isDate: (v: Date | unknown) => v is Date;
 /** Assert that a value is a `Date` instance. */
 export declare function assertDate(v: Date | unknown): asserts v is Date;
 /**
- * Convert an unknown value to a `Date` instance, or `null` if it couldn't be converted.
- *- Note: `Date` instances can be invalid (i.e. `date.getTime()` returns `NaN`). These are detected and will always return `null`
+ * Convert an unknown value to a valid `Date` instance, or `null` if it couldn't be converted.
+ * - Note: `Date` instances can be invalid (e.g. `new Date("blah blah").getTime()` returns `NaN`). These are detected and will always return `null`
  *
  * Conversion rules:
  * - `Date` instance returns unchanged (BUT if the date isn't valid, `null` is returned).
@@ -22,16 +22,16 @@ export declare function assertDate(v: Date | unknown): asserts v is Date;
  * - Numbers are return the corresponding date (using `new Date(number)`, i.e. milliseconds since 01/01/1970).
  * - Anything else is converted to `null`
  *
- * @param possibleDate Any value that we want to parse as a valid date.
+ * @param possible Any value that we want to parse as a valid date.
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
-export declare function getOptionalDate(possibleDate: unknown): Date | null;
+export declare function getOptionalDate(possible: unknown): Date | null;
 /** Convert a possible date to a `Date` instance, or throw `AssertionError` if it couldn't be converted. */
-export declare function getDate(possibleDate?: PossibleDate): Date;
+export declare function getDate(possible?: PossibleDate): Date;
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `null` if it couldn't be converted. */
-export declare function getOptionalYmd(possibleDate: unknown): string | null;
+export declare function getOptionalYMD(possible: unknown): string | null;
 /** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
-export declare function getYmd(possibleDate?: PossibleDate): string;
+export declare const getYMD: (possible?: PossibleDate) => string;
 /** List of day-of-week strings. */
 export declare const days: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 /** Type listing day-of-week strings. */

package/util/date.js

@@ -7,8 +7,8 @@ export function assertDate(v) {
         throw new AssertionError(`Must be date`, v);
 }
 /**
- * Convert an unknown value to a `Date` instance, or `null` if it couldn't be converted.
- *- Note: `Date` instances can be invalid (i.e. `date.getTime()` returns `NaN`). These are detected and will always return `null`
+ * Convert an unknown value to a valid `Date` instance, or `null` if it couldn't be converted.
+ * - Note: `Date` instances can be invalid (e.g. `new Date("blah blah").getTime()` returns `NaN`). These are detected and will always return `null`
  *
  * Conversion rules:
  * - `Date` instance returns unchanged (BUT if the date isn't valid, `null` is returned).
@@ -22,48 +22,47 @@ export function assertDate(v) {
  * - Numbers are return the corresponding date (using `new Date(number)`, i.e. milliseconds since 01/01/1970).
  * - Anything else is converted to `null`
  *
- * @param possibleDate Any value that we want to parse as a valid date.
+ * @param possible Any value that we want to parse as a valid date.
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
-export function getOptionalDate(possibleDate) {
-    if (possibleDate === undefined || possibleDate === "now")
+export function getOptionalDate(possible) {
+    if (possible === undefined || possible === "now")
         return new Date();
-    if (isDate(possibleDate))
-        return !Number.isNaN(possibleDate.getTime()) ? possibleDate : null;
-    if (possibleDate === "today")
+    if (isDate(possible))
+        return _getValidDate(possible);
+    if (possible === "today")
         return getMidnight();
-    if (possibleDate === "tomorrow")
+    if (possible === "tomorrow")
         return addDays(1, getMidnight());
-    if (possibleDate === "yesterday")
+    if (possible === "yesterday")
         return addDays(-1, getMidnight());
-    if (possibleDate === null || possibleDate === "")
+    if (possible === null || possible === "")
         return null; // We know empty string is always an invalid date.
-    if (typeof possibleDate === "string" || typeof possibleDate === "number")
-        return getOptionalDate(new Date(possibleDate));
-    if (typeof possibleDate === "function")
-        return getOptionalDate(possibleDate());
+    if (typeof possible === "string" || typeof possible === "number")
+        return _getValidDate(new Date(possible));
     return null;
 }
+const _getValidDate = (date) => (Number.isFinite(date.getTime()) ? date : null);
 /** Convert a possible date to a `Date` instance, or throw `AssertionError` if it couldn't be converted. */
-export function getDate(possibleDate = "now") {
-    const date = getOptionalDate(possibleDate);
+export function getDate(possible = "now") {
+    const date = getOptionalDate(possible);
     if (!date)
-        throw new AssertionError(`Must be date`, possibleDate);
+        throw new AssertionError(`Must be date`, possible);
     return date;
 }
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `null` if it couldn't be converted. */
-export function getOptionalYmd(possibleDate) {
-    const date = getOptionalDate(possibleDate);
-    return date ? date.toISOString().slice(0, 10) : null;
+export function getOptionalYMD(possible) {
+    const date = getOptionalDate(possible);
+    return date ? _ymd(date) : null;
 }
 /** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
-export function getYmd(possibleDate = "now") {
-    const date = getDate(possibleDate);
+export const getYMD = (possible = "now") => _ymd(getDate(possible));
+const _ymd = (date) => {
     const y = _pad(date.getUTCFullYear(), 4);
     const m = _pad(date.getUTCMonth() + 1, 2);
     const d = _pad(date.getUTCDate(), 2);
     return `${y}-${m}-${d}`;
-}
+};
 const _pad = (num, size) => num.toString(10).padStart(size, "0000");
 /** List of day-of-week strings. */
 export const days = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

package/util/index.d.ts

@@ -15,7 +15,6 @@ export * from "./diff.js";
 export * from "./entry.js";
 export * from "./equal.js";
 export * from "./error.js";
-export * from "./filter.js";
 export * from "./function.js";
 export * from "./hydrate.js";
 export * from "./iterate.js";

package/util/index.js

@@ -15,7 +15,6 @@ export * from "./diff.js";
 export * from "./entry.js";
 export * from "./equal.js";
 export * from "./error.js";
-export * from "./filter.js";
 export * from "./function.js";
 export * from "./hydrate.js";
 export * from "./iterate.js";

package/util/iterate.d.ts

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

package/util/iterate.js

@@ -1,8 +1,4 @@
-/**
- * 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`
- */
+import { match } from "./match.js";
 export const isIterable = (value) => typeof value === "object" && !!value && Symbol.iterator in value;
 /** Flatten one or more iterables. */
 export function* flattenItems(items) {
@@ -73,6 +69,12 @@ 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(input, matcher, ...args) {
+    for (const item of input)
+        if (match(matcher, item, ...args))
+            yield item;
+}
 export function* getChunks(input, size) {
     let chunk = [];
     for (const item of input) {

package/util/match.d.ts

@@ -1,20 +1,20 @@
+import { Arguments } from "./function.js";
 /** Object that can match an item against a target with its `match()` function. */
-export interface Matchable<L = unknown, R = unknown> {
-    match(item: L, target: R): boolean;
+export interface Matchable<A extends Arguments = unknown[]> {
+    match(...args: A): boolean;
 }
 /** Function that can match an item against a target. */
-export declare type Match<L = unknown, R = unknown> = (item: L, target: R) => boolean;
+export declare type Match<A extends Arguments = unknown[]> = (...args: A) => boolean;
 /** Match is either a `Matcherable` object, or matcher function. */
-export declare type Matcher<L = unknown, R = unknown> = Matchable<L, R> | Match<L, R>;
+export declare type Matcher<A extends Arguments = unknown[]> = Matchable<A> | Match<A>;
 /** Match two values using a `Matcher`. */
-export declare function match<L>(item: L, matcher: Matcher<L, void>): boolean;
-export declare function match<L, R>(item: L, matcher: Matcher<L, R>, target: R): boolean;
-export declare const isEqual: Match<unknown, unknown>;
-export declare const notEqual: Match<unknown, unknown>;
-export declare const isInArray: Match<unknown, unknown>;
-export declare const notInArray: Match<unknown, unknown>;
-export declare const isArrayWith: Match<unknown, unknown>;
-export declare const isLess: Match<unknown, unknown>;
-export declare const isEqualLess: Match<unknown, unknown>;
-export declare const isGreater: Match<unknown, unknown>;
-export declare const isEqualGreater: Match<unknown, unknown>;
+export declare function match<A extends Arguments>(matcher: Matcher<A>, ...args: A): boolean;
+export declare const isEqual: Match<[item: unknown, target: unknown]>;
+export declare const notEqual: Match<[item: unknown, target: unknown]>;
+export declare const isInArray: Match<[item: unknown, target: unknown]>;
+export declare const notInArray: Match<[item: unknown, target: unknown]>;
+export declare const isArrayWith: Match<[item: unknown, target: unknown]>;
+export declare const isLess: Match<[item: unknown, target: unknown]>;
+export declare const isEqualLess: Match<[item: unknown, target: unknown]>;
+export declare const isGreater: Match<[item: unknown, target: unknown]>;
+export declare const isEqualGreater: Match<[item: unknown, target: unknown]>;

package/util/match.js

@@ -1,7 +1,8 @@
 import { isArray } from "./array.js";
 import { rankAsc } from "./sort.js";
-export function match(item, matcher, target) {
-    return typeof matcher === "function" ? matcher(item, target) : matcher.match(item, target);
+/** Match two values using a `Matcher`. */
+export function match(matcher, ...args) {
+    return typeof matcher === "function" ? matcher(...args) : matcher.match(...args);
 }
 // Regular matchers.
 export const isEqual = (item, target) => item === target;

package/util/regexp.d.ts

@@ -34,6 +34,6 @@ export declare function getAnyRegExp(patterns: Iterable<PossibleRegExp> & NotStr
 /** Create regular expression that matches all of a list of other expressions. */
 export declare function getAllRegExp(patterns: Iterable<PossibleRegExp> & NotString, flags?: string): RegExp;
 /** Match function for finding strings that match against regular expressions (use with `filter()` to positively filter iterable sets of items). */
-export declare const isRegExpMatch: Match<string, RegExp>;
+export declare const isRegExpMatch: Match<[item: string, target: RegExp]>;
 /** Match function for finding strings that match against regular expressions (use with `filter()` to negatively filter iterable sets of items). */
-export declare const notRegExpMatch: Match<string, RegExp>;
+export declare const notRegExpMatch: Match<[item: string, target: RegExp]>;

package/util/time.d.ts

@@ -33,9 +33,9 @@ export declare class Time {
 /** Regular expression that matches a time in ISO 8601 format. */
 export declare const TIME_REGEXP: RegExp;
 /** Things that converted to times. */
-export declare type PossibleTime = Time | Date | number | string | (() => number | string);
+export declare type PossibleTime = Time | Date | number | string;
 /** Things that converted to times or `null` */
-export declare type PossibleOptionalTime = Time | Date | number | string | null | (() => number | string | null);
+export declare type PossibleOptionalTime = Time | Date | number | string | null;
 /** Is an unknown value a `Time` instance. */
 export declare const isTime: (v: Time | unknown) => v is Time;
 /**

package/util/time.js

@@ -88,8 +88,6 @@ export const isTime = (v) => v instanceof Time;
 export function getOptionalTime(possible) {
     if (isTime(possible))
         return possible;
-    if (typeof possible === "function")
-        return getOptionalTime(possible());
     return (typeof possible === "string" && Time.fromString(possible)) || Time.fromDate(possible) || null;
 }
 /** Convert a possible time to a `Time` instance, or throw `AssertionError` if it couldn't be converted. */

package/util/filter.d.ts

@@ -1,8 +0,0 @@
-import type { ImmutableArray } from "./array.js";
-import { Matcher } from "./match.js";
-/** Filter an iterable set of items using a matcher (and optionally a target value). */
-export declare function filterItems<L>(input: Iterable<L>, matcher: Matcher<L, void>): Iterable<L>;
-export declare function filterItems<L, R>(input: Iterable<L>, matcher: Matcher<L, R>, target: R): Iterable<L>;
-/** Filter an array using a matcher (and optionally a target value). */
-export declare function filterArray<L>(input: ImmutableArray<L>, matcher: Matcher<L, void>): ImmutableArray<L>;
-export declare function filterArray<L, R>(input: ImmutableArray<L>, matcher: Matcher<L, R>, target: R): ImmutableArray<L>;

package/util/filter.js

@@ -1,12 +0,0 @@
-import { match } from "./match.js";
-export function* filterItems(input, matcher, target) {
-    for (const item of input)
-        if (match(item, matcher, target))
-            yield item;
-}
-export function filterArray(input, matcher, target) {
-    if (!input.length)
-        return input;
-    const output = Array.from(filterItems(input, matcher, target));
-    return output.length === input.length ? input : output;
-}