ts-data-forge 14.7.1 → 14.9.0

package/src/array/impl/array-utils-length-bounded-array-cast.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type MaxLengthArray,
-  type MinLengthArray,
-  type NonEmptyArray,
-  type SupportedLength,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  MaxLengthArray,
+  MinLengthArray,
+  NonEmptyArray,
+  SupportedLength,
 } from 'ts-type-forge';
 import {
   isBoundedLengthArray,

package/src/array/impl/array-utils-length-bounded-array-cast.test.mts

@@ -1,9 +1,9 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type MaxLengthArray,
-  type MinLengthArray,
-  type NonEmptyArray,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  MaxLengthArray,
+  MinLengthArray,
+  NonEmptyArray,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {

package/src/array/impl/array-utils-length-bounded-array-guard.mts

@@ -1,9 +1,9 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type MaxLengthArray,
-  type MinLengthArray,
-  type SupportedLength,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  MaxLengthArray,
+  MinLengthArray,
+  SupportedLength,
 } from 'ts-type-forge';
 
 /**
@@ -38,9 +38,9 @@ import {
  *
  *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)
  *
- *   assert.deepStrictEqual(history[0], 0);
+ *   assert.strictEqual(history[0], 0);
  *
- *   assert.deepStrictEqual(nonEmpty[0], 0);
+ *   assert.strictEqual(nonEmpty[0], 0);
  * }
  *
  * // curried version
@@ -122,9 +122,9 @@ const hasMinLength = (
  *
  *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)
  *
- *   assert.deepStrictEqual(tags.length, 3);
+ *   assert.strictEqual(tags.length, 3);
  *
- *   assert.deepStrictEqual(relaxed.length, 3);
+ *   assert.strictEqual(relaxed.length, 3);
  * }
  *
  * // curried version
@@ -207,9 +207,9 @@ const hasMaxLength = (
  *
  *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])
  *
- *   assert.deepStrictEqual(selection[0], 1);
+ *   assert.strictEqual(selection[0], 1);
  *
- *   assert.deepStrictEqual(relaxed.length, 3);
+ *   assert.strictEqual(relaxed.length, 3);
  * }
  *
  * // curried version
@@ -271,7 +271,7 @@ const hasBoundedLength = (
   minLength: SupportedLength,
   maxLength: SupportedLength,
   xs: readonly unknown[],
-): boolean => xs.length >= minLength && xs.length <= maxLength;
+): boolean => minLength <= xs.length && xs.length <= maxLength;
 
 /**
  * Type guard that checks if an array has exactly `length` elements.
@@ -306,9 +306,9 @@ const hasBoundedLength = (
  *
  *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)
  *
- *   assert.deepStrictEqual(rgb[0], 255);
+ *   assert.strictEqual(rgb[0], 255);
  *
- *   assert.deepStrictEqual(atMost5.length, 3);
+ *   assert.strictEqual(atMost5.length, 3);
  * }
  *
  * // curried version

package/src/array/impl/array-utils-length-bounded-array-guard.test.mts

@@ -1,8 +1,8 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type MaxLengthArray,
-  type MinLengthArray,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  MaxLengthArray,
+  MinLengthArray,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -32,39 +32,43 @@ describe(isMinLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [0, 1, 2, 3] as const;
 
-    if (isMinLengthArray(3, value)) {
-      expectType<typeof value, MinLengthArray<3, number>>('<=');
+    if (!isMinLengthArray(3, value)) {
+      return;
+    }
 
-      expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
+    expectType<typeof value, MinLengthArray<3, number>>('<=');
 
-      expectType<typeof value, MinLengthArray<5, number>>('!<=');
+    expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
 
-      // indexed access below the minimum length does not include `undefined`
-      // (even under `noUncheckedIndexedAccess`)
-      const _first = value[0];
+    expectType<typeof value, MinLengthArray<5, number>>('!<=');
 
-      expectType<typeof _first, number>('=');
+    // indexed access below the minimum length does not include `undefined`
+    // (even under `noUncheckedIndexedAccess`)
+    const _first = value[0];
 
-      const _third = value[2];
+    expectType<typeof _first, number>('=');
 
-      expectType<typeof _third, number>('=');
+    const _third = value[2];
 
-      const _fourth = value[3];
+    expectType<typeof _third, number>('=');
 
-      expectType<typeof _fourth, number | undefined>('=');
+    const _fourth = value[3];
 
-      expect(value.length).toBeGreaterThanOrEqual(3);
-    }
+    expectType<typeof _fourth, number | undefined>('=');
+
+    expect(value.length).toBeGreaterThanOrEqual(3);
   });
 
   test('should preserve the original array type', () => {
     const tuple = [1, 2, 3] as const;
 
-    if (isMinLengthArray(2, tuple)) {
-      expectType<typeof tuple, readonly [1, 2, 3]>('<=');
-
-      expectType<typeof tuple, MinLengthArray<2, 1 | 2 | 3>>('<=');
+    if (!isMinLengthArray(2, tuple)) {
+      return;
     }
+
+    expectType<typeof tuple, readonly [1, 2, 3]>('<=');
+
+    expectType<typeof tuple, MinLengthArray<2, 1 | 2 | 3>>('<=');
   });
 });
 
@@ -86,15 +90,17 @@ describe(isMaxLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [0, 1, 2] as const;
 
-    if (isMaxLengthArray(8, value)) {
-      expectType<typeof value, MaxLengthArray<8, number>>('<=');
+    if (!isMaxLengthArray(8, value)) {
+      return;
+    }
 
-      expectType<typeof value, MaxLengthArray<16, number>>('<='); // 8 <= 16
+    expectType<typeof value, MaxLengthArray<8, number>>('<=');
 
-      expectType<typeof value, MaxLengthArray<2, number>>('!<=');
+    expectType<typeof value, MaxLengthArray<16, number>>('<='); // 8 <= 16
 
-      expect(value.length).toBeLessThanOrEqual(8);
-    }
+    expectType<typeof value, MaxLengthArray<2, number>>('!<=');
+
+    expect(value.length).toBeLessThanOrEqual(8);
   });
 });
 
@@ -116,17 +122,19 @@ describe(isBoundedLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [1, 2, 3] as const;
 
-    if (isBoundedLengthArray(1, 5, value)) {
-      expectType<typeof value, BoundedLengthArray<1, 5, number>>('<=');
+    if (!isBoundedLengthArray(1, 5, value)) {
+      return;
+    }
 
-      expectType<typeof value, BoundedLengthArray<0, 100, number>>('<=');
+    expectType<typeof value, BoundedLengthArray<1, 5, number>>('<=');
 
-      expectType<typeof value, MinLengthArray<1, number>>('<=');
+    expectType<typeof value, BoundedLengthArray<0, 100, number>>('<=');
 
-      expectType<typeof value, MaxLengthArray<5, number>>('<=');
+    expectType<typeof value, MinLengthArray<1, number>>('<=');
 
-      expectType<typeof value, BoundedLengthArray<2, 5, number>>('!<=');
-    }
+    expectType<typeof value, MaxLengthArray<5, number>>('<=');
+
+    expectType<typeof value, BoundedLengthArray<2, 5, number>>('!<=');
   });
 });
 
@@ -146,27 +154,29 @@ describe(isFixedLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [255, 128, 0] as const;
 
-    if (isFixedLengthArray(3, value)) {
-      expectType<typeof value, FixedLengthArray<3, number>>('<=');
+    if (!isFixedLengthArray(3, value)) {
+      return;
+    }
 
-      expectType<typeof value, MaxLengthArray<5, number>>('<='); // 3 <= 5
+    expectType<typeof value, FixedLengthArray<3, number>>('<=');
 
-      expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
+    expectType<typeof value, MaxLengthArray<5, number>>('<='); // 3 <= 5
 
-      expectType<typeof value, FixedLengthArray<4, number>>('!<=');
+    expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
 
-      // `length` is narrowed to the literal and in-range indexed access does
-      // not include `undefined` (even under `noUncheckedIndexedAccess`)
-      const _len = value.length;
+    expectType<typeof value, FixedLengthArray<4, number>>('!<=');
 
-      expectType<typeof _len, 3>('=');
+    // `length` is narrowed to the literal and in-range indexed access does
+    // not include `undefined` (even under `noUncheckedIndexedAccess`)
+    const _len = value.length;
 
-      const _second = value[1];
+    expectType<typeof _len, 3>('=');
 
-      expectType<typeof _second, number>('=');
+    const _second = value[1];
 
-      expect(value).toHaveLength(3);
-    }
+    expectType<typeof _second, number>('=');
+
+    expect(value).toHaveLength(3);
   });
 });
 
@@ -182,13 +192,15 @@ describe('curried length guards', () => {
 
     assert.isTrue(hasThree(value));
 
-    if (hasThree(value)) {
-      expectType<typeof value, MinLengthArray<3, number>>('<=');
+    if (!hasThree(value)) {
+      return;
+    }
 
-      const _first = value[0];
+    expectType<typeof value, MinLengthArray<3, number>>('<=');
 
-      expectType<typeof _first, number>('=');
-    }
+    const _first = value[0];
+
+    expectType<typeof _first, number>('=');
   });
 
   test('isMaxLengthArray narrows when applied later', () => {

package/src/array/impl/array-utils-length-bounded-tuple-cast.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import {
   isBoundedLengthTuple,
   isEmptyTuple,

package/src/array/impl/array-utils-length-bounded-tuple-cast.test.mts

@@ -1,8 +1,8 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -24,7 +24,7 @@ describe(asFixedLengthTuple, () => {
 
     const red: number = casted[0];
 
-    assert.deepStrictEqual(red, 255);
+    assert.strictEqual(red, 255);
   });
 
   test('is the same value it was handed', () => {
@@ -69,7 +69,7 @@ describe(asMinLengthTuple, () => {
 
     const first: number = casted[0];
 
-    assert.deepStrictEqual(first, 0);
+    assert.strictEqual(first, 0);
   });
 
   test('throws when the array is too short', () => {
@@ -168,7 +168,7 @@ describe(asNonEmptyTuple, () => {
 
     const first: number = casted[0];
 
-    assert.deepStrictEqual(first, 1);
+    assert.strictEqual(first, 1);
   });
 
   test('throws when the array is empty', () => {
@@ -190,7 +190,7 @@ describe('tuple casts preserve the input type, like their branded counterparts',
 
     const length: 5 = casted.length;
 
-    assert.deepStrictEqual(length, 5);
+    assert.strictEqual(length, 5);
 
     assert.deepStrictEqual<readonly number[]>(casted, [1, 2, 3, 4, 5]);
   });
@@ -202,6 +202,6 @@ describe('tuple casts preserve the input type, like their branded counterparts',
 
     const first: 1 = casted[0];
 
-    assert.deepStrictEqual(first, 1);
+    assert.strictEqual(first, 1);
   });
 });

package/src/array/impl/array-utils-length-bounded-tuple-guard.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 
 /**
  * Type guard that checks if an array is empty, narrowing it to the structural
@@ -218,7 +218,7 @@ const hasMaxLength = (
  * assert.isFalse(Arr.isBoundedLengthTuple(1, 3, quad));
  *
  * if (Arr.isBoundedLengthTuple(1, 3, pair)) {
- *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ *   assert.isTrue(1 <= pair.length && pair.length <= 3);
  * }
  * ```
  */
@@ -263,4 +263,4 @@ const isWithinBounds = (
   min: SizeType.ArgArr,
   max: SizeType.ArgArr,
   array: readonly unknown[],
-): boolean => array.length >= min && array.length <= max;
+): boolean => min <= array.length && array.length <= max;

