ts-data-forge 1.0.0

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

@@ -0,0 +1,149 @@
+import { expectType } from '../expect-type.mjs';
+import { pipe } from '../functional/index.mjs';
+import { Arr } from './array-utils.mjs';
+
+// Tests for ensuring type errors occur with incorrect usage of overloaded functions
+
+describe('Array overloaded functions - type error validation', () => {
+  const testArray = [1, 2, 3, 4, 5] as const;
+  const predicate = (x: number): boolean => x > 3;
+
+  describe('Arr.findIndex type safety', () => {
+    test('findIndex with correct arguments should work', () => {
+      // These should work fine
+      const _result1 = Arr.findIndex(testArray, predicate);
+      const _result2 = Arr.findIndex(predicate);
+      const _result3 = Arr.findIndex(predicate)(testArray);
+
+      expectType<typeof _result1, SizeType.Arr | -1>('=');
+      expectType<
+        typeof _result2,
+        (array: readonly number[]) => SizeType.Arr | -1
+      >('=');
+      expectType<typeof _result3, SizeType.Arr | -1>('=');
+    });
+
+    test('findIndex type constraints work correctly', () => {
+      // Test that type constraints exist for predicate function
+      // @ts-expect-error - Predicate should return boolean, not string
+      Arr.findIndex(testArray, (x: number) => x.toString());
+
+      // @ts-expect-error - Array element type should match predicate parameter
+      Arr.findIndex(['a', 'b', 'c'], (x: number) => x > 0);
+
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Arr.filterNot type safety', () => {
+    test('filterNot with correct arguments should work', () => {
+      // These should work fine
+      const _result1 = Arr.filterNot(testArray, predicate);
+      const _result2 = Arr.filterNot(predicate);
+      const _result3 = Arr.filterNot(predicate)(testArray);
+
+      expectType<typeof _result1, readonly number[]>('<=');
+      expectType<
+        typeof _result2,
+        (array: readonly number[]) => readonly number[]
+      >('<=');
+      expectType<typeof _result3, readonly number[]>('<=');
+    });
+
+    test('filterNot type constraints work correctly', () => {
+      // @ts-expect-error - Predicate should return boolean, not string
+      Arr.filterNot(testArray, (x: number) => x.toString());
+
+      // @ts-expect-error - Array element type should match predicate parameter
+      Arr.filterNot(['a', 'b', 'c'], (x: number) => x > 0);
+
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Arr.partition type safety', () => {
+    test('partition with correct arguments should work', () => {
+      // These should work fine
+      const _result1 = Arr.partition(testArray, 2);
+      const _result2 = Arr.partition(2);
+      const _result3 = Arr.partition(2)(testArray);
+
+      expectType<typeof _result1, readonly (readonly number[])[]>('<=');
+      expectType<
+        typeof _result2,
+        <A>(array: readonly A[]) => readonly (readonly A[])[]
+      >('<=');
+      expectType<typeof _result3, readonly (readonly number[])[]>('<=');
+    });
+
+    test('partition type constraints work correctly', () => {
+      // @ts-expect-error - Partition size should be number, not string
+      expect(() => Arr.partition(testArray, 'invalid')).toThrowError();
+
+      // @ts-expect-error - Negative partition size should not be allowed
+      Arr.partition(testArray, -1);
+    });
+  });
+
+  describe('Arr.range type safety', () => {
+    test('range with correct arguments should work', () => {
+      // These should work fine
+      const _result1 = Arr.range(1, 5);
+      const _result2 = Arr.range(1, 5, 1);
+
+      expectType<typeof _result1, readonly [1, 2, 3, 4]>('=');
+      expectType<typeof _result2, readonly [1, 2, 3, 4]>('=');
+    });
+
+    test('range type constraints work correctly', () => {
+      // @ts-expect-error - Range bounds should be numbers, not strings
+      expect(() => Arr.range('1', '5')).toThrowError();
+
+      // @ts-expect-error - Step should be number, not string
+      Arr.range(1, 5, 'invalid');
+    });
+  });
+
+  describe('Type-safe spread operations', () => {
+    test('spread with correct tuple types should work', () => {
+      // Correct usage with spread
+      const correctArgs1 = [testArray, predicate] as const;
+      const correctArgs2 = [predicate] as const;
+
+      const _result1 = Arr.findIndex(...correctArgs1);
+      const _result2 = Arr.findIndex(...correctArgs2);
+
+      expectType<typeof _result1, SizeType.Arr | -1>('<=');
+      expectType<
+        typeof _result2,
+        (array: readonly number[]) => SizeType.Arr | -1
+      >('<=');
+    });
+
+    test('spread with incorrect types should cause errors', () => {
+      const invalidArgs: [string[], (x: string) => number] = [
+        ['a'],
+        (x) => x.length,
+      ];
+
+      // @ts-expect-error - Wrong types in tuple for spread
+      Arr.findIndex(...invalidArgs);
+
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Function composition with overloaded functions', () => {
+    test('composition should preserve type safety', () => {
+      // This should work
+      const findPositive = Arr.findIndex((x: number) => x > 0);
+      const filterNegative = Arr.filterNot((x: number) => x < 0);
+
+      const _composedResult = pipe(testArray)
+        .map(filterNegative)
+        .map(findPositive).value;
+
+      expectType<typeof _composedResult, SizeType.Arr | -1>('=');
+    });
+  });
+});

package/src/array/array-utils-reducing-value.test.mts

@@ -0,0 +1,425 @@
+import { IMap } from '../collections/index.mjs';
+import { expectType } from '../expect-type.mjs';
+import { Optional, Result } from '../functional/index.mjs';
+import { Arr } from './array-utils.mjs';
+
+describe('Arr reducing value', () => {
+  describe('min', () => {
+    {
+      const xs = [3, 5, 4] as const;
+      const result = Arr.min(xs);
+
+      expectType<typeof result, Optional.Some<3 | 4 | 5>>('=');
+
+      test('case 1', () => {
+        expect(Optional.isSome(result)).toBe(true);
+        if (Optional.isSome(result)) {
+          expect(result.value).toBe(3);
+        }
+      });
+    }
+    {
+      const xs = [3, 5, 4] as const;
+      const result = Arr.min(xs, (a, b) => a - b);
+
+      expectType<typeof result, Optional.Some<3 | 4 | 5>>('=');
+
+      test('case 2', () => {
+        expect(Optional.isSome(result)).toBe(true);
+        if (Optional.isSome(result)) {
+          expect(result.value).toBe(3);
+        }
+      });
+    }
+    {
+      const xs: readonly (3 | 4 | 5)[] = [3, 5, 4] as const;
+      const result = Arr.min(xs, (a, b) => a - b);
+
+      expectType<typeof result, Optional<3 | 4 | 5>>('=');
+
+      test('case 3', () => {
+        expect(Optional.isSome(result)).toBe(true);
+        if (Optional.isSome(result)) {
+          expect(result.value).toBe(3);
+        }
+      });
+    }
+  });
+
+  describe('max', () => {
+    const xs = [3, 5, 4] as const;
+    const result = Arr.max(xs, (a, b) => a - b);
+
+    expectType<typeof result, Optional.Some<3 | 4 | 5>>('=');
+
+    test('case 1', () => {
+      expect(Optional.isSome(result)).toBe(true);
+      if (Optional.isSome(result)) {
+        expect(result.value).toBe(5);
+      }
+    });
+
+    test('case 2: no comparator', () => {
+      const res = Arr.max(xs);
+      expectType<typeof res, Optional.Some<3 | 4 | 5>>('=');
+      expect(Optional.isSome(res)).toBe(true);
+      if (Optional.isSome(res)) {
+        expect(res.value).toBe(5);
+      }
+    });
+
+    test('case 3: readonly array', () => {
+      const arr: readonly number[] = [1, 5, 2];
+      const res = Arr.max(arr);
+      expectType<typeof res, Optional<number>>('=');
+      expect(Optional.isSome(res)).toBe(true);
+      if (Optional.isSome(res)) {
+        expect(res.value).toBe(5);
+      }
+    });
+
+    test('case 4: empty array', () => {
+      const arr: readonly number[] = [];
+      const res = Arr.max(arr);
+      expectType<typeof res, Optional<number>>('=');
+      expect(Optional.isNone(res)).toBe(true);
+    });
+  });
+
+  describe('minBy', () => {
+    const xs: NonEmptyArray<
+      | Readonly<{ x: 1; y: 2 }>
+      | Readonly<{ x: 2; y: 3 }>
+      | Readonly<{ x: 3; y: 2 }>
+      | Readonly<{ x: 4; y: 1 }>
+      | Readonly<{ x: 5; y: 1 }>
+      | Readonly<{ x: 6; y: 1 }>
+    > = [
+      { x: 5, y: 1 },
+      { x: 4, y: 1 },
+      { x: 6, y: 1 },
+      { x: 3, y: 2 },
+      { x: 1, y: 2 },
+      { x: 2, y: 3 },
+    ] as const;
+
+    const result = Arr.minBy(xs, (a) => a.x);
+
+    expectType<
+      typeof result,
+      Optional.Some<
+        | Readonly<{ x: 1; y: 2 }>
+        | Readonly<{ x: 2; y: 3 }>
+        | Readonly<{ x: 3; y: 2 }>
+        | Readonly<{ x: 4; y: 1 }>
+        | Readonly<{ x: 5; y: 1 }>
+        | Readonly<{ x: 6; y: 1 }>
+      >
+    >('=');
+
+    test('case 1', () => {
+      expect(Optional.isSome(result)).toBe(true);
+      if (Optional.isSome(result)) {
+        expect(result.value).toStrictEqual({ x: 1, y: 2 });
+      }
+    });
+
+    test('case 2: empty array', () => {
+      const arr: readonly { x: number }[] = [];
+      const res = Arr.minBy(arr, (a) => a.x);
+      expectType<typeof res, Optional<{ x: number }>>('=');
+      expect(Optional.isNone(res)).toBe(true);
+    });
+
+    test('case 3: custom comparator', () => {
+      const arr = [
+        { name: 'apple', score: 10 },
+        { name: 'banana', score: 5 },
+        { name: 'cherry', score: 12 },
+      ] as const;
+
+      const res = Arr.minBy(
+        arr,
+        (item) => item.name,
+        (a, b) => a.localeCompare(b),
+      );
+
+      expectType<
+        typeof res,
+        Optional<
+          | Readonly<{ name: 'apple'; score: 10 }>
+          | Readonly<{ name: 'banana'; score: 5 }>
+          | Readonly<{ name: 'cherry'; score: 12 }>
+        >
+      >('=');
+
+      expect(Optional.isSome(res)).toBe(true);
+      if (Optional.isSome(res)) {
+        expect(res.value).toStrictEqual({ name: 'apple', score: 10 });
+      }
+    });
+  });
+
+  describe('maxBy', () => {
+    const xs: NonEmptyArray<
+      | Readonly<{ x: 1; y: 2 }>
+      | Readonly<{ x: 2; y: 3 }>
+      | Readonly<{ x: 3; y: 2 }>
+      | Readonly<{ x: 4; y: 1 }>
+      | Readonly<{ x: 5; y: 1 }>
+      | Readonly<{ x: 6; y: 1 }>
+    > = [
+      { x: 5, y: 1 },
+      { x: 4, y: 1 },
+      { x: 6, y: 1 },
+      { x: 3, y: 2 },
+      { x: 1, y: 2 },
+      { x: 2, y: 3 },
+    ] as const;
+
+    const result = Arr.maxBy(xs, (a) => a.x);
+
+    expectType<
+      typeof result,
+      Optional.Some<
+        | Readonly<{ x: 1; y: 2 }>
+        | Readonly<{ x: 2; y: 3 }>
+        | Readonly<{ x: 3; y: 2 }>
+        | Readonly<{ x: 4; y: 1 }>
+        | Readonly<{ x: 5; y: 1 }>
+        | Readonly<{ x: 6; y: 1 }>
+      >
+    >('=');
+
+    test('case 1', () => {
+      expect(Optional.isSome(result)).toBe(true);
+      if (Optional.isSome(result)) {
+        expect(result.value).toStrictEqual({ x: 6, y: 1 });
+      }
+    });
+
+    test('case 2: empty array', () => {
+      const arr: readonly { x: number }[] = [];
+      const res = Arr.maxBy(arr, (a) => a.x);
+      expectType<typeof res, Optional<{ x: number }>>('=');
+      expect(Optional.isNone(res)).toBe(true);
+    });
+
+    test('case 3: custom comparator', () => {
+      const arr = [
+        { name: 'apple', score: 10 },
+        { name: 'banana', score: 5 },
+        { name: 'cherry', score: 12 },
+      ] as const;
+
+      const res = Arr.maxBy(
+        arr,
+        (item) => item.name,
+        (a, b) => a.localeCompare(b),
+      );
+
+      expectType<
+        typeof res,
+        Optional<
+          | Readonly<{ name: 'apple'; score: 10 }>
+          | Readonly<{ name: 'banana'; score: 5 }>
+          | Readonly<{ name: 'cherry'; score: 12 }>
+        >
+      >('=');
+
+      expect(Optional.isSome(res)).toBe(true);
+      if (Optional.isSome(res)) {
+        expect(res.value).toStrictEqual({ name: 'cherry', score: 12 });
+      }
+    });
+  });
+
+  describe('count', () => {
+    const xs = [
+      { x: 1, y: 1 },
+      { x: 2, y: 1 },
+      { x: 3, y: 1 },
+      { x: 1, y: 2 },
+      { x: 2, y: 2 },
+      { x: 1, y: 3 },
+    ] as const;
+
+    const result = Arr.count(xs, (a) => a.x === 2);
+
+    expectType<typeof result, Uint32>('=');
+
+    test('case 1', () => {
+      expect(result).toBe(2);
+    });
+
+    test('case 2: empty array', () => {
+      const arr: readonly number[] = [];
+      const res = Arr.count(arr, (x) => x > 0);
+      expectType<typeof res, Uint32>('=');
+      expect(res).toBe(0);
+    });
+  });
+
+  describe('countBy', () => {
+    const xs = [
+      { x: 1, y: 1 },
+      { x: 2, y: 1 },
+      { x: 3, y: 1 },
+      { x: 1, y: 2 },
+      { x: 2, y: 2 },
+      { x: 1, y: 3 },
+    ] as const;
+
+    const result = Arr.countBy(xs, (a) => a.x);
+
+    expectType<typeof result, IMap<1 | 2 | 3, Uint32>>('=');
+
+    test('case 1', () => {
+      expect(result).toStrictEqual(
+        IMap.create<1 | 2 | 3, number>([
+          [1, 3],
+          [2, 2],
+          [3, 1],
+        ]),
+      );
+    });
+
+    test('case 2: empty array', () => {
+      const arr: readonly { x: number }[] = [];
+      const res = Arr.countBy(arr, (a) => a.x);
+      expectType<typeof res, IMap<number, Uint32>>('=');
+      expect(res.size).toBe(0);
+    });
+  });
+
+  describe('foldl', () => {
+    test('empty array', () => {
+      const result = Arr.foldl([], (acc, curr: number) => acc + curr, 0);
+      expectType<typeof result, number>('=');
+      expect(result).toBe(0);
+    });
+
+    test('sum numbers', () => {
+      const result = Arr.foldl(
+        [1, 2, 3] as const,
+        (acc, curr) => acc + curr,
+        0,
+      );
+      expectType<typeof result, number>('=');
+      expect(result).toBe(6);
+    });
+
+    test('concatenate strings', () => {
+      const result = Arr.foldl(
+        ['a', 'b', 'c'] as const,
+        (acc, curr) => acc + curr,
+        '',
+      );
+      expectType<typeof result, string>('=');
+      expect(result).toBe('abc');
+    });
+
+    test('alias reduce', () => {
+      expect(Arr.reduce).toBe(Arr.foldl);
+    });
+  });
+
+  describe('foldr', () => {
+    test('empty array', () => {
+      const result = Arr.foldr([], (acc, curr: number) => acc + curr, 0);
+      expectType<typeof result, number>('=');
+      expect(result).toBe(0);
+    });
+
+    test('subtract numbers from right', () => {
+      // (1 - (2 - (3 - 0))) = 1 - (2 - 3) = 1 - (-1) = 2
+      const result = Arr.foldr(
+        [1, 2, 3] as const,
+        (acc, curr) => curr - acc,
+        0,
+      );
+      expectType<typeof result, number>('=');
+      expect(result).toBe(2); // 3 - (2 - (1 - 0)) = 3 - (2 - 1) = 3 - 1 = 2.  No, this is (acc, curr) => acc - curr.
+      // The callback is (previousValue: S, currentValue: A) => S
+      // So it's initialValue for S.
+      // Iteration 1: prev = 0, curr = 3. Result = 3 - 0 = 3.
+      // Iteration 2: prev = 3, curr = 2. Result = 2 - 3 = -1.
+      // Iteration 3: prev = -1, curr = 1. Result = 1 - (-1) = 2.
+    });
+
+    test('concatenate strings from right', () => {
+      const result = Arr.foldr(
+        ['a', 'b', 'c'] as const,
+        (acc, curr) => curr + acc,
+        '',
+      );
+      expectType<typeof result, string>('=');
+      expect(result).toBe('abc'); // c + (b + (a + "")) = cba. No, it's curr + acc.
+      // Iteration 1: prev = "", curr = "c". Result = "c" + "" = "c".
+      // Iteration 2: prev = "c", curr = "b". Result = "b" + "c" = "bc".
+      // Iteration 3: prev = "bc", curr = "a". Result = "a" + "bc" = "abc".
+    });
+
+    test('alias reduceRight', () => {
+      expect(Arr.reduceRight).toBe(Arr.foldr);
+    });
+  });
+
+  describe('sum', () => {
+    test('empty array', () => {
+      const result = Arr.sum([]);
+      expectType<typeof result, 0>('=');
+      expect(result).toBe(0);
+    });
+
+    test('one element array', () => {
+      const result = Arr.sum([23]);
+      expectType<typeof result, 23>('=');
+      expect(result).toBe(23);
+    });
+
+    test('positive numbers', () => {
+      const result = Arr.sum([1, 2, 3, 4, 5] as const);
+      expectType<typeof result, number>('=');
+      expect(result).toBe(15);
+    });
+
+    test('mixed numbers', () => {
+      const result = Arr.sum([1, -2, 3, 0, -5] as const);
+      expectType<typeof result, number>('=');
+      expect(result).toBe(-3);
+    });
+  });
+
+  describe('join', () => {
+    test('should join array elements', () => {
+      const arr = ['Hello', 'World'];
+      const result = Arr.join(arr, ' ');
+
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe('Hello World');
+      }
+    });
+
+    test('should handle empty separator', () => {
+      const arr = ['a', 'b', 'c'];
+      const result = Arr.join(arr, '');
+
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe('abc');
+      }
+    });
+
+    test('should handle undefined separator', () => {
+      const arr = ['a', 'b', 'c'];
+      const result = Arr.join(arr);
+
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe('a,b,c');
+      }
+    });
+  });
+});