ts-data-forge 12.2.1 → 12.2.2

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":["import {\n  type FixedLengthTuple,\n  type Increment,\n  type IsFixedLengthList,\n  type NonEmptyArray,\n  type NonEmptyTuple,\n} from 'ts-type-forge';\nimport { asPositiveUint32 } from '../../number/index.mjs';\nimport { castMutable } from '../../others/index.mjs';\nimport {\n  type ArgArrayIndex,\n  type ArgArrayIndexWithNegative,\n  type SizeType,\n} from '../../types.mjs';\nimport { copy, create } from './array-utils-creation.mjs';\n\n/**\n * Returns a new array with an element at the specified index replaced.\n *\n * @example\n *\n * ```ts\n * const scores: readonly number[] = [10, 20, 30] as const;\n *\n * const updated = Arr.set(scores, 1, 25);\n *\n * assert.deepStrictEqual(updated, [10, 25, 30]);\n * ```\n */\nexport function set<const Ar extends readonly unknown[], const V = Ar[number]>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function set<const V>(\n  index: SizeType.ArgArr,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function set<E, const V = E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n    | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3: {\n      const [array, index, newValue] = args;\n\n      return (array as readonly (E | V)[]).with(index, newValue);\n    }\n\n    case 2: {\n      const [index, newValue] = args;\n\n      return (array) => set(array, index, newValue);\n    }\n  }\n}\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<number>(\n *   2,\n *   (value) => value + 1,\n * )(temperatures);\n *\n * assert.deepStrictEqual(increased, [20, 26, 22]);\n *\n * assert.deepStrictEqual(incrementLast, [20, 21, 23]);\n * ```\n */\nexport function toUpdated<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  updater: (prev: Ar[number]) => V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function toUpdated<E, const V = E>(\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function toUpdated<E, V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArr,\n        updater: (prev: E) => V,\n      ]\n    | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3: {\n      const [array, index, updater] = args;\n\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return (array as readonly (E | V)[]).with(index, updater(array[index]!));\n    }\n\n    case 2: {\n      const [index, updater] = args;\n\n      return (array) => toUpdated(array, index, updater);\n    }\n  }\n}\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArrWithNegative,\n        newValue: V,\n      ]\n    | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n  switch (args.length) {\n    case 3: {\n      const [array, index, newValue] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return (array as readonly (E | V)[]).toSpliced(\n        index,\n        0,\n        newValue,\n      ) as unknown as NonEmptyArray<E | V>;\n    }\n\n    case 2: {\n      const [index, newValue] = args;\n\n      return (array) => toInserted(array, index, newValue);\n    }\n  }\n}\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n  index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n    | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, index] = args;\n\n      return array.toSpliced(index, 1);\n    }\n\n    case 1: {\n      const [index] = args;\n\n      return (array) => toRemoved(array, index);\n    }\n  }\n}\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = appended;\n *\n * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n  switch (args.length) {\n    case 2: {\n      const [array, newValue] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.toSpliced(array.length, 0, newValue) as unknown as readonly [\n        ...Ar,\n        V,\n      ];\n    }\n\n    case 1: {\n      const [newValue] = args;\n\n      return (array) => toPushed(array, newValue);\n    }\n  }\n}\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = prefixed;\n *\n * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n  switch (args.length) {\n    case 2: {\n      const [array, newValue] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n    }\n\n    case 1: {\n      const [newValue] = args;\n\n      return (array) => toUnshifted(array, newValue);\n    }\n  }\n}\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\n// curried version\nexport function toFilled<const V>(\n  value: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\nexport function toFilled<E>(\n  ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, value] = args;\n\n      return create(asPositiveUint32(array.length), value);\n    }\n\n    case 1: {\n      const [value] = args;\n\n      return (array) => toFilled(array, value);\n    }\n  }\n}\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n  fillRange: readonly [\n    start: ArgArrayIndexWithNegative<Ar>,\n    end: ArgArrayIndexWithNegative<Ar>,\n  ],\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\n// curried version\nexport function toRangeFilled<const V>(\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\nexport function toRangeFilled<E, const V>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n    | readonly [\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3: {\n      const [array, value, [start, end]] = args;\n\n      const mut_cp: (E | V)[] = castMutable(copy(array));\n\n      mut_cp.fill(value, start, end);\n\n      return mut_cp;\n    }\n\n    case 2: {\n      const [value, fillRange] = args;\n\n      return (array) => toRangeFilled(array, value, fillRange);\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDO,SAAS,OACX,IAAA,EAGiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAEjC,MAAA,OAAQ,KAAA,CAA6B,IAAA,CAAK,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC3D;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,CAAC,KAAA,KAAU,GAAA,CAAI,KAAA,EAAO,OAAO,QAAQ,CAAA;AAAA,IAC9C;AAAA;AAEJ;AA+CO,SAAS,aACX,IAAA,EAOiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAA,EAAO,OAAO,CAAA,GAAI,IAAA;AAGhC,MAAA,OAAQ,MAA6B,IAAA,CAAK,KAAA,EAAO,QAAQ,KAAA,CAAM,KAAK,CAAE,CAAC,CAAA;AAAA,IACzE;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,OAAO,CAAA,GAAI,IAAA;AAEzB,MAAA,OAAO,CAAC,KAAA,KAAU,SAAA,CAAU,KAAA,EAAO,OAAO,OAAO,CAAA;AAAA,IACnD;AAAA;AAEJ;AAwCO,SAAS,cACX,IAAA,EAOqE;AACxE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAGjC,MAAA,OAAQ,KAAA,CAA6B,SAAA;AAAA,QACnC,KAAA;AAAA,QACA,CAAA;AAAA,QACA;AAAA,OACF;AAAA,IACF;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,CAAC,KAAA,KAAU,UAAA,CAAW,KAAA,EAAO,OAAO,QAAQ,CAAA;AAAA,IACrD;AAAA;AAEJ;AA8BO,SAAS,aACX,IAAA,EAGqD;AACxD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAK,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,KAAA,CAAM,SAAA,CAAU,KAAA,EAAO,CAAC,CAAA;AAAA,IACjC;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,KAAA,KAAU,SAAA,CAAU,KAAA,EAAO,KAAK,CAAA;AAAA,IAC1C;AAAA;AAEJ;AAmCO,SAAS,YACX,IAAA,EACyD;AAC5D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAG1B,MAAA,OAAO,KAAA,CAAM,SAAA,CAAU,KAAA,CAAM,MAAA,EAAQ,GAAG,QAAQ,CAAA;AAAA,IAIlD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAQ,CAAA,GAAI,IAAA;AAEnB,MAAA,OAAO,CAAC,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC5C;AAAA;AAEJ;AAmCO,SAAS,eACX,IAAA,EACyD;AAC5D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAG1B,MAAA,OAAO,KAAA,CAAM,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,QAAQ,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAQ,CAAA,GAAI,IAAA;AAEnB,MAAA,OAAO,CAAC,KAAA,KAAU,WAAA,CAAY,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC/C;AAAA;AAEJ;AAuCO,SAAS,YACX,IAAA,EACqD;AACxD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAK,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,MAAA,CAAO,gBAAA,CAAiB,KAAA,CAAM,MAAM,GAAG,KAAK,CAAA;AAAA,IACrD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,KAAK,CAAA;AAAA,IACzC;AAAA;AAEJ;AA+CO,SAAS,iBACX,IAAA,EAgBiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAA,EAAO,CAAC,KAAA,EAAO,GAAG,CAAC,CAAA,GAAI,IAAA;AAErC,MAAA,MAAM,MAAA,GAAoB,WAAA,CAAY,IAAA,CAAK,KAAK,CAAC,CAAA;AAEjD,MAAA,MAAA,CAAO,IAAA,CAAK,KAAA,EAAO,KAAA,EAAO,GAAG,CAAA;AAE7B,MAAA,OAAO,MAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,CAAC,KAAA,KAAU,aAAA,CAAc,KAAA,EAAO,OAAO,SAAS,CAAA;AAAA,IACzD;AAAA;AAEJ;;;;"}
+{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":["import {\n  type FixedLengthTuple,\n  type Increment,\n  type IsFixedLengthList,\n  type NonEmptyArray,\n  type NonEmptyTuple,\n} from 'ts-type-forge';\nimport { asPositiveUint32 } from '../../number/index.mjs';\nimport { castMutable } from '../../others/index.mjs';\nimport {\n  type ArgArrayIndex,\n  type ArgArrayIndexWithNegative,\n  type SizeType,\n} from '../../types.mjs';\nimport { copy, create } from './array-utils-creation.mjs';\n\n/**\n * Returns a new array with an element at the specified index replaced.\n *\n * @example\n *\n * ```ts\n * const scores: readonly number[] = [10, 20, 30] as const;\n *\n * const updated = Arr.set(scores, 1, 25);\n *\n * assert.deepStrictEqual(updated, [10, 25, 30]);\n * ```\n */\nexport function set<const Ar extends readonly unknown[], const V = Ar[number]>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function set<const V>(\n  index: SizeType.ArgArr,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function set<E, const V = E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n    | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return setImpl(...args);\n\n    case 2:\n      return (array) => setImpl(array, ...args);\n  }\n}\n\nconst setImpl = <E, const V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n  newValue: V,\n): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<number>(\n *   2,\n *   (value) => value + 1,\n * )(temperatures);\n *\n * assert.deepStrictEqual(increased, [20, 26, 22]);\n *\n * assert.deepStrictEqual(incrementLast, [20, 21, 23]);\n * ```\n */\nexport function toUpdated<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  updater: (prev: Ar[number]) => V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function toUpdated<E, const V = E>(\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function toUpdated<E, V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArr,\n        updater: (prev: E) => V,\n      ]\n    | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return toUpdatedImpl(...args);\n\n    case 2:\n      return (array) => toUpdatedImpl(array, ...args);\n  }\n}\n\nconst toUpdatedImpl = <E, V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): readonly (E | V)[] =>\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  (array as readonly (E | V)[]).with(index, updater(array[index]!));\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArrWithNegative,\n        newValue: V,\n      ]\n    | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n  switch (args.length) {\n    case 3:\n      return toInsertedImpl(...args);\n\n    case 2:\n      return (array) => toInsertedImpl(array, ...args);\n  }\n}\n\nconst toInsertedImpl = <E, const V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): NonEmptyArray<E | V> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  (array as readonly (E | V)[]).toSpliced(\n    index,\n    0,\n    newValue,\n  ) as unknown as NonEmptyArray<E | V>;\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n  index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n    | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2:\n      return toRemovedImpl(...args);\n\n    case 1:\n      return (array) => toRemovedImpl(array, ...args);\n  }\n}\n\nconst toRemovedImpl = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArrWithNegative,\n): readonly E[] => array.toSpliced(index, 1);\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = appended;\n *\n * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n  switch (args.length) {\n    case 2:\n      return toPushedImpl(...args);\n\n    case 1:\n      return (array) => toPushedImpl(array, ...args);\n  }\n}\n\nconst toPushedImpl = <const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = prefixed;\n *\n * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n  switch (args.length) {\n    case 2:\n      return toUnshiftedImpl(...args);\n\n    case 1:\n      return (array) => toUnshiftedImpl(array, ...args);\n  }\n}\n\nconst toUnshiftedImpl = <Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\n// curried version\nexport function toFilled<const V>(\n  value: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\nexport function toFilled<E>(\n  ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2:\n      return toFilledImpl(...args);\n\n    case 1:\n      return (array) => toFilledImpl(array, ...args);\n  }\n}\n\nconst toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>\n  create(asPositiveUint32(array.length), value);\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n  fillRange: readonly [\n    start: ArgArrayIndexWithNegative<Ar>,\n    end: ArgArrayIndexWithNegative<Ar>,\n  ],\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\n// curried version\nexport function toRangeFilled<const V>(\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\nexport function toRangeFilled<E, const V>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n    | readonly [\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return toRangeFilledImpl(...args);\n\n    case 2:\n      return (array) => toRangeFilledImpl(array, ...args);\n  }\n}\n\nconst toRangeFilledImpl = <E, const V>(\n  array: readonly E[],\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): readonly (E | V)[] => {\n  const [start, end] = fillRange;\n\n  const mut_cp: (E | V)[] = castMutable(copy(array));\n\n  mut_cp.fill(value, start, end);\n\n  return mut_cp;\n};\n"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-reducing-value.d.mts.map

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

