@fileverse-dev/formula-parser 0.2.5-tally-1

package/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) Handsoncode sp. z o.o. <hello@handsoncode.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,261 @@
+:warning: This repository is deprecated. We've released new and improved [HyperFormula](https://github.com/handsontable/hyperformula/) engine.
+
+<details>
+
+# Formula Parser [![Build Status](https://travis-ci.org/handsontable/formula-parser.png?branch=master)](https://travis-ci.org/handsontable/formula-parser) [![Test Coverage](https://codeclimate.com/github/handsontable/formula-parser/badges/coverage.svg)](https://codeclimate.com/github/handsontable/formula-parser/coverage) [![hot-formula-parser](https://img.shields.io/npm/v/hot-formula-parser.svg)](https://www.npmjs.com/package/hot-formula-parser)
+
+Library provides a `Parser` class that evaluates excel and mathematical formulas.
+
+---
+
+## Install
+
+A recommended way to install Formula Parser is through [NPM](https://www.npmjs.com/) using the following command:
+
+```sh
+$ npm install hot-formula-parser --save
+```
+
+Node.js:
+
+```js
+var FormulaParser = require("hot-formula-parser").Parser;
+var parser = new FormulaParser();
+
+parser.parse("SUM(1, 6, 7)"); // It returns `Object {error: null, result: 14}`
+```
+
+Browser:
+
+```html
+<script src="/node_modules/hot-formula-parser/dist/formula-parser.min.js"></script>
+<script>
+  var parser = new formulaParser.Parser();
+
+  parser.parse("SUM(1, 6, 7)"); // It returns `Object {error: null, result: 14}`
+</script>
+```
+
+## Features
+
+It supports:
+
+- Any numbers, negative and positive as float or integer;
+- Arithmetic operations like `+`, `-`, `/`, `*`, `%`, `^`;
+- Logical operations like `AND()`, `OR()`, `NOT()`, `XOR()`;
+- Comparison operations like `=`, `>`, `>=`, `<`, `<=`, `<>`;
+- All JavaScript Math constants like `PI()`, `E()`, `LN10()`, `LN2()`, `LOG10E()`, `LOG2E()`, `SQRT1_2()`, `SQRT2()`;
+- String operations like `&` (concatenation eq. `parser.parse('-(2&5)');` will return `-25`);
+- All excel formulas defined in [formula.js](https://github.com/handsontable/formula.js);
+- Relative and absolute cell coordinates like `A1`, `$A1`, `A$1`, `$A$1`;
+- Build-in variables like `TRUE`, `FALSE`, `NULL`
+- Custom variables;
+- Custom functions/formulas;
+- Node and Browser environment.
+
+## API (methods)
+
+```js
+var parser = new formulaParser.Parser();
+```
+
+### .parse(expression)
+
+Parses and evaluates provided expression. It always returns an object with `result` and `error` properties. `result` property
+always keep evaluated value. If error occurs `error` property will be set as:
+
+- `#ERROR!` General error;
+- `#DIV/0!` Divide by zero error;
+- `#NAME?` Not recognised function name or variable name;
+- `#N/A` Indicates that a value is not available to a formula;
+- `#NUM!` Occurs when formula encounters an invalid number;
+- `#VALUE!` Occurs when one of formula arguments is of the wrong type.
+
+```js
+parser.parse("(1 + 5 + (5 * 10)) / 10"); // returns `Object {error: null, result: 5.6}`
+parser.parse("SUM(MY_VAR)"); // returns `Object {error: "#NAME?", result: null}`
+parser.parse("1;;1"); // returns `Object {error: "#ERROR!", result: null}`
+```
+
+### .setVariable(name, value)
+
+Set predefined variable name which can be visible while parsing formula expression.
+
+```js
+parser.setVariable("MY_VARIABLE", 5);
+parser.setVariable("fooBar", 10);
+
+parser.parse("(1 + MY_VARIABLE + (5 * fooBar)) / fooBar"); // returns `5.6`
+```
+
+### .getVariable(name)
+
+Get variable name.
+
+```js
+parser.setVariable("fooBar", 10);
+
+parser.getVariable("fooBar"); // returns `10`
+```
+
+### .setFunction(name, fn)
+
+Set custom function which can be visible while parsing formula expression.
+
+```js
+parser.setFunction("ADD_5", function (params) {
+  return params[0] + 5;
+});
+parser.setFunction("GET_LETTER", function (params) {
+  var string = params[0];
+  var index = params[1] - 1;
+
+  return string.charAt(index);
+});
+
+parser.parse("SUM(4, ADD_5(1))"); // returns `10`
+parser.parse('GET_LETTER("Some string", 3)'); // returns `m`
+```
+
+### .getFunction(name)
+
+Get custom function.
+
+```js
+parser.setFunction("ADD_5", function (params) {
+  return params[0] + 5;
+});
+
+parser.getFunction("ADD_5")([1]); // returns `6`
+```
+
+### .SUPPORTED_FORMULAS
+
+List of all supported formulas function.
+
+```js
+require("hot-formula-parser").SUPPORTED_FORMULAS; // An array of formula names
+```
+
+## API (hooks)
+
+### 'callVariable' (name, done)
+
+Fired while retrieving variable. If variable was defined earlier using `setVariable` you can overwrite it by this hook.
+
+```js
+parser.on("callVariable", function (name, done) {
+  if (name === "foo") {
+    done(Math.PI / 2);
+  }
+});
+
+parser.parse("SUM(SIN(foo), COS(foo))"); // returns `1`
+```
+
+### 'callFunction' (name, params, done)
+
+Fired while calling function. If function was defined earlier using `setFunction` you can overwrite it's result by this hook.
+You can also use this to override result of build-in formulas.
+
+```js
+parser.on("callFunction", function (name, params, done) {
+  if (name === "ADD_5") {
+    done(params[0] + 5);
+  }
+});
+
+parser.parse("ADD_5(3)"); // returns `8`
+```
+
+### 'callCellValue' (cellCoord, done)
+
+Fired while retrieving cell value by its label (eq: `B3`, `B$3`, `B$3`, `$B$3`).
+
+```js
+parser.on("callCellValue", function (cellCoord, done) {
+  // using label
+  if (cellCoord.label === "B$6") {
+    done("hello");
+  }
+  // or using indexes
+  if (
+    cellCoord.row.index === 5 &&
+    cellCoord.row.isAbsolute &&
+    cellCoord.column.index === 1 &&
+    !cellCoord.column.isAbsolute
+  ) {
+    done("hello");
+  }
+
+  if (cellCoord.label === "C6") {
+    done(0.75);
+  }
+});
+
+parser.parse("B$6"); // returns `"hello"`
+parser.parse('B$6&" world"'); // returns `"hello world"`
+parser.parse("FISHER(C6)"); // returns `0.9729550745276566`
+```
+
+### 'callRangeValue' (startCellCoord, endCellCoord, done)
+
+Fired while retrieving cells range value (eq: `A1:B3`, `$A1:B$3`, `A$1:B$3`, `$A$1:$B$3`).
+
+```js
+parser.on("callRangeValue", function (startCellCoord, endCellCoord, done) {
+  var data = [
+    [1, 2, 3, 4, 5],
+    [6, 7, 8, 9, 10],
+    [11, 12, 13, 14, 15],
+    [16, 17, 18, 19, 20],
+  ];
+  var fragment = [];
+
+  for (
+    var row = startCellCoord.row.index;
+    row <= endCellCoord.row.index;
+    row++
+  ) {
+    var rowData = data[row];
+    var colFragment = [];
+
+    for (
+      var col = startCellCoord.column.index;
+      col <= endCellCoord.column.index;
+      col++
+    ) {
+      colFragment.push(rowData[col]);
+    }
+    fragment.push(colFragment);
+  }
+
+  if (fragment) {
+    done(fragment);
+  }
+});
+
+parser.parse("JOIN(A1:E2)"); // returns `"1,2,3,4,5,6,7,8,9,10"`
+parser.parse("COLUMNS(A1:E2)"); // returns `5`
+parser.parse("ROWS(A1:E2)"); // returns `2`
+parser.parse("COUNT(A1:E2)"); // returns `10`
+parser.parse('COUNTIF(A1:E2, ">5")'); // returns `5`
+```
+
+### Want to help?
+
+Please see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+### Changelog
+
+To see the list of recent changes, see [Releases section](https://github.com/handsontable/formula-parser/releases).
+
+### License
+
+The MIT License (see the [LICENSE](https://github.com/handsontable/formula-parser/blob/master/LICENSE) file for the full text).
+
+### Contact
+
+You can contact us at hello@handsontable.com.
+
+</details>

package/es/error.js

@@ -0,0 +1,45 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export var ERROR = "ERROR";
+export var ERROR_DIV_ZERO = "DIV/0";
+export var ERROR_NAME = "NAME";
+export var ERROR_NOT_AVAILABLE = "N/A";
+export var ERROR_NULL = "NULL";
+export var ERROR_NUM = "NUM";
+export var ERROR_REF = "REF";
+export var ERROR_VALUE = "VALUE";
+var errors = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, ERROR, "Syntax error"), ERROR_DIV_ZERO, "#DIV/0!"), ERROR_NAME, "Wrong function name or parameter"), ERROR_NOT_AVAILABLE, "#N/A"), ERROR_NULL, "#NULL!"), ERROR_NUM, "#NUM!"), ERROR_REF, "#REF!"), ERROR_VALUE, "#VALUE!");
+
+/**
+ * Return error type based on provided error id.
+ *
+ * @param {String} type Error type.
+ * @returns {String|null} Returns error id.
+ */
+export default function error(type) {
+  var result;
+  type = (type + "").replace(/#|!|\?/g, "");
+  if (errors[type]) {
+    result = errors[type];
+  }
+  return result ? result : null;
+}
+
+/**
+ * Check if error type is strict valid with knows errors.
+ *
+ * @param {String} Error type.
+ * @return {Boolean}
+ */
+export function isValidStrict(type) {
+  var valid = false;
+  for (var i in errors) {
+    if (Object.prototype.hasOwnProperty.call(errors, i) && errors[i] === type) {
+      valid = true;
+      break;
+    }
+  }
+  return valid;
+}

package/es/evaluate-by-operator/evaluate-by-operator.js

@@ -0,0 +1,70 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/* eslint-disable import/no-named-as-default-member */
+import add from "./operator/add";
+import ampersand from "./operator/ampersand";
+import divide from "./operator/divide";
+import equal from "./operator/equal";
+import formulaFunction from "./operator/formula-function";
+import greaterThan from "./operator/greater-than";
+import greaterThanOrEqual from "./operator/greater-than-or-equal";
+import lessThan from "./operator/less-than";
+import lessThanOrEqual from "./operator/less-than-or-equal";
+import minus from "./operator/minus";
+import multiply from "./operator/multiply";
+import notEqual from "./operator/not-equal";
+import power from "./operator/power";
+import { ERROR_NAME } from "./../error";
+var availableOperators = Object.create(null);
+
+/**
+ * Evaluate values by operator id.git
+ *
+ * @param {String} operator Operator id.
+ * @param {Array} [params=[]] Arguments to evaluate.
+ * @returns {*}
+ */
+export default function evaluateByOperator(operator) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  operator = operator.toUpperCase();
+  if (!availableOperators[operator]) {
+    throw Error(ERROR_NAME);
+  }
+  return availableOperators[operator].apply(availableOperators, _toConsumableArray(params));
+}
+
+/**
+ * Register operator.
+ *
+ * @param {String|Array} symbol Symbol to register.
+ * @param {Function} func Logic to register for this symbol.
+ */
+export function registerOperation(symbol, func) {
+  if (!Array.isArray(symbol)) {
+    symbol = [symbol.toUpperCase()];
+  }
+  symbol.forEach(function (s) {
+    if (func.isFactory) {
+      availableOperators[s] = func(s);
+    } else {
+      availableOperators[s] = func;
+    }
+  });
+}
+registerOperation(add.SYMBOL, add);
+registerOperation(ampersand.SYMBOL, ampersand);
+registerOperation(divide.SYMBOL, divide);
+registerOperation(equal.SYMBOL, equal);
+registerOperation(power.SYMBOL, power);
+registerOperation(formulaFunction.SYMBOL, formulaFunction);
+registerOperation(greaterThan.SYMBOL, greaterThan);
+registerOperation(greaterThanOrEqual.SYMBOL, greaterThanOrEqual);
+registerOperation(lessThan.SYMBOL, lessThan);
+registerOperation(lessThanOrEqual.SYMBOL, lessThanOrEqual);
+registerOperation(multiply.SYMBOL, multiply);
+registerOperation(notEqual.SYMBOL, notEqual);
+registerOperation(minus.SYMBOL, minus);

