ts-data-forge 5.0.1 → 5.1.1

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

@@ -15,33 +15,41 @@ describe('Arr search operations', () => {
   describe(find, () => {
     test('should find first element matching predicate', () => {
       const numbers = [1, 2, 3, 4, 5];
+
       const firstEven = find(numbers, (n) => n % 2 === 0);
 
-      expect(Optional.isSome(firstEven)).toBe(true);
+      assert.isTrue(Optional.isSome(firstEven));
+
       expect(Optional.unwrap(firstEven)).toBe(2);
     });
 
     test('should return None when no element matches', () => {
       const odds = [1, 3, 5];
+
       const firstEven = find(odds, (n) => n % 2 === 0);
 
-      expect(Optional.isNone(firstEven)).toBe(true);
+      assert.isTrue(Optional.isNone(firstEven));
     });
 
     test('should work with curried version', () => {
       const isEven = (n: number): boolean => n % 2 === 0;
+
       const findEven = find<number>(isEven);
 
       const result1 = findEven([1, 2, 3]);
+
       const result2 = findEven([1, 3, 5]);
 
-      expect(Optional.isSome(result1)).toBe(true);
+      assert.isTrue(Optional.isSome(result1));
+
       expect(Optional.unwrap(result1)).toBe(2);
-      expect(Optional.isNone(result2)).toBe(true);
+
+      assert.isTrue(Optional.isNone(result2));
     });
 
     test('should work with type guard predicate', () => {
       const values: readonly (string | number)[] = [1, 'a', 2, 'b'];
+
       const firstString = find(
         values,
         (x): x is string => typeof x === 'string',
@@ -49,12 +57,14 @@ describe('Arr search operations', () => {
 
       expectType<typeof firstString, Optional<string>>('=');
 
-      expect(Optional.isSome(firstString)).toBe(true);
+      assert.isTrue(Optional.isSome(firstString));
+
       expect(Optional.unwrap(firstString)).toBe('a');
     });
 
     test('should provide index and array to predicate', () => {
       const numbers = [10, 20, 30];
+
       const foundWithIndex = find(numbers, (value, index, arr) => {
         expect(arr).toBe(numbers);
 
@@ -66,6 +76,7 @@ describe('Arr search operations', () => {
 
     test('should return first match when multiple elements match', () => {
       const numbers = [2, 4, 6, 8];
+
       const firstEven = find(numbers, (n) => n % 2 === 0);
 
       expect(Optional.unwrap(firstEven)).toBe(2);
@@ -73,46 +84,55 @@ describe('Arr search operations', () => {
 
     test('should work with empty array', () => {
       const empty: readonly number[] = [];
+
       const result = find(empty, () => true);
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
   });
 
   describe(findLast, () => {
     test('should find last element matching predicate', () => {
       const numbers = [1, 2, 3, 4, 5];
+
       const lastEven = findLast(numbers, (n) => n % 2 === 0);
 
-      expect(Optional.isSome(lastEven)).toBe(true);
+      assert.isTrue(Optional.isSome(lastEven));
+
       expect(Optional.unwrap(lastEven)).toBe(4);
     });
 
     test('should return None when no element matches', () => {
       const odds = [1, 3, 5];
+
       const lastEven = findLast(odds, (n) => n % 2 === 0);
 
-      expect(Optional.isNone(lastEven)).toBe(true);
+      assert.isTrue(Optional.isNone(lastEven));
     });
 
     test('should work with curried version', () => {
       const isPositive = (n: number): boolean => n > 0;
+
       const findLastPositive = findLast(isPositive);
+
       const result = findLastPositive([-1, 2, -3, 4]);
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
+
       expect(Optional.unwrap(result)).toBe(4);
     });
 
     test('should work with empty array', () => {
       const empty: number[] = [];
+
       const result = findLast(empty, (n) => n > 0);
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should pass index and array to predicate', () => {
       const numbers = [10, 20, 30, 40];
+
       const lastWithIndex2 = findLast(numbers, (_, idx, arr) => {
         expect(arr).toBe(numbers);
 
@@ -124,6 +144,7 @@ describe('Arr search operations', () => {
 
     test('should find last occurrence', () => {
       const numbers = [1, 2, 2, 3, 2, 4];
+
       const lastTwo = findLast(numbers, (n) => n === 2);
 
       expect(Optional.unwrap(lastTwo)).toBe(2);
@@ -138,6 +159,7 @@ describe('Arr search operations', () => {
   describe(findIndex, () => {
     test('should find index of matching element', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = findIndex(arr, (x) => x === 'b');
 
       expect(result).toBeGreaterThanOrEqual(0);
@@ -149,6 +171,7 @@ describe('Arr search operations', () => {
 
     test('should return None for no match', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = findIndex(arr, (x) => x === 'd');
 
       expect(result).toBe(-1);
@@ -158,6 +181,7 @@ describe('Arr search operations', () => {
   describe(findLastIndex, () => {
     test('should find last index matching predicate', () => {
       const numbers = [1, 2, 3, 4, 2, 5];
+
       const lastTwoIndex = findLastIndex(numbers, (n) => n === 2);
 
       expect(lastTwoIndex).toBe(4);
@@ -165,6 +189,7 @@ describe('Arr search operations', () => {
 
     test('should return -1 when no element matches', () => {
       const odds = [1, 3, 5];
+
       const lastEvenIndex = findLastIndex(odds, (n) => n % 2 === 0);
 
       expect(lastEvenIndex).toBe(-1);
@@ -172,7 +197,9 @@ describe('Arr search operations', () => {
 
     test('should work with curried version', () => {
       const isPositive = (n: number): boolean => n > 0;
+
       const findLastPositiveIndex = findLastIndex(isPositive);
+
       const result = findLastPositiveIndex([-1, 2, -3, 4, -5]);
 
       expect(result).toBe(3); // index of last positive number (4)
@@ -180,6 +207,7 @@ describe('Arr search operations', () => {
 
     test('should work with empty array', () => {
       const empty: number[] = [];
+
       const result = findLastIndex(empty, (n) => n > 0);
 
       expect(result).toBe(-1);
@@ -187,6 +215,7 @@ describe('Arr search operations', () => {
 
     test('should pass index and array to predicate', () => {
       const numbers = [10, 20, 30, 40];
+
       const lastWithIndex2OrHigher = findLastIndex(numbers, (_, idx, arr) => {
         expect(arr).toBe(numbers);
 
@@ -204,6 +233,7 @@ describe('Arr search operations', () => {
         { id: 4, active: false },
         { id: 5, active: true },
       ];
+
       const lastActiveIndex = findLastIndex(data, (item) => item.active);
 
       expect(lastActiveIndex).toBe(4); // last active item
@@ -211,6 +241,7 @@ describe('Arr search operations', () => {
 
     test('should work with tuples', () => {
       const tuple = [10, 20, 30, 20, 40] as const;
+
       const lastTwentyIndex = findLastIndex(tuple, (x) => x === 20);
 
       expect(lastTwentyIndex).toBe(3); // last occurrence of 20
@@ -219,10 +250,12 @@ describe('Arr search operations', () => {
     test('should search from end to beginning', () => {
       // Verify search order by using side effects
       const numbers = [1, 2, 3, 4, 5];
+
       const mut_searchOrder: number[] = [];
 
       findLastIndex(numbers, (val, idx) => {
         mut_searchOrder.push(idx);
+
         return val === 3;
       });
 
@@ -232,15 +265,19 @@ describe('Arr search operations', () => {
 
     test('should handle single element array', () => {
       const single = [42];
+
       const foundIndex = findLastIndex(single, (n) => n === 42);
+
       const notFoundIndex = findLastIndex(single, (n) => n === 0);
 
       expect(foundIndex).toBe(0);
+
       expect(notFoundIndex).toBe(-1);
     });
 
     test('should work with string arrays', () => {
       const words = ['hello', 'world', 'test', 'hello', 'end'];
+
       const lastHelloIndex = findLastIndex(words, (word) => word === 'hello');
 
       expect(lastHelloIndex).toBe(3);
@@ -250,6 +287,7 @@ describe('Arr search operations', () => {
   describe(indexOf, () => {
     test('should find index of element', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = indexOf(arr, 'b');
 
       expect(result).toBeGreaterThanOrEqual(0);
@@ -263,6 +301,7 @@ describe('Arr search operations', () => {
 
     test('should return -1 for non-existent element', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = indexOf(arr, 'd');
 
       expect(result).toBe(-1);
@@ -272,6 +311,7 @@ describe('Arr search operations', () => {
   describe(indexOfFrom, () => {
     test('should find index of element from specified index', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = indexOfFrom(arr, 'b', 2);
 
       expect(result).toBeGreaterThanOrEqual(0);
@@ -285,6 +325,7 @@ describe('Arr search operations', () => {
 
     test('should return -1 when element not found from index', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = indexOfFrom(arr, 'a', 1);
 
       expect(result).toBe(-1);
@@ -292,6 +333,7 @@ describe('Arr search operations', () => {
 
     test('should find first occurrence when fromIndex is 0', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = indexOfFrom(arr, 'b', 0);
 
       expect(result).toBe(1);
@@ -299,6 +341,7 @@ describe('Arr search operations', () => {
 
     test('should handle negative fromIndex', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = indexOfFrom(arr, 'b', -2);
 
       expect(result).toBe(3);
@@ -306,6 +349,7 @@ describe('Arr search operations', () => {
 
     test('should handle fromIndex beyond array length', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = indexOfFrom(arr, 'a', 10);
 
       expect(result).toBe(-1);
@@ -315,6 +359,7 @@ describe('Arr search operations', () => {
   describe(lastIndexOf, () => {
     test('should find last index of element', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = lastIndexOf(arr, 'b');
 
       expect(result).toBeGreaterThanOrEqual(0);
@@ -328,6 +373,7 @@ describe('Arr search operations', () => {
 
     test('should return -1 for non-existent element', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = lastIndexOf(arr, 'd');
 
       expect(result).toBe(-1);
@@ -337,6 +383,7 @@ describe('Arr search operations', () => {
   describe(lastIndexOfFrom, () => {
     test('should find last index of element from specified index', () => {
       const arr = ['a', 'b', 'c', 'b', 'e'];
+
       const result = lastIndexOfFrom(arr, 'b', 2);
 
       expect(result).toBeGreaterThanOrEqual(0);
@@ -350,6 +397,7 @@ describe('Arr search operations', () => {
 
     test('should return -1 when element not found before index', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = lastIndexOfFrom(arr, 'b', 0);
 
       expect(result).toBe(-1);
@@ -357,6 +405,7 @@ describe('Arr search operations', () => {
 
     test('should find last occurrence when fromIndex covers all elements', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = lastIndexOfFrom(arr, 'b', 10);
 
       expect(result).toBe(3);
@@ -364,6 +413,7 @@ describe('Arr search operations', () => {
 
     test('should handle negative fromIndex', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = lastIndexOfFrom(arr, 'b', -1);
 
       expect(result).toBe(3);
@@ -371,6 +421,7 @@ describe('Arr search operations', () => {
 
     test('should handle fromIndex of 0', () => {
       const arr = ['a', 'b', 'c', 'b'];
+
       const result = lastIndexOfFrom(arr, 'a', 0);
 
       expect(result).toBe(0);

package/src/array/impl/array-utils-set-op.mts

@@ -5,11 +5,14 @@
  *
  * ```ts
  * const numbers = [1, 2, 3] as const;
+ *
  * const sameNumbers = [1, 2, 3] as const;
+ *
  * const differentNumbers = [1, 2, 4] as const;
  *
- * assert.ok(Arr.eq(numbers, sameNumbers));
- * assert.notOk(Arr.eq(numbers, differentNumbers));
+ * assert.isTrue(Arr.eq(numbers, sameNumbers));
+ *
+ * assert.isFalse(Arr.eq(numbers, differentNumbers));
  * ```
  */
 export const eq = <E,>(
@@ -35,11 +38,14 @@ export const equal = eq;
  *
  * ```ts
  * const subset = [1, 2] as const;
+ *
  * const superset = [1, 2, 3] as const;
+ *
  * const notSubset = [2, 4] as const;
  *
- * assert.ok(Arr.isSubset(subset, superset));
- * assert.notOk(Arr.isSubset(notSubset, superset));
+ * assert.isTrue(Arr.isSubset(subset, superset));
+ *
+ * assert.isFalse(Arr.isSubset(notSubset, superset));
  * ```
  */
 export const isSubset = <E1 extends Primitive, E2 extends Primitive = E1>(
@@ -58,12 +64,16 @@ export const isSubset = <E1 extends Primitive, E2 extends Primitive = E1>(
  *
  * ```ts
  * const potentialSuperset = ['a', 'b', 'c'] as const;
+ *
  * const subset = ['a', 'c'] as const;
+ *
  * const notSuperset = ['a', 'd'] as const;
  *
- * assert.ok(Arr.isSuperset(potentialSuperset, subset));
- * assert.notOk(Arr.isSuperset(subset, potentialSuperset));
- * assert.notOk(Arr.isSuperset(potentialSuperset, notSuperset));
+ * assert.isTrue(Arr.isSuperset(potentialSuperset, subset));
+ *
+ * assert.isFalse(Arr.isSuperset(subset, potentialSuperset));
+ *
+ * assert.isFalse(Arr.isSuperset(potentialSuperset, notSuperset));
  * ```
  */
 export const isSuperset = <E1 extends Primitive, E2 extends Primitive = E1>(
@@ -78,6 +88,7 @@ export const isSuperset = <E1 extends Primitive, E2 extends Primitive = E1>(
  *
  * ```ts
  * const refs = ['Ada', 'Alan', 'Grace'] as const;
+ *
  * const attendees = ['Grace', 'Alan', 'Barbara'] as const;
  *
  * const both = Arr.setIntersection(refs, attendees);
@@ -102,6 +113,7 @@ export const setIntersection = <
  *
  * ```ts
  * const baseline = [1, 2, 3, 4] as const;
+ *
  * const removed = [2, 4] as const;
  *
  * const remaining = Arr.setDifference(baseline, removed);
@@ -121,6 +133,7 @@ export const setDifference = <E extends Primitive>(
  *
  * ```ts
  * const upcoming = [1, 3, 5, 7, 9] as const;
+ *
  * const completed = [3, 4, 7] as const;
  *
  * const remaining = Arr.sortedNumSetDifference(upcoming, completed);
@@ -135,27 +148,33 @@ export const sortedNumSetDifference = <E extends number>(
   sortedList2: readonly E[],
 ): readonly E[] => {
   const mut_result: E[] = [];
+
   let mut_it1 = 0; // iterator for sortedList1
+
   let mut_it2 = 0; // iterator for sortedList2
 
   while (mut_it1 < sortedList1.length && mut_it2 < sortedList2.length) {
     // Non-null assertions are safe due to loop condition
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const val1 = sortedList1[mut_it1]!;
+
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const val2 = sortedList2[mut_it2]!;
 
     if (val1 === val2) {
       mut_it1 += 1;
+
       mut_it2 += 1;
     } else if (val1 < val2) {
       mut_result.push(val1);
+
       mut_it1 += 1;
     } else {
       // val1 > val2
       mut_it2 += 1;
     }
   }
+
   // Add remaining elements from sortedList1
   for (; mut_it1 < sortedList1.length; mut_it1 += 1) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion