ts-data-forge 14.6.2 → 14.6.3

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

@@ -1,118 +1,118 @@
 
 import { range as rangeIterator } from '../../iterator/index.mjs';
-/**
- * Creates an array of zeros with the specified length.
- *
- * @example
- *
- * ```ts
- * const emptyZeros = Arr.zeros(0);
- *
- * const threeZeros = Arr.zeros(3);
- *
- * assert.deepStrictEqual(emptyZeros, []);
- *
- * assert.deepStrictEqual(threeZeros, [0, 0, 0]);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const zeros = (len) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Array.from({ length: len }, () => 0);
-/**
- * Creates a sequence of consecutive integers from 0 to `len-1`.
- *
- * @example
- *
- * ```ts
- * const emptySeq = Arr.seq(0);
- *
- * const firstFive = Arr.seq(5);
- *
- * assert.deepStrictEqual(emptySeq, []);
- *
- * assert.deepStrictEqual(firstFive, [0, 1, 2, 3, 4]);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const seq = (len) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Array.from({ length: len }, (_, i) => i);
-/**
- * Creates a new array of the specified length, filled with the initial value.
- *
- * @example
- *
- * ```ts
- * const threeOnes = Arr.create(3, 1);
- *
- * const emptyStrings = Arr.create(0, 'Ada');
- *
- * assert.deepStrictEqual(threeOnes, [1, 1, 1]);
- *
- * assert.deepStrictEqual(emptyStrings, []);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const create = (len, init) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Array.from({ length: Math.max(0, len) }, () => init);
-/**
- * Alias for `create`.
- *
- * @see {@link create}
- */
+
+
+
+
+
 export const newArray = create;
-/**
- * Generates an array from a generator function.
- *
- * @example
- *
- * ```ts
- * const numbers = Arr.generate(function* () {
- *   yield 1;
- *
- *   yield 2;
- *
- *   yield 3;
- * });
- *
- * assert.deepStrictEqual(numbers, [1, 2, 3]);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const generate = (generatorFn) => Array.from(generatorFn());
-/**
- * Generates an array from an async generator function.
- *
- * @example
- *
- * ```ts
- * const values = await Arr.generateAsync(async function* () {
- *   yield 'Ada';
- *
- *   await Promise.resolve();
- *
- *   yield 'Lovelace';
- * });
- *
- * assert.deepStrictEqual(values, ['Ada', 'Lovelace']);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const generateAsync = (generatorFn) => Array.fromAsync(generatorFn());
-/**
- * Creates a shallow copy of an array.
- *
- * @example
- *
- * ```ts
- * const original = [{ id: 1 }, { id: 2 }] as const;
- *
- * const cloned = Arr.copy(original);
- *
- * assert.deepStrictEqual(cloned, original);
- *
- * assert.notStrictEqual(cloned, original);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const copy = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 array.slice();
 
 

package/dist/array/impl/array-utils-element-access.mjs

@@ -9,56 +9,56 @@ export function at(...args) {
 }
 const atImpl = (array, index) => pipe(index < 0 ? array.length + index : index).map((normalizedIndex) => normalizedIndex < 0 || normalizedIndex >= array.length
     ? Optional.none
-    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    :
         Optional.some(array[normalizedIndex])).value;
-/**
- * Returns the first element of an array as an Optional.
- *
- * @example
- *
- * ```ts
- * const users = [{ id: 1 }, { id: 2 }] as const;
- *
- * const empty: readonly Readonly<{ id: number }>[] = [] as const;
- *
- * const first = Arr.head(users);
- *
- * const none = Arr.head(empty);
- *
- * assert.deepStrictEqual(first, Optional.some({ id: 1 }));
- *
- * assert.deepStrictEqual(none, Optional.none);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const head = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 (array.length === 0 ? Optional.none : Optional.some(array.at(0)));
-/**
- * Returns the last element of an array as an Optional.
- *
- * @example
- *
- * ```ts
- * const queue = ['first', 'second'] as const;
- *
- * const emptyQueue: readonly string[] = [] as const;
- *
- * const lastValue = Arr.last(queue);
- *
- * const none = Arr.last(emptyQueue);
- *
- * assert.deepStrictEqual(lastValue, Optional.some('second'));
- *
- * assert.deepStrictEqual(none, Optional.none);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const last = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 (array.length === 0 ? Optional.none : Optional.some(array.at(-1)));
-/**
- * Alias for `head`.
- *
- * @see {@link head}
- */
+
+
+
+
+
 export const first = head;
 //# sourceMappingURL=array-utils-element-access.mjs.map

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

@@ -1,72 +1,72 @@
 import { asUint32 } from '../../number/index.mjs';
