shelving 1.35.0 → 1.36.0

package/db/Pagination.js

@@ -1,4 +1,4 @@
-import { getLastItem, assertLength, assertNumber, yieldMerged, toMap, LOADING } from "../util/index.js";
+import { getLastItem, assertNumber, yieldMerged, toMap, LOADING, assertMaximum } from "../util/index.js";
 import { State } from "../stream/index.js";
 import { ConditionError } from "../index.js";
 /**
@@ -40,7 +40,7 @@ export class Pagination extends State {
         };
         this.ref = ref;
         assertNumber(ref.limit); // Collection must have a numeric limit to paginate (otherwise you'd be retrieving the entire set of documents).
-        assertLength(ref.sorts, 1, Infinity); // Collection must have at least one sort order to paginate.
+        assertMaximum(ref.sorts.size, 1); // Collection must have at least one sort order to paginate.
         this.limit = ref.limit;
     }
     /**

package/package.json

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

package/query/Rules.d.ts

@@ -8,7 +8,7 @@ export declare abstract class Rules<T extends Data, R extends Rule<T>> extends R
     /** Get the last rule. */
     get last(): R | undefined;
     /** Get the number of rules. */
-    get length(): number;
+    get size(): number;
     constructor(...rules: R[]);
     toString(): string;
     /** Iterate over the rules. */

package/query/Rules.js

@@ -15,7 +15,7 @@ export class Rules extends Rule {
         return this._rules[this._rules.length - 1];
     }
     /** Get the number of rules. */
