Remove nullToNaN

Author: ntkme

lib/src/value/color.ts

@@ -117,14 +117,6 @@ function getColorSpace(options: ChannelOptions): KnownColorSpace {
   throw valueError('No color space found');
 }
 
-/**
- * Convert from the ColorJS representation of a missing component (`null`) to
- * `NaN`.
- */
-function nullToNaN(val: number | null): number {
-  return val ?? NaN;
-}
-
 /**
  * Convert from the ColorJS representation of a missing component (`null`) to
  * `0`.
@@ -650,8 +642,7 @@ export class SassColor extends Value {
    */
   get red(): number {
     emitColor4ApiGetterDeprecation('red');
-    const val = nullToZero(coordToRgb(this.color.srgb.red));
-    return fuzzyRound(val);
+    return fuzzyRound(coordToRgb(this.color.srgb.red)) ?? 0;
   }
 
   /**
@@ -661,8 +652,7 @@ export class SassColor extends Value {
    */
   get green(): number {
     emitColor4ApiGetterDeprecation('green');
-    const val = nullToZero(coordToRgb(this.color.srgb.green));
-    return fuzzyRound(val);
+    return fuzzyRound(coordToRgb(this.color.srgb.green)) ?? 0;
   }
 
   /**
@@ -672,8 +662,7 @@ export class SassColor extends Value {
    */
   get blue(): number {
     emitColor4ApiGetterDeprecation('blue');
-    const val = nullToZero(coordToRgb(this.color.srgb.blue));
-    return fuzzyRound(val);
+    return fuzzyRound(coordToRgb(this.color.srgb.blue)) ?? 0;
   }
 
   /**
@@ -1157,49 +1146,47 @@ export class SassColor extends Value {
         coords = this.color
           .to('srgb')
           .coords.map(coordToRgb)
-          .map(nullToNaN)
-          .map(fuzzyRound) as [number, number, number];
+          .map(fuzzyRound) as [number | null, number | null, number | null];
         otherCoords = other.color
           .to('srgb')
           .coords.map(coordToRgb)
-          .map(nullToNaN)
-          .map(fuzzyRound) as [number, number, number];
+          .map(fuzzyRound) as [number | null, number | null, number | null];
       }
       return (
-        fuzzyEquals(nullToNaN(coords[0]), nullToNaN(otherCoords[0])) &&
-        fuzzyEquals(nullToNaN(coords[1]), nullToNaN(otherCoords[1])) &&
-        fuzzyEquals(nullToNaN(coords[2]), nullToNaN(otherCoords[2]))
+        fuzzyEquals(coords[0], otherCoords[0]) &&
+        fuzzyEquals(coords[1], otherCoords[1]) &&
+        fuzzyEquals(coords[2], otherCoords[2])
       );
     }
     return (
       this.space === other.space &&
-      fuzzyEquals(nullToNaN(coords[0]), nullToNaN(otherCoords[0])) &&
-      fuzzyEquals(nullToNaN(coords[1]), nullToNaN(otherCoords[1])) &&
-      fuzzyEquals(nullToNaN(coords[2]), nullToNaN(otherCoords[2])) &&
+      fuzzyEquals(coords[0], otherCoords[0]) &&
+      fuzzyEquals(coords[1], otherCoords[1]) &&
+      fuzzyEquals(coords[2], otherCoords[2]) &&
       fuzzyEquals(this.alpha, other.alpha)
     );
   }
 
   hashCode(): number {
     let coords = this.color.coords;
     if (this.isLegacy) {
-      coords = this.color
-        .to('srgb')
-        .coords.map(coordToRgb)
-        .map(nullToNaN)
-        .map(fuzzyRound) as [number, number, number];
+      coords = this.color.to('srgb').coords.map(coordToRgb).map(fuzzyRound) as [
+        number,
+        number,
+        number,
+      ];
       return (
-        fuzzyHashCode(nullToNaN(coords[0])) ^
-        fuzzyHashCode(nullToNaN(coords[1])) ^
-        fuzzyHashCode(nullToNaN(coords[2])) ^
+        fuzzyHashCode(coords[0]) ^
+        fuzzyHashCode(coords[1]) ^
+        fuzzyHashCode(coords[2]) ^
         fuzzyHashCode(this.alpha)
       );
     }
     return (
       hash(this.space) ^
-      fuzzyHashCode(nullToNaN(coords[0])) ^
-      fuzzyHashCode(nullToNaN(coords[1])) ^
-      fuzzyHashCode(nullToNaN(coords[2])) ^
+      fuzzyHashCode(coords[0]) ^
+      fuzzyHashCode(coords[1]) ^
+      fuzzyHashCode(coords[2]) ^
       fuzzyHashCode(this.alpha)
     );
   }

lib/src/value/utils.ts

@@ -16,7 +16,10 @@ export const precision = 10;
 const epsilon = 10 ** (-precision - 1);
 
 /** Whether `num1` and `num2` are equal within `epsilon`. */
-export function fuzzyEquals(num1: number, num2: number): boolean {
+export function fuzzyEquals(num1: number | null, num2: number | null): boolean {
+  if (num1 === null || num2 === null) {
+    return false;
+  }
   return Math.abs(num1 - num2) < epsilon;
 }
 
@@ -25,10 +28,8 @@ export function fuzzyEquals(num1: number, num2: number): boolean {
  *
  * Two numbers that `fuzzyEquals` each other must have the same hash code.
  */
-export function fuzzyHashCode(num: number): number {
-  return !isFinite(num) || isNaN(num)
-    ? hash(num)
-    : hash(Math.round(num / epsilon));
+export function fuzzyHashCode(num: number | null): number {
+  return num === null ? hash(num) : hash(Math.round(num / epsilon));
 }
 
 /** Whether `num1` < `num2`, within `epsilon`. */
@@ -72,7 +73,10 @@ export function fuzzyAsInt(num: number): number | null {
  *
  * If `num` `fuzzyEquals` `x.5`, rounds away from zero.
  */
-export function fuzzyRound(num: number): number {
+export function fuzzyRound(num: number | null): number | null {
+  if (num === null) {
+    return num;
+  }
   if (num > 0) {
     return fuzzyLessThan(num % 1, 0.5) ? Math.floor(num) : Math.ceil(num);
   } else {