1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
'use strict';
const order = {
'*': 0,
'/': 0,
'+': 1,
'-': 1,
};
/**
* @param {number} value
* @param {number | false} prec
*/
function round(value, prec) {
if (prec !== false) {
const precision = Math.pow(10, prec);
return Math.round(value * precision) / precision;
}
return value;
}
/**
* @param {number | false} prec
* @param {import('../parser').CalcNode} node
*
* @return {string}
*/
function stringify(node, prec) {
switch (node.type) {
case 'MathExpression': {
const { left, right, operator: op } = node;
let str = '';
if (left.type === 'MathExpression' && order[op] < order[left.operator]) {
str += `(${stringify(left, prec)})`;
} else {
str += stringify(left, prec);
}
str += order[op] ? ` ${node.operator} ` : node.operator;
if (
right.type === 'MathExpression' &&
order[op] < order[right.operator]
) {
str += `(${stringify(right, prec)})`;
} else {
str += stringify(right, prec);
}
return str;
}
case 'Number':
return round(node.value, prec).toString();
case 'Function':
return node.value.toString();
case 'ParenthesizedExpression':
return `(${stringify(node.content, prec)})`;
default:
return round(node.value, prec) + node.unit;
}
}
/**
* @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}
*/
module.exports = function (calc, node, originalValue, options, result, item) {
let str = stringify(node, options.precision);
const shouldPrintCalc =
node.type === 'MathExpression' || node.type === 'Function' ||
node.type === 'ParenthesizedExpression';
if (shouldPrintCalc) {
// if calc expression couldn't be resolved to a single value, re-wrap it as
// a calc()
if (node.type === 'ParenthesizedExpression') {
str = `${calc}${str}`;
} else {
str = `${calc}(${str})`;
}
// if the warnWhenCannotResolve option is on, inform the user that the calc
// expression could not be resolved to a single value
if (options.warnWhenCannotResolve) {
result.warn('Could not reduce expression: ' + originalValue, {
plugin: 'postcss-calc',
node: item,
});
}
}
return str;
};
|
