npm - ts-data-forge - Versions diffs - 12.1.0 → 12.2.0 - Mend

ts-data-forge 12.1.0 → 12.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/array/impl/array-utils-modification.d.mts CHANGED Viewed

@@ -96,13 +96,18 @@ export declare function toRemoved(index: SizeType.ArgArrWithNegative): <E>(array
  *
  * const appendedCurried = Arr.toPushed(4)(base);
  *
- * assert.deepStrictEqual(appended, [1, 2, 3]);
+ * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.
+ * const nonEmpty: NonEmptyArray<number> = appended;
  *
- * assert.deepStrictEqual(appendedCurried, [1, 2, 4]);
+ * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);
+ *
+ * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);
+ *
+ * assert.isTrue(nonEmpty.length >= 1);
  * ```
  */
-export declare function toPushed<const Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [...Ar, V];
-export declare function toPushed<const V>(newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];
+export declare function toPushed<const Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;
+export declare function toPushed<const V>(newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;
 /**
  * Returns a new array with a value prepended to the beginning.
  *
@@ -115,13 +120,18 @@ export declare function toPushed<const V>(newValue: V): <const Ar extends readon
  *
  * const prefixedCurried = Arr.toUnshifted(0)(base);
  *
- * assert.deepStrictEqual(prefixed, [1, 2, 3]);
+ * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.
+ * const nonEmpty: NonEmptyArray<number> = prefixed;
+ *
+ * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);
+ *
+ * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);
  *
- * assert.deepStrictEqual(prefixedCurried, [0, 2, 3]);
+ * assert.isTrue(nonEmpty.length >= 1);
  * ```
  */
