ts-data-forge 14.0.0 → 14.1.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.
- package/README.md +8 -7
- package/dist/array/impl/array-utils-modification.d.mts +18 -5
- package/dist/array/impl/array-utils-modification.d.mts.map +1 -1
- package/dist/array/impl/array-utils-modification.mjs.map +1 -1
- package/dist/array/impl/array-utils-slice-clamped.d.mts.map +1 -1
- package/dist/array/impl/array-utils-slice-clamped.mjs.map +1 -1
- package/dist/array/impl/array-utils-transformation.d.mts +12 -4
- package/dist/array/impl/array-utils-transformation.d.mts.map +1 -1
- package/dist/array/impl/array-utils-transformation.mjs +4 -5
- package/dist/array/impl/array-utils-transformation.mjs.map +1 -1
- package/dist/array/impl/array-utils-validation.d.mts +8 -3
- package/dist/array/impl/array-utils-validation.d.mts.map +1 -1
- package/dist/array/impl/array-utils-validation.mjs.map +1 -1
- package/dist/collections/imap-mapped.mjs +1 -1
- package/dist/collections/imap-mapped.mjs.map +1 -1
- package/dist/collections/imap.d.mts +1 -1
- package/dist/collections/imap.mjs +1 -1
- package/dist/collections/imap.mjs.map +1 -1
- package/dist/collections/iset-mapped.d.mts +2 -2
- package/dist/collections/iset-mapped.d.mts.map +1 -1
- package/dist/collections/iset-mapped.mjs.map +1 -1
- package/dist/collections/iset.d.mts +2 -2
- package/dist/collections/iset.d.mts.map +1 -1
- package/dist/collections/iset.mjs.map +1 -1
- package/dist/functional/match.d.mts.map +1 -1
- package/dist/functional/match.mjs.map +1 -1
- package/dist/number/branded-types/int.d.mts +1 -1
- package/dist/number/branded-types/int16.d.mts +1 -1
- package/dist/number/branded-types/int32.d.mts +1 -1
- package/dist/number/branded-types/non-negative-int16.d.mts +1 -1
- package/dist/number/branded-types/non-negative-int32.d.mts +1 -1
- package/dist/number/branded-types/non-positive-finite-number.mjs +1 -1
- package/dist/number/branded-types/non-positive-finite-number.mjs.map +1 -1
- package/dist/number/branded-types/positive-int.d.mts +1 -1
- package/dist/number/branded-types/positive-int16.d.mts +1 -1
- package/dist/number/branded-types/positive-int32.d.mts +1 -1
- package/dist/number/branded-types/positive-safe-int.d.mts +1 -1
- package/dist/number/branded-types/positive-uint16.d.mts +1 -1
- package/dist/number/branded-types/positive-uint32.d.mts +1 -1
- package/dist/number/branded-types/safe-int.d.mts +1 -1
- package/dist/number/branded-types/safe-uint.d.mts +1 -1
- package/dist/number/branded-types/uint.d.mts +1 -1
- package/dist/number/branded-types/uint16.d.mts +1 -1
- package/dist/number/branded-types/uint32.d.mts +1 -1
- package/dist/number/enum/int8.d.mts +2 -2
- package/dist/number/enum/int8.d.mts.map +1 -1
- package/dist/number/enum/int8.mjs.map +1 -1
- package/dist/number/enum/uint8.d.mts +2 -2
- package/dist/number/enum/uint8.d.mts.map +1 -1
- package/dist/number/enum/uint8.mjs.map +1 -1
- package/dist/number/num-arithmetic-types.d.mts +9 -10
- package/dist/number/num-arithmetic-types.d.mts.map +1 -1
- package/dist/number/refined-number-utils.d.mts +2 -2
- package/dist/number/refined-number-utils.d.mts.map +1 -1
- package/dist/number/refined-number-utils.mjs.map +1 -1
- package/dist/object/object.d.mts +12 -12
- package/dist/object/object.d.mts.map +1 -1
- package/dist/object/object.mjs +5 -1
- package/dist/object/object.mjs.map +1 -1
- package/dist/others/fast-deep-equal.d.mts.map +1 -1
- package/dist/others/fast-deep-equal.mjs +2 -2
- package/dist/others/fast-deep-equal.mjs.map +1 -1
- package/package.json +4 -5
- package/src/array/impl/array-utils-creation.test.mts +10 -8
- package/src/array/impl/array-utils-length-constraint-preservation.test.mts +2 -2
- package/src/array/impl/array-utils-modification.mts +41 -33
- package/src/array/impl/array-utils-modification.test.mts +77 -4
- package/src/array/impl/array-utils-shape-invariants.test.mts +526 -0
- package/src/array/impl/array-utils-slice-clamped.mts +2 -1
- package/src/array/impl/array-utils-slicing.test.mts +11 -3
- package/src/array/impl/array-utils-transformation.mts +70 -20
- package/src/array/impl/array-utils-transformation.test.mts +44 -10
- package/src/array/impl/array-utils-validation.mts +54 -10
- package/src/array/impl/array-utils-validation.test.mts +153 -3
- package/src/collections/imap-mapped.mts +1 -1
- package/src/collections/imap-mapped.test.mts +2 -2
- package/src/collections/imap.mts +2 -2
- package/src/collections/iset-mapped.mts +7 -3
- package/src/collections/iset-mapped.test.mts +1 -1
- package/src/collections/iset.mts +7 -3
- package/src/collections/iset.test.mts +9 -6
- package/src/functional/match.mts +5 -4
- package/src/functional/result.test.mts +5 -2
- package/src/guard/is-primitive.test.mts +1 -1
- package/src/guard/is-record.test.mts +4 -4
- package/src/guard/is-type.test.mts +2 -2
- package/src/number/branded-types/finite-number.test.mts +2 -2
- package/src/number/branded-types/non-negative-finite-number.test.mts +2 -2
- package/src/number/branded-types/non-positive-finite-number.mts +1 -1
- package/src/number/branded-types/non-positive-finite-number.test.mts +5 -9
- package/src/number/branded-types/non-zero-finite-number.test.mts +2 -2
- package/src/number/branded-types/positive-finite-number.test.mts +2 -2
- package/src/number/enum/int8.mts +2 -1
- package/src/number/enum/uint8.mts +6 -2
- package/src/number/num-arithmetic-types.mts +129 -24
- package/src/number/num.test.mts +11 -11
- package/src/number/refined-number-utils.mts +2 -1
- package/src/object/object.mts +29 -17
- package/src/object/object.test.mts +2 -1
- package/src/others/fast-deep-equal.mts +6 -4
package/README.md
CHANGED
|
@@ -269,9 +269,9 @@ assert.isTrue(clamp(-10) === 0);
|
|
|
269
269
|
// Rounding utilities
|
|
270
270
|
const round2 = Num.round(2);
|
|
271
271
|
|
|
272
|
-
assert.isTrue(round2(
|
|
272
|
+
assert.isTrue(round2(1.234_56) === 1.23);
|
|
273
273
|
|
|
274
|
-
assert.isTrue(Num.roundAt(
|
|
274
|
+
assert.isTrue(Num.roundAt(1.234_56, 3) === 1.235);
|
|
275
275
|
|
|
276
276
|
assert.isTrue(Num.roundToInt(3.7) === 4);
|
|
277
277
|
|
|
@@ -309,7 +309,7 @@ const integer = asInt(42); // Int - any integer
|
|
|
309
309
|
|
|
310
310
|
const unsigned = asUint(42); // Uint - non-negative integer
|
|
311
311
|
|
|
312
|
-
const finite = asFiniteNumber(
|
|
312
|
+
const finite = asFiniteNumber(1.23); // FiniteNumber - finite floating-point
|
|
313
313
|
|
|
314
314
|
const safeInt = asSafeInt(42); // SafeInt - integer in safe range
|
|
315
315
|
|
|
@@ -317,13 +317,13 @@ assert.isTrue(integer === 42);
|
|
|
317
317
|
|
|
318
318
|
assert.isTrue(unsigned === 42);
|
|
319
319
|
|
|
320
|
-
assert.isTrue(finite ===
|
|
320
|
+
assert.isTrue(finite === 1.23);
|
|
321
321
|
|
|
322
322
|
assert.isTrue(safeInt === 42);
|
|
323
323
|
|
|
324
324
|
// This line would cause a runtime error:
|
|
325
325
|
assert.throw(() => {
|
|
326
|
-
asInt(
|
|
326
|
+
asInt(1.23);
|
|
327
327
|
});
|
|
328
328
|
|
|
329
329
|
// Range-constrained types (16-bit, 32-bit)
|
|
@@ -372,6 +372,7 @@ The `Arr` object provides a rich set of functions for array manipulation.
|
|
|
372
372
|
|
|
373
373
|
```tsx
|
|
374
374
|
import { Arr, expectType, Optional } from 'ts-data-forge';
|
|
375
|
+
import { type FixedLengthTuple, type MinLengthTuple } from 'ts-type-forge';
|
|
375
376
|
|
|
376
377
|
const numbers: readonly number[] = [1, 2, 3, 4, 5, 2, 3] as const;
|
|
377
378
|
|
|
@@ -383,7 +384,7 @@ assert.isTrue(sum === 20);
|
|
|
383
384
|
// Type-safe length checking
|
|
384
385
|
if (Arr.isMinLengthTuple(2, numbers)) {
|
|
385
386
|
// numbers is now guaranteed to have at least 2 elements
|
|
386
|
-
expectType<typeof numbers,
|
|
387
|
+
expectType<typeof numbers, MinLengthTuple<2, number>>('=');
|
|
387
388
|
|
|
388
389
|
assert.isTrue(numbers[1] === 2); // Safe access to index 1
|
|
389
390
|
}
|
|
@@ -399,7 +400,7 @@ const unique = Arr.uniq(numbers);
|
|
|
399
400
|
assert.deepStrictEqual(unique, [1, 2, 3, 4, 5]);
|
|
400
401
|
|
|
401
402
|
// Array creation
|
|
402
|
-
const zeros:
|
|
403
|
+
const zeros: FixedLengthTuple<5, 0> = Arr.zeros(5);
|
|
403
404
|
|
|
404
405
|
assert.deepStrictEqual(zeros, [0, 0, 0, 0, 0]);
|
|
405
406
|
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { type ChangeArrayElement, type ConstrainedList, type FixedLengthTuple, type
|
|
1
|
+
import { type ChangeArrayElement, type ConstrainedList, type FixedLengthTuple, type Increment, type IsFixedLengthList, type NonEmptyArray, type UnknownBrand } from 'ts-type-forge';
|
|
2
2
|
import { type ArgArrayIndex, type ArgArrayIndexWithNegative, type SizeType } from '../../types.mjs';
|
|
3
3
|
/**
|
|
4
4
|
* Returns a new array with an element at the specified index replaced.
|
|
@@ -141,8 +141,13 @@ export declare function toUnshifted<const V>(newValue: V): <const Ar extends rea
|
|
|
141
141
|
* assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);
|
|
142
142
|
* ```
|
|
143
143
|
*/
|
|
144
|
-
export declare function toFilled<const Ar extends readonly unknown[], const V>(array: Ar, value: V):
|
|
145
|
-
export declare function toFilled<const
|
|
144
|
+
export declare function toFilled<const Ar extends readonly unknown[] & UnknownBrand, const V>(array: Ar, value: V): ChangeArrayElement<Ar, V>;
|
|
145
|
+
export declare function toFilled<const Ar extends readonly unknown[], const V>(array: Ar, value: V): Readonly<{
|
|
146
|
+
[K in keyof Ar]: V;
|
|
147
|
+
}>;
|
|
148
|
+
export declare function toFilled<const V>(value: V): (<const Ar extends readonly unknown[] & UnknownBrand>(array: Ar) => ChangeArrayElement<Ar, V>) & (<const Ar extends readonly unknown[]>(array: Ar) => Readonly<{
|
|
149
|
+
[K in keyof Ar]: V;
|
|
150
|
+
}>);
|
|
146
151
|
/**
|
|
147
152
|
* Returns a new array with elements in the specified range replaced by the specified value.
|
|
148
153
|
*
|
|
@@ -160,14 +165,22 @@ export declare function toFilled<const V>(value: V): <const Ar extends readonly
|
|
|
160
165
|
* assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);
|
|
161
166
|
* ```
|
|
162
167
|
*/
|
|
168
|
+
export declare function toRangeFilled<const Ar extends readonly unknown[] & UnknownBrand, const V>(array: Ar, value: V, fillRange: readonly [
|
|
169
|
+
start: ArgArrayIndexWithNegative<Ar>,
|
|
170
|
+
end: ArgArrayIndexWithNegative<Ar>
|
|
171
|
+
]): ChangeArrayElement<Ar, V | Ar[number]>;
|
|
163
172
|
export declare function toRangeFilled<const Ar extends readonly unknown[], const V>(array: Ar, value: V, fillRange: readonly [
|
|
164
173
|
start: ArgArrayIndexWithNegative<Ar>,
|
|
165
174
|
end: ArgArrayIndexWithNegative<Ar>
|
|
166
|
-
]):
|
|
175
|
+
]): Readonly<{
|
|
176
|
+
[K in keyof Ar]: V | Ar[number];
|
|
177
|
+
}>;
|
|
167
178
|
export declare function toRangeFilled<const V>(value: V, fillRange: readonly [
|
|
168
179
|
start: SizeType.ArgArrWithNegative,
|
|
169
180
|
end: SizeType.ArgArrWithNegative
|
|
170
|
-
]): <const Ar extends readonly unknown[]>(array: Ar) =>
|
|
181
|
+
]): (<const Ar extends readonly unknown[] & UnknownBrand>(array: Ar) => ChangeArrayElement<Ar, V | Ar[number]>) & (<const Ar extends readonly unknown[]>(array: Ar) => Readonly<{
|
|
182
|
+
[K in keyof Ar]: V | Ar[number];
|
|
183
|
+
}>);
|
|
171
184
|
/**
|
|
172
185
|
* The result of replacing the element at `I` of `Ar` with a `V`.
|
|
173
186
|
*
|
|
@@ -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,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,
|
|
1
|
+
{"version":3,"file":"array-utils-modification.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-modification.mts"],"names":[],"mappings":"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"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":["import {\n type ChangeArrayElement,\n type ConstrainedList,\n type FixedLengthTuple,\n type HasLengthConstraint,\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<\n const Ar extends readonly unknown[],\n const I extends ArgArrayIndex<Ar>,\n const V = Ar[number],\n>(array: Ar, index: I, newValue: V): ReplacedAt<Ar, I, V>;\n\n// curried version\nexport function set<const I extends SizeType.ArgArr, const V>(\n index: I,\n newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => ReplacedAt<Ar, I, V>;\n\nexport function set<E, const V = E>(\n ...args:\n | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n switch (args.length) {\n case 3:\n return setImpl(...args);\n\n case 2:\n return (array) => setImpl(array, ...args);\n }\n}\n\nconst setImpl = <E, const V = E>(\n array: readonly E[],\n index: SizeType.ArgArr,\n newValue: V,\n): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<2, 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 I extends ArgArrayIndex<Ar>,\n const V = Ar[number],\n>(array: Ar, index: I, updater: (prev: Ar[number]) => V): ReplacedAt<Ar, I, V>;\n\n// curried version\nexport function toUpdated<const I extends SizeType.ArgArr, E, const V = E>(\n index: I,\n updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(array: Ar) => ReplacedAt<Ar, I, V>;\n\nexport function toUpdated<E, V = E>(\n ...args:\n | readonly [\n array: readonly E[],\n index: SizeType.ArgArr,\n updater: (prev: E) => V,\n ]\n | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n switch (args.length) {\n case 3:\n return toUpdatedImpl(...args);\n\n case 2:\n return (array) => toUpdatedImpl(array, ...args);\n }\n}\n\nconst toUpdatedImpl = <E, V = E>(\n array: readonly E[],\n index: SizeType.ArgArr,\n updater: (prev: E) => V,\n): readonly (E | V)[] =>\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n (array as readonly (E | V)[]).with(index, updater(array[index]!));\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n const Ar extends readonly unknown[],\n const V = Ar[number],\n>(\n array: Ar,\n index: ArgArrayIndexWithNegative<Ar>,\n newValue: V,\n): IsFixedLengthList<Ar> extends true\n ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n index: SizeType.ArgArrWithNegative,\n newValue: V,\n): <const Ar extends readonly unknown[]>(\n array: Ar,\n) => IsFixedLengthList<Ar> extends true\n ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n ...args:\n | readonly [\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n newValue: V,\n ]\n | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n switch (args.length) {\n case 3:\n return toInsertedImpl(...args);\n\n case 2:\n return (array) => toInsertedImpl(array, ...args);\n }\n}\n\nconst toInsertedImpl = <E, const V = E>(\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n newValue: V,\n): NonEmptyArray<E | V> =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n (array as readonly (E | V)[]).toSpliced(\n index,\n 0,\n newValue,\n ) as unknown as NonEmptyArray<E | V>;\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n array: Ar,\n index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n ...args:\n | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return toRemovedImpl(...args);\n\n case 1:\n return (array) => toRemovedImpl(array, ...args);\n }\n}\n\nconst toRemovedImpl = <E,>(\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n): readonly E[] => array.toSpliced(index, 1);\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = appended;\n *\n * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const V>(\n newValue: V,\n): <const Ar extends readonly unknown[]>(\n array: Ar,\n) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n switch (args.length) {\n case 2:\n return toPushedImpl(...args);\n\n case 1:\n return (array) => toPushedImpl(array, ...args);\n }\n}\n\nconst toPushedImpl = <const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [...Ar, V] =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = prefixed;\n *\n * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<const V>(\n newValue: V,\n): <const Ar extends readonly unknown[]>(\n array: Ar,\n) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n switch (args.length) {\n case 2:\n return toUnshiftedImpl(...args);\n\n case 1:\n return (array) => toUnshiftedImpl(array, ...args);\n }\n}\n\nconst toUnshiftedImpl = <Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [V, ...Ar] =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n array: Ar,\n value: V,\n): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, 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) => HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, V>\n : IsFixedLengthList<Ar> extends true\n ? FixedLengthTuple<Ar['length'], V>\n : Ar extends NonEmptyTuple<unknown>\n ? NonEmptyArray<V>\n : readonly V[];\n\nexport function toFilled<E>(\n ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return toFilledImpl(...args);\n\n case 1:\n return (array) => toFilledImpl(array, ...args);\n }\n}\n\nconst toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>\n create(asPositiveUint32(array.length), value);\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<const Ar extends readonly unknown[], const V>(\n array: Ar,\n value: V,\n fillRange: readonly [\n start: ArgArrayIndexWithNegative<Ar>,\n end: ArgArrayIndexWithNegative<Ar>,\n ],\n): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, V | Ar[number]>\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) => HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, V | Ar[number]>\n : IsFixedLengthList<Ar> extends true\n ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n : Ar extends NonEmptyTuple<unknown>\n ? NonEmptyArray<V | Ar[number]>\n : readonly (V | Ar[number])[];\n\nexport function toRangeFilled<E, const V>(\n ...args:\n | readonly [\n array: readonly E[],\n value: V,\n fillRange: readonly [\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n ],\n ]\n | readonly [\n value: V,\n fillRange: readonly [\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n ],\n ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n switch (args.length) {\n case 3:\n return toRangeFilledImpl(...args);\n\n case 2:\n return (array) => toRangeFilledImpl(array, ...args);\n }\n}\n\nconst toRangeFilledImpl = <E, const V>(\n array: readonly E[],\n value: V,\n fillRange: readonly [\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n ],\n): readonly (E | V)[] => {\n const [start, end] = fillRange;\n\n const mut_cp: (E | V)[] = castMutable(copy(array));\n\n mut_cp.fill(value, start, end);\n\n return mut_cp;\n};\n\n/**\n * The result of replacing the element at `I` of `Ar` with a `V`.\n *\n * `ConstrainedList.SetAt` replaces exactly one position when the index pins\n * one, which is what makes `Arr.set(xs, 1, v)` report `readonly [a, V, c]`\n * instead of widening every position to `a | V`.\n *\n * A union index needs the weaker answer, and this used to guard for it here:\n * `ArgArrayIndex<Ar>` for a tuple is the union of its indices, so\n * `Arr.set(tuple, someIndex, v)` with `someIndex: 0 | 2` binds `I = 0 | 2`, and\n * the upstream `List.SetAt` used to answer `readonly [V, b, V]` — a type that\n * *neither* possible runtime result satisfies, since the call replaces one\n * position or the other and never both.\n *\n * ts-type-forge 9.1.1 fixes that at the source and widens the candidate\n * positions itself, so the guard is gone. Upstream is the more precise of the\n * two: it widens only the positions the index can name, where the guard here\n * widened all of them — `Arr.set(t, i, 'x')` with `i: 0 | 2` on\n * `readonly [1, 2, 3]` now keeps the middle element at `2` rather than\n * reporting `2 | 'x'`.\n */\ntype ReplacedAt<\n Ar extends readonly unknown[],\n I extends number,\n V,\n> = ConstrainedList.SetAt<I, V, Ar>;\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 ChangeArrayElement,\n type ConstrainedList,\n type FixedLengthTuple,\n type Increment,\n type IsFixedLengthList,\n type NonEmptyArray,\n type UnknownBrand,\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<\n const Ar extends readonly unknown[],\n const I extends ArgArrayIndex<Ar>,\n const V = Ar[number],\n>(array: Ar, index: I, newValue: V): ReplacedAt<Ar, I, V>;\n\n// curried version\nexport function set<const I extends SizeType.ArgArr, const V>(\n index: I,\n newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => ReplacedAt<Ar, I, V>;\n\nexport function set<E, const V = E>(\n ...args:\n | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n switch (args.length) {\n case 3:\n return setImpl(...args);\n\n case 2:\n return (array) => setImpl(array, ...args);\n }\n}\n\nconst setImpl = <E, const V = E>(\n array: readonly E[],\n index: SizeType.ArgArr,\n newValue: V,\n): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<2, 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 I extends ArgArrayIndex<Ar>,\n const V = Ar[number],\n>(array: Ar, index: I, updater: (prev: Ar[number]) => V): ReplacedAt<Ar, I, V>;\n\n// curried version\nexport function toUpdated<const I extends SizeType.ArgArr, E, const V = E>(\n index: I,\n updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(array: Ar) => ReplacedAt<Ar, I, V>;\n\nexport function toUpdated<E, V = E>(\n ...args:\n | readonly [\n array: readonly E[],\n index: SizeType.ArgArr,\n updater: (prev: E) => V,\n ]\n | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n switch (args.length) {\n case 3:\n return toUpdatedImpl(...args);\n\n case 2:\n return (array) => toUpdatedImpl(array, ...args);\n }\n}\n\nconst toUpdatedImpl = <E, V = E>(\n array: readonly E[],\n index: SizeType.ArgArr,\n updater: (prev: E) => V,\n): readonly (E | V)[] =>\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n (array as readonly (E | V)[]).with(index, updater(array[index]!));\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n const Ar extends readonly unknown[],\n const V = Ar[number],\n>(\n array: Ar,\n index: ArgArrayIndexWithNegative<Ar>,\n newValue: V,\n): IsFixedLengthList<Ar> extends true\n ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n index: SizeType.ArgArrWithNegative,\n newValue: V,\n): <const Ar extends readonly unknown[]>(\n array: Ar,\n) => IsFixedLengthList<Ar> extends true\n ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n ...args:\n | readonly [\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n newValue: V,\n ]\n | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n switch (args.length) {\n case 3:\n return toInsertedImpl(...args);\n\n case 2:\n return (array) => toInsertedImpl(array, ...args);\n }\n}\n\nconst toInsertedImpl = <E, const V = E>(\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n newValue: V,\n): NonEmptyArray<E | V> =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n (array as readonly (E | V)[]).toSpliced(\n index,\n 0,\n newValue,\n ) as unknown as NonEmptyArray<E | V>;\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n array: Ar,\n index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n ...args:\n | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return toRemovedImpl(...args);\n\n case 1:\n return (array) => toRemovedImpl(array, ...args);\n }\n}\n\nconst toRemovedImpl = <E,>(\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n): readonly E[] => array.toSpliced(index, 1);\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = appended;\n *\n * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const V>(\n newValue: V,\n): <const Ar extends readonly unknown[]>(\n array: Ar,\n) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n switch (args.length) {\n case 2:\n return toPushedImpl(...args);\n\n case 1:\n return (array) => toPushedImpl(array, ...args);\n }\n}\n\nconst toPushedImpl = <const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [...Ar, V] =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = prefixed;\n *\n * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<const V>(\n newValue: V,\n): <const Ar extends readonly unknown[]>(\n array: Ar,\n) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n switch (args.length) {\n case 2:\n return toUnshiftedImpl(...args);\n\n case 1:\n return (array) => toUnshiftedImpl(array, ...args);\n }\n}\n\nconst toUnshiftedImpl = <Ar extends readonly unknown[], const V>(\n array: Ar,\n newValue: V,\n): readonly [V, ...Ar] =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<\n const Ar extends readonly unknown[] & UnknownBrand,\n const V,\n>(array: Ar, value: V): ChangeArrayElement<Ar, V>;\n\n// For an array or tuple that carries no length brand the homomorphic mapping\n// already covers every case the conditional spelled out — a fixed-length tuple\n// keeps its length, `readonly [A, ...A[]]` stays non-empty, and `readonly A[]`\n// stays unbounded. Stating it directly is what keeps this usable from a\n// caller that is itself generic over the array: a conditional a *generic* `Ar`\n// cannot decide stays deferred, and its branded branch is then not assignable\n// to the caller's own mapping.\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n array: Ar,\n value: V,\n): Readonly<{ [K in keyof Ar]: V }>;\n\n// curried version — the two cases have to be overloads of the *returned*\n// function, spelled as an intersection of function types (see `Arr.map`).\nexport function toFilled<const V>(\n value: V,\n): (<const Ar extends readonly unknown[] & UnknownBrand>(\n array: Ar,\n) => ChangeArrayElement<Ar, V>) &\n (<const Ar extends readonly unknown[]>(\n array: Ar,\n ) => Readonly<{ [K in keyof Ar]: V }>);\n\nexport function toFilled<E>(\n ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return toFilledImpl(...args);\n\n case 1:\n return (array) => toFilledImpl(array, ...args);\n }\n}\n\nconst toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>\n create(asPositiveUint32(array.length), value);\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<\n const Ar extends readonly unknown[] & UnknownBrand,\n const V,\n>(\n array: Ar,\n value: V,\n fillRange: readonly [\n start: ArgArrayIndexWithNegative<Ar>,\n end: ArgArrayIndexWithNegative<Ar>,\n ],\n): ChangeArrayElement<Ar, V | Ar[number]>;\n\n// See `toFilled` for why the unbranded case states the homomorphic mapping\n// directly instead of going through a conditional.\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): Readonly<{ [K in keyof Ar]: 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[] & UnknownBrand>(\n array: Ar,\n) => ChangeArrayElement<Ar, V | Ar[number]>) &\n (<const Ar extends readonly unknown[]>(\n array: Ar,\n ) => Readonly<{ [K in keyof Ar]: V | Ar[number] }>);\n\nexport function toRangeFilled<E, const V>(\n ...args:\n | readonly [\n array: readonly E[],\n value: V,\n fillRange: readonly [\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n ],\n ]\n | readonly [\n value: V,\n fillRange: readonly [\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n ],\n ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n switch (args.length) {\n case 3:\n return toRangeFilledImpl(...args);\n\n case 2:\n return (array) => toRangeFilledImpl(array, ...args);\n }\n}\n\nconst toRangeFilledImpl = <E, const V>(\n array: readonly E[],\n value: V,\n fillRange: readonly [\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n ],\n): readonly (E | V)[] => {\n const [start, end] = fillRange;\n\n const mut_cp: (E | V)[] = castMutable(copy(array));\n\n mut_cp.fill(value, start, end);\n\n return mut_cp;\n};\n\n/**\n * The result of replacing the element at `I` of `Ar` with a `V`.\n *\n * `ConstrainedList.SetAt` replaces exactly one position when the index pins\n * one, which is what makes `Arr.set(xs, 1, v)` report `readonly [a, V, c]`\n * instead of widening every position to `a | V`.\n *\n * A union index needs the weaker answer, and this used to guard for it here:\n * `ArgArrayIndex<Ar>` for a tuple is the union of its indices, so\n * `Arr.set(tuple, someIndex, v)` with `someIndex: 0 | 2` binds `I = 0 | 2`, and\n * the upstream `List.SetAt` used to answer `readonly [V, b, V]` — a type that\n * *neither* possible runtime result satisfies, since the call replaces one\n * position or the other and never both.\n *\n * ts-type-forge 9.1.1 fixes that at the source and widens the candidate\n * positions itself, so the guard is gone. Upstream is the more precise of the\n * two: it widens only the positions the index can name, where the guard here\n * widened all of them — `Arr.set(t, i, 'x')` with `i: 0 | 2` on\n * `readonly [1, 2, 3]` now keeps the middle element at `2` rather than\n * reporting `2 | 'x'`.\n */\ntype ReplacedAt<\n Ar extends readonly unknown[],\n I extends number,\n V,\n> = ConstrainedList.SetAt<I, V, Ar>;\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CO,SAAS,OACX,IAAA,EAGiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,OAAA,CAAQ,GAAG,IAAI,CAAA;AAAA,IAExB,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,OAAA,CAAQ,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAE9C;AAEA,MAAM,OAAA,GAAU,CACd,KAAA,EACA,KAAA,EACA,aACwB,KAAA,CAA6B,IAAA,CAAK,OAAO,QAAQ,CAAA;AAkCpE,SAAS,aACX,IAAA,EAOiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,aAAA,CAAc,GAAG,IAAI,CAAA;AAAA,IAE9B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,aAAA,CAAc,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEpD;AAEA,MAAM,aAAA,GAAgB,CACpB,KAAA,EACA,KAAA,EACA,OAAA;AAAA;AAAA,EAGC,MAA6B,IAAA,CAAK,KAAA,EAAO,QAAQ,KAAA,CAAM,KAAK,CAAE,CAAC;AAAA,CAAA;AAwC3D,SAAS,cACX,IAAA,EAOqE;AACxE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,cAAA,CAAe,GAAG,IAAI,CAAA;AAAA,IAE/B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,cAAA,CAAe,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAErD;AAEA,MAAM,cAAA,GAAiB,CACrB,KAAA,EACA,KAAA,EACA,QAAA;AAAA;AAAA,EAGC,KAAA,CAA6B,SAAA;AAAA,IAC5B,KAAA;AAAA,IACA,CAAA;AAAA,IACA;AAAA;AACF,CAAA;AA8BK,SAAS,aACX,IAAA,EAGqD;AACxD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,aAAA,CAAc,GAAG,IAAI,CAAA;AAAA,IAE9B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,aAAA,CAAc,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEpD;AAEA,MAAM,gBAAgB,CACpB,KAAA,EACA,UACiB,KAAA,CAAM,SAAA,CAAU,OAAO,CAAC,CAAA;AAmCpC,SAAS,YACX,IAAA,EACyD;AAC5D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,YAAA,CAAa,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEnD;AAEA,MAAM,YAAA,GAAe,CACnB,KAAA,EACA,QAAA;AAAA;AAAA,EAGA,KAAA,CAAM,SAAA,CAAU,KAAA,CAAM,MAAA,EAAQ,GAAG,QAAQ;AAAA,CAAA;AAmCpC,SAAS,eACX,IAAA,EACyD;AAC5D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,eAAA,CAAgB,GAAG,IAAI,CAAA;AAAA,IAEhC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,eAAA,CAAgB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEtD;AAEA,MAAM,eAAA,GAAkB,CACtB,KAAA,EACA,QAAA;AAAA;AAAA,EAGA,KAAA,CAAM,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,QAAQ;AAAA,CAAA;AA+CzB,SAAS,YACX,IAAA,EACqD;AACxD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,YAAA,CAAa,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEnD;AAEA,MAAM,YAAA,GAAe,CAAK,KAAA,EAAqB,KAAA,KAC7C,OAAO,gBAAA,CAAiB,KAAA,CAAM,MAAM,CAAA,EAAG,KAAK,CAAA;AAwDvC,SAAS,iBACX,IAAA,EAgBiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,iBAAA,CAAkB,GAAG,IAAI,CAAA;AAAA,IAElC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,iBAAA,CAAkB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAExD;AAEA,MAAM,iBAAA,GAAoB,CACxB,KAAA,EACA,KAAA,EACA,SAAA,KAIuB;AACvB,EAAA,MAAM,CAAC,KAAA,EAAO,GAAG,CAAA,GAAI,SAAA;AAErB,EAAA,MAAM,MAAA,GAAoB,WAAA,CAAY,IAAA,CAAK,KAAK,CAAC,CAAA;AAEjD,EAAA,MAAA,CAAO,IAAA,CAAK,KAAA,EAAO,KAAA,EAAO,GAAG,CAAA;AAE7B,EAAA,OAAO,MAAA;AACT,CAAA;;;;"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"array-utils-slice-clamped.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-slice-clamped.mts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"array-utils-slice-clamped.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-slice-clamped.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC9D,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,EACpC,GAAG,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACjC,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;AAEzB,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAClC,GAAG,EAAE,QAAQ,CAAC,kBAAkB,GAC/B,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"array-utils-slice-clamped.mjs","sources":["../../../src/array/impl/array-utils-slice-clamped.mts"],"sourcesContent":["import { Num } from '../../number/index.mjs';\nimport { type ArgArrayIndexWithNegative, type SizeType } from '../../types.mjs';\n\n/**\n * Slices an array with automatically clamped start and end indices.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd', 'e'] as readonly string[];\n *\n * const lastThree = Arr.sliceClamped(letters, -3, 10);\n *\n * const middleTwo = Arr.sliceClamped(1, 3)(letters);\n *\n * assert.deepStrictEqual(lastThree, ['a', 'b', 'c', 'd', 'e']);\n *\n * assert.deepStrictEqual(middleTwo, ['b', 'c']);\n * ```\n */\nexport function sliceClamped<const Ar extends readonly unknown[]>(\n array: Ar,\n start: ArgArrayIndexWithNegative<Ar>,\n end: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function sliceClamped(\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function sliceClamped<E>(\n ...args:\n | readonly [\n readonly E[],\n SizeType.ArgArrWithNegative,\n SizeType.ArgArrWithNegative,\n ]\n |
|
|
1
|
+
{"version":3,"file":"array-utils-slice-clamped.mjs","sources":["../../../src/array/impl/array-utils-slice-clamped.mts"],"sourcesContent":["import { type FixedLengthTuple } from 'ts-type-forge';\nimport { Num } from '../../number/index.mjs';\nimport { type ArgArrayIndexWithNegative, type SizeType } from '../../types.mjs';\n\n/**\n * Slices an array with automatically clamped start and end indices.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd', 'e'] as readonly string[];\n *\n * const lastThree = Arr.sliceClamped(letters, -3, 10);\n *\n * const middleTwo = Arr.sliceClamped(1, 3)(letters);\n *\n * assert.deepStrictEqual(lastThree, ['a', 'b', 'c', 'd', 'e']);\n *\n * assert.deepStrictEqual(middleTwo, ['b', 'c']);\n * ```\n */\nexport function sliceClamped<const Ar extends readonly unknown[]>(\n array: Ar,\n start: ArgArrayIndexWithNegative<Ar>,\n end: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function sliceClamped(\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function sliceClamped<E>(\n ...args:\n | readonly [\n readonly E[],\n SizeType.ArgArrWithNegative,\n SizeType.ArgArrWithNegative,\n ]\n | FixedLengthTuple<2, SizeType.ArgArrWithNegative>\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 3:\n return sliceClampedImpl(...args);\n\n case 2:\n return (array) => sliceClampedImpl(array, ...args);\n }\n}\n\nconst sliceClampedImpl = <E,>(\n array: readonly E[],\n start: SizeType.ArgArrWithNegative,\n end: SizeType.ArgArrWithNegative,\n): readonly E[] => {\n const startClamped = Num.clamp(0, array.length)(start);\n\n // Ensure endClamped is not less than startClamped.\n const endClamped = Num.clamp(startClamped, array.length)(end);\n\n return array.slice(startClamped, endClamped);\n};\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCO,SAAS,gBACX,IAAA,EAOqD;AACxD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,gBAAA,CAAiB,GAAG,IAAI,CAAA;AAAA,IAEjC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,gBAAA,CAAiB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEvD;AAEA,MAAM,gBAAA,GAAmB,CACvB,KAAA,EACA,KAAA,EACA,GAAA,KACiB;AACjB,EAAA,MAAM,eAAe,GAAA,CAAI,KAAA,CAAM,GAAG,KAAA,CAAM,MAAM,EAAE,KAAK,CAAA;AAGrD,EAAA,MAAM,aAAa,GAAA,CAAI,KAAA,CAAM,cAAc,KAAA,CAAM,MAAM,EAAE,GAAG,CAAA;AAE5D,EAAA,OAAO,KAAA,CAAM,KAAA,CAAM,YAAA,EAAc,UAAU,CAAA;AAC7C,CAAA;;;;"}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { type BoundedLengthArray, type ChangeArrayElement, type ConstrainedList, type FixedLengthTuple, type HasLengthConstraint, type IsFixedLengthList, type NonEmptyArray, type NonEmptyTuple, type PositiveInt, type Primitive, type SafeUintWithSmallInt, type SupportedLength, type WithSmallInt } from 'ts-type-forge';
|
|
1
|
+
import { type BoundedLengthArray, type ChangeArrayElement, type ConstrainedList, type FixedLengthTuple, type HasLengthConstraint, type IsFixedLengthList, type NonEmptyArray, type NonEmptyTuple, type PositiveInt, type Primitive, type SafeUintWithSmallInt, type SupportedLength, type UnknownBrand, type WithSmallInt } from 'ts-type-forge';
|
|
2
2
|
import { IMap } from '../../collections/index.mjs';
|
|
3
3
|
import { type ArrayIndex, type MapSetKeyType, type SizeType } from '../../types.mjs';
|
|
4
4
|
/**
|
|
@@ -20,8 +20,13 @@ import { type ArrayIndex, type MapSetKeyType, type SizeType } from '../../types.
|
|
|
20
20
|
* assert.deepStrictEqual(indexed, ['0:1', '1:2', '2:3']);
|
|
21
21
|
* ```
|
|
22
22
|
*/
|
|
23
|
-
export declare function map<const Ar extends readonly unknown[], B>(array: Ar, mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B): ChangeArrayElement<Ar, B>;
|
|
24
|
-
export declare function map<
|
|
23
|
+
export declare function map<const Ar extends readonly unknown[] & UnknownBrand, B>(array: Ar, mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B): ChangeArrayElement<Ar, B>;
|
|
24
|
+
export declare function map<const Ar extends readonly unknown[], B>(array: Ar, mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B): Readonly<{
|
|
25
|
+
[K in keyof Ar]: B;
|
|
26
|
+
}>;
|
|
27
|
+
export declare function map<A, B>(mapFn: (a: A, index: SizeType.Arr) => B): (<const Ar extends readonly A[] & UnknownBrand>(array: Ar) => ChangeArrayElement<Ar, B>) & (<const Ar extends readonly A[]>(array: Ar) => Readonly<{
|
|
28
|
+
[K in keyof Ar]: B;
|
|
29
|
+
}>);
|
|
25
30
|
/**
|
|
26
31
|
* Returns an array of successively reduced values from an array.
|
|
27
32
|
*
|
|
@@ -96,7 +101,10 @@ export declare const toReversed: <const Ar extends readonly unknown[]>(array: Ar
|
|
|
96
101
|
* assert.deepStrictEqual(alphabetical, expectedWords);
|
|
97
102
|
* ```
|
|
98
103
|
*/
|
|
99
|
-
export declare
|
|
104
|
+
export declare function toSorted<const Ar extends readonly number[]>(array: Ar, comparator?: (x: Ar[number], y: Ar[number]) => number): SortedResult<Ar>;
|
|
105
|
+
export declare function toSorted<const Ar extends readonly unknown[]>(array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number): SortedResult<Ar>;
|
|
106
|
+
/** The result of sorting `Ar`: same elements, same length, same bounds. */
|
|
107
|
+
type SortedResult<Ar extends readonly unknown[]> = HasLengthConstraint<Ar> extends true ? ChangeArrayElement<Ar, Ar[number]> : IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], Ar[number]> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][];
|
|
100
108
|
/**
|
|
101
109
|
* Sorts an array by a mapped value.
|
|
102
110
|
*
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"array-utils-transformation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-transformation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAEhB,KAAK,SAAS,EACd,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAInD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,iBAAiB,CAAC;AAKzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,GAAG,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,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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"}
|
|
@@ -80,14 +80,13 @@ const toReversed = (array) => (
|
|
|
80
80
|
// eslint-disable-next-line total-functions/no-unsafe-type-assertion
|
|
81
81
|
array.toReversed()
|
|
82
82
|
);
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
array.toSorted(
|
|
83
|
+
function toSorted(array, comparator) {
|
|
84
|
+
return array.toSorted(
|
|
86
85
|
// eslint-disable-next-line total-functions/no-unsafe-type-assertion
|
|
87
86
|
comparator ?? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
|
|
88
87
|
((x, y) => x - y)
|
|
89
|
-
)
|
|
90
|
-
|
|
88
|
+
);
|
|
89
|
+
}
|
|
91
90
|
function toSortedBy(array, comparatorValueMapper, comparator) {
|
|
92
91
|
return array.toSorted(
|
|
93
92
|
(x, y) => comparator === void 0 ? (
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":["import {\n type BoundedLengthArray,\n type ChangeArrayElement,\n type ConstrainedList,\n type FixedLengthTuple,\n type HasLengthConstraint,\n type IsFixedLengthList,\n type NonEmptyArray,\n type NonEmptyTuple,\n type PositiveInt,\n type PositiveUint32,\n type Primitive,\n type SafeUintWithSmallInt,\n type SupportedLength,\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 { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';\nimport { size } from './array-utils-size.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): ChangeArrayElement<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[]>(array: Ar) => ChangeArrayElement<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 return scanImpl(...args);\n\n case 2:\n return (array) => scanImpl(array, ...args);\n }\n}\n\nconst scanImpl = <E, S>(\n array: readonly E[],\n reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,\n init: S,\n): NonEmptyTuple<S> => {\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/**\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): ConstrainedList.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): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, Ar[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): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, Ar[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): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, Ar[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 return filterImpl(...args);\n\n case 1:\n return (array) => filterImpl(array, ...args);\n }\n}\n\nconst filterImpl = <E,>(\n array: readonly E[],\n predicate: (a: E, index: SizeType.Arr) => boolean,\n): readonly E[] => array.filter((a, i) => predicate(a, asUint32(i)));\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 return filterNotImpl(...args);\n\n case 1:\n return (array) => filterNotImpl(array, ...args);\n }\n}\n\nconst filterNotImpl = <E,>(\n array: readonly E[],\n predicate: (a: E, index: SizeType.Arr) => boolean,\n): readonly E[] => array.filter((a, i) => !predicate(a, asUint32(i)));\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 return flatImpl(...args);\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) => flatImpl(array, depth);\n }\n\n if (arrayOrDepth === undefined) {\n return (array) => flatImpl(array, 1);\n }\n\n expectType<typeof arrayOrDepth, readonly E[]>('=');\n\n return arrayOrDepth.flat();\n }\n\n case 0:\n return (array) => flatImpl(array, 1);\n }\n}\n\nconst flatImpl = (\n array: readonly unknown[],\n depth?: SafeUintWithSmallInt,\n): readonly unknown[] => array.flat(depth);\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 * // Every chunk is branded `BoundedLengthArray<1, N, …>` — `partition` never\n * // emits an empty chunk — so the expected values are annotated with the\n * // unbranded type.\n * const expectedPairs = [[1, 2], [3, 4], [5]] as const;\n *\n * assert.deepStrictEqual<readonly (readonly number[])[]>(\n * pairs,\n * expectedPairs,\n * );\n *\n * assert.deepStrictEqual<readonly (readonly number[])[]>(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<readonly (readonly number[])[]>(pairs2, [\n * [1, 2],\n * [3, 4],\n * [5, 6],\n * ]);\n * ```\n */\nexport function partition<\n E,\n N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n>(array: readonly E[], chunkSize: N): readonly PartitionChunk<N, E>[];\n\nexport function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n chunkSize: N,\n): <E>(array: readonly E[]) => readonly PartitionChunk<N, E>[];\n\nexport function partition<\n E,\n N extends WithSmallInt<PositiveInt & SizeType.Arr>,\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 return partitionImpl(...args);\n\n case 1:\n return (array) => partitionImpl(array, ...args);\n }\n}\n\n/**\n * Element type of {@link partition}'s result: a chunk holds between 1 and `N`\n * elements. The lower bound is what makes this worth spelling out — `partition`\n * never emits an empty chunk, so indexed access into a chunk is not\n * `undefined` at position `0`, unlike with a plain `readonly E[]`.\n *\n * Falls back to {@link NonEmptyArray} when `N` is not a bound the brand can\n * express, which keeps that lower bound in every case.\n */\ntype PartitionChunk<N, E> = N extends SupportedLength\n ? BoundedLengthArray<1, N, E>\n : NonEmptyArray<E>;\n\nconst partitionImpl = <E, N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n array: readonly E[],\n chunkSize: N,\n): readonly (readonly E[])[] =>\n chunkSize < 2\n ? ([] as const)\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 * Alias for `partition`.\n *\n * @see {@link partition}\n */\nexport const chunk = partition;\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): ConstrainedList.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 ConstrainedList.Zip<Ar1, Ar2>;\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 BoundedLengthArray,\n type ChangeArrayElement,\n type ConstrainedList,\n type FixedLengthTuple,\n type HasLengthConstraint,\n type IsFixedLengthList,\n type NonEmptyArray,\n type NonEmptyTuple,\n type PositiveInt,\n type PositiveUint32,\n type Primitive,\n type SafeUintWithSmallInt,\n type SupportedLength,\n type UnknownBrand,\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 { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';\nimport { size } from './array-utils-size.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[] & UnknownBrand, B>(\n array: Ar,\n mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B,\n): ChangeArrayElement<Ar, B>;\n\n// A plain array or tuple carries no length brand, so the homomorphic mapping\n// is the whole answer. Stating it directly — rather than going through\n// `ChangeArrayElement`, whose `HasLengthConstraint` test a *generic* `Ar`\n// cannot decide — is what keeps `map` usable inside a function that is itself\n// generic over the tuple: a deferred conditional is not assignable to the\n// caller's own `{ [K in keyof Ar]: B }`, while this is.\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\n//\n// The two cases have to be overloads *of the returned function*, not two\n// overloads of `map` itself: both curried signatures take the same single\n// argument, so overload resolution would always pick the first and the second\n// would be dead.\n//\n// Spelled as an intersection of two function types rather than one object type\n// carrying two call signatures — the `convert-to-readonly` codemod wraps an\n// inline object type in `Readonly<…>`, and a mapped type drops call\n// signatures, which would leave the curried form with none at all.\nexport function map<A, B>(\n mapFn: (a: A, index: SizeType.Arr) => B,\n): (<const Ar extends readonly A[] & UnknownBrand>(\n array: Ar,\n) => ChangeArrayElement<Ar, 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 return scanImpl(...args);\n\n case 2:\n return (array) => scanImpl(array, ...args);\n }\n}\n\nconst scanImpl = <E, S>(\n array: readonly E[],\n reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,\n init: S,\n): NonEmptyTuple<S> => {\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/**\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): ConstrainedList.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 */\n// Numbers sort without a comparator, so it is optional for them and required\n// for everything else.\n//\n// Stated as two overloads rather than one conditional rest-parameter tuple.\n// The conditional form reads well, but a *generic* `Ar` cannot decide it, so\n// the parameter list stayed unresolved and `Arr.toSorted(xs, cmp)` inside a\n// function that is itself generic over the array was rejected outright:\n//\n// Argument of type '[T, (a: number, b: number) => number]' is not\n// assignable to parameter of type 'T extends readonly number[] ? ... : ...'\n//\n// Overload resolution picks a branch per call instead, so both concrete and\n// generic callers work. The *return* type stays conditional — that one a\n// generic caller handles, as `toSortedBy` (same shape) already showed.\nexport function toSorted<const Ar extends readonly number[]>(\n array: Ar,\n comparator?: (x: Ar[number], y: Ar[number]) => number,\n): SortedResult<Ar>;\n\nexport function toSorted<const Ar extends readonly unknown[]>(\n array: Ar,\n comparator: (x: Ar[number], y: Ar[number]) => number,\n): SortedResult<Ar>;\n\nexport function toSorted(\n array: readonly unknown[],\n comparator?: (x: never, y: never) => number,\n): readonly unknown[] {\n return 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 );\n}\n\n/** The result of sorting `Ar`: same elements, same length, same bounds. */\ntype SortedResult<Ar extends readonly unknown[]> =\n HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, Ar[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\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): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, Ar[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): HasLengthConstraint<Ar> extends true\n ? ChangeArrayElement<Ar, Ar[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 return filterImpl(...args);\n\n case 1:\n return (array) => filterImpl(array, ...args);\n }\n}\n\nconst filterImpl = <E,>(\n array: readonly E[],\n predicate: (a: E, index: SizeType.Arr) => boolean,\n): readonly E[] => array.filter((a, i) => predicate(a, asUint32(i)));\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 return filterNotImpl(...args);\n\n case 1:\n return (array) => filterNotImpl(array, ...args);\n }\n}\n\nconst filterNotImpl = <E,>(\n array: readonly E[],\n predicate: (a: E, index: SizeType.Arr) => boolean,\n): readonly E[] => array.filter((a, i) => !predicate(a, asUint32(i)));\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 return flatImpl(...args);\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) => flatImpl(array, depth);\n }\n\n if (arrayOrDepth === undefined) {\n return (array) => flatImpl(array, 1);\n }\n\n expectType<typeof arrayOrDepth, readonly E[]>('=');\n\n return arrayOrDepth.flat();\n }\n\n case 0:\n return (array) => flatImpl(array, 1);\n }\n}\n\nconst flatImpl = (\n array: readonly unknown[],\n depth?: SafeUintWithSmallInt,\n): readonly unknown[] => array.flat(depth);\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 * // Every chunk is branded `BoundedLengthArray<1, N, …>` — `partition` never\n * // emits an empty chunk — so the expected values are annotated with the\n * // unbranded type.\n * const expectedPairs = [[1, 2], [3, 4], [5]] as const;\n *\n * assert.deepStrictEqual<readonly (readonly number[])[]>(\n * pairs,\n * expectedPairs,\n * );\n *\n * assert.deepStrictEqual<readonly (readonly number[])[]>(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<readonly (readonly number[])[]>(pairs2, [\n * [1, 2],\n * [3, 4],\n * [5, 6],\n * ]);\n * ```\n */\nexport function partition<\n E,\n N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n>(array: readonly E[], chunkSize: N): readonly PartitionChunk<N, E>[];\n\nexport function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n chunkSize: N,\n): <E>(array: readonly E[]) => readonly PartitionChunk<N, E>[];\n\nexport function partition<\n E,\n N extends WithSmallInt<PositiveInt & SizeType.Arr>,\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 return partitionImpl(...args);\n\n case 1:\n return (array) => partitionImpl(array, ...args);\n }\n}\n\n/**\n * Element type of {@link partition}'s result: a chunk holds between 1 and `N`\n * elements. The lower bound is what makes this worth spelling out — `partition`\n * never emits an empty chunk, so indexed access into a chunk is not\n * `undefined` at position `0`, unlike with a plain `readonly E[]`.\n *\n * Falls back to {@link NonEmptyArray} when `N` is not a bound the brand can\n * express, which keeps that lower bound in every case.\n */\ntype PartitionChunk<N, E> = N extends SupportedLength\n ? BoundedLengthArray<1, N, E>\n : NonEmptyArray<E>;\n\nconst partitionImpl = <E, N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n array: readonly E[],\n chunkSize: N,\n): readonly (readonly E[])[] =>\n chunkSize < 2\n ? ([] as const)\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 * Alias for `partition`.\n *\n * @see {@link partition}\n */\nexport const chunk = partition;\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): ConstrainedList.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 ConstrainedList.Zip<Ar1, Ar2>;\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,4 +1,4 @@
|
|
|
1
|
-
import { type BoolOr, type IsAny, type IsUnknown } from 'ts-type-forge';
|
|
1
|
+
import { type BoolOr, type ChangeArrayElement, type IsAny, type IsUnknown, type UnknownBrand } from 'ts-type-forge';
|
|
2
2
|
import { type ArrayIndex, type SizeType } from '../../types.mjs';
|
|
3
3
|
/**
|
|
4
4
|
* Type guard that checks if a value is an array.
|
|
@@ -41,9 +41,14 @@ type Cast<A, B> = A extends B ? A : never;
|
|
|
41
41
|
* assert.isFalse(allStartWithA);
|
|
42
42
|
* ```
|
|
43
43
|
*/
|
|
44
|
-
export declare function every<
|
|
45
|
-
export declare function every<
|
|
44
|
+
export declare function every<const Ar extends readonly unknown[] & UnknownBrand, S extends Ar[number]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S): array is ChangeArrayElement<Ar, S> & Ar;
|
|
45
|
+
export declare function every<const Ar extends readonly unknown[], S extends Ar[number]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S): array is Readonly<{
|
|
46
|
+
[K in keyof Ar]: S;
|
|
47
|
+
}> & Ar;
|
|
46
48
|
export declare function every<const Ar extends readonly unknown[]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean): boolean;
|
|
49
|
+
export declare function every<E, S extends E>(predicate: (a: E, index: SizeType.Arr) => a is S): (<const Ar extends readonly E[] & UnknownBrand>(array: Ar) => array is ChangeArrayElement<Ar, S> & Ar) & (<const Ar extends readonly E[]>(array: Ar) => array is Readonly<{
|
|
50
|
+
[K in keyof Ar]: S;
|
|
51
|
+
}> & Ar);
|
|
47
52
|
export declare function every<E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => boolean;
|
|
48
53
|
/**
|
|
49
54
|
* Tests whether at least one element in an array passes a test implemented by a predicate.
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"AAAA,OAAO,
|
|
1
|
+
{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"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"}
|