ts-data-forge 9.0.0 → 9.0.1

package/dist/array/impl/array-utils-transformation.mjs

@@ -46,329 +46,187 @@ import { size } from './array-utils-size.mjs';
 import { isNonEmpty } from './array-utils-validation.mjs';
 
 function map(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, mapFn] = args;
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            return array.map(mapFn);
-        }
-        case 1: {
-            const [mapFn] = args;
-            return (array) => map(array, mapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, mapFn] = args;
+      return array.map(mapFn);
     }
+    case 1: {
+      const [mapFn] = args;
+      return (array) => map(array, mapFn);
+    }
+  }
 }
 function scan(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, reducer, init] = args;
-            const mut_result = castMutable(newArray(asPositiveUint32(array.length + 1), init));
-            let mut_acc = init;
-            for (const [index, value] of array.entries()) {
-                mut_acc = reducer(mut_acc, value, asUint32(index));
-                mut_result[index + 1] = mut_acc;
-            }
-            return mut_result;
-        }
-        case 2: {
-            const [reducer, init] = args;
-            return (array) => scan(array, reducer, init);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, reducer, init] = args;
+      const mut_result = castMutable(
+        newArray(asPositiveUint32(array.length + 1), init)
+      );
+      let mut_acc = init;
+      for (const [index, value] of array.entries()) {
+        mut_acc = reducer(mut_acc, value, asUint32(index));
+        mut_result[index + 1] = mut_acc;
+      }
+      return mut_result;
+    }
+    case 2: {
+      const [reducer, init] = args;
+      return (array) => scan(array, reducer, init);
     }
+  }
 }
-/**
- * Reverses an array.
- *
- * @example
- *
- * ```ts
- * const tuple = [1, 'two', true] as const;
- *
- * const reversed = Arr.toReversed(tuple);
- *
- * const expected = [true, 'two', 1] as const;
- *
- * assert.deepStrictEqual(reversed, expected);
- * ```
- */
-const toReversed = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-array.toReversed();
-/**
- * Sorts an array.
- *
- * @example
- *
- * ```ts
- * const numbers = [3, 1, 2] as const;
- *
- * const words = ['banana', 'apple', 'cherry'] as const;
- *
- * const ascendingNumbers = Arr.toSorted(numbers);
- *
- * const alphabetical = Arr.toSorted(words, (left, right) =>
- *   left.localeCompare(right),
- * );
- *
- * const expectedNumbers = [1, 2, 3] as const;
- *
- * const expectedWords = ['apple', 'banana', 'cherry'] as const;
- *
- * assert.deepStrictEqual(ascendingNumbers, expectedNumbers);
- *
- * assert.deepStrictEqual(alphabetical, expectedWords);
- * ```
- */
-const toSorted = (...[array, comparator]) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-array.toSorted(
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-comparator ??
+const toReversed = (array) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toReversed()
+);
+const toSorted = (...[array, comparator]) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSorted(
     // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    ((x, y) => x - y));
+    comparator ?? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ((x, y) => x - y)
+  )
+);
 function toSortedBy(array, comparatorValueMapper, comparator) {
-    return array.toSorted((x, y) => comparator === undefined
-        ? // This branch assumes V is number if comparator is undefined.
-            // The overloads should handle this, but explicit cast might be needed if V is not number.
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            comparatorValueMapper(x) -
-                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-                comparatorValueMapper(y)
-        : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
+  return array.toSorted(
+    (x, y) => comparator === void 0 ? (
+      // This branch assumes V is number if comparator is undefined.
+      // The overloads should handle this, but explicit cast might be needed if V is not number.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      comparatorValueMapper(x) - // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      comparatorValueMapper(y)
+    ) : comparator(comparatorValueMapper(x), comparatorValueMapper(y))
+  );
 }
 function filter(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            return array.filter((a, i) => predicate(a, asUint32(i)));
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => filter(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      return array.filter((a, i) => predicate(a, asUint32(i)));
+    }
+    case 1: {
+      const [predicate] = args;
+      return (array) => filter(array, predicate);
     }
+  }
 }
 function filterNot(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            return array.filter((a, i) => !predicate(a, asUint32(i)));
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => filterNot(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      return array.filter((a, i) => !predicate(a, asUint32(i)));
+    }
+    case 1: {
+      const [predicate] = args;
+      return (array) => filterNot(array, predicate);
     }
+  }
 }
