postcss-calc 11.0.3 → 11.1.1

package/src/reduce.js

@@ -0,0 +1,176 @@
+// CSS component-value reducer. This module deliberately has no PostCSS
+// dependency so it can also be used for individual declaration values,
+// at-rule parameters, or selector text.
+import {
+  tokenize as cssTokenize,
+  TokenType as CssType,
+} from '@csstools/css-tokenizer';
+import { tokenizeTokens } from './lib/tokenizer.js';
+import { parse } from './lib/parser.js';
+import { simplify } from './lib/simplify.js';
+import {
+  isSupportedMathFunction,
+  hasPotentialMathFunction,
+  QUICK_MATH_TEST,
+} from './lib/simplify/call.js';
+import { serialize } from './lib/serialize.js';
+
+const MATCH_CALC = /^(?:-(?:moz|webkit)-)?calc$/i;
+
+const BLOCK_CLOSE = new Map([
+  [CssType.OpenParen, CssType.CloseParen],
+  [CssType.OpenSquare, CssType.CloseSquare],
+  [CssType.OpenCurly, CssType.CloseCurly],
+]);
+
+/**
+ * @typedef {object} ReduceCalcOptions
+ * @property {number | false} [precision]
+ * @property {boolean} [warnWhenCannotResolve]
+ * @property {boolean} [unwrapSingleNegativeNumber] Serialize finite negative results without a `calc()` wrapper. Defaults to `false`.
+ * @property {(error: Error, input: string) => void} [onParseError] Invoked when parse/simplify throws.
+ * @property {(message: string) => void} [onWarn] Invoked when `warnWhenCannotResolve` is set and an expression cannot be reduced to a single value.
+ */
+
+/** @typedef {Required<Omit<ReduceCalcOptions, 'onParseError' | 'onWarn'>> & Pick<ReduceCalcOptions, 'onParseError' | 'onWarn'>} ResolvedReduceCalcOptions */
+
+/**
+ * Fields threaded through the internal token-range walk.
+ *
+ * @typedef {object} TransformContext
+ * @property {ResolvedReduceCalcOptions} options
+ * @property {string} value
+ * @property {import('@csstools/css-tokenizer').CSSToken[]} tokens
+ * @property {Replacement[]} replacements
+ */
+
+/**
+ * @typedef {object} Replacement
+ * @property {number} start
+ * @property {number} end
+ * @property {import('./lib/node.js').Node} node
+ * @property {string} calcName
+ */
+
+/**
+ * Walk one component-value level. Unsupported functions and simple blocks are
+ * traversed, while a supported function is treated as one opaque calculation
+ * even when parsing it fails. A missing closer consumes through EOF, matching
+ * CSS component-value parsing's error recovery.
+ *
+ * @param {number} start
+ * @param {import('@csstools/css-tokenizer').TokenType | undefined} expectedClose
+ * @param {TransformContext} ctx
+ * @param {boolean} transform
+ * @return {number} Index of the matching closer, or the EOF token.
+ */
+function walkTokens(start, expectedClose, ctx, transform) {
+  for (let i = start; i < ctx.tokens.length; i++) {
+    const token = ctx.tokens[i];
+    if (token[0] === CssType.EOF || token[0] === expectedClose) return i;
+
+    const blockClose = BLOCK_CLOSE.get(token[0]);
+    if (blockClose) {
+      i = walkTokens(i + 1, blockClose, ctx, transform);
+      continue;
+    }
+
+    if (token[0] !== CssType.Function) continue;
+
+    const name = token[4].value;
+    const isCalc = MATCH_CALC.test(name);
+    const isMath = !isCalc && isSupportedMathFunction(name);
+    if (!transform || (!isCalc && !isMath)) {
+      i = walkTokens(i + 1, CssType.CloseParen, ctx, transform);
+      continue;
+    }
+
+    // Locate the complete outer function without transforming its children.
+    const close = walkTokens(i + 1, CssType.CloseParen, ctx, false);
+    const closed = ctx.tokens[close][0] === CssType.CloseParen;
+    const end = closed ? ctx.tokens[close][3] + 1 : ctx.value.length;
+    const sliceStart = isCalc ? i + 1 : i;
+    const sliceEnd = closed ? close + (isCalc ? 0 : 1) : close;
+    const inputStart = isCalc ? token[3] + 1 : token[2];
+    const inputEnd = closed && isCalc ? ctx.tokens[close][2] : end;
+    const contents = ctx.value.slice(inputStart, inputEnd);
+    try {
+      const node = simplify(
+        parse(tokenizeTokens(ctx.tokens, end, sliceStart, sliceEnd))
+      );
+      ctx.replacements.push({
+        start: token[2],
+        end,
+        node,
+        calcName: isCalc ? name : 'calc',
+      });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error('Error');
+      ctx.options.onParseError?.(err, contents);
+    }
+    i = close;
+  }
+
+  return ctx.tokens.length - 1;
+}
+
+/**
+ * @param {import('./lib/node.js').Node} node
+ * @return {boolean}
+ */
+function isUnresolvedResult(node) {
+  if (node.type === 'Sum' || node.type === 'Product') {
+    return true;
+  }
+  return node.type === 'Call' && isSupportedMathFunction(node.name);
+}
+
+/**
+ * Simplify every supported CSS math function in a component-value string.
+ * Text outside those functions is preserved byte-for-byte.
+ *
+ * @param {string} value
+ * @param {ReduceCalcOptions} [opts]
+ * @return {string}
+ */
+function reduceCalc(value, opts) {
+  if (!hasPotentialMathFunction(value)) {
+    return value;
+  }
+
+  /** @type {ResolvedReduceCalcOptions} */
+  const options = {
+    precision: 5,
+    warnWhenCannotResolve: false,
+    unwrapSingleNegativeNumber: false,
+    ...opts,
+  };
+  const tokens = cssTokenize({ css: value });
+  /** @type {Replacement[]} */
+  const replacements = [];
+  walkTokens(0, undefined, { options, value, tokens, replacements }, true);
+
+  if (replacements.length === 0) {
+    return value;
+  }
+
+  let output = '';
+  let lastIndex = 0;
+  for (const replacement of replacements) {
+    const text = serialize(replacement.node, {
+      precision: options.precision,
+      calcName: replacement.calcName,
+      unwrapSingleNegativeNumber: options.unwrapSingleNegativeNumber,
+    });
+    if (options.warnWhenCannotResolve && isUnresolvedResult(replacement.node)) {
+      options.onWarn?.('Could not reduce expression: ' + value);
+    }
+    output += value.slice(lastIndex, replacement.start) + text;
+    lastIndex = replacement.end;
+  }
+  output += value.slice(lastIndex);
+  return output;
+}
+
+export { QUICK_MATH_TEST, hasPotentialMathFunction };
+export default reduceCalc;

