postcss-calc 11.1.1 → 11.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "11.1.1",
+  "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/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,
+};