-/**
- * Returns an iterator of `[index, value]` pairs for an array.
- *
- * @example
- *
- * ```ts
- * const tags = ['alpha', 'beta', 'gamma'] as const;
- *
- * const entryList = Array.from(
- *   Arr.entries(tags),
- *   ([index, tag]) => [Number(index), tag] as const,
- * );
- *
- * assert.deepStrictEqual(
- *   entryList,
- *   Array.from([
- *     [0, 'alpha'],
- *     [1, 'beta'],
- *     [2, 'gamma'],
- *   ]),
- * );
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const entries = function* (array) {
     for (const [index, value] of array.entries()) {
         yield [asUint32(index), value];
     }
 };
-/**
- * Returns an iterator of values for an array.
- *
- * @example
- *
- * ```ts
- * const players = ['Ada', 'Grace', 'Alan'] as readonly string[];
- *
- * const valueList = Array.from(Arr.values(players));
- *
- * assert.deepStrictEqual(valueList, players);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const values = function* (array) {
     for (const value of array) {
         yield value;
     }
 };
-/**
- * Returns an iterator of indices for an array.
- *
- * @example
- *
- * ```ts
- * const items = ['zero', 'one', 'two'] as const;
- *
- * const indexList = Array.from(Arr.indices(items));
- *
- * assert.deepStrictEqual(indexList, [0, 1, 2]);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const indices = function* (array) {
     for (const key of array.keys()) {
         yield asUint32(key);
     }
 };
-/**
- * Alias for `indices`.
- *
- * @see {@link indices}
- */
+
+
+
+
+
 export const keys = indices;
 //# sourceMappingURL=array-utils-iterators.mjs.map

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

@@ -59,61 +59,61 @@ const asBoundedLengthArrayImpl = (minLength, maxLength, xs) => {
     }
     return xs;
 };
-/**
- * Casts an array to `FixedLengthArray<0, E>` after checking that it is empty.
- *
- * `Arr.isEmpty` narrows to that same type, so this is its cast counterpart —
- * the length-0 specialization of {@link asFixedLengthArray}. Use this instead
- * of writing `xs as unknown as FixedLengthArray<0, E>`: the length is verified
- * at runtime, and the original array type is preserved via intersection.
- *
- * @example
- *
- * ```ts
- * const nothing = Arr.asEmptyArray([]);
- *
- * const atMost5: MaxLengthArray<5, never> = nothing; // OK (0 <= 5)
- *
- * // Arr.asEmptyArray([1]); // throws TypeError
- * ```
- *
- * @template Xs - The input array type (tuple types are preserved).
- * @param xs - The array to cast.
- * @returns `xs` typed as `FixedLengthArray<0, Xs[number]> & Xs`.
- * @throws {TypeError} If `xs` is not empty.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const asEmptyArray = (xs) => {
     if (!isFixedLengthArray(0, xs)) {
         throw new TypeError(`Expected an empty array, got an array of length ${xs.length}`);
     }
     return xs;
 };
-/**
- * Casts an array to `NonEmptyArray<E>` after checking that it has at least one
- * element.
- *
- * `NonEmptyArray<E>` is an alias of `MinLengthArray<1, E>`, so this is the
- * length-1 specialization of {@link asMinLengthArray}. Use this instead of
- * writing `xs as unknown as NonEmptyArray<E>`: the length is verified at
- * runtime, and the original array type (e.g. tuple types) is preserved via
- * intersection, so the result also benefits from the structural tuple prefix
- * (`xs[0]` without `undefined` under `noUncheckedIndexedAccess`).
- *
- * @example
- *
- * ```ts
- * const history = Arr.asNonEmptyArray([0, 1, 2, 3]);
- *
- * const first: number = history[0]; // OK — no `undefined`
- *
- * // Arr.asNonEmptyArray([]); // throws TypeError
- * ```
- *
- * @template Xs - The input array type (tuple types are preserved).
- * @param xs - The array to cast.
- * @returns `xs` typed as `NonEmptyArray<Xs[number]> & Xs`.
- * @throws {TypeError} If `xs` is empty.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const asNonEmptyArray = (xs) => {
     if (!isMinLengthArray(1, xs)) {
         throw new TypeError('Expected a non-empty array, got an empty array');

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

@@ -34,46 +34,46 @@ export function isFixedLengthArray(...args) {
     }
 }
 const hasFixedLength = (length, xs) => xs.length === length;
-/**
- * Type guard that checks if an array is empty.
- *
- * @example
- *
- * ```ts
- * const emptyNumbers: readonly number[] = [] as const;
- *
- * const words = ['Ada', 'Lovelace'] as const;
- *
- * assert.isTrue(Arr.isEmpty(emptyNumbers));
- *
- * assert.isFalse(Arr.isEmpty(words));
- *
- * if (Arr.isEmpty(emptyNumbers)) {
- *   // `isEmpty` narrows to the branded `FixedLengthArray<0, number>`, so the
- *   // expected value is annotated with the unbranded type.
- *   assert.deepStrictEqual<readonly number[]>(emptyNumbers, []);
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isEmpty = (array) => array.length === 0;
-/**
- * Type guard that checks if an array is non-empty.
- *
- * @example
- *
- * ```ts
- * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;
- *
- * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;
- *
- * assert.isTrue(Arr.isNonEmpty(users));
- *
- * assert.isFalse(Arr.isNonEmpty(emptyUsers));
- *
- * if (Arr.isNonEmpty(users)) {
- *   assert.deepStrictEqual(users[0], { id: 1 });
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isNonEmpty = (array) => array.length > 0;
 //# sourceMappingURL=array-utils-length-bounded-array-guard.mjs.map