ts-data-forge 7.0.1 → 7.1.0

package/dist/array/impl/array-utils-validation.d.mts

@@ -1,4 +1,4 @@
-import { type ArrayAtLeastLen, type ArrayOfLength, type BoolOr, type NonEmptyArray, type TypeEq } from 'ts-type-forge';
+import { type ArrayAtLeastLen, type ArrayAtMostLen, type ArrayBoundedLen, type ArrayOfLength, type BoolOr, type NonEmptyArray, type TypeEq } from 'ts-type-forge';
 import { type ArrayIndex, type SizeType } from '../../types.mjs';
 /**
  * Type guard that checks if a value is an array.
@@ -102,6 +102,46 @@ export declare const isArrayOfLength: <E, N extends SizeType.ArgArr>(array: read
  * ```
  */
 export declare const isArrayAtLeastLength: <E, N extends SizeType.ArgArr>(array: readonly E[], len: N) => array is ArrayAtLeastLen<N, E>;
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isArrayAtMostLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));
+ *
+ * if (Arr.isArrayAtMostLength(pair, 2)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+export declare const isArrayAtMostLength: <E, N extends SizeType.ArgArr>(array: readonly E[], len: N) => array is ArrayAtMostLen<N, E>;
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isArrayBoundedLength(pair, 1, 3));
+ *
+ * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));
+ *
+ * if (Arr.isArrayBoundedLength(pair, 1, 3)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+export declare const isArrayBoundedLength: <E, Min extends SizeType.ArgArr, Max extends SizeType.ArgArr>(array: readonly E[], min: Min, max: Max) => array is ArrayBoundedLen<Min, Max, E>;
 /**
  * Tests whether all elements in an array pass a test implemented by a predicate.
  *

package/dist/array/impl/array-utils-validation.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-validation.mjs

@@ -136,6 +136,46 @@ const isArrayOfLength = (array, len) => array.length === len;
  * ```
  */
 const isArrayAtLeastLength = (array, len) => array.length >= len;
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isArrayAtMostLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));
+ *
+ * if (Arr.isArrayAtMostLength(pair, 2)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+const isArrayAtMostLength = (array, len) => array.length <= len;
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isArrayBoundedLength(pair, 1, 3));
+ *
+ * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));
+ *
+ * if (Arr.isArrayBoundedLength(pair, 1, 3)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+const isArrayBoundedLength = (array, min, max) => array.length >= min && array.length <= max;
 function every(...args) {
     switch (args.length) {
         case 2: {
@@ -179,5 +219,5 @@ function some(...args) {
  */
 const indexIsInRange = (array, index) => Num.isInRange(0, array.length)(index);
 
-export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayOfLength, isEmpty, isNonEmpty, some };
+export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayAtMostLength, isArrayBoundedLength, isArrayOfLength, isEmpty, isNonEmpty, some };
 //# sourceMappingURL=array-utils-validation.mjs.map

package/dist/array/impl/array-utils-validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAQ,KAClC,KAAK,CAAC,OAAO,CAAC,KAAK;AAarB;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAmB,KAC7C,KAAK,CAAC,MAAM,KAAK;AAEnB;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,UAAU,GAAG,CACxB,KAAmB,KACW,KAAK,CAAC,MAAM,GAAG;AAE/C;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,eAAe,GAAG,CAC7B,KAAmB,EACnB,GAAM,KAC2B,KAAK,CAAC,MAAM,KAAK;AAEpD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,KAAmB,EACnB,GAAM,KAC6B,KAAK,CAAC,MAAM,IAAI;AAyC/C,SAAU,KAAK,CACnB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC;QAC3C;;AAEJ;AA8BM,SAAU,IAAI,CAClB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC;QAC1C;;AAEJ;AAEA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,cAAc,GAAG,CAC5B,KAAmB,EACnB,KAAsB,KACV,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK;;;;"}
+{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAQ,KAClC,KAAK,CAAC,OAAO,CAAC,KAAK;AAarB;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAmB,KAC7C,KAAK,CAAC,MAAM,KAAK;AAEnB;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,UAAU,GAAG,CACxB,KAAmB,KACW,KAAK,CAAC,MAAM,GAAG;AAE/C;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,eAAe,GAAG,CAC7B,KAAmB,EACnB,GAAM,KAC2B,KAAK,CAAC,MAAM,KAAK;AAEpD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,KAAmB,EACnB,GAAM,KAC6B,KAAK,CAAC,MAAM,IAAI;AAErD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,mBAAmB,GAAG,CACjC,KAAmB,EACnB,GAAM,KAC4B,KAAK,CAAC,MAAM,IAAI;AAEpD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAKlC,KAAmB,EACnB,GAAQ,EACR,GAAQ,KAER,KAAK,CAAC,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,MAAM,IAAI;AAyCnC,SAAU,KAAK,CACnB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC;QAC3C;;AAEJ;AA8BM,SAAU,IAAI,CAClB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC;QAC1C;;AAEJ;AAEA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,cAAc,GAAG,CAC5B,KAAmB,EACnB,KAAsB,KACV,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK;;;;"}

package/dist/array/impl/index.mjs

@@ -9,5 +9,5 @@ export { length, size } from './array-utils-size.mjs';
 export { sliceClamped } from './array-utils-slice-clamped.mjs';
 export { butLast, drop, rest, skip, skipLast, tail, take, takeLast } from './array-utils-slicing.mjs';
 export { cartesianProduct, chunk, concat, filter, filterNot, flat, flatMap, groupBy, map, partition, scan, toReversed, toSorted, toSortedBy, uniq, uniqBy, zip } from './array-utils-transformation.mjs';
-export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayOfLength, isEmpty, isNonEmpty, some } from './array-utils-validation.mjs';
+export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayAtMostLength, isArrayBoundedLength, isArrayOfLength, isEmpty, isNonEmpty, some } from './array-utils-validation.mjs';
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "7.0.1",
+  "version": "7.1.0",
   "private": false,
   "keywords": [
     "typescript",

package/src/array/impl/array-utils-validation.mts

@@ -1,5 +1,7 @@
 import {
   type ArrayAtLeastLen,
+  type ArrayAtMostLen,
+  type ArrayBoundedLen,
   type ArrayOfLength,
   type BoolOr,
   type NonEmptyArray,
@@ -136,6 +138,60 @@ export const isArrayAtLeastLength = <E, N extends SizeType.ArgArr>(
   len: N,
 ): array is ArrayAtLeastLen<N, E> => array.length >= len;
 
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isArrayAtMostLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));
+ *
+ * if (Arr.isArrayAtMostLength(pair, 2)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+export const isArrayAtMostLength = <E, N extends SizeType.ArgArr>(
+  array: readonly E[],
+  len: N,
+): array is ArrayAtMostLen<N, E> => array.length <= len;
+
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isArrayBoundedLength(pair, 1, 3));
+ *
+ * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));
+ *
+ * if (Arr.isArrayBoundedLength(pair, 1, 3)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+export const isArrayBoundedLength = <
+  E,
+  Min extends SizeType.ArgArr,
+  Max extends SizeType.ArgArr,
+>(
+  array: readonly E[],
+  min: Min,
+  max: Max,
+): array is ArrayBoundedLen<Min, Max, E> =>
+  array.length >= min && array.length <= max;
+
 /**
  * Tests whether all elements in an array pass a test implemented by a predicate.
  *

package/src/array/impl/array-utils-validation.test.mts

@@ -1,10 +1,17 @@
-import { type ArrayAtLeastLen, type ArrayOfLength } from 'ts-type-forge';
+import {
+  type ArrayAtLeastLen,
+  type ArrayAtMostLen,
+  type ArrayBoundedLen,
+  type ArrayOfLength,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
   every,
   indexIsInRange,
   isArray,
   isArrayAtLeastLength,
+  isArrayAtMostLength,
+  isArrayBoundedLength,
   isArrayOfLength,
   isEmpty,
   isNonEmpty,
@@ -584,6 +591,158 @@ describe('Arr validations', () => {
     });
   });
 
+  describe(isArrayAtMostLength, () => {
+    test('should return true if array length is less than or equal to specified length', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isTrue(isArrayAtMostLength(arr, 3));
+
+      if (isArrayAtMostLength(arr, 3)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+
+      assert.isTrue(isArrayAtMostLength(arr, 4));
+
+      if (isArrayAtMostLength(arr, 4)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+    });
+
+    test('should return false if array length is greater than specified length', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isFalse(isArrayAtMostLength(arr, 2));
+    });
+
+    test('should return true for empty array and length 0', () => {
+      const arr = [] as const;
+
+      assert.isTrue(isArrayAtMostLength(arr, 0));
+
+      if (isArrayAtMostLength(arr, 0)) {
+        expectType<typeof arr, readonly []>('=');
+      }
+    });
+
+    test('should return false for non-empty array and length 0', () => {
+      const arr = [1] as const;
+
+      assert.isFalse(isArrayAtMostLength(arr, 0));
+    });
+
+    test('should work with unknown array type', () => {
+      const mut_arr: number[] = [1, 2];
+
+      assert.isTrue(isArrayAtMostLength(mut_arr, 2));
+
+      // transformer-ignore-next-line
+      expectType<typeof mut_arr, number[] & ArrayAtMostLen<2, number>>('=');
+
+      assert.isFalse(isArrayAtMostLength(mut_arr, 1));
+    });
+
+    test('should return true for arrays of at most specified length (additional)', () => {
+      assert.isTrue(isArrayAtMostLength([1, 2, 3], 3));
+
+      assert.isTrue(isArrayAtMostLength([1, 2, 3], 4));
+
+      assert.isTrue(isArrayAtMostLength([], 0));
+    });
+
+    test('should return false for arrays longer than specified length (additional)', () => {
+      assert.isFalse(isArrayAtMostLength([1, 2, 3], 2));
+
+      assert.isFalse(isArrayAtMostLength([1, 2, 3], 0));
+    });
+
+    test('should work as type guard for at most length (additional)', () => {
+      const array: readonly number[] = [1, 2] as const;
+
+      if (isArrayAtMostLength(array, 3)) {
+        expectType<typeof array, ArrayAtMostLen<3, number>>('=');
+
+        expect(array.length).toBeLessThanOrEqual(3);
+      }
+    });
+  });
+
+  describe(isArrayBoundedLength, () => {
+    test('should return true if array length is within the specified range', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isTrue(isArrayBoundedLength(arr, 1, 3));
+
+      if (isArrayBoundedLength(arr, 1, 3)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+
+      assert.isTrue(isArrayBoundedLength(arr, 3, 5));
+
+      if (isArrayBoundedLength(arr, 3, 5)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+    });
+
+    test('should return false if array length is below the specified range', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isFalse(isArrayBoundedLength(arr, 4, 5));
+    });
+
+    test('should return false if array length is above the specified range', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isFalse(isArrayBoundedLength(arr, 0, 2));
+    });
+
+    test('should return true for empty array and range including 0', () => {
+      const arr = [] as const;
+
+      assert.isTrue(isArrayBoundedLength(arr, 0, 2));
+
+      if (isArrayBoundedLength(arr, 0, 2)) {
+        expectType<typeof arr, readonly []>('=');
+      }
+    });
+
+    test('should work with unknown array type', () => {
+      const mut_arr: number[] = [1, 2];
+
+      assert.isTrue(isArrayBoundedLength(mut_arr, 1, 3));
+
+      // transformer-ignore-next-line
+      expectType<typeof mut_arr, number[] & ArrayBoundedLen<1, 3, number>>('=');
+
+      assert.isFalse(isArrayBoundedLength(mut_arr, 3, 5));
+    });
+
+    test('should return true for arrays within specified range (additional)', () => {
+      assert.isTrue(isArrayBoundedLength([1, 2, 3], 1, 3));
+
+      assert.isTrue(isArrayBoundedLength([1, 2, 3], 3, 3));
+
+      assert.isTrue(isArrayBoundedLength([], 0, 0));
+    });
+
+    test('should return false for arrays outside specified range (additional)', () => {
+      assert.isFalse(isArrayBoundedLength([1, 2, 3], 4, 5));
+
+      assert.isFalse(isArrayBoundedLength([1, 2, 3], 0, 2));
+    });
+
+    test('should work as type guard for bounded length (additional)', () => {
+      const array: readonly number[] = [1, 2] as const;
+
+      if (isArrayBoundedLength(array, 1, 3)) {
+        expectType<typeof array, ArrayBoundedLen<1, 3, number>>('=');
+
+        expect(array.length).toBeGreaterThanOrEqual(1);
+
+        expect(array.length).toBeLessThanOrEqual(3);
+      }
+    });
+  });
+
   describe(every, () => {
     test('should return true when all elements satisfy predicate', () => {
       const evens = [2, 4, 6, 8] as const;