-/**
- * Creates a new array with unique elements.
- *
- * @example
- *
- * ```ts
- * const letters = ['a', 'b', 'a', 'c', 'b'] as const;
- *
- * const uniqueLetters = Arr.uniq(letters);
- *
- * const expected = ['a', 'b', 'c'] as const;
- *
- * assert.deepStrictEqual(uniqueLetters, expected);
- * ```
- */
-const uniq = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Array.from(new Set(array));
-/**
- * Creates a new array with unique elements based on a mapped value.
- *
- * @example
- *
- * ```ts
- * const people = [
- *   { id: 1, name: 'Ada' },
- *   { id: 2, name: 'Brian' },
- *   { id: 1, name: 'Alan' },
- *   { id: 3, name: 'Grace' },
- * ] as const;
- *
- * const uniqueById = Arr.uniqBy(people, (person) => person.id);
- *
- * const expected = [
- *   { id: 1, name: 'Ada' },
- *   { id: 2, name: 'Brian' },
- *   { id: 3, name: 'Grace' },
- * ] as const;
- *
- * assert.deepStrictEqual(uniqueById, expected);
- * ```
- */
+const uniq = (array) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Array.from(new Set(array))
+);
 const uniqBy = (array, mapFn) => {
-    const mut_mappedValues = new Set();
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    return array.filter((val) => {
-        const mappedValue = mapFn(val);
-        if (mut_mappedValues.has(mappedValue))
-            return false;
-        mut_mappedValues.add(mappedValue);
-        return true;
-    });
+  const mut_mappedValues = /* @__PURE__ */ new Set();
+  return array.filter((val) => {
+    const mappedValue = mapFn(val);
+    if (mut_mappedValues.has(mappedValue)) return false;
+    mut_mappedValues.add(mappedValue);
+    return true;
+  });
 };
 function flat(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, depth] = args;
-            return array.flat(depth);
-        }
-        case 1: {
-            const [arrayOrDepth] = args;
-            if (typeof arrayOrDepth === 'number') {
-                const depth = arrayOrDepth;
-                return (array) => flat(array, depth);
-            }
-            if (arrayOrDepth === undefined) {
-                return (array) => flat(array, 1);
-            }
-            return arrayOrDepth.flat();
-        }
-        case 0:
-            return (array) => flat(array, 1);
+  switch (args.length) {
+    case 2: {
+      const [array, depth] = args;
+      return array.flat(depth);
+    }
+    case 1: {
+      const [arrayOrDepth] = args;
+      if (typeof arrayOrDepth === "number") {
+        const depth = arrayOrDepth;
+        return (array) => flat(array, depth);
+      }
+      if (arrayOrDepth === void 0) {
+        return (array) => flat(array, 1);
+      }
+      return arrayOrDepth.flat();
     }
+    case 0:
+      return (array) => flat(array, 1);
+  }
 }
 function flatMap(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, mapFn] = args;
-            return array.flatMap((a, i) => mapFn(a, asUint32(i)));
-        }
-        case 1: {
-            const [mapFn] = args;
-            return (array) => flatMap(array, mapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, mapFn] = args;
+      return array.flatMap((a, i) => mapFn(a, asUint32(i)));
+    }
+    case 1: {
+      const [mapFn] = args;
+      return (array) => flatMap(array, mapFn);
     }
+  }
 }
 function partition(...args) {
-    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) => array.slice(chunkSize * i, chunkSize * (i + 1)));
-        }
-        case 1: {
-            const [chunkSize] = args;
-            return (array) => partition(array, chunkSize);
-        }
+  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) => array.slice(chunkSize * i, chunkSize * (i + 1))
+        )
+      );
+    }
+    case 1: {
+      const [chunkSize] = args;
+      return (array) => partition(array, chunkSize);
     }
+  }
 }
