@fileverse-dev/formula-parser 0.2.49-patch-4 → 0.2.49-patch-6

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

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var _number = require("./../../helper/number");
+var _error = require("./../../error");
+var SYMBOL = exports.SYMBOL = "/";
+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 / (0, _number.toNumber)(value);
+  }, (0, _number.toNumber)(first));
+  if (result === Infinity) {
+    return _error.ERROR_DIV_ZERO;
+    // throw Error(ERROR_DIV_ZERO);
+  }
+  if (isNaN(result)) {
+    return _error.ERROR_VALUE;
+    // throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var SYMBOL = exports.SYMBOL = "=";
+function func(exp1, exp2) {
+  return exp1 === exp2;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,50 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var formulajs = _interopRequireWildcard(require("@fileverse-dev/formulajs"));
+var _supportedFormulas = _interopRequireDefault(require("./../../supported-formulas"));
+var _error = require("./../../error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var SYMBOL = exports.SYMBOL = _supportedFormulas["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.ERROR_NAME);
+    }
+    return result;
+  };
+}
+func.isFactory = true;
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var SYMBOL = exports.SYMBOL = ">=";
+function func(exp1, exp2) {
+  return exp1 >= exp2;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var SYMBOL = exports.SYMBOL = ">";
+function func(exp1, exp2) {
+  return exp1 > exp2;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var SYMBOL = exports.SYMBOL = "<=";
+function func(exp1, exp2) {
+  return exp1 <= exp2;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var SYMBOL = exports.SYMBOL = "<";
+function func(exp1, exp2) {
+  return exp1 < exp2;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var _number = require("./../../helper/number");
+var _error = require("./../../error");
+var SYMBOL = exports.SYMBOL = "-";
+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 - (0, _number.toNumber)(value);
+  }, (0, _number.toNumber)(first));
+  if (isNaN(result)) {
+    throw Error(_error.ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var _number = require("./../../helper/number");
+var _error = require("./../../error");
+var SYMBOL = exports.SYMBOL = "*";
+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 * (0, _number.toNumber)(value);
+  }, (0, _number.toNumber)(first));
+  if (isNaN(result)) {
+    throw Error(_error.ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var SYMBOL = exports.SYMBOL = "<>";
+function func(exp1, exp2) {
+  return exp1 !== exp2;
+}
+func.SYMBOL = SYMBOL;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYMBOL = void 0;
+exports["default"] = func;
+var _number = require("./../../helper/number");
+var _error = require("./../../error");
+var SYMBOL = exports.SYMBOL = "^";
+function func(exp1, exp2) {
+  var result = Math.pow((0, _number.toNumber)(exp1), (0, _number.toNumber)(exp2));
+  if (isNaN(result)) {
+    throw Error(_error.ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;

package/lib/grammar-parser/grammar-parser.jison

@@ -0,0 +1,230 @@
+/* description: Parses end evaluates mathematical expressions. */
+/* lexical grammar */
+%lex
+%%
+\s+                                                                                             {/* skip whitespace */}
+'"'("\\"["]|[^"])*'"'                                                                           {return 'STRING';}
+"'"('\\'[']|[^'])*"'"                                                                           {return 'STRING';}
+[A-Za-z]{1,}[A-Za-z_0-9\.]+(?=[(])                                                              {return 'FUNCTION';}
+'#'[A-Z0-9\/]+('!'|'?')?                                                                        {return 'ERROR';}
+'$'[A-Za-z]+'$'[0-9]+                                                                           {return 'ABSOLUTE_CELL';}
+'$'[A-Za-z]+[0-9]+                                                                              {return 'MIXED_CELL';}
+[A-Za-z]+'$'[0-9]+                                                                              {return 'MIXED_CELL';}
+[A-Za-z]+[0-9]+                                                                                 {return 'RELATIVE_CELL';}
+[A-Za-z\.]+(?=[(])                                                                              {return 'FUNCTION';}
+[A-Za-z]{1,}[A-Za-z_0-9]+                                                                       {return 'VARIABLE';}
+[A-Za-z_]+                                                                                      {return 'VARIABLE';}
+[0-9]*\.?[0-9]+                                                                                 {return 'NUMBER';}
+'['(.*)?']'                                                                                     {return 'ARRAY';}
+"&"                                                                                             {return '&';}
+" "                                                                                             {return ' ';}
+[.]                                                                                             {return 'DECIMAL';}
+":"                                                                                             {return ':';}
+";"                                                                                             {return ';';}
+","                                                                                             {return ',';}
+"*"                                                                                             {return '*';}
+"/"                                                                                             {return '/';}
+"-"                                                                                             {return '-';}
+"+"                                                                                             {return '+';}
+"^"                                                                                             {return '^';}
+"("                                                                                             {return '(';}
+")"                                                                                             {return ')';}
+">"                                                                                             {return '>';}
+"<"                                                                                             {return '<';}
+"NOT"                                                                                           {return 'NOT';}
+'"'                                                                                             {return '"';}
+"'"                                                                                             {return "'";}
+"!"                                                                                             {return "!";}
+"="                                                                                             {return '=';}
+"%"                                                                                             {return '%';}
+[#]                                                                                             {return '#';}
+<<EOF>>                                                                                         {return 'EOF';}
+/lex
+
+/* operator associations and precedence (low-top, high-bottom) */
+%left '='
+%left '<=' '>=' '<>' 'NOT' '||'
+%left '>' '<'
+%left '+' '-'
+%left '*' '/'
+%left '^'
+%left '&'
+%left '%'
+%left UMINUS
+
+%start expressions
+
+%% /* language grammar */
+
+expressions
+  : expression EOF {
+      return $1;
+    }
+;
+
+expression
+  : variableSequence {
+      $$ = yy.callVariable($1[0]);
+    }
+  | number {
+      $$ = yy.toNumber($1);
+    }
+  | STRING {
+      $$ = yy.trimEdges($1);
+    }
+  | expression '&' expression {
+      $$ = yy.evaluateByOperator('&', [$1, $3]);
+    }
+  | expression '=' expression {
+      $$ = yy.evaluateByOperator('=', [$1, $3]);
+    }
+  | expression '+' expression {
+      $$ = yy.evaluateByOperator('+', [$1, $3]);
+    }
+  | '(' expression ')' {
+      $$ = $2;
+    }
+  | expression '<' '=' expression {
+      $$ = yy.evaluateByOperator('<=', [$1, $4]);
+    }
+  | expression '>' '=' expression {
+      $$ = yy.evaluateByOperator('>=', [$1, $4]);
+    }
+  | expression '<' '>' expression {
+      $$ = yy.evaluateByOperator('<>', [$1, $4]);
+    }
+  | expression NOT expression {
+      $$ = yy.evaluateByOperator('NOT', [$1, $3]);
+    }
+  | expression '>' expression {
+      $$ = yy.evaluateByOperator('>', [$1, $3]);
+    }
+  | expression '<' expression {
+      $$ = yy.evaluateByOperator('<', [$1, $3]);
+    }
+  | expression '-' expression {
+      $$ = yy.evaluateByOperator('-', [$1, $3]);
+    }
+  | expression '*' expression {
+      $$ = yy.evaluateByOperator('*', [$1, $3]);
+    }
+  | expression '/' expression {
+      $$ = yy.evaluateByOperator('/', [$1, $3]);
+    }
+  | expression '^' expression {
+      $$ = yy.evaluateByOperator('^', [$1, $3]);
+    }
+  | '-' expression {
+      var n1 = yy.invertNumber($2);
+
+      $$ = n1;
+
+      if (isNaN($$)) {
+          $$ = 0;
+      }
+    }
+  | '+' expression {
+      var n1 = yy.toNumber($2);
+
+      $$ = n1;
+
+      if (isNaN($$)) {
+          $$ = 0;
+      }
+    }
+  | FUNCTION '(' ')' {
+      $$ = yy.callFunction($1);
+    }
+  | FUNCTION '(' expseq ')' {
+      $$ = yy.callFunction($1, $3);
+    }
+  | cell
+  | error
+  | error error
+;
+
+cell
+   : ABSOLUTE_CELL {
+      $$ = yy.cellValue($1);
+    }
+  | RELATIVE_CELL {
+      $$ = yy.cellValue($1);
+    }
+  | MIXED_CELL {
+      $$ = yy.cellValue($1);
+    }
+  | ABSOLUTE_CELL ':' ABSOLUTE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | ABSOLUTE_CELL ':' RELATIVE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | ABSOLUTE_CELL ':' MIXED_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | RELATIVE_CELL ':' ABSOLUTE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | RELATIVE_CELL ':' RELATIVE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | RELATIVE_CELL ':' MIXED_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | MIXED_CELL ':' ABSOLUTE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | MIXED_CELL ':' RELATIVE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | MIXED_CELL ':' MIXED_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+;
+
+expseq
+  : expression {
+      $$ = [$1];
+    }
+  | ARRAY {
+      $$ = yy.trimEdges(yytext).split(',');
+    }
+  | expseq ';' expression {
+      $1.push($3);
+      $$ = $1;
+    }
+  | expseq ',' expression {
+      $1.push($3);
+      $$ = $1;
+    }
+;
+
+variableSequence
+  : VARIABLE {
+      $$ = [$1];
+    }
+  | variableSequence DECIMAL VARIABLE {
+      $$ = (Array.isArray($1) ? $1 : [$1]);
+      $$.push($3);
+    }
+;
+
+number
+  : NUMBER {
+      $$ = $1;
+    }
+  | NUMBER DECIMAL NUMBER {
+      $$ = ($1 + '.' + $3) * 1;
+    }
+  | number '%' {
+      $$ = $1 * 0.01;
+    }
+;
+
+error
+  : ERROR {
+      $$ = yy.throwError($1);
+    }
+;
+
+%%