ts-data-forge 12.2.1 → 12.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "12.2.1",
+  "version": "12.2.2",
   "private": false,
   "keywords": [
     "typescript",
@@ -36,16 +36,16 @@
   ],
   "dependencies": {
     "@sindresorhus/is": "^8.1.0",
-    "ts-type-forge": "7.x"
+    "ts-type-forge": "~7.2.1"
   },
   "devDependencies": {
     "@emotion/react": "11.14.0",
     "@emotion/styled": "11.14.1",
     "@mui/material": "9.2.0",
     "@types/react": "19.2.17",
-    "immer": "11.1.11",
+    "immer": "11.1.15",
     "react": "19.2.7",
-    "typedoc": "0.28.19",
+    "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0"
   },
   "peerDependencies": {

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

@@ -45,26 +45,25 @@ export function at<E>(
     | readonly [index: SizeType.ArgArrWithNegative]
 ): Optional<E> | ((array: readonly E[]) => Optional<E>) {
   switch (args.length) {
-    case 2: {
-      const [array, index] = args;
+    case 2:
+      return atImpl(...args);
 
-      return pipe(index < 0 ? array.length + index : index).map(
-        (normalizedIndex) =>
-          normalizedIndex < 0 || normalizedIndex >= array.length
-            ? Optional.none
-            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              Optional.some(array[normalizedIndex]!),
-      ).value;
-    }
-
-    case 1: {
-      const [index] = args;
-
-      return (array) => at(array, index);
-    }
+    case 1:
+      return (array) => atImpl(array, ...args);
   }
 }
 
+const atImpl = <E,>(
+  array: readonly E[],
+  index: SizeType.ArgArrWithNegative,
+): Optional<E> =>
+  pipe(index < 0 ? array.length + index : index).map((normalizedIndex) =>
+    normalizedIndex < 0 || normalizedIndex >= array.length
+      ? Optional.none
+      : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        Optional.some(array[normalizedIndex]!),
+  ).value;
+
 /**
  * Returns the first element of an array as an Optional.
  *

package/src/array/impl/array-utils-length-bounded-array-cast.mts

@@ -66,25 +66,28 @@ export function asFixedLengthArray<E>(
     | readonly [length: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [xs, length] = args;
+    case 2:
+      return asFixedLengthArrayImpl(...args);
 
-      if (!isFixedLengthArray(xs, length)) {
-        throw new TypeError(
-          `Expected an array of length ${length}, got an array of length ${xs.length}`,
-        );
-      }
-
-      return xs;
-    }
+    case 1:
+      return (xs) => asFixedLengthArrayImpl(xs, ...args);
+  }
+}
 
-    case 1: {
-      const [length] = args;
+const asFixedLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  length: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
 
-      return (xs) => asFixedLengthArray(xs, length);
-    }
+  if (!isFixedLengthArray(xs, length)) {
+    throw new TypeError(
+      `Expected an array of length ${length}, got an array of length ${actualLength}`,
+    );
   }
-}
+
+  return xs;
+};
 
 /**
  * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has
@@ -139,25 +142,28 @@ export function asMinLengthArray<E>(
     | readonly [minLength: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [xs, minLength] = args;
+    case 2:
+      return asMinLengthArrayImpl(...args);
 
-      if (!isMinLengthArray(xs, minLength)) {
-        throw new TypeError(
-          `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`,
-        );
-      }
-
-      return xs;
-    }
+    case 1:
+      return (xs) => asMinLengthArrayImpl(xs, ...args);
+  }
+}
 
-    case 1: {
-      const [minLength] = args;
+const asMinLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  minLength: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
 
-      return (xs) => asMinLengthArray(xs, minLength);
-    }
+  if (!isMinLengthArray(xs, minLength)) {
+    throw new TypeError(
+      `Expected an array of length >= ${minLength}, got an array of length ${actualLength}`,
+    );
   }
-}
+
+  return xs;
+};
 
 /**
  * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has
@@ -209,25 +215,28 @@ export function asMaxLengthArray<E>(
     | readonly [maxLength: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [xs, maxLength] = args;
+    case 2:
+      return asMaxLengthArrayImpl(...args);
 
-      if (!isMaxLengthArray(xs, maxLength)) {
-        throw new TypeError(
-          `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`,
-        );
-      }
-
-      return xs;
-    }
+    case 1:
+      return (xs) => asMaxLengthArrayImpl(xs, ...args);
+  }
+}
 
-    case 1: {
-      const [maxLength] = args;
+const asMaxLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  maxLength: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
 
-      return (xs) => asMaxLengthArray(xs, maxLength);
-    }
+  if (!isMaxLengthArray(xs, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`,
+    );
   }
-}
+
+  return xs;
+};
 
 /**
  * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after
@@ -298,25 +307,29 @@ export function asBoundedLengthArray<E>(
     | readonly [minLength: SupportedLength, maxLength: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 3: {
-      const [xs, minLength, maxLength] = args;
+    case 3:
+      return asBoundedLengthArrayImpl(...args);
 
-      if (!isBoundedLengthArray(xs, minLength, maxLength)) {
-        throw new TypeError(
-          `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`,
-        );
-      }
-
-      return xs;
-    }
+    case 2:
+      return (xs) => asBoundedLengthArrayImpl(xs, ...args);
+  }
+}
 
-    case 2: {
-      const [minLength, maxLength] = args;
+const asBoundedLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  minLength: SupportedLength,
+  maxLength: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
 
-      return (xs) => asBoundedLengthArray(xs, minLength, maxLength);
-    }
+  if (!isBoundedLengthArray(xs, minLength, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${actualLength}`,
+    );
   }
-}
+
+  return xs;
+};
 
 /**
  * Casts an array to `NonEmptyArray<E>` after checking that it has at least one

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

@@ -55,20 +55,20 @@ export function set<E, const V = E>(
     | readonly [index: SizeType.ArgArr, newValue: V]
 ): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {
   switch (args.length) {
-    case 3: {
-      const [array, index, newValue] = args;
+    case 3:
+      return setImpl(...args);
 
-      return (array as readonly (E | V)[]).with(index, newValue);
-    }
-
-    case 2: {
-      const [index, newValue] = args;
-
-      return (array) => set(array, index, newValue);
-    }
+    case 2:
+      return (array) => setImpl(array, ...args);
   }
 }
 
+const setImpl = <E, const V = E>(
+  array: readonly E[],
+  index: SizeType.ArgArr,
+  newValue: V,
+): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);
+
 /**
  * Returns a new array with an element at the specified index updated by applying a function.
  *
@@ -124,21 +124,22 @@ export function toUpdated<E, V = E>(
     | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]
 ): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {
   switch (args.length) {
-    case 3: {
-      const [array, index, updater] = args;
+    case 3:
+      return toUpdatedImpl(...args);
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      return (array as readonly (E | V)[]).with(index, updater(array[index]!));
-    }
-
-    case 2: {
-      const [index, updater] = args;
-
-      return (array) => toUpdated(array, index, updater);
-    }
+    case 2:
+      return (array) => toUpdatedImpl(array, ...args);
   }
 }
 
+const toUpdatedImpl = <E, V = E>(
+  array: readonly E[],
+  index: SizeType.ArgArr,
+  updater: (prev: E) => V,
+): readonly (E | V)[] =>
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  (array as readonly (E | V)[]).with(index, updater(array[index]!));
+
 /**
  * Returns a new array with a value inserted at the specified index.
  *
@@ -187,25 +188,26 @@ export function toInserted<E, const V = E>(
     | readonly [index: SizeType.ArgArrWithNegative, newValue: V]
 ): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {
   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,
-        0,
-        newValue,
-      ) as unknown as NonEmptyArray<E | V>;
-    }
-
-    case 2: {
-      const [index, newValue] = args;
-
-      return (array) => toInserted(array, index, newValue);
-    }
+    case 3:
+      return toInsertedImpl(...args);
+
+    case 2:
+      return (array) => toInsertedImpl(array, ...args);
   }
 }
 
+const toInsertedImpl = <E, const V = E>(
+  array: readonly E[],
+  index: SizeType.ArgArrWithNegative,
+  newValue: V,
+): NonEmptyArray<E | V> =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  (array as readonly (E | V)[]).toSpliced(
+    index,
+    0,
+    newValue,
+  ) as unknown as NonEmptyArray<E | V>;
+
 type CastToNumber<T> = T extends number ? T : never;
 
 /**
@@ -240,20 +242,19 @@ export function toRemoved<E>(
     | readonly [index: SizeType.ArgArrWithNegative]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, index] = args;
-
-      return array.toSpliced(index, 1);
-    }
+    case 2:
+      return toRemovedImpl(...args);
 
-    case 1: {
-      const [index] = args;
-
-      return (array) => toRemoved(array, index);
-    }
+    case 1:
+      return (array) => toRemovedImpl(array, ...args);
   }
 }
 
+const toRemovedImpl = <E,>(
+  array: readonly E[],
+  index: SizeType.ArgArrWithNegative,
+): readonly E[] => array.toSpliced(index, 1);
+
 /**
  * Returns a new array with a value appended to the end.
  *
@@ -291,24 +292,21 @@ export function toPushed<const Ar extends readonly unknown[], const V>(
   ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]
 ): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, 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;
+    case 2:
+      return toPushedImpl(...args);
 
-      return (array) => toPushed(array, newValue);
-    }
+    case 1:
+      return (array) => toPushedImpl(array, ...args);
   }
 }
 
+const toPushedImpl = <const Ar extends readonly unknown[], const V>(
+  array: Ar,
+  newValue: V,
+): readonly [...Ar, V] =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];
+
 /**
  * Returns a new array with a value prepended to the beginning.
  *
@@ -346,21 +344,21 @@ export function toUnshifted<Ar extends readonly unknown[], const V>(
   ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]
 ): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {
   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;
+    case 2:
+      return toUnshiftedImpl(...args);
 
-      return (array) => toUnshifted(array, newValue);
-    }
+    case 1:
+      return (array) => toUnshiftedImpl(array, ...args);
   }
 }
 
+const toUnshiftedImpl = <Ar extends readonly unknown[], const V>(
+  array: Ar,
+  newValue: V,
+): readonly [V, ...Ar] =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];
+
 /**
  * Returns a new array with all elements replaced by the specified value.
  *
@@ -402,20 +400,17 @@ export function toFilled<E>(
   ...args: readonly [array: readonly E[], value: E] | readonly [value: E]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, value] = args;
-
-      return create(asPositiveUint32(array.length), value);
-    }
-
-    case 1: {
-      const [value] = args;
+    case 2:
+      return toFilledImpl(...args);
 
-      return (array) => toFilled(array, value);
-    }
+    case 1:
+      return (array) => toFilledImpl(array, ...args);
   }
 }
 
+const toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>
+  create(asPositiveUint32(array.length), value);
+
 /**
  * Returns a new array with elements in the specified range replaced by the specified value.
  *
@@ -480,20 +475,27 @@ export function toRangeFilled<E, const V>(
       ]
 ): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {
   switch (args.length) {
-    case 3: {
-      const [array, value, [start, end]] = args;
+    case 3:
+      return toRangeFilledImpl(...args);
 
-      const mut_cp: (E | V)[] = castMutable(copy(array));
+    case 2:
+      return (array) => toRangeFilledImpl(array, ...args);
+  }
+}
 
-      mut_cp.fill(value, start, end);
+const toRangeFilledImpl = <E, const V>(
+  array: readonly E[],
+  value: V,
+  fillRange: readonly [
+    start: SizeType.ArgArrWithNegative,
+    end: SizeType.ArgArrWithNegative,
+  ],
+): readonly (E | V)[] => {
+  const [start, end] = fillRange;
 
-      return mut_cp;
-    }
+  const mut_cp: (E | V)[] = castMutable(copy(array));
 
-    case 2: {
-      const [value, fillRange] = args;
+  mut_cp.fill(value, start, end);
 
-      return (array) => toRangeFilled(array, value, fillRange);
-    }
-  }
-}
+  return mut_cp;
+};

package/src/array/impl/array-utils-reducing-value.mts

@@ -239,24 +239,24 @@ export function count<E>(
     | readonly [predicate: (value: E, index: SizeType.Arr) => boolean]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return array.reduce<Uint32>(
-        (acc, curr, index) =>
-          predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
-        asUint32(0),
-      );
-    }
+    case 2:
+      return countImpl(...args);
 
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => count(array, predicate);
-    }
+    case 1:
+      return (array) => countImpl(array, ...args);
   }
 }
 
+const countImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr) => boolean,
+): SizeType.Arr =>
+  array.reduce<Uint32>(
+    (acc, curr, index) =>
+      predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
+    asUint32(0),
+  );
+
 /**
  * Groups elements by a key and counts the elements in each group.
  *
@@ -295,29 +295,30 @@ export function countBy<E, G extends MapSetKeyType>(
     | readonly [grouper: (value: E, index: SizeType.Arr) => G]
 ): IMap<G, SizeType.Arr> | ((array: readonly E[]) => IMap<G, SizeType.Arr>) {
   switch (args.length) {
-    case 2: {
-      const [array, grouper] = args;
-
-      const mut_groups = new Map<G, SizeType.Arr>();
-
-      for (const [index, e] of array.entries()) {
-        const key = grouper(e, asUint32(index));
+    case 2:
+      return countByImpl(...args);
 
-        const curr = mut_groups.get(key) ?? 0;
+    case 1:
+      return (array) => countByImpl(array, ...args);
+  }
+}
 
-        mut_groups.set(key, asUint32(curr + 1));
-      }
+const countByImpl = <E, G extends MapSetKeyType>(
+  array: readonly E[],
+  grouper: (value: E, index: SizeType.Arr) => G,
+): IMap<G, SizeType.Arr> => {
+  const mut_groups = new Map<G, SizeType.Arr>();
 
-      return IMap.create(mut_groups);
-    }
+  for (const [index, e] of array.entries()) {
+    const key = grouper(e, asUint32(index));
 
-    case 1: {
-      const [grouper] = args;
+    const curr = mut_groups.get(key) ?? 0;
 
-      return (array) => countBy(array, grouper);
-    }
+    mut_groups.set(key, asUint32(curr + 1));
   }
-}
+
+  return IMap.create(mut_groups);
+};
 
 /**
  * Reduces an array to a single value from left to right.
@@ -379,23 +380,28 @@ export function foldl<E, P>(
       ]
 ): P | ((array: readonly E[]) => P) {
   switch (args.length) {
-    case 3: {
-      const [array, callbackfn, initialValue] = args;
-
-      return array.reduce(
-        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
-        initialValue,
-      );
-    }
+    case 3:
+      return foldlImpl(...args);
 
-    case 2: {
-      const [callbackfn, initialValue] = args;
-
-      return (array) => foldl(array, callbackfn, initialValue);
-    }
+    case 2:
+      return (array) => foldlImpl(array, ...args);
   }
 }
 
+const foldlImpl = <E, P>(
+  array: readonly E[],
+  callbackfn: (
+    previousValue: P,
+    currentValue: E,
+    currentIndex: SizeType.Arr,
+  ) => P,
+  initialValue: P,
+): P =>
+  array.reduce(
+    (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+    initialValue,
+  );
+
 /**
  * Reduces an array to a single value from right to left.
  *
@@ -456,23 +462,28 @@ export function foldr<E, P>(
       ]
 ): P | ((array: readonly E[]) => P) {
   switch (args.length) {
-    case 3: {
-      const [array, callbackfn, initialValue] = args;
-
-      return array.reduceRight(
-        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
-        initialValue,
-      );
-    }
-
-    case 2: {
-      const [callbackfn, initialValue] = args;
+    case 3:
+      return foldrImpl(...args);
 
-      return (array) => foldr(array, callbackfn, initialValue);
-    }
+    case 2:
+      return (array) => foldrImpl(array, ...args);
   }
 }
 
+const foldrImpl = <E, P>(
+  array: readonly E[],
+  callbackfn: (
+    previousValue: P,
+    currentValue: E,
+    currentIndex: SizeType.Arr,
+  ) => P,
+  initialValue: P,
+): P =>
+  array.reduceRight(
+    (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+    initialValue,
+  );
+
 /**
  * Calculates the sum of numbers in an array.
  *