ts-data-forge 14.6.2 → 14.6.4

package/dist/others/debounce-function.mjs

@@ -1,17 +1,17 @@
-/**
- * Creates a debounced function that delays invoking `func` until after `waitMilliseconds`
- * have elapsed since the last time the debounced function was invoked.
- *
- * @template F The type of the function to debounce.
- * @param func The function to debounce.
- * @param waitMilliseconds The number of milliseconds to delay.
- * @returns The new debounced function.
- */
+
+
+
+
+
+
+
+
+
 export const debounce = (func, waitMilliseconds) => {
-    // Not `ReturnType<typeof setTimeout>`: with both the DOM and Node
-    // declarations in scope that resolves to `unknown`, which `clearTimeout`
-    // will not take. Naming what `clearTimeout` accepts says the same thing and
-    // stays true in either environment.
+
+
+
+
     let mut_timeoutId;
     return (...args) => {
         clearTimeout(mut_timeoutId);

package/dist/others/fast-deep-equal.mjs

@@ -1,11 +1,11 @@
 import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';
 import { hasKey, isRecord } from '../guard/index.mjs';
-/**
- * The fastest deep equal with ES6 Map, Set and Typed arrays support.
- * Checks equality of Date and RegExp objects by value.
- *
- * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst
- */
+
+
+
+
+
+
 export const fastDeepEqual = (a, b) => {
     if (a === b) {
         return true;
@@ -13,7 +13,7 @@ export const fastDeepEqual = (a, b) => {
     if (typeof a !== typeof b) {
         return false;
     }
-    // Arrays are handled before `isRecord`, which excludes them.
+
     if (Array.isArray(a)) {
         return (Array.isArray(b) &&
             a.constructor === b.constructor &&
@@ -57,16 +57,16 @@ export const fastDeepEqual = (a, b) => {
         const bKeys = Object.keys(b);
         return (aKeys.length === bKeys.length &&
             aKeys.every((key) => hasKey(b, key) &&
-                // React-specific: avoid traversing React elements' _owner.
-                //  _owner contains circular references
-                // and is not needed when comparing the actual elements (and not their owners)
-                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+
+
+
+
                 !(key === '_owner' && a['$$typeof']) &&
                 fastDeepEqual(a[key], b[key])));
     }
-    // true if both NaN, false otherwise. `Number.isNaN` takes a number: called
-    // with anything else it is always false, so the check belongs behind a
-    // `typeof` guard rather than relying on that.
+
+
+
     return (typeof a === 'number' &&
         typeof b === 'number' &&
         Number.isNaN(a) &&

package/dist/others/if-then.mjs

@@ -1,32 +1,32 @@
-/**
- * Implements the logical implication (if-then) operator.
- *
- * Returns `true` if the antecedent is `false` or the consequent is `true`. In
- * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨
- * consequent`.
- *
- * **Truth table:**
- *
- * - `true → true` = `true` (valid implication)
- * - `true → false` = `false` (invalid implication)
- * - `false → true` = `true` (vacuously true)
- * - `false → false` = `true` (vacuously true)
- *
- * @param antecedent - The condition (if part)
- * @param consequent - The result that should hold if the condition is true
- *   (then part)
- * @returns `true` if the implication holds, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const ifThen = (antecedent, consequent) => !antecedent || consequent;
-/**
- * Alias for {@link ifThen}.
- *
- * Implements the logical implication (if-then) operator.
- *
- * @param antecedent - The condition (if part)
- * @param consequent - The result that should hold if the condition is true
- *   (then part)
- * @returns `true` if the implication holds, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
+
 export const implies = ifThen;
 //# sourceMappingURL=if-then.mjs.map

package/dist/others/tuple.mjs

@@ -1,52 +1,52 @@
-/**
- * Creates a readonly tuple from the given arguments with precise literal type
- * inference. It is a convenient shorthand for `[...args] as const`.
- *
- * @example
- *
- * ```ts
- * // Create a tuple with literal types preserved
- * const coordinates = tp(10, 20, 30);
- *
- * expectType<typeof coordinates, readonly [10, 20, 30]>('=');
- *
- * expectType<typeof coordinates, readonly number[]>('!=');
- *
- * assert.deepStrictEqual(coordinates, [10, 20, 30]);
- *
- * // The following two are equivalent
- * const a = tp(1, 2);
- *
- * const b = [1, 2] as const;
- *
- * expectType<typeof a, typeof b>('=');
- *
- * assert.deepStrictEqual(a, b);
- *
- * // Without tp, type would be number[]
- * const point = tp('x', 42, true);
- *
- * expectType<typeof point, readonly ['x', 42, true]>('=');
- *
- * assert.deepStrictEqual(point, ['x', 42, true]);
- *
- * // Useful for creating const tuples
- * const rgb = tp(255, 128, 0);
- *
- * expectType<typeof rgb, readonly [255, 128, 0]>('=');
- *
- * assert.isTrue(rgb[0] === 255);
- *
- * assert.isTrue(rgb[1] === 128);
- *
- * assert.isTrue(rgb[2] === 0);
- * ```
- *
- * @template T - A tuple type with literal types inferred from the arguments
- * @param args - The elements to include in the tuple (variadic)
- * @returns A readonly tuple containing the provided arguments with preserved
- *   literal types
- * @see https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const tp = (...args) => args;
 //# sourceMappingURL=tuple.mjs.map

package/dist/others/unknown-to-string.mjs

@@ -1,38 +1,38 @@
 import { isDate, isError, isMap, isRegExp, isSet } from '@sindresorhus/is';
-/**
- * Converts an unknown value to its string representation in a type-safe manner.
- *
- * This function handles all JavaScript types and provides consistent string
- * conversion with proper error handling for edge cases like circular
- * references. Unlike naive toString() calls, this function never throws and
- * handles all value types gracefully.
- *
- * **Type conversion rules:**
- *
- * - Strings: returned as-is
- * - Numbers, booleans, bigints: converted via toString()
- * - Symbols: converted to their description string
- * - Functions: converted to their string representation
- * - null: returns "null" (not "null" from JSON)
- * - undefined: returns "undefined"
- * - Date: converted to ISO string
- * - RegExp: converted to regex literal string
- * - Map: converted to Map representation with entries
- * - Set: converted to Set representation with values
- * - Error: returns error message
- * - Objects: JSON stringified (with optional pretty printing)
- *
- * @param value - The unknown value to convert to string
- * @param options - Optional configuration for the conversion
- * @param options.prettyPrintObject - If true, objects are formatted with
- *   2-space indentation
- * @returns The string representation of the value. For circular references or
- *   non-serializable objects, returns an error message string
- *
- *   **Error Handling:** Circular references and non-serializable objects return
- *   descriptive error messages instead of throwing
- * @see JSON.stringify - Underlying serialization for objects
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unknownToString = (value, options) => {
     switch (typeof value) {
         case 'string':
@@ -51,11 +51,11 @@ export const unknownToString = (value, options) => {
                 return 'null';
             }
             try {
-                // Special handling for Date
+
                 if (isDate(value)) {
                     return value.toISOString();
                 }
-                // Special handling for RegExp
+
                 if (isRegExp(value)) {
                     return value.toString();
                 }
@@ -63,7 +63,7 @@ export const unknownToString = (value, options) => {
                     return value.message;
                 }
                 const prettyPrintObject = options?.prettyPrintObject === true;
-                // Special handling for Map
+
                 if (isMap(value)) {
                     const entries = Array.from(value);
                     const entriesStr = prettyPrintObject
@@ -71,7 +71,7 @@ export const unknownToString = (value, options) => {
                         : JSON.stringify(entries);
                     return `Map(${entriesStr})`;
                 }
-                // Special handling for Set
+
                 if (isSet(value)) {
                     const values = Array.from(value);
                     const valuesStr = prettyPrintObject

package/dist/promise/promise.mjs

@@ -1,51 +1,51 @@
 import { Result } from '../functional/index.mjs';
-/**
- * Creates a Promise that wraps the result in a Result type for type-safe error
- * handling. This function is an alternative to `new Promise(executor)` that
- * provides enhanced type safety by returning a Result type instead of throwing
- * exceptions.
- *
- * @example
- *
- * ```ts
- * // Create a promise that resolves successfully
- * const successPromise = createPromise<number, string>((resolve) => {
- *   setTimeout(() => {
- *     resolve(42);
- *   }, 0);
- * });
- *
- * const successResult = await successPromise;
- *
- * assert.isTrue(Result.isOk(successResult));
- *
- * if (Result.isOk(successResult)) {
- *   assert.isTrue(successResult.value === 42);
- * }
- *
- * // Create a promise that rejects with an error
- * const errorPromise = createPromise<number, string>((_, reject) => {
- *   setTimeout(() => {
- *     reject('Something went wrong');
- *   }, 0);
- * });
- *
- * const errorResult = await errorPromise;
- *
- * assert.isTrue(Result.isErr(errorResult));
- *
- * if (Result.isErr(errorResult)) {
- *   assert.isTrue(errorResult.value === 'Something went wrong');
- * }
- * ```
- *
- * @template S - The type of successful value
- * @template E - The type of error value
- * @param executor - Function that takes resolve and reject callbacks
- * @returns A Promise that resolves to a Result containing either success or
- *   error
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const createPromise = (executor) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Result.fromPromise(new Promise(executor));
 //# sourceMappingURL=promise.mjs.map