ts-data-forge 14.10.1 → 14.11.0

package/src/number/branded-types/non-negative-int16.mts

@@ -1,37 +1,25 @@
 import type { NonNegativeInt16 as TtfImported_NonNegativeInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonNegativeInt16 = TtfImported_NonNegativeInt16;
-
-type ElementType = NonNegativeInt16;
-
-const typeNameInMessage = 'a non-negative integer in [0, 2^15)';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
   add,
-  castType,
   div,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   mul,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  0,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: 0,
-  MAX_VALUE: 2 ** 15 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/non-negative-int16.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonNegativeInt16 = TtfImported_NonNegativeInt16;
+
+type ElementType = NonNegativeInt16;
+
+const typeNameInMessage = 'a non-negative integer in [0, 2^15)';
 
 /**
  * Type guard that checks if a value is a non-negative integer in [0, 2^15).
@@ -42,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer in [0, 2^15), `false` otherwise
  */
-export const isNonNegativeInt16 = is;
+export const isNonNegativeInt16 = (value: number): value is NonNegativeInt16 =>
+  Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 15 - 1;
 
 /**
  * Casts a `number` to the `NonNegativeInt16` branded type.
@@ -54,7 +43,15 @@ export const isNonNegativeInt16 = is;
  * @returns The value as a `NonNegativeInt16`
  * @throws {TypeError} If the value is not a non-negative integer in [0, 2^15)
  */
-export const asNonNegativeInt16 = castType;
+export const asNonNegativeInt16 = <N extends number>(
+  value: N,
+): NonNegativeInt16 & N => {
+  if (!isNonNegativeInt16(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonNegativeInt16` branded
@@ -71,7 +68,7 @@ export const NonNegativeInt16 = {
    * @returns `true` if the value is a non-negative integer in [0, 2^15), `false` otherwise
    * @see {@link isNonNegativeInt16} for usage examples
    */
-  is,
+  is: isNonNegativeInt16,
 
   /**
    * The smallest value representable as `NonNegativeInt16` (the lower

package/src/number/branded-types/non-negative-int32.mts

@@ -1,37 +1,25 @@
 import type { NonNegativeInt32 as TtfImported_NonNegativeInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonNegativeInt32 = TtfImported_NonNegativeInt32;
-
-type ElementType = NonNegativeInt32;
-
-const typeNameInMessage = 'a non-negative integer in [0, 2^31)';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
   add,
-  castType,
   div,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   mul,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  0,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: 0,
-  MAX_VALUE: 2 ** 31 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/non-negative-int32.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonNegativeInt32 = TtfImported_NonNegativeInt32;
+
+type ElementType = NonNegativeInt32;
+
+const typeNameInMessage = 'a non-negative integer in [0, 2^31)';
 
 /**
  * Type guard that checks if a value is a non-negative integer in [0, 2^31).
@@ -42,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer in [0, 2^31), `false` otherwise
  */
-export const isNonNegativeInt32 = is;
+export const isNonNegativeInt32 = (value: number): value is NonNegativeInt32 =>
+  Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 31 - 1;
 
 /**
  * Casts a `number` to the `NonNegativeInt32` branded type.
@@ -54,7 +43,15 @@ export const isNonNegativeInt32 = is;
  * @returns The value as a `NonNegativeInt32`
  * @throws {TypeError} If the value is not a non-negative integer in [0, 2^31)
  */
-export const asNonNegativeInt32 = castType;
+export const asNonNegativeInt32 = <N extends number>(
+  value: N,
+): NonNegativeInt32 & N => {
+  if (!isNonNegativeInt32(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonNegativeInt32` branded
@@ -71,7 +68,7 @@ export const NonNegativeInt32 = {
    * @returns `true` if the value is a non-negative integer in [0, 2^31), `false` otherwise
    * @see {@link isNonNegativeInt32} for usage examples
    */
-  is,
+  is: isNonNegativeInt32,
 
   /**
    * The smallest value representable as `NonNegativeInt32` (the lower

package/src/number/branded-types/non-positive-finite-number.mts

@@ -1,32 +1,21 @@
 import type { NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonPositiveFiniteNumber = TtfImported_NonPositiveFiniteNumber;
-
-type ElementType = NonPositiveFiniteNumber;
-
-const typeNameInMessage = 'a non-positive finite number';
-
-const {
+import {
   MAX_VALUE,
   add,
-  castType,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
-  ElementType,
-  number,
-  0
->({
-  MIN_VALUE: -Number.MAX_VALUE,
-  MAX_VALUE: 0,
-  typeNameInMessage,
-} as const);
+} from '../operators/non-positive-finite-number.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonPositiveFiniteNumber = TtfImported_NonPositiveFiniteNumber;
+
+type ElementType = NonPositiveFiniteNumber;
+
+const typeNameInMessage = 'a non-positive finite number';
 
 const floor = (
   x: ElementType,
@@ -71,7 +60,9 @@ const round = (
  * @param value - The value to check
  * @returns `true` if the value is a non-positive finite number, `false` otherwise
  */
-export const isNonPositiveFiniteNumber = is;
+export const isNonPositiveFiniteNumber = (
+  value: number,
+): value is NonPositiveFiniteNumber => Number.isFinite(value) && value <= 0;
 
 /**
  * Casts a `number` to the `NonPositiveFiniteNumber` branded type.
@@ -83,7 +74,15 @@ export const isNonPositiveFiniteNumber = is;
  * @returns The value as a `NonPositiveFiniteNumber`
  * @throws {TypeError} If the value is not a non-positive finite number
  */
-export const asNonPositiveFiniteNumber = castType;
+export const asNonPositiveFiniteNumber = <N extends number>(
+  value: N,
+): NonPositiveFiniteNumber & N => {
+  if (!isNonPositiveFiniteNumber(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonPositiveFiniteNumber`
@@ -99,7 +98,7 @@ export const NonPositiveFiniteNumber = {
    * @returns `true` if the value is a non-positive finite number, `false` otherwise
    * @see {@link isNonPositiveFiniteNumber} for usage examples
    */
-  is,
+  is: isNonPositiveFiniteNumber,
 
   /**
    * The largest value representable as `NonPositiveFiniteNumber` (the upper

package/src/number/branded-types/non-positive-int.mts

@@ -1,33 +1,18 @@
 import type { NonPositiveInt as TtfImported_NonPositiveInt } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonPositiveInt = TtfImported_NonPositiveInt;
-
-type ElementType = NonPositiveInt;
-
-const typeNameInMessage = 'a non-positive integer';
-
-const {
+import {
   MAX_VALUE,
   add,
-  castType,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  number,
-  0
->({
-  integerOrSafeInteger: 'Integer',
-  MIN_VALUE: -Number.MAX_VALUE,
-  MAX_VALUE: 0,
-  typeNameInMessage,
-} as const);
+} from '../operators/non-positive-int.mjs';
+
+export type NonPositiveInt = TtfImported_NonPositiveInt;
+
+const typeNameInMessage = 'a non-positive integer';
 
 /**
  * Type guard that checks if a value is a non-positive integer.
@@ -39,7 +24,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-positive integer, `false` otherwise
  */
-export const isNonPositiveInt = is;
+export const isNonPositiveInt = (value: number): value is NonPositiveInt =>
+  Number.isInteger(value) && value <= 0;
 
 /**
  * Casts a `number` to the `NonPositiveInt` branded type.
@@ -51,7 +37,15 @@ export const isNonPositiveInt = is;
  * @returns The value as a `NonPositiveInt`
  * @throws {TypeError} If the value is not a non-positive integer
  */
-export const asNonPositiveInt = castType;
+export const asNonPositiveInt = <N extends number>(
+  value: N,
+): NonPositiveInt & N => {
+  if (!isNonPositiveInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonPositiveInt` branded
@@ -72,7 +66,7 @@ export const NonPositiveInt = {
    * @returns `true` if the value is a non-positive integer, `false` otherwise
    * @see {@link isNonPositiveInt} for usage examples
    */
-  is,
+  is: isNonPositiveInt,
 
   /**
    * The largest value representable as `NonPositiveInt` (the upper saturation

package/src/number/branded-types/non-positive-safe-int.mts

@@ -1,34 +1,19 @@
 import type { NonPositiveSafeInt as TtfImported_NonPositiveSafeInt } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonPositiveSafeInt = TtfImported_NonPositiveSafeInt;
-
-type ElementType = NonPositiveSafeInt;
-
-const typeNameInMessage = 'a non-positive safe integer';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
   add,
-  castType,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  number,
-  0
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: Number.MIN_SAFE_INTEGER,
-  MAX_VALUE: 0,
-  typeNameInMessage,
-} as const);
+} from '../operators/non-positive-safe-int.mjs';
+
+export type NonPositiveSafeInt = TtfImported_NonPositiveSafeInt;
+
+const typeNameInMessage = 'a non-positive safe integer';
 
 /**
  * Type guard that checks if a value is a non-positive safe integer.
@@ -39,7 +24,9 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-positive safe integer, `false` otherwise
  */
-export const isNonPositiveSafeInt = is;
+export const isNonPositiveSafeInt = (
+  value: number,
+): value is NonPositiveSafeInt => Number.isSafeInteger(value) && value <= 0;
 
 /**
  * Casts a `number` to the `NonPositiveSafeInt` branded type.
@@ -51,7 +38,15 @@ export const isNonPositiveSafeInt = is;
  * @returns The value as a `NonPositiveSafeInt`
  * @throws {TypeError} If the value is not a non-positive safe integer
  */
-export const asNonPositiveSafeInt = castType;
+export const asNonPositiveSafeInt = <N extends number>(
+  value: N,
+): NonPositiveSafeInt & N => {
+  if (!isNonPositiveSafeInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonPositiveSafeInt` branded
@@ -68,7 +63,7 @@ export const NonPositiveSafeInt = {
    * @returns `true` if the value is a non-positive safe integer, `false` otherwise
    * @see {@link isNonPositiveSafeInt} for usage examples
    */
-  is,
+  is: isNonPositiveSafeInt,
 
   /**
    * The smallest value representable as `NonPositiveSafeInt` (the lower

package/src/number/branded-types/non-zero-finite-number.mts

@@ -5,7 +5,16 @@ import type {
   NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import {
+  abs,
+  div,
+  max as max_,
+  min as min_,
+  mul,
+  pow,
+  randomNonZero as random,
+} from '../operators/non-zero-finite-number.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 export type NonZeroFiniteNumber = TtfImported_NonZeroFiniteNumber;
 
@@ -13,27 +22,6 @@ type ElementType = NonZeroFiniteNumber;
 
 const typeNameInMessage = 'a non-zero finite number';
 
-const {
-  abs,
-  castType,
-  div,
-  is,
-  max: max_,
-  min: min_,
-  mul,
-  pow,
-  randomNonZero: random,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
-  ElementType,
-  number,
-  number
->({
-  nonZero: true,
-  MIN_VALUE: -Number.MAX_VALUE,
-  MAX_VALUE: Number.MAX_VALUE,
-  typeNameInMessage,
-} as const);
-
 const floor = (
   x: ElementType,
 ): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>
@@ -73,7 +61,9 @@ expectType<
  * @param value - The value to check
  * @returns `true` if the value is a non-zero finite number, `false` otherwise
  */
-export const isNonZeroFiniteNumber = is;
+export const isNonZeroFiniteNumber = (
+  value: number,
+): value is NonZeroFiniteNumber => Number.isFinite(value) && value !== 0;
 
 /**
  * Casts a `number` to the `NonZeroFiniteNumber` branded type.
@@ -85,7 +75,15 @@ export const isNonZeroFiniteNumber = is;
  * @returns The value as a `NonZeroFiniteNumber`
  * @throws {TypeError} If the value is not a non-zero finite number
  */
-export const asNonZeroFiniteNumber = castType;
+export const asNonZeroFiniteNumber = <N extends number>(
+  value: N,
+): NonZeroFiniteNumber & N => {
+  if (!isNonZeroFiniteNumber(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonZeroFiniteNumber`
@@ -101,7 +99,7 @@ export const NonZeroFiniteNumber = {
    * @returns `true` if the value is a non-zero finite number, `false` otherwise
    * @see {@link isNonZeroFiniteNumber} for usage examples
    */
-  is,
+  is: isNonZeroFiniteNumber,
 
   /**
    * Returns the absolute value of a non-zero finite number.

package/src/number/branded-types/non-zero-int.mts

@@ -1,6 +1,14 @@
 import type { NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import {
+  abs,
+  max as max_,
+  min as min_,
+  mul,
+  pow,
+  randomNonZero as random,
+} from '../operators/non-zero-int.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 export type NonZeroInt = TtfImported_NonZeroInt;
 
@@ -8,27 +16,6 @@ type ElementType = NonZeroInt;
 
 const typeNameInMessage = 'a non-zero integer';
 
-const {
-  abs,
-  castType,
-  is,
-  max: max_,
-  min: min_,
-  mul,
-  pow,
-  randomNonZero: random,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  number,
-  number
->({
-  integerOrSafeInteger: 'Integer',
-  nonZero: true,
-  MIN_VALUE: -Number.MAX_VALUE,
-  MAX_VALUE: Number.MAX_VALUE,
-  typeNameInMessage,
-} as const);
-
 /**
  * Type guard that checks if a value is a non-zero integer.
  *
@@ -38,7 +25,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-zero integer, `false` otherwise
  */
-export const isNonZeroInt = is;
+export const isNonZeroInt = (value: number): value is NonZeroInt =>
+  Number.isInteger(value) && value !== 0;
 
 /**
  * Casts a `number` to the `NonZeroInt` branded type.
@@ -50,7 +38,13 @@ export const isNonZeroInt = is;
  * @returns The value as a `NonZeroInt`
  * @throws {TypeError} If the value is not a non-zero integer
  */
-export const asNonZeroInt = castType;
+export const asNonZeroInt = <N extends number>(value: N): NonZeroInt & N => {
+  if (!isNonZeroInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonZeroInt` branded type.
@@ -70,7 +64,7 @@ export const NonZeroInt = {
    * @returns `true` if the value is a non-zero integer, `false` otherwise
    * @see {@link isNonZeroInt} for usage examples
    */
-  is,
+  is: isNonZeroInt,
 
   /**
    * Returns the absolute value of a non-zero integer.

package/src/number/branded-types/non-zero-int16.mts

@@ -1,36 +1,23 @@
 import type { NonZeroInt16 as TtfImported_NonZeroInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonZeroInt16 = TtfImported_NonZeroInt16;
-
-type ElementType = NonZeroInt16;
-
-const typeNameInMessage = 'a non-zero integer in [-2^15, 2^15)';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
   abs,
-  castType,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   mul,
   pow,
-  randomNonZero: random,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  number,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  nonZero: true,
-  MIN_VALUE: -(2 ** 15),
-  MAX_VALUE: 2 ** 15 - 1,
-  typeNameInMessage,
-} as const);
+  randomNonZero as random,
+} from '../operators/non-zero-int16.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonZeroInt16 = TtfImported_NonZeroInt16;
+
+type ElementType = NonZeroInt16;
+
+const typeNameInMessage = 'a non-zero integer in [-2^15, 2^15)';
 
 /**
  * Type guard that checks if a value is a non-zero integer in [-2^15, 2^15).
@@ -41,7 +28,11 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-zero integer in [-2^15, 2^15), `false` otherwise
  */
-export const isNonZeroInt16 = is;
+export const isNonZeroInt16 = (value: number): value is NonZeroInt16 =>
+  Number.isSafeInteger(value) &&
+  value !== 0 &&
+  -(2 ** 15) <= value &&
+  value <= 2 ** 15 - 1;
 
 /**
  * Casts a `number` to the `NonZeroInt16` branded type.
@@ -53,7 +44,15 @@ export const isNonZeroInt16 = is;
  * @returns The value as a `NonZeroInt16`
  * @throws {TypeError} If the value is not a non-zero integer in [-2^15, 2^15)
  */
-export const asNonZeroInt16 = castType;
+export const asNonZeroInt16 = <N extends number>(
+  value: N,
+): NonZeroInt16 & N => {
+  if (!isNonZeroInt16(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonZeroInt16` branded type.
@@ -69,7 +68,7 @@ export const NonZeroInt16 = {
    * @returns `true` if the value is a non-zero integer in [-2^15, 2^15), `false` otherwise
    * @see {@link isNonZeroInt16} for usage examples
    */
-  is,
+  is: isNonZeroInt16,
 
   /**
    * The smallest value representable as `NonZeroInt16` (the lower saturation