ts-data-forge 14.10.1 → 14.11.0

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

@@ -1,36 +1,23 @@
 import type { NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonZeroInt32 = TtfImported_NonZeroInt32;
-
-type ElementType = NonZeroInt32;
-
-const typeNameInMessage = 'a non-zero integer in [-2^31, 2^31)';
-
-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 ** 31),
-  MAX_VALUE: 2 ** 31 - 1,
-  typeNameInMessage,
-} as const);
+  randomNonZero as random,
+} from '../operators/non-zero-int32.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonZeroInt32 = TtfImported_NonZeroInt32;
+
+type ElementType = NonZeroInt32;
+
+const typeNameInMessage = 'a non-zero integer in [-2^31, 2^31)';
 
 /**
  * Type guard that checks if a value is a non-zero integer in [-2^31, 2^31).
@@ -41,7 +28,11 @@ const {
  * @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;
+export const isNonZeroInt32 = (value: number): value is NonZeroInt32 =>
+  Number.isSafeInteger(value) &&
+  value !== 0 &&
+  -(2 ** 31) <= value &&
+  value <= 2 ** 31 - 1;
 
 /**
  * Casts a `number` to the `NonZeroInt32` branded type.
@@ -53,7 +44,15 @@ export const isNonZeroInt32 = is;
  * @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;
+export const asNonZeroInt32 = <N extends number>(
+  value: N,
+): NonZeroInt32 & N => {
+  if (!isNonZeroInt32(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonZeroInt32` branded type.
@@ -69,7 +68,7 @@ export const NonZeroInt32 = {
    * @returns `true` if the value is a non-zero integer in [-2^31, 2^31), `false` otherwise
    * @see {@link isNonZeroInt32} for usage examples
    */
-  is,
+  is: isNonZeroInt32,
 
   /**
    * The smallest value representable as `NonZeroInt32` (the lower saturation

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

@@ -1,42 +1,23 @@
-import type {
-  SafeInt,
-  SafeUint,
-  NonZeroSafeInt as TtfImported_NonZeroSafeInt,
-} from 'ts-type-forge';
+import type { NonZeroSafeInt as TtfImported_NonZeroSafeInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
-
-type ElementType = NonZeroSafeInt;
-
-const typeNameInMessage = 'a non-zero safe integer';
-
-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,
-  SafeInt,
-  SafeUint
->({
-  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 as SafeInt,
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
-  MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
-  typeNameInMessage,
-} as const);
+  randomNonZero as random,
+} from '../operators/non-zero-safe-int.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
+
+type ElementType = NonZeroSafeInt;
+
+const typeNameInMessage = 'a non-zero safe integer';
 
 /**
  * Type guard that checks if a value is a non-zero safe integer.
@@ -47,7 +28,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-zero safe integer, `false` otherwise
  */
-export const isNonZeroSafeInt = is;
+export const isNonZeroSafeInt = (value: number): value is NonZeroSafeInt =>
+  Number.isSafeInteger(value) && value !== 0;
 
 /**
  * Casts a `number` to the `NonZeroSafeInt` branded type.
@@ -59,7 +41,15 @@ export const isNonZeroSafeInt = is;
  * @returns The value as a `NonZeroSafeInt`
  * @throws {TypeError} If the value is not a non-zero safe integer
  */