package/dist/array/impl/array-utils-reducing-value.mjs

@@ -77,67 +77,57 @@ function maxBy(array, comparatorValueMapper, comparator) {
 }
 function count(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      return array.reduce(
-        (acc, curr, index) => predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
-        asUint32(0)
-      );
-    }
-    case 1: {
-      const [predicate] = args;
-      return (array) => count(array, predicate);
-    }
+    case 2:
+      return countImpl(...args);
+    case 1:
+      return (array) => countImpl(array, ...args);
   }
 }
+const countImpl = (array, predicate) => array.reduce(
+  (acc, curr, index) => predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
+  asUint32(0)
+);
 function countBy(...args) {
   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 curr = mut_groups.get(key) ?? 0;
-        mut_groups.set(key, asUint32(curr + 1));
-      }
-      return IMap.create(mut_groups);
-    }
-    case 1: {
-      const [grouper] = args;
-      return (array) => countBy(array, grouper);
-    }
+    case 2:
+      return countByImpl(...args);
+    case 1:
+      return (array) => countByImpl(array, ...args);
   }
 }
+const countByImpl = (array, grouper) => {
+  const mut_groups = /* @__PURE__ */ new Map();
+  for (const [index, e] of array.entries()) {
+    const key = grouper(e, asUint32(index));
+    const curr = mut_groups.get(key) ?? 0;
+    mut_groups.set(key, asUint32(curr + 1));
+  }
+  return IMap.create(mut_groups);
+};
 function foldl(...args) {
   switch (args.length) {
-    case 3: {
-      const [array, callbackfn, initialValue] = args;
-      return array.reduce(
-        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
-        initialValue
-      );
-    }
-    case 2: {
-      const [callbackfn, initialValue] = args;
-      return (array) => foldl(array, callbackfn, initialValue);
-    }
+    case 3:
+      return foldlImpl(...args);
+    case 2:
+      return (array) => foldlImpl(array, ...args);
   }
 }
