ts-data-forge 13.0.0 → 14.0.1

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/imap.mts

@@ -549,7 +549,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const entries = [
    *   ['k1', 'v1'],
    *   ['k2', 'v2'],
-   * ] as const satisfies readonly (readonly [string, string])[];
+   * ] as const satisfies readonly FixedLengthTuple<2, string>[];
    *
    * const map = IMap.create(entries);
    *

package/src/collections/iset-mapped.mts

@@ -1,5 +1,9 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';
+import {
+  type FixedLengthTuple,
+  type ReadonlyRecord,
+  type WidenLiteral,
+} from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
 
@@ -788,7 +792,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *
    * @returns An iterable iterator of entries.
    */
-  entries: () => IterableIterator<readonly [K, K]>;
+  entries: () => IterableIterator<FixedLengthTuple<2, K>>;
 
   // Conversion
 
@@ -1444,7 +1448,7 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
   }
 
   /** @inheritdoc */
-  *entries(): IterableIterator<readonly [K, K]> {
+  *entries(): IterableIterator<FixedLengthTuple<2, K>> {
     for (const km of this.#set) {
       // JavaScript Set's entries() yields [value, value]
       const a = this.#fromKey(km);

package/src/collections/iset.mts

@@ -1,5 +1,9 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';
+import {
+  type FixedLengthTuple,
+  type ReadonlyRecord,
+  type WidenLiteral,
+} from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
 import { unknownToString } from '../others/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
@@ -460,7 +464,7 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * @returns An iterable iterator of entries.
    */
-  entries: () => IterableIterator<readonly [K, K]>;
+  entries: () => IterableIterator<FixedLengthTuple<2, K>>;
 
   // Conversion
 
@@ -913,7 +917,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
   }
 
   /** @inheritdoc */
-  entries(): IterableIterator<readonly [K, K]> {
+  entries(): IterableIterator<FixedLengthTuple<2, K>> {
     return this.#set.entries();
   }
 

package/src/collections/iset.test.mts

@@ -1,4 +1,9 @@
-import { type DeepReadonly, type Primitive } from 'ts-type-forge';
+import {
+  type DeepReadonly,
+  type FixedLengthTuple,
+  type MutableFixedLengthTuple,
+  type Primitive,
+} from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { isString } from '../guard/index.mjs';
 import { type MapSetKeyType } from '../types.mjs';
@@ -974,13 +979,11 @@ describe('ISet.entries', () => {
 
     expectType<
       typeof s0.entries,
-      () => IterableIterator<readonly [1 | 2 | 3, 1 | 2 | 3]>
+      () => IterableIterator<FixedLengthTuple<2, 1 | 2 | 3>>
     >('<=');
 
-    const result: DeepReadonly<[1 | 2 | 3, 1 | 2 | 3][]> = Array.from(
-      s0.entries(),
-      (x) => [x[0], x[1]],
-    );
+    const result: DeepReadonly<MutableFixedLengthTuple<2, 1 | 2 | 3>[]> =
+      Array.from(s0.entries(), (x) => [x[0], x[1]]);
 
     assert.deepStrictEqual(
       result.toSorted((a, b) => a[0] - b[0]),

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;

package/src/number/num-arithmetic-types.mts

@@ -75,8 +75,10 @@ export type LevelOf<N> = [N] extends [SafeInt]
 
 // --- boolean fact algebra over a sign ----------------------------------------
 
-type And<A extends boolean, B extends boolean> = [A, B] extends [true, true]
-  ? true
+type And<A extends boolean, B extends boolean> = [A] extends [true]
+  ? [B] extends [true]
+    ? true
+    : false
   : false;
 
 type Or<A extends boolean, B extends boolean> = true extends A | B
@@ -170,8 +172,10 @@ type DivLevel<LA extends Level, LB extends Level> = 'number' extends LA | LB
 /** Floor division yields an integer; the safe range is preserved. */
 type DivIntLevel<LA extends Level, LB extends Level> = 'number' extends LA | LB
   ? 'number'
-  : [LA, LB] extends ['safeint', 'safeint']
-    ? 'safeint'
+  : [LA] extends ['safeint']
+    ? [LB] extends ['safeint']
+      ? 'safeint'
+      : 'int'
     : 'int';
 
 // --- reconstruction (sign, level) -> canonical brand -------------------------

package/src/number/num.test.mts

@@ -1,11 +1,11 @@
-import { type NonZeroNumber } from 'ts-type-forge';
+import { type FixedLengthTuple, type NonZeroNumber } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe, Result } from '../functional/index.mjs';
 import { asNonZeroFiniteNumber } from './branded-types/index.mjs';
 import { Num } from './num.mjs';
 
 const testClamp = (
-  [a, b]: readonly [number, number],
+  [a, b]: FixedLengthTuple<2, number>,
   target: number,
   expected: number,
 ): void => {