-/**
- * Concatenates two arrays.
- *
- * @example
- *
- * ```ts
- * const numbers = [1, 2] as const;
- *
- * const words = ['three', 'four'] as const;
- *
- * const combined = Arr.concat(numbers, words);
- *
- * const expectedCombined = [1, 2, 'three', 'four'] as const;
- *
- * assert.deepStrictEqual(combined, expectedCombined);
- * ```
- */
 const concat = (array1, array2) => [...array1, ...array2];
 function groupBy(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, grouper] = args;
-            const mut_groups = new Map(); // Store mutable arrays internally
-            for (const [index, e] of array.entries()) {
-                const key = grouper(e, asUint32(index)); // Ensure index is treated as SizeType.Arr
-                const mut_group = mut_groups.get(key);
-                if (mut_group !== undefined) {
-                    mut_group.push(e);
-                }
-                else {
-                    mut_groups.set(key, [e]);
-                }
-            }
-            // Cast to IMap<G, readonly A[]> for the public interface
-            return IMap.create(mut_groups);
-        }
-        case 1: {
-            const [grouper] = args;
-            return (array) => groupBy(array, grouper);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, grouper] = args;
+      const mut_groups = /* @__PURE__ */ new Map();
+      for (const [index, e] of array.entries()) {
+        const key = grouper(e, asUint32(index));
+        const mut_group = mut_groups.get(key);
+        if (mut_group !== void 0) {
+          mut_group.push(e);
+        } else {
+          mut_groups.set(key, [e]);
+        }
+      }
+      return IMap.create(mut_groups);
+    }
+    case 1: {
+      const [grouper] = args;
+      return (array) => groupBy(array, grouper);
     }
+  }
 }
-/**
- * Creates an array of tuples by pairing corresponding elements from two arrays.
- *
- * @example
- *
- * ```ts
- * const letters = ['a', 'b', 'c'] as const;
- *
- * const numbers = [1, 2, 3] as const;
- *
- * const pairs = Arr.zip(letters, numbers);
- *
- * const expectedPairs = [
- *   ['a', 1],
- *   ['b', 2],
- *   ['c', 3],
- * ] as const;
- *
- * assert.deepStrictEqual(pairs, expectedPairs);
- * ```
- */
-const zip = (array1, array2) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-seq(Uint32.min(size(array1), size(array2))).map((i) => 
-// Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.
-// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-tp(array1[i], array2[i]));
-/**
- * Alias for `partition`.
- *
- * @see {@link partition}
- */
+const zip = (array1, array2) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  seq(Uint32.min(size(array1), size(array2))).map(
+    (i) => (
+      // Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      tp(array1[i], array2[i])
+    )
+  )
+);
 const chunk = partition;
-/**
- * Computes the cartesian product of arrays.
- * cartesianProduct([[1,2], [3,4]]) => [[1,3], [1,4], [2,3], [2,4]]
- *
- * @example
- *
- *
- * ```ts
- * const sizes = ['S', 'M'] as const;
- *
- * const colors = ['red', 'blue'] as const;
- *
- * const combinations = Arr.cartesianProduct([sizes, colors]);
- *
- * const expectedCombinations = [
- *   ['S', 'red'],
- *   ['S', 'blue'],
- *   ['M', 'red'],
- *   ['M', 'blue'],
- * ] as const;
- *
- * assert.deepStrictEqual(combinations, expectedCombinations);
- * ```
- */
 const cartesianProduct = (arrays) => {
-    if (!isNonEmpty(arrays))
-        return [[]];
-    const [first, ...rest] = arrays;
-    // If first array is empty, the result is empty
-    if (!isNonEmpty(first))
-        return [];
-    const restProduct = cartesianProduct(rest);
-    return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));
+  if (!isNonEmpty(arrays)) return [[]];
+  const [first, ...rest] = arrays;
+  if (!isNonEmpty(first)) return [];
+  const restProduct = cartesianProduct(rest);
+  return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));
 };
 
 export { cartesianProduct, chunk, concat, filter, filterNot, flat, flatMap, groupBy, map, partition, scan, toReversed, toSorted, toSortedBy, uniq, uniqBy, zip };