+const foldlImpl = (array, callbackfn, initialValue) => array.reduce(
+  (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+  initialValue
+);
 function foldr(...args) {
   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;
-      return (array) => foldr(array, callbackfn, initialValue);
-    }
+    case 3:
+      return foldrImpl(...args);
+    case 2:
+      return (array) => foldrImpl(array, ...args);
   }
 }
+const foldrImpl = (array, callbackfn, initialValue) => array.reduceRight(
+  (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+  initialValue
+);
 function sum(array) {
   return array.reduce((prev, curr) => prev + curr, 0);
 }

package/dist/array/impl/array-utils-reducing-value.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-reducing-value.mjs","sources":["../../../src/array/impl/array-utils-reducing-value.mts"],"sourcesContent":["import { isError } from '@sindresorhus/is';\nimport { type Int, type NonEmptyTuple, type Uint } from 'ts-type-forge';\nimport { IMap } from '../../collections/index.mjs';\nimport { Optional, Result } from '../../functional/index.mjs';\nimport { isString, isUndefined } from '../../guard/index.mjs';\nimport { asUint32, Num, Uint32 } from '../../number/index.mjs';\nimport { unknownToString } from '../../others/index.mjs';\nimport {\n  type ArrayIndex,\n  type MapSetKeyType,\n  type SizeType,\n  type Some,\n} from '../../types.mjs';\nimport { isNonEmpty } from './array-utils-validation.mjs';\n\n/**\n * Finds the minimum value in an array.\n *\n * @example\n *\n * ```ts\n * const values = [5, 3, 9] as const;\n *\n * const empty: readonly number[] = [] as const;\n *\n * const smallest = Arr.min(values);\n *\n * const none = Arr.min(empty);\n *\n * const custom = Arr.min(values, (a, b) => b - a);\n *\n * assert.deepStrictEqual(smallest, Optional.some(3));\n *\n * assert.deepStrictEqual(none, Optional.none);\n *\n * assert.deepStrictEqual(custom, Optional.some(9));\n * ```\n */\nexport function min<const Ar extends readonly number[]>(\n  array: Ar,\n  // If the array elements are numbers, comparator is optional.\n  comparator?: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function min<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparator: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function min<E extends number>(\n  array: readonly E[],\n  comparator?: (x: E, y: E) => number,\n): Optional<E> {\n  if (!isNonEmpty(array)) {\n    return Optional.none;\n  }\n\n  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));\n\n  return Optional.some(\n    array.reduce(\n      (currentMin, curr) => (cmp(curr, currentMin) < 0 ? curr : currentMin),\n      array[0],\n    ),\n  );\n}\n\n/**\n * Finds the maximum value in an array.\n *\n * @example\n *\n * ```ts\n * const values = [5, 3, 9] as const;\n *\n * const largest = Arr.max(values);\n *\n * const reversed = Arr.max(values, (a, b) => b - a);\n *\n * assert.deepStrictEqual(largest, Optional.some(9));\n *\n * assert.deepStrictEqual(reversed, Optional.some(3));\n * ```\n */\nexport function max<const Ar extends readonly number[]>(\n  array: Ar,\n  // If the array elements are numbers, comparator is optional.\n  comparator?: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function max<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparator: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function max<E extends number>(\n  array: readonly E[],\n  comparator?: (x: E, y: E) => number,\n): Optional<E> {\n  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));\n\n  // Find max by finding min with an inverted comparator\n  return min(array, (x, y) => -cmp(x, y));\n}\n\n/**\n * Finds the element with the minimum mapped value.\n *\n * @example\n *\n * ```ts\n * const users = [\n *   { id: 1, visits: 10 },\n *   { id: 2, visits: 3 },\n *   { id: 3, visits: 5 },\n * ] as const;\n *\n * const leastVisits = Arr.minBy(users, (user) => user.visits);\n *\n * const custom = Arr.minBy(\n *   users,\n *   (user) => user.visits,\n *   (a, b) => b - a,\n * );\n *\n * assert.deepStrictEqual(leastVisits, Optional.some({ id: 2, visits: 3 }));\n *\n * assert.deepStrictEqual(custom, Optional.some({ id: 1, visits: 10 }));\n * ```\n */\nexport function minBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparatorValueMapper: (value: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function minBy<const Ar extends readonly unknown[], V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function minBy<E, V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): Optional<E> {\n  return min(array, (x, y) =>\n    comparator === undefined\n      ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Finds the element with the maximum mapped value.\n *\n * @example\n *\n * ```ts\n * const projects = [\n *   { id: 'a', stars: 10 },\n *   { id: 'b', stars: 30 },\n *   { id: 'c', stars: 20 },\n * ] as const;\n *\n * const mostStars = Arr.maxBy(projects, (project) => project.stars);\n *\n * const smallestStars = Arr.maxBy(\n *   projects,\n *   (project) => project.stars,\n *   (a, b) => b - a,\n * );\n *\n * assert.deepStrictEqual(mostStars, Optional.some({ id: 'b', stars: 30 }));\n *\n * assert.deepStrictEqual(\n *   smallestStars,\n *   Optional.some({ id: 'a', stars: 10 }),\n * );\n * ```\n */\nexport function maxBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparatorValueMapper: (value: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function maxBy<const Ar extends readonly unknown[], V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function maxBy<E, V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): Optional<E> {\n  return max(array, (x, y) =>\n    comparator === undefined\n      ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Counts the number of elements that satisfy a predicate.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Grace', 'Linus'] as const;\n *\n * const longWords = Arr.count(words, (word) => word.length > 4);\n *\n * const withCurried = Arr.count<string>((word) => word.includes('a'))(words);\n *\n * assert.isTrue(longWords === 2);\n *\n * assert.isTrue(withCurried === 2);\n * ```\n */\nexport function count<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): SizeType.Arr;\n\nexport function count<E>(\n  predicate: (value: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => SizeType.Arr;\n\nexport function count<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (value: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (value: E, index: SizeType.Arr) => boolean]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.reduce<Uint32>(\n        (acc, curr, index) =>\n          predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,\n        asUint32(0),\n      );\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => count(array, predicate);\n    }\n  }\n}\n\n/**\n * Groups elements by a key and counts the elements in each group.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Grace', 'Alan', 'Barbara'] as const;\n *\n * const counts = Arr.countBy(words, (word) => word.at(0));\n *\n * assert.deepStrictEqual(counts.get('A'), Optional.some(2));\n *\n * assert.deepStrictEqual(counts.get('G'), Optional.some(1));\n *\n * assert.deepStrictEqual(counts.get('B'), Optional.some(1));\n * ```\n */\nexport function countBy<\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, ArrayIndex<Ar>>;\n\nexport function countBy<E, G extends MapSetKeyType>(\n  grouper: (value: E, index: SizeType.Arr) => G,\n): (array: readonly E[]) => IMap<G, SizeType.Arr>;\n\nexport function countBy<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, SizeType.Arr> | ((array: readonly E[]) => IMap<G, SizeType.Arr>) {\n  switch (args.length) {\n    case 2: {\n      const [array, grouper] = args;\n\n      const mut_groups = new Map<G, SizeType.Arr>();\n\n      for (const [index, e] of array.entries()) {\n        const key = grouper(e, asUint32(index));\n\n        const curr = mut_groups.get(key) ?? 0;\n\n        mut_groups.set(key, asUint32(curr + 1));\n      }\n\n      return IMap.create(mut_groups);\n    }\n\n    case 1: {\n      const [grouper] = args;\n\n      return (array) => countBy(array, grouper);\n    }\n  }\n}\n\n/**\n * Reduces an array to a single value from left to right.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * const totalLength = Arr.foldl(words, (acc, word) => acc + word.length, 0);\n *\n * const concat = Arr.foldl<string | number, string>(\n *   (acc, value) => `${acc}-${value}`,\n *   'items',\n * )(words);\n *\n * assert.isTrue(totalLength === 11);\n *\n * assert.isTrue(concat === 'items-Ada-Lovelace');\n * ```\n */\nexport function foldl<const Ar extends readonly unknown[], P>(\n  array: Ar,\n  callbackfn: (\n    previousValue: P,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => P,\n  initialValue: P,\n): P;\n\nexport function foldl<E, P>(\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): (array: readonly E[]) => P;\n\nexport function foldl<E, P>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n    | readonly [\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n): P | ((array: readonly E[]) => P) {\n  switch (args.length) {\n    case 3: {\n      const [array, callbackfn, initialValue] = args;\n\n      return array.reduce(\n        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),\n        initialValue,\n      );\n    }\n\n    case 2: {\n      const [callbackfn, initialValue] = args;\n\n      return (array) => foldl(array, callbackfn, initialValue);\n    }\n  }\n}\n\n/**\n * Reduces an array to a single value from right to left.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const subtractRight = Arr.foldr(numbers, (acc, value) => acc - value, 0);\n *\n * const joinFromRight = Arr.foldr<number, string>(\n *   (acc, value) => `${acc}${value}`,\n *   '',\n * )(numbers);\n *\n * assert.isTrue(subtractRight === -6);\n *\n * assert.isTrue(joinFromRight === '321');\n * ```\n */\nexport function foldr<const Ar extends readonly unknown[], P>(\n  array: Ar,\n  callbackfn: (\n    previousValue: P,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => P,\n  initialValue: P,\n): P;\n\nexport function foldr<E, P>(\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): (array: readonly E[]) => P;\n\nexport function foldr<E, P>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n    | readonly [\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n): P | ((array: readonly E[]) => P) {\n  switch (args.length) {\n    case 3: {\n      const [array, callbackfn, initialValue] = args;\n\n      return array.reduceRight(\n        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),\n        initialValue,\n      );\n    }\n\n    case 2: {\n      const [callbackfn, initialValue] = args;\n\n      return (array) => foldr(array, callbackfn, initialValue);\n    }\n  }\n}\n\n/**\n * Calculates the sum of numbers in an array.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3, 4] as const;\n *\n * const negatives = [3, -2, 5] as const;\n *\n * const total = Arr.sum(numbers);\n *\n * const totalNegatives = Arr.sum(negatives);\n *\n * assert.isTrue(total === 10);\n *\n * assert.isTrue(totalNegatives === 6);\n * ```\n */\nexport function sum(array: readonly []): 0;\n\nexport function sum<N extends number>(array: readonly [N]): N;\n\nexport function sum(array: readonly Uint[]): Uint;\n\nexport function sum(array: readonly Int[]): Int;\n\nexport function sum(array: readonly number[]): number;\n\nexport function sum(array: readonly number[]): number {\n  return array.reduce((prev, curr) => prev + curr, 0);\n}\n\n/**\n * Calculates the sum of values in an array by applying a mapping function to each element.\n *\n * @example\n *\n * ```ts\n * const numbers = [\n *   { value: 1 },\n *   { value: 2 },\n *   { value: 3 },\n *   { value: 4 },\n * ] as const;\n *\n * const negatives = [{ value: 3 }, { value: -2 }, { value: 5 }] as const;\n *\n * const total = Arr.sumBy(numbers, (item) => item.value);\n *\n * const totalNegatives = Arr.sumBy(negatives, (item) => item.value);\n *\n * assert.isTrue(total === 10);\n *\n * assert.isTrue(totalNegatives === 6);\n * ```\n */\nexport function sumBy(array: readonly [], mapFn: (item: unknown) => number): 0;\n\nexport function sumBy<N extends Uint, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): Uint;\n\nexport function sumBy<N extends Int, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): Int;\n\nexport function sumBy<N extends number, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): number;\n\nexport function sumBy<N extends number, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): number {\n  return array.reduce((prev, curr) => prev + mapFn(curr), 0);\n}\n\n/**\n * Joins array elements into a string.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const defaultSeparator = Arr.join(numbers);\n *\n * const hyphenSeparated = Arr.join(numbers, '-');\n *\n * assert.deepStrictEqual(defaultSeparator, Result.ok('1,2,3'));\n *\n * assert.deepStrictEqual(hyphenSeparated, Result.ok('1-2-3'));\n * ```\n */\nexport function join(\n  array: readonly unknown[],\n  separator?: string,\n): Result<string, Error>;\n\nexport function join(\n  separator?: string,\n): (array: readonly unknown[]) => Result<string, Error>;\n\nexport function join(\n  ...args:\n    | readonly [array: readonly unknown[], separator?: string]\n    | readonly [separator?: string]\n):\n  | Result<string, Error>\n  | ((array: readonly unknown[]) => Result<string, Error>) {\n  switch (args.length) {\n    case 0:\n      return (array) => joinImpl(array, undefined);\n\n    case 1: {\n      const [arg] = args;\n\n      if (isString(arg) || isUndefined(arg)) {\n        return (array) => joinImpl(array, arg);\n      }\n\n      return joinImpl(arg, undefined);\n    }\n\n    case 2: {\n      const [array, separator] = args;\n\n      return joinImpl(array, separator);\n    }\n  }\n}\n\nconst joinImpl = (\n  array: readonly unknown[],\n  separator: string | undefined,\n): Result<string, Error> => {\n  try {\n    const result = array.join(separator);\n\n    return Result.ok(result);\n  } catch (error) {\n    return Result.err(\n      isError(error) ? error : new Error(unknownToString(error)),\n    );\n  }\n};\n\n/**\n * Alias for `foldl`.\n *\n * @see {@link foldl}\n */\nexport const reduce = foldl;\n\n/**\n * Alias for `foldr`.\n *\n * @see {@link foldr}\n */\nexport const reduceRight = foldr;\n"],"names":["Optional.none","Optional.some","Result.ok","Result.err"],"mappings":"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"}
+{"version":3,"file":"array-utils-reducing-value.mjs","sources":["../../../src/array/impl/array-utils-reducing-value.mts"],"sourcesContent":["import { isError } from '@sindresorhus/is';\nimport { type Int, type NonEmptyTuple, type Uint } from 'ts-type-forge';\nimport { IMap } from '../../collections/index.mjs';\nimport { Optional, Result } from '../../functional/index.mjs';\nimport { isString, isUndefined } from '../../guard/index.mjs';\nimport { asUint32, Num, Uint32 } from '../../number/index.mjs';\nimport { unknownToString } from '../../others/index.mjs';\nimport {\n  type ArrayIndex,\n  type MapSetKeyType,\n  type SizeType,\n  type Some,\n} from '../../types.mjs';\nimport { isNonEmpty } from './array-utils-validation.mjs';\n\n/**\n * Finds the minimum value in an array.\n *\n * @example\n *\n * ```ts\n * const values = [5, 3, 9] as const;\n *\n * const empty: readonly number[] = [] as const;\n *\n * const smallest = Arr.min(values);\n *\n * const none = Arr.min(empty);\n *\n * const custom = Arr.min(values, (a, b) => b - a);\n *\n * assert.deepStrictEqual(smallest, Optional.some(3));\n *\n * assert.deepStrictEqual(none, Optional.none);\n *\n * assert.deepStrictEqual(custom, Optional.some(9));\n * ```\n */\nexport function min<const Ar extends readonly number[]>(\n  array: Ar,\n  // If the array elements are numbers, comparator is optional.\n  comparator?: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function min<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparator: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function min<E extends number>(\n  array: readonly E[],\n  comparator?: (x: E, y: E) => number,\n): Optional<E> {\n  if (!isNonEmpty(array)) {\n    return Optional.none;\n  }\n\n  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));\n\n  return Optional.some(\n    array.reduce(\n      (currentMin, curr) => (cmp(curr, currentMin) < 0 ? curr : currentMin),\n      array[0],\n    ),\n  );\n}\n\n/**\n * Finds the maximum value in an array.\n *\n * @example\n *\n * ```ts\n * const values = [5, 3, 9] as const;\n *\n * const largest = Arr.max(values);\n *\n * const reversed = Arr.max(values, (a, b) => b - a);\n *\n * assert.deepStrictEqual(largest, Optional.some(9));\n *\n * assert.deepStrictEqual(reversed, Optional.some(3));\n * ```\n */\nexport function max<const Ar extends readonly number[]>(\n  array: Ar,\n  // If the array elements are numbers, comparator is optional.\n  comparator?: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function max<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparator: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function max<E extends number>(\n  array: readonly E[],\n  comparator?: (x: E, y: E) => number,\n): Optional<E> {\n  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));\n\n  // Find max by finding min with an inverted comparator\n  return min(array, (x, y) => -cmp(x, y));\n}\n\n/**\n * Finds the element with the minimum mapped value.\n *\n * @example\n *\n * ```ts\n * const users = [\n *   { id: 1, visits: 10 },\n *   { id: 2, visits: 3 },\n *   { id: 3, visits: 5 },\n * ] as const;\n *\n * const leastVisits = Arr.minBy(users, (user) => user.visits);\n *\n * const custom = Arr.minBy(\n *   users,\n *   (user) => user.visits,\n *   (a, b) => b - a,\n * );\n *\n * assert.deepStrictEqual(leastVisits, Optional.some({ id: 2, visits: 3 }));\n *\n * assert.deepStrictEqual(custom, Optional.some({ id: 1, visits: 10 }));\n * ```\n */\nexport function minBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparatorValueMapper: (value: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function minBy<const Ar extends readonly unknown[], V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function minBy<E, V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): Optional<E> {\n  return min(array, (x, y) =>\n    comparator === undefined\n      ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Finds the element with the maximum mapped value.\n *\n * @example\n *\n * ```ts\n * const projects = [\n *   { id: 'a', stars: 10 },\n *   { id: 'b', stars: 30 },\n *   { id: 'c', stars: 20 },\n * ] as const;\n *\n * const mostStars = Arr.maxBy(projects, (project) => project.stars);\n *\n * const smallestStars = Arr.maxBy(\n *   projects,\n *   (project) => project.stars,\n *   (a, b) => b - a,\n * );\n *\n * assert.deepStrictEqual(mostStars, Optional.some({ id: 'b', stars: 30 }));\n *\n * assert.deepStrictEqual(\n *   smallestStars,\n *   Optional.some({ id: 'a', stars: 10 }),\n * );\n * ```\n */\nexport function maxBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparatorValueMapper: (value: Ar[number]) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function maxBy<const Ar extends readonly unknown[], V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function maxBy<E, V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): Optional<E> {\n  return max(array, (x, y) =>\n    comparator === undefined\n      ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Counts the number of elements that satisfy a predicate.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Grace', 'Linus'] as const;\n *\n * const longWords = Arr.count(words, (word) => word.length > 4);\n *\n * const withCurried = Arr.count<string>((word) => word.includes('a'))(words);\n *\n * assert.isTrue(longWords === 2);\n *\n * assert.isTrue(withCurried === 2);\n * ```\n */\nexport function count<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): SizeType.Arr;\n\nexport function count<E>(\n  predicate: (value: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => SizeType.Arr;\n\nexport function count<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (value: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (value: E, index: SizeType.Arr) => boolean]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr) {\n  switch (args.length) {\n    case 2:\n      return countImpl(...args);\n\n    case 1:\n      return (array) => countImpl(array, ...args);\n  }\n}\n\nconst countImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr) => boolean,\n): SizeType.Arr =>\n  array.reduce<Uint32>(\n    (acc, curr, index) =>\n      predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,\n    asUint32(0),\n  );\n\n/**\n * Groups elements by a key and counts the elements in each group.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Grace', 'Alan', 'Barbara'] as const;\n *\n * const counts = Arr.countBy(words, (word) => word.at(0));\n *\n * assert.deepStrictEqual(counts.get('A'), Optional.some(2));\n *\n * assert.deepStrictEqual(counts.get('G'), Optional.some(1));\n *\n * assert.deepStrictEqual(counts.get('B'), Optional.some(1));\n * ```\n */\nexport function countBy<\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, ArrayIndex<Ar>>;\n\nexport function countBy<E, G extends MapSetKeyType>(\n  grouper: (value: E, index: SizeType.Arr) => G,\n): (array: readonly E[]) => IMap<G, SizeType.Arr>;\n\nexport function countBy<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, SizeType.Arr> | ((array: readonly E[]) => IMap<G, SizeType.Arr>) {\n  switch (args.length) {\n    case 2:\n      return countByImpl(...args);\n\n    case 1:\n      return (array) => countByImpl(array, ...args);\n  }\n}\n\nconst countByImpl = <E, G extends MapSetKeyType>(\n  array: readonly E[],\n  grouper: (value: E, index: SizeType.Arr) => G,\n): IMap<G, SizeType.Arr> => {\n  const mut_groups = new Map<G, SizeType.Arr>();\n\n  for (const [index, e] of array.entries()) {\n    const key = grouper(e, asUint32(index));\n\n    const curr = mut_groups.get(key) ?? 0;\n\n    mut_groups.set(key, asUint32(curr + 1));\n  }\n\n  return IMap.create(mut_groups);\n};\n\n/**\n * Reduces an array to a single value from left to right.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * const totalLength = Arr.foldl(words, (acc, word) => acc + word.length, 0);\n *\n * const concat = Arr.foldl<string | number, string>(\n *   (acc, value) => `${acc}-${value}`,\n *   'items',\n * )(words);\n *\n * assert.isTrue(totalLength === 11);\n *\n * assert.isTrue(concat === 'items-Ada-Lovelace');\n * ```\n */\nexport function foldl<const Ar extends readonly unknown[], P>(\n  array: Ar,\n  callbackfn: (\n    previousValue: P,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => P,\n  initialValue: P,\n): P;\n\nexport function foldl<E, P>(\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): (array: readonly E[]) => P;\n\nexport function foldl<E, P>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n    | readonly [\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n): P | ((array: readonly E[]) => P) {\n  switch (args.length) {\n    case 3:\n      return foldlImpl(...args);\n\n    case 2:\n      return (array) => foldlImpl(array, ...args);\n  }\n}\n\nconst foldlImpl = <E, P>(\n  array: readonly E[],\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): P =>\n  array.reduce(\n    (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),\n    initialValue,\n  );\n\n/**\n * Reduces an array to a single value from right to left.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const subtractRight = Arr.foldr(numbers, (acc, value) => acc - value, 0);\n *\n * const joinFromRight = Arr.foldr<number, string>(\n *   (acc, value) => `${acc}${value}`,\n *   '',\n * )(numbers);\n *\n * assert.isTrue(subtractRight === -6);\n *\n * assert.isTrue(joinFromRight === '321');\n * ```\n */\nexport function foldr<const Ar extends readonly unknown[], P>(\n  array: Ar,\n  callbackfn: (\n    previousValue: P,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => P,\n  initialValue: P,\n): P;\n\nexport function foldr<E, P>(\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): (array: readonly E[]) => P;\n\nexport function foldr<E, P>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n    | readonly [\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n): P | ((array: readonly E[]) => P) {\n  switch (args.length) {\n    case 3:\n      return foldrImpl(...args);\n\n    case 2:\n      return (array) => foldrImpl(array, ...args);\n  }\n}\n\nconst foldrImpl = <E, P>(\n  array: readonly E[],\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): P =>\n  array.reduceRight(\n    (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),\n    initialValue,\n  );\n\n/**\n * Calculates the sum of numbers in an array.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3, 4] as const;\n *\n * const negatives = [3, -2, 5] as const;\n *\n * const total = Arr.sum(numbers);\n *\n * const totalNegatives = Arr.sum(negatives);\n *\n * assert.isTrue(total === 10);\n *\n * assert.isTrue(totalNegatives === 6);\n * ```\n */\nexport function sum(array: readonly []): 0;\n\nexport function sum<N extends number>(array: readonly [N]): N;\n\nexport function sum(array: readonly Uint[]): Uint;\n\nexport function sum(array: readonly Int[]): Int;\n\nexport function sum(array: readonly number[]): number;\n\nexport function sum(array: readonly number[]): number {\n  return array.reduce((prev, curr) => prev + curr, 0);\n}\n\n/**\n * Calculates the sum of values in an array by applying a mapping function to each element.\n *\n * @example\n *\n * ```ts\n * const numbers = [\n *   { value: 1 },\n *   { value: 2 },\n *   { value: 3 },\n *   { value: 4 },\n * ] as const;\n *\n * const negatives = [{ value: 3 }, { value: -2 }, { value: 5 }] as const;\n *\n * const total = Arr.sumBy(numbers, (item) => item.value);\n *\n * const totalNegatives = Arr.sumBy(negatives, (item) => item.value);\n *\n * assert.isTrue(total === 10);\n *\n * assert.isTrue(totalNegatives === 6);\n * ```\n */\nexport function sumBy(array: readonly [], mapFn: (item: unknown) => number): 0;\n\nexport function sumBy<N extends Uint, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): Uint;\n\nexport function sumBy<N extends Int, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): Int;\n\nexport function sumBy<N extends number, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): number;\n\nexport function sumBy<N extends number, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): number {\n  return array.reduce((prev, curr) => prev + mapFn(curr), 0);\n}\n\n/**\n * Joins array elements into a string.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const defaultSeparator = Arr.join(numbers);\n *\n * const hyphenSeparated = Arr.join(numbers, '-');\n *\n * assert.deepStrictEqual(defaultSeparator, Result.ok('1,2,3'));\n *\n * assert.deepStrictEqual(hyphenSeparated, Result.ok('1-2-3'));\n * ```\n */\nexport function join(\n  array: readonly unknown[],\n  separator?: string,\n): Result<string, Error>;\n\nexport function join(\n  separator?: string,\n): (array: readonly unknown[]) => Result<string, Error>;\n\nexport function join(\n  ...args:\n    | readonly [array: readonly unknown[], separator?: string]\n    | readonly [separator?: string]\n):\n  | Result<string, Error>\n  | ((array: readonly unknown[]) => Result<string, Error>) {\n  switch (args.length) {\n    case 0:\n      return (array) => joinImpl(array, undefined);\n\n    case 1: {\n      const [arg] = args;\n\n      if (isString(arg) || isUndefined(arg)) {\n        return (array) => joinImpl(array, arg);\n      }\n\n      return joinImpl(arg, undefined);\n    }\n\n    case 2: {\n      const [array, separator] = args;\n\n      return joinImpl(array, separator);\n    }\n  }\n}\n\nconst joinImpl = (\n  array: readonly unknown[],\n  separator: string | undefined,\n): Result<string, Error> => {\n  try {\n    const result = array.join(separator);\n\n    return Result.ok(result);\n  } catch (error) {\n    return Result.err(\n      isError(error) ? error : new Error(unknownToString(error)),\n    );\n  }\n};\n\n/**\n * Alias for `foldl`.\n *\n * @see {@link foldl}\n */\nexport const reduce = foldl;\n\n/**\n * Alias for `foldr`.\n *\n * @see {@link foldr}\n */\nexport const reduceRight = foldr;\n"],"names":["Optional.none","Optional.some","Result.ok","Result.err"],"mappings":"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"}

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

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

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

@@ -41,128 +41,116 @@ import '../../number/refined-number-utils.mjs';
 
 function find(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      const foundIndex = array.findIndex(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        predicate
-      );
-      return foundIndex === -1 ? none : (
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        some(array[foundIndex])
-      );
-    }
-    case 1: {
-      const [predicate] = args;
-      return (array) => find(array, predicate);
-    }
+    case 2:
+      return findImpl(...args);
+    case 1:
+      return (array) => findImpl(array, ...args);
   }
 }
