shelving 1.86.4 → 1.86.5

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.5",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

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;
 }