postcss-calc 8.2.3 → 9.0.0

package/src/lib/transform.js

@@ -0,0 +1,109 @@
+'use strict';
+const selectorParser = require('postcss-selector-parser');
+const valueParser = require('postcss-value-parser');
+
+const { parser } = require('../parser.js');
+
+const reducer = require('./reducer.js');
+const stringifier = require('./stringifier.js');
+
+const MATCH_CALC = /((?:-(moz|webkit)-)?calc)/i;
+
+/**
+ * @param {string} value
+ * @param {{precision: number, warnWhenCannotResolve: boolean}} options
+ * @param {import("postcss").Result} result
+ * @param {import("postcss").ChildNode} item
+ */
+function transformValue(value, options, result, item) {
+  return valueParser(value)
+    .walk((node) => {
+      // skip anything which isn't a calc() function
+      if (node.type !== 'function' || !MATCH_CALC.test(node.value)) {
+        return;
+      }
+
+      // stringify calc expression and produce an AST
+      const contents = valueParser.stringify(node.nodes);
+      const ast = parser.parse(contents);
+
+      // reduce AST to its simplest form, that is, either to a single value
+      // or a simplified calc expression
+      const reducedAst = reducer(ast, options.precision);
+
+      // stringify AST and write it back
+      /** @type {valueParser.Node} */ (node).type = 'word';
+      node.value = stringifier(
+        node.value,
+        reducedAst,
+        value,
+        options,
+        result,
+        item
+      );
+
+      return false;
+    })
+    .toString();
+}
+/**
+ * @param {import("postcss-selector-parser").Selectors} value
+ * @param {{precision: number, warnWhenCannotResolve: boolean}} options
+ * @param {import("postcss").Result} result
+ * @param {import("postcss").ChildNode} item
+ */
+function transformSelector(value, options, result, item) {
+  return selectorParser((selectors) => {
+    selectors.walk((node) => {
+      // attribute value
+      // e.g. the "calc(3*3)" part of "div[data-size="calc(3*3)"]"
+      if (node.type === 'attribute' && node.value) {
+        node.setValue(transformValue(node.value, options, result, item));
+      }
+
+      // tag value
+      // e.g. the "calc(3*3)" part of "div:nth-child(2n + calc(3*3))"
+      if (node.type === 'tag') {
+        node.value = transformValue(node.value, options, result, item);
+      }
+
+      return;
+    });
+  }).processSync(value);
+}
+
+/**
+ * @param {any} node
+ * @param {{precision: number, preserve: boolean, warnWhenCannotResolve: boolean}} options
+ * @param {'value'|'params'|'selector'} property
+ * @param {import("postcss").Result} result
+ */
+module.exports = (node, property, options, result) => {
+  let value = node[property];
+
+  try {
+    value =
+      property === 'selector'
+        ? transformSelector(node[property], options, result, node)
+        : transformValue(node[property], options, result, node);
+  } catch (error) {
+    if (error instanceof Error) {
+      result.warn(error.message, { node });
+    } else {
+      result.warn('Error', { node });
+    }
+    return;
+  }
+
+  // if the preserve option is enabled and the value has changed, write the
+  // transformed value into a cloned node which is inserted before the current
+  // node, preserving the original value. Otherwise, overwrite the original
+  // value.
+  if (options.preserve && node[property] !== value) {
+    const clone = node.clone();
+    clone[property] = value;
+    node.parent.insertBefore(node, clone);
+  } else {
+    node[property] = value;
+  }
+};

package/src/parser.d.ts

@@ -0,0 +1,51 @@
+export interface MathExpression {
+  type: 'MathExpression';
+  right: CalcNode;
+  left: CalcNode;
+  operator: '*' | '+' | '-' | '/';
+}
+
+export interface ParenthesizedExpression {
+  type: 'ParenthesizedExpression';
+  content: CalcNode;
+}
+
+export interface DimensionExpression {
+  type:
+    | 'LengthValue'
+    | 'AngleValue'
+    | 'TimeValue'
+    | 'FrequencyValue'
+    | 'PercentageValue'
+    | 'ResolutionValue'
+    | 'EmValue'
+    | 'ExValue'
+    | 'ChValue'
+    | 'RemValue'
+    | 'VhValue'
+    | 'VwValue'
+    | 'VminValue'
+    | 'VmaxValue';
+  value: number;
+  unit: string;
+}
+
+export interface NumberExpression {
+  type: 'Number';
+  value: number;
+}
+
+export interface FunctionExpression {
+  type: 'Function';
+  value: string;
+}
+
+export type ValueExpression = DimensionExpression | NumberExpression;
+
+export type CalcNode = MathExpression | ValueExpression | FunctionExpression | ParenthesizedExpression;
+
+export interface Parser {
+  parse: (arg: string) => CalcNode;
+}
+
+export const parser: Parser;