-export declare function toUnshifted<const Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [V, ...Ar];
-export declare function toUnshifted<const V>(newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];
+export declare function toUnshifted<const Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;
+export declare function toUnshifted<const V>(newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;
 /**
  * Returns a new array with all elements replaced by the specified value.
  *

package/dist/array/impl/array-utils-modification.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-modification.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-modification.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACd,MAAM,iBAAiB,CAAC;AAGzB;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,EAC3E,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC,EACxB,QAAQ,EAAE,CAAC,GACV,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,QAAQ,CAAC;KAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;CAAE,CAAC,GACxC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAC7B,SAAS,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;AAGlC,wBAAgB,GAAG,CAAC,KAAK,CAAC,CAAC,EACzB,KAAK,EAAE,QAAQ,CAAC,MAAM,EACtB,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,QAAQ,CAAC;KAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;CAAE,CAAC,GACxC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAC7B,SAAS,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;AAsBlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CACvB,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACnC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,EAEpB,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC,EACxB,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,GAC/B,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,QAAQ,CAAC;KAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;CAAE,CAAC,GACxC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAC7B,SAAS,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;AAGlC,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,EACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,EACtB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACtB,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,CAAC,EAAE,EAC/B,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,QAAQ,CAAC;KAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;CAAE,CAAC,GACxC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAC7B,SAAS,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;AA2BlC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACxB,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACnC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,EAEpB,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,EACpC,QAAQ,EAAE,CAAC,GACV,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GACvE,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAGlC,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,EAChC,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAClC,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GACvE,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AA+BlC,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC3D,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACnC,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;AAEzB,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,kBAAkB,GACjC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC;AAsB5C~~;;;;;;;;;;;;;;;;GAgBG~~;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACnE,KAAK,EAAE,EAAE,EACT,QAAQ,EAAE,CAAC,GACV,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;~~AAEvB~~,wBAAgB,QAAQ,CAAC,KAAK,CAAC,CAAC,EAC9B,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,~~EAAE~~,KAAK,EAAE,EAAE,~~KAAK~~,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;~~AAwB3E;;;;;;;;;;;;;;;;GAgBG~~;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACtE,KAAK,EAAE,EAAE,EACT,QAAQ,EAAE,CAAC,GACV,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;~~AAEvB~~,wBAAgB,WAAW,CAAC,KAAK,CAAC,CAAC,EACjC,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,~~EAAE~~,KAAK,EAAE,EAAE,~~KAAK~~,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;~~AAqB3E~~;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACnE,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,CAAC,GACP,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GACjC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAAE,CAAC;AAGnB,wBAAgB,QAAQ,CAAC,KAAK,CAAC,CAAC,EAC9B,KAAK,EAAE,CAAC,GACP,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GACjC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAAE,CAAC;AAoBnB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACxE,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,SAAS;IAClB,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC;IACpC,GAAG,EAAE,yBAAyB,CAAC,EAAE,CAAC;CACnC,GACA,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC9C,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC7B,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;AAGlC,wBAAgB,aAAa,CAAC,KAAK,CAAC,CAAC,EACnC,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,SAAS;IAClB,KAAK,EAAE,QAAQ,CAAC,kBAAkB;IAClC,GAAG,EAAE,QAAQ,CAAC,kBAAkB;CACjC,GACA,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC9C,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC7B,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC"}
1	+ {"version":3,"file":"array-utils-modification.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-modification.mts"],"names":[],"mappings":"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"}

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

	@@ -1 +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 assert.deepStrictEqual(appended, [1, 2, 3]);\n \n assert.deepStrictEqual(appendedCurried, [1, 2, 4]);\n * ```\n /\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [...Ar, V];\n\nexport function toPushed<const V>(\n newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, 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 assert.deepStrictEqual(prefixed, [1, 2, 3]);\n \n assert.deepStrictEqual(prefixedCurried, [0, 2, 3]);\n * ```\n /\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [V, ...Ar];\n\nexport function toUnshifted<const V>(\n newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];\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":"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"}
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":"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"}

package/dist/array/impl/array-utils-transformation.d.mts CHANGED Viewed

@@ -305,6 +305,10 @@ export declare function partition<N extends WithSmallInt<PositiveInt & SizeType.
 /**
  * Concatenates two arrays.
  *
+ * The exact tuple shape is preserved. Additionally, when either input is known
+ * to be non-empty (a non-empty tuple or a branded `NonEmptyArray`), the result
+ * is branded as non-empty so it is assignable to `NonEmptyArray`.
+ *
  * @example
  *
  * ```ts
@@ -314,12 +318,28 @@ export declare function partition<N extends WithSmallInt<PositiveInt & SizeType.
  *
  * const combined = Arr.concat(numbers, words);
  *
+ * // Because at least one input is non-empty, the result is assignable to
+ * // NonEmptyArray.
+ * const nonEmpty: NonEmptyArray<number | string> = combined;
+ *
  * const expectedCombined = [1, 2, 'three', 'four'] as const;
  *
- * assert.deepStrictEqual(combined, expectedCombined);
+ * assert.deepStrictEqual<readonly (number | string)[]>(
+ *   combined,
+ *   expectedCombined,
+ * );
+ *
+ * assert.isTrue(nonEmpty.length >= 1);
  * ```
  */
-export declare const concat: <const Ar1 extends readonly unknown[], const Ar2 extends readonly unknown[]>(array1: Ar1, array2: Ar2) => readonly [...Ar1, ...Ar2];
+export declare const concat: <const Ar1 extends readonly unknown[], const Ar2 extends readonly unknown[]>(array1: Ar1, array2: Ar2) => ConcatResult<Ar1, Ar2>;
+/**
+ * Return type of {@link concat}: the concatenated tuple `readonly [...Ar1,
+ * ...Ar2]`, additionally branded as {@link NonEmptyArray} when either input is
+ * a non-empty tuple (a plain non-empty tuple or a branded `NonEmptyArray`,
+ * both of which extend `NonEmptyTuple<unknown>`).
+ */
+type ConcatResult<Ar1 extends readonly unknown[], Ar2 extends readonly unknown[]> = Ar1 extends NonEmptyTuple<unknown> ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]> : Ar2 extends NonEmptyTuple<unknown> ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]> : readonly [...Ar1, ...Ar2];
 /**
  * Groups elements by a key derived from each element.
  *
@@ -412,4 +432,5 @@ export declare const chunk: typeof partition;
  * ```
  */
 export declare const cartesianProduct: <T>(arrays: readonly (readonly T[])[]) => readonly (readonly T[])[];
