forked from daren.hsu/line_push
update
This commit is contained in:
+196
-203
@@ -9,10 +9,6 @@ var _convertUnit = _interopRequireDefault(require("./convertUnit"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
function isEqual(left, right) {
|
||||
return left.type === right.type && left.value === right.value;
|
||||
}
|
||||
|
||||
function isValueType(type) {
|
||||
switch (type) {
|
||||
case 'LengthValue':
|
||||
@@ -40,178 +36,132 @@ function flip(operator) {
|
||||
return operator === '+' ? '-' : '+';
|
||||
}
|
||||
|
||||
function flipValue(node) {
|
||||
if (isValueType(node.type)) {
|
||||
node.value = -node.value;
|
||||
} else if (node.type === 'MathExpression') {
|
||||
if (node.operator === '*' || node.operator === '/') {
|
||||
node.left = flipValue(node.left);
|
||||
} else {
|
||||
node.left = flipValue(node.left);
|
||||
node.right = flipValue(node.right);
|
||||
}
|
||||
function isAddSubOperator(operator) {
|
||||
return operator === '+' || operator === '-';
|
||||
}
|
||||
|
||||
function collectAddSubItems(preOperator, node, collected, precision) {
|
||||
if (!isAddSubOperator(preOperator)) {
|
||||
throw new Error(`invalid operator ${preOperator}`);
|
||||
}
|
||||
|
||||
return node;
|
||||
var type = node.type;
|
||||
|
||||
if (isValueType(type)) {
|
||||
var itemIndex = collected.findIndex(function (x) {
|
||||
return x.node.type === type;
|
||||
});
|
||||
|
||||
if (itemIndex >= 0) {
|
||||
if (node.value === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
var _covertNodesUnits = covertNodesUnits(collected[itemIndex].node, node, precision),
|
||||
reducedNode = _covertNodesUnits.left,
|
||||
current = _covertNodesUnits.right;
|
||||
|
||||
if (collected[itemIndex].preOperator === '-') {
|
||||
collected[itemIndex].preOperator = '+';
|
||||
reducedNode.value *= -1;
|
||||
}
|
||||
|
||||
if (preOperator === "+") {
|
||||
reducedNode.value += current.value;
|
||||
} else {
|
||||
reducedNode.value -= current.value;
|
||||
} // make sure reducedNode.value >= 0
|
||||
|
||||
|
||||
if (reducedNode.value >= 0) {
|
||||
collected[itemIndex] = {
|
||||
node: reducedNode,
|
||||
preOperator: '+'
|
||||
};
|
||||
} else {
|
||||
reducedNode.value *= -1;
|
||||
collected[itemIndex] = {
|
||||
node: reducedNode,
|
||||
preOperator: '-'
|
||||
};
|
||||
}
|
||||
} else {
|
||||
// make sure node.value >= 0
|
||||
if (node.value >= 0) {
|
||||
collected.push({
|
||||
node,
|
||||
preOperator
|
||||
});
|
||||
} else {
|
||||
node.value *= -1;
|
||||
collected.push({
|
||||
node,
|
||||
preOperator: flip(preOperator)
|
||||
});
|
||||
}
|
||||
}
|
||||
} else if (type === "MathExpression") {
|
||||
if (isAddSubOperator(node.operator)) {
|
||||
collectAddSubItems(preOperator, node.left, collected, precision);
|
||||
var collectRightOperator = preOperator === '-' ? flip(node.operator) : node.operator;
|
||||
collectAddSubItems(collectRightOperator, node.right, collected, precision);
|
||||
} else {
|
||||
// * or /
|
||||
var _reducedNode = reduce(node, precision); // prevent infinite recursive call
|
||||
|
||||
|
||||
if (_reducedNode.type !== "MathExpression" || isAddSubOperator(_reducedNode.operator)) {
|
||||
collectAddSubItems(preOperator, _reducedNode, collected, precision);
|
||||
} else {
|
||||
collected.push({
|
||||
node: _reducedNode,
|
||||
preOperator
|
||||
});
|
||||
}
|
||||
}
|
||||
} else {
|
||||
collected.push({
|
||||
node,
|
||||
preOperator
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function reduceAddSubExpression(node, precision) {
|
||||
// something + 0 => something
|
||||
// something - 0 => something
|
||||
if (isValueType(node.right.type) && node.right.value === 0) {
|
||||
return node.left;
|
||||
} // 0 + something => something
|
||||
var collected = [];
|
||||
collectAddSubItems('+', node, collected, precision);
|
||||
var withoutZeroItem = collected.filter(function (item) {
|
||||
return !(isValueType(item.node.type) && item.node.value === 0);
|
||||
});
|
||||
var firstNonZeroItem = withoutZeroItem[0]; // could be undefined
|
||||
// prevent producing "calc(-var(--a))" or "calc()"
|
||||
// which is invalid css
|
||||
|
||||
if (!firstNonZeroItem || firstNonZeroItem.preOperator === '-' && !isValueType(firstNonZeroItem.node.type)) {
|
||||
var firstZeroItem = collected.find(function (item) {
|
||||
return isValueType(item.node.type) && item.node.value === 0;
|
||||
});
|
||||
withoutZeroItem.unshift(firstZeroItem);
|
||||
} // make sure the preOperator of the first item is +
|
||||
|
||||
|
||||
if (isValueType(node.left.type) && node.left.value === 0 && node.operator === "+") {
|
||||
return node.right;
|
||||
} // 0 - something => -something
|
||||
|
||||
|
||||
if (isValueType(node.left.type) && node.left.value === 0 && node.operator === "-" && node.right.type !== "Function") {
|
||||
return flipValue(node.right);
|
||||
} // value + value
|
||||
// value - value
|
||||
|
||||
|
||||
if (isValueType(node.left.type) && node.left.type === node.right.type) {
|
||||
var operator = node.operator;
|
||||
|
||||
var _covertNodesUnits = covertNodesUnits(node.left, node.right, precision),
|
||||
left = _covertNodesUnits.left,
|
||||
right = _covertNodesUnits.right;
|
||||
|
||||
if (operator === "+") {
|
||||
left.value += right.value;
|
||||
} else {
|
||||
left.value -= right.value;
|
||||
}
|
||||
|
||||
return left;
|
||||
} // value <op> (expr)
|
||||
|
||||
|
||||
if (node.right.type === 'MathExpression' && (node.right.operator === '+' || node.right.operator === '-')) {
|
||||
// something - (something + something) => something - something - something
|
||||
// something - (something - something) => something - something + something
|
||||
if ((node.right.operator === '+' || node.right.operator === '-') && node.operator === '-') {
|
||||
node.right.operator = flip(node.right.operator);
|
||||
}
|
||||
|
||||
if (isValueType(node.left.type)) {
|
||||
// value + (value + something) => value + something
|
||||
// value + (value - something) => value - something
|
||||
// value - (value + something) => value - something
|
||||
// value - (value - something) => value + something
|
||||
if (node.left.type === node.right.left.type) {
|
||||
var _left = node.left,
|
||||
_operator = node.operator,
|
||||
_right = node.right;
|
||||
node.left = reduce({
|
||||
type: 'MathExpression',
|
||||
operator: _operator,
|
||||
left: _left,
|
||||
right: _right.left
|
||||
});
|
||||
node.operator = _right.operator;
|
||||
node.right = _right.right;
|
||||
return reduce(node, precision);
|
||||
} // something + (something + value) => dimension + something
|
||||
// something + (something - value) => dimension + something
|
||||
// something - (something + value) => dimension - something
|
||||
// something - (something - value) => dimension - something
|
||||
|
||||
|
||||
if (node.left.type === node.right.right.type) {
|
||||
var _left2 = node.left,
|
||||
_right2 = node.right;
|
||||
node.left = reduce({
|
||||
type: 'MathExpression',
|
||||
operator: _right2.operator,
|
||||
left: _left2,
|
||||
right: _right2.right
|
||||
});
|
||||
node.right = _right2.left;
|
||||
return reduce(node, precision);
|
||||
}
|
||||
}
|
||||
} // (expr) <op> value
|
||||
|
||||
|
||||
if (node.left.type === 'MathExpression' && (node.left.operator === '+' || node.left.operator === '-') && isValueType(node.right.type)) {
|
||||
// (value + something) + value => value + something
|
||||
// (value - something) + value => value - something
|
||||
// (value + something) - value => value + something
|
||||
// (value - something) - value => value - something
|
||||
if (node.right.type === node.left.left.type) {
|
||||
var _left3 = node.left,
|
||||
_operator2 = node.operator,
|
||||
_right3 = node.right;
|
||||
_left3.left = reduce({
|
||||
type: 'MathExpression',
|
||||
operator: _operator2,
|
||||
left: _left3.left,
|
||||
right: _right3
|
||||
}, precision);
|
||||
return reduce(_left3, precision);
|
||||
} // (something + dimension) + dimension => something + dimension
|
||||
// (something - dimension) + dimension => something - dimension
|
||||
// (something + dimension) - dimension => something + dimension
|
||||
// (something - dimension) - dimension => something - dimension
|
||||
|
||||
|
||||
if (node.right.type === node.left.right.type) {
|
||||
var _left4 = node.left,
|
||||
_operator3 = node.operator,
|
||||
_right4 = node.right;
|
||||
|
||||
if (_left4.operator === '-') {
|
||||
_left4.operator = _operator3 === '-' ? '-' : '+';
|
||||
_left4.right = reduce({
|
||||
type: 'MathExpression',
|
||||
operator: _operator3 === '-' ? '+' : '-',
|
||||
left: _right4,
|
||||
right: _left4.right
|
||||
}, precision);
|
||||
} else {
|
||||
_left4.right = reduce({
|
||||
type: 'MathExpression',
|
||||
operator: _operator3,
|
||||
left: _left4.right,
|
||||
right: _right4
|
||||
}, precision);
|
||||
}
|
||||
|
||||
if (_left4.right.value < 0) {
|
||||
_left4.right.value *= -1;
|
||||
_left4.operator = _left4.operator === '-' ? '+' : '-';
|
||||
}
|
||||
|
||||
_left4.parenthesized = node.parenthesized;
|
||||
return reduce(_left4, precision);
|
||||
}
|
||||
} // (expr) + (expr) => number
|
||||
// (expr) - (expr) => number
|
||||
|
||||
|
||||
if (node.right.type === 'MathExpression' && node.left.type === 'MathExpression') {
|
||||
if (isEqual(node.left.right, node.right.right)) {
|
||||
var newNodes = covertNodesUnits(node.left.left, node.right.left, precision);
|
||||
node.left = newNodes.left;
|
||||
node.right = newNodes.right;
|
||||
return reduce(node);
|
||||
}
|
||||
|
||||
if (isEqual(node.left.right, node.right.left)) {
|
||||
var _newNodes = covertNodesUnits(node.left.left, node.right.right, precision);
|
||||
|
||||
node.left = _newNodes.left;
|
||||
node.right = _newNodes.right;
|
||||
return reduce(node);
|
||||
}
|
||||
if (withoutZeroItem[0].preOperator === '-' && isValueType(withoutZeroItem[0].node.type)) {
|
||||
withoutZeroItem[0].node.value *= -1;
|
||||
withoutZeroItem[0].preOperator = '+';
|
||||
}
|
||||
|
||||
return node;
|
||||
var root = withoutZeroItem[0].node;
|
||||
|
||||
for (var i = 1; i < withoutZeroItem.length; i++) {
|
||||
root = {
|
||||
type: 'MathExpression',
|
||||
operator: withoutZeroItem[i].preOperator,
|
||||
left: root,
|
||||
right: withoutZeroItem[i].node
|
||||
};
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
function reduceDivisionExpression(node) {
|
||||
@@ -223,51 +173,93 @@ function reduceDivisionExpression(node) {
|
||||
throw new Error(`Cannot divide by "${node.right.unit}", number expected`);
|
||||
}
|
||||
|
||||
if (node.right.value === 0) {
|
||||
return applyNumberDivision(node.left, node.right.value);
|
||||
} // apply (expr) / number
|
||||
|
||||
|
||||
function applyNumberDivision(node, divisor) {
|
||||
if (divisor === 0) {
|
||||
throw new Error('Cannot divide by zero');
|
||||
} // something / value
|
||||
|
||||
|
||||
if (isValueType(node.left.type)) {
|
||||
node.left.value /= node.right.value;
|
||||
return node.left;
|
||||
}
|
||||
|
||||
return node;
|
||||
if (isValueType(node.type)) {
|
||||
node.value /= divisor;
|
||||
return node;
|
||||
}
|
||||
|
||||
if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {
|
||||
// turn (a + b) / num into a/num + b/num
|
||||
// is good for further reduction
|
||||
// checkout the test case
|
||||
// "should reduce division before reducing additions"
|
||||
return {
|
||||
type: "MathExpression",
|
||||
operator: node.operator,
|
||||
left: applyNumberDivision(node.left, divisor),
|
||||
right: applyNumberDivision(node.right, divisor)
|
||||
};
|
||||
} // it is impossible to reduce it into a single value
|
||||
// .e.g the node contains css variable
|
||||
// so we just preserve the division and let browser do it
|
||||
|
||||
|
||||
return {
|
||||
type: "MathExpression",
|
||||
operator: '/',
|
||||
left: node,
|
||||
right: {
|
||||
type: "Number",
|
||||
value: divisor
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function reduceMultiplicationExpression(node) {
|
||||
// (expr) * number
|
||||
if (node.left.type === 'MathExpression' && node.right.type === 'Number') {
|
||||
if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {
|
||||
node.left.left.value *= node.right.value;
|
||||
node.left.right.value *= node.right.value;
|
||||
return node.left;
|
||||
}
|
||||
} // something * number
|
||||
|
||||
|
||||
if (isValueType(node.left.type) && node.right.type === 'Number') {
|
||||
node.left.value *= node.right.value;
|
||||
return node.left;
|
||||
if (node.right.type === 'Number') {
|
||||
return applyNumberMultiplication(node.left, node.right.value);
|
||||
} // number * (expr)
|
||||
|
||||
|
||||
if (node.left.type === 'Number' && node.right.type === 'MathExpression') {
|
||||
if (isValueType(node.right.left.type) && isValueType(node.right.right.type)) {
|
||||
node.right.left.value *= node.left.value;
|
||||
node.right.right.value *= node.left.value;
|
||||
return node.right;
|
||||
}
|
||||
} // number * something
|
||||
|
||||
|
||||
if (node.left.type === 'Number' && isValueType(node.right.type)) {
|
||||
node.right.value *= node.left.value;
|
||||
return node.right;
|
||||
if (node.left.type === 'Number') {
|
||||
return applyNumberMultiplication(node.right, node.left.value);
|
||||
}
|
||||
|
||||
return node;
|
||||
} // apply (expr) / number
|
||||
|
||||
|
||||
function applyNumberMultiplication(node, multiplier) {
|
||||
if (isValueType(node.type)) {
|
||||
node.value *= multiplier;
|
||||
return node;
|
||||
}
|
||||
|
||||
if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {
|
||||
// turn (a + b) * num into a*num + b*num
|
||||
// is good for further reduction
|
||||
// checkout the test case
|
||||
// "should reduce multiplication before reducing additions"
|
||||
return {
|
||||
type: "MathExpression",
|
||||
operator: node.operator,
|
||||
left: applyNumberMultiplication(node.left, multiplier),
|
||||
right: applyNumberMultiplication(node.right, multiplier)
|
||||
};
|
||||
} // it is impossible to reduce it into a single value
|
||||
// .e.g the node contains css variable
|
||||
// so we just preserve the division and let browser do it
|
||||
|
||||
|
||||
return {
|
||||
type: "MathExpression",
|
||||
operator: '*',
|
||||
left: node,
|
||||
right: {
|
||||
type: "Number",
|
||||
value: multiplier
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function covertNodesUnits(left, right, precision) {
|
||||
@@ -301,14 +293,15 @@ function covertNodesUnits(left, right, precision) {
|
||||
|
||||
function reduce(node, precision) {
|
||||
if (node.type === "MathExpression") {
|
||||
if (isAddSubOperator(node.operator)) {
|
||||
// reduceAddSubExpression will call reduce recursively
|
||||
return reduceAddSubExpression(node, precision);
|
||||
}
|
||||
|
||||
node.left = reduce(node.left, precision);
|
||||
node.right = reduce(node.right, precision);
|
||||
|
||||
switch (node.operator) {
|
||||
case "+":
|
||||
case "-":
|
||||
return reduceAddSubExpression(node, precision);
|
||||
|
||||
case "/":
|
||||
return reduceDivisionExpression(node, precision);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user