ts-data-forge 14.6.2 → 14.6.4

package/dist/array/impl/array-utils-length-bounded-tuple-cast.mjs

@@ -59,54 +59,54 @@ const asBoundedLengthTupleImpl = (min, max, xs) => {
     }
     return xs;
 };
-/**
- * Casts an array to the structural empty tuple after checking that it is
- * empty.
- *
- * This is the structural counterpart of `asEmptyArray`, and the length-0
- * specialization of {@link asFixedLengthTuple}.
- *
- * @example
- *
- * ```ts
- * const nothing = Arr.asEmptyTuple([]);
- *
- * // Arr.asEmptyTuple([1]); // throws TypeError
- * ```
- *
- * @template Xs - The input array type (tuple types are preserved).
- * @param xs - The array to cast.
- * @returns `xs` typed as `readonly [] & Xs`.
- * @throws {TypeError} If `xs` is not empty.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const asEmptyTuple = (xs) => {
     if (!isEmptyTuple(xs)) {
         throw new TypeError(`Expected an empty array, got an array of length ${xs.length}`);
     }
     return xs;
 };
-/**
- * Casts an array to `MinLengthTuple<1, E>` after checking that it has at least
- * one element.
- *
- * This is the structural counterpart of `asNonEmptyArray`, and the length-1
- * specialization of {@link asMinLengthTuple}.
- *
- * @example
- *
- * ```ts
- * const values = Arr.asNonEmptyTuple([1, 2, 3]);
- *
- * const first: number = values[0]; // OK — no `undefined`
- *
- * // Arr.asNonEmptyTuple([]); // throws TypeError
- * ```
- *
- * @template Xs - The input array type (tuple types are preserved).
- * @param xs - The array to cast.
- * @returns `xs` typed as `MinLengthTuple<1, Xs[number]> & Xs`.
- * @throws {TypeError} If `xs` is empty.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const asNonEmptyTuple = (xs) => {
     if (!isMinLengthTuple(1, xs)) {
         throw new TypeError('Expected a non-empty array, got an empty array');

package/dist/array/impl/array-utils-length-bounded-tuple-guard.mjs

@@ -1,50 +1,50 @@
-/**
- * Type guard that checks if an array is empty, narrowing it to the structural
- * empty tuple.
- *
- * This is the structural counterpart of `isEmpty`: it narrows to `readonly []`
- * rather than to the branded `FixedLengthArray<0, E>`. Prefer `isEmpty` unless
- * you specifically need the structural type.
- *
- * @example
- *
- * ```ts
- * const values: readonly number[] = [] as const;
- *
- * assert.isTrue(Arr.isEmptyTuple(values));
- *
- * assert.isFalse(Arr.isEmptyTuple([1] as const));
- * ```
- *
- * @template E - The element type.
- * @param array - The array to check.
- * @returns `true` if `array.length === 0`. When `true`, TypeScript narrows
- *   `array` to `readonly []`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isEmptyTuple = (array) => array.length === 0;
-/**
- * Type guard that checks if an array is non-empty, narrowing it to the
- * structural non-empty tuple.
- *
- * This is the structural counterpart of `isNonEmpty`: it narrows to
- * `MinLengthTuple<1, E>` rather than to the branded `MinLengthArray<1, E>`.
- * Prefer `isNonEmpty` unless you specifically need the structural type.
- *
- * @example
- *
- * ```ts
- * const values: readonly number[] = [1, 2] as const;
- *
- * assert.isTrue(Arr.isNonEmptyTuple(values));
- *
- * assert.isFalse(Arr.isNonEmptyTuple([] as const));
- * ```
- *
- * @template E - The element type.
- * @param array - The array to check.
- * @returns `true` if `array.length >= 1`. When `true`, TypeScript narrows
- *   `array` to `MinLengthTuple<1, E>`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isNonEmptyTuple = (array) => array.length >= 1;
 export function isFixedLengthTuple(...args) {
     switch (args.length) {

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

@@ -1,6 +1,6 @@
 import { asPositiveUint32 } from '../../number/index.mjs';
 
-import { create } from './array-utils-creation.mjs';
+import { copy, create } from './array-utils-creation.mjs';
 export function set(...args) {
     switch (args.length) {
         case 3:
@@ -19,7 +19,7 @@ export function toUpdated(...args) {
     }
 }
 const toUpdatedImpl = (array, index, updater) => 
-// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
 array.with(index, updater(array[index]));
 export function toInserted(...args) {
     switch (args.length) {
@@ -30,7 +30,7 @@ export function toInserted(...args) {
     }
 }
 const toInsertedImpl = (array, index, newValue) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.toSpliced(index, 0, newValue);
 export function toRemoved(...args) {
     switch (args.length) {
@@ -50,7 +50,7 @@ export function toPushed(...args) {
     }
 }
 const toPushedImpl = (array, newValue) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.toSpliced(array.length, 0, newValue);
 export function toUnshifted(...args) {
     switch (args.length) {
@@ -61,7 +61,7 @@ export function toUnshifted(...args) {
     }
 }
 const toUnshiftedImpl = (array, newValue) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.toSpliced(0, 0, newValue);
 export function toFilled(...args) {
     switch (args.length) {

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

@@ -14,7 +14,7 @@ export function min(array, comparator) {
 }
 export function max(array, comparator) {
     const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
-    // Find max by finding min with an inverted comparator
+
     return min(array, (x, y) => -cmp(x, y));
 }
 export function minBy(array, comparatorValueMapper, comparator) {
@@ -103,16 +103,16 @@ const joinImpl = (array, separator) => {
         return Result.err(isError(error) ? error : new Error(unknownToString(error)));
     }
 };
-/**
- * Alias for `foldl`.
- *
- * @see {@link foldl}
- */
+
+
+
+
+
 export const reduce = foldl;
