ts-data-forge 14.6.2 → 14.6.3

package/dist/number/branded-types/non-zero-int32.mjs

@@ -8,113 +8,113 @@ const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min
     MAX_VALUE: 2 ** 31 - 1,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-zero integer in [-2^31, 2^31).
- *
- * Returns `true` for a non-zero integer in [-2^31, 2^31) — a value with no
- * fractional component.
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-zero integer in [-2^31, 2^31), `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonZeroInt32 = is;
-/**
- * Casts a `number` to the `NonZeroInt32` branded type.
- *
- * Validates that the value is a non-zero integer in [-2^31, 2^31) and returns
- * it with the `NonZeroInt32` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonZeroInt32`
- * @throws {TypeError} If the value is not a non-zero integer in [-2^31, 2^31)
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonZeroInt32 = castType;
-/**
- * Namespace providing type-safe operations for the `NonZeroInt32` branded type.
- *
- * The `NonZeroInt32` type represents a non-zero integer in [-2^31, 2^31).
- * Division (`div`) uses floor division.
- */
+
+
+
+
+
+
 export const NonZeroInt32 = {
-    /**
-     * Type guard that checks if a value is a non-zero integer in [-2^31, 2^31).
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-zero integer in [-2^31, 2^31), `false` otherwise
-     * @see {@link isNonZeroInt32} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The smallest value representable as `NonZeroInt32` (the lower saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MIN_VALUE,
-    /**
-     * The largest value representable as `NonZeroInt32` (the upper saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the absolute value of a non-zero integer in [-2^31, 2^31).
-     *
-     * The result is non-negative and keeps the `NonZeroInt32` brand.
-     *
-     * @param a - The non-zero integer value
-     * @returns The absolute value as a non-negative `NonZeroInt32`
-     */
+
+
+
+
+
+
+
+
     abs,
-    /**
-     * Returns the smallest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The smallest value as a `NonZeroInt32`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The largest value as a `NonZeroInt32`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonZeroInt32`, rounding to the
-     * nearest integer and saturating the result into the range `[MIN_VALUE,
-     * MAX_VALUE]`.
-     *
-     * Unlike `asNonZeroInt32`, this is total: out-of-range inputs are clamped to
-     * the nearest representable `NonZeroInt32` instead of throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonZeroInt32`
-     */
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Generates a random `NonZeroInt32` within the given range.
-     *
-     * The range is inclusive on both ends.
-     *
-     * @param min - The minimum value (inclusive)
-     * @param max - The maximum value (inclusive)
-     * @returns A random `NonZeroInt32` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonZeroInt32`
-     * (floored to an integer).
-     *
-     * @param a - The base non-zero integer
-     * @param b - The exponent non-zero integer
-     * @returns `a ** b` as a `NonZeroInt32`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Multiplies two non-zero integers, returning `a * b` as a `NonZeroInt32`.
-     *
-     * @param a - The first non-zero integer
-     * @param b - The second non-zero integer
-     * @returns The product of `a` and `b` as a `NonZeroInt32`
-     */
+
+
+
+
+
+
+
     mul,
 };
 

package/dist/number/branded-types/non-zero-safe-int.mjs

@@ -4,121 +4,121 @@ const typeNameInMessage = 'a non-zero safe integer';
 const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     nonZero: true,
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-min-safe-integer
+
     MIN_VALUE: Number.MIN_SAFE_INTEGER,
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
+
     MAX_VALUE: Number.MAX_SAFE_INTEGER,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-zero safe integer.
- *
- * Returns `true` for a non-zero safe integer — a value with no fractional
- * component.
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-zero safe integer, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonZeroSafeInt = is;
-/**
- * Casts a `number` to the `NonZeroSafeInt` branded type.
- *
- * Validates that the value is a non-zero safe integer and returns it with the
- * `NonZeroSafeInt` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonZeroSafeInt`
- * @throws {TypeError} If the value is not a non-zero safe integer
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonZeroSafeInt = castType;
-/**
- * Namespace providing type-safe operations for the `NonZeroSafeInt` branded
- * type.
- *
- * The `NonZeroSafeInt` type represents a non-zero safe integer. Division
- * (`div`) uses floor division.
- */
+
+
+
+
+
+
+
 export const NonZeroSafeInt = {
-    /**
-     * Type guard that checks if a value is a non-zero safe integer.
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-zero safe integer, `false` otherwise
-     * @see {@link isNonZeroSafeInt} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The smallest value representable as `NonZeroSafeInt` (the lower saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MIN_VALUE,
-    /**
-     * The largest value representable as `NonZeroSafeInt` (the upper saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the absolute value of a non-zero safe integer.
-     *
-     * The result is non-negative and keeps the `NonZeroSafeInt` brand.
-     *
-     * @param a - The non-zero safe integer value
-     * @returns The absolute value as a non-negative `NonZeroSafeInt`
-     */
+
+
+
+
+
+
+
+
     abs,
-    /**
-     * Returns the smallest of the given non-zero safe integers.
-     *
-     * @param values - The non-zero safe integers to compare (at least one required)
-     * @returns The smallest value as a `NonZeroSafeInt`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-zero safe integers.
-     *
-     * @param values - The non-zero safe integers to compare (at least one required)
-     * @returns The largest value as a `NonZeroSafeInt`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonZeroSafeInt`, rounding to the
-     * nearest integer and saturating the result into the range `[MIN_VALUE,
-     * MAX_VALUE]`.
-     *
-     * Unlike `asNonZeroSafeInt`, this is total: out-of-range inputs are clamped
-     * to the nearest representable `NonZeroSafeInt` instead of throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonZeroSafeInt`
-     */
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Generates a random `NonZeroSafeInt` within the given range.
-     *
-     * The range is inclusive on both ends.
-     *
-     * @param min - The minimum value (inclusive)
-     * @param max - The maximum value (inclusive)
-     * @returns A random `NonZeroSafeInt` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonZeroSafeInt`
-     * (floored to an integer).
-     *
-     * @param a - The base non-zero safe integer
-     * @param b - The exponent non-zero safe integer
-     * @returns `a ** b` as a `NonZeroSafeInt`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Multiplies two non-zero safe integers, returning `a * b` as a
-     * `NonZeroSafeInt`.
-     *
-     * @param a - The first non-zero safe integer
-     * @param b - The second non-zero safe integer
-     * @returns The product of `a` and `b` as a `NonZeroSafeInt`
-     */
+
+
+
+
+
+
+
+
     mul,
 };
 

package/dist/number/branded-types/non-zero-uint16.mjs

@@ -8,113 +8,113 @@ const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min
     MAX_VALUE: 2 ** 16 - 1,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-zero integer in [1, 2^16).
- *
- * Returns `true` for a non-zero integer in [1, 2^16) — a value with no
- * fractional component.
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-zero integer in [1, 2^16), `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonZeroUint16 = is;
-/**
- * Casts a `number` to the `NonZeroUint16` branded type.
- *
- * Validates that the value is a non-zero integer in [1, 2^16) and returns it
- * with the `NonZeroUint16` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonZeroUint16`
- * @throws {TypeError} If the value is not a non-zero integer in [1, 2^16)
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonZeroUint16 = castType;
-/**
- * Namespace providing type-safe operations for the `NonZeroUint16` branded
- * type.
- *
- * The `NonZeroUint16` type represents a non-zero integer in [1, 2^16). Division
- * (`div`) uses floor division.
- */
+
+
+
+
+
+
+
 export const NonZeroUint16 = {
-    /**
-     * Type guard that checks if a value is a non-zero integer in [1, 2^16).
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-zero integer in [1, 2^16), `false` otherwise
-     * @see {@link isNonZeroUint16} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The smallest value representable as `NonZeroUint16` (the lower saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MIN_VALUE,
-    /**
-     * The largest value representable as `NonZeroUint16` (the upper saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the smallest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The smallest value as a `NonZeroUint16`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The largest value as a `NonZeroUint16`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonZeroUint16`, rounding to the
-     * nearest integer and saturating the result into the range `[MIN_VALUE,
-     * MAX_VALUE]`.
-     *
-     * Unlike `asNonZeroUint16`, this is total: out-of-range inputs are clamped to
-     * the nearest representable `NonZeroUint16` instead of throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonZeroUint16`
-     */
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Generates a random `NonZeroUint16` within the given range.
-     *
-     * The range is inclusive on both ends.
-     *
-     * @param min - The minimum value (inclusive)
-     * @param max - The maximum value (inclusive)
-     * @returns A random `NonZeroUint16` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonZeroUint16`
-     * (floored to an integer).
-     *
-     * @param a - The base non-zero integer
-     * @param b - The exponent non-zero integer
-     * @returns `a ** b` as a `NonZeroUint16`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Adds two non-zero integers, returning `a + b` as a `NonZeroUint16`.
-     *
-     * @param a - The first non-zero integer
-     * @param b - The second non-zero integer
-     * @returns The sum of `a` and `b` as a `NonZeroUint16`
-     */
+
+
+
+
+
+
+
     add,
-    /**
-     * Multiplies two non-zero integers, returning `a * b` as a `NonZeroUint16`.
-     *
-     * @param a - The first non-zero integer
-     * @param b - The second non-zero integer
-     * @returns The product of `a` and `b` as a `NonZeroUint16`
-     */
+
+
+
+
+
+
+
     mul,
 };