ts-data-forge 1.0.0 → 1.0.1

package/dist/number/num.d.mts

@@ -0,0 +1,515 @@
+/**
+ * Namespace providing utility functions for number manipulation and validation.
+ *
+ * This namespace offers a comprehensive set of type-safe number utilities including:
+ * - Type conversion and validation
+ * - Type guards for numeric constraints (non-zero, non-negative, positive)
+ * - Range checking and clamping operations
+ * - Mathematical operations with type safety
+ * - Rounding utilities
+ *
+ * Many functions in this namespace leverage TypeScript's type system to provide
+ * compile-time guarantees about numeric constraints.
+ *
+ * @example
+ * ```typescript
+ * // Type conversion
+ * const num = Num.from('123.45'); // 123.45
+ * const invalid = Num.from('abc'); // NaN
+ *
+ * // Type guards
+ * const value = 5;
+ * if (Num.isPositive(value)) {
+ *   // value is typed as PositiveNumber & 5
+ * }
+ *
+ * // Range checking
+ * const isValid = Num.isInRange(0, 100)(50); // true
+ *
+ * // Clamping
+ * const clamped = Num.clamp(150, 0, 100); // 100
+ * const clampFn = Num.clamp(0, 100);
+ * const result = clampFn(150); // 100
+ * ```
+ */
+export declare namespace Num {
+    /**
+     * Converts an unknown value to a number. Alias for the `Number` constructor.
+     * @param n The value to convert.
+     * @returns The numeric representation of `n`.
+     * @example
+     * ```typescript
+     * Num.from('123'); // 123
+     * Num.from('123.45'); // 123.45
+     * Num.from(true); // 1
+     * Num.from(false); // 0
+     * Num.from('hello'); // NaN
+     * ```
+     */
+    export const from: (n: unknown) => number;
+    /**
+     * Type guard that checks if a number is non-zero.
+     *
+     * When this function returns `true`, TypeScript narrows the type to exclude zero,
+     * providing compile-time safety for division operations and other calculations
+     * that require non-zero values.
+     *
+     * @template N - The numeric literal type or number type to check
+     * @param num - The number to check
+     * @returns `true` if the number is not zero, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * const value = 5;
+     * if (Num.isNonZero(value)) {
+     *   // value is typed as NonZeroNumber & 5
+     *   const result = 10 / value; // Safe division
+     * }
+     *
+     * // Works with numeric literals
+     * const literal = 0 as 0 | 1 | 2;
+     * if (Num.isNonZero(literal)) {
+     *   // literal is typed as 1 | 2
+     * }
+     * ```
+     */
+    export const isNonZero: <N extends number>(num: N) => num is NonZeroNumber & RelaxedExclude<N, 0>;
+    /**
+     * Type guard that checks if a number is non-negative (greater than or equal to zero).
+     *
+     * When this function returns `true`, TypeScript narrows the type to exclude negative
+     * values, which is useful for operations that require non-negative inputs like
+     * array indices or measurements.
+     *
+     * @template N - The numeric literal type or number type to check
+     * @param num - The number to check
+     * @returns `true` if the number is >= 0, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * const value = 10;
+     * if (Num.isNonNegative(value)) {
+     *   // value is typed as NonNegativeNumber & 10
+     *   const arr = new Array(value); // Safe array creation
+     * }
+     *
+     * // Type narrowing with unions
+     * const index = -1 as -1 | 0 | 1;
+     * if (Num.isNonNegative(index)) {
+     *   // index is typed as 0 | 1
+     * }
+     * ```
+     */
+    export const isNonNegative: <N extends number>(num: N) => num is NonNegativeNumber & RelaxedExclude<N, NegativeIndex<1024>>;
+    /**
+     * Type guard that checks if a number is positive (greater than zero).
+     *
+     * When this function returns `true`, TypeScript narrows the type to exclude zero
+     * and negative values. This is particularly useful for validating inputs that
+     * must be strictly positive, such as dimensions, counts, or rates.
+     *
+     * @template N - The numeric literal type or number type to check
+     * @param num - The number to check
+     * @returns `true` if the number is > 0, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * const count = 5;
+     * if (Num.isPositive(count)) {
+     *   // count is typed as PositiveNumber & 5
+     *   const average = total / count; // Safe division
+     * }
+     *
+     * // Type narrowing with numeric literals
+     * const value = 0 as -1 | 0 | 1 | 2;
+     * if (Num.isPositive(value)) {
+     *   // value is typed as 1 | 2
+     * }
+     * ```
+     */
+    export const isPositive: <N extends number>(num: N) => num is PositiveNumber & RelaxedExclude<N, NegativeIndex<1024> | 0>;
+    /**
+     * Creates a function that checks if a number `x` is within the range `lowerBound <= x < upperBound`.
+     * @param lowerBound The lower bound (inclusive).
+     * @param upperBound The upper bound (exclusive).
+     * @returns A function that takes a number `x` and returns `true` if `x` is in the range, `false` otherwise.
+     * @example
+     * ```typescript
+     * const isInRange0to10 = Num.isInRange(0, 10);
+     * isInRange0to10(5); // true
+     * isInRange0to10(0); // true (inclusive lower bound)
+     * isInRange0to10(10); // false (exclusive upper bound)
+     * isInRange0to10(-1); // false
+     * ```
+     */
+    export const isInRange: (lowerBound: number, upperBound: number) => (x: number) => boolean;
+    /**
+     * Creates a function that checks if a number `x` is within the range `lowerBound <= x <= upperBound`.
+     * @param lowerBound The lower bound (inclusive).
+     * @param upperBound The upper bound (inclusive).
+     * @returns A function that takes a number `x` and returns `true` if `x` is in the range, `false` otherwise.
+     * @example
+     * ```typescript
+     * const inRange = Num.isInRangeInclusive(1, 10);
+     * console.log(inRange(1));   // true (lower bound)
+     * console.log(inRange(5));   // true
+     * console.log(inRange(10));  // true (upper bound)
+     * console.log(inRange(11));  // false
+     * ```
+     */
+    export const isInRangeInclusive: (lowerBound: number, upperBound: number) => (x: number) => boolean;
+    /**
+     * @internal
+     * Helper type mapping each SmallUint N to the union of integers from 0 to N-1.
+     * Used internally for type-safe range operations.
+     *
+     * For example:
+     * - LT[3] = 0 | 1 | 2
+     * - LT[5] = 0 | 1 | 2 | 3 | 4
+     *
+     * @template N - A SmallUint representing the exclusive upper bound
+     */
+    type LT = {
+        [N in SmallUint]: Index<N>;
+    };
+    /**
+     * @internal
+     * Helper type mapping each SmallUint N to the union of integers from 0 to N (inclusive).
+     * Used internally for type-safe range operations with inclusive upper bounds.
+     *
+     * For example:
+     * - LEQ[3] = 0 | 1 | 2 | 3
+     * - LEQ[5] = 0 | 1 | 2 | 3 | 4 | 5
+     *
+     * @template N - A SmallUint representing the inclusive upper bound
+     */
+    type LEQ = {
+        [N in SmallUint]: Index<N> | N;
+    };
+    /**
+     * Creates a type guard that checks if a number is an unsigned integer within a specified range.
+     *
+     * This function returns a predicate that validates whether a number is:
+     * - A safe integer (no floating point)
+     * - Within the range [lowerBound, upperBound)
+     *
+     * The returned type guard provides precise type narrowing when the bounds are
+     * SmallUint literals, making it ideal for array index validation.
+     *
+     * @template L - The lower bound as a SmallUint literal type
+     * @template U - The upper bound as a SmallUint literal type
+     * @param lowerBound - The minimum value (inclusive)
+     * @param upperBound - The maximum value (exclusive)
+     * @returns A type guard function that validates and narrows number types
+     *
+     * @example
+     * ```typescript
+     * // Array index validation
+     * const isValidIndex = Num.isUintInRange(0, 10);
+     * const index: number = getUserInput();
+     *
+     * if (isValidIndex(index)) {
+     *   // index is typed as 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+     *   const value = array[index]; // Safe array access
+     * }
+     *
+     * // Custom range validation
+     * const isValidPercentage = Num.isUintInRange(0, 101);
+     * if (isValidPercentage(value)) {
+     *   // value is typed as 0 | 1 | ... | 100
+     * }
+     * ```
+     */
+    export const isUintInRange: <L extends SmallUint, U extends SmallUint>(lowerBound: L, upperBound: U) => (x: number) => x is RelaxedExclude<LT[U], LT[Min<L>]>;
+    /**
+     * Creates a type guard that checks if a number is an unsigned integer within a specified inclusive range.
+     *
+     * This function returns a predicate that validates whether a number is:
+     * - A safe integer (no floating point)
+     * - Within the range [lowerBound, upperBound] (both bounds inclusive)
+     *
+     * The returned type guard provides precise type narrowing when the bounds are
+     * SmallUint literals, useful for validating scores, percentages, or other bounded values.
+     *
+     * @template L - The lower bound as a SmallUint literal type
+     * @template U - The upper bound as a SmallUint literal type
+     * @param lowerBound - The minimum value (inclusive)
+     * @param upperBound - The maximum value (inclusive)
+     * @returns A type guard function that validates and narrows number types
+     *
+     * @example
+     * ```typescript
+     * // Score validation (0-100)
+     * const isValidScore = Num.isUintInRangeInclusive(0, 100);
+     * const score: number = getTestScore();
+     *
+     * if (isValidScore(score)) {
+     *   // score is typed as 0 | 1 | 2 | ... | 100
+     *   const grade = calculateGrade(score);
+     * }
+     *
+     * // Day of month validation
+     * const isValidDay = Num.isUintInRangeInclusive(1, 31);
+     * if (isValidDay(day)) {
+     *   // day is typed as 1 | 2 | ... | 31
+     * }
+     * ```
+     */
+    export const isUintInRangeInclusive: <L extends SmallUint, U extends SmallUint>(lowerBound: L, upperBound: U) => (x: number) => x is RelaxedExclude<LEQ[U], LT[Min<L>]>;
+    /**
+     * Clamps a value within the given range. If the target value is invalid (not finite), returns the lower bound.
+     *
+     * Provides two usage patterns for maximum flexibility:
+     * - **Direct usage**: Pass all three arguments to get the clamped value immediately
+     * - **Curried usage**: Pass bounds to get a reusable clamping function
+     *
+     * @example
+     * Direct usage:
+     * ```typescript
+     * Num.clamp(15, 0, 10); // 10 (clamped to upper bound)
+     * Num.clamp(-5, 0, 10); // 0 (clamped to lower bound)
+     * Num.clamp(5, 0, 10);  // 5 (within bounds)
+     * Num.clamp(NaN, 0, 10); // 0 (invalid values default to lower bound)
+     * ```
+     *
+     * @example
+     * Curried usage for reusable functions:
+     * ```typescript
+     * const clampToPercent = Num.clamp(0, 100);
+     * clampToPercent(150); // 100
+     * clampToPercent(-10); // 0
+     * clampToPercent(75);  // 75
+     *
+     * // Perfect for pipe composition
+     * const result = pipe(userInput)
+     *   .map(Number)
+     *   .map(clampToPercent).value;
+     * ```
+     *
+     * @example
+     * Working with arrays and functional programming:
+     * ```typescript
+     * const clampTo0_1 = Num.clamp(0, 1);
+     * const normalizedValues = values.map(clampTo0_1);
+     *
+     * // Temperature clamping
+     * const clampTemperature = Num.clamp(-40, 50);
+     * const safeTemperatures = readings.map(clampTemperature);
+     * ```
+     */
+    export const clamp: ClampFnOverload;
+    type ClampFnOverload = {
+        (target: number, lowerBound: number, upperBound: number): number;
+        (lowerBound: number, upperBound: number): (target: number) => number;
+    };
+    /**
+     * Performs type-safe division with compile-time zero-check.
+     *
+     * This function leverages TypeScript's type system to prevent division by zero
+     * at compile time. The divisor must be typed as NonZeroNumber or a non-zero
+     * numeric literal.
+     *
+     * @param a - The dividend
+     * @param b - The divisor (must be non-zero, enforced by types)
+     * @returns The quotient of a / b
+     *
+     * @example
+     * ```typescript
+     * // Safe division with literals
+     * const result1 = Num.div(10, 2); // 5
+     * const result2 = Num.div(7, 3); // 2.3333...
+     *
+     * // Compile-time error prevention
+     * // Num.div(10, 0); // ❌ TypeScript error: Type '0' is not assignable
+     *
+     * // With type guards
+     * const divisor: number = getDivisor();
+     * if (Num.isNonZero(divisor)) {
+     *   const result = Num.div(100, divisor); // ✅ Safe
+     * }
+     *
+     * // With branded types
+     * const nonZero = asNonZeroNumber(5);
+     * const result3 = Num.div(20, nonZero); // 4
+     * ```
+     */
+    export const div: (a: number, b: NonZeroNumber | SmallInt<"!=0">) => number;
+    /**
+     * Performs integer division using floor division.
+     *
+     * Computes `⌊a / b⌋` by flooring both operands before division and then
+     * flooring the result. This ensures integer arithmetic semantics.
+     *
+     * Note: Unlike `div`, this function does not enforce non-zero divisor at
+     * compile time. Division by zero returns `NaN`.
+     *
+     * @param a - The dividend
+     * @param b - The divisor
+     * @returns The integer quotient, or `NaN` if b is zero
+     *
+     * @example
+     * ```typescript
+     * Num.divInt(10, 3);   // 3
+     * Num.divInt(10, -3);  // -4 (floor division)
+     * Num.divInt(-10, 3);  // -4
+     * Num.divInt(10.7, 3.2); // 3 (floors both inputs first)
+     * Num.divInt(10, 0);   // NaN
+     * ```
+     */
+    export const divInt: (a: number, b: number) => number;
+    /**
+     * Rounds a number to a specified number of decimal places.
+     *
+     * Uses the standard rounding algorithm (round half up) to round the number
+     * to the given precision. The precision must be a positive safe integer.
+     *
+     * @param num - The number to round
+     * @param precision - The number of decimal places (must be positive)
+     * @returns The rounded number
+     *
+     * @example
+     * ```typescript
+     * Num.roundAt(3.14159, 2);   // 3.14
+     * Num.roundAt(3.14159, 4);   // 3.1416
+     * Num.roundAt(10.5, 0);      // 11
+     * Num.roundAt(-10.5, 0);     // -10
+     * Num.roundAt(0.005, 2);     // 0.01
+     * ```
+     */
+    export const roundAt: (num: number, precision: PositiveSafeIntWithSmallInt) => number;
+    /**
+     * Rounds a number to the nearest integer using bitwise operations.
+     *
+     * This function uses a bitwise OR trick for potentially faster rounding.
+     * Note: This implementation rounds half up for positive numbers but may
+     * behave differently for negative numbers compared to Math.round.
+     *
+     * @param num - The number to round
+     * @returns The rounded integer as an Int branded type
+     *
+     * @example
+     * ```typescript
+     * Num.roundToInt(3.2);   // 3
+     * Num.roundToInt(3.5);   // 4
+     * Num.roundToInt(3.8);   // 4
+     * Num.roundToInt(-3.2);  // -3
+     * Num.roundToInt(-3.8);  // -3
+     * ```
+     */
+    export const roundToInt: (num: number) => Int;
+    /**
+     * Creates a reusable rounding function with a fixed precision.
+     *
+     * This is a curried version of roundAt that returns a function configured
+     * to always round to the specified number of decimal places. Useful for
+     * creating consistent rounding behavior across multiple values.
+     *
+     * @param digit - The number of decimal places for rounding
+     * @returns A function that rounds numbers to the specified precision
+     *
+     * @example
+     * ```typescript
+     * // Create specialized rounding functions
+     * const roundTo2 = Num.round(2);
+     * const roundTo4 = Num.round(4);
+     *
+     * roundTo2(3.14159);  // 3.14
+     * roundTo2(2.71828);  // 2.72
+     * roundTo2(10);       // 10
+     *
+     * roundTo4(3.14159);  // 3.1416
+     *
+     * // Use with array operations
+     * const values = [1.234, 5.678, 9.012];
+     * const rounded = values.map(roundTo2); // [1.23, 5.68, 9.01]
+     * ```
+     */
+    export const round: (digit: PositiveSafeIntWithSmallInt) => ((num: number) => number);
+    /**
+     * Converts NaN values to undefined while preserving all other numbers.
+     *
+     * This function is useful for handling potentially invalid numeric operations
+     * in a type-safe way, converting NaN results to undefined for easier handling
+     * with optional chaining or nullish coalescing.
+     *
+     * @template N - The numeric type (literal or number)
+     * @param num - The number to check
+     * @returns The original number if not NaN, otherwise undefined
+     *
+     * @example
+     * ```typescript
+     * Num.mapNaN2Undefined(42);           // 42
+     * Num.mapNaN2Undefined(0);            // 0
+     * Num.mapNaN2Undefined(NaN);          // undefined
+     * Num.mapNaN2Undefined(Math.sqrt(-1)); // undefined
+     *
+     * // Useful in chains
+     * const result = Num.mapNaN2Undefined(parseFloat(userInput)) ?? 0;
+     *
+     * // Type narrowing
+     * const value = Math.sqrt(x);
+     * const safe = Num.mapNaN2Undefined(value);
+     * if (safe !== undefined) {
+     *   // safe is typed without NaN
+     * }
+     * ```
+     */
+    export const mapNaN2Undefined: <N extends number>(num: N) => RelaxedExclude<N, NaNType> | undefined;
+    /**
+     * Type-safe increment operation for SmallUint values.
+     *
+     * Increments a SmallUint (0-40) by 1 with the result type computed at
+     * compile time. This provides type-level arithmetic for small unsigned
+     * integers, useful for type-safe counter operations.
+     *
+     * @template N - A SmallUint literal type (0-40)
+     * @param n - The SmallUint value to increment
+     * @returns The incremented value with type Increment<N>
+     *
+     * @example
+     * ```typescript
+     * const zero = 0 as 0;
+     * const one = Num.increment(zero); // type is 1, value is 1
+     *
+     * const five = 5 as 5;
+     * const six = Num.increment(five); // type is 6, value is 6
+     *
+     * // Type-safe counter
+     * type Counter<N extends SmallUint> = {
+     *   value: N;
+     *   next(): Counter<Increment<N>>;
+     * };
+     * ```
+     */
+    export const increment: <N extends SmallUint>(n: N) => Increment<N>;
+    /**
+     * Type-safe decrement operation for positive SmallInt values.
+     *
+     * Decrements a positive SmallInt (1-40) by 1 with the result type computed
+     * at compile time. This provides type-level arithmetic for small positive
+     * integers, useful for type-safe countdown operations.
+     *
+     * @template N - A positive SmallInt literal type (1-40)
+     * @param n - The positive SmallInt value to decrement
+     * @returns The decremented value with type Decrement<N>
+     *
+     * @example
+     * ```typescript
+     * const three = 3 as 3;
+     * const two = Num.decrement(three); // type is 2, value is 2
+     *
+     * const one = 1 as 1;
+     * const zero = Num.decrement(one); // type is 0, value is 0
+     *
+     * // Type-safe countdown
+     * function countdown<N extends PositiveSmallInt>(
+     *   n: N
+     * ): N extends 1 ? 0 : Decrement<N> {
+     *   return Num.decrement(n);
+     * }
+     * ```
+     */
+    export const decrement: <N extends PositiveSmallInt>(n: N) => Decrement<N>;
+    export {};
+}
+//# sourceMappingURL=num.d.mts.map

package/dist/number/num.d.mts.map

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