ts-data-forge 14.10.1 → 14.11.0

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

@@ -1,41 +1,25 @@
-import type {
-  SafeUint,
-  PositiveSafeInt as TtfImported_PositiveSafeInt,
-} from 'ts-type-forge';
+import type { PositiveSafeInt as TtfImported_PositiveSafeInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type PositiveSafeInt = TtfImported_PositiveSafeInt;
-
-type ElementType = PositiveSafeInt;
-
-const typeNameInMessage = 'a positive safe integer';
-
-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,
-  SafeUint
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: 1,
-  // 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);
+} from '../operators/positive-safe-int.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type PositiveSafeInt = TtfImported_PositiveSafeInt;
+
+type ElementType = PositiveSafeInt;
+
+const typeNameInMessage = 'a positive safe integer';
 
 /**
  * Type guard that checks if a value is a positive safe integer.
@@ -58,7 +42,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a positive safe integer, `false` otherwise
  */
-export const isPositiveSafeInt = is;
+export const isPositiveSafeInt = (value: number): value is PositiveSafeInt =>
+  Number.isSafeInteger(value) && value >= 1;
 
 /**
  * Casts a `number` to the `PositiveSafeInt` branded type.
@@ -80,7 +65,15 @@ export const isPositiveSafeInt = is;
  * @returns The value as a `PositiveSafeInt`
  * @throws {TypeError} If the value is not a positive safe integer
  */