package/types/index.d.ts

@@ -9,21 +9,6 @@ export type PostCssCalcOptions = {
     onParseError?: (error: Error, input: string) => void;
 };
 export type ResolvedOptions = Required<Omit<PostCssCalcOptions, 'onParseError'>> & Pick<PostCssCalcOptions, 'onParseError'>;
-export type TransformContext = {
-    options: ResolvedOptions;
-    result: import('postcss').Result;
-    item: import('postcss').ChildNode;
-    value: string;
-    tokens: import('@csstools/css-tokenizer').CSSToken[];
-    replacements: Replacement[];
-};
-export type Replacement = {
-    start: number;
-    end: number;
-    node: import('./lib/node.js').Node;
-    calcName: string;
-    matchedName: string;
-};
 /**
  * @param {PostCssCalcOptions} [opts]
  * @return {import('postcss').Plugin}

package/types/lib/parser.d.ts

@@ -21,6 +21,22 @@ declare class Parser {
      * @return {Token}
      */
     expect(type: TokenType, value?: string): Token;
+    /**
+     * @param {string} value
+     * @param {string} [value2]
+     * @return {boolean}
+     */
+    isPunct(value: string, value2?: string): boolean;
+    /**
+     * @param {string} value
+     * @return {boolean}
+     */
+    matchPunct(value: string): boolean;
+    /**
+     * @param {string} value
+     * @return {Token}
+     */
+    expectPunct(value: string): Token;
     /**
      * @param {number} [minBp]
      * @return {Node}

package/types/lib/serialize.d.ts

@@ -11,6 +11,10 @@ export type SerializeOptions = {
      * Wrapper name to use when `calc()` is needed. Default `'calc'`.
      */
     calcName?: string;
+    /**
+     * Serialize finite negative scalars without a wrapper. Internal selector-only mode.
+     */
+    unwrapSingleNegativeNumber?: boolean;
 };
 /**
  * @param {Node} node

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

@@ -1,6 +1,16 @@
 export type Node = import('../node.js').Node;
 export type SimplifyFn = import('../simplify.js').SimplifyFn;
 export type MathSimplifier = (name: string, args: Node[]) => Node;
+declare const QUICK_MATH_TEST: RegExp;
+/**
+ * Fast check to determine whether a CSS component value could contain
+ * a supported calculation or math function call (or an escape sequence
+ * that could decode to one).
+ *
+ * @param {string} value
+ * @return {boolean}
+ */
+declare function hasPotentialMathFunction(value: string): boolean;
 /**
  * Whether a bare CSS math function has an implemented simplifier.
  *
@@ -16,4 +26,4 @@ declare function isSupportedMathFunction(name: string): boolean;
 declare function simplifyCall(node: Extract<Node, {
     type: 'Call';
 }>, simplify: SimplifyFn): Node;
-export { isSupportedMathFunction, simplifyCall };
+export { isSupportedMathFunction, simplifyCall, hasPotentialMathFunction, QUICK_MATH_TEST, };

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

@@ -1,7 +1,20 @@
 export type Node = import('../node.js').Node;
+export type Num = import('../node.js').Num;
+export type Dim = import('../node.js').Dim;
 export type BaseType = import('../convertUnits.js').BaseType;
 /** @typedef {import('../node.js').Node} Node */