package/src/array/impl/array-utils-length-bounded-tuple-guard.test.mts

@@ -1,8 +1,8 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -92,11 +92,13 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard with exact length (additional)', () => {
       const array: readonly number[] = [1, 2, 3] as const;
 
-      if (isFixedLengthTuple(3, array)) {
-        expectType<typeof array, FixedLengthTuple<3, number>>('=');
-
-        expect(array).toHaveLength(3);
+      if (!isFixedLengthTuple(3, array)) {
+        return;
       }
+
+      expectType<typeof array, FixedLengthTuple<3, number>>('=');
+
+      expect(array).toHaveLength(3);
     });
   });
 
@@ -180,11 +182,13 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard for at least length (additional)', () => {
       const array: readonly number[] = [1, 2, 3] as const;
 
-      if (isMinLengthTuple(2, array)) {
-        expectType<typeof array, MinLengthTuple<2, number>>('=');
-
-        expect(array.length).toBeGreaterThanOrEqual(2);
+      if (!isMinLengthTuple(2, array)) {
+        return;
       }
+
+      expectType<typeof array, MinLengthTuple<2, number>>('=');
+
+      expect(array.length).toBeGreaterThanOrEqual(2);
     });
   });
 
@@ -255,11 +259,13 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard for at most length (additional)', () => {
       const array: readonly number[] = [1, 2] as const;
 