package/dist/array/impl/array-utils-transformation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":["import {\n  type ArrayOfLength,\n  type IsFixedLengthList,\n  type List,\n  type MutableNonEmptyArray,\n  type NonEmptyArray,\n  type PositiveInt,\n  type PositiveUint32,\n  type Primitive,\n  type SafeUintWithSmallInt,\n  type WithSmallInt,\n} from 'ts-type-forge';\nimport { IMap } from '../../collections/index.mjs';\nimport { expectType } from '../../expect-type.mjs';\nimport { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';\nimport { castMutable, tp } from '../../others/index.mjs';\nimport {\n  type ArrayIndex,\n  type MapSetKeyType,\n  type SizeType,\n} from '../../types.mjs';\nimport { newArray, seq } from './array-utils-creation.mjs';\nimport { size } from './array-utils-size.mjs';\nimport { isNonEmpty } from './array-utils-validation.mjs';\n\n/**\n * Creates a new array by transforming each element with a mapping function.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const doubled = Arr.map(numbers, (value) => value * 2);\n *\n * const indexed = Arr.map<number, string>(\n *   (value, index) => `${index}:${value}`,\n * )(numbers);\n *\n * assert.deepStrictEqual(doubled, [2, 4, 6]);\n *\n * assert.deepStrictEqual(indexed, ['0:1', '1:2', '2:3']);\n * ```\n */\nexport function map<const Ar extends readonly unknown[], B>(\n  array: Ar,\n  mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B,\n): Readonly<{ [K in keyof Ar]: B }>;\n\n// curried version\nexport function map<A, B>(\n  mapFn: (a: A, index: SizeType.Arr) => B,\n): <const Ar extends readonly A[]>(\n  array: Ar,\n) => Readonly<{ [K in keyof Ar]: B }>;\n\nexport function map<A, B>(\n  ...args:\n    | readonly [array: readonly A[], mapFn: (a: A, index: SizeType.Arr) => B]\n    | readonly [mapFn: (a: A, index: SizeType.Arr) => B]\n): readonly B[] | ((array: readonly A[]) => readonly B[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, mapFn] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.map(mapFn as never);\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (array: readonly A[]) => map(array, mapFn);\n    }\n  }\n}\n\n/**\n * Returns an array of successively reduced values from an array.\n *\n * @example\n *\n * ```ts\n * const changes = [5, -2, 3] as const;\n *\n * const runningTotals = Arr.scan(\n *   changes,\n *   (total, change) => total + change,\n *   0,\n * );\n *\n * const runningTotalsFromCurried = Arr.scan(\n *   (total: number, change: number) => total + change,\n *   10,\n * )([-5, 15]);\n *\n * const expectedTotals = [0, 5, 3, 6] as const;\n *\n * const expectedCurriedTotals = [10, 5, 20] as const;\n *\n * assert.deepStrictEqual(runningTotals, expectedTotals);\n *\n * assert.deepStrictEqual(runningTotalsFromCurried, expectedCurriedTotals);\n * ```\n */\nexport function scan<const Ar extends readonly unknown[], S>(\n  array: Ar,\n  reducer: (\n    accumulator: S,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => S,\n  init: S,\n): NonEmptyArray<S>;\n\nexport function scan<E, S>(\n  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,\n  init: S,\n): (array: readonly E[]) => NonEmptyArray<S>;\n\nexport function scan<E, S>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        reducer: (\n          accumulator: S,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => S,\n        init: S,\n      ]\n    | readonly [\n        reducer: (\n          accumulator: S,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => S,\n        init: S,\n      ]\n): NonEmptyArray<S> | ((array: readonly E[]) => NonEmptyArray<S>) {\n  switch (args.length) {\n    case 3: {\n      const [array, reducer, init] = args;\n\n      const mut_result: MutableNonEmptyArray<S> = castMutable(\n        newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),\n      );\n\n      let mut_acc = init;\n\n      for (const [index, value] of array.entries()) {\n        mut_acc = reducer(mut_acc, value, asUint32(index));\n\n        mut_result[index + 1] = mut_acc;\n      }\n\n      return mut_result;\n    }\n\n    case 2: {\n      const [reducer, init] = args;\n\n      return (array) => scan(array, reducer, init);\n    }\n  }\n}\n\n/**\n * Reverses an array.\n *\n * @example\n *\n * ```ts\n * const tuple = [1, 'two', true] as const;\n *\n * const reversed = Arr.toReversed(tuple);\n *\n * const expected = [true, 'two', 1] as const;\n *\n * assert.deepStrictEqual(reversed, expected);\n * ```\n */\nexport const toReversed = <const Ar extends readonly unknown[]>(\n  array: Ar,\n): List.Reverse<Ar> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toReversed() as never;\n\n/**\n * Sorts an array.\n *\n * @example\n *\n * ```ts\n * const numbers = [3, 1, 2] as const;\n *\n * const words = ['banana', 'apple', 'cherry'] as const;\n *\n * const ascendingNumbers = Arr.toSorted(numbers);\n *\n * const alphabetical = Arr.toSorted(words, (left, right) =>\n *   left.localeCompare(right),\n * );\n *\n * const expectedNumbers = [1, 2, 3] as const;\n *\n * const expectedWords = ['apple', 'banana', 'cherry'] as const;\n *\n * assert.deepStrictEqual(ascendingNumbers, expectedNumbers);\n *\n * assert.deepStrictEqual(alphabetical, expectedWords);\n * ```\n */\nexport const toSorted = <const Ar extends readonly unknown[]>(\n  ...[array, comparator]: Ar extends readonly number[]\n    ? readonly [\n        array: Ar,\n        // If the array elements are mapped to numbers, comparator is optional.\n        comparator?: (x: Ar[number], y: Ar[number]) => number,\n      ]\n    : readonly [array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number]\n): IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSorted(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (comparator as ((x: unknown, y: unknown) => number) | undefined) ??\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ((x, y) => (x as number) - (y as number)),\n  ) as never;\n\n/**\n * Sorts an array by a mapped value.\n *\n * @example\n *\n * ```ts\n * const projects = [\n *   { name: 'compiler', issues: 7 },\n *   { name: 'docs', issues: 2 },\n *   { name: 'ui', issues: 5 },\n * ] as const;\n *\n * const byIssueCount = Arr.toSortedBy(projects, (project) => project.issues);\n *\n * const byIssueCountDescending = Arr.toSortedBy(\n *   projects,\n *   (project) => project.issues,\n *   (left, right) => right - left,\n * );\n *\n * const expectedByIssues = [\n *   { name: 'docs', issues: 2 },\n *   { name: 'ui', issues: 5 },\n *   { name: 'compiler', issues: 7 },\n * ] as const;\n *\n * const expectedByIssueCountDescending = [\n *   { name: 'compiler', issues: 7 },\n *   { name: 'ui', issues: 5 },\n *   { name: 'docs', issues: 2 },\n * ] as const;\n *\n * assert.deepStrictEqual(byIssueCount, expectedByIssues);\n *\n * assert.deepStrictEqual(\n *   byIssueCountDescending,\n *   expectedByIssueCountDescending,\n * );\n * ```\n */\nexport function toSortedBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => number,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparator?: (x: number, y: number) => number,\n): IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][];\n\nexport function toSortedBy<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][];\n\nexport function toSortedBy<E, const V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): readonly E[] {\n  return array.toSorted((x, y) =>\n    comparator === undefined\n      ? // This branch assumes V is number if comparator is undefined.\n        // The overloads should handle this, but explicit cast might be needed if V is not number.\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (comparatorValueMapper(x) as number) -\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (comparatorValueMapper(y) as number)\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Filters an array based on a predicate function.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3, 4] as const;\n *\n * const evens = Arr.filter(numbers, (value) => value % 2 === 0);\n *\n * const greaterThanTwo = Arr.filter<number>((value) => value > 2)(numbers);\n *\n * assert.deepStrictEqual(evens, [2, 4]);\n *\n * assert.deepStrictEqual(greaterThanTwo, [3, 4]);\n * ```\n */\n// Type guard overloads\nexport function filter<\n  const Ar extends readonly unknown[],\n  S extends Ar[number],\n>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,\n): readonly S[];\n\nexport function filter<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => readonly S[];\n\n// Regular boolean predicate overloads\nexport function filter<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): readonly Ar[number][];\n\nexport function filter<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => readonly E[];\n\nexport function filter<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.filter((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => filter(array, predicate);\n    }\n  }\n}\n\n/**\n * Filters an array by excluding elements for which the predicate returns true.\n *\n * @example\n *\n * ```ts\n * const names = ['Ada', 'Grace', 'Linus'] as const;\n *\n * const notAda = Arr.filterNot(names, (name) => name === 'Ada');\n *\n * const notShort = Arr.filterNot<string>((name) => name.length <= 4)(names);\n *\n * assert.deepStrictEqual(notAda, ['Grace', 'Linus']);\n *\n * assert.deepStrictEqual(notShort, ['Grace', 'Linus']);\n * ```\n */\nexport function filterNot<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): readonly Ar[number][];\n\nexport function filterNot<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => readonly E[];\n\nexport function filterNot<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.filter((a, i) => !predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => filterNot(array, predicate);\n    }\n  }\n}\n\n/**\n * Creates a new array with unique elements.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'a', 'c', 'b'] as const;\n *\n * const uniqueLetters = Arr.uniq(letters);\n *\n * const expected = ['a', 'b', 'c'] as const;\n *\n * assert.deepStrictEqual(uniqueLetters, expected);\n * ```\n */\nexport const uniq = <const Ar extends readonly Primitive[]>(\n  array: Ar,\n): Ar extends NonEmptyArray<unknown>\n  ? NonEmptyArray<Ar[number]>\n  : readonly Ar[number][] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Array.from(new Set(array)) as never;\n\n/**\n * Creates a new array with unique elements based on a mapped value.\n *\n * @example\n *\n * ```ts\n * const people = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Brian' },\n *   { id: 1, name: 'Alan' },\n *   { id: 3, name: 'Grace' },\n * ] as const;\n *\n * const uniqueById = Arr.uniqBy(people, (person) => person.id);\n *\n * const expected = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Brian' },\n *   { id: 3, name: 'Grace' },\n * ] as const;\n *\n * assert.deepStrictEqual(uniqueById, expected);\n * ```\n */\nexport const uniqBy = <\n  const Ar extends readonly unknown[],\n  P extends Primitive,\n>(\n  array: Ar,\n  mapFn: (value: Ar[number]) => P,\n): Ar extends NonEmptyArray<unknown>\n  ? NonEmptyArray<Ar[number]>\n  : readonly Ar[number][] => {\n  const mut_mappedValues = new Set<P>();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return array.filter((val) => {\n    const mappedValue = mapFn(val);\n\n    if (mut_mappedValues.has(mappedValue)) return false;\n\n    mut_mappedValues.add(mappedValue);\n\n    return true;\n  }) satisfies readonly Ar[number][] as never;\n};\n\n/**\n * Flattens nested arrays up to the specified depth.\n *\n * @example\n *\n * ```ts\n * const nested = [\n *   [1, 2],\n *   [3, 4],\n * ] as const;\n *\n * const flatOnce = Arr.flat(nested, 1);\n *\n * const flatCurried = Arr.flat()(nested);\n *\n * assert.deepStrictEqual(flatOnce, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(flatCurried, [1, 2, 3, 4]);\n * ```\n */\nexport function flat<\n  const Ar extends readonly unknown[],\n  D extends SafeUintWithSmallInt = 1,\n>(array: Ar, depth?: D): readonly FlatArray<Ar, D>[];\n\nexport function flat<D extends SafeUintWithSmallInt = 1>(\n  depth?: number,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly FlatArray<Ar, D>[];\n\nexport function flat<E, D extends SafeUintWithSmallInt = 1>(\n  ...args: readonly [array: readonly E[], depth?: D] | readonly [depth?: D]\n): readonly unknown[] | ((array: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, depth] = args;\n\n      return array.flat(depth);\n    }\n\n    case 1: {\n      const [arrayOrDepth] = args;\n\n      if (typeof arrayOrDepth === 'number') {\n        const depth = arrayOrDepth as SafeUintWithSmallInt | undefined;\n\n        return (array) => flat(array, depth);\n      }\n\n      if (arrayOrDepth === undefined) {\n        return (array) => flat(array, 1);\n      }\n\n      expectType<typeof arrayOrDepth, readonly E[]>('=');\n\n      return arrayOrDepth.flat();\n    }\n\n    case 0:\n      return (array) => flat(array, 1);\n  }\n}\n\n/**\n * Maps each element and flattens the result.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'AI'] as const;\n *\n * const characters = Arr.flatMap(words, (word) => word.split(''));\n *\n * const labeled = Arr.flatMap<string, string>((word, index) =>\n *   word.split('').map((char) => `${index}-${char}`),\n * )(words);\n *\n * assert.deepStrictEqual(characters, ['A', 'd', 'a', 'A', 'I']);\n *\n * assert.deepStrictEqual(labeled, ['0-A', '0-d', '0-a', '1-A', '1-I']);\n * ```\n */\nexport function flatMap<const Ar extends readonly unknown[], B>(\n  array: Ar,\n  mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => readonly B[],\n): readonly B[];\n\nexport function flatMap<A, B>(\n  mapFn: (a: A, index: SizeType.Arr) => readonly B[],\n): (array: readonly A[]) => readonly B[];\n\nexport function flatMap<A, B>(\n  ...args:\n    | readonly [\n        array: readonly A[],\n        mapFn: (a: A, index: SizeType.Arr) => readonly B[],\n      ]\n    | readonly [mapFn: (a: A, index: SizeType.Arr) => readonly B[]]\n): readonly B[] | ((array: readonly A[]) => readonly B[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, mapFn] = args;\n\n      return array.flatMap((a, i) => mapFn(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (array: readonly A[]) => flatMap(array, mapFn);\n    }\n  }\n}\n\n/**\n * Partitions an array into sub-arrays of a specified size.\n *\n * @example\n *\n * ```ts\n * const values = [1, 2, 3, 4, 5] as const;\n *\n * const pairs = Arr.partition(values, 2);\n *\n * const triples = Arr.partition(3)(values);\n *\n * const expectedPairs = [[1, 2], [3, 4], [5]] as const;\n *\n * assert.deepStrictEqual(pairs, expectedPairs);\n *\n * assert.deepStrictEqual(triples, [\n *   [1, 2, 3],\n *   [4, 5],\n * ]);\n *\n * const pairs2 = Arr.chunk([1, 2, 3, 4, 5, 6], 2);\n *\n * assert.deepStrictEqual(pairs2, [\n *   [1, 2],\n *   [3, 4],\n *   [5, 6],\n * ]);\n * ```\n */\nexport function partition<\n  N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n  E,\n>(array: readonly E[], chunkSize: N): readonly (readonly E[])[];\n\nexport function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n  chunkSize: N,\n): <E>(array: readonly E[]) => readonly (readonly E[])[];\n\nexport function partition<\n  N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n  E,\n>(\n  ...args:\n    readonly [array: readonly E[], chunkSize: N] | readonly [chunkSize: N]\n):\n  | readonly (readonly E[])[]\n  | ((array: readonly E[]) => readonly (readonly E[])[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, chunkSize] = args;\n\n      return chunkSize < 2\n        ? []\n        : // eslint-disable-next-line total-functions/no-partial-division\n          seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>\n            array.slice(chunkSize * i, chunkSize * (i + 1)),\n          );\n    }\n\n    case 1: {\n      const [chunkSize] = args;\n\n      return (array) => partition(array, chunkSize);\n    }\n  }\n}\n\n/**\n * Concatenates two arrays.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2] as const;\n *\n * const words = ['three', 'four'] as const;\n *\n * const combined = Arr.concat(numbers, words);\n *\n * const expectedCombined = [1, 2, 'three', 'four'] as const;\n *\n * assert.deepStrictEqual(combined, expectedCombined);\n * ```\n */\nexport const concat = <\n  const Ar1 extends readonly unknown[],\n  const Ar2 extends readonly unknown[],\n>(\n  array1: Ar1,\n  array2: Ar2,\n): readonly [...Ar1, ...Ar2] => [...array1, ...array2] as const;\n\n/**\n * Groups elements by a key derived from each element.\n *\n * @example\n *\n * ```ts\n * const animals = ['ant', 'bat', 'cat', 'dove'] as const;\n *\n * const groupedByLength = Arr.groupBy(animals, (animal) => animal.length);\n *\n * const groupedByFirstLetter = Arr.groupBy((animal: string) => animal.at(0))(\n *   animals,\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByLength.get(3),\n *   Optional.some(['ant', 'bat', 'cat'] as const),\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByLength.get(4),\n *   Optional.some(['dove'] as const),\n * );\n *\n * assert.deepStrictEqual(groupedByLength.get(5), Optional.none);\n *\n * assert.deepStrictEqual(\n *   groupedByFirstLetter.get('a'),\n *   Optional.some(['ant'] as const),\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByFirstLetter.get('d'),\n *   Optional.some(['dove'] as const),\n * );\n * ```\n */\nexport function groupBy<\n  const Ar extends readonly unknown[],\n  G extends MapSetKeyType,\n>(\n  array: Ar,\n  grouper: (value: Ar[number], index: ArrayIndex<Ar>) => G,\n): IMap<G, readonly Ar[number][]>;\n\nexport function groupBy<E, G extends MapSetKeyType>(\n  grouper: (value: E, index: SizeType.Arr) => G,\n): (array: readonly E[]) => IMap<G, readonly E[]>;\n\nexport function groupBy<E, G extends MapSetKeyType>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        grouper: (value: E, index: SizeType.Arr) => G,\n      ]\n    | readonly [grouper: (value: E, index: SizeType.Arr) => G]\n): IMap<G, readonly E[]> | ((array: readonly E[]) => IMap<G, readonly E[]>) {\n  switch (args.length) {\n    case 2: {\n      const [array, grouper] = args;\n\n      const mut_groups = new Map<G, E[]>(); // Store mutable arrays internally\n\n      for (const [index, e] of array.entries()) {\n        const key = grouper(e, asUint32(index)); // Ensure index is treated as SizeType.Arr\n\n        const mut_group = mut_groups.get(key);\n\n        if (mut_group !== undefined) {\n          mut_group.push(e);\n        } else {\n          mut_groups.set(key, [e]);\n        }\n      }\n\n      // Cast to IMap<G, readonly A[]> for the public interface\n      return IMap.create<G, readonly E[]>(mut_groups);\n    }\n\n    case 1: {\n      const [grouper] = args;\n\n      return (array: readonly E[]) => groupBy(array, grouper);\n    }\n  }\n}\n\n/**\n * Creates an array of tuples by pairing corresponding elements from two arrays.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c'] as const;\n *\n * const numbers = [1, 2, 3] as const;\n *\n * const pairs = Arr.zip(letters, numbers);\n *\n * const expectedPairs = [\n *   ['a', 1],\n *   ['b', 2],\n *   ['c', 3],\n * ] as const;\n *\n * assert.deepStrictEqual(pairs, expectedPairs);\n * ```\n */\nexport const zip = <\n  const Ar1 extends readonly unknown[],\n  const Ar2 extends readonly unknown[],\n>(\n  array1: Ar1,\n  array2: Ar2,\n): List.Zip<Ar1, Ar2> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  seq(Uint32.min(size(array1), size(array2))).map((i: Uint32) =>\n    // Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    tp(array1[i]!, array2[i]!),\n  ) as unknown as List.Zip<Ar1, Ar2>;\n\n/**\n * Alias for `partition`.\n *\n * @see {@link partition}\n */\nexport const chunk = partition;\n\n/**\n * Computes the cartesian product of arrays.\n * cartesianProduct([[1,2], [3,4]]) => [[1,3], [1,4], [2,3], [2,4]]\n *\n * @example\n *\n *\n * ```ts\n * const sizes = ['S', 'M'] as const;\n *\n * const colors = ['red', 'blue'] as const;\n *\n * const combinations = Arr.cartesianProduct([sizes, colors]);\n *\n * const expectedCombinations = [\n *   ['S', 'red'],\n *   ['S', 'blue'],\n *   ['M', 'red'],\n *   ['M', 'blue'],\n * ] as const;\n *\n * assert.deepStrictEqual(combinations, expectedCombinations);\n * ```\n */\nexport const cartesianProduct = <T,>(\n  arrays: readonly (readonly T[])[],\n): readonly (readonly T[])[] => {\n  if (!isNonEmpty(arrays)) return [[]];\n\n  const [first, ...rest] = arrays;\n\n  // If first array is empty, the result is empty\n  if (!isNonEmpty(first)) return [];\n\n  const restProduct = cartesianProduct(rest);\n\n  return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));\n};\n"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-validation.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"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"}