ts-data-forge 14.6.2 → 14.6.4

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

@@ -2,55 +2,55 @@ import { Uint32 } from '../../number/index.mjs';
 import { isEmpty } from './array-utils-length-bounded-array-guard.mjs';
 import { size } from './array-utils-size.mjs';
 import { sliceClamped } from './array-utils-slice-clamped.mjs';
-/**
- * Returns all elements of an array except the first one.
- *
- * @example
- *
- * ```ts
- * {
- *   const scientists = ['Ada', 'Grace', 'Katherine'] as const;
- *
- *   const remainder = Arr.tail(scientists);
- *
- *   assert.deepStrictEqual(remainder, ['Grace', 'Katherine']);
- *
- *   assert.isTrue(remainder.length === 2);
- * }
- *
- * {
- *   const values = [1, 2, 3] as const;
- *
- *   const remainder = Arr.rest(values);
- *
- *   const emptyRemainder = Arr.rest([1] as const);
- *
- *   assert.deepStrictEqual(remainder, [2, 3] as const);
- *
- *   assert.deepStrictEqual(emptyRemainder, [] as const);
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const tail = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.slice(1);
-/**
- * Returns all elements of an array except the last one.
- *
- * @example
- *
- * ```ts
- * const queue = ['task-1', 'task-2', 'task-3'] as const;
- *
- * const withoutLast = Arr.butLast(queue);
- *
- * assert.deepStrictEqual(withoutLast, ['task-1', 'task-2']);
- *
- * assert.isTrue(withoutLast.length === 2);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const butLast = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 (isEmpty(array)
     ? []
     : array.slice(0, -1));
@@ -90,16 +90,16 @@ export function skipLast(...args) {
     }
 }
 const skipLastImpl = (array, num) => sliceClamped(array, 0, Uint32.sub(size(array), num));
-/**
- * Alias for `tail`.
- *
- * @see {@link tail}
- */
+
+
+
+
+
 export const rest = tail;
-/**
- * Alias for `skip`.
- *
- * @see {@link skip}
- */
+
+
+
+
+
 export const drop = skip;
 //# sourceMappingURL=array-utils-slicing.mjs.map

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

@@ -1,15 +1,15 @@
 import { IMap } from '../../collections/index.mjs';
 
