ts-data-forge 14.10.2 → 14.11.0

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

package/src/number/enum/int8.mts

@@ -5,47 +5,58 @@ import type {
   Int8 as TtfImported_Int8,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import {
+  MAX_VALUE,
+  MIN_VALUE,
+  castType as castTypeImpl,
+  fromNumber as fromNumberImpl,
+  random as randomImpl,
+} from '../operators/int8.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 export type Int8 = TtfImported_Int8;
 
 const typeNameInMessage = 'an integer in [-128, 127]';
 
-const {
-  MAX_VALUE,
-  MIN_VALUE,
-  castType: castTypeImpl,
-  fromNumber: fromNumberImpl,
-  is: isImpl,
-  random: randomImpl,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
-  Int16,
-  -128,
-  127
->({
-  integerOrSafeInteger: 'SafeInteger',
-  MIN_VALUE: -128,
-  MAX_VALUE: 127,
-  typeNameInMessage,
-} as const);
+/**
+ * Type guard that checks if a value is an integer in [-128, 127].
+ *
+ * Returns `true` for an integer in [-128, 127] — a value with no fractional
+ * component.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
+ */
+export const isInt8 = (value: number): value is Int8 =>
+  Number.isSafeInteger(value) && -128 <= value && value <= 127;
 
-const is = (x: number): x is Int8 => isImpl(x);
+/**
+ * Casts a `number` to the `Int8` branded type.
+ *
+ * Validates that the value is an integer in [-128, 127] and returns it with the
+ * `Int8` brand. Throws a `TypeError` otherwise.
+ *
+ * @param value - The value to cast
+ * @returns The value as an `Int8`
+ * @throws {TypeError} If the value is not an integer in [-128, 127]
+ */
+export const asInt8 = (value: number): Int8 => {
+  if (!isInt8(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
 
-const castType = (x: number): Int8 =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  castTypeImpl(x) as Int8;
+  return value;
+};
 
-const fromNumber = (a: number): Int8 => castType(fromNumberImpl(a));
+const fromNumber = (a: number): Int8 => asInt8(fromNumberImpl(a));
 
 const abs = <N extends Int8>(x: N): AbsoluteValue<N> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `Math.abs` as returning `number`
   Math.abs(x) as unknown as AbsoluteValue<N>;
 
-const min_ = (...values: readonly Int8[]): Int8 =>
-  castType(Math.min(...values));
+const min_ = (...values: readonly Int8[]): Int8 => asInt8(Math.min(...values));
 
-const max_ = (...values: readonly Int8[]): Int8 =>
-  castType(Math.max(...values));
+const max_ = (...values: readonly Int8[]): Int8 => asInt8(Math.max(...values));
 
 const pow = (x: Int8, y: Int8): Int8 => fromNumber(x ** y);
 
@@ -59,30 +70,7 @@ const div = (x: Int8, y: StrictExclude<Int8, 0>): Int8 =>
   fromNumber(Math.floor(x / y));
 
 const random = (min: Int8, max: Int8): Int8 =>
-  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
-
-/**
- * Type guard that checks if a value is an integer in [-128, 127].
- *
- * Returns `true` for an integer in [-128, 127] — a value with no fractional
- * component.
- *
- * @param value - The value to check
- * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
- */
-export const isInt8 = is;
-
-/**
- * Casts a `number` to the `Int8` branded type.
- *
- * Validates that the value is an integer in [-128, 127] and returns it with the
- * `Int8` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as an `Int8`
- * @throws {TypeError} If the value is not an integer in [-128, 127]
- */
-export const asInt8 = castType;
+  asInt8(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 
 /**
  * Namespace providing type-safe operations for the `Int8` branded type.
@@ -98,7 +86,7 @@ export const Int8 = {
    * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
    * @see {@link isInt8} for usage examples
    */
-  is,
+  is: isInt8,
 
   /**
    * The smallest value representable as `Int8` (the lower saturation target of

package/src/number/enum/uint8.mts

@@ -4,55 +4,18 @@ import type {
   Uint16,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
-
-export type Uint8 = TtfImported_Uint8;
-
-const typeNameInMessage = 'an non-negative integer less than 256';
-
-const {
+import {
   MAX_VALUE,
   MIN_VALUE,
-  castType: castTypeImpl,
-  fromNumber: fromNumberImpl,
-  is: isImpl,
-  random: randomImpl,
-} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<Uint16, 0, 255>(
-  {
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: 0,
-    MAX_VALUE: 255,
-    typeNameInMessage,
-  } as const,
-);
-
-const is = (x: number): x is Uint8 => isImpl(x);
-
-const castType = (x: number): Uint8 =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  castTypeImpl(x) as Uint8;
-
-const fromNumber = (a: number): Uint8 => castType(fromNumberImpl(a));
-
-const min_ = (...values: readonly Uint8[]): Uint8 =>
-  castType(Math.min(...values));
-
-const max_ = (...values: readonly Uint8[]): Uint8 =>
-  castType(Math.max(...values));
-
-const pow = (x: Uint8, y: Uint8): Uint8 => fromNumber(x ** y);
+  castType as castTypeImpl,
+  fromNumber as fromNumberImpl,
+  random as randomImpl,
+} from '../operators/uint8.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
-const add = (x: Uint8, y: Uint8): Uint8 => fromNumber(x + y);
-
-const sub = (x: Uint8, y: Uint8): Uint8 => fromNumber(x - y);
-
-const mul = (x: Uint8, y: Uint8): Uint8 => fromNumber(x * y);
-
-const div = (x: Uint8, y: StrictExclude<Uint8, 0>): Uint8 =>
-  fromNumber(Math.floor(x / y));
+export type Uint8 = TtfImported_Uint8;
 
-const random = (min: Uint8, max: Uint8): Uint8 =>
-  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
+const typeNameInMessage = 'an non-negative integer less than 256';
 
 /**
  * Type guard that checks if a value is an non-negative integer less than 256.
@@ -63,7 +26,8 @@ const random = (min: Uint8, max: Uint8): Uint8 =>
  * @param value - The value to check
  * @returns `true` if the value is an non-negative integer less than 256, `false` otherwise
  */
-export const isUint8 = is;
+export const isUint8 = (value: number): value is Uint8 =>
+  Number.isSafeInteger(value) && 0 <= value && value <= 255;
 
 /**
  * Casts a `number` to the `Uint8` branded type.
@@ -75,7 +39,35 @@ export const isUint8 = is;
  * @returns The value as an `Uint8`
  * @throws {TypeError} If the value is not an non-negative integer less than 256
  */
-export const asUint8 = castType;
+export const asUint8 = (value: number): Uint8 => {
+  if (!isUint8(value)) {
+    throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+  }
+
+  return value;
+};
+
+const fromNumber = (a: number): Uint8 => asUint8(fromNumberImpl(a));
+
+const min_ = (...values: readonly Uint8[]): Uint8 =>
+  asUint8(Math.min(...values));
+
+const max_ = (...values: readonly Uint8[]): Uint8 =>
+  asUint8(Math.max(...values));
+
+const pow = (x: Uint8, y: Uint8): Uint8 => fromNumber(x ** y);
+
+const add = (x: Uint8, y: Uint8): Uint8 => fromNumber(x + y);
+
+const sub = (x: Uint8, y: Uint8): Uint8 => fromNumber(x - y);
+
+const mul = (x: Uint8, y: Uint8): Uint8 => fromNumber(x * y);
+
+const div = (x: Uint8, y: StrictExclude<Uint8, 0>): Uint8 =>
+  fromNumber(Math.floor(x / y));
+
+const random = (min: Uint8, max: Uint8): Uint8 =>
+  asUint8(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 
 /**
  * Namespace providing type-safe operations for the `Uint8` branded type.
@@ -91,7 +83,7 @@ export const Uint8 = {
    * @returns `true` if the value is an non-negative integer less than 256, `false` otherwise
    * @see {@link isUint8} for usage examples
    */
-  is,
+  is: isUint8,
 
   /**
    * The smallest value representable as `Uint8` (the lower saturation target of

package/src/number/index.mts

@@ -1,5 +1,5 @@
 export * from './branded-types/index.mjs';
 export * from './enum/index.mjs';
 export * from './num-arithmetic-types.mjs';
-export * from './num.mjs';
+export * from './num/index.mjs';
 export * from './refined-number-utils.mjs';

package/src/number/num/impl/index.mts

@@ -0,0 +1 @@
+export * from './num.mjs';