@oat-sa/tao-core-ui 1.60.2 → 1.61.0

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

@@ -5,26 +5,26 @@ define(['lodash', 'ui/maths/calculator/core/terms', 'ui/maths/calculator/core/to
     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 ;
+    /**
+     * 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}
+    /**
+     * List of ignored tokens
+     * @type {Object}
      */
 
     var ignoredTokens = {
@@ -33,117 +33,117 @@ define(['lodash', 'ui/maths/calculator/core/terms', 'ui/maths/calculator/core/to
         lineBreaks: true
       }
     };
-    /**
-     * Match keywords
-     * @type {RegExp}
+    /**
+     * Match keywords
+     * @type {RegExp}
      */
 
     var reKeyword = /[a-zA-Z_]\w*/;
-    /**
-     * Match numbers
-     * @type {RegExp}
+    /**
+     * Match numbers
+     * @type {RegExp}
      */
 
     var reNumber = /[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?/;
-    /**
-     * Match keywords prefixed with @
-     * @type {RegExp}
+    /**
+     * Match keywords prefixed with @
+     * @type {RegExp}
      */
 
     var rePrefixedKeyword = new RegExp('@' + reKeyword.source);
-    /**
-     * Match keywords only
-     * @type {RegExp}
+    /**
+     * Match keywords only
+     * @type {RegExp}
      */
 
     var reKeywordOnly = new RegExp('^' + reKeyword.source + '$');
-    /**
-     * List of keywords (functions from the list of registered terms).
-     * @type {Object}
+    /**
+     * 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}
+    /**
+     * 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}
+    /**
+     * 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}
+    /**
+     * 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}
+    /**
+     * 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)
+    /**
+     * @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}
+    /**
+     * 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}
+      /**
+       * Extracts a token from the current position in the expression
+       * @returns {token}
        */
 
       var next = function next() {
@@ -175,26 +175,26 @@ define(['lodash', 'ui/maths/calculator/core/terms', 'ui/maths/calculator/core/to
 
         return term;
       };
-      /**
-       * @typedef {Object} calculatorTokenizer
+      /**
+       * @typedef {Object} calculatorTokenizer
        */
 
 
       var tokenizer = {
-        /**
-         * Gets an iterator that will returns tokens from the provided expression
-         * @param {String} expression
-         * @returns {function(): token}
+        /**
+         * 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[]}
+        /**
+         * Tokenizes the expression
+         * @param {String} expression
+         * @returns {token[]}
          */
         tokenize: function tokenize(expression) {
           var iterator = tokenizer.iterator(expression);

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

@@ -12,16 +12,16 @@ define(['ui/maths/calculator/core/terms'], function (registeredTerms) { 'use str
     }, _typeof(obj);
   }
 
-  /**
-   * List of helpers that apply on tokens
-   * @type {Object}
+  /**
+   * List of helpers that apply on tokens
+   * @type {Object}
    */
 
   var tokensHelper = {
-    /**
-     * Identifies the type of a given token
-     * @param {String|Object} token
-     * @returns {String|null}
+    /**
+     * Identifies the type of a given token
+     * @param {String|Object} token
+     * @returns {String|null}
      */
     getType: function getType(token) {
       var type, term;
@@ -35,124 +35,124 @@ define(['ui/maths/calculator/core/terms'], function (registeredTerms) { 'use str
       return token;
     },
 
-    /**
-     * Checks if the type is related to a digit value
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to a digit value
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isDigit: function isDigit(type) {
       return tokensHelper.getType(type) === 'digit';
     },
 
-    /**
-     * Checks if the type is related to an operator
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to an operator
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isOperator: function isOperator(type) {
       return tokensHelper.getType(type) === 'operator';
     },
 
-    /**
-     * Checks if the type is related to an operand
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to an operand
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isOperand: function isOperand(type) {
       type = tokensHelper.getType(type);
       return type !== 'operator' && type !== 'aggregator' && type !== 'separator';
     },
 
-    /**
-     * Checks if the type is related to an operand
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to an operand
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isValue: function isValue(type) {
       type = tokensHelper.getType(type);
       return type === 'digit' || type === 'constant' || type === 'variable' || type === 'term' || type === 'error';
     },
 
-    /**
-     * Checks if the type is related to an aggregator
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to an aggregator
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isAggregator: function isAggregator(type) {
       return tokensHelper.getType(type) === 'aggregator';
     },
 
-    /**
-     * Checks if the type is related to an error
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to an error
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isError: function isError(type) {
       return tokensHelper.getType(type) === 'error';
     },
 
-    /**
-     * Checks if the type is related to a constant
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to a constant
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isConstant: function isConstant(type) {
       return tokensHelper.getType(type) === 'constant';
     },
 
-    /**
-     * Checks if the type is related to a variable
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to a variable
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isVariable: function isVariable(type) {
       type = tokensHelper.getType(type);
       return type === 'variable' || type === 'term';
     },
 
-    /**
-     * Checks if the type is related to a function
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to a function
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isFunction: function isFunction(type) {
       return tokensHelper.getType(type) === 'function';
     },
 
-    /**
-     * Checks if the type is related to an identifier
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to an identifier
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isIdentifier: function isIdentifier(type) {
       type = tokensHelper.getType(type);
       return type === 'constant' || type === 'variable' || type === 'term' || type === 'function' || type === 'error';
     },
 
-    /**
-     * Checks if the type is related to a separator
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to a separator
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isSeparator: function isSeparator(type) {
       type = tokensHelper.getType(type);
       return type === 'operator' || type === 'aggregator' || type === 'separator';
     },
 
-    /**
-     * Checks if the type is related to a modifier
-     * @param {String|Object} type
-     * @returns {Boolean}
+    /**
+     * Checks if the type is related to a modifier
+     * @param {String|Object} type
+     * @returns {Boolean}
      */
     isModifier: function isModifier(type) {
       type = tokensHelper.getType(type);
       return type === 'operator' || type === 'function';
     },
 
-    /**
-     * Ensures an expression is a string. If a token or a descriptor is provided, extract the value.
-     * @param {String|Number|Object} expression
-     * @returns {String}
+    /**
+     * Ensures an expression is a string. If a token or a descriptor is provided, extract the value.
+     * @param {String|Number|Object} expression
+     * @returns {String}
      */
     stringValue: function stringValue(expression) {
       var type = _typeof(expression);

package/dist/maths/calculator/css/calculator.css

@@ -1,10 +1,10 @@
 /* Style for the calculator component */
-/*
-Usage:
-- linear-gradient((color1, color2, color3)) - returns linear-gradient with evenly distributed colors,
-   if 3 colors used then the position of each will be 33,33%
-- linear-gradient((color1 0%, color2 30%, color3 80%)) - returns linear-gradient with manually distributed colors,
-   first param - color, second - position. Also you can use px or other valid units for set position.
+/*
+Usage:
+- linear-gradient((color1, color2, color3)) - returns linear-gradient with evenly distributed colors,
+   if 3 colors used then the position of each will be 33,33%
+- linear-gradient((color1 0%, color2 30%, color3 80%)) - returns linear-gradient with manually distributed colors,
+   first param - color, second - position. Also you can use px or other valid units for set position.
 */
 /* based on "visually-hidden" mixin in LDS for accessibility goals */
 /* Do not edit */
@@ -365,5 +365,5 @@ Usage:
 .calculator.error .screen .expression {
     background: #f1d0d5;
 }
-
+
 /*# sourceMappingURL=calculator.css.map */