ts-data-forge 12.2.1 → 12.2.2

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

@@ -62,43 +62,39 @@ export function find<E>(
       ]
 ): Optional<E> | ((array: readonly E[]) => Optional<E>) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      const foundIndex = array.findIndex(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        predicate as () => boolean,
-      );
-
-      expectType<
-        Parameters<typeof array.findIndex>[0],
-        (value: E, index: number, arr: readonly E[]) => unknown
-      >('=');
-
-      expectType<
-        typeof predicate,
-        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-      >('=');
-
-      return foundIndex === -1
-        ? Optional.none
-        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          Optional.some(array[foundIndex]!);
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      expectType<
-        typeof predicate,
-        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-      >('=');
-
-      return (array) => find(array, predicate);
-    }
+    case 2:
+      return findImpl(...args);
+
+    case 1:
+      return (array) => findImpl(array, ...args);
   }
 }
 
+const findImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): Optional<E> => {
+  const foundIndex = array.findIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate as () => boolean,
+  );
+
+  expectType<
+    Parameters<typeof array.findIndex>[0],
+    (value: E, index: number, arr: readonly E[]) => unknown
+  >('=');
+
+  expectType<
+    typeof predicate,
+    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
+  >('=');
+
+  return foundIndex === -1
+    ? Optional.none
+    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      Optional.some(array[foundIndex]!);
+};
+
 /**
  * Finds the last element that satisfies a predicate.
  *
@@ -149,43 +145,39 @@ export function findLast<E>(
       ]
 ): Optional<E> | ((array: readonly E[]) => Optional<E>) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      const foundIndex = array.findLastIndex(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        predicate as () => boolean,
-      );
-
-      expectType<
-        Parameters<typeof array.findIndex>[0],
-        (value: E, index: number, arr: readonly E[]) => unknown
-      >('=');
-
-      expectType<
-        typeof predicate,
-        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-      >('=');
-
-      return foundIndex === -1
-        ? Optional.none
-        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          Optional.some(array[foundIndex]!);
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      expectType<
-        typeof predicate,
-        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-      >('=');
-
-      return (array) => findLast(array, predicate);
-    }
+    case 2:
+      return findLastImpl(...args);
+
+    case 1:
+      return (array) => findLastImpl(array, ...args);
   }
 }
 
+const findLastImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): Optional<E> => {
+  const foundIndex = array.findLastIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate as () => boolean,
+  );
+
+  expectType<
+    Parameters<typeof array.findIndex>[0],
+    (value: E, index: number, arr: readonly E[]) => unknown
+  >('=');
+
+  expectType<
+    typeof predicate,
+    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
+  >('=');
+
+  return foundIndex === -1
+    ? Optional.none
+    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      Optional.some(array[foundIndex]!);
+};
+
 /**
  * Finds the index of the first element that satisfies a predicate.
  *
@@ -233,25 +225,25 @@ export function findIndex<E>(
       ]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return pipe(
-        array.findIndex(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          predicate as (value: E, index: number) => boolean,
-        ),
-      ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => findIndex(array, predicate);
-    }
+    case 2:
+      return findIndexImpl(...args);
+
+    case 1:
+      return (array) => findIndexImpl(array, ...args);
   }
 }
 
+const findIndexImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): SizeType.Arr | -1 =>
+  pipe(
+    array.findIndex(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      predicate as (value: E, index: number) => boolean,
+    ),
+  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
+
 /**
  * Finds the index of the last element that satisfies a predicate.
  *
@@ -299,25 +291,25 @@ export function findLastIndex<E>(
       ]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return pipe(
-        array.findLastIndex(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          predicate as (value: E, index: number) => boolean,
-        ),
-      ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => findLastIndex(array, predicate);
-    }
+    case 2:
+      return findLastIndexImpl(...args);
+
+    case 1:
+      return (array) => findLastIndexImpl(array, ...args);
   }
 }
 
+const findLastIndexImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): SizeType.Arr | -1 =>
+  pipe(
+    array.findLastIndex(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      predicate as (value: E, index: number) => boolean,
+    ),
+  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
+
 /**
  * Gets the index of a value in an array.
  *
@@ -357,22 +349,23 @@ export function indexOf<E>(
     | readonly [searchElement: E]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, searchElement] = args;
-
-      const index = array.indexOf(searchElement);
-
-      return index !== -1 ? asUint32(index) : -1;
-    }
+    case 2:
+      return indexOfImpl(...args);
 
-    case 1: {
-      const [searchElement] = args;
-
-      return (array) => indexOf(array, searchElement);
-    }
+    case 1:
+      return (array) => indexOfImpl(array, ...args);
   }
 }
 
+const indexOfImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+): SizeType.Arr | -1 => {
+  const index = array.indexOf(searchElement);
+
+  return index !== -1 ? asUint32(index) : -1;
+};
+
 /**
  * Gets the index of a value in an array, starting from a specified index.
  *
@@ -425,22 +418,24 @@ export function indexOfFrom<E>(
     | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 3: {
-      const [array, searchElement, fromIndex] = args;
+    case 3:
+      return indexOfFromImpl(...args);
 
-      const index = array.indexOf(searchElement, fromIndex);
-
-      return index !== -1 ? asUint32(index) : -1;
-    }
-
-    case 2: {
-      const [searchElement, fromIndex] = args;
-
-      return (array) => indexOfFrom(array, searchElement, fromIndex);
-    }
+    case 2:
+      return (array) => indexOfFromImpl(array, ...args);
   }
 }
 
+const indexOfFromImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+  fromIndex: SizeType.ArgArrWithNegative,
+): SizeType.Arr | -1 => {
+  const index = array.indexOf(searchElement, fromIndex);
+
+  return index !== -1 ? asUint32(index) : -1;
+};
+
 /**
  * Gets the last index of a value in an array.
  *
@@ -484,22 +479,23 @@ export function lastIndexOf<E>(
     | readonly [searchElement: E]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, searchElement] = args;
-
-      const index = array.lastIndexOf(searchElement);
+    case 2:
+      return lastIndexOfImpl(...args);
 
-      return index !== -1 ? asUint32(index) : -1;
-    }
-
-    case 1: {
-      const [searchElement] = args;
-
-      return (array) => lastIndexOf(array, searchElement);
-    }
+    case 1:
+      return (array) => lastIndexOfImpl(array, ...args);
   }
 }
 
+const lastIndexOfImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+): SizeType.Arr | -1 => {
+  const index = array.lastIndexOf(searchElement);
+
+  return index !== -1 ? asUint32(index) : -1;
+};
+
 /**
  * Gets the last index of a value in an array, starting from a specified index.
  *
@@ -552,18 +548,20 @@ export function lastIndexOfFrom<E>(
     | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 3: {
-      const [array, searchElement, fromIndex] = args;
-
-      const index = array.lastIndexOf(searchElement, fromIndex);
-
-      return index !== -1 ? asUint32(index) : -1;
-    }
-
-    case 2: {
-      const [searchElement, fromIndex] = args;
+    case 3:
+      return lastIndexOfFromImpl(...args);
 
-      return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
-    }
+    case 2:
+      return (array) => lastIndexOfFromImpl(array, ...args);
   }
 }
+
+const lastIndexOfFromImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+  fromIndex: SizeType.ArgArrWithNegative,
+): SizeType.Arr | -1 => {
+  const index = array.lastIndexOf(searchElement, fromIndex);
+
+  return index !== -1 ? asUint32(index) : -1;
+};

package/src/array/impl/array-utils-slice-clamped.mts

@@ -39,21 +39,23 @@ export function sliceClamped<E>(
     | readonly [SizeType.ArgArrWithNegative, SizeType.ArgArrWithNegative]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 3: {
-      const [array, start, end] = args;
+    case 3:
+      return sliceClampedImpl(...args);
 
-      const startClamped = Num.clamp(0, array.length)(start);
-
-      // Ensure endClamped is not less than startClamped.
-      const endClamped = Num.clamp(startClamped, array.length)(end);
+    case 2:
+      return (array) => sliceClampedImpl(array, ...args);
+  }
+}
 
-      return array.slice(startClamped, endClamped);
-    }
+const sliceClampedImpl = <E,>(
+  array: readonly E[],
+  start: SizeType.ArgArrWithNegative,
+  end: SizeType.ArgArrWithNegative,
+): readonly E[] => {
+  const startClamped = Num.clamp(0, array.length)(start);
 
-    case 2: {
-      const [start, end] = args;
+  // Ensure endClamped is not less than startClamped.
+  const endClamped = Num.clamp(startClamped, array.length)(end);
 
-      return (array) => sliceClamped(array, start, end);
-    }
-  }
-}
+  return array.slice(startClamped, endClamped);
+};

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

@@ -115,20 +115,19 @@ export function take<E>(
     | readonly [num: SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return takeImpl(...args);
 
-      return sliceClamped(array, 0, num);
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => take(array, num);
-    }
+    case 1:
+      return (array) => takeImpl(array, ...args);
   }
 }
 
+const takeImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, 0, num);
+
 /**
  * Takes the last N elements from an array.
  *
@@ -178,20 +177,20 @@ export function takeLast<E>(
     | readonly [num: SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return takeLastImpl(...args);
 
-      return sliceClamped(array, Uint32.sub(size(array), num), size(array));
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => takeLast(array, num);
-    }
+    case 1:
+      return (array) => takeLastImpl(array, ...args);
   }
 }
 
+const takeLastImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] =>
+  sliceClamped(array, Uint32.sub(size(array), num), size(array));
+
 /**
  * Skips the first N elements of an array.
  *
@@ -230,20 +229,19 @@ export function skip<E>(
   ...args: readonly [readonly E[], SizeType.ArgArr] | readonly [SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return skipImpl(...args);
 
-      return sliceClamped(array, num, size(array));
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => skip(array, num);
-    }
+    case 1:
+      return (array) => skipImpl(array, ...args);
   }
 }
 
+const skipImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, num, size(array));
+
 /**
  * Skips the last N elements of an array.
  *
@@ -286,20 +284,19 @@ export function skipLast<E>(
     | readonly [num: SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return skipLastImpl(...args);
 
-      return sliceClamped(array, 0, Uint32.sub(size(array), num));
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => skipLast(array, num);
-    }
+    case 1:
+      return (array) => skipLastImpl(array, ...args);
   }
 }
 
+const skipLastImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, 0, Uint32.sub(size(array), num));
+
 /**
  * Alias for `tail`.
  *