postcss-calc 11.0.0-rc.0 → 11.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "11.0.0-rc.0",
+  "version": "11.0.0-rc.1",
   "description": "PostCSS plugin to reduce calc()",
   "keywords": [
     "css",
@@ -31,6 +31,7 @@
     "@eslint/js": "^10.0.1",
     "@rmenke/css-tokenizer-tests": "^1.2.0",
     "@stryker-mutator/core": "^9.6.1",
+    "@stryker-mutator/tap-runner": "^9.6.1",
     "@stryker-mutator/typescript-checker": "^9.6.1",
     "@types/node": "^26.1.1",
     "eslint": "^10.7.0",

package/src/lib/serialize.js

@@ -15,7 +15,15 @@
  * @property {string} [calcName] Wrapper name to use when `calc()` is needed. Default `'calc'`.
  */
 
+// Below this is float noise, not a value: `0.1 + 0.2 - 0.3` is 5.5e-17.
+const NOISE_FLOOR = 1e-12;
+
 /**
+ * Rounding to `prec` decimal places turns `calc(1/1000000)` into `0`, and a
+ * `0` in CSS is often a switch, not a small number (`flex-grow: 0` never
+ * grows). So when a value is too small for `prec`, keep its significant digits
+ * instead: `1/1000000` -> `0.000001`, `1/3000000` -> `3.3333e-7`.
+ *
  * @param {number} v
  * @param {number | false} prec
  * @return {number}
@@ -25,7 +33,12 @@ function round(v, prec) {
     return v;
   }
   const m = Math.pow(10, prec);
-  return Math.round(v * m) / m;
+  const rounded = Math.round(v * m) / m;
+  if (rounded === 0 && Math.abs(v) > NOISE_FLOOR) {
+    // toPrecision needs at least one significant digit; `prec` may be 0.
+    return Number(v.toPrecision(Math.max(prec, 1)));
+  }
+  return rounded;
 }
 
 // §10.13 / §10.7.2: Infinity/NaN serialize as canonical keywords.

package/src/lib/simplify/bucket.js

@@ -11,6 +11,7 @@ const { convert } = require('../convertUnits.js');
  * @typedef {object} UnitBucket
  * @property {string} unit
  * @property {number} total
+ * @property {number} scale largest |term| accumulated into `total`, for noise detection
  * @property {import('../convertUnits.js').BaseType | null} base
  * @property {number} order
  */

package/src/lib/simplify/sum.js

@@ -12,6 +12,19 @@ const { mergeConvertibleBuckets } = require('./bucket.js');
  * @typedef {import('./bucket.js').UnitBucket} UnitBucket
  */
 
+// Subtracting near-equal terms leaves float dust: `0.07 * 1e7 - 700000` is
+// 1.16e-10, not 0. Snap a total that's tiny next to its terms back to 0.
+const NOISE_REL = Number.EPSILON * 8;
+
+/**
+ * @param {number} total
+ * @param {number} scale largest |term| accumulated into `total`
+ * @return {number}
+ */
+function denoise(total, scale) {
+  return Math.abs(total) < scale * NOISE_REL ? 0 : total;
+}
+
 /**
  * @param {Sum} sum
  * @param {SimplifyFn} simplify
@@ -23,6 +36,7 @@ function simplifySum(sum, simplify) {
   // encountered unit. `100vh - 5rem - 10rem - 100px` → `-15rem` in phase 1,
   // then vh/rem/px stay separate in phase 2 (none convert to each other).
   let numTotal = 0;
+  let numScale = 0;
   /** @type {Map<string, UnitBucket>} */
   const byUnit = new Map();
   /** @type {SumTerm[]} */
@@ -43,6 +57,7 @@ function simplifySum(sum, simplify) {
     }
     if (n.type === 'Num') {
       numTotal += sign * n.value;
+      numScale = Math.max(numScale, Math.abs(n.value));
       return;
     }
     if (n.type === 'Dim') {
@@ -50,10 +65,12 @@ function simplifySum(sum, simplify) {
       const existing = byUnit.get(key);
       if (existing) {
         existing.total += sign * n.value;
+        existing.scale = Math.max(existing.scale, Math.abs(n.value));
       } else {
         byUnit.set(key, {
           unit: n.unit,
           total: sign * n.value,
+          scale: Math.abs(n.value),
           base: baseOf(n.unit),
           order: bucketOrder++,
         });
@@ -71,9 +88,9 @@ function simplifySum(sum, simplify) {
   // unconditionally is harmless. Zero-valued unit buckets are kept for
   // type info (WPT calc-serialization-002).
   /** @type {SumTerm[]} */
-  const terms = [{ sign: 1, node: num(numTotal) }];
+  const terms = [{ sign: 1, node: num(denoise(numTotal, numScale)) }];
   for (const bucket of mergeConvertibleBuckets([...byUnit.values()])) {
-    terms.push({ sign: 1, node: dim(bucket.total, bucket.unit) });
+    terms.push({ sign: 1, node: dim(denoise(bucket.total, bucket.scale), bucket.unit) });
   }
   terms.push(...opaque);
 

package/types/lib/simplify/bucket.d.ts

@@ -1,6 +1,10 @@
 export type UnitBucket = {
     unit: string;
     total: number;
+    /**
+     * largest |term| accumulated into `total`, for noise detection
+     */
+    scale: number;
     base: import("../convertUnits.js").BaseType | null;
     order: number;
 };
@@ -8,6 +12,7 @@ export type UnitBucket = {
  * @typedef {object} UnitBucket
  * @property {string} unit
  * @property {number} total
+ * @property {number} scale largest |term| accumulated into `total`, for noise detection
  * @property {import('../convertUnits.js').BaseType | null} base
  * @property {number} order
  */

package/types/lib/simplify/sum.d.ts

@@ -3,13 +3,6 @@ export type Sum = import("../node.js").Sum;
 export type SumTerm = import("../node.js").SumTerm;
 export type SimplifyFn = import("../simplify.js").SimplifyFn;
 export type UnitBucket = import("./bucket.js").UnitBucket;
-/**
- * @typedef {import('../node.js').Node} Node
- * @typedef {import('../node.js').Sum} Sum
- * @typedef {import('../node.js').SumTerm} SumTerm
- * @typedef {import('../simplify.js').SimplifyFn} SimplifyFn
- * @typedef {import('./bucket.js').UnitBucket} UnitBucket
- */
 /**
  * @param {Sum} sum
  * @param {SimplifyFn} simplify