-/**
- * Alias for `foldr`.
- *
- * @see {@link foldr}
- */
+
+
+
+
+
 export const reduceRight = foldr;
 //# sourceMappingURL=array-utils-reducing-value.mjs.map

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

@@ -11,7 +11,7 @@ export function find(...args) {
 }
 const findImpl = (array, predicate) => {
     const foundIndex = array.findIndex(
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     predicate);
 
 
@@ -27,7 +27,7 @@ const findImpl = (array, predicate) => {
 
     return foundIndex === -1
         ? Optional.none
-        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        :
             Optional.some(array[foundIndex]);
 };
 export function findLast(...args) {
@@ -40,7 +40,7 @@ export function findLast(...args) {
 }
 const findLastImpl = (array, predicate) => {
     const foundIndex = array.findLastIndex(
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     predicate);
 
 
@@ -56,7 +56,7 @@ const findLastImpl = (array, predicate) => {
 
     return foundIndex === -1
         ? Optional.none
-        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        :
             Optional.some(array[foundIndex]);
 };
 export function findIndex(...args) {
@@ -68,7 +68,7 @@ export function findIndex(...args) {
     }
 }
 const findIndexImpl = (array, predicate) => pipe(array.findIndex(
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 predicate)).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
 export function findLastIndex(...args) {
     switch (args.length) {
@@ -79,7 +79,7 @@ export function findLastIndex(...args) {
     }
 }
 const findLastIndexImpl = (array, predicate) => pipe(array.findLastIndex(
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 predicate)).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
 export function indexOf(...args) {
     switch (args.length) {

package/dist/array/impl/array-utils-set-op.mjs

@@ -1,129 +1,129 @@
-/**
- * Checks if two arrays are equal by comparing their elements.
- *
- * @example
- *
- * ```ts
- * const numbers = [1, 2, 3] as const;
- *
- * const sameNumbers = [1, 2, 3] as const;
- *
- * const differentNumbers = [1, 2, 4] as const;
- *
- * assert.isTrue(Arr.eq(numbers, sameNumbers));
- *
- * assert.isFalse(Arr.eq(numbers, differentNumbers));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const eq = (array1, array2, equality = Object.is) => array1.length === array2.length &&
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
     array1.every((v, i) => equality(v, array2[i]));
-/**
- * Alias for `eq`.
- *
- * @see {@link eq}
- */
+
+
+
+
+
 export const equal = eq;
-/**
- * Checks if the first array is a subset of the second array.
- *
- * @example
- *
- * ```ts
- * const subset = [1, 2] as const;
- *
- * const superset = [1, 2, 3] as const;
- *
- * const notSubset = [2, 4] as const;
- *
- * assert.isTrue(Arr.isSubset(subset, superset));
- *
- * assert.isFalse(Arr.isSubset(notSubset, superset));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isSubset = (array1, array2) => array1.every((a) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array2.includes(a));
-/**
- * Checks if the first array is a superset of the second array.
- *
- * @example
- *
- * ```ts
- * const potentialSuperset = ['a', 'b', 'c'] as const;
- *
- * const subset = ['a', 'c'] as const;
- *
- * const notSuperset = ['a', 'd'] as const;
- *
- * assert.isTrue(Arr.isSuperset(potentialSuperset, subset));
- *
- * assert.isFalse(Arr.isSuperset(subset, potentialSuperset));
- *
- * assert.isFalse(Arr.isSuperset(potentialSuperset, notSuperset));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isSuperset = (array1, array2) => isSubset(array2, array1);
-/**
- * Returns the intersection of two arrays.
- *
- * @example
- *
- * ```ts
- * const refs = ['Ada', 'Alan', 'Grace'] as const;
- *
- * const attendees = ['Grace', 'Alan', 'Barbara'] as const;
- *
- * const both = Arr.setIntersection(refs, attendees);
- *
- * assert.deepStrictEqual(both, ['Alan', 'Grace']);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const setIntersection = (array1, array2) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array1.filter((e) => array2.includes(e));
-/**
- * Returns the set difference of two arrays (elements in first but not in second).
- *
- * @example
- *
- * ```ts
- * const baseline = [1, 2, 3, 4] as const;
- *
- * const removed = [2, 4] as const;
- *
- * const remaining = Arr.setDifference(baseline, removed);
- *
- * assert.deepStrictEqual(remaining, [1, 3]);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const setDifference = (array1, array2) => array1.filter((e) => !array2.includes(e));
-/**
- * Returns the set difference of two sorted numeric arrays (optimized for sorted arrays).
- *
- * @example
- *
- * ```ts
- * const upcoming = [1, 3, 5, 7, 9] as const;
- *
- * const completed = [3, 4, 7] as const;
- *
- * const remaining = Arr.sortedNumSetDifference(upcoming, completed);
- *
- * const expected = [1, 5, 9] as const;
- *
- * assert.deepStrictEqual(remaining, expected);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const sortedNumSetDifference = (sortedList1, sortedList2) => {
     const mut_result = [];
-    let mut_it1 = 0; // iterator for sortedList1
-    let mut_it2 = 0; // iterator for sortedList2
+    let mut_it1 = 0;
+    let mut_it2 = 0;
     while (mut_it1 < sortedList1.length && mut_it2 < sortedList2.length) {
-        // Non-null assertions are safe due to loop condition
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
+
         const val1 = sortedList1[mut_it1];
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
         const val2 = sortedList2[mut_it2];
         if (val1 === val2) {
             mut_it1 += 1;
@@ -134,13 +134,13 @@ export const sortedNumSetDifference = (sortedList1, sortedList2) => {
             mut_it1 += 1;
         }
         else {
-            // val1 > val2
+
             mut_it2 += 1;
         }
     }
-    // Add remaining elements from sortedList1
+
     for (; mut_it1 < sortedList1.length; mut_it1 += 1) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
         mut_result.push(sortedList1[mut_it1]);
     }
     return mut_result;

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

@@ -1,10 +1,10 @@
 export const size = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.length;
-/**
- * Alias for `size`.
- *
- * @see {@link size}
- */
+
+
+
+
+
 export const length = size;
 //# sourceMappingURL=array-utils-size.mjs.map

package/dist/array/impl/array-utils-slice-clamped.mjs

@@ -9,7 +9,7 @@ export function sliceClamped(...args) {
 }
 const sliceClampedImpl = (array, start, end) => {
     const startClamped = Num.clamp(0, array.length)(start);
-    // Ensure endClamped is not less than startClamped.
+
     const endClamped = Num.clamp(startClamped, array.length)(end);
     return array.slice(startClamped, endClamped);
 };