+const findImpl = (array, predicate) => {
+  const foundIndex = array.findIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate
+  );
+  return foundIndex === -1 ? none : (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    some(array[foundIndex])
+  );
+};
 function findLast(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      const foundIndex = array.findLastIndex(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        predicate
-      );
-      return foundIndex === -1 ? none : (
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        some(array[foundIndex])
-      );
-    }
-    case 1: {
-      const [predicate] = args;
-      return (array) => findLast(array, predicate);
-    }
+    case 2:
+      return findLastImpl(...args);
+    case 1:
+      return (array) => findLastImpl(array, ...args);
   }
 }
+const findLastImpl = (array, predicate) => {
+  const foundIndex = array.findLastIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate
+  );
+  return foundIndex === -1 ? none : (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    some(array[foundIndex])
+  );
+};
 function findIndex(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      return pipe(
-        array.findIndex(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          predicate
-        )
-      ).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 = (array, predicate) => pipe(
+  array.findIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate
+  )
+).map((idx) => idx >= 0 ? asUint32(idx) : -1).value;
 function findLastIndex(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      return pipe(
-        array.findLastIndex(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          predicate
-        )
-      ).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 = (array, predicate) => pipe(
+  array.findLastIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate
+  )
+).map((idx) => idx >= 0 ? asUint32(idx) : -1).value;
 function indexOf(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, searchElement] = args;
