data-structure-typed 2.1.0 → 2.1.1

package/dist/esm/utils/utils.js

@@ -1,325 +0,0 @@
-/**
- * The function generates a random UUID (Universally Unique Identifier) in TypeScript.
- * @returns A randomly generated UUID (Universally Unique Identifier) in the format
- * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' where each 'x' is replaced with a random hexadecimal
- * character.
- */
-export const uuidV4 = function () {
-    return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-};
-/**
- * The `arrayRemove` function removes elements from an array based on a specified predicate function
- * and returns the removed elements.
- * @param {T[]} array - An array of elements that you want to filter based on the provided predicate
- * function.
- * @param predicate - The `predicate` parameter is a function that takes three arguments:
- * @returns The `arrayRemove` function returns an array containing the elements that satisfy the given
- * `predicate` function.
- */
-export const arrayRemove = function (array, predicate) {
-    let i = -1, len = array ? array.length : 0;
-    const result = [];
-    while (++i < len) {
-        const value = array[i];
-        if (predicate(value, i, array)) {
-            result.push(value);
-            Array.prototype.splice.call(array, i--, 1);
-            len--;
-        }
-    }
-    return result;
-};
-/**
- * The function `getMSB` returns the most significant bit of a given number.
- * @param {number} value - The `value` parameter is a number for which we want to find the position of
- * the Most Significant Bit (MSB). The function `getMSB` takes this number as input and calculates the
- * position of the MSB in its binary representation.
- * @returns The function `getMSB` returns the most significant bit (MSB) of the input `value`. If the
- * input value is less than or equal to 0, it returns 0. Otherwise, it calculates the position of the
- * MSB using the `Math.clz32` function and bitwise left shifts 1 to that position.
- */
-export const getMSB = (value) => {
-    if (value <= 0) {
-        return 0;
-    }
-    return 1 << (31 - Math.clz32(value));
-};
-/**
- * The `rangeCheck` function in TypeScript is used to validate if an index is within a specified range
- * and throws a `RangeError` with a custom message if it is out of bounds.
- * @param {number} index - The `index` parameter represents the value that you want to check if it
- * falls within a specified range.
- * @param {number} min - The `min` parameter represents the minimum value that the `index` should be
- * compared against in the `rangeCheck` function.
- * @param {number} max - The `max` parameter in the `rangeCheck` function represents the maximum value
- * that the `index` parameter is allowed to have. If the `index` is greater than this `max` value, a
- * `RangeError` will be thrown.
- * @param [message=Index out of bounds.] - The `message` parameter is a string that represents the
- * error message to be thrown if the index is out of bounds. By default, if no message is provided when
- * calling the `rangeCheck` function, the message "Index out of bounds." will be used.
- */
-export const rangeCheck = (index, min, max, message = 'Index out of bounds.') => {
-    if (index < min || index > max)
-        throw new RangeError(message);
-};
-/**
- * The function `throwRangeError` throws a RangeError with a custom message if called.
- * @param [message=The value is off-limits.] - The `message` parameter is a string that represents the
- * error message to be displayed when a `RangeError` is thrown. If no message is provided, the default
- * message is 'The value is off-limits.'.
- */
-export const throwRangeError = (message = 'The value is off-limits.') => {
-    throw new RangeError(message);
-};
-/**
- * The function `isWeakKey` checks if the input is an object or a function in TypeScript.
- * @param {unknown} input - The `input` parameter in the `isWeakKey` function is of type `unknown`,
- * which means it can be any type. The function checks if the `input` is an object (excluding `null`)
- * or a function, and returns a boolean indicating whether the `input` is a weak
- * @returns The function `isWeakKey` returns a boolean value indicating whether the input is an object
- * or a function.
- */
-export const isWeakKey = (input) => {
-    const inputType = typeof input;
-    return (inputType === 'object' && input !== null) || inputType === 'function';
-};
-/**
- * The function `calcMinUnitsRequired` calculates the minimum number of units required to accommodate a
- * given total quantity based on a specified unit size.
- * @param {number} totalQuantity - The `totalQuantity` parameter represents the total quantity of items
- * that need to be processed or handled.
- * @param {number} unitSize - The `unitSize` parameter represents the size of each unit or package. It
- * is used in the `calcMinUnitsRequired` function to calculate the minimum number of units required to
- * accommodate a total quantity of items.
- */
-export const calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
-/**
- * The `roundFixed` function in TypeScript rounds a number to a specified number of decimal places.
- * @param {number} num - The `num` parameter is a number that you want to round to a certain number of
- * decimal places.
- * @param {number} [digit=10] - The `digit` parameter in the `roundFixed` function specifies the number
- * of decimal places to round the number to. By default, it is set to 10 if not provided explicitly.
- * @returns The function `roundFixed` returns a number that is rounded to the specified number of
- * decimal places (default is 10 decimal places).
- */
-export const roundFixed = (num, digit = 10) => {
-    const multiplier = Math.pow(10, digit);
-    return Math.round(num * multiplier) / multiplier;
-};
-/**
- * The function `isPrimitiveComparable` checks if a value is a primitive type that can be compared.
- * @param {unknown} value - The `value` parameter in the `isPrimitiveComparable` function is of type
- * `unknown`, which means it can be any type. The function checks if the `value` is a primitive type
- * that can be compared, such as number, bigint, string, or boolean.
- * @returns The function `isPrimitiveComparable` returns a boolean value indicating whether the input
- * `value` is a primitive value that can be compared using standard comparison operators (<, >, <=,
- * >=).
- */
-function isPrimitiveComparable(value) {
-    const valueType = typeof value;
-    if (valueType === 'number')
-        return true;
-    // if (valueType === 'number') return !Number.isNaN(value);
-    return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';
-}
-/**
- * The function `tryObjectToPrimitive` attempts to convert an object to a comparable primitive value by
- * first checking the `valueOf` method and then the `toString` method.
- * @param {object} obj - The `obj` parameter in the `tryObjectToPrimitive` function is an object that
- * you want to convert to a primitive value. The function attempts to convert the object to a primitive
- * value by first checking if the object has a `valueOf` method. If the `valueOf` method exists, it
- * @returns The function `tryObjectToPrimitive` returns a value of type `ComparablePrimitive` if a
- * primitive comparable value is found within the object, or a string value if the object has a custom
- * `toString` method that does not return `'[object Object]'`. If neither condition is met, the
- * function returns `null`.
- */
-function tryObjectToPrimitive(obj) {
-    if (typeof obj.valueOf === 'function') {
-        const valueOfResult = obj.valueOf();
-        if (valueOfResult !== obj) {
-            if (isPrimitiveComparable(valueOfResult))
-                return valueOfResult;
-            if (typeof valueOfResult === 'object' && valueOfResult !== null)
-                return tryObjectToPrimitive(valueOfResult);
-        }
-    }
-    if (typeof obj.toString === 'function') {
-        const stringResult = obj.toString();
-        if (stringResult !== '[object Object]')
-            return stringResult;
-    }
-    return null;
-}
-/**
- * The function `isComparable` in TypeScript checks if a value is comparable, handling primitive values
- * and objects with optional force comparison.
- * @param {unknown} value - The `value` parameter in the `isComparable` function represents the value
- * that you want to check if it is comparable. It can be of any type (`unknown`), and the function will
- * determine if it is comparable based on certain conditions.
- * @param [isForceObjectComparable=false] - The `isForceObjectComparable` parameter in the
- * `isComparable` function is a boolean flag that determines whether to treat non-primitive values as
- * comparable objects. When set to `true`, it forces the function to consider non-primitive values as
- * comparable objects, regardless of their type.
- * @returns The function `isComparable` returns a boolean value indicating whether the `value` is
- * considered comparable or not.
- */
-export function isComparable(value, isForceObjectComparable = false) {
-    if (value === null || value === undefined)
-        return false;
-    if (isPrimitiveComparable(value))
-        return true;
-    if (typeof value !== 'object')
-        return false;
-    if (value instanceof Date)
-        return true;
-    // if (value instanceof Date) return !Number.isNaN(value.getTime());
-    if (isForceObjectComparable)
-        return true;
-    const comparableValue = tryObjectToPrimitive(value);
-    if (comparableValue === null || comparableValue === undefined)
-        return false;
-    return isPrimitiveComparable(comparableValue);
-}
-/**
- * Creates a trampoline thunk object.
- *
- * A "thunk" is a deferred computation — instead of performing a recursive call immediately,
- * it wraps the next step of the computation in a function. This allows recursive processes
- * to be executed iteratively, preventing stack overflows.
- *
- * @template T - The type of the final computation result.
- * @param computation - A function that, when executed, returns the next trampoline step.
- * @returns A TrampolineThunk object containing the deferred computation.
- */
-export const makeTrampolineThunk = (computation) => ({
-    isThunk: true, // Marker indicating this is a thunk
-    fn: computation // The deferred computation function
-});
-/**
- * Type guard to check whether a given value is a TrampolineThunk.
- *
- * This function is used to distinguish between a final computation result (value)
- * and a deferred computation (thunk).
- *
- * @template T - The type of the value being checked.
- * @param value - The value to test.
- * @returns True if the value is a valid TrampolineThunk, false otherwise.
- */
-export const isTrampolineThunk = (value) => typeof value === 'object' && // Must be an object
-    value !== null && // Must not be null
-    'isThunk' in value && // Must have the 'isThunk' property
-    value.isThunk; // The flag must be true
-/**
- * Executes a trampoline computation until a final (non-thunk) result is obtained.
- *
- * The trampoline function repeatedly invokes the deferred computations (thunks)
- * in an iterative loop. This avoids deep recursive calls and prevents stack overflow,
- * which is particularly useful for implementing recursion in a stack-safe manner.
- *
- * @template T - The type of the final result.
- * @param initial - The initial Trampoline value or thunk to start execution from.
- * @returns The final result of the computation (a non-thunk value).
- */
-export function trampoline(initial) {
-    let current = initial; // Start with the initial trampoline value
-    while (isTrampolineThunk(current)) {
-        // Keep unwrapping while we have thunks
-        current = current.fn(); // Execute the deferred function to get the next step
-    }
-    return current; // Once no thunks remain, return the final result
-}
-/**
- * Wraps a recursive function inside a trampoline executor.
- *
- * This function transforms a potentially recursive function (that returns a Trampoline<Result>)
- * into a *stack-safe* function that executes iteratively using the `trampoline` runner.
- *
- * In other words, it allows you to write functions that look recursive,
- * but actually run in constant stack space.
- *
- * @template Args - The tuple type representing the argument list of the original function.
- * @template Result - The final return type after all trampoline steps are resolved.
- *
- * @param fn - A function that performs a single step of computation
- *             and returns a Trampoline (either a final value or a deferred thunk).
- *
- * @returns A new function with the same arguments, but which automatically
- *          runs the trampoline process and returns the *final result* instead
- *          of a Trampoline.
- *
- * @example
- * // Example: Computing factorial in a stack-safe way
- * const factorial = makeTrampoline(function fact(n: number, acc: number = 1): Trampoline<number> {
- *   return n === 0
- *     ? acc
- *     : makeTrampolineThunk(() => fact(n - 1, acc * n));
- * });
- *
- * console.log(factorial(100000)); // Works without stack overflow
- */
-export function makeTrampoline(fn // A function that returns a trampoline step
-) {
-    // Return a wrapped function that automatically runs the trampoline execution loop
-    return (...args) => trampoline(fn(...args));
-}
-/**
- * Executes an asynchronous trampoline computation until a final (non-thunk) result is obtained.
- *
- * This function repeatedly invokes asynchronous deferred computations (thunks)
- * in an iterative loop. Each thunk may return either a Trampoline<T> or a Promise<Trampoline<T>>.
- *
- * It ensures that asynchronous recursive functions can run without growing the call stack,
- * making it suitable for stack-safe async recursion.
- *
- * @template T - The type of the final result.
- * @param initial - The initial Trampoline or Promise of Trampoline to start execution from.
- * @returns A Promise that resolves to the final result (a non-thunk value).
- */
-export async function asyncTrampoline(initial) {
-    let current = await initial; // Wait for the initial step to resolve if it's a Promise
-    // Keep executing thunks until we reach a non-thunk (final) value
-    while (isTrampolineThunk(current)) {
-        current = await current.fn(); // Execute the thunk function (may be async)
-    }
-    // Once the final value is reached, return it
-    return current;
-}
-/**
- * Wraps an asynchronous recursive function inside an async trampoline executor.
- *
- * This helper transforms a recursive async function that returns a Trampoline<Result>
- * (or Promise<Trampoline<Result>>) into a *stack-safe* async function that executes
- * iteratively via the `asyncTrampoline` runner.
- *
- * @template Args - The tuple type representing the argument list of the original function.
- * @template Result - The final return type after all async trampoline steps are resolved.
- *
- * @param fn - An async or sync function that performs a single step of computation
- *             and returns a Trampoline (either a final value or a deferred thunk).
- *
- * @returns An async function with the same arguments, but which automatically
- *          runs the trampoline process and resolves to the *final result*.
- *
- * @example
- * // Example: Async factorial using trampoline
- * const asyncFactorial = makeAsyncTrampoline(async function fact(
- *   n: number,
- *   acc: number = 1
- * ): Promise<Trampoline<number>> {
- *   return n === 0
- *     ? acc
- *     : makeTrampolineThunk(() => fact(n - 1, acc * n));
- * });
- *
- * asyncFactorial(100000).then(console.log); // Works without stack overflow
- */
-export function makeAsyncTrampoline(fn) {
-    // Return a wrapped async function that runs through the async trampoline loop
-    return async (...args) => {
-        return asyncTrampoline(fn(...args));
-    };
-}
-//# sourceMappingURL=utils.js.map

package/dist/esm/utils/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/utils/utils.ts"],"names":[],"mappings":"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"}

package/tsconfig-cjs.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig-base.json",
-  "compilerOptions": {
-    "rootDir": "./src/",
-    "outDir": "dist/cjs",
-    "module": "CommonJS",
-    "target": "ES2015",
-    "moduleResolution": "node",
-    "sourceMap": true
-  },
-  "include": [
-    "./src/**/*.ts"
-  ]
-}

package/tsconfig-esm.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig-base.json",
-  "compilerOptions": {
-    "rootDir": "./src/",
-    "outDir": "dist/esm",
-    "module": "ESNext",
-    "target": "ESNext",
-    "moduleResolution": "Node",
-    "sourceMap": true
-  },
-  "include": [
-    "./src/**/*.ts"
-  ]
-}