ts-data-forge 5.0.1 → 5.1.1

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

@@ -7,38 +7,54 @@ 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);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should handle very large negative indices', () => {
       const array = [1, 2, 3];
+
       const result = at(array, asInt32(-1000));
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should work with valid indices', () => {
       const array = [10, 20, 30];
+
       const result = at(array, 1);
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(result.value).toBe(20);
       }
     });
+
+    test('should work with curried version', () => {
+      const atIndex2 = at(2);
+
+      const result = atIndex2([10, 20, 30, 40]);
+
+      assert.isTrue(Optional.isSome(result));
+
+      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>>('=');
 
-      expect(Optional.isSome(h)).toBe(true);
+      assert.isTrue(Optional.isSome(h));
 
       if (Optional.isSome(h)) {
         expect(h.value).toBe(1);
@@ -47,11 +63,12 @@ describe('Arr element access', () => {
 
     test('case 2', () => {
       const xs: MutableNonEmptyArray<number> = [1, 2, 3];
+
       const h = head(xs);
 
       expectType<typeof h, Some<number>>('=');
 
-      expect(Optional.isSome(h)).toBe(true);
+      assert.isTrue(Optional.isSome(h));
 
       if (Optional.isSome(h)) {
         expect(h.value).toBe(1);
@@ -60,11 +77,12 @@ describe('Arr element access', () => {
 
     test('case 3', () => {
       const mut_xs: number[] = [1, 2, 3];
+
       const h = head(mut_xs);
 
       expectType<typeof h, Optional<number>>('=');
 
-      expect(Optional.isSome(h)).toBe(true);
+      assert.isTrue(Optional.isSome(h));
 
       if (Optional.isSome(h)) {
         expect(h.value).toBe(1);
@@ -78,19 +96,19 @@ describe('Arr element access', () => {
 
       expectType<typeof h, None>('=');
 
-      expect(Optional.isNone(h)).toBe(true);
+      assert.isTrue(Optional.isNone(h));
     });
 
     test('should return none for empty array', () => {
       const result = head([]);
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should work with single element array', () => {
       const result = head([42]);
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(result.value).toBe(42);
@@ -101,11 +119,12 @@ 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>>('=');
 
-      expect(Optional.isSome(l)).toBe(true);
+      assert.isTrue(Optional.isSome(l));
 
       if (Optional.isSome(l)) {
         expect(l.value).toBe(3);
@@ -114,11 +133,12 @@ describe('Arr element access', () => {
 
     test('case 2', () => {
       const xs: MutableNonEmptyArray<number> = [1, 2, 3];
+
       const l = last(xs);
 
       expectType<typeof l, Some<number>>('=');
 
-      expect(Optional.isSome(l)).toBe(true);
+      assert.isTrue(Optional.isSome(l));
 
       if (Optional.isSome(l)) {
         expect(l.value).toBe(3);
@@ -127,11 +147,12 @@ describe('Arr element access', () => {
 
     test('case 3', () => {
       const mut_xs: number[] = [1, 2, 3];
+
       const l = last(mut_xs);
 
       expectType<typeof l, Optional<number>>('=');
 
-      expect(Optional.isSome(l)).toBe(true);
+      assert.isTrue(Optional.isSome(l));
 
       if (Optional.isSome(l)) {
         expect(l.value).toBe(3);
@@ -145,19 +166,19 @@ describe('Arr element access', () => {
 
       expectType<typeof l, None>('=');
 
-      expect(Optional.isNone(l)).toBe(true);
+      assert.isTrue(Optional.isNone(l));
     });
 
     test('should return none for empty array', () => {
       const result = last([]);
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should work with single element array', () => {
       const result = last([42]);
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(result.value).toBe(42);

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

@@ -20,10 +20,13 @@ export function set<const Ar extends readonly unknown[], const V = Ar[number]>(
   index: ArgArrayIndex<Ar>,
   newValue: V,
 ): IsFixedLengthList<Ar> extends true
-  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    Readonly<{ [K in keyof Ar]: Ar[K] | V }>
   : Ar extends NonEmptyArray<unknown>
-    ? NonEmptyArray<Ar[number] | V>
-    : readonly (Ar[number] | V)[];
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      NonEmptyArray<Ar[number] | V>
+    : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      readonly (Ar[number] | V)[];
 
 // curried version
 export function set<const V>(
@@ -32,10 +35,13 @@ export function set<const V>(
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
-  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    Readonly<{ [K in keyof Ar]: Ar[K] | V }>
   : Ar extends NonEmptyArray<unknown>
-    ? NonEmptyArray<Ar[number] | V>
-    : readonly (Ar[number] | V)[];
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      NonEmptyArray<Ar[number] | V>
+    : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      readonly (Ar[number] | V)[];
 
 export function set<E, const V = E>(
   ...args:
@@ -45,11 +51,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 +73,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]);
  * ```
  */
@@ -81,10 +92,13 @@ export function toUpdated<
   index: ArgArrayIndex<Ar>,
   updater: (prev: Ar[number]) => V,
 ): IsFixedLengthList<Ar> extends true
-  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    Readonly<{ [K in keyof Ar]: Ar[K] | V }>
   : Ar extends NonEmptyArray<unknown>
-    ? NonEmptyArray<Ar[number] | V>
-    : readonly (Ar[number] | V)[];
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      NonEmptyArray<Ar[number] | V>
+    : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      readonly (Ar[number] | V)[];
 
 // curried version
 export function toUpdated<E, const V = E>(
@@ -110,11 +124,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 +146,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]);
  * ```
  */
@@ -143,8 +162,10 @@ export function toInserted<
   index: ArgArrayIndexWithNegative<Ar>,
   newValue: V,
 ): IsFixedLengthList<Ar> extends true
-  ? ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>
-  : NonEmptyArray<Ar[number] | V>;
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>
+  : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    NonEmptyArray<Ar[number] | V>;
 
 // curried version
 export function toInserted<const V>(
@@ -153,8 +174,10 @@ export function toInserted<const V>(
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
-  ? ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>
-  : NonEmptyArray<Ar[number] | V>;
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>
+  : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    NonEmptyArray<Ar[number] | V>;
 
 export function toInserted<E, const V = E>(
   ...args:
@@ -168,6 +191,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 +199,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 +219,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 +244,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 +265,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 +288,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 +313,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 +336,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 +358,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 +392,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 +413,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]);
  * ```
  */
@@ -381,10 +429,13 @@ export function toRangeFilled<const Ar extends readonly unknown[], const V>(
     end: ArgArrayIndexWithNegative<Ar>,
   ],
 ): IsFixedLengthList<Ar> extends true
-  ? ArrayOfLength<Ar['length'], V | Ar[number]>
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    ArrayOfLength<Ar['length'], V | Ar[number]>
   : Ar extends NonEmptyArray<unknown>
-    ? NonEmptyArray<V | Ar[number]>
-    : readonly (V | Ar[number])[];
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      NonEmptyArray<V | Ar[number]>
+    : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      readonly (V | Ar[number])[];
 
 // curried version
 export function toRangeFilled<const V>(
@@ -396,10 +447,13 @@ export function toRangeFilled<const V>(
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
-  ? ArrayOfLength<Ar['length'], V | Ar[number]>
+  ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    ArrayOfLength<Ar['length'], V | Ar[number]>
   : Ar extends NonEmptyArray<unknown>
-    ? NonEmptyArray<V | Ar[number]>
-    : readonly (V | Ar[number])[];
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      NonEmptyArray<V | Ar[number]>
+    : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+      readonly (V | Ar[number])[];
 
 export function toRangeFilled<E, const V>(
   ...args:
@@ -422,12 +476,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);
     }
   }