ts-data-forge 5.0.0 → 5.1.0

package/src/array/impl/array-utils-element-access.mts

@@ -9,11 +9,15 @@ import { Optional, pipe } from '../../functional/index.mjs';
  * const letters: readonly string[] = ['a', 'b', 'c'];
  *
  * const two = Arr.at(letters, 1);
+ *
  * const last = Arr.at(-1)(letters);
+ *
  * const missing = Arr.at(letters, 5);
  *
  * assert.deepStrictEqual(two, Optional.some('b'));
+ *
  * assert.deepStrictEqual(last, Optional.some('c'));
+ *
  * assert.deepStrictEqual(missing, Optional.none);
  * ```
  */
@@ -36,6 +40,7 @@ export function at<E>(
   switch (args.length) {
     case 2: {
       const [array, index] = args;
+
       return pipe(index < 0 ? array.length + index : index).map(
         (normalizedIndex) =>
           normalizedIndex < 0 || normalizedIndex >= array.length
@@ -44,8 +49,10 @@ export function at<E>(
               Optional.some(array[normalizedIndex]!),
       ).value;
     }
+
     case 1: {
       const [index] = args;
+
       return (array) => at(array, index);
     }
   }
@@ -58,12 +65,15 @@ export function at<E>(
  *
  * ```ts
  * const users = [{ id: 1 }, { id: 2 }];
+ *
  * const empty: { id: number }[] = [];
  *
  * const first = Arr.head(users);
+ *
  * const none = Arr.head(empty);
  *
  * assert.deepStrictEqual(first, Optional.some({ id: 1 }));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */
