postcss-calc 11.1.0 → 11.1.2

package/README.md

@@ -68,7 +68,8 @@ reduceCalc('min(50px, calc(2 * 40px))');
 // => '50px'
 ```
 
-It accepts `precision`, `warnWhenCannotResolve`, `onParseError`, and `onWarn`:
+It accepts `precision`, `unwrapSingleNegativeNumber`, `warnWhenCannotResolve`, `onParseError`,
+and `onWarn`:
 
 ```js
 const result = reduceCalc('calc(100% + var(--gap))', {
@@ -84,7 +85,30 @@ const result = reduceCalc('calc(100% + var(--gap))', {
 Unlike the PostCSS plugin, the standalone reducer does not show warnings
 by default; provide `onParseError` and/or `onWarn` if you want diagnostics.
 
-### Options
+### Standalone reducer options
+
+#### `unwrapSingleNegativeNumber` (default: `false`)
+
+Controls whether a finite negative result is serialized as a bare value or
+wrapped in `calc()`. Keep the default when reducing declaration values; set it
+to `true` when the surrounding CSS context requires a bare negative value, such
+as a selector:
+
+```js
+reduceCalc('calc(5px - 10px)');
+// => 'calc(-5px)'
+
+reduceCalc('calc(5px - 10px)', { unwrapNegativeNumbers: true });
+// => '-5px'
+```
+
+### PostCSS plugin options
+
+These options apply when using the PostCSS plugin:
+
+```js
+postcss().use(calc({ precision: 10 }));
+```
 
 #### `precision` (default: `5`)
 
@@ -139,7 +163,11 @@ With `mediaQueries: true`, this becomes:
 
 #### `selectors` (default: `false`)
 
-Allows calc() usage as part of selectors.
+Reduces `calc()` functions found in selectors. Selectors do not accept
+`calc()` functions, so the plugin replaces them with their reduced values.
+Finite negative results are serialized as bare values because a selector cannot
+contain a `calc()` function; the plugin enables `unwrapSingleNegativeNumber` automatically
+for selectors.
 
 ```js
 var out = postcss()
@@ -163,11 +191,13 @@ Callback invoked when a `calc()` body fails to parse or simplify. Matches
 [`@csstools/css-calc`][csstools-css-calc]'s shape:
 
 ```js
-calc({
-  onParseError: (err, input) => {
-    throw err; // or log, route to a different channel, etc.
-  },
-});
+postcss().use(
+  calc({
+    onParseError: (err, input) => {
+      throw err; // or log, route to a different channel, etc.
+    },
+  })
+);
 ```
 
 When omitted, errors are reported via PostCSS `result.warn()` so the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "11.1.0",
+  "version": "11.1.2",
   "type": "module",
   "description": "PostCSS plugin to reduce calc()",
   "keywords": [
@@ -38,16 +38,16 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "11.25.0"
+      "version": "12.3.4"
     }
   },
   "devDependencies": {
     "@csstools/css-calc": "^3.3.0",
     "@rmenke/css-tokenizer-tests": "^1.2.0",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.5.0",
     "fast-check": "^4.9.0",
-    "oxfmt": "^0.66.0",
-    "oxlint": "^1.81.0",
+    "oxfmt": "^0.67.0",
+    "oxlint": "^1.82.0",
     "postcss": "^8.5.28",
     "typescript": "~7.0.2"
   },
@@ -61,6 +61,7 @@
     "lint": "oxlint . && tsc && oxfmt --check",
     "fmt": "oxfmt",
     "benchmark:arithmetic-chains": "node scripts/benchmark-arithmetic-chains.mjs",
+    "benchmark:nested-fallbacks": "node scripts/benchmark-nested-fallbacks.mjs",
     "test": "node --test --test-reporter=dot 'test/**/*.test.mjs' test/index.cjs test/convertUnit.cjs",
     "test:mutation:corpus": "node test/mutation/corpus-selection.mjs",
     "test:corpus:full": "POSTCSS_CALC_FULL_CORPUS=1 node --test test/conformance/corpus.test.mjs"

package/src/index.js

@@ -24,9 +24,17 @@ import reduceCalc, { hasPotentialMathFunction } from './reduce.js';
  * @param {(target: import('postcss').ChildNode, value: string) => void} setProp
  * @param {ResolvedOptions} options
  * @param {import('postcss').Result} result
+ * @param {boolean} unwrapSingleNegativeNumber
  * @return {void}
  */
-function applyTransform(node, current, setProp, options, result) {
+function applyTransform(
+  node,
+  current,
+  setProp,
+  options,
+  result,
+  unwrapSingleNegativeNumber
+) {
   if (!hasPotentialMathFunction(current)) {
     return;
   }
@@ -41,6 +49,7 @@ function applyTransform(node, current, setProp, options, result) {
     onWarn: (message) => {
       result.warn(message, { plugin: 'postcss-calc', node });
     },
+    unwrapSingleNegativeNumber,
   });
   if (transformed !== current) {
     setProp(node, transformed);
@@ -77,7 +86,8 @@ function pluginCreator(opts) {
               /** @type {import('postcss').Declaration} */ (n).value = v;
             },
             options,
-            result
+            result,
+            false
           );
         }
         if (node.type === 'atrule' && options.mediaQueries) {
@@ -88,7 +98,8 @@ function pluginCreator(opts) {
               /** @type {import('postcss').AtRule} */ (n).params = v;
             },
             options,
-            result
+            result,
+            false
           );
         }
         if (node.type === 'rule' && options.selectors) {
@@ -101,7 +112,8 @@ function pluginCreator(opts) {
               /** @type {import('postcss').Rule} */ (n).selector = v;
             },
             options,
-            result
+            result,
+            true
           );
         }
       });

package/src/lib/convertUnits.js

@@ -139,4 +139,18 @@ function convert(value, from, to) {
   return (value * f) / t;
 }
 
-export { baseOf, convert };
+/**
+ * Return a base type only for units present in the static conversion table.
+ * Units with context-dependent values (em, rem, vw, etc.) return null.
+ * @param {string} unit
+ * @return {BaseType | null}
+ */
+function staticBaseOf(unit) {
+  const key = unit.toLowerCase();
+  if (TO_CANONICAL[key] === undefined) {
+    return null;
+  }
+  return UNIT_TO_BASE[key] ?? null;
+}
+
+export { baseOf, staticBaseOf, convert };

package/src/lib/node.js

@@ -16,9 +16,9 @@
 
 /**
  * @typedef {{type: 'Num', value: number}} Num
- * @typedef {{type: 'Dim', value: number, unit: string}} Dim
- * @typedef {{type: 'Ident', name: string}} Ident
- * @typedef {{type: 'Call', name: string, args: Node[]}} Call
+ * @typedef {{type: 'Dim', value: number, unit: string, rawUnit?: string}} Dim
+ * @typedef {{type: 'Ident', name: string, rawName?: string}} Ident
+ * @typedef {{type: 'Call', name: string, args: Node[], rawName?: string}} Call
  * @typedef {{sign: 1 | -1, node: Node}} SumTerm Sign is always +1 when node is Num or Dim.
  * @typedef {{type: 'Sum', terms: SumTerm[], grouped?: boolean}} Sum
  * @typedef {{exponent: 1 | -1, node: Node}} ProductFactor exponent +1 = numerator, -1 = denominator.
@@ -37,27 +37,36 @@ function num(value) {
 /**
  * @param {number} value
  * @param {string} unit
+ * @param {string} [rawUnit]
  * @return {Dim}
  */
-function dim(value, unit) {
-  return { type: 'Dim', value, unit };
+function dim(value, unit, rawUnit) {
+  return rawUnit === undefined
+    ? { type: 'Dim', value, unit }
+    : { type: 'Dim', value, unit, rawUnit };
 }
 
 /**
  * @param {string} name
+ * @param {string} [rawName]
  * @return {Ident}
  */
-function ident(name) {
-  return { type: 'Ident', name };
+function ident(name, rawName) {
+  return rawName === undefined
+    ? { type: 'Ident', name }
+    : { type: 'Ident', name, rawName };
 }
 
 /**
  * @param {string} name
  * @param {Node[]} args
+ * @param {string} [rawName]
  * @return {Call}
  */
-function call(name, args) {
-  return { type: 'Call', name, args };
+function call(name, args, rawName) {
+  return rawName === undefined
+    ? { type: 'Call', name, args }
+    : { type: 'Call', name, args, rawName };
 }
 
 /**
@@ -99,14 +108,9 @@ function pushSumTerm(out, term) {
 
   // sign=-1 around a Num/Dim leaf collapses into the value's sign — the
   // canonical-form rule downstream code relies on.
-  if (sign === -1) {
-    if (node.type === 'Num') {
-      node = num(-node.value);
-      sign = 1;
-    } else if (node.type === 'Dim') {
-      node = dim(-node.value, node.unit);
-      sign = 1;
-    }
+  if (sign === -1 && (node.type === 'Num' || node.type === 'Dim')) {
+    node = negate(node);
+    sign = 1;
   }
 
   // Drop zero-valued Nums. Dims with value 0 stay — the unit carries type.
@@ -169,7 +173,7 @@ function negate(node) {
     return num(-node.value);
   }
   if (node.type === 'Dim') {
-    return dim(-node.value, node.unit);
+    return dim(-node.value, node.unit, node.rawUnit);
   }
   if (node.type === 'Sum') {
     const result = mkSum(

package/src/lib/opaque.js

@@ -0,0 +1,40 @@
+// Private metadata for opaque function contents (including var() fallbacks).
+// Keeping it in a WeakMap means the public calculation AST remains unchanged.
+/** @typedef {import('./node.js').Node} Node */
+/** @typedef {string | Node | Component[]} Component */
+/** @type {WeakMap<Extract<Node, {type: 'Call'}>, Component[]>} */
+const components = new WeakMap();
+/** @param {Extract<Node, {type: 'Call'}>} node @param {Component[]} tree */
+function setComponents(node, tree) {
+  components.set(node, tree);
+  return node;
+}
+/** @param {Extract<Node, {type: 'Call'}>} node */
+function getComponents(node) {
+  return components.get(node);
+}
+/** @param {Component[]} tree @param {(node: Node) => Node} simplify @return {Component[]} */
+function simplifyComponents(tree, simplify) {
+  return tree.map((part) => {
+    if (typeof part === 'string') return part;
+    if (Array.isArray(part)) return simplifyComponents(part, simplify);
+    return simplify(part);
+  });
+}
+/** @param {Component[]} tree @param {(node: Node) => string} serialize @return {string} */
+function serializeComponents(tree, serialize) {
+  let result = '';
+  for (const part of tree) {
+    if (typeof part === 'string') result += part;
+    else if (Array.isArray(part))
+      result += serializeComponents(part, serialize);
+    else result += serialize(part);
+  }
+  return result;
+}
+export {
+  getComponents,
+  setComponents,
+  simplifyComponents,
+  serializeComponents,
+};