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

package/dist/validator/Report.js

@@ -1,10 +1,9 @@
 define(function () { 'use strict';
 
-    var Report = function Report(type, data) {
+    var Report = function (type, data) {
       this.type = type;
       this.data = data;
     };
-
     Report.prototype.isError = function () {
       return this.type === 'failure' || this.type === 'error';
     };

package/dist/validator/Validator.js

@@ -5,10 +5,9 @@ define(['lodash', 'async', 'ui/validator/Report', 'ui/validator/validators'], fu
     Report = Report && Object.prototype.hasOwnProperty.call(Report, 'default') ? Report['default'] : Report;
     validators = validators && Object.prototype.hasOwnProperty.call(validators, 'default') ? validators['default'] : validators;
 
-    var _buildRule = function _buildRule(rule) {
+    var _buildRule = function (rule) {
       var ret = null;
       var _rules = validators.validators;
-
       if (_.isString(rule) && _rules[rule]) {
         ret = _rules[rule];
       } else if (_.isObject(rule) && rule.name) {
@@ -18,49 +17,39 @@ define(['lodash', 'async', 'ui/validator/Report', 'ui/validator/validators'], fu
           ret = rule;
         }
       }
-
       return ret;
     };
-
     var _defaultOptions = {
       lazy: false
     };
-
-    var _applyRules = function _applyRules(value, rule, callback, options) {
+    var _applyRules = function (value, rule, callback, options) {
       options = _.merge(_.cloneDeep(rule.options), options);
       rule.validate(value, callback, options);
     };
-
-    var Validator = function Validator(rules, options) {
+    var Validator = function (rules, options) {
       this.options = _.merge(_.cloneDeep(_defaultOptions), options);
       this.rules = [];
       this.addRules(rules);
     };
-
     Validator.getDefaultOptions = function () {
       return _.clone(_defaultOptions);
     };
-
     Validator.prototype.validate = function (value, arg1, arg2) {
       var callstack = [],
-          callback,
-          options = _.cloneDeep(this.options);
-
+        callback,
+        options = _.cloneDeep(this.options);
       if (_.isFunction(arg1)) {
         callback = arg1;
       } else if (_.isObject(arg1)) {
         _.merge(options, arg1); //treat it like the options array:
-
-
         if (_.isFunction(arg2)) {
           callback = arg2;
         }
       }
-
       _.each(this.rules, function (rule) {
         //note: individual validating option reserved for a later usage:
         var validatorOptions = {},
-            message;
+          message;
         callstack.push(function (cb) {
           _applyRules(value, rule, function (success) {
             if (success) {
@@ -73,7 +62,6 @@ define(['lodash', 'async', 'ui/validator/Report', 'ui/validator/validators'], fu
                 validator: rule.name,
                 message: message
               });
-
               if (options.lazy) {
                 cb(new Error('lazy mode'), report); //stop execution now
               } else {
@@ -83,7 +71,6 @@ define(['lodash', 'async', 'ui/validator/Report', 'ui/validator/validators'], fu
           }, validatorOptions);
         });
       });
-
       async.series(callstack, function (err, results) {
         if (_.isFunction(callback)) {
           callback(results);
@@ -91,26 +78,20 @@ define(['lodash', 'async', 'ui/validator/Report', 'ui/validator/validators'], fu
       });
       return this;
     };
-
     Validator.prototype.addRule = function (rule) {
       var _rules = validators.validators;
-
       if (_.isString(rule) && _rules[rule]) {
         this.rules.push(_rules[rule]);
       } else if (rule = _buildRule(rule)) {
         this.rules.push(rule);
       }
-
       return this;
     };
-
     Validator.prototype.addRules = function (rules) {
       var _this = this;
-
       _.each(rules, function (rule) {
         _this.addRule(rule);
       });
-
       return this;
     };
 

package/dist/validator/validators.js

@@ -6,73 +6,69 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
     urlUtil = urlUtil && Object.prototype.hasOwnProperty.call(urlUtil, 'default') ? urlUtil['default'] : urlUtil;
     UrlParser = UrlParser && Object.prototype.hasOwnProperty.call(UrlParser, 'default') ? UrlParser['default'] : UrlParser;
 
-    /*
-     * 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) 2016-2019 (original work) Open Assessment Technologies SA;
-     *
-     */
-    /**
-     * Defines the validation callback
-     * @callback IsValidCallback
-     * @param {Boolean} isValid - whether the value is valid or not
+    /*
+     * 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) 2016-2019 (original work) Open Assessment Technologies SA;
+     *
      */
 
-    /**
-     * The function called by a validator to validate a value
-     * @callback Validate
-     * @param {String|Boolean|Number} value - the value to validate
-     * @param {IsValidCallback} callback - called with the validation result
-     * @param {Object} [options] - additional options
+    /**
+     * Defines the validation callback
+     * @callback IsValidCallback
+     * @param {Boolean} isValid - whether the value is valid or not
      */
 
-    /**
-     * Validate with a regex pattern
-     * @private
-     * @param {String|Boolean|Number} value - the value to validate
-     * @param {IsValidCallback} callback - called with the validation result
-     * @param {Object} [options] - additional options
-     * @param {String} [options.modifier] - pattern modifier
-     * @param {String} [options.pattern] - the pattern itself
+    /**
+     * The function called by a validator to validate a value
+     * @callback Validate
+     * @param {String|Boolean|Number} value - the value to validate
+     * @param {IsValidCallback} callback - called with the validation result
+     * @param {Object} [options] - additional options
      */
 
+    /**
+     * Validate with a regex pattern
+     * @private
+     * @param {String|Boolean|Number} value - the value to validate
+     * @param {IsValidCallback} callback - called with the validation result
+     * @param {Object} [options] - additional options
+     * @param {String} [options.modifier] - pattern modifier
+     * @param {String} [options.pattern] - the pattern itself
+     */
     var _validatePattern = function _validatePattern(value, callback, options) {
       var regex = new RegExp(options.pattern, options.modifier || ''),
-          match = value.match(regex),
-          r = match !== null;
-
+        match = value.match(regex),
+        r = match !== null;
       if (typeof callback === 'function') {
         callback.call(null, r);
       }
-
       return r;
     };
-    /**
-     * The current validators
-     */
-
 
+    /**
+     * The current validators
+     */
     var validators = {
       numeric: {
         name: 'numeric',
         message: __('The value of this field must be numeric'),
         options: {},
-        validate: function validate(value, callback) {
+        validate: function (value, callback) {
           var parsedValue = parseFloat(value),
-              r = parsedValue.toString() === value.toString() && _.isNumber(parsedValue) && !_.isNaN(parsedValue);
-
+            r = parsedValue.toString() === value.toString() && _.isNumber(parsedValue) && !_.isNaN(parsedValue);
           if (typeof callback === 'function') {
             callback.call(null, r);
           }
@@ -82,9 +78,8 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
         name: 'notEmpty',
         message: __('this is required'),
         options: {},
-        validate: function validate(value, callback) {
+        validate: function (value, callback) {
           var r;
-
           if (_.isNumber(value)) {
             r = true;
           } else {
@@ -112,9 +107,8 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
           min: 0,
           max: 0
         },
-        validate: function validate(value, callback, options) {
+        validate: function (value, callback, options) {
           var r = false;
-
           if (value.length >= options.min) {
             if (options.max) {
               r = value.length <= options.max;
@@ -122,7 +116,6 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
               r = true;
             }
           }
-
           if (typeof callback === 'function') {
             callback.call(null, r);
           }
@@ -140,11 +133,9 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
               callback(false);
               return;
             }
-
-            var parser = new UrlParser(value);
-            var protocol = parser.get('protocol');
-            var isHttp = protocol === 'http:' || protocol === 'https:';
-
+            const parser = new UrlParser(value);
+            const protocol = parser.get('protocol');
+            const isHttp = protocol === 'http:' || protocol === 'https:';
             if (!(urlUtil.isAbsolute(value) && isHttp) && !urlUtil.isBase64(value)) {
               //request HEAD only for bandwidth saving
               $.ajax({
@@ -152,10 +143,10 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
                 //FIXME change this to use an URL without transfomations. the validator should be called with the right URL,
                 //here it works only for the getFile service...
                 url: options.baseUrl + encodeURIComponent(value),
-                success: function success() {
+                success: function () {
                   callback(true);
                 },
-                error: function error(jqXHR, textStatus, errorThrown) {
+                error: function (jqXHR, textStatus, errorThrown) {
                   callback(false);
                 }
               });
@@ -169,10 +160,9 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
         name: 'validRegex',
         message: __('invalid regular expression'),
         options: {},
-        validate: function validate(value, callback) {
+        validate: function (value, callback) {
           if (typeof callback === 'function') {
             var valid = false;
-
             if (value !== '') {
               try {
                 new RegExp('^' + value + '$');
@@ -183,47 +173,43 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
             } else {
               valid = true;
             }
-
             callback(valid);
           }
         }
       }
     };
-    /**
-     * Register a new validator
-     * @param {String} [name] - the validator name
-     * @param {Object} validator - the validator
-     * @param {String} [validator.name] - the name if not used in first parameter
-     * @param {String} validator.message - the failure message
-     * @param {Function} validator.validate - the validator
-     * @param {Boolean} [force = false] - force to register the validator even if it is always registered
-     */
 
+    /**
+     * Register a new validator
+     * @param {String} [name] - the validator name
+     * @param {Object} validator - the validator
+     * @param {String} [validator.name] - the name if not used in first parameter
+     * @param {String} validator.message - the failure message
+     * @param {Function} validator.validate - the validator
+     * @param {Boolean} [force = false] - force to register the validator even if it is always registered
+     */
     var register = function registerValidator(name, validator, force) {
       if (_.isPlainObject(name) && name.name && !validator) {
         validator = name;
         name = validator.name;
       }
-
       if (!_.isString(name) || _.isEmpty(name)) {
         throw new Error('Please name your validator');
       }
-
       if (!_.isObject(validator) || !_.isString(validator.message) || !_.isFunction(validator.validate)) {
         throw new Error('A validator must be an object with a message and a validate method, but given : ' + JSON.stringify(validator));
-      } //do not override
-
+      }
 
+      //do not override
       if (!validators[name] || !!force) {
         validators[name] = validator;
       }
     };
-    /**
-     * Gives access to the validator and enable to register new validators
-     * @exports validator/validators
-     */
-
 
+    /**
+     * Gives access to the validator and enable to register new validators
+     * @exports validator/validators
+     */
     var validators$1 = {
       validators: validators,
       register: register