@oat-sa/tao-core-ui 1.67.0 → 1.69.0

package/dist/maths/calculator/core/terms.js

@@ -1,456 +0,0 @@
-define(['i18n', 'ui/maths/calculator/core/labels'], function (__, labels) { 'use strict';
-
-    __ = __ && Object.prototype.hasOwnProperty.call(__, 'default') ? __['default'] : __;
-    labels = labels && Object.prototype.hasOwnProperty.call(labels, 'default') ? labels['default'] : labels;
-
-    /**
-     * This program is free software; you can redistribute it and/or
-     * modify it under the terms of the GNU General Public License
-     * as published by the Free Software Foundation; under version 2
-     * of the License (non-upgradable).
-     *
-     * This program is distributed in the hope that it will be useful,
-     * but WITHOUT ANY WARRANTY; without even the implied warranty of
-     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-     * GNU General Public License for more details.
-     *
-     * You should have received a copy of the GNU General Public License
-     * along with this program; if not, write to the Free Software
-     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-     *
-     * Copyright (c) 2018-2019 Open Assessment Technologies SA ;
-     */
-
-    /**
-     * @typedef {Object} term - Represents a tokenizable term
-     * @property {String} label - The displayable text
-     * @property {String} value - The related text that should be found in the expression
-     * @property {String} type - The type of token
-     * @property {String} description - A description of what represent the term
-     * @property {String|null} exponent - Some terms introduce exponent notation, and this property tells on which side
-     */
-
-    /**
-     * Defines the terms that can be tokenized from an expression
-     * @type {term[]}
-     */
-    var terms = {
-      // Digits definition
-      NUM0: {
-        label: labels.NUM0,
-        value: '0',
-        type: 'digit',
-        description: __('Digit 0'),
-        exponent: null
-      },
-      NUM1: {
-        label: labels.NUM1,
-        value: '1',
-        type: 'digit',
-        description: __('Digit 1'),
-        exponent: null
-      },
-      NUM2: {
-        label: labels.NUM2,
-        value: '2',
-        type: 'digit',
-        description: __('Digit 2'),
-        exponent: null
-      },
-      NUM3: {
-        label: labels.NUM3,
-        value: '3',
-        type: 'digit',
-        description: __('Digit 3'),
-        exponent: null
-      },
-      NUM4: {
-        label: labels.NUM4,
-        value: '4',
-        type: 'digit',
-        description: __('Digit 4'),
-        exponent: null
-      },
-      NUM5: {
-        label: labels.NUM5,
-        value: '5',
-        type: 'digit',
-        description: __('Digit 5'),
-        exponent: null
-      },
-      NUM6: {
-        label: labels.NUM6,
-        value: '6',
-        type: 'digit',
-        description: __('Digit 6'),
-        exponent: null
-      },
-      NUM7: {
-        label: labels.NUM7,
-        value: '7',
-        type: 'digit',
-        description: __('Digit 7'),
-        exponent: null
-      },
-      NUM8: {
-        label: labels.NUM8,
-        value: '8',
-        type: 'digit',
-        description: __('Digit 8'),
-        exponent: null
-      },
-      NUM9: {
-        label: labels.NUM9,
-        value: '9',
-        type: 'digit',
-        description: __('Digit 9'),
-        exponent: null
-      },
-      DOT: {
-        label: labels.DOT,
-        value: '.',
-        type: 'digit',
-        description: __('Dot'),
-        exponent: null
-      },
-      EXP10: {
-        label: labels.EXP10,
-        value: 'e',
-        type: 'digit',
-        description: __('Power of 10'),
-        exponent: 'right'
-      },
-      // Aggregators
-      LPAR: {
-        label: labels.LPAR,
-        value: '(',
-        type: 'aggregator',
-        description: __('Left parenthesis'),
-        exponent: null
-      },
-      RPAR: {
-        label: labels.RPAR,
-        value: ')',
-        type: 'aggregator',
-        description: __('Right parenthesis'),
-        exponent: null
-      },
-      // Separator
-      COMMA: {
-        label: labels.COMMA,
-        value: ',',
-        type: 'separator',
-        description: __('Arguments separator'),
-        exponent: null
-      },
-      ELLIPSIS: {
-        label: labels.ELLIPSIS,
-        value: '~',
-        type: 'separator',
-        description: __('Value ellipsis'),
-        exponent: null
-      },
-      // Operators
-      SUB: {
-        label: labels.SUB,
-        value: '-',
-        type: 'operator',
-        description: __('Binary operator -'),
-        exponent: null
-      },
-      NEG: {
-        label: labels.NEG,
-        value: labels.NEG,
-        type: 'operator',
-        description: __('Unary operator -'),
-        exponent: null
-      },
-      ADD: {
-        label: labels.ADD,
-        value: '+',
-        type: 'operator',
-        description: __('Binary operator +'),
-        exponent: null
-      },
-      POS: {
-        label: labels.POS,
-        value: labels.POS,
-        type: 'operator',
-        description: __('Unary operator +'),
-        exponent: null
-      },
-      MUL: {
-        label: labels.MUL,
-        value: '*',
-        type: 'operator',
-        description: __('Binary operator *'),
-        exponent: null
-      },
-      DIV: {
-        label: labels.DIV,
-        value: '/',
-        type: 'operator',
-        description: __('Binary operator /'),
-        exponent: null
-      },
-      MOD: {
-        label: labels.MOD,
-        value: '%',
-        type: 'operator',
-        description: __('Binary operator modulo'),
-        exponent: null
-      },
-      POW: {
-        label: labels.POW,
-        value: '^',
-        type: 'operator',
-        description: __('Power of'),
-        exponent: 'right'
-      },
-      FAC: {
-        label: labels.FAC,
-        value: '!',
-        type: 'operator',
-        description: __('Factorial'),
-        exponent: null
-      },
-      ASSIGN: {
-        label: labels.ASSIGN,
-        value: '=',
-        type: 'operator',
-        description: __('Assign'),
-        exponent: null
-      },
-      // Variables
-      ANS: {
-        label: labels.ANS,
-        value: 'ans',
-        type: 'variable',
-        description: __('Last result'),
-        exponent: null
-      },
-      // Constants
-      PI: {
-        label: labels.PI,
-        value: 'PI',
-        type: 'constant',
-        description: __('Value of PI'),
-        exponent: null
-      },
-      E: {
-        label: labels.E,
-        value: 'E',
-        type: 'constant',
-        description: __('Value of E'),
-        exponent: null
-      },
-      // Errors
-      NAN: {
-        label: labels.NAN,
-        value: 'NaN',
-        type: 'error',
-        description: __('Error in value'),
-        exponent: null
-      },
-      INFINITY: {
-        label: labels.INFINITY,
-        value: 'Infinity',
-        type: 'error',
-        description: __('Error in result'),
-        exponent: null
-      },
-      ERROR: {
-        label: labels.ERROR,
-        value: '#',
-        type: 'error',
-        description: __('Error in syntax'),
-        exponent: null
-      },
-      // Functions
-      EXP: {
-        label: labels.EXP,
-        value: 'exp',
-        type: 'function',
-        description: __('Exponent'),
-        exponent: 'right'
-      },
-      SQRT: {
-        label: labels.SQRT,
-        value: 'sqrt',
-        type: 'function',
-        description: __('Square root'),
-        exponent: null
-      },
-      CBRT: {
-        label: labels.CBRT,
-        value: 'cbrt',
-        type: 'function',
-        description: __('Cube root'),
-        exponent: null
-      },
-      NTHRT: {
-        label: labels.SQRT,
-        value: 'nthrt',
-        type: 'function',
-        description: __('Nth root'),
-        exponent: 'left'
-      },
-      FLOOR: {
-        label: labels.FLOOR,
-        value: 'floor',
-        type: 'function',
-        description: __('Round to lower whole number'),
-        exponent: null
-      },
-      CEIL: {
-        label: labels.CEIL,
-        value: 'ceil',
-        type: 'function',
-        description: __('Round to upper whole number'),
-        exponent: null
-      },
-      ROUND: {
-        label: labels.ROUND,
-        value: 'round',
-        type: 'function',
-        description: __('Round to closest whole number'),
-        exponent: null
-      },
-      TRUNC: {
-        label: labels.TRUNC,
-        value: 'trunc',
-        type: 'function',
-        description: __('Whole number part'),
-        exponent: null
-      },
-      SIN: {
-        label: labels.SIN,
-        value: 'sin',
-        type: 'function',
-        description: __('Sine'),
-        exponent: null
-      },
-      COS: {
-        label: labels.COS,
-        value: 'cos',
-        type: 'function',
-        description: __('Cosine'),
-        exponent: null
-      },
-      TAN: {
-        label: labels.TAN,
-        value: 'tan',
-        type: 'function',
-        description: __('Tangent'),
-        exponent: null
-      },
-      ASIN: {
-        label: labels.ASIN,
-        value: 'asin',
-        type: 'function',
-        description: __('Arc sine'),
-        exponent: null
-      },
-      ACOS: {
-        label: labels.ACOS,
-        value: 'acos',
-        type: 'function',
-        description: __('Arc cosine'),
-        exponent: null
-      },
-      ATAN: {
-        label: labels.ATAN,
-        value: 'atan',
-        type: 'function',
-        description: __('Arc tangent'),
-        exponent: null
-      },
-      SINH: {
-        label: labels.SINH,
-        value: 'sinh',
-        type: 'function',
-        description: __('Hyperbolic sine'),
-        exponent: null
-      },
-      COSH: {
-        label: labels.COSH,
-        value: 'cosh',
-        type: 'function',
-        description: __('Hyperbolic cosine'),
-        exponent: null
-      },
-      TANH: {
-        label: labels.TANH,
-        value: 'tanh',
-        type: 'function',
-        description: __('Hyperbolic tangent'),
-        exponent: null
-      },
-      ASINH: {
-        label: labels.ASINH,
-        value: 'asinh',
-        type: 'function',
-        description: __('Hyperbolic arc sine'),
-        exponent: null
-      },
-      ACOSH: {
-        label: labels.ACOSH,
-        value: 'acosh',
-        type: 'function',
-        description: __('Hyperbolic arc cosine'),
-        exponent: null
-      },
-      ATANH: {
-        label: labels.ATANH,
-        value: 'atanh',
-        type: 'function',
-        description: __('Hyperbolic arc tangent'),
-        exponent: null
-      },
-      LN: {
-        label: labels.LN,
-        value: 'ln',
-        type: 'function',
-        description: __('Natural logarithm'),
-        exponent: null
-      },
-      LOG: {
-        label: labels.LN,
-        value: 'log',
-        type: 'function',
-        description: __('Natural logarithm'),
-        exponent: null
-      },
-      LG: {
-        label: labels.LOG,
-        value: 'lg',
-        type: 'function',
-        description: __('Base-10 logarithm'),
-        exponent: null
-      },
-      LOG10: {
-        label: labels.LOG,
-        value: 'log10',
-        type: 'function',
-        description: __('Base-10 logarithm'),
-        exponent: null
-      },
-      ABS: {
-        label: labels.ABS,
-        value: 'abs',
-        type: 'function',
-        description: __('Absolute value'),
-        exponent: null
-      },
-      RAND: {
-        label: labels.RAND,
-        value: 'random',
-        type: 'function',
-        description: __('Random value'),
-        exponent: null
-      }
-    };
-
-    return terms;
-
-});

