ts-data-forge 14.6.2 → 14.6.3

package/dist/number/refined-number-utils.mjs

@@ -1,31 +1,31 @@
 
 import { pipe } from '../functional/index.mjs';
 import { Num } from './num.mjs';
-/** @internal */
+
 export var TsDataForgeInternals;
 (function (TsDataForgeInternals) {
-    /**
-     * Internal utilities for creating and managing refined (branded) number
-     * types.
-     *
-     * This namespace provides factory functions and type utilities for building
-     * type-safe numeric operations with compile-time constraints. It serves as
-     * the foundation for all branded number types in the library, including:
-     *
-     * - Integer types (Int, SafeInt, Int8, Int16, Int32)
-     * - Unsigned types (UInt, UInt8, UInt16, UInt32)
-     * - Constrained types (NonZero, NonNegative, Positive)
-     * - Range-bounded types
-     *
-     * The utilities handle:
-     *
-     * - Type validation and narrowing
-     * - Arithmetic operations that preserve type constraints
-     * - Automatic clamping for bounded types
-     * - Random number generation within type bounds
-     *
-     * @internal This namespace is not part of the public API
-     */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     let RefinedNumberUtils;
     (function (RefinedNumberUtils) {
         const castTypeImpl = (is, typeNameInErrorMessage) => (a) => {
@@ -54,77 +54,77 @@ export var TsDataForgeInternals;
             : max === undefined
                 ? (n) => Math.max(min, n)
                 : Num.clamp(min, max);
-        /**
-         * Factory function that creates a complete set of type-safe operations for
-         * integer types.
-         *
-         * This function generates:
-         *
-         * - Type guards and validators
-         * - Arithmetic operations that preserve type constraints
-         * - Utility functions (min, max, abs, random)
-         * - Automatic clamping for bounded types
-         *
-         * All operations ensure results remain within the type's constraints, using
-         * clamping when bounds are specified.
-         *
-         * @example
-         *
-         * ```ts
-         * const intOps = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-         *   SafeInt,
-         *   number,
-         *   number
-         * >({
-         *   integerOrSafeInteger: 'SafeInteger',
-         *   MIN_VALUE: Number.MIN_SAFE_INTEGER,
-         *   MAX_VALUE: Number.MAX_SAFE_INTEGER,
-         *   typeNameInMessage: 'SafeInt',
-         * } as const);
-         *
-         * const six = intOps.castType(6);
-         *
-         * const four = intOps.castType(4);
-         *
-         * const sum = intOps.add(six, four);
-         *
-         * const difference = intOps.sub(six, four);
-         *
-         * const product = intOps.mul(six, four);
-         *
-         * const quotient = intOps.div(six, intOps.castType(2));
-         *
-         * const coerced = intOps.fromNumber(1.5);
-         *
-         * const randomValue = intOps.random();
-         *
-         * assert.isTrue(sum === 10);
-         *
-         * assert.isTrue(difference === 2);
-         *
-         * assert.isTrue(product === 24);
-         *
-         * assert.isTrue(quotient === 3);
-         *
-         * assert.isTrue(coerced === 2);
-         *
-         * assert.isTrue(Number.isSafeInteger(randomValue));
-         * ```
-         *
-         * @template ElementType - The integer branded type
-         * @template MIN_VALUE - Optional minimum value for bounded types
-         * @template MAX_VALUE - Optional maximum value for bounded types
-         * @param config - Configuration object
-         * @param config.integerOrSafeInteger - Whether to use Number.isInteger or
-         *   Number.isSafeInteger
-         * @param config.nonZero - If true, excludes zero from valid values
-         * @param config.MIN_VALUE - Minimum valid value (inclusive)
-         * @param config.MAX_VALUE - Maximum valid value (inclusive)
-         * @param config.typeNameInMessage - Human-readable type name for error
-         *   messages
-         * @returns Object containing all type-safe operations for the integer type
-         * @internal
-         */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         RefinedNumberUtils.operatorsForInteger = ({ integerOrSafeInteger, nonZero, MIN_VALUE, MAX_VALUE, typeNameInMessage, }) => {
             const is = (a) => (integerOrSafeInteger === 'Integer'
                 ? Number.isInteger(a)
@@ -135,7 +135,7 @@ export var TsDataForgeInternals;
             const fromNumber = pipe(clampFnOrUndefined(MIN_VALUE, MAX_VALUE)).mapNullable((cl) => (x) => castType(Math.round(cl(x)))).value;
             const clampOrCastFn = fromNumber ?? castType;
             const abs = (x) => 
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
             Math.abs(clampOrCastFn(x));
             const min_ = (...values) => clampOrCastFn(Math.min(...values));
             const max_ = (...values) => clampOrCastFn(Math.max(...values));
@@ -144,10 +144,10 @@ export var TsDataForgeInternals;
             const sub = (x, y) => clampOrCastFn(x - y);
             const mul = (x, y) => clampOrCastFn(x * y);
             const div = (x, y) => clampOrCastFn(Math.floor(
-            // eslint-disable-next-line total-functions/no-partial-division
+
             x / y));
             const randomImpl = (min = MIN_VALUE, max = MAX_VALUE) => min + Math.floor((Math.max(max, min) - min + 1) * Math.random());
-            // [-5, 5] -> floor(11 * Math.random()) + (-5)
+
             const random = (min, max) => clampOrCastFn(randomImpl(min, max));
             const randomNonZero = (min, max) => {
                 while (true) {
@@ -172,79 +172,79 @@ export var TsDataForgeInternals;
                 randomNonZero,
                 castType,
                 fromNumber: 
-                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
                 fromNumber,
             };
         };
-        /**
-         * Factory function that creates a complete set of type-safe operations for
-         * floating-point types.
-         *
-         * This function generates:
-         *
-         * - Type guards and validators (checking for finite values)
-         * - Arithmetic operations that preserve type constraints
-         * - Utility functions (min, max, abs, random)
-         * - Automatic clamping for bounded types
-         *
-         * All operations ensure results remain finite and within any specified
-         * bounds. Division by zero is prevented through type constraints.
-         *
-         * @example
-         *
-         * ```ts
-         * const floatOps = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
-         *   PositiveFiniteNumber,
-         *   number,
-         *   number
-         * >({
-         *   nonZero: true,
-         *   MIN_VALUE: Number.MIN_VALUE,
-         *   MAX_VALUE: Number.MAX_VALUE,
-         *   typeNameInMessage: 'PositiveFiniteNumber',
-         * } as const);
-         *
-         * const fortyTwo = floatOps.castType(42.5);
-         *
-         * const seven = floatOps.castType(7.5);
-         *
-         * const sum = floatOps.add(fortyTwo, seven);
-         *
-         * const ratio = floatOps.div(sum, floatOps.castType(10));
-         *
-         * const coerced = floatOps.fromNumber(0);
-         *
-         * const boundedRandom = floatOps.random(
-         *   floatOps.castType(10),
-         *   floatOps.castType(20),
-         * );
-         *
-         * const nonZeroRandom = floatOps.randomNonZero();
-         *
-         * assert.isTrue(sum === 50);
-         *
-         * assert.isTrue(ratio === 5);
-         *
-         * assert.isTrue(coerced >= Number.MIN_VALUE);
-         *
-         * assert.isTrue(boundedRandom >= 10 && boundedRandom <= 20);
-         *
-         * assert.isTrue(nonZeroRandom > 0);
-         * ```
-         *
-         * @template ElementType - The floating-point branded type
-         * @template MIN_VALUE - Optional minimum value for bounded types
-         * @template MAX_VALUE - Optional maximum value for bounded types
-         * @param config - Configuration object
-         * @param config.nonZero - If true, excludes zero from valid values
-         * @param config.MIN_VALUE - Minimum valid value (inclusive)
-         * @param config.MAX_VALUE - Maximum valid value (inclusive)
-         * @param config.typeNameInMessage - Human-readable type name for error
-         *   messages
-         * @returns Object containing all type-safe operations for the
-         *   floating-point type
-         * @internal
-         */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         RefinedNumberUtils.operatorsForFloat = ({ nonZero, MIN_VALUE, MAX_VALUE, typeNameInMessage, }) => {
             const is = (a) => Number.isFinite(a) &&
                 (nonZero === true ? a !== 0 : true) &&
@@ -253,7 +253,7 @@ export var TsDataForgeInternals;
             const fromNumber = pipe(clampFnOrUndefined(MIN_VALUE, MAX_VALUE)).mapNullable((cl) => (x) => castType(cl(x))).value;
             const clampOrCastFn = fromNumber ?? castType;
             const abs = (x) => 
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
             Math.abs(x);
             const min_ = (...values) => clampOrCastFn(Math.min(...values));
             const max_ = (...values) => clampOrCastFn(Math.max(...values));
@@ -262,7 +262,7 @@ export var TsDataForgeInternals;
             const sub = (x, y) => clampOrCastFn(x - y);
             const mul = (x, y) => clampOrCastFn(x * y);
             const div = (x, y) => 
-            // eslint-disable-next-line total-functions/no-partial-division
+
             clampOrCastFn(x / y);
             const randomImpl = (min = MIN_VALUE, max = MAX_VALUE) => min + (Math.max(max, min) - min) * Math.random();
             const random = (min, max) => clampOrCastFn(randomImpl(min, max));
@@ -288,7 +288,7 @@ export var TsDataForgeInternals;
                 random,
                 randomNonZero,
                 castType,
-                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
                 fromNumber: fromNumber,
             };
         };