package/types/index.d.ts

@@ -1,11 +1,4 @@
-export default pluginCreator;
-export type PostCssCalcOptions = {
-    precision?: number | false;
-    preserve?: boolean;
-    warnWhenCannotResolve?: boolean;
-    mediaQueries?: boolean;
-    selectors?: boolean;
-};
+export = pluginCreator;
 /**
  * @typedef {{precision?: number | false,
  *          preserve?: boolean,
@@ -14,11 +7,19 @@ export type PostCssCalcOptions = {
  *          selectors?: boolean}} PostCssCalcOptions
  */
 /**
-* @type {import('postcss').PluginCreator<PostCssCalcOptions>}
-* @param {PostCssCalcOptions} opts
-* @return {import('postcss').Plugin}
-*/
+ * @type {import('postcss').PluginCreator<PostCssCalcOptions>}
+ * @param {PostCssCalcOptions} opts
+ * @return {import('postcss').Plugin}
+ */
 declare function pluginCreator(opts: PostCssCalcOptions): import('postcss').Plugin;
 declare namespace pluginCreator {
-    const postcss: true;
+    export { postcss, PostCssCalcOptions };
 }
+type PostCssCalcOptions = {
+    precision?: number | false;
+    preserve?: boolean;
+    warnWhenCannotResolve?: boolean;
+    mediaQueries?: boolean;
+    selectors?: boolean;
+};
+declare var postcss: true;

package/types/lib/convertUnit.d.ts

@@ -1,4 +1,4 @@
-export default convertUnit;
+export = convertUnit;
 /**
  * @param {number} value
  * @param {string} sourceUnit

package/types/lib/reducer.d.ts

@@ -1,11 +1,14 @@
-export default reduce;
-export type Collectible = {
-    preOperator: '+' | '-';
-    node: import('../parser').CalcNode;
-};
+export = reduce;
 /**
  * @param {import('../parser').CalcNode} node
  * @param {number} precision
  * @return {import('../parser').CalcNode}
  */
 declare function reduce(node: import('../parser').CalcNode, precision: number): import('../parser').CalcNode;
+declare namespace reduce {
+    export { Collectible };
+}
+type Collectible = {
+    preOperator: '+' | '-';
+    node: import('../parser').CalcNode;
+};

package/types/lib/stringifier.d.ts