-import { asUint32, Uint32 } from '../../number/index.mjs';
+import { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';
 import { tp } from '../../others/index.mjs';
-import { seq } from './array-utils-creation.mjs';
+import { newArray, seq } from './array-utils-creation.mjs';
 import { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
 import { size } from './array-utils-size.mjs';
 export function map(...args) {
     switch (args.length) {
         case 2: {
             const [array, mapFn] = args;
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
             return array.map(mapFn);
         }
         case 1: {
@@ -35,38 +35,38 @@ const scanImpl = (array, reducer, init) => {
     }
     return mut_result;
 };
-/**
- * Reverses an array.
- *
- * @example
- *
- * ```ts
- * const tuple = [1, 'two', true] as const;
- *
- * const reversed = Arr.toReversed(tuple);
- *
- * const expected = [true, 'two', 1] as const;
- *
- * assert.deepStrictEqual(reversed, expected);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const toReversed = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.toReversed();
 export function toSorted(array, comparator) {
     return array.toSorted(
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     comparator ??
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         ((x, y) => x - y));
 }
 export function toSortedBy(array, comparatorValueMapper, comparator) {
     return array.toSorted((x, y) => comparator === undefined
-        ? // This branch assumes V is number if comparator is undefined.
-            // The overloads should handle this, but explicit cast might be needed if V is not number.
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        ?
+
+
             comparatorValueMapper(x) -
-                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
                 comparatorValueMapper(y)
         : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
 }
@@ -88,54 +88,54 @@ export function filterNot(...args) {
     }
 }
 const filterNotImpl = (array, predicate) => array.filter((a, i) => !predicate(a, asUint32(i)));
-/**
- * Creates a new array with unique elements.
- *
- * @example
- *
- * ```ts
- * const letters = ['a', 'b', 'a', 'c', 'b'] as const;
- *
- * const uniqueLetters = Arr.uniq(letters);
- *
- * const expected = ['a', 'b', 'c'] as const;
- *
- * assert.deepStrictEqual<readonly string[]>(uniqueLetters, expected);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const uniq = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Array.from(new Set(array));
-/**
- * Creates a new array with unique elements based on a mapped value.
- *
- * @example
- *
- * ```ts
- * const people = [
- *   { id: 1, name: 'Ada' },
- *   { id: 2, name: 'Brian' },
- *   { id: 1, name: 'Alan' },
- *   { id: 3, name: 'Grace' },
- * ] as const;
- *
- * const uniqueById = Arr.uniqBy(people, (person) => person.id);
- *
- * const expected = [
- *   { id: 1, name: 'Ada' },
- *   { id: 2, name: 'Brian' },
- *   { id: 3, name: 'Grace' },
- * ] as const;
- *
- * assert.deepStrictEqual<readonly Readonly<{ id: number; name: string }>[]>(
- *   uniqueById,
- *   expected,
- * );
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const uniqBy = (array, mapFn) => {
     const mut_mappedValues = new Set();
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return array.filter((val) => {
         const mappedValue = mapFn(val);
         if (mut_mappedValues.has(mappedValue))
@@ -187,54 +187,54 @@ export function partition(...args) {
 }
 const partitionImpl = (array, chunkSize) => chunkSize < 2
     ? []
-    : // eslint-disable-next-line total-functions/no-partial-division
+    :
         seq(asUint32(Math.ceil(array.length / chunkSize))).map((i) => array.slice(chunkSize * i, chunkSize * (i + 1)));
-/**
- * Alias for `partition`.
- *
- * @see {@link partition}
- */
+
+
+
+
+
 export const chunk = partition;
-/**
- * Concatenates two arrays.
- *
- * The exact tuple shape is preserved. Additionally, when either input is known
- * to be non-empty (a non-empty tuple or a branded `NonEmptyArray`), the result
- * is branded as non-empty so it is assignable to `NonEmptyArray`.
- *
- * @example
- *
- * ```ts
- * const numbers = [1, 2] as const;
- *
- * const words = ['three', 'four'] as const;
- *
- * const combined = Arr.concat(numbers, words);
- *
- * // Because at least one input is non-empty, the result is assignable to
- * // NonEmptyArray.
- * const nonEmpty: NonEmptyArray<number | string> = combined;
- *
- * const expectedCombined = [1, 2, 'three', 'four'] as const;
- *
- * assert.deepStrictEqual<readonly (number | string)[]>(
- *   combined,
- *   expectedCombined,
- * );
- *
- * assert.isTrue(nonEmpty.length >= 1);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const concat = (array1, array2) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 [...array1, ...array2];
 export function groupBy(...args) {
     switch (args.length) {
         case 2: {
             const [array, grouper] = args;
-            const mut_groups = new Map(); // Store mutable arrays internally
+            const mut_groups = new Map();
             for (const [index, e] of array.entries()) {
-                const key = grouper(e, asUint32(index)); // Ensure index is treated as SizeType.Arr
+                const key = grouper(e, asUint32(index));
                 const mut_group = mut_groups.get(key);
                 if (mut_group !== undefined) {
                     mut_group.push(e);
@@ -243,7 +243,7 @@ export function groupBy(...args) {
                     mut_groups.set(key, [e]);
                 }
             }
-            // Cast to IMap<G, readonly A[]> for the public interface
+
             return IMap.create(mut_groups);
         }
         case 1: {
@@ -252,62 +252,62 @@ export function groupBy(...args) {
         }
     }
 }
-/**
- * Creates an array of tuples by pairing corresponding elements from two arrays.
- *
- * @example
- *
- * ```ts
- * const letters = ['a', 'b', 'c'] as const;
- *
- * const numbers = [1, 2, 3] as const;
- *
- * const pairs = Arr.zip(letters, numbers);
- *
- * const expectedPairs = [
- *   ['a', 1],
- *   ['b', 2],
- *   ['c', 3],
- * ] as const;
- *
- * assert.deepStrictEqual(pairs, expectedPairs);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const zip = (array1, array2) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 seq(Uint32.min(size(array1), size(array2))).map((i) => 
-// Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.
-// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
+
 tp(array1[i], array2[i]));
-/**
- * Computes the cartesian product of arrays.
- * cartesianProduct([[1,2], [3,4]]) => [[1,3], [1,4], [2,3], [2,4]]
- *
- * @example
- *
- *
- * ```ts
- * const sizes = ['S', 'M'] as const;
- *
- * const colors = ['red', 'blue'] as const;
- *
- * const combinations = Arr.cartesianProduct([sizes, colors]);
- *
- * const expectedCombinations = [
- *   ['S', 'red'],
- *   ['S', 'blue'],
- *   ['M', 'red'],
- *   ['M', 'blue'],
- * ] as const;
- *
- * assert.deepStrictEqual(combinations, expectedCombinations);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const cartesianProduct = (arrays) => {
     if (!isNonEmpty(arrays))
         return [[]];
     const [first, ...rest] = arrays;
-    // If first array is empty, the result is empty
+
     if (!isNonEmpty(first))
         return [];
     const restProduct = cartesianProduct(rest);

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

@@ -1,23 +1,23 @@
 import { asUint32, Num } from '../../number/index.mjs';
-/**
- * Type guard that checks if a value is an array.
- *
- * @example
- *
- * ```ts
- * const maybeArray: unknown = [1, 2, 3] as const;
- *
- * const maybeValue: unknown = 'Ada';
- *
- * assert.isTrue(Arr.isArray(maybeArray));
- *
- * assert.isFalse(Arr.isArray(maybeValue));
- *
- * if (Arr.isArray(maybeArray)) {
- *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isArray = (value) => Array.isArray(value);
 export function every(...args) {
     switch (args.length) {
@@ -37,22 +37,22 @@ export function some(...args) {
     }
 }
 const someImpl = (array, predicate) => array.some((a, i) => predicate(a, asUint32(i)));
-/**
- * Checks if an index is within the valid range of an array.
- *
- * @example
- *
- * ```ts
- * const items = ['Ada', 'Grace', 'Katherine'] as const;
- *
- * assert.isTrue(Arr.indexIsInRange(items, 1));
- *
- * assert.isFalse(Arr.indexIsInRange(items, 3));
- *
- * if (Arr.indexIsInRange(items, 2)) {
- *   assert.isTrue(items[2] === 'Katherine');
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const indexIsInRange = (array, index) => Num.isInRange(0, array.length)(index);
 //# sourceMappingURL=array-utils-validation.mjs.map