+/** @typedef {import('../node.js').Num} Num */
+/** @typedef {import('../node.js').Dim} Dim */
 /** @typedef {import('../convertUnits.js').BaseType} BaseType */
+/**
+ * Construct a Num or Dim node from a folded result.
+ * @param {{ unit: string }} fold
+ * @param {number} value
+ * @return {Num | Dim}
+ */
+declare function foldResult(fold: {
+    unit: string;
+}, value: number): Num | Dim;
 /**
  * @param {Node[]} args
  * @return {{ values: number[], unit: string } | null}
@@ -10,4 +23,4 @@ declare function foldConstArgs(args: Node[]): {
     values: number[];
     unit: string;
 } | null;
-export { foldConstArgs };
+export { foldConstArgs, foldResult };

package/types/lib/tokenizer.d.ts

@@ -24,7 +24,9 @@ declare function tokenize(input: string): Token[];
  *
  * @param {import('@csstools/css-tokenizer').CSSToken[]} cssTokens
  * @param {number} eofPosition
+ * @param {number} [start]
+ * @param {number} [end]
  * @return {Token[]}
  */
-declare function tokenizeTokens(cssTokens: import('@csstools/css-tokenizer').CSSToken[], eofPosition: number): Token[];
+declare function tokenizeTokens(cssTokens: import('@csstools/css-tokenizer').CSSToken[], eofPosition: number, start?: number, end?: number): Token[];
 export { tokenize, tokenizeTokens };

package/types/reduce.d.ts

@@ -0,0 +1,41 @@
+import { hasPotentialMathFunction, QUICK_MATH_TEST } from './lib/simplify/call.js';
+export type ReduceCalcOptions = {
+    precision?: number | false;
+    warnWhenCannotResolve?: boolean;
+    /**
+     * Serialize finite negative results without a `calc()` wrapper. Defaults to `false`.
+     */
+    unwrapSingleNegativeNumber?: boolean;
+    /**
+     * Invoked when parse/simplify throws.
+     */
+    onParseError?: (error: Error, input: string) => void;
+    /**
+     * Invoked when `warnWhenCannotResolve` is set and an expression cannot be reduced to a single value.
+     */
+    onWarn?: (message: string) => void;
+};
+export type ResolvedReduceCalcOptions = Required<Omit<ReduceCalcOptions, 'onParseError' | 'onWarn'>> & Pick<ReduceCalcOptions, 'onParseError' | 'onWarn'>;
+export type TransformContext = {
+    options: ResolvedReduceCalcOptions;
+    value: string;
+    tokens: import('@csstools/css-tokenizer').CSSToken[];
+    replacements: Replacement[];
+};
+export type Replacement = {
+    start: number;
+    end: number;
+    node: import('./lib/node.js').Node;
+    calcName: string;
+};
+/**
+ * Simplify every supported CSS math function in a component-value string.
+ * Text outside those functions is preserved byte-for-byte.
+ *
+ * @param {string} value
+ * @param {ReduceCalcOptions} [opts]
+ * @return {string}
+ */
+declare function reduceCalc(value: string, opts?: ReduceCalcOptions): string;
+export { QUICK_MATH_TEST, hasPotentialMathFunction };
+export default reduceCalc;

package/types/lib/type.d.ts

@@ -1,23 +0,0 @@
-export type BaseType =
-  | 'length'
-  | 'angle'
-  | 'time'
-  | 'frequency'
-  | 'resolution'
-  | 'flex'
-  | 'percentage';
-/**
- * @param {string} unit
- * @return {BaseType | null}
- */
-export function baseOf(unit: string): BaseType | null;
-/**
- * Convert a value within a single conversion family. Returns null when
- * either unit is missing from the table (em/rem/vw need runtime context)
- * or when the units belong to different base types.
- * @param {number} value
- * @param {string} from
- * @param {string} to
- * @return {number | null}
- */
-export function convert(value: number, from: string, to: string): number | null;