@@ -86,12 +96,15 @@ export const head = <const Ar extends readonly unknown[]>(
  *
  * ```ts
  * const queue = ['first', 'second'];
+ *
  * const emptyQueue: string[] = [];
  *
  * const lastValue = Arr.last(queue);
+ *
  * const none = Arr.last(emptyQueue);
  *
  * assert.deepStrictEqual(lastValue, Optional.some('second'));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */

package/src/array/impl/array-utils-element-access.test.mts

@@ -7,6 +7,7 @@ describe('Arr element access', () => {
   describe(at, () => {
     test('should handle very large positive indices', () => {
       const array = [1, 2, 3];
+
       const result = at(array, asUint32(1000));
 
       expect(Optional.isNone(result)).toBe(true);
@@ -14,6 +15,7 @@ describe('Arr element access', () => {
 
     test('should handle very large negative indices', () => {
       const array = [1, 2, 3];
+
       const result = at(array, asInt32(-1000));
 
       expect(Optional.isNone(result)).toBe(true);
@@ -21,6 +23,7 @@ describe('Arr element access', () => {
 
     test('should work with valid indices', () => {
       const array = [10, 20, 30];
+
       const result = at(array, 1);
 
       expect(Optional.isSome(result)).toBe(true);
@@ -29,11 +32,24 @@ describe('Arr element access', () => {
         expect(result.value).toBe(20);
       }
     });
+
+    test('should work with curried version', () => {
+      const atIndex2 = at(2);
+
+      const result = atIndex2([10, 20, 30, 40]);
+
+      expect(Optional.isSome(result)).toBe(true);
+
+      if (Optional.isSome(result)) {
+        expect(result.value).toBe(30);
+      }
+    });
   });
 
   describe(head, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
+
       const h = head(xs);
 
       expectType<typeof h, Some<1>>('=');
@@ -47,6 +63,7 @@ describe('Arr element access', () => {
 
     test('case 2', () => {
       const xs: MutableNonEmptyArray<number> = [1, 2, 3];
+
       const h = head(xs);
 
       expectType<typeof h, Some<number>>('=');
@@ -60,6 +77,7 @@ describe('Arr element access', () => {
 
     test('case 3', () => {
       const mut_xs: number[] = [1, 2, 3];
+
       const h = head(mut_xs);
 
       expectType<typeof h, Optional<number>>('=');
@@ -101,6 +119,7 @@ describe('Arr element access', () => {
   describe(last, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
+
       const l = last(xs);
 
       expectType<typeof l, Some<3>>('=');
@@ -114,6 +133,7 @@ describe('Arr element access', () => {
 
     test('case 2', () => {
       const xs: MutableNonEmptyArray<number> = [1, 2, 3];
+
       const l = last(xs);
 
       expectType<typeof l, Some<number>>('=');
@@ -127,6 +147,7 @@ describe('Arr element access', () => {
 
     test('case 3', () => {
       const mut_xs: number[] = [1, 2, 3];
+
       const l = last(mut_xs);
 
       expectType<typeof l, Optional<number>>('=');

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

@@ -5,6 +5,7 @@ import { entries, indices, values } from './array-utils-iterators.mjs';
 describe(entries, () => {
   test('should return array of index-value pairs', () => {
     const fruits = ['apple', 'banana', 'cherry'];
+
     const es = Array.from(entries(fruits));
 
     assert.deepStrictEqual(es, [
@@ -16,7 +17,9 @@ describe(entries, () => {
 
   test('should work with tuples', () => {
     const tuple = [10, 20, 30] as const;
+
     const es = Array.from(entries(tuple));
+
     expectType<typeof es, (readonly [Uint32, 10 | 20 | 30])[]>('=');
 
     assert.deepStrictEqual(es, [
@@ -28,6 +31,7 @@ describe(entries, () => {
 
   test('should work with empty array', () => {
     const empty: string[] = [];
+
     const es = Array.from(entries(empty));
 
     assert.deepStrictEqual(es, []);
@@ -35,7 +39,9 @@ describe(entries, () => {
 
   test('should preserve mixed types', () => {
     const mixed = [1, 'hello', true] as const;
+
     const es = Array.from(entries(mixed));
+
     expectType<typeof es, (readonly [Uint32, 1 | 'hello' | true])[]>('=');
 
     assert.deepStrictEqual(es, [
@@ -49,6 +55,7 @@ describe(entries, () => {
 describe(values, () => {
   test('should return copy of array values', () => {
     const numbers = [1, 2, 3];
+
     const vs = Array.from(values(numbers));
 
     assert.deepStrictEqual(vs, [1, 2, 3]);
@@ -58,7 +65,9 @@ describe(values, () => {
 
   test('should work with tuples', () => {
     const tuple = ['a', 'b', 'c'] as const;
+
     const vs = Array.from(values(tuple));
+
     expectType<typeof vs, ('a' | 'b' | 'c')[]>('=');
 
     assert.deepStrictEqual(vs, ['a', 'b', 'c']);
@@ -66,6 +75,7 @@ describe(values, () => {
 
   test('should work with empty array', () => {
     const empty: number[] = [];
+
     const vs = Array.from(values(empty));
 
     assert.deepStrictEqual(vs, []);
@@ -73,7 +83,9 @@ describe(values, () => {
 
   test('should preserve mixed types', () => {
     const mixed = [1, 'hello', null] as const;
+
     const vs = Array.from(values(mixed));
+
     expectType<typeof vs, (1 | 'hello' | null)[]>('=');
 
     assert.deepStrictEqual(vs, [1, 'hello', null]);
@@ -83,6 +95,7 @@ describe(values, () => {
 describe(indices, () => {
   test('should return array of indices', () => {
     const fruits = ['apple', 'banana', 'cherry'];
+
     const ks = Array.from(indices(fruits));
 
     assert.deepStrictEqual(ks, [asUint32(0), asUint32(1), asUint32(2)]);
@@ -90,7 +103,9 @@ describe(indices, () => {
 
   test('should work with tuples', () => {
     const tuple = ['a', 'b'] as const;
+
     const ks = Array.from(indices(tuple));
+
     expectType<typeof ks, Uint32[]>('=');
 
     assert.deepStrictEqual(ks, [asUint32(0), asUint32(1)]);
@@ -98,6 +113,7 @@ describe(indices, () => {
 
   test('should work with empty array', () => {
     const empty: string[] = [];
+
     const ks = Array.from(indices(empty));
 
     assert.deepStrictEqual(ks, []);
@@ -105,6 +121,7 @@ describe(indices, () => {
 
   test('should work with larger arrays', () => {
     const large = Array.from({ length: 5 }, () => 'x');
+
     const ks = Array.from(indices(large));
 
     assert.deepStrictEqual(ks, [

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

@@ -45,11 +45,14 @@ export function set<E, const V = E>(
   switch (args.length) {
     case 3: {
       const [array, index, newValue] = args;
+
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
       return (array as (E | V)[]).with(index, newValue);
     }
+
     case 2: {
       const [index, newValue] = args;
+
       return (array) => set(array, index, newValue);
     }
   }
@@ -64,12 +67,14 @@ export function set<E, const V = E>(
  * const temperatures: number[] = [20, 21, 22];
  *
  * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);
+ *
  * const incrementLast = Arr.toUpdated<number>(
  *   2,
  *   (value) => value + 1,
  * )(temperatures);
  *
  * assert.deepStrictEqual(increased, [20, 26, 22]);
+ *
  * assert.deepStrictEqual(incrementLast, [20, 21, 23]);
  * ```
  */
@@ -110,11 +115,14 @@ export function toUpdated<E, V = E>(
   switch (args.length) {
     case 3: {
       const [array, index, updater] = args;
+
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, total-functions/no-unsafe-type-assertion
       return (array as (E | V)[]).with(index, updater(array[index]!));
     }
+
     case 2: {
       const [index, updater] = args;
+
       return (array) => toUpdated(array, index, updater);
     }
   }
@@ -129,9 +137,11 @@ export function toUpdated<E, V = E>(
  * const numbers = [1, 2, 4] as const;
  *
  * const withThree = Arr.toInserted(numbers, 2, 3);
+ *
  * const appendFive = Arr.toInserted(3, 5)(numbers);
  *
  * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);
+ *
  * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);
  * ```
  */
@@ -168,6 +178,7 @@ export function toInserted<E, const V = E>(
   switch (args.length) {
     case 3: {
       const [array, index, newValue] = args;
+
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
       return (array as readonly (E | V)[]).toSpliced(
         index,
@@ -175,8 +186,10 @@ export function toInserted<E, const V = E>(
         newValue,
       ) as unknown as NonEmptyArray<E | V>;
     }
+
     case 2: {
       const [index, newValue] = args;
+
       return (array) => toInserted(array, index, newValue);
     }
   }
@@ -193,9 +206,11 @@ type CastToNumber<T> = T extends number ? T : never;
  * const letters = ['a', 'b', 'c', 'd'] as const;
  *
  * const withoutSecond = Arr.toRemoved(letters, 1);
+ *
  * const withoutFirstCurried = Arr.toRemoved(0)(letters);
  *
  * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);
+ *
  * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);
  * ```
  */
@@ -216,10 +231,13 @@ export function toRemoved<E>(
   switch (args.length) {
     case 2: {
       const [array, index] = args;
+
       return array.toSpliced(index, 1);
     }
+
     case 1: {
       const [index] = args;
+
       return (array) => toRemoved(array, index);
     }
   }
@@ -234,9 +252,11 @@ export function toRemoved<E>(
  * const base = [1, 2] as const;
  *
  * const appended = Arr.toPushed(base, 3);
+ *
  * const appendedCurried = Arr.toPushed(4)(base);
  *
  * assert.deepStrictEqual(appended, [1, 2, 3]);
+ *
  * assert.deepStrictEqual(appendedCurried, [1, 2, 4]);
  * ```
  */
@@ -255,14 +275,17 @@ export function toPushed<const Ar extends readonly unknown[], const V>(
   switch (args.length) {
     case 2: {
       const [array, newValue] = args;
+
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
       return array.toSpliced(array.length, 0, newValue) as unknown as readonly [
         ...Ar,
         V,
       ];
     }
+
     case 1: {
       const [newValue] = args;
+
       return (array) => toPushed(array, newValue);
     }
   }
@@ -277,9 +300,11 @@ export function toPushed<const Ar extends readonly unknown[], const V>(
  * const base = [2, 3] as const;
  *
  * const prefixed = Arr.toUnshifted(base, 1);
+ *
  * const prefixedCurried = Arr.toUnshifted(0)(base);
  *
  * assert.deepStrictEqual(prefixed, [1, 2, 3]);
+ *
  * assert.deepStrictEqual(prefixedCurried, [0, 2, 3]);
  * ```
  */
@@ -298,11 +323,14 @@ export function toUnshifted<Ar extends readonly unknown[], const V>(
   switch (args.length) {
     case 2: {
       const [array, newValue] = args;
+
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
       return array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];
     }
+
     case 1: {
       const [newValue] = args;
+
       return (array) => toUnshifted(array, newValue);
     }
   }
@@ -317,9 +345,11 @@ export function toUnshifted<Ar extends readonly unknown[], const V>(
  * const base = [1, 2, 3];
  *
  * const filled = Arr.toFilled(base, 0);
+ *
  * const filledCurried = Arr.toFilled('x')(base);
  *
  * assert.deepStrictEqual(filled, [0, 0, 0]);
+ *
  * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);
  * ```
  */
@@ -349,10 +379,13 @@ export function toFilled<E>(
   switch (args.length) {
     case 2: {
       const [array, value] = args;
+
       return create(asPositiveUint32(array.length), value);
     }
+
     case 1: {
       const [value] = args;
+
       return (array) => toFilled(array, value);
     }
   }
@@ -367,9 +400,11 @@ export function toFilled<E>(
  * const base = [0, 1, 2, 3, 4];
  *
  * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);
+ *
  * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);
  *
  * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);
+ *
  * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);
  * ```
  */
@@ -422,12 +457,17 @@ export function toRangeFilled<E, const V>(
   switch (args.length) {
     case 3: {
       const [array, value, [start, end]] = args;
+
       const mut_cp: (E | V)[] = castMutable(copy(array));
+
       mut_cp.fill(value, start, end);
+
       return mut_cp;
     }
+
     case 2: {
       const [value, fillRange] = args;
+
       return (array) => toRangeFilled(array, value, fillRange);
     }
   }

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

@@ -14,6 +14,7 @@ import {
 describe('Arr modifications', () => {
   describe(toUpdated, () => {
     const xs = [1, 2, 3] as const;
+
     const result = toUpdated(xs, 1, (x) => x + 2);
 
     expectType<typeof result, ArrayOfLength<3, number>>('=');
@@ -21,6 +22,14 @@ describe('Arr modifications', () => {
     test('case 1', () => {
       assert.deepStrictEqual(result, [1, 4, 3]);
     });
+
+    test('should work with curried version', () => {
+      const updater = toUpdated(1, (x: number) => x * 2);
+
+      const r = updater([10, 20, 30]);
+
+      assert.deepStrictEqual(r, [10, 40, 30]);
+    });
   });
 
   describe(toInserted, () => {
@@ -53,11 +62,20 @@ describe('Arr modifications', () => {
 
       assert.deepStrictEqual(result, ['a', 'b', 'c', 5]);
     });
+
+    test('should work with curried version', () => {
+      const inserter = toInserted(2, 99);
+
+      const result = inserter([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 99, 3]);
+    });
   });
 
   describe(toRemoved, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toRemoved(xs, 1);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
@@ -67,6 +85,7 @@ describe('Arr modifications', () => {
 
     test('case 2 (remove head)', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toRemoved(xs, 0);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
@@ -76,6 +95,7 @@ describe('Arr modifications', () => {
 
     test('case 3 (remove tail)', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toRemoved(xs, 2);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
@@ -85,17 +105,27 @@ describe('Arr modifications', () => {
 
     test('case 4 (number[])', () => {
       const xs: number[] = [1, 2, 3];
+
       const result = toRemoved(xs, 5);
 
       expectType<typeof result, readonly number[]>('=');
 
       assert.deepStrictEqual(result, [1, 2, 3]);
     });
+
+    test('should work with curried version', () => {
+      const removeFirst = toRemoved(0);
+
+      const result = removeFirst([10, 20, 30]);
+
+      assert.deepStrictEqual(result, [20, 30]);
+    });
   });
 
   describe(toPushed, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toPushed(xs, 4 as const);
 
       expectType<typeof result, readonly [1, 2, 3, 4]>('=');
@@ -105,12 +135,21 @@ describe('Arr modifications', () => {
 
     test('case 2', () => {
       const xs: number[] = [1, 2, 3];
+
       const result = toPushed(xs, 4 as const);
 
       expectType<typeof result, readonly [...number[], 4]>('=');
 
       assert.deepStrictEqual(result, [1, 2, 3, 4]);
     });
+
+    test('should work with curried version', () => {
+      const pushFive = toPushed(5);
+
+      const result = pushFive([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 3, 5]);
+    });
   });
 
   describe(toUnshifted, () => {
@@ -133,11 +172,20 @@ describe('Arr modifications', () => {
 
       assert.deepStrictEqual(result, [4, 1, 2, 3]);
     });
+
+    test('should work with curried version', () => {
+      const unshiftZero = toUnshifted(0);
+
+      const result = unshiftZero([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [0, 1, 2, 3]);
+    });
   });
 
   describe(toFilled, () => {
     test('should fill entire array with value', () => {
       const arr = [1, 2, 3, 4, 5];
+
       const result = toFilled(arr, 0);
 
       assert.deepStrictEqual(result, [0, 0, 0, 0, 0]);
@@ -145,7 +193,9 @@ describe('Arr modifications', () => {
 
     test('should work with curried version', () => {
       const fillWithZero = toFilled(0);
+
       const arr = [1, 2, 3];
+
       const result = fillWithZero(arr);
 
       assert.deepStrictEqual(result, [0, 0, 0]);
@@ -155,6 +205,7 @@ describe('Arr modifications', () => {
   describe(toRangeFilled, () => {
     test('should fill array with range', () => {
       const arr = [1, 2, 3, 4, 5];
+
       const result = toRangeFilled(arr, 0, [1, 4]);
 
       assert.deepStrictEqual(result, [1, 0, 0, 0, 5]);
@@ -162,6 +213,7 @@ describe('Arr modifications', () => {
 
     test('should fill with range starting from 0', () => {
       const arr = [1, 2, 3, 4, 5];
+
       const result = toRangeFilled(arr, 9, [0, 3]);
 
       assert.deepStrictEqual(result, [9, 9, 9, 4, 5]);
@@ -169,6 +221,7 @@ describe('Arr modifications', () => {
 
     test('should handle empty range', () => {
       const arr = [1, 2, 3];
+
       const result = toRangeFilled(arr, 0, [2, 2]);
 
       assert.deepStrictEqual(result, [1, 2, 3]);
@@ -176,6 +229,7 @@ describe('Arr modifications', () => {
 
     test('should clamp range to array bounds', () => {
       const arr = [1, 2, 3];
+
       const result = toRangeFilled(arr, 0, [1, 10]);
 
       assert.deepStrictEqual(result, [1, 0, 0]);
@@ -183,11 +237,20 @@ describe('Arr modifications', () => {
 
     test('should handle negative start (clamped to 0)', () => {
       const arr = [1, 2, 3];
+
       const result = toRangeFilled(arr, 9, [-5, 2]);
 
       assert.deepStrictEqual(result, [9, 9, 3]);
     });
 
+    test('should work with curried version', () => {
+      const fillMiddle = toRangeFilled(7, [1, 3]);
+
+      const result = fillMiddle([1, 2, 3, 4]);
+
+      assert.deepStrictEqual(result, [1, 7, 7, 4]);
+    });
+
     test('A non-integer starting value should result in a type error', () => {
       const arr = [1, 2, 3];
 
@@ -214,7 +277,9 @@ describe('Arr modifications', () => {
 
     test('should work with different value types', () => {
       const nums = [1, 2, 3] as const;
+
       const withString = set(nums, 1, 'two');
+
       expectType<typeof withString, readonly [1 | 'two', 2 | 'two', 3 | 'two']>(
         '=',
       );
@@ -224,6 +289,7 @@ describe('Arr modifications', () => {
 
     test('should work at index 0', () => {
       const tuple = ['a', 'b', 'c'] as const;
+
       const updated = set(tuple, 0, 'A');
 
       assert.deepStrictEqual(updated, ['A', 'b', 'c']);
@@ -231,9 +297,18 @@ describe('Arr modifications', () => {
 
     test('should work at last index', () => {
       const tuple = ['a', 'b', 'c'] as const;
+
       const updated = set(tuple, 2, 'C');
 
       assert.deepStrictEqual(updated, ['a', 'b', 'C']);
     });
+
+    test('should work with curried version', () => {
+      const setIndex1To99 = set(1, 99);
+
+      const r = setIndex1To99([10, 20, 30]);
+
+      assert.deepStrictEqual(r, [10, 99, 30]);
+    });
   });
 });