ts-data-forge 14.10.2 → 14.11.1

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

@@ -1,38 +1,26 @@
 import type { Int32 as TtfImported_Int32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type Int32 = TtfImported_Int32;
-
-type ElementType = Int32;
-
-const typeNameInMessage = 'an integer in [-2^31, 2^31)';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
   abs,
   add,
-  castType,
   div,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   mul,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  number,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: -(2 ** 31),
-  MAX_VALUE: 2 ** 31 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/int32.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type Int32 = TtfImported_Int32;
+
+type ElementType = Int32;
+
+const typeNameInMessage = 'an integer in [-2^31, 2^31)';
 
 /**
  * Type guard that checks if a value is an integer in [-2^31, 2^31).
@@ -43,7 +31,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is an integer in [-2^31, 2^31), `false` otherwise
  */
-export const isInt32 = is;
+export const isInt32 = (value: number): value is Int32 =>
+  Number.isSafeInteger(value) && -(2 ** 31) <= value && value <= 2 ** 31 - 1;
 
 /**
  * Casts a `number` to the `Int32` branded type.
@@ -55,7 +44,13 @@ export const isInt32 = is;
  * @returns The value as an `Int32`
  * @throws {TypeError} If the value is not an integer in [-2^31, 2^31)
  */
-export const asInt32 = castType;
+export const asInt32 = <N extends number>(value: N): Int32 & N => {
+  if (!isInt32(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `Int32` branded type.
@@ -71,7 +66,7 @@ export const Int32 = {
    * @returns `true` if the value is an integer in [-2^31, 2^31), `false` otherwise
    * @see {@link isInt32} for usage examples
    */
-  is,
+  is: isInt32,
 
   /**
    * The smallest value representable as `Int32` (the lower saturation target of

package/src/number/branded-types/negative-finite-number.mts

@@ -1,5 +1,15 @@
 import type { NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import {
+  MAX_VALUE,
+  add,
+  fromNumber,
+  max as max_,
+  min as min_,
+  pow,
+  random,
+  sub,
+} from '../operators/negative-finite-number.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 import { PositiveFiniteNumber } from './positive-finite-number.mjs';
 
 export type NegativeFiniteNumber = TtfImported_NegativeFiniteNumber;
@@ -8,28 +18,6 @@ type ElementType = NegativeFiniteNumber;
 
 const typeNameInMessage = 'a negative finite number';
 
-const {
-  MAX_VALUE,
-  add,
-  castType,
-  fromNumber,
-  is,
-  max: max_,
-  min: min_,
-  pow,
-  random,
-  sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
-  ElementType,
-  number,
-  number
->({
-  nonZero: true,
-  MIN_VALUE: -Number.MAX_VALUE,
-  MAX_VALUE: -Number.MIN_VALUE,
-  typeNameInMessage,
-} as const);
-
 const abs = (x: ElementType): PositiveFiniteNumber =>
   PositiveFiniteNumber.fromNumber(Math.abs(x));
 
@@ -70,7 +58,10 @@ const round = (
  * @param value - The value to check
  * @returns `true` if the value is a negative finite number, `false` otherwise
  */
-export const isNegativeFiniteNumber = is;
+export const isNegativeFiniteNumber = (
+  value: number,
+): value is NegativeFiniteNumber =>
+  Number.isFinite(value) && value <= -Number.MIN_VALUE;
 
 /**
  * Casts a `number` to the `NegativeFiniteNumber` branded type.
@@ -82,7 +73,15 @@ export const isNegativeFiniteNumber = is;
  * @returns The value as a `NegativeFiniteNumber`
  * @throws {TypeError} If the value is not a negative finite number
  */
-export const asNegativeFiniteNumber = castType;
+export const asNegativeFiniteNumber = <N extends number>(
+  value: N,
+): NegativeFiniteNumber & N => {
+  if (!isNegativeFiniteNumber(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NegativeFiniteNumber`
@@ -98,7 +97,7 @@ export const NegativeFiniteNumber = {
    * @returns `true` if the value is a negative finite number, `false` otherwise
    * @see {@link isNegativeFiniteNumber} for usage examples
    */
-  is,
+  is: isNegativeFiniteNumber,
 
   /**
    * The largest value representable as `NegativeFiniteNumber` (the upper

package/src/number/branded-types/negative-int.mts

@@ -2,7 +2,16 @@ import type {
   NegativeInt as TtfImported_NegativeInt,
   WithSmallInt,
 } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import {
+  MAX_VALUE,
+  add,
+  fromNumber,
+  max as max_,
+  min as min_,
+  pow,
+  random,
+  sub,
+} from '../operators/negative-int.mjs';
 import { PositiveInt } from './positive-int.mjs';
 
 export type NegativeInt = TtfImported_NegativeInt;
@@ -11,29 +20,6 @@ type ElementType = NegativeInt;
 
 const typeNameInMessage = 'a negative integer';
 
-const {
-  MAX_VALUE,
-  add,
-  castType,
-  fromNumber,
-  is,
-  max: max_,
-  min: min_,
-  pow,
-  random,
-  sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  number,
-  -1
->({
-  integerOrSafeInteger: 'Integer',
-  nonZero: true,
-  MIN_VALUE: -Number.MAX_VALUE,
-  MAX_VALUE: -1,
-  typeNameInMessage,
-} as const);
-
 const abs = (x: WithSmallInt<ElementType>): PositiveInt =>
   PositiveInt.fromNumber(Math.abs(x));
 
@@ -46,7 +32,8 @@ const abs = (x: WithSmallInt<ElementType>): PositiveInt =>
  * @param value - The value to check
  * @returns `true` if the value is a negative integer, `false` otherwise
  */
-export const isNegativeInt = is;
+export const isNegativeInt = (value: number): value is NegativeInt =>
+  Number.isInteger(value) && value <= -1;
 
 /**
  * Casts a `number` to the `NegativeInt` branded type.
@@ -58,7 +45,13 @@ export const isNegativeInt = is;
  * @returns The value as a `NegativeInt`
  * @throws {TypeError} If the value is not a negative integer
  */
-export const asNegativeInt = castType;
+export const asNegativeInt = <N extends number>(value: N): NegativeInt & N => {
+  if (!isNegativeInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NegativeInt` branded type.
@@ -78,7 +71,7 @@ export const NegativeInt = {
    * @returns `true` if the value is a negative integer, `false` otherwise
    * @see {@link isNegativeInt} for usage examples
    */
-  is,
+  is: isNegativeInt,
 
   /**
    * The largest value representable as `NegativeInt` (the upper saturation

package/src/number/branded-types/negative-safe-int.mts

@@ -2,38 +2,24 @@ import type {
   NegativeSafeInt as TtfImported_NegativeSafeInt,
   WithSmallInt,
 } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-import { PositiveSafeInt } from './positive-safe-int.mjs';
-
-export type NegativeSafeInt = TtfImported_NegativeSafeInt;
-
-type ElementType = NegativeSafeInt;
-
-const typeNameInMessage = 'a negative 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,
-  -1
->({
-  integerOrSafeInteger: 'SafeInteger',
-  nonZero: true,
-  MIN_VALUE: Number.MIN_SAFE_INTEGER,
-  MAX_VALUE: -1,
-  typeNameInMessage,
-} as const);
+} from '../operators/negative-safe-int.mjs';
+import { PositiveSafeInt } from './positive-safe-int.mjs';
+
+export type NegativeSafeInt = TtfImported_NegativeSafeInt;
+
+type ElementType = NegativeSafeInt;
+
+const typeNameInMessage = 'a negative safe integer';
 
 const abs = (x: WithSmallInt<ElementType>): PositiveSafeInt =>
   PositiveSafeInt.fromNumber(Math.abs(x));
@@ -47,7 +33,8 @@ const abs = (x: WithSmallInt<ElementType>): PositiveSafeInt =>
  * @param value - The value to check
  * @returns `true` if the value is a negative safe integer, `false` otherwise
  */
-export const isNegativeSafeInt = is;
+export const isNegativeSafeInt = (value: number): value is NegativeSafeInt =>
+  Number.isSafeInteger(value) && value <= -1;
 
 /**
  * Casts a `number` to the `NegativeSafeInt` branded type.
@@ -59,7 +46,15 @@ export const isNegativeSafeInt = is;
  * @returns The value as a `NegativeSafeInt`
  * @throws {TypeError} If the value is not a negative safe integer
  */
-export const asNegativeSafeInt = castType;
+export const asNegativeSafeInt = <N extends number>(
+  value: N,
+): NegativeSafeInt & N => {
+  if (!isNegativeSafeInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NegativeSafeInt` branded
@@ -76,7 +71,7 @@ export const NegativeSafeInt = {
    * @returns `true` if the value is a negative safe integer, `false` otherwise
    * @see {@link isNegativeSafeInt} for usage examples
    */
-  is,
+  is: isNegativeSafeInt,
 
   /**
    * The smallest value representable as `NegativeSafeInt` (the lower saturation

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

@@ -3,36 +3,25 @@ import type {
   Uint,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonNegativeFiniteNumber = TtfImported_NonNegativeFiniteNumber;
-
-type ElementType = NonNegativeFiniteNumber;
-
-const typeNameInMessage = 'a non-negative finite number';
-
-const {
+import {
   MIN_VALUE,
   add,
-  castType,
   div,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   mul,
   pow,
   random,
   sub,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
-  ElementType,
-  0,
-  number
->({
-  MIN_VALUE: 0,
-  MAX_VALUE: Number.MAX_VALUE,
-  typeNameInMessage,
-} as const);
+} from '../operators/non-negative-finite-number.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonNegativeFiniteNumber = TtfImported_NonNegativeFiniteNumber;
+
+type ElementType = NonNegativeFiniteNumber;
+
+const typeNameInMessage = 'a non-negative finite number';
 
 const floor = (
   x: ElementType,
@@ -65,7 +54,9 @@ expectType<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>, Uint>(
  * @param value - The value to check
  * @returns `true` if the value is a non-negative finite number, `false` otherwise
  */
-export const isNonNegativeFiniteNumber = is;
+export const isNonNegativeFiniteNumber = (
+  value: number,
+): value is NonNegativeFiniteNumber => Number.isFinite(value) && value >= 0;
 
 /**
  * Casts a `number` to the `NonNegativeFiniteNumber` branded type.
@@ -77,7 +68,15 @@ export const isNonNegativeFiniteNumber = is;
  * @returns The value as a `NonNegativeFiniteNumber`
  * @throws {TypeError} If the value is not a non-negative finite number
  */
-export const asNonNegativeFiniteNumber = castType;
+export const asNonNegativeFiniteNumber = <N extends number>(
+  value: N,
+): NonNegativeFiniteNumber & N => {
+  if (!isNonNegativeFiniteNumber(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonNegativeFiniteNumber`
@@ -93,7 +92,7 @@ export const NonNegativeFiniteNumber = {
    * @returns `true` if the value is a non-negative finite number, `false` otherwise
    * @see {@link isNonNegativeFiniteNumber} for usage examples
    */
-  is,
+  is: isNonNegativeFiniteNumber,
 
   /**
    * The smallest value representable as `NonNegativeFiniteNumber` (the lower

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