ts-data-forge 12.2.2 → 14.0.0

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

@@ -1,12 +1,4 @@
-import {
-  type BoolOr,
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
-  type NonEmptyArray,
-  type TypeEq,
-} from 'ts-type-forge';
+import { type BoolOr, type IsAny, type IsUnknown } from 'ts-type-forge';
 import { asUint32, Num } from '../../number/index.mjs';
 import { type ArrayIndex, type SizeType } from '../../types.mjs';
 
@@ -33,8 +25,7 @@ export const isArray = <E,>(value: E): value is FilterArray<E> =>
   Array.isArray(value);
 
 type FilterArray<T> = T extends T
-  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    BoolOr<TypeEq<T, unknown>, TypeEq<T, any>> extends true
+  ? BoolOr<IsUnknown<T>, IsAny<T>> extends true
     ? Cast<readonly unknown[], T>
     : T extends readonly unknown[]
       ? T
@@ -45,153 +36,6 @@ type Cast<A, B> = A extends B ? A : never;
 
 // validation
 
-/**
- * Type guard that checks if an array is empty.
- *
- * @example
- *
- * ```ts
- * const emptyNumbers: readonly number[] = [] as const;
- *
- * const words = ['Ada', 'Lovelace'] as const;
- *
- * assert.isTrue(Arr.isEmpty(emptyNumbers));
- *
- * assert.isFalse(Arr.isEmpty(words));
- *
- * if (Arr.isEmpty(emptyNumbers)) {
- *   assert.deepStrictEqual(emptyNumbers, []);
- * }
- * ```
- */
-export const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>
-  array.length === 0;
-
-/**
- * Type guard that checks if an array is non-empty.
- *
- * @example
- *
- * ```ts
- * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;
- *
- * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;
- *
- * assert.isTrue(Arr.isNonEmpty(users));
- *
- * assert.isFalse(Arr.isNonEmpty(emptyUsers));
- *
- * if (Arr.isNonEmpty(users)) {
- *   assert.deepStrictEqual(users[0], { id: 1 });
- * }
- * ```
- */
-export const isNonEmpty = <E,>(
-  array: readonly E[],
-): array is NonEmptyArray<E> => array.length > 0;
-
-/**
- * Checks if an array has 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.isFixedLengthTuple(pair, 2));
- *
- * assert.isFalse(Arr.isFixedLengthTuple(triple, 2));
- *
- * if (Arr.isFixedLengthTuple(pair, 2)) {
- *   assert.deepStrictEqual(pair, [1, 2]);
- * }
- * ```
- */
-export const isFixedLengthTuple = <E, N extends SizeType.ArgArr>(
-  array: readonly E[],
-  len: N,
-): array is FixedLengthTuple<N, E> => array.length === len;
-
-/**
- * Checks if an array has at least a specific length.
- *
- * @example
- *
- * ```ts
- * const queue: readonly string[] = ['task-1', 'task-2'] as const;
- *
- * const emptyQueue: readonly string[] = [] as const;
- *
- * assert.isTrue(Arr.isMinLengthTuple(queue, 1));
- *
- * assert.isFalse(Arr.isMinLengthTuple(emptyQueue, 1));
- *
- * if (Arr.isMinLengthTuple(queue, 1)) {
- *   assert.isTrue(queue[0] === 'task-1');
- * }
- * ```
- */
-export const isMinLengthTuple = <E, N extends SizeType.ArgArr>(
-  array: readonly E[],
-  len: N,
-): array is MinLengthTuple<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.isMaxLengthTuple(pair, 2));
- *
- * assert.isFalse(Arr.isMaxLengthTuple(triple, 2));
- *
- * if (Arr.isMaxLengthTuple(pair, 2)) {
- *   assert.isTrue(pair.length <= 2);
- * }
- * ```
- */
-export const isMaxLengthTuple = <E, N extends SizeType.ArgArr>(
-  array: readonly E[],
-  len: N,
-): array is MaxLengthTuple<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.isBoundedLengthTuple(pair, 1, 3));
- *
- * assert.isFalse(Arr.isBoundedLengthTuple(quad, 1, 3));
- *
- * if (Arr.isBoundedLengthTuple(pair, 1, 3)) {
- *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
- * }
- * ```
- */
-export const isBoundedLengthTuple = <
-  E,
-  Min extends SizeType.ArgArr,
-  Max extends SizeType.ArgArr,
->(
-  array: readonly E[],
-  min: Min,
-  max: Max,
-): array is BoundedLengthTuple<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,20 +1,8 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
-} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
   every,
   indexIsInRange,
   isArray,
