Add precision option

poke @7studio

Author: MoOx

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.2.0 - 2014-11-24
+
+* Decimal precision is now customisable as the `precision` option
+
 # 1.1.4 - 2014-11-12
 
 * 5 decimals rounding for everything

README.md

@@ -1,17 +1,19 @@
 # reduce-css-calc [![Build Status](https://travis-ci.org/MoOx/reduce-css-calc.png)](https://travis-ci.org/MoOx/reduce-css-calc)
 
-Reduce CSS calc() function to the maximum.
+> Reduce CSS calc() function to the maximum.
 
 Particularly useful for packages like [rework-calc](https://github.com/reworkcss/rework-calc) or [postcss-calc](https://github.com/postcss/postcss-calc).
 
 ## Installation
 
-```bash
-npm install reduce-css-calc
+```console
+$ npm install reduce-css-calc
 ```
 
 ## Usage
 
+### `var reducedString = reduceCSSCalc(string, precision)`
+
 ```javascript
 var reduceCSSCalc = require('reduce-css-calc')
 
@@ -21,6 +23,12 @@ reduceCSSCalc("calc(1 + 1)")
 reduceCSSCalc("calc((6 / 2) - (4 * 2) + 1)")
 // -4
 
+reduceCSSCalc("calc(1/3)")
+// 0.33333
+
+reduceCSSCalc("calc(1/3)", 10)
+// 0.3333333333
+
 reduceCSSCalc("calc(3rem * 2 - 1rem)")
 // 5rem
 
@@ -52,11 +60,11 @@ See [unit tests](test/index.js) for others examples.
 
 Work on a branch, install dev-dependencies, respect coding style & run tests before submitting a bug fix or a feature.
 
-```bash
-git clone https://github.com/MoOx/reduce-css-calc.git
-git checkout -b patch-1
-npm install
-npm test
+```console
+$ git clone https://github.com/MoOx/reduce-css-calc.git
+$ git checkout -b patch-1
+$ npm install
+$ npm test
 ```
 
 ## [Changelog](CHANGELOG.md)

index.js

@@ -8,7 +8,6 @@ var reduceFunctionCall = require("reduce-function-call")
  * Constantes
  */
 var MAX_STACK = 100 // should be enough for a single calc()...
-var DECIMAL_PRECISION = 100000 // 5 decimals
 var NESTED_CALC_RE = /(\+|\-|\*|\\|[^a-z]|)(\s*)(\()/g
 
 /**
@@ -28,103 +27,104 @@ module.exports = reduceCSSCalc
  *
  * @param {String} value css input
  */
-function reduceCSSCalc(value) {
+function reduceCSSCalc(value, decimalPrecision) {
   stack = 0
-  return reduceFunctionCall(value, /((?:\-[a-z]+\-)?calc)\(/, evaluateExpression)
-}
+  decimalPrecision = Math.pow(10, decimalPrecision === undefined ? 5 : decimalPrecision)
+
+  /**
+   * Evaluates an expression
+   *
+   * @param {String} expression
+   * @returns {String}
+   */
+  function evaluateExpression (expression, functionIdentifier, call) {
+    if (stack++ > MAX_STACK) {
+      stack = 0
+      throw new Error("Call stack overflow for " + call)
+    }
 
-/**
- * Evaluates an expression
- *
- * @param {String} expression
- * @returns {String}
- */
-function evaluateExpression (expression, functionIdentifier, call) {
-  if (stack++ > MAX_STACK) {
-    stack = 0
-    throw new Error("Call stack overflow for " + call)
-  }
+    if (expression === "") {
+      throw new Error(functionIdentifier + "(): '" + call + "' must contain a non-whitespace string")
+    }
 
-  if (expression === "") {
-    throw new Error(functionIdentifier + "(): '" + call + "' must contain a non-whitespace string")
-  }
+    expression = evaluateNestedExpression(expression, call)
 
-  expression = evaluateNestedExpression(expression, call)
+    var units = getUnitsInExpression(expression)
 
-  var units = getUnitsInExpression(expression)
+    // If multiple units let the expression be (i.e. browser calc())
+    if (units.length > 1) {
+      return functionIdentifier + "(" + expression + ")"
+    }
 
-  // If multiple units let the expression be (i.e. browser calc())
-  if (units.length > 1) {
-    return functionIdentifier + "(" + expression + ")"
-  }
+    var unit = units[0] || ""
 
-  var unit = units[0] || ""
+    if (unit === "%") {
+      // Convert percentages to numbers, to handle expressions like: 50% * 50% (will become: 25%):
+      expression = expression.replace(/\b[0-9\.]+%/g, function(percent) {
+        return parseFloat(percent.slice(0, -1)) * 0.01
+      })
+    }
 
-  if (unit === "%") {
-    // Convert percentages to numbers, to handle expressions like: 50% * 50% (will become: 25%):
-    expression = expression.replace(/\b[0-9\.]+%/g, function(percent) {
-      return parseFloat(percent.slice(0, -1)) * 0.01
-    })
-  }
+    // Remove units in expression:
+    var toEvaluate = expression.replace(new RegExp(unit, "g"), "")
+    var result
 
-  // Remove units in expression:
-  var toEvaluate = expression.replace(new RegExp(unit, "g"), "")
-  var result
+    try {
+      result = eval(toEvaluate)
+    }
+    catch (e) {
+      return functionIdentifier + "(" + expression + ")"
+    }
 
-  try {
-    result = eval(toEvaluate)
-  }
-  catch (e) {
-    return functionIdentifier + "(" + expression + ")"
-  }
+    // Transform back to a percentage result:
+    if (unit === "%") {
+      result *= 100
+    }
 
-  // Transform back to a percentage result:
-  if (unit === "%") {
-    result *= 100
-  }
+    // adjust rounding shit
+    // (0.1 * 0.2 === 0.020000000000000004)
+    result = Math.round(result * decimalPrecision) / decimalPrecision
 
-  // adjust rounding shit
-  // (0.1 * 0.2 === 0.020000000000000004)
-  result = Math.round(result * DECIMAL_PRECISION) / DECIMAL_PRECISION
+    // We don't need units for zero values...
+    if (result !== 0) {
+      result += unit
+    }
 
-  // We don't need units for zero values...
-  if (result !== 0) {
-    result += unit
+    return result
   }
 
-  return result
-}
-
-/**
- * Evaluates nested expressions
- *
- * @param {String} expression
- * @returns {String}
- */
-function evaluateNestedExpression(expression, call) {
-  var evaluatedPart = ""
-  var nonEvaluatedPart = expression
-  var matches
-  while ((matches = NESTED_CALC_RE.exec(nonEvaluatedPart))) {
-    if (matches[0].index > 0) {
-      evaluatedPart += nonEvaluatedPart.substring(0, matches[0].index)
-    }
-
-    var balancedExpr = balanced("(", ")", nonEvaluatedPart.substring([0].index))
-    if (balancedExpr.body === "") {
-      throw new Error("'" + expression + "' must contain a non-whitespace string")
+  /**
+   * Evaluates nested expressions
+   *
+   * @param {String} expression
+   * @returns {String}
+   */
+  function evaluateNestedExpression(expression, call) {
+    var evaluatedPart = ""
+    var nonEvaluatedPart = expression
+    var matches
+    while ((matches = NESTED_CALC_RE.exec(nonEvaluatedPart))) {
+      if (matches[0].index > 0) {
+        evaluatedPart += nonEvaluatedPart.substring(0, matches[0].index)
+      }
+
+      var balancedExpr = balanced("(", ")", nonEvaluatedPart.substring([0].index))
+      if (balancedExpr.body === "") {
+        throw new Error("'" + expression + "' must contain a non-whitespace string")
+      }
+
+      var evaluated = evaluateExpression(balancedExpr.body, "", call)
+
+      evaluatedPart += balancedExpr.pre + evaluated
+      nonEvaluatedPart = balancedExpr.post
     }
 
-    var evaluated = evaluateExpression(balancedExpr.body, "", call)
-
-    evaluatedPart += balancedExpr.pre + evaluated
-    nonEvaluatedPart = balancedExpr.post
+    return evaluatedPart + nonEvaluatedPart
   }
 
-  return evaluatedPart + nonEvaluatedPart
+  return reduceFunctionCall(value, /((?:\-[a-z]+\-)?calc)\(/, evaluateExpression)
 }
 
-
 /**
  * Checks what units are used in an expression
  *

test/index.js

@@ -75,6 +75,9 @@ test("reduce prefixed css calc()", function(t) {
 test("handle rounding issues", function(t) {
   t.equal(reduceCSSCalc("calc(10% * 20%)"), "2%", "should round percentage")
   t.equal(reduceCSSCalc("calc(3rem * 1.2)"), "3.6rem", "should round floats")
+  t.equal(reduceCSSCalc("calc(1/3)"), "0.33333", "should round with default precision to 5 decimals")
+  t.equal(reduceCSSCalc("calc(1/3)", 10), "0.3333333333", "should round with desired precision (10)")
+  t.equal(reduceCSSCalc("calc(3 * 1.2)", 0), "4", "should round with desired precision (O)")
   t.end()
 })