shelving 1.86.4 → 1.86.6

package/db/Query.js

@@ -1,4 +1,4 @@
-import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem, isArrayMin, countArray } from "../util/array.js";
+import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem, isArrayLength, 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. */
@@ -68,7 +68,7 @@ export class AsyncQuery extends BaseQuery {
         return this.value.then(countArray);
     }
     get exists() {
-        return this.max(1).value.then(isArrayMin);
+        return this.max(1).value.then(isArrayLength);
     }
     get firstValue() {
         return this.max(1).value.then(getOptionalFirstItem);

package/package.json

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

package/schema/ArraySchema.d.ts

@@ -6,7 +6,7 @@ export type ArraySchemaOptions<T> = SchemaOptions & {
     readonly value?: ImmutableArray;
     readonly items: Validator<T>;
     readonly min?: number;
-    readonly max?: number | null;
+    readonly max?: number;
     readonly unique?: boolean;
 };
 /**
@@ -41,7 +41,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly items: Validator<T>;
     readonly unique: boolean;
     readonly min: number;
-    readonly max: number | null;
+    readonly max: number;
     constructor({ value, items, unique, min, max, ...options }: ArraySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }

package/schema/ArraySchema.js

@@ -30,7 +30,7 @@ import { Schema } from "./Schema.js";
  *  schema.validate(["a", null], schema); // Throws Invalids({ "1": Invalid('Must be a string') });
  */
 export class ArraySchema extends Schema {
-    constructor({ value = [], items, unique = false, min = 0, max = null, ...options }) {
+    constructor({ value = [], items, unique = false, min = 0, max = Infinity, ...options }) {
         super(options);
         this.value = value;
         this.items = items;
@@ -43,9 +43,9 @@ export class ArraySchema extends Schema {
             throw new InvalidFeedback("Must be array", { value: unsafeValue });
         const safeArray = validateArray(unsafeValue, this.items);
         const dedupedArray = this.unique ? uniqueArray(safeArray) : safeArray;
-        if (typeof this.min === "number" && dedupedArray.length < this.min)
+        if (dedupedArray.length < this.min)
             throw new InvalidFeedback(dedupedArray.length ? `Minimum ${this.min} items` : "Required", { value: dedupedArray });
-        if (typeof this.max === "number" && dedupedArray.length > this.max)
+        if (dedupedArray.length > this.max)
             throw new InvalidFeedback(`Maximum ${this.max} items`, { value: dedupedArray });
         return dedupedArray;
     }

package/schema/BooleanSchema.d.ts

@@ -1,7 +1,7 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `BooleanSchema` */
 export type BooleanSchemaOptions = SchemaOptions & {
-    readonly value?: boolean;
+    readonly value?: boolean | undefined;
 };
 /** Define a valid boolean. */
 export declare class BooleanSchema extends Schema<boolean> {

package/schema/DataSchema.d.ts

@@ -5,7 +5,7 @@ import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DataSchema` */
 export type DataSchemaOptions<T extends Data> = SchemaOptions & {
     readonly props: Validators<T>;
-    readonly value?: Partial<T>;
+    readonly value?: Partial<T> | undefined;
 };
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<T> {

package/schema/DateSchema.d.ts

@@ -1,10 +1,10 @@
-import { PossibleDate } from "../util/date.js";
+import { PossibleDate, PossibleOptionalDate } from "../util/date.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DateSchema` */
 export type DateSchemaOptions = SchemaOptions & {
-    readonly value?: PossibleDate;
-    readonly min?: PossibleDate | null;
-    readonly max?: PossibleDate | null;
+    readonly value?: PossibleDate | undefined;
+    readonly min?: PossibleOptionalDate | undefined;
+    readonly max?: PossibleOptionalDate | undefined;
 };
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {

package/schema/DateSchema.js

@@ -1,4 +1,4 @@
-import { formatDate, getDate, getOptionalDate, getYMD } from "../util/date.js";
+import { formatDate, getOptionalDate, getYMD } from "../util/date.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -7,8 +7,8 @@ export class DateSchema extends Schema {
     constructor({ value = "now", min = null, max = null, ...options }) {
         super(options);
         this.value = value;
-        this.min = min !== null ? getDate(min) : null;
-        this.max = max !== null ? getDate(max) : null;
+        this.min = getOptionalDate(min);
+        this.max = getOptionalDate(max);
     }
     validate(unsafeValue = this.value) {
         const date = getOptionalDate(unsafeValue);

package/schema/DictionarySchema.d.ts

@@ -4,16 +4,16 @@ import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
 export type DictionarySchemaOptions<T> = SchemaOptions & {
     readonly items: Validator<T>;
-    readonly value?: ImmutableDictionary;
-    readonly min?: number | null;
-    readonly max?: number | null;
+    readonly value?: ImmutableDictionary | undefined;
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
 };
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>> {
     readonly value: ImmutableDictionary;
     readonly items: Validator<T>;
-    readonly min: number | null;
-    readonly max: number | null;
+    readonly min: number;
+    readonly max: number;
     constructor({ value, items, min, max, ...rest }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }

package/schema/DictionarySchema.js

@@ -4,10 +4,8 @@ import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export class DictionarySchema extends Schema {
-    constructor({ value = {}, items, min = null, max = null, ...rest }) {
+    constructor({ value = {}, items, min = 0, max = Infinity, ...rest }) {
         super(rest);
-        this.min = null;
-        this.max = null;
         this.items = items;
         this.value = value;
         this.min = min;
@@ -18,9 +16,9 @@ export class DictionarySchema extends Schema {
             throw new InvalidFeedback("Must be object", { value: unsafeValue });
         const unsafeEntries = Object.entries(unsafeValue);
         const safeObject = Object.fromEntries(validateEntries(unsafeEntries, this.items));
-        if (typeof this.min === "number" && unsafeEntries.length < this.min)
+        if (unsafeEntries.length < this.min)
             throw new InvalidFeedback(unsafeEntries.length ? `Minimum ${this.min} items` : "Required", { value: safeObject });
-        if (typeof this.max === "number" && unsafeEntries.length > this.max)
+        if (unsafeEntries.length > this.max)
             throw new InvalidFeedback(`Maximum ${this.max} items`, { value: safeObject });
         return safeObject;
     }

package/schema/LinkSchema.d.ts

@@ -1,8 +1,8 @@
 import { StringSchema, StringSchemaOptions } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
 export type LinkSchemaOptions = StringSchemaOptions & {
-    readonly schemes?: string[];
-    readonly hosts?: string[] | null;
+    readonly schemes?: string[] | undefined;
+    readonly hosts?: string[] | undefined;
 };
 /**
  * Type of `StringSchema` that defines a valid URL.
@@ -15,7 +15,7 @@ export declare class LinkSchema extends StringSchema {
     readonly min = 1;
     readonly max = 512;
     readonly schemes: string[];
-    readonly hosts: string[] | null;
+    readonly hosts: string[] | undefined;
     constructor({ schemes, hosts, ...rest }: LinkSchemaOptions);
     validate(unsafeValue: unknown): string;
 }

package/schema/LinkSchema.js

@@ -9,13 +9,11 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to `""` empty string.
  */
 export class LinkSchema extends StringSchema {
-    constructor({ schemes = ["http:", "https:"], hosts = null, ...rest }) {
+    constructor({ schemes = ["http:", "https:"], hosts, ...rest }) {
         super(rest);
         this.type = "url";
         this.min = 1;
         this.max = 512;
-        this.schemes = ["http:", "https:"];
-        this.hosts = null;
         this.schemes = schemes;
         this.hosts = hosts;
     }

package/schema/NumberSchema.d.ts

@@ -1,16 +1,16 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `NumberSchema` */
 export type NumberSchemaOptions = SchemaOptions & {
-    readonly value?: number | null;
-    readonly min?: number | null;
-    readonly max?: number | null;
-    readonly step?: number | null;
+    readonly value?: number | undefined;
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
+    readonly step?: number | null | undefined;
 };
 /** Schema that defines a valid number. */
 export declare class NumberSchema extends Schema<number> {
-    readonly value: number | null;
-    readonly min: number | null;
-    readonly max: number | null;
+    readonly value: number;
+    readonly min: number;
+    readonly max: number;
     readonly step: number | null;
     constructor({ value, min, max, step, ...rest }: NumberSchemaOptions);
     validate(unsafeValue?: unknown): number;

package/schema/NumberSchema.js

@@ -4,7 +4,7 @@ import { Schema } from "./Schema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 /** Schema that defines a valid number. */
 export class NumberSchema extends Schema {
-    constructor({ value = 0, min = null, max = null, step = null, ...rest }) {
+    constructor({ value = 0, min = -Infinity, max = Infinity, step = null, ...rest }) {
         super(rest);
         this.value = value;
         this.min = min;
@@ -16,9 +16,9 @@ export class NumberSchema extends Schema {
         if (typeof unsafeNumber !== "number")
             throw new InvalidFeedback("Must be number", { value: unsafeValue });
         const safeNumber = typeof this.step === "number" ? roundStep(unsafeNumber, this.step) : unsafeNumber;
-        if (typeof this.max === "number" && safeNumber > this.max)
+        if (safeNumber > this.max)
             throw new InvalidFeedback(`Maximum ${formatNumber(this.max)}`, { value: safeNumber });
-        if (typeof this.min === "number" && safeNumber < this.min)
+        if (safeNumber < this.min)
             throw new InvalidFeedback(`Minimum ${formatNumber(this.min)}`, { value: safeNumber });
         return safeNumber;
     }

package/schema/Schema.d.ts

@@ -2,11 +2,11 @@ import type { Validatable } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
 export type SchemaOptions = {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title?: string | null;
+    readonly title?: string | undefined;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description?: string | null;
+    readonly description?: string | undefined;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder?: string | null;
+    readonly placeholder?: string | undefined;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value?: unknown;
 };
@@ -17,14 +17,16 @@ export type SchemaOptions = {
  */
 export declare abstract class Schema<T extends unknown = unknown> implements Validatable<T> {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title: string | null;
+    readonly title: string | undefined;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description: string | null;
+    readonly description: string | undefined;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder: string | null;
+    readonly placeholder: string | undefined;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value: unknown;
     constructor({ title, description, placeholder, value }: SchemaOptions);
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }
+/** Is an unknown value a `Schema` instance? */
+export declare const isSchema: <T extends Schema<unknown>>(v: unknown) => v is T;

package/schema/Schema.js

@@ -4,10 +4,12 @@
  * - `validate()` returns `Invalid` if value was not valid.
  */
 export class Schema {
-    constructor({ title = null, description = null, placeholder = null, value }) {
+    constructor({ title, description, placeholder, value }) {
         this.title = title;
         this.description = description;
         this.placeholder = placeholder;
         this.value = value;
     }
 }
+/** Is an unknown value a `Schema` instance? */
+export const isSchema = (v) => v instanceof Schema;

package/schema/StringSchema.d.ts

@@ -5,13 +5,13 @@ export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "
 export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
 export type StringSchemaOptions = SchemaOptions & {
-    readonly value?: string;
-    readonly type?: HtmlInputType;
-    readonly min?: number;
-    readonly max?: number | null;
-    readonly match?: RegExp | null;
-    readonly sanitizer?: Sanitizer | null;
-    readonly multiline?: boolean;
+    readonly value?: string | undefined;
+    readonly type?: HtmlInputType | undefined;
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
+    readonly match?: RegExp | undefined;
+    readonly sanitizer?: Sanitizer | undefined;
+    readonly multiline?: boolean | undefined;
 };
 /**
  * Schema that defines a valid string.
@@ -37,9 +37,9 @@ export declare class StringSchema extends Schema<string> {
     readonly value: string;
     readonly type: HtmlInputType;
     readonly min: number;
-    readonly max: number | null;
-    readonly match: RegExp | null;
-    readonly sanitizer: Sanitizer | null;
+    readonly max: number;
+    readonly match: RegExp | undefined;
+    readonly sanitizer: Sanitizer | undefined;
     readonly multiline: boolean;
     constructor({ value, type, min, max, match, sanitizer, multiline, ...rest }: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;

package/schema/StringSchema.js

@@ -22,7 +22,7 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
-    constructor({ value = "", type = "text", min = 0, max = null, match = null, sanitizer = null, multiline = false, ...rest }) {
+    constructor({ value = "", type = "text", min = 0, max = Infinity, match, sanitizer, multiline = false, ...rest }) {
         super(rest);
         this.type = type;
         this.value = value;
@@ -39,7 +39,7 @@ export class StringSchema extends Schema {
         const safeString = this.sanitize(unsafeString);
         if (safeString.length < this.min)
             throw new InvalidFeedback(safeString ? `Minimum ${this.min} characters` : "Required", { value: safeString });
-        if (this.max && safeString.length > this.max)
+        if (safeString.length > this.max)
             throw new InvalidFeedback(`Maximum ${this.max} characters`, { value: safeString });
         if (this.match && !this.match.test(safeString))
             throw new InvalidFeedback(safeString ? "Invalid format" : "Required", { value: safeString });

package/schema/TimeSchema.d.ts

@@ -1,11 +1,11 @@
-import { PossibleTime, Time } from "../util/time.js";
+import { PossibleTime, Time, PossibleOptionalTime } from "../util/time.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
 export type TimeSchemaOptions = SchemaOptions & {
-    readonly value?: PossibleTime;
-    readonly min?: PossibleTime | null;
-    readonly max?: PossibleTime | null;
-    readonly step?: number | null;
+    readonly value?: PossibleTime | undefined;
+    readonly min?: PossibleOptionalTime | undefined;
+    readonly max?: PossibleOptionalTime | undefined;
+    readonly step?: number | null | undefined;
 };
 /** 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> {

package/schema/TimeSchema.js

@@ -1,6 +1,6 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { roundStep } from "../util/number.js";
-import { getOptionalTime, Time, getTime } from "../util/time.js";
+import { getOptionalTime, Time } 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 */
@@ -8,8 +8,8 @@ export class TimeSchema extends Schema {
     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.min = getOptionalTime(min);
+        this.max = getOptionalTime(max);
         this.step = step;
     }
     validate(unsafeValue = this.value) {

package/util/array.d.ts

@@ -60,20 +60,32 @@ export declare function limitArray<T>(items: Iterable<T>, limit: number): Immuta
 /** 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[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: 3): arr is [T, T, T, ...T[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: 4): arr is [T, T, T, T, ...T[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: number): boolean;
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): arr is readonly [T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): arr is readonly [T, T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): arr is readonly [T, T, T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): arr is readonly [T, T, T, T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min?: 1, max?: number): arr is readonly [T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: number): arr is readonly [T, T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): arr is readonly [T, T, T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): arr is readonly [T, T, T, T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min?: number, max?: number): boolean;
 /** Assert that a value has a specific length (or length is in a specific range). */
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min?: 1): asserts arr is [T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: 2): asserts arr is [T, T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: 3): asserts arr is [T, T, T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: 4): asserts arr is [T, T, T, T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: number): asserts arr is ImmutableArray<T>;
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): asserts arr is readonly [T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): asserts arr is readonly [T, T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): asserts arr is readonly [T, T, T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): asserts arr is readonly [T, T, T, T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min?: 1, max?: number): asserts arr is readonly [T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 2, max?: number): asserts arr is readonly [T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 3, max?: number): asserts arr is readonly [T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 4, max?: number): asserts arr is readonly [T, T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: number, max?: number): asserts arr is ImmutableArray<T>;
 /** Get an array if it has the specified minimum length.  */
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min?: 1): [T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: 2): [T, T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: 3): [T, T, T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: 4): [T, T, T, T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: number): ImmutableArray<T>;
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): readonly [T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): readonly [T, T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): readonly [T, T, T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): readonly [T, T, T, T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min?: 1, max?: number): readonly [T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: number): readonly [T, T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): readonly [T, T, T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): readonly [T, T, T, T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min?: number, max?: number): ImmutableArray<T>;

package/util/array.js

@@ -1,6 +1,7 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { filterItems, omitItems, pickItems } from "./iterate.js";
+import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
 export const isArray = (v) => Array.isArray(v);
 /** Assert that a value is an array. */
@@ -137,14 +138,14 @@ export function limitArray(items, limit) {
 export function countArray(arr) {
     return arr.length;
 }
-export function isArrayMin(arr, min = 1) {
-    return arr.length >= min;
+export function isArrayLength(arr, min = 1, max = Infinity) {
+    return arr.length >= min && arr.length <= max;
 }
-export function assertArrayMin(arr, min = 1) {
-    if (!isArray(arr) || !isArrayMin(arr, min))
-        throw new AssertionError(`Must be array with minimum length ${min}`, arr);
+export function assertArrayLength(arr, min = 1, max = Infinity) {
+    if (!isArray(arr) || !isArrayLength(arr, min, max))
+        throw new AssertionError(`Must be array with length ${formatRange(min, max)}`, arr);
 }
-export function getArrayMin(arr, min = 1) {
-    assertArrayMin(arr, min);
+export function getArrayLength(arr, min = 1, max = Infinity) {
+    assertArrayLength(arr, min, max);
     return arr;
 }

package/util/number.d.ts

@@ -70,6 +70,8 @@ export declare function boundNumber(num: number, min: number, max: number): numb
 export declare function wrapNumber(num: number, min: number, max: number): number;
 /** Format a number (based on the user's browser language settings). */
 export declare function formatNumber(num: number, precision?: number | null): string;
+/** Format a number range (based on the user's browser language settings). */
+export declare function formatRange(min: number, max: number, precision?: number | null): string;
 /** Format a number with a short suffix, e.g. `1,000 kg` */
 export declare const formatQuantity: (num: number, abbr: string, precision?: number | null) => string;
 /** Format a number with a longer full-word suffix. */

package/util/number.js

@@ -110,10 +110,16 @@ export function wrapNumber(num, min, max) {
 }
 /** Format a number (based on the user's browser language settings). */
 export function formatNumber(num, precision = null) {
+    if (Number.isNaN(num))
+        return "None";
     if (!Number.isFinite(num))
-        return Number.isNaN(num) ? "None" : "Infinity";
+        return "∞";
     return new Intl.NumberFormat(undefined, { minimumFractionDigits: precision !== null && precision !== void 0 ? precision : undefined, maximumFractionDigits: precision !== null && precision !== void 0 ? precision : 20 }).format(num);
 }
+/** Format a number range (based on the user's browser language settings). */
+export function formatRange(min, max, precision = null) {
+    return `${formatNumber(min, precision)}–${formatNumber(max, precision)}`;
+}
 /** Format a number with a short suffix, e.g. `1,000 kg` */
 export const formatQuantity = (num, abbr, precision) => `${formatNumber(num, precision)}${NNBSP}${abbr}`;
 /** Format a number with a longer full-word suffix. */

package/util/string.d.ts

@@ -27,6 +27,12 @@ export declare function assertString(value: unknown): asserts value is string;
  * - Everything else returns `"Unknown"`
  */
 export declare function getString(value: unknown): string;
+/** Does a string have the specified minimum length.  */
+export declare const isStringLength: (str: string, min?: number, max?: number) => boolean;
+/** Assert that a value has a specific length (or length is in a specific range). */
+export declare function assertStringLength(str: string | unknown, min?: number, max?: number): asserts str is string;
+/** Get a string if it has the specified minimum length.  */
+export declare function getStringLength(arr: string, min?: number, max?: number): string;
 /** Concatenate an iterable set of strings together. */
 export declare const joinStrings: (strs: Iterable<string> & NotString, joiner?: string) => string;
 /**
@@ -89,13 +95,17 @@ export declare function limitString(str: string, maxLength: number, append?: str
  * Divide a string into parts based on a separator.
  * - Like `String.prototype.split()` but with more useful arguments.
  * - Excess segments in `String.prototype.split()` is counterintuitive because further parts are thrown away.
- * - Excess segments in `splitString()` are concatenated onto the last segment (set `maxSegments` to `null` if you want infinite segments).
+ * - Excess segments in `splitString()` are concatenated onto the last segment (set `max` to `null` if you want infinite segments).
  *
- * @throws AssertionError if `minSegments` isn't met.
+ * @throws AssertionError if `min` isn't met.
  * @throws AssertionError if any of the segments are empty.
  */
-export declare function splitString(str: string, separator: string, minSegments: 1, maxSegments?: number): readonly [string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments: 2, maxSegments?: number): readonly [string, string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments: 3, maxSegments?: number): readonly [string, string, string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments: 4, maxSegments?: number): readonly [string, string, string, string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments?: number, maxSegments?: number | null): ImmutableArray<string>;
+export declare function splitString(str: string, separator: string, min: 1, max: 1): readonly [string];
+export declare function splitString(str: string, separator: string, min: 2, max: 2): readonly [string, string];
+export declare function splitString(str: string, separator: string, min: 3, max: 3): readonly [string, string, string];
+export declare function splitString(str: string, separator: string, min: 4, max: 4): readonly [string, string, string, string];
+export declare function splitString(str: string, separator: string, min: 1, max?: number): readonly [string, ...string[]];
+export declare function splitString(str: string, separator: string, min: 2, max?: number): readonly [string, string, ...string[]];
+export declare function splitString(str: string, separator: string, min: 3, max?: number): readonly [string, string, string, ...string[]];
+export declare function splitString(str: string, separator: string, min: 4, max?: number): readonly [string, string, string, string, ...string[]];
+export declare function splitString(str: string, separator: string, min?: number, max?: number): ImmutableArray<string>;

package/util/string.js

@@ -3,7 +3,7 @@ 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 { formatNumber, isBetween } from "./number.js";
+import { formatNumber, formatRange, isBetween } from "./number.js";
 /** Is a value a string? */
 export const isString = (v) => typeof v === "string";
 /** Assert that a value is a string. */
@@ -45,6 +45,18 @@ export function getString(value) {
         return formatObject(value);
     return "Unknown";
 }
+/** Does a string have the specified minimum length.  */
+export const isStringLength = (str, min = 1, max = Infinity) => str.length >= min && str.length <= max;
+/** Assert that a value has a specific length (or length is in a specific range). */
+export function assertStringLength(str, min = 1, max = Infinity) {
+    if (!isString(str) || !isStringLength(str, min, max))
+        throw new AssertionError(`Must be string with length ${formatRange(min, max)}`, str);
+}
+/** Get a string if it has the specified minimum length.  */
+export function getStringLength(arr, min = 1, max = Infinity) {
+    assertStringLength(arr, min, max);
+    return arr;
+}
 /** Concatenate an iterable set of strings together. */
 export const joinStrings = (strs, joiner = "") => getArray(strs).join(joiner);
 /**
@@ -133,11 +145,11 @@ export function limitString(str, maxLength, append = "…") {
     const lastSpace = str.lastIndexOf(" ", maxLength);
     return `${str.slice(0, lastSpace > 0 ? lastSpace : maxLength).trimEnd()}${append}`;
 }
-export function splitString(str, separator, minSegments = 0, maxSegments = minSegments) {
+export function splitString(str, separator, min = 1, max = Infinity) {
     const segments = str.split(separator);
-    if (typeof maxSegments === "number" && segments.length > maxSegments)
-        segments.splice(maxSegments - 1, segments.length, segments.slice(maxSegments - 1).join(separator));
-    if (segments.length < minSegments || !segments.every(Boolean))
-        throw new AssertionError(`Must be string with ${minSegments} non-empty segments separated by "${separator}"`, str);
+    if (segments.length > max)
+        segments.splice(max - 1, segments.length, segments.slice(max - 1).join(separator));
+    if (segments.length < min || !segments.every(Boolean))
+        throw new AssertionError(`Must be string with ${formatRange(min, max)} non-empty segments separated by "${separator}"`, str);
     return segments;
 }