+export {};
 //# sourceMappingURL=array-utils-transformation.d.mts.map

package/dist/array/impl/array-utils-transformation.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-transformation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-transformation.mts"],"names":[],"mappings":"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~~;;;;;;;;;;;;;;;;GAgBG~~;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,CAAC,GAAG,SAAS,SAAS,OAAO,EAAE,EACpC,KAAK,CAAC,GAAG,SAAS,SAAS,OAAO,EAAE,UAE5B,GAAG,UACH,GAAG,KACV,SAAS,CAAC,GAAG,GAAG,EAAE,GAAG,GAAG,~~CAAoC~~,CAAC;~~AAEhE~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,OAAO,CACrB,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACnC,CAAC,SAAS,aAAa,EAEvB,KAAK,EAAE,EAAE,EACT,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,CAAC,GACvD,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAElC,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,aAAa,EAChD,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC,GAC5C,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;AAwClD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,GAAG,GACd,KAAK,CAAC,GAAG,SAAS,SAAS,OAAO,EAAE,EACpC,KAAK,CAAC,GAAG,SAAS,SAAS,OAAO,EAAE,UAE5B,GAAG,UACH,GAAG,KACV,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAMgB,CAAC;AAErC;;;;GAIG;AACH,eAAO,MAAM,KAAK,kBAAY,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,UACxB,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,KAChC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAWzB,CAAC"}
1	+ {"version":3,"file":"array-utils-transformation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-transformation.mts"],"names":[],"mappings":"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"}

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

@@ -187,7 +187,10 @@ function partition(...args) {
     }
   }
 }