package/es/evaluate-by-operator/operator/add.js

@@ -0,0 +1,16 @@
+import { toNumber } from "./../../helper/number";
+import { ERROR_VALUE } from "./../../error";
+export var SYMBOL = "+";
+export default function func(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc + toNumber(value || 0);
+  }, toNumber(first || 0));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/ampersand.js

@@ -0,0 +1,10 @@
+export var SYMBOL = "&";
+export default function func() {
+  for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+    params[_key] = arguments[_key];
+  }
+  return params.reduce(function (acc, value) {
+    return acc + value.toString();
+  }, "");
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/divide.js

@@ -0,0 +1,21 @@
+import { toNumber } from "./../../helper/number";
+import { ERROR_DIV_ZERO, ERROR_VALUE } from "./../../error";
+export var SYMBOL = "/";
+export default function func(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc / toNumber(value);
+  }, toNumber(first));
+  if (result === Infinity) {
+    return ERROR_DIV_ZERO;
+    // throw Error(ERROR_DIV_ZERO);
+  }
+  if (isNaN(result)) {
+    return ERROR_VALUE;
+    // throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/equal.js

@@ -0,0 +1,5 @@
+export var SYMBOL = "=";
+export default function func(exp1, exp2) {
+  return exp1 === exp2;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/formula-function.js

@@ -0,0 +1,40 @@
+import * as formulajs from "@fileverse-dev/formulajs";
+import SUPPORTED_FORMULAS from "./../../supported-formulas";
+import { ERROR_NAME } from "./../../error";
+export var SYMBOL = SUPPORTED_FORMULAS;
+export default function func(symbol) {
+  return function __formulaFunction() {
+    symbol = symbol.toUpperCase();
+    var symbolParts = symbol.split(".");
+    var foundFormula = false;
+    var result;
+    if (symbolParts.length === 1) {
+      if (formulajs[symbolParts[0]]) {
+        foundFormula = true;
+        result = formulajs[symbolParts[0]].apply(formulajs, arguments);
+      }
+    } else {
+      var length = symbolParts.length;
+      var index = 0;
+      var nestedFormula = formulajs;
+      while (index < length) {
+        nestedFormula = nestedFormula[symbolParts[index]];
+        index++;
+        if (!nestedFormula) {
+          nestedFormula = null;
+          break;
+        }
+      }
+      if (nestedFormula) {
+        foundFormula = true;
+        result = nestedFormula.apply(void 0, arguments);
+      }
+    }
+    if (!foundFormula) {
+      throw Error(ERROR_NAME);
+    }
+    return result;
+  };
+}
+func.isFactory = true;
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/greater-than-or-equal.js

@@ -0,0 +1,5 @@
+export var SYMBOL = ">=";
+export default function func(exp1, exp2) {
+  return exp1 >= exp2;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/greater-than.js

@@ -0,0 +1,5 @@
+export var SYMBOL = ">";
+export default function func(exp1, exp2) {
+  return exp1 > exp2;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/less-than-or-equal.js

@@ -0,0 +1,5 @@
+export var SYMBOL = "<=";
+export default function func(exp1, exp2) {
+  return exp1 <= exp2;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/less-than.js

@@ -0,0 +1,5 @@
+export var SYMBOL = "<";
+export default function func(exp1, exp2) {
+  return exp1 < exp2;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/minus.js

@@ -0,0 +1,16 @@
+import { toNumber } from "./../../helper/number";
+import { ERROR_VALUE } from "./../../error";
+export var SYMBOL = "-";
+export default function func(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc - toNumber(value);
+  }, toNumber(first));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/multiply.js

@@ -0,0 +1,16 @@
+import { toNumber } from "./../../helper/number";
+import { ERROR_VALUE } from "./../../error";
+export var SYMBOL = "*";
+export default function func(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc * toNumber(value);
+  }, toNumber(first));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/not-equal.js

@@ -0,0 +1,5 @@
+export var SYMBOL = "<>";
+export default function func(exp1, exp2) {
+  return exp1 !== exp2;
+}
+func.SYMBOL = SYMBOL;

package/es/evaluate-by-operator/operator/power.js

@@ -0,0 +1,11 @@
+import { toNumber } from "./../../helper/number";
+import { ERROR_VALUE } from "./../../error";
+export var SYMBOL = "^";
+export default function func(exp1, exp2) {
+  var result = Math.pow(toNumber(exp1), toNumber(exp2));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;