package/dist/maths/calculator/core/tokenizer.js

@@ -1,229 +0,0 @@
-define(['lodash', 'ui/maths/calculator/core/terms', 'ui/maths/calculator/core/tokens', 'lib/moo/moo'], function (_, registeredTerms, tokensHelper, moo) { 'use strict';
-
-    _ = _ && Object.prototype.hasOwnProperty.call(_, 'default') ? _['default'] : _;
-    registeredTerms = registeredTerms && Object.prototype.hasOwnProperty.call(registeredTerms, 'default') ? registeredTerms['default'] : registeredTerms;
-    tokensHelper = tokensHelper && Object.prototype.hasOwnProperty.call(tokensHelper, 'default') ? tokensHelper['default'] : tokensHelper;
-    moo = moo && Object.prototype.hasOwnProperty.call(moo, 'default') ? moo['default'] : moo;
-
-    /**
-     * This program is free software; you can redistribute it and/or
-     * modify it under the terms of the GNU General Public License
-     * as published by the Free Software Foundation; under version 2
-     * of the License (non-upgradable).
-     *
-     * This program is distributed in the hope that it will be useful,
-     * but WITHOUT ANY WARRANTY; without even the implied warranty of
-     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-     * GNU General Public License for more details.
-     *
-     * You should have received a copy of the GNU General Public License
-     * along with this program; if not, write to the Free Software
-     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-     *
-     * Copyright (c) 2018-2019 Open Assessment Technologies SA ;
-     */
-
-    /**
-     * List of ignored tokens
-     * @type {Object}
-     */
-    var ignoredTokens = {
-      SPACE: {
-        match: /\s+/,
-        lineBreaks: true
-      }
-    };
-
-    /**
-     * Match keywords
-     * @type {RegExp}
-     */
-    var reKeyword = /[a-zA-Z_]\w*/;
-
-    /**
-     * Match numbers
-     * @type {RegExp}
-     */
-    var reNumber = /[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?/;
-
-    /**
-     * Match keywords prefixed with @
-     * @type {RegExp}
-     */
-    var rePrefixedKeyword = new RegExp('@' + reKeyword.source);
-
-    /**
-     * Match keywords only
-     * @type {RegExp}
-     */
-    var reKeywordOnly = new RegExp('^' + reKeyword.source + '$');
-
-    /**
-     * List of keywords (functions from the list of registered terms).
-     * @type {Object}
-     */
-    var keywords = _.pick(registeredTerms, filterKeyword);
-
-    /**
-     * List of symbols (operators and operands from the list of registered terms).
-     * @type {Object}
-     */
-    var symbols = _.omit(registeredTerms, filterKeyword);
-
-    /**
-     * List of digits and related symbols
-     * @type {Object}
-     */
-    var digits = _.pick(registeredTerms, filterDigit);
-
-    /**
-     * Filter function that checks if the provided term is a keyword.
-     * Keywords are all terms that have alphanumeric non digit value from the list of terms.
-     * @param term
-     * @returns {boolean}
-     */
-    function filterKeyword(term) {
-      return term.value.match(reKeywordOnly);
-    }
-
-    /**
-     * Filter function that checks if the provided term is a digit or a related symbol.
-     * @param term
-     * @returns {boolean}
-     */
-    function filterDigit(term) {
-      return tokensHelper.isDigit(term.type) || term.value === '-' || term.value === '+';
-    }
-
-    /**
-     * @typedef {Object} token
-     * @property {String} type - The identifier of the token
-     * @property {String} value - The actual value of the token
-     * @property {String} text - The raw value that produced the token
-     * @property {Number} offset - The original offset in the source
-     * @property {Number} lineBreaks - How many line breaks are contained in the raw value
-     * @property {Number} line - The line number of the token (starting from 1)
-     * @property {Number} col - The column number of the token (starting from 1)
-     */
-
-    /**
-     * Generates an expression tokenizer.
-     *
-     * @example
-     *
-     * var expression = '(.1 + .2) * 10^8';
-     * var tokenizer = calculatorTokenizerFactory();
-     * var terms = tokenizer(expression);
-     *
-     * // terms now contains an array of terms:
-     * // [{type: "LPAR", value: "(", text: "(", offset: 0, lineBreaks: 0, line: 1, col: 1},
-     * //  {type: "DOT", value: ".", text: ".", offset: 1, lineBreaks: 0, line: 1, col: 2},
-     * //  {type: "NUM1", value: "1", text: "1", offset: 2, lineBreaks: 0, line: 1, col: 3},
-     * //  {type: "ADD", value: "+", text: "+", offset: 4, lineBreaks: 0, line: 1, col: 5},
-     * //  {type: "DOT", value: ".", text: ".", offset: 6, lineBreaks: 0, line: 1, col: 7},
-     * //  {type: "NUM2", value: "2", text: "2", offset: 7, lineBreaks: 0, line: 1, col: 8},
-     * //  {type: "RPAR", value: ")", text: ")", offset: 8, lineBreaks: 0, line: 1, col: 9},
-     * //  {type: "MUL", value: "*", text: "*", offset: 10, lineBreaks: 0, line: 1, col: 11},
-     * //  {type: "NUM1", value: "1", text: "1", offset: 12, lineBreaks: 0, line: 1, col: 13},
-     * //  {type: "NUM0", value: "0", text: "0", offset: 13, lineBreaks: 0, line: 1, col: 14},
-     * //  {type: "POW", value: "^", text: "^", offset: 14, lineBreaks: 0, line: 1, col: 15},
-     * //  {type: "NUM8", value: "8", text: "8", offset: 15, lineBreaks: 0, line: 1, col: 16}]
-     *
-     * @param {Object} [config]
-     * @param {Object} [config.keywords] - List of additional keywords: key being the name, value being the pattern (should be on the domain /[a-zA-Z]+/)
-     * @param {Object} [config.symbols] - List of additional symbols: key being the name, value being the pattern
-     * @returns {calculatorTokenizer}
-     */
-    function calculatorTokenizerFactory(config) {
-      var keywordsTransform, lexer, digitLexer, digitContext;
-
-      /**
-       * Extracts a token from the current position in the expression
-       * @returns {token}
-       */
-      var next = function next() {
-        var term;
-        if (digitContext) {
-          term = digitLexer.next();
-          if (term) {
-            term.offset += digitContext.offset;
-          }
-        }
-        if (!term) {
-          digitContext = null;
-          do {
-            term = lexer.next();
-          } while (term && ignoredTokens[term.type]);
-
-          // rely on a specific lexer to tokenize numbers
-          // this is required to properly identify numbers like 42e15 without colliding with regular identifiers
-          if (term && term.type === 'number') {
-            digitContext = term;
-            digitLexer.reset(term.value);
-            term = next();
-          }
-        }
-        return term;
-      };
-
-      /**
-       * @typedef {Object} calculatorTokenizer
-       */
-      var tokenizer = {
-        /**
-         * Gets an iterator that will returns tokens from the provided expression
-         * @param {String} expression
-         * @returns {function(): token}
-         */
-        iterator: function iterator(expression) {
-          lexer.reset(tokensHelper.stringValue(expression));
-          return next;
-        },
-        /**
-         * Tokenizes the expression
-         * @param {String} expression
-         * @returns {token[]}
-         */
-        tokenize: function tokenize(expression) {
-          var iterator = tokenizer.iterator(expression);
-          var terms = [];
-          var term;
-          do {
-            term = iterator();
-            if (term) {
-              terms.push(term);
-            }
-          } while (term);
-          return terms;
-        }
-      };
-      config = config || {};
-      config.keywords = _.defaults(_.mapValues(keywords, 'value'), config.keywords);
-      config.symbols = _.defaults(_.mapValues(symbols, 'value'), config.symbols);
-      keywordsTransform = moo.keywords(config.keywords);
-
-      // Lexer used to tokenize the expression
-      lexer = moo.compile(_.defaults({}, ignoredTokens, {
-        number: reNumber,
-        prefixed: {
-          match: rePrefixedKeyword,
-          type: function (token) {
-            // simply rely on the keywords transform to identify the prefixed keyword
-            return keywordsTransform(token.substring(1));
-          }
-        },
-        term: {
-          match: reKeyword,
-          type: keywordsTransform
-        },
-        syntaxError: moo.error
-      }, config.symbols));
-
-      // Lexer used to tokenize numbers
-      digitLexer = moo.compile(_.mapValues(digits, 'value'));
-      return tokenizer;
-    }
-
-    return calculatorTokenizerFactory;
-
-});