-      if (isMaxLengthTuple(3, array)) {
-        expectType<typeof array, MaxLengthTuple<3, number>>('=');
-
-        expect(array.length).toBeLessThanOrEqual(3);
+      if (!isMaxLengthTuple(3, array)) {
+        return;
       }
+
+      expectType<typeof array, MaxLengthTuple<3, number>>('=');
+
+      expect(array.length).toBeLessThanOrEqual(3);
     });
   });
 
@@ -332,13 +338,15 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard for bounded length (additional)', () => {
       const array: readonly number[] = [1, 2] as const;
 
-      if (isBoundedLengthTuple(1, 3, array)) {
-        expectType<typeof array, BoundedLengthTuple<1, 3, number>>('=');
+      if (!isBoundedLengthTuple(1, 3, array)) {
+        return;
+      }
 
-        expect(array.length).toBeGreaterThanOrEqual(1);
+      expectType<typeof array, BoundedLengthTuple<1, 3, number>>('=');
 
-        expect(array.length).toBeLessThanOrEqual(3);
-      }
+      expect(array.length).toBeGreaterThanOrEqual(1);
+
+      expect(array.length).toBeLessThanOrEqual(3);
     });
   });
 
@@ -364,14 +372,16 @@ describe('Arr structural tuple length guards', () => {
 
       assert.isTrue(isNonEmptyTuple(values));
 
-      if (isNonEmptyTuple(values)) {
-        expectType<typeof values, MinLengthTuple<1, number>>('=');
+      if (!isNonEmptyTuple(values)) {
+        return;
+      }
+
+      expectType<typeof values, MinLengthTuple<1, number>>('=');
 
-        // The structural prefix makes the first element defined.
-        const first: number = values[0];
+      // The structural prefix makes the first element defined.
+      const first: number = values[0];
 
-        assert.deepStrictEqual(first, 1);
-      }
+      assert.strictEqual(first, 1);
     });
 
     test('rejects an empty array', () => {

package/src/array/impl/array-utils-length-constraint-preservation.test.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type FixedLengthTuple,
-  type MaxLengthArray,
-  type MinLengthArray,
-  type Seq,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  FixedLengthTuple,
+  MaxLengthArray,
+  MinLengthArray,
+  Seq,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { copy, create, seq, zeros } from './array-utils-creation.mjs';
@@ -39,7 +39,7 @@ describe('map preserves length constraints', () => {
     // The structural prefix survives, so in-range access is not `undefined`.
     const first: string = result[0];
 
-    assert.deepStrictEqual(first, '#0');
+    assert.strictEqual(first, '#0');
 
     assert.deepStrictEqual<readonly string[]>(result, ['#0', '#1', '#2', '#3']);
   });
@@ -56,7 +56,7 @@ describe('map preserves length constraints', () => {
 
     const length: 3 = result.length;
 
-    assert.deepStrictEqual(length, 3);
+    assert.strictEqual(length, 3);
   });
 
   test('a minimum above the structural prefix cap survives, clamped like MinLengthArray itself', () => {
@@ -199,7 +199,7 @@ describe('other length-preserving utilities preserve length constraints', () =>
     // The structural prefix survives the reversal too.
     const first: number = result[0];
 
-    assert.deepStrictEqual(first, 4);
+    assert.strictEqual(first, 4);
 
     assert.deepStrictEqual<readonly number[]>(result, [4, 3, 2, 1]);
   });
@@ -242,7 +242,7 @@ describe('partition reports the bounds of each chunk', () => {
 
     const first: 1 | 2 | 3 | 4 | 5 = firstChunk[0];
 
-    assert.deepStrictEqual(first, 1);
+    assert.strictEqual(first, 1);
 
     assert.deepStrictEqual<readonly (readonly number[])[]>(result, [
       [1, 2],
@@ -262,7 +262,7 @@ describe('creation utilities report an exact length past their tuple range', ()
 
     expectType<typeof result, FixedLengthArray<12, 'x'>>('~=');
 
-    assert.deepStrictEqual(result.length, 12);
+    assert.strictEqual(result.length, 12);
   });
 
   test('a length still inside the tuple range keeps its exact tuple type', () => {
@@ -280,8 +280,8 @@ describe('creation utilities report an exact length past their tuple range', ()
 
     expectType<typeof seq12, Seq<12>>('=');
 
-    assert.deepStrictEqual(zeros12.length, 12);
+    assert.strictEqual(zeros12.length, 12);
 
-    assert.deepStrictEqual(seq12.length, 12);
+    assert.strictEqual(seq12.length, 12);
   });
 });

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

@@ -1,18 +1,18 @@
-import {
-  type ChangeArrayElement,
-  type ConstrainedList,
-  type FixedLengthTuple,
-  type Increment,
-  type IsFixedLengthList,
-  type NonEmptyArray,
-  type UnknownBrand,
+import type {
+  ChangeArrayElement,
+  ConstrainedList,
+  FixedLengthTuple,
+  Increment,
+  IsFixedLengthList,
+  NonEmptyArray,
+  UnknownBrand,
 } from 'ts-type-forge';
 import { asPositiveUint32 } from '../../number/index.mjs';
 import { castMutable } from '../../others/index.mjs';
-import {
-  type ArgArrayIndex,
-  type ArgArrayIndexWithNegative,
-  type SizeType,
+import type {
+  ArgArrayIndex,
+  ArgArrayIndexWithNegative,
+  SizeType,
 } from '../../types.mjs';
 import { copy, create } from './array-utils-creation.mjs';
 

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

@@ -1,13 +1,13 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type FixedLengthTuple,
-  type MinLengthArray,
-  type NonEmptyArray,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  FixedLengthTuple,
+  MinLengthArray,
+  NonEmptyArray,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { asUint32 } from '../../number/index.mjs';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import {
   asBoundedLengthArray,
   asFixedLengthArray,

package/src/array/impl/array-utils-overload-type-error.test.mts

@@ -1,6 +1,6 @@
 import { expectType } from '../../expect-type.mjs';
 import { pipe } from '../../functional/index.mjs';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import { range } from './array-utils-creation.mjs';
 import { findIndex } from './array-utils-search.mjs';
 import { filterNot, partition } from './array-utils-transformation.mjs';