ts-data-forge 12.2.1 → 12.2.2

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

@@ -142,31 +142,33 @@ export function scan<E, S>(
       ]
 ): NonEmptyTuple<S> | ((array: readonly E[]) => NonEmptyTuple<S>) {
   switch (args.length) {
-    case 3: {
-      const [array, reducer, init] = args;
+    case 3:
+      return scanImpl(...args);
 
-      const mut_result = castMutable<NonEmptyTuple<S>>(
-        newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),
-      );
-
-      let mut_acc = init;
-
-      for (const [index, value] of array.entries()) {
-        mut_acc = reducer(mut_acc, value, asUint32(index));
+    case 2:
+      return (array) => scanImpl(array, ...args);
+  }
+}
 
-        mut_result[index + 1] = mut_acc;
-      }
+const scanImpl = <E, S>(
+  array: readonly E[],
+  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,
+  init: S,
+): NonEmptyTuple<S> => {
+  const mut_result = castMutable<NonEmptyTuple<S>>(
+    newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),
+  );
 
-      return mut_result;
-    }
+  let mut_acc = init;
 
-    case 2: {
-      const [reducer, init] = args;
+  for (const [index, value] of array.entries()) {
+    mut_acc = reducer(mut_acc, value, asUint32(index));
 
-      return (array) => scan(array, reducer, init);
-    }
+    mut_result[index + 1] = mut_acc;
   }
