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

package/dist/maths/calculator/plugins/modifiers/pow10.js

@@ -5,71 +5,68 @@ define(['i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', 'ui/maths/c
     pluginFactory = pluginFactory && Object.prototype.hasOwnProperty.call(pluginFactory, 'default') ? pluginFactory['default'] : pluginFactory;
     tokensHelper = tokensHelper && Object.prototype.hasOwnProperty.call(tokensHelper, 'default') ? tokensHelper['default'] : tokensHelper;
 
-    /**
-     * 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) 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) 2019 Open Assessment Technologies SA ;
      */
     var pluginName = 'pow10';
-    /**
-     * The basic `10^x` expression.
-     * @type {String}
-     */
 
-    var termsPow10 = '10^';
-    /**
-     * The multiply by `10^x` expression.
-     * @type {String}
+    /**
+     * The basic `10^x` expression.
+     * @type {String}
      */
+    var termsPow10 = '10^';
 
+    /**
+     * The multiply by `10^x` expression.
+     * @type {String}
+     */
     var termsMulByPow10 = '*' + termsPow10;
     var pow10 = pluginFactory({
       name: pluginName,
-
-      /**
-       * Called when the plugin is installing in its host.
+      /**
+       * Called when the plugin is installing in its host.
        */
       install: function install() {
         this.getCalculator().setCommand('pow10', __('Power of 10'), __('Multiply the value by 10^x'));
       },
-
-      /**
-       * Called when the plugin should be initialized.
+      /**
+       * Called when the plugin should be initialized.
        */
       init: function init() {
         var calculator = this.getCalculator();
-        /**
-         * Checks if the expression contains a space before the current position
-         * @returns {Boolean}
-         */
 
+        /**
+         * Checks if the expression contains a space before the current position
+         * @returns {Boolean}
+         */
         function spaceBefore() {
           return calculator.getExpression().charAt(calculator.getPosition() - 1) === ' ';
         }
-        /**
-         * Checks if the token is considered as a separator
-         * @param {token} token
-         * @returns {Boolean}
-         */
-
 
+        /**
+         * Checks if the token is considered as a separator
+         * @param {token} token
+         * @returns {Boolean}
+         */
         function isSeparator(token) {
           return tokensHelper.isFunction(token) || tokensHelper.isSeparator(token) && token.type !== 'RPAR';
-        } // insert the sub-expression based on strategies
-
+        }
 
+        // insert the sub-expression based on strategies
         calculator.on(nsHelper.namespaceAll('command-pow10', pluginName), function () {
           var position = calculator.getPosition();
           var tokens = calculator.getTokens();
@@ -79,13 +76,11 @@ define(['i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', 'ui/maths/c
           var nextToken = tokens[index + 1] || null;
           var aligned = false;
           var expr = termsMulByPow10;
-
           if (token) {
             // refine the current position, as it should be either on the start or the end of the token:
             // "aligned" means the position is properly aligned with the token, said at the start of the value,
             // while not "aligned" means any other position inside the token
             aligned = token.offset === position;
-
             if (token.type === 'MUL') {
               if (aligned) {
                 // the "multiply" operator is a special case, as it is part of the complete expression,
@@ -101,12 +96,13 @@ define(['i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', 'ui/maths/c
                 aligned = true;
               }
             }
-          } // empty expression or 0, should be replaced by the shorter version
-
+          }
 
+          // empty expression or 0, should be replaced by the shorter version
           if (tokens.length <= 1 && !token || token.type === 'NUM0') {
             calculator.replace(termsPow10);
-          } // will insert expression at position:
+          }
+          // will insert expression at position:
           // - use the shorter version if there is no token before, or the previous one is either an operator
           //   or a function
           // - user the longer version in any other cases
@@ -116,20 +112,19 @@ define(['i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', 'ui/maths/c
                 expr = termsPow10;
               }
             } else if (isSeparator(token)) {
-              expr = termsPow10; // the expression may need a space before if the previous token is a function
+              expr = termsPow10;
 
+              // the expression may need a space before if the previous token is a function
               if (tokensHelper.isFunction(token) && !spaceBefore()) {
                 expr = ' ' + expr;
               }
             }
-
             calculator.insert(expr);
           }
         });
       },
-
-      /**
-       * Called when the plugin is destroyed. Mostly when the host is destroyed itself.
+      /**
+       * Called when the plugin is destroyed. Mostly when the host is destroyed itself.
        */
       destroy: function destroy() {
         this.getCalculator().deleteCommand('pow10').off('.' + pluginName);

package/dist/maths/calculator/plugins/modifiers/sign.js

@@ -7,56 +7,55 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
     tokensHelper = tokensHelper && Object.prototype.hasOwnProperty.call(tokensHelper, 'default') ? tokensHelper['default'] : tokensHelper;
     registeredTerms = registeredTerms && Object.prototype.hasOwnProperty.call(registeredTerms, 'default') ? registeredTerms['default'] : registeredTerms;
 
-    /**
-     * 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) 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) 2019 Open Assessment Technologies SA ;
      */
     var pluginName = 'sign';
-    /**
-     * List of tokens that refuse explicit positive sign
-     * @type {String[]}
-     */
 
-    var refuseExplicitPositive = ['LPAR', 'SUB', 'ADD', 'MUL', 'DIV', 'MOD', 'POW', 'ASSIGN'];
-    /**
-     * @typedef {Object} signChange
-     * @property {String} sign - The sign to insert
-     * @property {Number} offset - The offset where insert the sign
-     * @property {Number} length - The length of text to replace
-     * @property {Number} move - The move to apply on the current position
+    /**
+     * List of tokens that refuse explicit positive sign
+     * @type {String[]}
      */
+    var refuseExplicitPositive = ['LPAR', 'SUB', 'ADD', 'MUL', 'DIV', 'MOD', 'POW', 'ASSIGN'];
 
-    /**
-     * List of known strategies to apply on an expression in order to process sign change.
-     * Each strategy will return either `null` if cannot apply, or the descriptor of the change to apply.
-     * @type {Function[]}
+    /**
+     * @typedef {Object} signChange
+     * @property {String} sign - The sign to insert
+     * @property {Number} offset - The offset where insert the sign
+     * @property {Number} length - The length of text to replace
+     * @property {Number} move - The move to apply on the current position
      */
 
+    /**
+     * List of known strategies to apply on an expression in order to process sign change.
+     * Each strategy will return either `null` if cannot apply, or the descriptor of the change to apply.
+     * @type {Function[]}
+     */
     var strategies = [
-    /**
-     * Strategy that applies on numeric operands only
-     * @param {Number} index - The index of the current token
-     * @param {token[]} tokens - The list of tokens that represent the expression
-     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
+    /**
+     * Strategy that applies on numeric operands only
+     * @param {Number} index - The index of the current token
+     * @param {token[]} tokens - The list of tokens that represent the expression
+     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
      */
     function strategyNumeric(index, tokens) {
       var token = tokens[index] || null;
       var type = tokensHelper.getType(token);
       var result = null;
-
       if (tokensHelper.isDigit(type) && index >= 0) {
         // find the first token on the left of the operand
         while (index && tokensHelper.isDigit(type)) {
@@ -64,7 +63,6 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           token = tokens[index] || null;
           type = tokensHelper.getType(token);
         }
-
         if (tokensHelper.isDigit(type) && index === 0) {
           // the operand is the first of the expression, so the sign is implicit +, simply negate the value
           result = insertNegativeSign(token);
@@ -73,20 +71,18 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           result = applySignChange(index, tokens);
         }
       }
-
       return result;
     },
-    /**
-     * Strategy that applies on operators only
-     * @param {Number} index - The index of the current token
-     * @param {token[]} tokens - The list of tokens that represent the expression
-     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
+    /**
+     * Strategy that applies on operators only
+     * @param {Number} index - The index of the current token
+     * @param {token[]} tokens - The list of tokens that represent the expression
+     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
      */
     function strategyOperator(index, tokens) {
       var token = tokens[index] || null;
       var type = tokensHelper.getType(token);
       var result = null;
-
       if (tokensHelper.isOperator(type) && index >= 0) {
         if (token.type === 'SUB') {
           // the operator is -, simply replace it by +
@@ -99,20 +95,18 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           result = applyStrategies(index - 1, tokens);
         }
       }
-
       return result;
     },
-    /**
-     * Strategy that applies on identifiers only (constants, variables, functions)
-     * @param {Number} index - The index of the current token
-     * @param {token[]} tokens - The list of tokens that represent the expression
-     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
+    /**
+     * Strategy that applies on identifiers only (constants, variables, functions)
+     * @param {Number} index - The index of the current token
+     * @param {token[]} tokens - The list of tokens that represent the expression
+     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
      */
     function strategyIdentifier(index, tokens) {
       var token = tokens[index] || null;
       var type = tokensHelper.getType(token);
       var result = null;
-
       if (tokensHelper.isIdentifier(type) && index >= 0) {
         if (index === 0) {
           // the token is the first of the expression, so the sign is implicit +, simply negate the value
@@ -122,40 +116,35 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           result = applySignChange(index - 1, tokens);
         }
       }
-
       return result;
     },
-    /**
-     * Strategy that applies on sub-expression only
-     * @param {Number} index - The index of the current token
-     * @param {token[]} tokens - The list of tokens that represent the expression
-     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
+    /**
+     * Strategy that applies on sub-expression only
+     * @param {Number} index - The index of the current token
+     * @param {token[]} tokens - The list of tokens that represent the expression
+     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
      */
     function strategyExpression(index, tokens) {
       var token = tokens[index] || null;
       var type = tokensHelper.getType(token);
       var result = null;
       var count = 0;
-
       if (tokensHelper.isAggregator(type) && index >= 0) {
         if (token.type === 'RPAR') {
           count++;
-        } // find the opening parenthesis
-
+        }
 
+        // find the opening parenthesis
         while (index && (token.type !== 'LPAR' || count)) {
           index--;
           token = tokens[index] || null;
-
           if (token.type === 'RPAR') {
             count++;
           }
-
           if (token.type === 'LPAR') {
             count--;
           }
         }
-
         if (!count && token.type === 'LPAR') {
           if (index === 0) {
             // the token is the first of the expression, so the sign is implicit +, simply negate the value
@@ -166,40 +155,35 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           }
         }
       }
-
       return result;
     }];
-    /**
-     * Apply strategies to produce a sign change descriptor
-     * @param {Number} index - The index of the current token
-     * @param {token[]} tokens - The list of tokens that represent the expression
-     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
-     */
 
+    /**
+     * Apply strategies to produce a sign change descriptor
+     * @param {Number} index - The index of the current token
+     * @param {token[]} tokens - The list of tokens that represent the expression
+     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
+     */
     function applyStrategies(index, tokens) {
       var result = null;
-
       _.forEach(strategies, function (strategy) {
         result = strategy(index, tokens);
         return !result;
       });
-
       return result;
     }
-    /**
-     * Apply a sign change at the current index
-     * @param {Number} index - The index of the current token
-     * @param {token[]} tokens - The list of tokens that represent the expression
-     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
-     */
-
 
+    /**
+     * Apply a sign change at the current index
+     * @param {Number} index - The index of the current token
+     * @param {token[]} tokens - The list of tokens that represent the expression
+     * @returns {signChange|null} - The result of the strategy: `null` if cannot apply, or the descriptor of the change
+     */
     function applySignChange(index, tokens) {
       var token = tokens[index] || null;
       var nextToken = tokens[index + 1] || null;
       var type = tokensHelper.getType(token);
       var result = null;
-
       if (token) {
         if (tokensHelper.isOperator(type)) {
           // an operator precedes the operand
@@ -218,26 +202,23 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           result = insertNegativeSign(nextToken);
         }
       }
-
       return result;
     }
-    /**
-     * Checks if a token accept an explicit positive sign on the right
-     * @param {Object} token
-     * @returns {Boolean}
-     */
-
 
+    /**
+     * Checks if a token accept an explicit positive sign on the right
+     * @param {Object} token
+     * @returns {Boolean}
+     */
     function acceptExplicitPositive(token) {
       return !token || refuseExplicitPositive.indexOf(token.type) === -1 && !tokensHelper.isFunction(tokensHelper.getType(token));
     }
-    /**
-     * Produces a descriptor to insert a negative sign
-     * @param {token} token
-     * @returns {signChange}
-     */
-
 
+    /**
+     * Produces a descriptor to insert a negative sign
+     * @param {token} token
+     * @returns {signChange}
+     */
     function insertNegativeSign(token) {
       return {
         offset: token.offset,
@@ -246,13 +227,12 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
         move: registeredTerms.SUB.value.length
       };
     }
-    /**
-     * Produces a descriptor to replace a sign by a negative sign
-     * @param {token} token
-     * @returns {signChange}
-     */
-
 
+    /**
+     * Produces a descriptor to replace a sign by a negative sign
+     * @param {token} token
+     * @returns {signChange}
+     */
     function replaceByNegativeSign(token) {
       return {
         offset: token.offset,
@@ -261,15 +241,14 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
         move: registeredTerms.SUB.value.length - token.value.length
       };
     }
-    /**
-     * Produces a descriptor to replace a sign by a positive sign
-     * @param {token} token
-     * @param {Number} index
-     * @param {token[]} tokens
-     * @returns {signChange}
-     */
-
 
+    /**
+     * Produces a descriptor to replace a sign by a positive sign
+     * @param {token} token
+     * @param {Number} index
+     * @param {token[]} tokens
+     * @returns {signChange}
+     */
     function replaceByPositiveSign(token, index, tokens) {
       var allowExplicit = index && acceptExplicitPositive(tokens[index - 1]);
       return {
@@ -279,46 +258,41 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
         move: (allowExplicit ? registeredTerms.ADD.value.length : 0) - token.value.length
       };
     }
-    /**
-     * Replaces text at position
-     * @param {String} str - The string in which apply the replacement
-     * @param {Number} index - The index from which applying the replacement
-     * @param {Number} length - The length of the string to replace
-     * @param {String} sub - The replacement string
-     * @returns {String}
-     */
-
 
+    /**
+     * Replaces text at position
+     * @param {String} str - The string in which apply the replacement
+     * @param {Number} index - The index from which applying the replacement
+     * @param {Number} length - The length of the string to replace
+     * @param {String} sub - The replacement string
+     * @returns {String}
+     */
     function splice(str, index, length, sub) {
       return str.substring(0, index) + sub + str.substring(index + length);
     }
-
     var sign = pluginFactory({
       name: pluginName,
-
-      /**
-       * Called when the plugin is installing in its host.
+      /**
+       * Called when the plugin is installing in its host.
        */
       install: function install() {
         var calculator = this.getCalculator();
         calculator.setCommand('sign', __('Sign change'), __('Change the sign of the current operand'));
       },
-
-      /**
-       * Called when the plugin should be initialized.
+      /**
+       * Called when the plugin should be initialized.
        */
       init: function init() {
-        var calculator = this.getCalculator(); // applies a sign change based on strategies
+        var calculator = this.getCalculator();
 
+        // applies a sign change based on strategies
         calculator.on(nsHelper.namespaceAll('command-sign', pluginName), function () {
           var tokens = calculator.getTokens();
           var index = calculator.getTokenIndex();
           var expression = calculator.getExpression();
           var result;
-
           if (expression !== '0') {
             result = applyStrategies(index, tokens);
-
             if (result) {
               expression = splice(expression, result.offset, result.length, result.sign);
               calculator.replace(expression, calculator.getPosition() + result.move);
@@ -326,9 +300,8 @@ define(['lodash', 'i18n', 'util/namespace', 'ui/maths/calculator/core/plugin', '
           }
         });
       },
-
-      /**
-       * Called when the plugin is destroyed. Mostly when the host is destroyed itself.
+      /**
+       * Called when the plugin is destroyed. Mostly when the host is destroyed itself.
        */
       destroy: function destroy() {
         var calculator = this.getCalculator();