@@ -1,14 +1,5 @@
-/**
- * @param {string} calc
- * @param {import('../parser').CalcNode} node
- * @param {string} originalValue
- * @param {{precision: number | false, warnWhenCannotResolve: boolean}} options
- * @param {import("postcss").Result} result
- * @param {import("postcss").ChildNode} item
- *
- * @returns {string}
- */
-export default function _default(calc: string, node: import('../parser').CalcNode, originalValue: string, options: {
+declare function _exports(calc: string, node: import('../parser').CalcNode, originalValue: string, options: {
     precision: number | false;
     warnWhenCannotResolve: boolean;
 }, result: import("postcss").Result, item: import("postcss").ChildNode): string;
+export = _exports;

package/types/lib/transform.d.ts

@@ -1,6 +1,6 @@
-declare function _default(node: any, property: 'value' | 'params' | 'selector', options: {
+declare function _exports(node: any, property: 'value' | 'params' | 'selector', options: {
     precision: number;
     preserve: boolean;
     warnWhenCannotResolve: boolean;
 }, result: import("postcss").Result): void;
-export default _default;
+export = _exports;

package/dist/index.js

@@ -1,64 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _transform = _interopRequireDefault(require("./lib/transform"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * @typedef {{precision?: number | false,
- *          preserve?: boolean, 
- *          warnWhenCannotResolve?: boolean, 
- *          mediaQueries?: boolean, 
- *          selectors?: boolean}} PostCssCalcOptions
- */
-
-/**
-* @type {import('postcss').PluginCreator<PostCssCalcOptions>}
-* @param {PostCssCalcOptions} opts
-* @return {import('postcss').Plugin}
-*/
-function pluginCreator(opts) {
-  const options = Object.assign({
-    precision: 5,
-    preserve: false,
-    warnWhenCannotResolve: false,
-    mediaQueries: false,
-    selectors: false
-  }, opts);
-  return {
-    postcssPlugin: 'postcss-calc',
-
-    OnceExit(css, {
-      result
-    }) {
-      css.walk(node => {
-        const {
-          type
-        } = node;
-
-        if (type === 'decl') {
-          (0, _transform.default)(node, "value", options, result);
-        }
-
-        if (type === 'atrule' && options.mediaQueries) {
-          (0, _transform.default)(node, "params", options, result);
-        }
-
-        if (type === 'rule' && options.selectors) {
-          (0, _transform.default)(node, "selector", options, result);
-        }
-      });
-    }
-
-  };
-}
-
-pluginCreator.postcss = true;
-var _default = pluginCreator;
-exports.default = _default;
-module.exports = exports.default;

package/dist/lib/convertUnit.js

@@ -1,167 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-/**
- * @type {{[key:string]: {[key:string]: number}}}
- */
-const conversions = {
-  // Absolute length units
-  'px': {
-    'px': 1,
-    'cm': 96 / 2.54,
-    'mm': 96 / 25.4,
-    'q': 96 / 101.6,
-    'in': 96,
-    'pt': 96 / 72,
-    'pc': 16
-  },
-  'cm': {
-    'px': 2.54 / 96,
-    'cm': 1,
-    'mm': 0.1,
-    'q': 0.025,
-    'in': 2.54,
-    'pt': 2.54 / 72,
-    'pc': 2.54 / 6
-  },
-  'mm': {
-    'px': 25.4 / 96,
-    'cm': 10,
-    'mm': 1,
-    'q': 0.25,
-    'in': 25.4,
-    'pt': 25.4 / 72,
-    'pc': 25.4 / 6
-  },
-  'q': {
-    'px': 101.6 / 96,
-    'cm': 40,
-    'mm': 4,
-    'q': 1,
-    'in': 101.6,
-    'pt': 101.6 / 72,
-    'pc': 101.6 / 6
-  },
-  'in': {
-    'px': 1 / 96,
-    'cm': 1 / 2.54,
-    'mm': 1 / 25.4,
-    'q': 1 / 101.6,
-    'in': 1,
-    'pt': 1 / 72,
-    'pc': 1 / 6
-  },
-  'pt': {
-    'px': 0.75,
-    'cm': 72 / 2.54,
-    'mm': 72 / 25.4,
-    'q': 72 / 101.6,
-    'in': 72,
-    'pt': 1,
-    'pc': 12
-  },
-  'pc': {
-    'px': 0.0625,
-    'cm': 6 / 2.54,
-    'mm': 6 / 25.4,
-    'q': 6 / 101.6,
-    'in': 6,
-    'pt': 6 / 72,
-    'pc': 1
-  },
-  // Angle units
-  'deg': {
-    'deg': 1,
-    'grad': 0.9,
-    'rad': 180 / Math.PI,
-    'turn': 360
-  },
-  'grad': {
-    'deg': 400 / 360,
-    'grad': 1,
-    'rad': 200 / Math.PI,
-    'turn': 400
-  },
-  'rad': {
-    'deg': Math.PI / 180,
-    'grad': Math.PI / 200,
-    'rad': 1,
-    'turn': Math.PI * 2
-  },
-  'turn': {
-    'deg': 1 / 360,
-    'grad': 0.0025,
-    'rad': 0.5 / Math.PI,
-    'turn': 1
-  },
-  // Duration units
-  's': {
-    's': 1,
-    'ms': 0.001
-  },
-  'ms': {
-    's': 1000,
-    'ms': 1
-  },
-  // Frequency units
-  'hz': {
-    'hz': 1,
-    'khz': 1000
-  },
-  'khz': {
-    'hz': 0.001,
-    'khz': 1
-  },
-  // Resolution units
-  'dpi': {
-    'dpi': 1,
-    'dpcm': 1 / 2.54,
-    'dppx': 1 / 96
-  },
-  'dpcm': {
-    'dpi': 2.54,
-    'dpcm': 1,
-    'dppx': 2.54 / 96
-  },
-  'dppx': {
-    'dpi': 96,
-    'dpcm': 96 / 2.54,
-    'dppx': 1
-  }
-};
-/**
- * @param {number} value
- * @param {string} sourceUnit
- * @param {string} targetUnit
- * @param {number|false} precision 
- */
-
-function convertUnit(value, sourceUnit, targetUnit, precision) {
-  const sourceUnitNormalized = sourceUnit.toLowerCase();
-  const targetUnitNormalized = targetUnit.toLowerCase();
-
-  if (!conversions[targetUnitNormalized]) {
-    throw new Error("Cannot convert to " + targetUnit);
-  }
-
-  if (!conversions[targetUnitNormalized][sourceUnitNormalized]) {
-    throw new Error("Cannot convert from " + sourceUnit + " to " + targetUnit);
-  }
-
-  const converted = conversions[targetUnitNormalized][sourceUnitNormalized] * value;
-
-  if (precision !== false) {
-    precision = Math.pow(10, Math.ceil(precision) || 5);
-    return Math.round(converted * precision) / precision;
-  }
-
-  return converted;
-}
-
-var _default = convertUnit;
-exports.default = _default;
-module.exports = exports.default;

package/dist/lib/transform.js

@@ -1,119 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-
-var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
-
-var _parser = require("../parser");
-
-var _reducer = _interopRequireDefault(require("./reducer"));
-
-var _stringifier = _interopRequireDefault(require("./stringifier"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// eslint-disable-next-line import/no-unresolved
-const MATCH_CALC = /((?:-(moz|webkit)-)?calc)/i;
-/**
- * @param {string} value
- * @param {{precision: number, warnWhenCannotResolve: boolean}} options
- * @param {import("postcss").Result} result
- * @param {import("postcss").ChildNode} item
- */
-
-function transformValue(value, options, result, item) {
-  return (0, _postcssValueParser.default)(value).walk(node => {
-    // skip anything which isn't a calc() function
-    if (node.type !== "function" || !MATCH_CALC.test(node.value)) {
-      return;
-    } // stringify calc expression and produce an AST
-
-
-    const contents = _postcssValueParser.default.stringify(node.nodes);
-
-    const ast = _parser.parser.parse(contents); // reduce AST to its simplest form, that is, either to a single value
-    // or a simplified calc expression
-
-
-    const reducedAst = (0, _reducer.default)(ast, options.precision); // stringify AST and write it back
-
-    /** @type {valueParser.Node} */
-    node.type = "word";
-    node.value = (0, _stringifier.default)(node.value, reducedAst, value, options, result, item);
-    return false;
-  }).toString();
-}
-/**
- * @param {import("postcss-selector-parser").Selectors} value
- * @param {{precision: number, warnWhenCannotResolve: boolean}} options
- * @param {import("postcss").Result} result
- * @param {import("postcss").ChildNode} item
- */
-
-
-function transformSelector(value, options, result, item) {
-  return (0, _postcssSelectorParser.default)(selectors => {
-    selectors.walk(node => {
-      // attribute value
-      // e.g. the "calc(3*3)" part of "div[data-size="calc(3*3)"]"
-      if (node.type === "attribute" && node.value) {
-        node.setValue(transformValue(node.value, options, result, item));
-      } // tag value
-      // e.g. the "calc(3*3)" part of "div:nth-child(2n + calc(3*3))"
-
-
-      if (node.type === "tag") {
-        node.value = transformValue(node.value, options, result, item);
-      }
-
-      return;
-    });
-  }).processSync(value);
-}
-/** 
- * @param {any} node
- * @param {{precision: number, preserve: boolean, warnWhenCannotResolve: boolean}} options
- * @param {'value'|'params'|'selector'} property
- * @param {import("postcss").Result} result
- */
-
-
-var _default = (node, property, options, result) => {
-  let value = node[property];
-
-  try {
-    value = property === "selector" ? transformSelector(node[property], options, result, node) : transformValue(node[property], options, result, node);
-  } catch (error) {
-    if (error instanceof Error) {
-      result.warn(error.message, {
-        node
-      });
-    } else {
-      result.warn('Error', {
-        node
-      });
-    }
-
-    return;
-  } // if the preserve option is enabled and the value has changed, write the
-  // transformed value into a cloned node which is inserted before the current
-  // node, preserving the original value. Otherwise, overwrite the original
-  // value.
-
-
-  if (options.preserve && node[property] !== value) {
-    const clone = node.clone();
-    clone[property] = value;
-    node.parent.insertBefore(node, clone);
-  } else {
-    node[property] = value;
-  }
-};
-
-exports.default = _default;
-module.exports = exports.default;