-}
+
+  return mut_result;
+};
 
 /**
  * Reverses an array.
@@ -362,20 +364,19 @@ export function filter<E>(
     | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return array.filter((a, i) => predicate(a, asUint32(i)));
-    }
-
-    case 1: {
-      const [predicate] = args;
+    case 2:
+      return filterImpl(...args);
 
-      return (array) => filter(array, predicate);
-    }
+    case 1:
+      return (array) => filterImpl(array, ...args);
   }
 }
 
+const filterImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): readonly E[] => array.filter((a, i) => predicate(a, asUint32(i)));
+
 /**
  * Filters an array by excluding elements for which the predicate returns true.
  *
@@ -411,20 +412,19 @@ export function filterNot<E>(
     | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return array.filter((a, i) => !predicate(a, asUint32(i)));
-    }
-
-    case 1: {
-      const [predicate] = args;
+    case 2:
+      return filterNotImpl(...args);
 
-      return (array) => filterNot(array, predicate);
-    }
+    case 1:
+      return (array) => filterNotImpl(array, ...args);
   }
 }
 
+const filterNotImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): readonly E[] => array.filter((a, i) => !predicate(a, asUint32(i)));
+
 /**
  * Creates a new array with unique elements.
  *
@@ -533,11 +533,8 @@ export function flat<E, D extends SafeUintWithSmallInt = 1>(
   ...args: readonly [array: readonly E[], depth?: D] | readonly [depth?: D]
 ): readonly unknown[] | ((array: readonly unknown[]) => readonly unknown[]) {
   switch (args.length) {
-    case 2: {
-      const [array, depth] = args;
-
-      return array.flat(depth);
-    }
+    case 2:
+      return flatImpl(...args);
 
     case 1: {
       const [arrayOrDepth] = args;
@@ -545,11 +542,11 @@ export function flat<E, D extends SafeUintWithSmallInt = 1>(
       if (typeof arrayOrDepth === 'number') {
         const depth = arrayOrDepth as SafeUintWithSmallInt | undefined;
 
-        return (array) => flat(array, depth);
+        return (array) => flatImpl(array, depth);
       }
 
       if (arrayOrDepth === undefined) {
-        return (array) => flat(array, 1);
+        return (array) => flatImpl(array, 1);
       }
 
       expectType<typeof arrayOrDepth, readonly E[]>('=');
@@ -558,10 +555,15 @@ export function flat<E, D extends SafeUintWithSmallInt = 1>(
     }
 
     case 0:
-      return (array) => flat(array, 1);
+      return (array) => flatImpl(array, 1);
   }
 }
 
+const flatImpl = (
+  array: readonly unknown[],
+  depth?: SafeUintWithSmallInt,
+): readonly unknown[] => array.flat(depth);
+
 /**
  * Maps each element and flattens the result.
  *
@@ -662,25 +664,25 @@ export function partition<
   | readonly (readonly E[])[]
   | ((array: readonly E[]) => readonly (readonly E[])[]) {
   switch (args.length) {
-    case 2: {
-      const [array, chunkSize] = args;
-
-      return chunkSize < 2
-        ? []
-        : // eslint-disable-next-line total-functions/no-partial-division
-          seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>
-            array.slice(chunkSize * i, chunkSize * (i + 1)),
-          );
-    }
-
-    case 1: {
-      const [chunkSize] = args;
+    case 2:
+      return partitionImpl(...args);
 
-      return (array) => partition(array, chunkSize);
-    }
+    case 1:
+      return (array) => partitionImpl(array, ...args);
   }
 }
 
+const partitionImpl = <N extends WithSmallInt<PositiveInt & SizeType.Arr>, E>(
+  array: readonly E[],
+  chunkSize: N,
+): readonly (readonly E[])[] =>
+  chunkSize < 2
+    ? ([] as const)
+    : // eslint-disable-next-line total-functions/no-partial-division
+      seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>
+        array.slice(chunkSize * i, chunkSize * (i + 1)),
+      );
+
 /**
  * Concatenates two arrays.
  *

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

@@ -35,7 +35,7 @@ describe('Arr transformations', () => {
     test('should work with empty tuple', () => {
       const empty = [] as const;
 
-      const mappedEmpty = map(empty, (x) => String(x));
+      const mappedEmpty = map(empty, String);
 
       expectType<typeof mappedEmpty, readonly []>('=');
 

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

@@ -240,20 +240,19 @@ export function every<E>(
     | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]
 ): boolean | ((array: readonly E[]) => boolean) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
+    case 2:
+      return everyImpl(...args);
 
-      return array.every((a, i) => predicate(a, asUint32(i)));
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => every(array, predicate);
-    }
+    case 1:
+      return (array) => everyImpl(array, ...args);
   }
 }
 
+const everyImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): boolean => array.every((a, i) => predicate(a, asUint32(i)));
+
 /**
  * Tests whether at least one element in an array passes a test implemented by a predicate.
  *
@@ -291,20 +290,19 @@ export function some<E>(
     | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]
 ): boolean | ((array: readonly E[]) => boolean) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
+    case 2:
+      return someImpl(...args);
 
-      return array.some((a, i) => predicate(a, asUint32(i)));
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => some(array, predicate);
-    }
+    case 1:
+      return (array) => someImpl(array, ...args);
   }
 }
 
+const someImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): boolean => array.some((a, i) => predicate(a, asUint32(i)));
+
 /**
  * Checks if an index is within the valid range of an array.
  *

package/src/collections/iset.test.mts

@@ -1229,7 +1229,7 @@ describe('iterable functionality', () => {
     const array = Array.from(set);
 
     assert.deepStrictEqual(
-      Array.from(array).toSorted((a, b) => a - b),
+      array.toSorted((a, b) => a - b),
       [1, 2, 3],
     );
   });
@@ -1240,7 +1240,7 @@ describe('iterable functionality', () => {
     const array = Array.from(set);
 
     assert.deepStrictEqual(
-      Array.from(array).toSorted((a, b) => a - b),
+      array.toSorted((a, b) => a - b),
       [1, 2, 3],
     );
   });

package/src/functional/pipe.test.mts

@@ -142,7 +142,7 @@ describe(pipe, () => {
     ): D | undefined => {
       const v = pipe(input)
         .map(parse)
-        .mapNullable((n) => validate<D>(n))
+        .mapNullable(validate<D>)
         .mapNullable((res) => Result.unwrapOk(res)).value;
 
       expectType<typeof v, D | undefined>('=');

package/src/json/json.mts

@@ -327,7 +327,7 @@ export namespace Json {
     space?: UintRangeInclusive<1, 10> | string,
   ): Result<string | undefined, string> => {
     const allKeys = pipe(keysDeep(value))
-      .map((keys) => Arr.uniq(keys))
+      .map(Arr.uniq)
       .map((ks) => ks.toSorted()).value;
 
     return stringifySelected(value, allKeys, space);

package/src/string/str.mts

@@ -244,25 +244,28 @@ export namespace Str {
       | readonly [minLength: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
-      case 2: {
-        const [s, minLength] = args;
+      case 2:
+        return asMinLengthStringImpl(...args);
 
-        if (!isMinLengthString(s, minLength)) {
-          throw new TypeError(
-            `Expected a string of length >= ${minLength}, got a string of length ${s.length}`,
-          );
-        }
-
-        return s;
-      }
+      case 1:
+        return (s) => asMinLengthStringImpl(s, ...args);
+    }
+  }
 
-      case 1: {
-        const [minLength] = args;
+  const asMinLengthStringImpl = (
+    s: string,
+    minLength: SupportedLength,
+  ): string => {
+    const actualLength = s.length;
 
-        return (s) => asMinLengthString(s, minLength);
-      }
+    if (!isMinLengthString(s, minLength)) {
+      throw new TypeError(
+        `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`,
+      );
     }
-  }
+
+    return s;
+  };
 
   /**
    * Casts a string to `MaxLengthString<MaxLength>` after checking that it has
@@ -315,25 +318,28 @@ export namespace Str {
       | readonly [maxLength: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
-      case 2: {
-        const [s, maxLength] = args;
-
-        if (!isMaxLengthString(s, maxLength)) {
-          throw new TypeError(
-            `Expected a string of length <= ${maxLength}, got a string of length ${s.length}`,
-          );
-        }
+      case 2:
+        return asMaxLengthStringImpl(...args);
 
-        return s;
-      }
+      case 1:
+        return (s) => asMaxLengthStringImpl(s, ...args);
+    }
+  }
 
-      case 1: {
-        const [maxLength] = args;
+  const asMaxLengthStringImpl = (
+    s: string,
+    maxLength: SupportedLength,
+  ): string => {
+    const actualLength = s.length;
 
-        return (s) => asMaxLengthString(s, maxLength);
-      }
+    if (!isMaxLengthString(s, maxLength)) {
+      throw new TypeError(
+        `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`,
+      );
     }
-  }
+
+    return s;
+  };
 
   /**
    * Casts a string to `BoundedLengthString<MinLength, MaxLength>` after
@@ -403,26 +409,30 @@ export namespace Str {
       | readonly [minLength: SupportedLength, maxLength: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
-      case 3: {
-        const [s, minLength, maxLength] = args;
-
-        if (!isBoundedLengthString(s, minLength, maxLength)) {
-          throw new TypeError(
-            `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${s.length}`,
-          );
-        }
+      case 3:
+        return asBoundedLengthStringImpl(...args);
 
-        return s;
-      }
-
-      case 2: {
-        const [minLength, maxLength] = args;
-
-        return (s) => asBoundedLengthString(s, minLength, maxLength);
-      }
+      case 2:
+        return (s) => asBoundedLengthStringImpl(s, ...args);
     }
   }
 
+  const asBoundedLengthStringImpl = (
+    s: string,
+    minLength: SupportedLength,
+    maxLength: SupportedLength,
+  ): string => {
+    const actualLength = s.length;
+
+    if (!isBoundedLengthString(s, minLength, maxLength)) {
+      throw new TypeError(
+        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`,
+      );
+    }
+
+    return s;
+  };
+
   /**
    * Casts a string to `FixedLengthString<Length>` after checking that it has
    * exactly `length` characters.
@@ -474,25 +484,28 @@ export namespace Str {
       | readonly [length: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
-      case 2: {
-        const [s, length] = args;
+      case 2:
+        return asFixedLengthStringImpl(...args);
 
-        if (!isFixedLengthString(s, length)) {
-          throw new TypeError(
-            `Expected a string of length ${length}, got a string of length ${s.length}`,
-          );
-        }
-
-        return s;
-      }
+      case 1:
+        return (s) => asFixedLengthStringImpl(s, ...args);
+    }
+  }
 
-      case 1: {
-        const [length] = args;
+  const asFixedLengthStringImpl = (
+    s: string,
+    length: SupportedLength,
+  ): string => {
+    const actualLength = s.length;
 
-        return (s) => asFixedLengthString(s, length);
-      }
+    if (!isFixedLengthString(s, length)) {
+      throw new TypeError(
+        `Expected a string of length ${length}, got a string of length ${actualLength}`,
+      );
     }
-  }
+
+    return s;
+  };
 
   /**
    * Casts a string to `NonEmptyString` after checking that it has at least one