ts-data-forge 6.13.0 → 7.0.0

package/src/number/refined-number-utils.mts

@@ -6,6 +6,7 @@ import {
   type IntersectBrand,
   type NonNegativeNumber,
   type NonZeroNumber,
+  type PositiveNumber,
   type RelaxedExclude,
   type TypeEq,
   type UnknownBrand,
@@ -84,10 +85,10 @@ export namespace TsDataForgeInternals {
      * @template N - A branded number type
      * @internal
      */
-    export type ToNonNegative<N extends UnknownNumberBrand> = IntersectBrand<
-      N,
-      NonNegativeNumber
-    >;
+    export type ToNonNegative<N extends UnknownNumberBrand> =
+      '!=0' extends UnwrapBrandTrueKeys<N>
+        ? IntersectBrand<N, PositiveNumber>
+        : IntersectBrand<N, NonNegativeNumber>;
 
     /**
      * Removes the non-zero brand constraint from a branded number type. Used
@@ -99,7 +100,7 @@ export namespace TsDataForgeInternals {
     export type RemoveNonZeroBrandKey<N extends UnknownNumberBrand> = Brand<
       GetBrandValuePart<N>,
       RelaxedExclude<UnwrapBrandTrueKeys<N>, '!=0'> & string,
-      UnwrapBrandFalseKeys<N> & string
+      RelaxedExclude<UnwrapBrandFalseKeys<N>, '<=0' | '>=0'> & string
     >;
 
     type CastToInt<N> = N extends Int ? N : never;
@@ -120,9 +121,13 @@ export namespace TsDataForgeInternals {
      *   'positive' | 'range'
      * @internal
      */
+    /** The closed binary arithmetic operations a branded namespace may expose. */
+    export type NumberClassBinOp = 'add' | 'div' | 'mul' | 'sub';
+
     export type NumberClass<
       N extends UnknownNumberBrand,
       classes extends 'int' | 'non-negative' | 'positive' | 'range',
+      binOps extends NumberClassBinOp = NumberClassBinOp,
     > = ('int' extends classes
       ? unknown
       : 'positive' extends classes
@@ -162,16 +167,21 @@ export namespace TsDataForgeInternals {
             clamp: (a: number) => N;
           }>
         : unknown) &
+      Pick<
+        Readonly<{
+          add: (x: N, y: N) => N;
+          sub: (x: N, y: N) => N;
+          mul: (x: N, y: N) => N;
+          div: (x: N, y: ToNonZero<N>) => N;
+        }>,
+        binOps
+      > &
       Readonly<{
         is: (a: number) => a is N;
         min: (...values: readonly N[]) => N;
         max: (...values: readonly N[]) => N;
         random: (min: N, max: N) => N;
         pow: (x: N, y: N) => N;
-        add: (x: N, y: N) => N;
-        sub: (x: N, y: N) => N;
-        mul: (x: N, y: N) => N;
-        div: (x: N, y: ToNonZero<N>) => N;
       }>;
 
     type BaseKeys =

package/src/others/map-nullable.test.mts

@@ -143,10 +143,9 @@ describe(mapNullable, () => {
 
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
 
-      const result = pipe(42 as number | null)
-        .map(toStr)
-        .map(addPrefix)
-        .map(toUpperCase).value;
+      const x = 42 as number | null;
+
+      const result = pipe(x).map(toStr).map(addPrefix).map(toUpperCase).value;
 
       expect(result).toBe('NUMBER: 42');
     });