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

package/src/maths/calculator/plugins/core/stepNavigation.js

@@ -1,175 +0,0 @@
-/**
- * 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 Open Assessment Technologies SA ;
- */
-/**
- * Plugin that manages a navigation by tokens within the current expression
- * @author Jean-Sébastien Conan <jean-sebastien@taotesting.com>
- */
-
-import __ from 'i18n';
-import nsHelper from 'util/namespace';
-import pluginFactory from 'ui/maths/calculator/core/plugin';
-
-var pluginName = 'stepNavigation';
-
-export default pluginFactory({
-    name: pluginName,
-
-    /**
-     * Called when the plugin is installing in its host.
-     */
-    install: function install() {
-        var calculator = this.getCalculator();
-
-        calculator
-            .setCommand('stepMoveLeft', __('Move Left'), __('Move the cursor one step on the left'))
-            .setCommand('stepMoveRight', __('Move Right'), __('Move the cursor one step on the right'))
-            .setCommand('stepDeleteLeft', __('Delete Left'), __('Delete the term on the left side of the cursor'))
-            .setCommand('stepDeleteRight', __('Delete Right'), __('Delete the term on the right side of the cursor'));
-    },
-
-    /**
-     * Called when the plugin should be initialized.
-     */
-    init: function init() {
-        var calculator = this.getCalculator();
-
-        /**
-         * Remove a sub-expresion from the expression
-         * @param expression
-         * @param position
-         * @param length
-         */
-        function remove(expression, position, length) {
-            if (length) {
-                expression = calculator.getExpression();
-                calculator
-                    .setExpression(expression.substr(0, position) + expression.substr(position + length))
-                    .setPosition(position);
-            }
-        }
-
-        /**
-         * Remove a token from the expression
-         * @param expression
-         * @param token
-         */
-        function removeToken(expression, token) {
-            var from, length;
-            if (token) {
-                expression = calculator.getExpression();
-                from = token.offset;
-                length = token.value.length;
-                while (from + length < expression.length && expression.charAt(from + length) === ' ') {
-                    length++;
-                }
-
-                remove(expression, from, length);
-            }
-        }
-
-        calculator
-            .on(nsHelper.namespaceAll('command-stepMoveLeft', pluginName), function() {
-                var position = calculator.getPosition();
-                var tokens = calculator.getTokens();
-                var index = calculator.getTokenIndex();
-                var token = calculator.getToken();
-                var offset = position;
-
-                if (token && position > 0) {
-                    if (position === token.offset) {
-                        if (index > 0) {
-                            token = tokens[index - 1];
-                        } else {
-                            token = null;
-                        }
-                    }
-                } else {
-                    token = null;
-                }
-                if (token) {
-                    offset = token.offset;
-                } else {
-                    offset = 0;
-                }
-
-                if (offset !== position) {
-                    calculator.setPosition(offset);
-                }
-            })
-            .on(nsHelper.namespaceAll('command-stepMoveRight', pluginName), function() {
-                var expression = calculator.getExpression();
-                var position = calculator.getPosition();
-                var tokens = calculator.getTokens();
-                var index = calculator.getTokenIndex();
-                var token = calculator.getToken();
-                var offset = expression.length;
-
-                if (token && index < tokens.length - 1) {
-                    token = tokens[index + 1];
-                    if (token) {
-                        offset = token.offset;
-                    }
-                }
-
-                if (offset !== position) {
-                    calculator.setPosition(offset);
-                }
-            })
-            .on(nsHelper.namespaceAll('command-stepDeleteLeft', pluginName), function() {
-                var expression = calculator.getExpression();
-                var position = calculator.getPosition();
-                var tokens = calculator.getTokens();
-                var index = calculator.getTokenIndex();
-                var token = calculator.getToken();
-
-                if (token) {
-                    if (position > token.offset) {
-                        removeToken(expression, token);
-                    } else {
-                        if (index > 0) {
-                            removeToken(expression, tokens[index - 1]);
-                        } else if (position > 0) {
-                            remove(expression, 0, token.offset);
-                        }
-                    }
-                }
-            })
-            .on(nsHelper.namespaceAll('command-stepDeleteRight', pluginName), function() {
-                var expression = calculator.getExpression();
-                var position = calculator.getPosition();
-                var token = calculator.getToken();
-
-                if (token && position >= token.offset && position < token.offset + token.value.length) {
-                    removeToken(expression, token);
-                }
-            });
-    },
-
-    /**
-     * Called when the plugin is destroyed. Mostly when the host is destroyed itself.
-     */
-    destroy: function destroy() {
-        var calculator = this.getCalculator();
-        calculator
-            .deleteCommand('stepMoveLeft')
-            .deleteCommand('stepMoveRight')
-            .deleteCommand('stepDeleteLeft')
-            .deleteCommand('stepDeleteRight')
-            .off('.' + pluginName);
-    }
-});

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