-export const asPositiveSafeInt = castType;
+export const asPositiveSafeInt = <N extends number>(
+  value: N,
+): PositiveSafeInt & N => {
+  if (!isPositiveSafeInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `PositiveSafeInt` branded
@@ -109,7 +102,7 @@ export const PositiveSafeInt = {
    * @returns `true` if the value is a positive safe integer, `false` otherwise
    * @see {@link isPositiveSafeInt} for usage examples
    */
-  is,
+  is: isPositiveSafeInt,
 
   /**
    * The smallest value representable as `PositiveSafeInt` (the lower saturation

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

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

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

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

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

@@ -1,40 +1,26 @@
-import type { SafeUint, SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
+import type { SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type SafeInt = TtfImported_SafeInt;
-
-type ElementType = SafeInt;
-
-const typeNameInMessage = 'a safe integer';
-
-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,
-  SafeInt,
-  SafeUint
->({
-  integerOrSafeInteger: 'SafeInteger',
-  // 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);
+} from '../operators/safe-int.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type SafeInt = TtfImported_SafeInt;
+
+type ElementType = SafeInt;
+
+const typeNameInMessage = 'a safe integer';
 
 /**
  * Type guard that checks if a value is a safe integer.
@@ -54,7 +40,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a safe integer, `false` otherwise
  */
-export const isSafeInt = is;
+export const isSafeInt = (value: number): value is SafeInt =>
+  Number.isSafeInteger(value);
 
 /**
  * Casts a `number` to the `SafeInt` branded type.
@@ -76,7 +63,13 @@ export const isSafeInt = is;
  * @returns The value as a `SafeInt`
  * @throws {TypeError} If the value is not a safe integer
  */
-export const asSafeInt = castType;
+export const asSafeInt = <N extends number>(value: N): SafeInt & N => {
+  if (!isSafeInt(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `SafeInt` branded type.
@@ -102,7 +95,7 @@ export const SafeInt = {
    * @returns `true` if the value is a safe integer, `false` otherwise
    * @see {@link isSafeInt} for usage examples
    */
-  is,
+  is: isSafeInt,
 
   /**
    * The smallest value representable as `SafeInt` (the lower saturation target

package/src/number/branded-types/safe-uint.mts

@@ -1,38 +1,25 @@
 import type { SafeUint as TtfImported_SafeUint } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type SafeUint = TtfImported_SafeUint;
-
-type ElementType = SafeUint;
-
-const typeNameInMessage = 'a non-negative safe integer';
-
-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,
-  SafeUint
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: 0,
-  // 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);
+} from '../operators/safe-uint.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type SafeUint = TtfImported_SafeUint;
+
+type ElementType = SafeUint;
+
+const typeNameInMessage = 'a non-negative safe integer';
 
 /**
  * Type guard that checks if a value is a non-negative safe integer.
@@ -43,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-negative safe integer, `false` otherwise
  */
-export const isSafeUint = is;
+export const isSafeUint = (value: number): value is SafeUint =>
+  Number.isSafeInteger(value) && value >= 0;
 
 /**
  * Casts a `number` to the `SafeUint` branded type.
@@ -55,7 +43,13 @@ export const isSafeUint = is;
  * @returns The value as a `SafeUint`
  * @throws {TypeError} If the value is not a non-negative safe integer
  */
-export const asSafeUint = castType;
+export const asSafeUint = <N extends number>(value: N): SafeUint & N => {
+  if (!isSafeUint(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `SafeUint` branded type.
@@ -71,7 +65,7 @@ export const SafeUint = {
    * @returns `true` if the value is a non-negative safe integer, `false` otherwise
    * @see {@link isSafeUint} for usage examples
    */
-  is,
+  is: isSafeUint,
 
   /**
    * The smallest value representable as `SafeUint` (the lower saturation target

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

@@ -1,36 +1,24 @@
 import type { Uint as TtfImported_Uint } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type Uint = TtfImported_Uint;
-
-type ElementType = Uint;
-
-const typeNameInMessage = 'a non-negative 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,
-  0,
-  number
->({
-  integerOrSafeInteger: 'Integer',
-  MIN_VALUE: 0,
-  MAX_VALUE: Number.MAX_VALUE,
-  typeNameInMessage,
-} as const);
+} from '../operators/uint.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type Uint = TtfImported_Uint;
+
+type ElementType = Uint;
+
+const typeNameInMessage = 'a non-negative integer';
 
 /**
  * Type guard that checks if a value is a non-negative integer.
@@ -52,7 +40,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer, `false` otherwise
  */
-export const isUint = is;
+export const isUint = (value: number): value is Uint =>
+  Number.isInteger(value) && value >= 0;
 
 /**
  * Casts a `number` to the `Uint` branded type.
@@ -74,7 +63,13 @@ export const isUint = is;
  * @returns The value as an `Uint`
  * @throws {TypeError} If the value is not a non-negative integer
  */
-export const asUint = castType;
+export const asUint = <N extends number>(value: N): Uint & N => {
+  if (!isUint(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `Uint` branded type.
@@ -104,7 +99,7 @@ export const Uint = {
    * @returns `true` if the value is a non-negative integer, `false` otherwise
    * @see {@link isUint} for usage examples
    */
-  is,
+  is: isUint,
 
   /**
    * The smallest value representable as `Uint` (the lower saturation target of

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

@@ -1,37 +1,25 @@
 import type { Uint16 as TtfImported_Uint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type Uint16 = TtfImported_Uint16;
-
-type ElementType = Uint16;
-
-const typeNameInMessage = 'a non-negative integer less than 2^16';
-
-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 ** 16 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/uint16.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type Uint16 = TtfImported_Uint16;
+
+type ElementType = Uint16;
+
+const typeNameInMessage = 'a non-negative integer less than 2^16';
 
 /**
  * Type guard that checks if a value is a non-negative integer less than 2^16.
@@ -42,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer less than 2^16, `false` otherwise
  */
-export const isUint16 = is;
+export const isUint16 = (value: number): value is Uint16 =>
+  Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 16 - 1;
 
 /**
  * Casts a `number` to the `Uint16` branded type.
@@ -54,7 +43,13 @@ export const isUint16 = is;
  * @returns The value as an `Uint16`
  * @throws {TypeError} If the value is not a non-negative integer less than 2^16
  */
-export const asUint16 = castType;
+export const asUint16 = <N extends number>(value: N): Uint16 & N => {
+  if (!isUint16(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `Uint16` branded type.
@@ -70,7 +65,7 @@ export const Uint16 = {
    * @returns `true` if the value is a non-negative integer less than 2^16, `false` otherwise
    * @see {@link isUint16} for usage examples
    */
-  is,
+  is: isUint16,
 
   /**
    * The smallest value representable as `Uint16` (the lower saturation target

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

@@ -1,37 +1,25 @@
 import type { Uint32 as TtfImported_Uint32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type Uint32 = TtfImported_Uint32;
-
-type ElementType = Uint32;
-
-const typeNameInMessage = 'a non-negative integer less than 2^32';
-
-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 ** 32 - 1,
-  typeNameInMessage,
-} as const);
+} from '../operators/uint32.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export type Uint32 = TtfImported_Uint32;
+
+type ElementType = Uint32;
+
+const typeNameInMessage = 'a non-negative integer less than 2^32';
 
 /**
  * Type guard that checks if a value is a non-negative integer less than 2^32.
@@ -42,7 +30,8 @@ const {
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer less than 2^32, `false` otherwise
  */
-export const isUint32 = is;
+export const isUint32 = (value: number): value is Uint32 =>
+  Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 32 - 1;
 
 /**
  * Casts a `number` to the `Uint32` branded type.
@@ -54,7 +43,13 @@ export const isUint32 = is;
  * @returns The value as an `Uint32`
  * @throws {TypeError} If the value is not a non-negative integer less than 2^32
  */
-export const asUint32 = castType;
+export const asUint32 = <N extends number>(value: N): Uint32 & N => {
+  if (!isUint32(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
 
 /**
  * Namespace providing type-safe operations for the `Uint32` branded type.
@@ -70,7 +65,7 @@ export const Uint32 = {
    * @returns `true` if the value is a non-negative integer less than 2^32, `false` otherwise
    * @see {@link isUint32} for usage examples
    */
-  is,
+  is: isUint32,
 
   /**
    * The smallest value representable as `Uint32` (the lower saturation target