-    get length() {
+    get size() {
         return this._rules.length;
     }
     toString() {

package/util/array.d.ts

@@ -163,3 +163,15 @@ export declare function removeItems<T>(arr: MutableArray<T>, items: Iterable<T>)
 export declare function uniqueArray<T>(input: Iterable<T>): ImmutableArray<T>;
 /** Apply a limit to an array. */
 export declare function limitArray<T>(arr: ImmutableArray<T>, limit: number): ImmutableArray<T>;
+/** Does an array have the specified minimum length.  */
+export declare function isMinimumLength<T>(arr: ImmutableArray<T>, min?: 1): arr is [T, ...T[]];
+export declare function isMinimumLength<T>(arr: ImmutableArray<T>, min: 2): arr is [T, T, ...T[]];
+export declare function isMinimumLength<T>(arr: ImmutableArray<T>, min: 3): arr is [T, T, T, ...T[]];
+export declare function isMinimumLength<T>(arr: ImmutableArray<T>, min: 4): arr is [T, T, T, T, ...T[]];
+export declare function isMinimumLength<T>(arr: ImmutableArray<T>, min: number): arr is [T, T, T, T, T, ...T[]];
+/** Get an array if it has the specified minimum length.  */
+export declare function getMinimumLength<T>(arr: ImmutableArray<T>, min?: 1): [T, ...T[]];
+export declare function getMinimumLength<T>(arr: ImmutableArray<T>, min: 2): [T, T, ...T[]];
+export declare function getMinimumLength<T>(arr: ImmutableArray<T>, min: 3): [T, T, T, ...T[]];
+export declare function getMinimumLength<T>(arr: ImmutableArray<T>, min: 4): [T, T, T, T, ...T[]];
+export declare function getMinimumLength<T>(arr: ImmutableArray<T>, min: number): [T, T, T, T, T, ...T[]];

package/util/array.js

@@ -1,3 +1,4 @@
+import { AssertionError } from "../error/index.js";
 /** Is an unknown value an array? */
 export const isArray = (v) => v instanceof Array;
 /** Is an unknown value an item in a specified array? */
@@ -244,3 +245,11 @@ export function uniqueArray(input) {
 export function limitArray(arr, limit) {
     return limit > arr.length ? arr : arr.slice(0, limit);
 }
+export function isMinimumLength(arr, min = 1) {
+    return arr.length >= min;
+}
+export function getMinimumLength(arr, min = 1) {
+    if (arr.length >= min)
+        return arr;
+    throw new AssertionError(`Must have minimum length ${min}`, arr);
+}

package/util/assert.d.ts

@@ -24,15 +24,21 @@ export declare function assertProp<K extends string | number | symbol, T extends
     [L in K]: unknown;
 }>(value: T | unknown, key: K): asserts value is T;
 /** Assert that a value is an array. */
-export declare function assertArray<T extends ImmutableArray>(value: T | unknown): asserts value is T;
+export declare function assertArray<T>(value: ImmutableArray<T> | unknown): asserts value is ImmutableArray<T>;
 /** Assert that a value has a specific length (or length is in a specific range). */
-export declare function assertLength<T extends {
-    length: number;
-}>(value: T | unknown, min: number, max?: number): asserts value is T;
+export declare function assertMinimumLength<T>(value: ImmutableArray<T> | unknown, min?: 1): asserts value is [T, ...T[]];
+export declare function assertMinimumLength<T>(value: ImmutableArray<T> | unknown, min: 2): asserts value is [T, T, ...T[]];
+export declare function assertMinimumLength<T>(value: ImmutableArray<T> | unknown, min: 3): asserts value is [T, T, T, ...T[]];
+export declare function assertMinimumLength<T>(value: ImmutableArray<T> | unknown, min: 4): asserts value is [T, T, T, T, ...T[]];
+export declare function assertMinimumLength<T>(value: ImmutableArray<T> | unknown, min: number): asserts value is [T, T, T, T, T, ...T[]];
+/** Assert that a value has a specific length (or length is in a specific range). */
+export declare function assertLength<T>(value: ImmutableArray<T> | unknown, min: number, max?: number): asserts value is ImmutableArray<T>;
+/** Assert that a value is a number greater than. */
+export declare function assertBetween(value: number | unknown, min: number, max: number): asserts value is number;
 /** Assert that a value is a number greater than. */
-export declare function assertGreater(value: number | unknown, target: number): asserts value is number;
+export declare function assertMaximum(value: number | unknown, max: number): asserts value is number;
 /** Assert that a value is a number less than. */
-export declare function assertLess(value: number | unknown, target: number): asserts value is number;
+export declare function assertMinimum(value: number | unknown, min: number): asserts value is number;
 /** Assert that a value is an instance of something. */
 export declare function assertInstance<T>(value: T | unknown, type: Class<T>): asserts value is T;
 /** Assert that a value is a function. */
@@ -42,8 +48,8 @@ export declare function assertValue<T>(value: T | typeof NOVALUE): asserts value
 /** Assert that a value is not the `NOVALUE` constant. */
 export declare function assertDefined<T>(value: T | undefined): asserts value is T;
 /** Expect a synchronous value. */
-export declare function assertSync<T>(value: Promise<T> | T): asserts value is T;
+export declare function assertSynchronous<T>(value: Promise<T> | T): asserts value is T;
 /** Expect an asynchronous value. */
-export declare function assertAsync<T>(value: PromiseLike<T> | T): asserts value is PromiseLike<T>;
+export declare function assertAsynchronous<T>(value: PromiseLike<T> | T): asserts value is PromiseLike<T>;
 /** Expect a promise. */
 export declare function assertPromise<T>(value: Promise<T> | T): asserts value is Promise<T>;

package/util/assert.js

@@ -1,6 +1,7 @@
 import { AssertionError } from "../error/index.js";
 import { debug } from "./debug.js";
 import { isObject } from "./object.js";
+import { isArray } from "./array.js";
 import { NOVALUE } from "./constants.js";
 import { isAsync } from "./async.js";
 /** Assert a boolean condition is true. */
@@ -53,20 +54,29 @@ export function assertArray(value) {
     if (!(value instanceof Array))
         throw new AssertionError(`Must be array`, value);
 }
+export function assertMinimumLength(value, min = 1) {
+    if (!isArray(value) || value.length < min)
+        throw new AssertionError(`Must be array with minimum length ${min}`, value);
+}
 /** Assert that a value has a specific length (or length is in a specific range). */
 export function assertLength(value, min, max = min) {
-    if (!isObject(value) || typeof value.length !== "number" || value.length < min || value.length > max)
-        throw new AssertionError(`Must have length ${min}–${max}`, value);
+    if (!isArray(value) || value.length < min || value.length > max)
+        throw new AssertionError(`Must be array with length ${min}-${max}`, value);
+}
+/** Assert that a value is a number greater than. */
+export function assertBetween(value, min, max) {
+    if (typeof value !== "number" || value < min || value > max)
+        throw new AssertionError(`Must be number between ${min}-${max}`, value);
 }
 /** Assert that a value is a number greater than. */
-export function assertGreater(value, target) {
-    if (typeof value !== "number" || value <= target)
-        throw new AssertionError(`Must be greater than ${target}`, value);
+export function assertMaximum(value, max) {
+    if (typeof value !== "number" || value > max)
+        throw new AssertionError(`Must be number with maximum ${max}`, value);
 }
 /** Assert that a value is a number less than. */
-export function assertLess(value, target) {
-    if (typeof value !== "number" || value >= target)
-        throw new AssertionError(`Must be less than ${target}`, value);
+export function assertMinimum(value, min) {
+    if (typeof value !== "number" || value < min)
+        throw new AssertionError(`Must be number with minimum ${min}`, value);
 }
 /** Assert that a value is an instance of something. */
 export function assertInstance(value, type) {
@@ -89,12 +99,12 @@ export function assertDefined(value) {
         throw new AssertionError("Must be defined", value);
 }
 /** Expect a synchronous value. */
-export function assertSync(value) {
+export function assertSynchronous(value) {
     if (isAsync(value))
         throw new AssertionError("Must be synchronous", value);
 }
 /** Expect an asynchronous value. */
-export function assertAsync(value) {
+export function assertAsynchronous(value) {
     if (!isAsync(value))
         throw new AssertionError("Must be asynchronous", value);
 }