@@ -1,143 +0,0 @@
-/**
- * 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 ;
- */
-/**
- * Plugin that multiplies the current operand by 10^x.
- * @author Jean-Sébastien Conan <jean-sebastien@taotesting.com>
- */
-
-import __ from 'i18n';
-import nsHelper from 'util/namespace';
-import pluginFactory from 'ui/maths/calculator/core/plugin';
-import tokensHelper from 'ui/maths/calculator/core/tokens';
-
-var pluginName = 'pow10';
-
-/**
- * The basic `10^x` expression.
- * @type {String}
- */
-var termsPow10 = '10^';
-
-/**
- * The multiply by `10^x` expression.
- * @type {String}
- */
-var termsMulByPow10 = '*' + termsPow10;
-
-export default pluginFactory({
-    name: pluginName,
-
-    /**
-     * 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.
-     */
-    init: function init() {
-        var calculator = this.getCalculator();
-
-        /**
-         * 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}
-         */
-        function isSeparator(token) {
-            return tokensHelper.isFunction(token) || (tokensHelper.isSeparator(token) && token.type !== 'RPAR');
-        }
-
-        // insert the sub-expression based on strategies
-        calculator.on(nsHelper.namespaceAll('command-pow10', pluginName), function() {
-            var position = calculator.getPosition();
-            var tokens = calculator.getTokens();
-            var index = calculator.getTokenIndex();
-            var token = tokens[index] || null;
-            var prevToken = tokens[index - 1] || null;
-            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,
-                        // so if it is already there, we consider to use it, and move the position just after
-                        calculator.setPosition(position + token.value.length);
-                        aligned = false;
-                    }
-                } else if (!aligned) {
-                    // the strategy is to consider the position is in front of the token,
-                    // the allowed exception is when the position is the last one
-                    if (nextToken || position < token.offset + token.value.length) {
-                        calculator.setPosition(token.offset);
-                        aligned = true;
-                    }
-                }
-            }
-
-            // 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:
-            // - 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
-            else {
-                if (aligned) {
-                    if (index === 0 || isSeparator(prevToken)) {
-                        expr = termsPow10;
-                    }
-                } else if (isSeparator(token)) {
-                    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.
-     */
-    destroy: function destroy() {
-        this.getCalculator()
-            .deleteCommand('pow10')
-            .off('.' + pluginName);
-    }
-});

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

@@ -1,339 +0,0 @@
-/**
- * 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 ;
- */
-/**
- * Plugin that allows to change the sign of the current operand
- * @author Jean-Sébastien Conan <jean-sebastien@taotesting.com>
- */
-import _ from 'lodash';
-import __ from 'i18n';
-import nsHelper from 'util/namespace';
-import pluginFactory from 'ui/maths/calculator/core/plugin';
-import tokensHelper from 'ui/maths/calculator/core/tokens';
-import registeredTerms from 'ui/maths/calculator/core/terms';
-
-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 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
-     */
-    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)) {
-                index--;
-                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);
-            } else {
-                // the operand is preceded by something else
-                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
-     */
-    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 +
-                result = replaceByPositiveSign(token, index, tokens);
-            } else if (token.type === 'ADD') {
-                // the operator is +, simply replace it by -
-                result = replaceByNegativeSign(token);
-            } else if (token.type === 'FAC' && index > 0) {
-                // the operator is !, need to identify the operand
-                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
-     */
-    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
-                result = insertNegativeSign(token);
-            } else {
-                // the token is preceded by something else
-                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
-     */
-    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
-            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
-                    result = insertNegativeSign(token);
-                } else {
-                    // the token is preceded by something else
-                    result = applySignChange(index - 1, tokens);
-                }
-            }
-        }
-
-        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
- */
-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
- */
-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
-            if (token.type === 'SUB') {
-                // the operator is -, simply replace it by +
-                result = replaceByPositiveSign(token, index, tokens);
-            } else if (token.type === 'ADD') {
-                // the operator is +, simply replace it by -
-                result = replaceByNegativeSign(token);
-            } else if (nextToken) {
-                // the operator is not + or -, simply negate the value
-                result = insertNegativeSign(nextToken);
-            }
-        } else if (nextToken && (tokensHelper.isFunction(type) || token.type === 'LPAR')) {
-            // a function or a left parenthesis precedes the operand, simply negate the operand
-            result = insertNegativeSign(nextToken);
-        }
-    }
-
-    return result;
-}
-
-/**
- * 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}
- */
-function insertNegativeSign(token) {
-    return {
-        offset: token.offset,
-        length: 0,
-        sign: registeredTerms.SUB.value,
-        move: registeredTerms.SUB.value.length
-    };
-}
-
-/**
- * Produces a descriptor to replace a sign by a negative sign
- * @param {token} token
- * @returns {signChange}
- */
-function replaceByNegativeSign(token) {
-    return {
-        offset: token.offset,
-        length: token.value.length,
-        sign: registeredTerms.SUB.value,
-        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}
- */
-function replaceByPositiveSign(token, index, tokens) {
-    var allowExplicit = index && acceptExplicitPositive(tokens[index - 1]);
-    return {
-        offset: token.offset,
-        length: token.value.length,
-        sign: allowExplicit ? registeredTerms.ADD.value : '',
-        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}
- */
-function splice(str, index, length, sub) {
-    return str.substring(0, index) + sub + str.substring(index + length);
-}
-
-export default pluginFactory({
-    name: pluginName,
-
-    /**
-     * 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.
-     */
-    init: function init() {
-        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);
-                }
-            }
-        });
-    },
-
-    /**
-     * Called when the plugin is destroyed. Mostly when the host is destroyed itself.
-     */
-    destroy: function destroy() {
-        var calculator = this.getCalculator();
-        calculator.deleteCommand('sign').off('.' + pluginName);
-    }
-});