-      const index = array.indexOf(searchElement);
-      return index !== -1 ? asUint32(index) : -1;
-    }
-    case 1: {
-      const [searchElement] = args;
-      return (array) => indexOf(array, searchElement);
-    }
+    case 2:
+      return indexOfImpl(...args);
+    case 1:
+      return (array) => indexOfImpl(array, ...args);
   }
 }
+const indexOfImpl = (array, searchElement) => {
+  const index = array.indexOf(searchElement);
+  return index !== -1 ? asUint32(index) : -1;
+};
 function indexOfFrom(...args) {
   switch (args.length) {
-    case 3: {
-      const [array, searchElement, fromIndex] = 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 3:
+      return indexOfFromImpl(...args);
+    case 2:
+      return (array) => indexOfFromImpl(array, ...args);
   }
 }
+const indexOfFromImpl = (array, searchElement, fromIndex) => {
+  const index = array.indexOf(searchElement, fromIndex);
+  return index !== -1 ? asUint32(index) : -1;
+};
 function lastIndexOf(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, searchElement] = args;
-      const index = array.lastIndexOf(searchElement);
-      return index !== -1 ? asUint32(index) : -1;
-    }
-    case 1: {
-      const [searchElement] = args;
-      return (array) => lastIndexOf(array, searchElement);
-    }
+    case 2:
+      return lastIndexOfImpl(...args);
+    case 1:
+      return (array) => lastIndexOfImpl(array, ...args);
   }
 }
+const lastIndexOfImpl = (array, searchElement) => {
+  const index = array.lastIndexOf(searchElement);
+  return index !== -1 ? asUint32(index) : -1;
+};
 function lastIndexOfFrom(...args) {
   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;
-      return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
-    }
+    case 3:
+      return lastIndexOfFromImpl(...args);
+    case 2:
+      return (array) => lastIndexOfFromImpl(array, ...args);
   }
 }
+const lastIndexOfFromImpl = (array, searchElement, fromIndex) => {
+  const index = array.lastIndexOf(searchElement, fromIndex);
+  return index !== -1 ? asUint32(index) : -1;
+};
 
 export { find, findIndex, findLast, findLastIndex, indexOf, indexOfFrom, lastIndexOf, lastIndexOfFrom };
 //# sourceMappingURL=array-utils-search.mjs.map