-  isBoundedLengthTuple,
-  isEmpty,
-  isFixedLengthTuple,
-  isMaxLengthTuple,
-  isMinLengthTuple,
-  isNonEmpty,
   some,
 } from './array-utils-validation.mjs';
 
@@ -384,365 +372,6 @@ describe('Arr validations', () => {
     });
   });
 
-  describe(isEmpty, () => {
-    const xs = [1, 2, 3] as const;
-
-    const result = isEmpty(xs);
-
-    expectType<typeof result, boolean>('=');
-
-    test('case 1', () => {
-      assert.isFalse(result);
-    });
-
-    test('case 2', () => {
-      assert.isTrue(isEmpty([]));
-    });
-  });
-
-  describe(isNonEmpty, () => {
-    const xs = [1, 2, 3] as const;
-
-    const result = isNonEmpty(xs);
-
-    expectType<typeof result, boolean>('=');
-
-    test('case 1', () => {
-      assert.isTrue(result);
-    });
-
-    test('case 2', () => {
-      assert.isFalse(isNonEmpty([]));
-    });
-  });
-
-  describe(isFixedLengthTuple, () => {
-    test('should return true if array has specified length', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isTrue(isFixedLengthTuple(arr, 3));
-
-      if (isFixedLengthTuple(arr, 3)) {
-        expectType<typeof arr, readonly [1, 2, 3]>('=');
-      }
-    });
-
-    test('should return false if array does not have specified length', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isFalse(isFixedLengthTuple(arr, 2));
-    });
-
-    test('should return true for empty array and length 0', () => {
-      const arr = [] as const;
-
-      assert.isTrue(isFixedLengthTuple(arr, 0));
-
-      if (isFixedLengthTuple(arr, 0)) {
-        expectType<typeof arr, readonly []>('=');
-      }
-    });
-
-    test('should return false for non-empty array and length 0', () => {
-      const arr = [1] as const;
-
-      assert.isFalse(isFixedLengthTuple(arr, 0));
-    });
-
-    test('should work with unknown array type', () => {
-      const mut_arr: number[] = [1, 2];
-
-      assert.isTrue(isFixedLengthTuple(mut_arr, 2));
-
-      if (isFixedLengthTuple(mut_arr, 2)) {
-        // transformer-ignore-next-line
-        expectType<typeof mut_arr, number[] & FixedLengthTuple<2, number>>('=');
-      }
-
-      assert.isFalse(isFixedLengthTuple(mut_arr, 3));
-    });
-
-    test('should work with unknown readonly array type', () => {
-      const arr: readonly number[] = [1, 2] as const;
-
-      assert.isTrue(isFixedLengthTuple(arr, 2));
-
-      if (isFixedLengthTuple(arr, 2)) {
-        expectType<typeof arr, FixedLengthTuple<2, number>>('=');
-      }
-
-      assert.isFalse(isFixedLengthTuple(arr, 3));
-    });
-
-    test('should return true for arrays of exact length (additional)', () => {
-      assert.isTrue(isFixedLengthTuple([1, 2, 3], 3));
-
-      assert.isTrue(isFixedLengthTuple([], 0));
-
-      assert.isTrue(isFixedLengthTuple(['a'], 1));
-    });
-
-    test('should return false for arrays of different length (additional)', () => {
-      assert.isFalse(isFixedLengthTuple([1, 2, 3], 2));
-
-      assert.isFalse(isFixedLengthTuple([1, 2, 3], 4));
-
-      assert.isFalse(isFixedLengthTuple([], 1));
-    });
-
-    test('should work as type guard with exact length (additional)', () => {
-      const array: readonly number[] = [1, 2, 3] as const;
-
-      if (isFixedLengthTuple(array, 3)) {
-        expectType<typeof array, FixedLengthTuple<3, number>>('=');
-
-        expect(array).toHaveLength(3);
-      }
-    });
-  });
-
-  describe(isMinLengthTuple, () => {
-    test('should return true if array length is greater than or equal to specified length', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isTrue(isMinLengthTuple(arr, 3));
-
-      if (isMinLengthTuple(arr, 3)) {
-        expectType<typeof arr, readonly [1, 2, 3]>('=');
-      }
-
-      assert.isTrue(isMinLengthTuple(arr, 2));
-
-      if (isMinLengthTuple(arr, 2)) {
-        expectType<typeof arr, readonly [1, 2, 3]>('=');
-      }
-    });
-
-    test('should return false if array length is less than specified length', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isFalse(isMinLengthTuple(arr, 4));
-    });
-
-    test('should return true for empty array and length 0', () => {
-      const arr = [] as const;
-
-      assert.isTrue(isMinLengthTuple(arr, 0));
-
-      if (isMinLengthTuple(arr, 0)) {
-        expectType<typeof arr, readonly []>('=');
-      }
-    });
-
-    test('should return false for empty array and positive length', () => {
-      const arr = [] as const;
-
-      assert.isFalse(isMinLengthTuple(arr, 1));
-    });
-
-    test('should work with unknown array type', () => {
-      const mut_arr: number[] = [1, 2];
-
-      assert.isTrue(isMinLengthTuple(mut_arr, 2));
-
-      // transformer-ignore-next-line
-      expectType<typeof mut_arr, number[] & MinLengthTuple<2, number>>('=');
-
-      assert.isFalse(isMinLengthTuple(mut_arr, 3));
-    });
-
-    test('should work with unknown array type 2', () => {
-      const mut_arr: number[] = [1, 2];
-
-      assert.isTrue(isMinLengthTuple(mut_arr, 1));
-
-      // transformer-ignore-next-line
-      expectType<typeof mut_arr, number[] & MinLengthTuple<1, number>>('=');
-
-      assert.isFalse(isMinLengthTuple(mut_arr, 3));
-    });
-
-    test('should return true for arrays of at least specified length (additional)', () => {
-      assert.isTrue(isMinLengthTuple([1, 2, 3], 3));
-
-      assert.isTrue(isMinLengthTuple([1, 2, 3], 2));
-
-      assert.isTrue(isMinLengthTuple([1, 2, 3], 1));
-
-      assert.isTrue(isMinLengthTuple([1, 2, 3], 0));
-    });
-
-    test('should return false for arrays shorter than specified length (additional)', () => {
-      assert.isFalse(isMinLengthTuple([1, 2, 3], 4));
-
-      assert.isFalse(isMinLengthTuple([], 1));
-    });
-
-    test('should work as type guard for at least length (additional)', () => {
-      const array: readonly number[] = [1, 2, 3] as const;
-
-      if (isMinLengthTuple(array, 2)) {
-        expectType<typeof array, MinLengthTuple<2, number>>('=');
-
-        expect(array.length).toBeGreaterThanOrEqual(2);
-      }
-    });
-  });
-
-  describe(isMaxLengthTuple, () => {
-    test('should return true if array length is less than or equal to specified length', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isTrue(isMaxLengthTuple(arr, 3));
-
-      if (isMaxLengthTuple(arr, 3)) {
-        expectType<typeof arr, readonly [1, 2, 3]>('=');
-      }
-
-      assert.isTrue(isMaxLengthTuple(arr, 4));
-
-      if (isMaxLengthTuple(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(isMaxLengthTuple(arr, 2));
-    });
-
-    test('should return true for empty array and length 0', () => {
-      const arr = [] as const;
-
-      assert.isTrue(isMaxLengthTuple(arr, 0));
-
-      if (isMaxLengthTuple(arr, 0)) {
-        expectType<typeof arr, readonly []>('=');
-      }
-    });
-
-    test('should return false for non-empty array and length 0', () => {
-      const arr = [1] as const;
-
-      assert.isFalse(isMaxLengthTuple(arr, 0));
-    });
-
-    test('should work with unknown array type', () => {
-      const mut_arr: number[] = [1, 2];
-
-      assert.isTrue(isMaxLengthTuple(mut_arr, 2));
-
-      // transformer-ignore-next-line
-      expectType<typeof mut_arr, number[] & MaxLengthTuple<2, number>>('=');
-
-      assert.isFalse(isMaxLengthTuple(mut_arr, 1));
-    });
-
-    test('should return true for arrays of at most specified length (additional)', () => {
-      assert.isTrue(isMaxLengthTuple([1, 2, 3], 3));
-
-      assert.isTrue(isMaxLengthTuple([1, 2, 3], 4));
-
-      assert.isTrue(isMaxLengthTuple([], 0));
-    });
-
-    test('should return false for arrays longer than specified length (additional)', () => {
-      assert.isFalse(isMaxLengthTuple([1, 2, 3], 2));
-
-      assert.isFalse(isMaxLengthTuple([1, 2, 3], 0));
-    });
-
-    test('should work as type guard for at most length (additional)', () => {
-      const array: readonly number[] = [1, 2] as const;
-
-      if (isMaxLengthTuple(array, 3)) {
-        expectType<typeof array, MaxLengthTuple<3, number>>('=');
-
-        expect(array.length).toBeLessThanOrEqual(3);
-      }
-    });
-  });
-
-  describe(isBoundedLengthTuple, () => {
-    test('should return true if array length is within the specified range', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isTrue(isBoundedLengthTuple(arr, 1, 3));
-
-      if (isBoundedLengthTuple(arr, 1, 3)) {
-        expectType<typeof arr, readonly [1, 2, 3]>('=');
-      }
-
-      assert.isTrue(isBoundedLengthTuple(arr, 3, 5));
-
-      if (isBoundedLengthTuple(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(isBoundedLengthTuple(arr, 4, 5));
-    });
-
-    test('should return false if array length is above the specified range', () => {
-      const arr = [1, 2, 3] as const;
-
-      assert.isFalse(isBoundedLengthTuple(arr, 0, 2));
-    });
-
-    test('should return true for empty array and range including 0', () => {
-      const arr = [] as const;
-
-      assert.isTrue(isBoundedLengthTuple(arr, 0, 2));
-
-      if (isBoundedLengthTuple(arr, 0, 2)) {
-        expectType<typeof arr, readonly []>('=');
-      }
-    });
-
-    test('should work with unknown array type', () => {
-      const mut_arr: number[] = [1, 2];
-
-      assert.isTrue(isBoundedLengthTuple(mut_arr, 1, 3));
-
-      // transformer-ignore-next-line
-      expectType<typeof mut_arr, number[] & BoundedLengthTuple<1, 3, number>>(
-        '=',
-      );
-
-      assert.isFalse(isBoundedLengthTuple(mut_arr, 3, 5));
-    });
-
-    test('should return true for arrays within specified range (additional)', () => {
-      assert.isTrue(isBoundedLengthTuple([1, 2, 3], 1, 3));
-
-      assert.isTrue(isBoundedLengthTuple([1, 2, 3], 3, 3));
-
-      assert.isTrue(isBoundedLengthTuple([], 0, 0));
-    });
-
-    test('should return false for arrays outside specified range (additional)', () => {
-      assert.isFalse(isBoundedLengthTuple([1, 2, 3], 4, 5));
-
-      assert.isFalse(isBoundedLengthTuple([1, 2, 3], 0, 2));
-    });
-
-    test('should work as type guard for bounded length (additional)', () => {
-      const array: readonly number[] = [1, 2] as const;
-
-      if (isBoundedLengthTuple(array, 1, 3)) {
-        expectType<typeof array, BoundedLengthTuple<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;

package/src/array/impl/index.mts

@@ -3,6 +3,8 @@ export * from './array-utils-element-access.mjs';
 export * from './array-utils-iterators.mjs';
 export * from './array-utils-length-bounded-array-cast.mjs';
 export * from './array-utils-length-bounded-array-guard.mjs';
+export * from './array-utils-length-bounded-tuple-cast.mjs';
+export * from './array-utils-length-bounded-tuple-guard.mjs';
 export * from './array-utils-modification.mjs';
 export * from './array-utils-reducing-value.mjs';
 export * from './array-utils-search.mjs';

package/src/collections/queue.test.mts

@@ -586,7 +586,7 @@ describe('Queue test', () => {
       for (const _i of range(asUint32(1000))) {
         // Randomly decide to enqueue or dequeue
         const shouldEnqueue =
-          Arr.isFixedLengthTuple(mut_expected, 0) || Math.random() < 0.6;
+          Arr.isEmptyTuple(mut_expected) || Math.random() < 0.6;
 
         if (shouldEnqueue) {
           mut_counter += 1;