-const concat = (array1, array2) => [...array1, ...array2];
+const concat = (array1, array2) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  [...array1, ...array2]
+);
 function groupBy(...args) {
   switch (args.length) {
     case 2: {

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

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":["import {\n type FixedLengthTuple,\n type IsFixedLengthList,\n type List,\n type NonEmptyArray,\n type NonEmptyTuple,\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<readonly number[]>(runningTotals, expectedTotals);\n \n assert.deepStrictEqual<readonly number[]>(\n * runningTotalsFromCurried,\n * expectedCurriedTotals,\n * );\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): NonEmptyTuple<S> \| ((array: readonly E[]) => NonEmptyTuple<S>) {\n switch (args.length) {\n case 3: {\n const [array, reducer, init] = args;\n\n const mut_result = castMutable<NonEmptyTuple<S>>(\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 ? FixedLengthTuple<Ar['length'], Ar[number]>\n : Ar extends NonEmptyTuple<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 ? FixedLengthTuple<Ar['length'], Ar[number]>\n : Ar extends NonEmptyTuple<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 ? FixedLengthTuple<Ar['length'], Ar[number]>\n : Ar extends NonEmptyTuple<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<readonly string[]>(uniqueLetters, expected);\n * ```\n /\nexport const uniq = <const Ar extends readonly Primitive[]>(\n array: Ar,\n): Ar extends NonEmptyTuple<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<readonly Readonly<{ id: number; name: string }>[]>(\n * uniqueById,\n * expected,\n * );\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 NonEmptyTuple<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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"}
1	+ {"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":["import {\n type FixedLengthTuple,\n type IsFixedLengthList,\n type List,\n type NonEmptyArray,\n type NonEmptyTuple,\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<readonly number[]>(runningTotals, expectedTotals);\n \n assert.deepStrictEqual<readonly number[]>(\n * runningTotalsFromCurried,\n * expectedCurriedTotals,\n * );\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): NonEmptyTuple<S> \| ((array: readonly E[]) => NonEmptyTuple<S>) {\n switch (args.length) {\n case 3: {\n const [array, reducer, init] = args;\n\n const mut_result = castMutable<NonEmptyTuple<S>>(\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 ? FixedLengthTuple<Ar['length'], Ar[number]>\n : Ar extends NonEmptyTuple<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 ? FixedLengthTuple<Ar['length'], Ar[number]>\n : Ar extends NonEmptyTuple<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 ? FixedLengthTuple<Ar['length'], Ar[number]>\n : Ar extends NonEmptyTuple<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<readonly string[]>(uniqueLetters, expected);\n * ```\n /\nexport const uniq = <const Ar extends readonly Primitive[]>(\n array: Ar,\n): Ar extends NonEmptyTuple<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<readonly Readonly<{ id: number; name: string }>[]>(\n * uniqueById,\n * expected,\n * );\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 NonEmptyTuple<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 The exact tuple shape is preserved. Additionally, when either input is known\n * to be non-empty (a non-empty tuple or a branded `NonEmptyArray`), the result\n * is branded as non-empty so it is assignable to `NonEmptyArray`.\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 // Because at least one input is non-empty, the result is assignable to\n * // NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number \| string> = combined;\n \n const expectedCombined = [1, 2, 'three', 'four'] as const;\n \n assert.deepStrictEqual<readonly (number \| string)[]>(\n * combined,\n * expectedCombined,\n * );\n \n assert.isTrue(nonEmpty.length >= 1);\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): ConcatResult<Ar1, Ar2> =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n [...array1, ...array2] as never;\n\n/\n Return type of {@link concat}: the concatenated tuple `readonly [...Ar1,\n * ...Ar2]`, additionally branded as {@link NonEmptyArray} when either input is\n * a non-empty tuple (a plain non-empty tuple or a branded `NonEmptyArray`,\n * both of which extend `NonEmptyTuple<unknown>`).\n /\ntype ConcatResult<\n Ar1 extends readonly unknown[],\n Ar2 extends readonly unknown[],\n> =\n Ar1 extends NonEmptyTuple<unknown>\n ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] \| Ar2[number]>\n : Ar2 extends NonEmptyTuple<unknown>\n ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] \| Ar2[number]>\n : readonly [...Ar1, ...Ar2];\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/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "12.1.0",
+  "version": "12.2.0",
   "private": false,
   "keywords": [
     "typescript",

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

@@ -266,19 +266,26 @@ export function toRemoved<E>(
  *
  * const appendedCurried = Arr.toPushed(4)(base);
  *
- * assert.deepStrictEqual(appended, [1, 2, 3]);
+ * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.
+ * const nonEmpty: NonEmptyArray<number> = appended;
  *
- * assert.deepStrictEqual(appendedCurried, [1, 2, 4]);
+ * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);
+ *
+ * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);
+ *
+ * assert.isTrue(nonEmpty.length >= 1);
  * ```
  */
 export function toPushed<const Ar extends readonly unknown[], const V>(
   array: Ar,
   newValue: V,
-): readonly [...Ar, V];
+): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;
 export function toPushed<const V>(
   newValue: V,
-): <const Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];
+): <const Ar extends readonly unknown[]>(
+  array: Ar,
+) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;
 export function toPushed<const Ar extends readonly unknown[], const V>(
   ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]
@@ -314,19 +321,26 @@ export function toPushed<const Ar extends readonly unknown[], const V>(
  *
  * const prefixedCurried = Arr.toUnshifted(0)(base);
  *
- * assert.deepStrictEqual(prefixed, [1, 2, 3]);
+ * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.
+ * const nonEmpty: NonEmptyArray<number> = prefixed;
  *
- * assert.deepStrictEqual(prefixedCurried, [0, 2, 3]);
+ * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);
+ *
+ * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);
+ *
+ * assert.isTrue(nonEmpty.length >= 1);
  * ```
  */
 export function toUnshifted<const Ar extends readonly unknown[], const V>(
   array: Ar,
   newValue: V,
-): readonly [V, ...Ar];
+): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;
 export function toUnshifted<const V>(
   newValue: V,
-): <const Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];
+): <const Ar extends readonly unknown[]>(
+  array: Ar,
+) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;
 export function toUnshifted<Ar extends readonly unknown[], const V>(
   ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]

package/src/array/impl/array-utils-modification.test.mts CHANGED Viewed

@@ -134,9 +134,18 @@ describe('Arr modifications', () => {
       const result = toPushed(xs, 4 as const);
-      expectType<typeof result, readonly [1, 2, 3, 4]>('=');
+      // The structural tuple is preserved, and the result is additionally
+      // branded as non-empty so it is assignable to `NonEmptyArray`.
+      expectType<
+        typeof result,
+        readonly [1, 2, 3, 4] & NonEmptyArray<1 | 2 | 3 | 4>
+      >('=');
-      assert.deepStrictEqual(result, [1, 2, 3, 4]);
+      expectType<typeof result, readonly [1, 2, 3, 4]>('<=');
+      expectType<typeof result, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(result, [1, 2, 3, 4]);
     });
     test('case 2', () => {
@@ -144,9 +153,14 @@ describe('Arr modifications', () => {
       const result = toPushed(xs, 4 as const);
-      expectType<typeof result, readonly [...number[], 4]>('=');
+      expectType<
+        typeof result,
+        readonly [...number[], 4] & NonEmptyArray<number>
+      >('=');
-      assert.deepStrictEqual(result, [1, 2, 3, 4]);
+      expectType<typeof result, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(result, [1, 2, 3, 4]);
     });
     test('should work with curried version', () => {
@@ -154,7 +168,9 @@ describe('Arr modifications', () => {
       const result = pushFive([1, 2, 3]);
-      assert.deepStrictEqual(result, [1, 2, 3, 5]);
+      expectType<typeof result, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(result, [1, 2, 3, 5]);
     });
   });
@@ -164,9 +180,16 @@ describe('Arr modifications', () => {
       const result = toUnshifted(xs, 4 as const);
-      expectType<typeof result, readonly [4, 1, 2, 3]>('=');
+      expectType<
+        typeof result,
+        readonly [4, 1, 2, 3] & NonEmptyArray<1 | 2 | 3 | 4>
+      >('=');
-      assert.deepStrictEqual(result, [4, 1, 2, 3]);
+      expectType<typeof result, readonly [4, 1, 2, 3]>('<=');
+      expectType<typeof result, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(result, [4, 1, 2, 3]);
     });
     test('case 2', () => {
@@ -174,9 +197,14 @@ describe('Arr modifications', () => {
       const result = toUnshifted(xs, 4 as const);
-      expectType<typeof result, readonly [4, ...number[]]>('=');
+      expectType<
+        typeof result,
+        readonly [4, ...number[]] & NonEmptyArray<number>
+      >('=');
-      assert.deepStrictEqual(result, [4, 1, 2, 3]);
+      expectType<typeof result, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(result, [4, 1, 2, 3]);
     });
     test('should work with curried version', () => {
@@ -184,7 +212,9 @@ describe('Arr modifications', () => {
       const result = unshiftZero([1, 2, 3]);
-      assert.deepStrictEqual(result, [0, 1, 2, 3]);
+      expectType<typeof result, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(result, [0, 1, 2, 3]);
     });
   });

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

@@ -684,6 +684,10 @@ export function partition<
 /**
  * Concatenates two arrays.
  *
+ * The exact tuple shape is preserved. Additionally, when either input is known
+ * to be non-empty (a non-empty tuple or a branded `NonEmptyArray`), the result
+ * is branded as non-empty so it is assignable to `NonEmptyArray`.
+ *
  * @example
  *
  * ```ts
@@ -693,9 +697,18 @@ export function partition<
  *
  * const combined = Arr.concat(numbers, words);
  *
+ * // Because at least one input is non-empty, the result is assignable to
+ * // NonEmptyArray.
+ * const nonEmpty: NonEmptyArray<number | string> = combined;
+ *
  * const expectedCombined = [1, 2, 'three', 'four'] as const;
  *
- * assert.deepStrictEqual(combined, expectedCombined);
+ * assert.deepStrictEqual<readonly (number | string)[]>(
+ *   combined,
+ *   expectedCombined,
+ * );
+ *
+ * assert.isTrue(nonEmpty.length >= 1);
  * ```
  */
 export const concat = <
@@ -704,7 +717,25 @@ export const concat = <
 >(
   array1: Ar1,
   array2: Ar2,
-): readonly [...Ar1, ...Ar2] => [...array1, ...array2] as const;
+): ConcatResult<Ar1, Ar2> =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  [...array1, ...array2] as never;
+/**
+ * Return type of {@link concat}: the concatenated tuple `readonly [...Ar1,
+ * ...Ar2]`, additionally branded as {@link NonEmptyArray} when either input is
+ * a non-empty tuple (a plain non-empty tuple or a branded `NonEmptyArray`,
+ * both of which extend `NonEmptyTuple<unknown>`).
+ */
+type ConcatResult<
+  Ar1 extends readonly unknown[],
+  Ar2 extends readonly unknown[],
+> =
+  Ar1 extends NonEmptyTuple<unknown>
+    ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>
+    : Ar2 extends NonEmptyTuple<unknown>
+      ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>
+      : readonly [...Ar1, ...Ar2];
 /**
  * Groups elements by a key derived from each element.

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

@@ -1,4 +1,4 @@
-import { type FixedLengthTuple } from 'ts-type-forge';
+import { type FixedLengthTuple, type NonEmptyArray } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { expectType } from '../../expect-type.mjs';
 import { Optional } from '../../functional/index.mjs';
@@ -750,10 +750,56 @@ describe('Arr transformations', () => {
     const result = concat(xs, ys);
-    expectType<typeof result, readonly [1, 2, 3, 4, 5]>('=');
+    // The exact tuple shape is preserved, and because both inputs are
+    // non-empty tuples the result is additionally branded as non-empty so it
+    // is assignable to `NonEmptyArray`.
+    expectType<
+      typeof result,
+      readonly [1, 2, 3, 4, 5] & NonEmptyArray<1 | 2 | 3 | 4 | 5>
+    >('=');
+    expectType<typeof result, readonly [1, 2, 3, 4, 5]>('<=');
+    expectType<typeof result, NonEmptyArray<number>>('<=');
     test('case 1', () => {
-      assert.deepStrictEqual(result, [1, 2, 3, 4, 5]);
+      assert.deepStrictEqual<readonly number[]>(result, [1, 2, 3, 4, 5]);
+    });
+    test('is non-empty when only the left side is non-empty', () => {
+      const left = [1] as const;
+      const right: readonly number[] = [2, 3] as const;
+      const merged = concat(left, right);
+      expectType<typeof merged, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(merged, [1, 2, 3]);
+    });
+    test('is non-empty when only the right side is non-empty', () => {
+      const left: readonly number[] = [1, 2] as const;
+      const right = [3] as const;
+      const merged = concat(left, right);
+      expectType<typeof merged, NonEmptyArray<number>>('<=');
+      assert.deepStrictEqual<readonly number[]>(merged, [1, 2, 3]);
+    });
+    test('is not branded non-empty when both sides may be empty', () => {
+      const left: readonly number[] = [1] as const;
+      const right: readonly number[] = [2] as const;
+      const merged = concat(left, right);
+      expectType<typeof merged, readonly number[]>('=');
+      assert.deepStrictEqual<readonly number[]>(merged, [1, 2]);
     });
     // testArrayEquality({