-export const asNonZeroSafeInt = castType;
+export const asNonZeroSafeInt = <N extends number>(
+  value: N,
+): NonZeroSafeInt & N => {
+  if (!isNonZeroSafeInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonZeroSafeInt` branded
@@ -76,7 +66,7 @@ export const NonZeroSafeInt = {
    * @returns `true` if the value is a non-zero safe integer, `false` otherwise
    * @see {@link isNonZeroSafeInt} for usage examples
    */
-  is,
+  is: isNonZeroSafeInt,
 
   /**
    * The smallest value representable as `NonZeroSafeInt` (the lower saturation

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

@@ -1,36 +1,23 @@
 import type { NonZeroUint16 as TtfImported_NonZeroUint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type NonZeroUint16 = TtfImported_NonZeroUint16;
-
-type ElementType = NonZeroUint16;
-
-const typeNameInMessage = 'a non-zero integer in [1, 2^16)';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
   add,
-  castType,
   fromNumber,
-  is,
-  max: max_,
-  min: min_,
+  max as max_,
+  min as min_,
   mul,
   pow,
-  randomNonZero: random,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  ElementType,
-  1,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  nonZero: true,
-  MIN_VALUE: 1,
-  MAX_VALUE: 2 ** 16 - 1,
-  typeNameInMessage,
-} as const);
+  randomNonZero as random,
+} from '../operators/non-zero-uint16.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type NonZeroUint16 = TtfImported_NonZeroUint16;
+
+type ElementType = NonZeroUint16;
+
+const typeNameInMessage = 'a non-zero integer in [1, 2^16)';
 
 /**
  * Type guard that checks if a value is a non-zero integer in [1, 2^16).
@@ -41,7 +28,8 @@ const {
  * @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;
+export const isNonZeroUint16 = (value: number): value is NonZeroUint16 =>
+  Number.isSafeInteger(value) && 1 <= value && value <= 2 ** 16 - 1;
 
 /**
  * Casts a `number` to the `NonZeroUint16` branded type.
@@ -53,7 +41,15 @@ export const isNonZeroUint16 = is;
  * @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;
+export const asNonZeroUint16 = <N extends number>(
+  value: N,
+): NonZeroUint16 & N => {
+  if (!isNonZeroUint16(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `NonZeroUint16` branded
@@ -70,7 +66,7 @@ export const NonZeroUint16 = {
    * @returns `true` if the value is a non-zero integer in [1, 2^16), `false` otherwise
    * @see {@link isNonZeroUint16} for usage examples
    */
-  is,
+  is: isNonZeroUint16,
 
   /**
    * The smallest value representable as `NonZeroUint16` (the lower saturation

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

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

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

@@ -4,36 +4,25 @@ import type {
   Uint,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type PositiveFiniteNumber = TtfImported_PositiveFiniteNumber;
-
-type ElementType = PositiveFiniteNumber;
-
-const typeNameInMessage = 'a positive 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,
-  number,
-  number
->({
-  MIN_VALUE: Number.MIN_VALUE,
-  MAX_VALUE: Number.MAX_VALUE,
-  typeNameInMessage,
-} as const);
+} from '../operators/positive-finite-number.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type PositiveFiniteNumber = TtfImported_PositiveFiniteNumber;
+
+type ElementType = PositiveFiniteNumber;
+
+const typeNameInMessage = 'a positive finite number';
 
 const floor = (
   x: ElementType,
@@ -86,7 +75,10 @@ expectType<
  * @param value - The value to check
  * @returns `true` if the value is a positive finite number, `false` otherwise
  */
-export const isPositiveFiniteNumber = is;
+export const isPositiveFiniteNumber = (
+  value: number,
+): value is PositiveFiniteNumber =>
+  Number.isFinite(value) && value >= Number.MIN_VALUE;
 
 /**
  * Casts a `number` to the `PositiveFiniteNumber` branded type.
@@ -98,7 +90,15 @@ export const isPositiveFiniteNumber = is;
  * @returns The value as a `PositiveFiniteNumber`
  * @throws {TypeError} If the value is not a positive finite number
  */
-export const asPositiveFiniteNumber = castType;
+export const asPositiveFiniteNumber = <N extends number>(
+  value: N,
+): PositiveFiniteNumber & N => {
+  if (!isPositiveFiniteNumber(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `PositiveFiniteNumber`
@@ -114,7 +114,7 @@ export const PositiveFiniteNumber = {
    * @returns `true` if the value is a positive finite number, `false` otherwise
    * @see {@link isPositiveFiniteNumber} for usage examples
    */
-  is,
+  is: isPositiveFiniteNumber,
 
   /**
    * The smallest value representable as `PositiveFiniteNumber` (the lower

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

@@ -1,36 +1,24 @@
 import type { PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type PositiveInt = TtfImported_PositiveInt;
-
-type ElementType = PositiveInt;
-
-const typeNameInMessage = 'a positive integer';
-
-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.operatorsForInteger<
-  ElementType,
-  1,
-  number
->({
-  integerOrSafeInteger: 'Integer',
-  MIN_VALUE: 1,
-  MAX_VALUE: Number.MAX_VALUE,
-  typeNameInMessage,
-} as const);
+} from '../operators/positive-int.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type PositiveInt = TtfImported_PositiveInt;
+
+type ElementType = PositiveInt;
+
+const typeNameInMessage = 'a positive integer';
 
 /**
  * Type guard that checks if a value is a positive integer.
@@ -51,7 +39,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a positive integer, `false` otherwise
  */
-export const isPositiveInt = is;
+export const isPositiveInt = (value: number): value is PositiveInt =>
+  Number.isInteger(value) && value >= 1;
 
 /**
  * Casts a `number` to the `PositiveInt` branded type.
@@ -73,7 +62,13 @@ export const isPositiveInt = is;
  * @returns The value as a `PositiveInt`
  * @throws {TypeError} If the value is not a positive integer
  */
-export const asPositiveInt = castType;
+export const asPositiveInt = <N extends number>(value: N): PositiveInt & N => {
+  if (!isPositiveInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `PositiveInt` branded type.
@@ -103,7 +98,7 @@ export const PositiveInt = {
    * @returns `true` if the value is a positive integer, `false` otherwise
    * @see {@link isPositiveInt} for usage examples
    */
-  is,
+  is: isPositiveInt,
 
   /**
    * The smallest value representable as `PositiveInt` (the lower saturation

package/src/number/branded-types/positive-int16.mts

@@ -1,37 +1,25 @@
 import type { PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type PositiveInt16 = TtfImported_PositiveInt16;
-
-type ElementType = PositiveInt16;
-
-const typeNameInMessage = 'a positive integer in [1, 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,
-  1,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: 1,
-  MAX_VALUE: 2 ** 15 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/positive-int16.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type PositiveInt16 = TtfImported_PositiveInt16;
+
+type ElementType = PositiveInt16;
+
+const typeNameInMessage = 'a positive integer in [1, 2^15)';
 
 /**
  * Type guard that checks if a value is a positive integer in [1, 2^15).
@@ -42,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a positive integer in [1, 2^15), `false` otherwise
  */
-export const isPositiveInt16 = is;
+export const isPositiveInt16 = (value: number): value is PositiveInt16 =>
+  Number.isSafeInteger(value) && 1 <= value && value <= 2 ** 15 - 1;
 
 /**
  * Casts a `number` to the `PositiveInt16` branded type.
@@ -54,7 +43,15 @@ export const isPositiveInt16 = is;
  * @returns The value as a `PositiveInt16`
  * @throws {TypeError} If the value is not a positive integer in [1, 2^15)
  */
-export const asPositiveInt16 = castType;
+export const asPositiveInt16 = <N extends number>(
+  value: N,
+): PositiveInt16 & N => {
+  if (!isPositiveInt16(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `PositiveInt16` branded
@@ -71,7 +68,7 @@ export const PositiveInt16 = {
    * @returns `true` if the value is a positive integer in [1, 2^15), `false` otherwise
    * @see {@link isPositiveInt16} for usage examples
    */
-  is,
+  is: isPositiveInt16,
 
   /**
    * The smallest value representable as `PositiveInt16` (the lower saturation

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

@@ -1,37 +1,25 @@
 import type { PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type PositiveInt32 = TtfImported_PositiveInt32;
-
-type ElementType = PositiveInt32;
-
-const typeNameInMessage = 'a positive integer in [1, 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,
-  1,
-  number
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: 1,
-  MAX_VALUE: 2 ** 31 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/positive-int32.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type PositiveInt32 = TtfImported_PositiveInt32;
+
+type ElementType = PositiveInt32;
+
+const typeNameInMessage = 'a positive integer in [1, 2^31)';
 
 /**
  * Type guard that checks if a value is a positive integer in [1, 2^31).
@@ -42,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a positive integer in [1, 2^31), `false` otherwise
  */
-export const isPositiveInt32 = is;
+export const isPositiveInt32 = (value: number): value is PositiveInt32 =>
+  Number.isSafeInteger(value) && 1 <= value && value <= 2 ** 31 - 1;
 
 /**
  * Casts a `number` to the `PositiveInt32` branded type.
@@ -54,7 +43,15 @@ export const isPositiveInt32 = is;
  * @returns The value as a `PositiveInt32`
  * @throws {TypeError} If the value is not a positive integer in [1, 2^31)
  */
-export const asPositiveInt32 = castType;
+export const asPositiveInt32 = <N extends number>(
+  value: N,
+): PositiveInt32 & N => {
+  if (!isPositiveInt32(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `PositiveInt32` branded
@@ -71,7 +68,7 @@ export const PositiveInt32 = {
    * @returns `true` if the value is a positive integer in [1, 2^31), `false` otherwise
    * @see {@link isPositiveInt32} for usage examples
    */
-  is,
+  is: isPositiveInt32,
 
   /**
    * The smallest value representable as `PositiveInt32` (the lower saturation