@oat-sa/tao-core-ui 1.57.0 → 1.58.2

package/dist/validator/Report.js

@@ -1,6 +1,6 @@
 define(function () { 'use strict';
 
-    var Report = function (type, data) {
+    var Report = function Report(type, data) {
       this.type = type;
       this.data = data;
     };

package/dist/validator/Validator.js

@@ -5,7 +5,7 @@ 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 (rule) {
+    var _buildRule = function _buildRule(rule) {
       var ret = null;
       var _rules = validators.validators;
 
@@ -26,12 +26,12 @@ define(['lodash', 'async', 'ui/validator/Report', 'ui/validator/validators'], fu
       lazy: false
     };
 
-    var _applyRules = function (value, rule, callback, options) {
+    var _applyRules = function _applyRules(value, rule, callback, options) {
       options = _.merge(_.cloneDeep(rule.options), options);
       rule.validate(value, callback, options);
     };
 
-    var Validator = function (rules, options) {
+    var Validator = function Validator(rules, options) {
       this.options = _.merge(_.cloneDeep(_defaultOptions), options);
       this.rules = [];
       this.addRules(rules);

package/dist/validator/validators.js

@@ -69,7 +69,7 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
         name: 'numeric',
         message: __('The value of this field must be numeric'),
         options: {},
-        validate: function (value, callback) {
+        validate: function validate(value, callback) {
           var parsedValue = parseFloat(value),
               r = parsedValue.toString() === value.toString() && _.isNumber(parsedValue) && !_.isNaN(parsedValue);
 
@@ -82,7 +82,7 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
         name: 'notEmpty',
         message: __('this is required'),
         options: {},
-        validate: function (value, callback) {
+        validate: function validate(value, callback) {
           var r;
 
           if (_.isNumber(value)) {
@@ -112,7 +112,7 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
           min: 0,
           max: 0
         },
-        validate: function (value, callback, options) {
+        validate: function validate(value, callback, options) {
           var r = false;
 
           if (value.length >= options.min) {
@@ -141,9 +141,9 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
               return;
             }
 
-            const parser = new UrlParser(value);
-            const protocol = parser.get('protocol');
-            const isHttp = protocol === 'http:' || protocol === 'https:';
+            var parser = new UrlParser(value);
+            var protocol = parser.get('protocol');
+            var isHttp = protocol === 'http:' || protocol === 'https:';
 
             if (!(urlUtil.isAbsolute(value) && isHttp) && !urlUtil.isBase64(value)) {
               //request HEAD only for bandwidth saving
@@ -152,10 +152,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: function success() {
                   callback(true);
                 },
-                error: function (jqXHR, textStatus, errorThrown) {
+                error: function error(jqXHR, textStatus, errorThrown) {
                   callback(false);
                 }
               });
@@ -169,7 +169,7 @@ define(['jquery', 'lodash', 'i18n', 'util/url', 'util/urlParser'], function ($,
         name: 'validRegex',
         message: __('invalid regular expression'),
         options: {},
-        validate: function (value, callback) {
+        validate: function validate(value, callback) {
           if (typeof callback === 'function') {
             var valid = false;
 

package/dist/validator.js

@@ -1,272 +1,282 @@
 define(['jquery', 'lodash', 'ui/validator/Report', 'ui/validator/Validator'], function ($, _, Report, Validator) { 'use strict';
 
-    $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
-    _ = _ && Object.prototype.hasOwnProperty.call(_, 'default') ? _['default'] : _;
-    Report = Report && Object.prototype.hasOwnProperty.call(Report, 'default') ? Report['default'] : Report;
-    Validator = Validator && Object.prototype.hasOwnProperty.call(Validator, 'default') ? Validator['default'] : Validator;
-
-    /**
-     * Validate the set of matched elements (inputs).
-     *
-     * @example $('input').validator() - validate with default options;
-     * @example $('input').validator(options) - validate with custom validation options;
-     * @example $('input').validator('validate', {allowEmpty:true}, callback) - validate with custom validation options and callback function;
-     * @exports validator/jquery.validator
-     * @param {Object|String} options - the validator options or method name to call
-     * @param {boolean} [options.allowEmpty = false] - whether the input can be empty
-     * @param {object} [options.validator]
-     * @param {boolean} [options.validator.lazy]
-     * @param {string|Array} [options.events] - event that triggers the validation
-     * @param {object} arg1 - the validator options
-     * @fires validated.group
-     * @returns {jQueryElement} for chaining
-     */
-
-    $.fn.validator = function (options, arg1, arg2) {
-      var opts = {},
-          method = '',
-          args = [],
-          ret;
-
-      if (typeof options === 'object') {
-        opts = $.extend({}, $.fn.validator.defaults, options);
-      } else if (options === undefined) {
-        opts = $.extend({}, $.fn.validator.defaults); //use default
-      } else if (typeof options === 'string') {
-        if (typeof methods[options] === 'function') {
-          method = options;
-          args = Array.prototype.slice.call(arguments, 1);
-        }
+  $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
+  _ = _ && Object.prototype.hasOwnProperty.call(_, 'default') ? _['default'] : _;
+  Report = Report && Object.prototype.hasOwnProperty.call(Report, 'default') ? Report['default'] : Report;
+  Validator = Validator && Object.prototype.hasOwnProperty.call(Validator, 'default') ? Validator['default'] : Validator;
+
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
+  }
+
+  /**
+   * Validate the set of matched elements (inputs).
+   *
+   * @example $('input').validator() - validate with default options;
+   * @example $('input').validator(options) - validate with custom validation options;
+   * @example $('input').validator('validate', {allowEmpty:true}, callback) - validate with custom validation options and callback function;
+   * @exports validator/jquery.validator
+   * @param {Object|String} options - the validator options or method name to call
+   * @param {boolean} [options.allowEmpty = false] - whether the input can be empty
+   * @param {object} [options.validator]
+   * @param {boolean} [options.validator.lazy]
+   * @param {string|Array} [options.events] - event that triggers the validation
+   * @param {object} arg1 - the validator options
+   * @fires validated.group
+   * @returns {jQueryElement} for chaining
+   */
+
+  $.fn.validator = function (options, arg1, arg2) {
+    var opts = {},
+        method = '',
+        args = [],
+        ret;
+
+    if (_typeof(options) === 'object') {
+      opts = $.extend({}, $.fn.validator.defaults, options);
+    } else if (options === undefined) {
+      opts = $.extend({}, $.fn.validator.defaults); //use default
+    } else if (typeof options === 'string') {
+      if (typeof methods[options] === 'function') {
+        method = options;
+        args = Array.prototype.slice.call(arguments, 1);
       }
+    }
 
-      this.each(function () {
-        var $this = $(this);
+    this.each(function () {
+      var $this = $(this);
 
-        if (!isCreated($this)) {
-          create($this, opts);
-        }
+      if (!isCreated($this)) {
+        create($this, opts);
+      }
 
-        if (method) {
-          if (isCreated($this)) {
-            ret = methods[method].apply($(this), args);
-          } else {
-            $.error('call of method of validator when it is not initialized');
-          }
+      if (method) {
+        if (isCreated($this)) {
+          ret = methods[method].apply($(this), args);
+        } else {
+          $.error('call of method of validator when it is not initialized');
         }
-      });
-      return ret === undefined ? this : ret;
-    };
-
-    $.fn.validator.defaults = {
-      allowEmpty: false,
-      validator: {
-        lazy: false
       }
-    };
-
-    function isCreated($elt) {
-      return typeof $elt.data('validator-config') === 'object';
+    });
+    return ret === undefined ? this : ret;
+  };
+
+  $.fn.validator.defaults = {
+    allowEmpty: false,
+    validator: {
+      lazy: false
     }
+  };
 
-    var methods = {
-      destroy: function () {
-        destroy($(this));
-      },
-      validate: function (arg1, arg2) {
-        var callback,
-            options = {}; //prepare args:
+  function isCreated($elt) {
+    return _typeof($elt.data('validator-config')) === 'object';
+  }
 
-        if (_.isFunction(arg1)) {
-          callback = arg1;
-        } else if (_.isObject(arg1)) {
-          _.merge(options, arg1); //treat it like the options array:
+  var methods = {
+    destroy: function destroy() {
+      _destroy($(this));
+    },
+    validate: function validate(arg1, arg2) {
+      var callback,
+          options = {}; //prepare args:
 
+      if (_.isFunction(arg1)) {
+        callback = arg1;
+      } else if (_.isObject(arg1)) {
+        _.merge(options, arg1); //treat it like the options array:
 
-          if (_.isFunction(arg2)) {
-            callback = arg2;
-          }
-        } //event the callback is optional, since we may set an event listener instead
 
+        if (_.isFunction(arg2)) {
+          callback = arg2;
+        }
+      } //event the callback is optional, since we may set an event listener instead
 
-        validate($(this), callback, options);
-      },
-      getValidator: function () {
-        return $(this).data('validator-instance');
-      }
-    };
-    /**
-     * rule must have been set in the following string format:
-     * $validatorName1; $validatorName2(optionName1=optionValue1, optionName2=optionValue2)
-     *
-     * example:
-     * $notEmpty; $pattern(pattern=[A-Z][a-z]{3,}, modifier=i);
-     *
-     * @param {type} $elt
-     * @returns {object}
-     */
-
-    var buildRules = function ($elt) {
-      var rulesStr = $elt.data('validate'),
-          rules = rulesStr ? tokenize(rulesStr) : {};
-      return rules;
-    };
 
-    var tokenize = function (inputStr) {
-      var ret = []; //return object
+      _validate($(this), callback, options);
+    },
+    getValidator: function getValidator() {
+      return $(this).data('validator-instance');
+    }
+  };
+  /**
+   * rule must have been set in the following string format:
+   * $validatorName1; $validatorName2(optionName1=optionValue1, optionName2=optionValue2)
+   *
+   * example:
+   * $notEmpty; $pattern(pattern=[A-Z][a-z]{3,}, modifier=i);
+   *
+   * @param {type} $elt
+   * @returns {object}
+   */
+
+  var buildRules = function buildRules($elt) {
+    var rulesStr = $elt.data('validate'),
+        rules = rulesStr ? tokenize(rulesStr) : {};
+    return rules;
+  };
+
+  var tokenize = function tokenize(inputStr) {
+    var ret = []; //return object
+
+    var tokens = inputStr.split(/;/); //get name (and options) for every rules strings:
+
+    _.each(tokens, function (token) {
+      token = $.trim(token);
+      var key,
+          options = {},
+          rightStr = token.replace(/\$(\w*)/, function ($0, k) {
+        key = k;
+        return '';
+      });
 
-      var tokens = inputStr.split(/;/); //get name (and options) for every rules strings:
+      if (key) {
+        //remove brackets
+        var optionsStr = rightStr.replace(/^\((.*)\)$/, '$1'); //get string options
 
-      _.each(tokens, function (token) {
-        token = $.trim(token);
-        var key,
-            options = {},
-            rightStr = token.replace(/\$(\w*)/, function ($0, k) {
-          key = k;
+        optionsStr = optionsStr.replace(/(\w+)=((\"(\\.|[^\"])*\")|(\'(\\.|[^\'])*\')),?/g, function ($0, optionName, optionValue) {
+          //replace quotes
+          optionValue = optionValue.replace(/^["'](.*)["']$/g, '$1');
+          options[optionName] = optionValue;
           return '';
         });
+        optionsStr.replace(/(\w*)=([^\s]*)(,)?/g, function ($0, optionName, optionValue) {
+          if (optionValue.charAt(optionValue.length - 1) === ',') {
+            optionValue = optionValue.substring(0, optionValue.length - 1);
+          }
 
-        if (key) {
-          //remove brackets
-          var optionsStr = rightStr.replace(/^\((.*)\)$/, '$1'); //get string options
-
-          optionsStr = optionsStr.replace(/(\w+)=((\"(\\.|[^\"])*\")|(\'(\\.|[^\'])*\')),?/g, function ($0, optionName, optionValue) {
-            //replace quotes
-            optionValue = optionValue.replace(/^["'](.*)["']$/g, '$1');
-            options[optionName] = optionValue;
-            return '';
-          });
-          optionsStr.replace(/(\w*)=([^\s]*)(,)?/g, function ($0, optionName, optionValue) {
-            if (optionValue.charAt(optionValue.length - 1) === ',') {
-              optionValue = optionValue.substring(0, optionValue.length - 1);
-            }
-
-            options[optionName] = optionValue;
-          });
-          ret.push({
-            name: key,
-            options: options
-          });
-        }
-      });
-
-      return ret;
-    };
-
-    var buildOptions = function ($elt) {
-      var optionsStr = $elt.data('validate-option'),
-          optionsArray = optionsStr ? tokenize(optionsStr) : {},
-          availableCoreValidatorOptions = _.keys(Validator.getDefaultOptions()),
-          options = _.clone($.fn.validator.defaults); //separate core.validator options from jquery.validator options
+          options[optionName] = optionValue;
+        });
+        ret.push({
+          name: key,
+          options: options
+        });
+      }
+    });
 
+    return ret;
+  };
 
-      _.each(optionsArray, function (optionArray) {
-        if (_.indexOf(availableCoreValidatorOptions, optionArray.name) >= 0) {
-          options.validator[optionArray.name] = optionArray.options;
-        } else {
-          options[optionArray.name] = optionArray.options;
-        }
-      });
+  var buildOptions = function buildOptions($elt) {
+    var optionsStr = $elt.data('validate-option'),
+        optionsArray = optionsStr ? tokenize(optionsStr) : {},
+        availableCoreValidatorOptions = _.keys(Validator.getDefaultOptions()),
+        options = _.clone($.fn.validator.defaults); //separate core.validator options from jquery.validator options
 
-      return options;
-    };
 
-    var create = function ($elt, options) {
-      if (isCreated($elt)) {
-        return;
+    _.each(optionsArray, function (optionArray) {
+      if (_.indexOf(availableCoreValidatorOptions, optionArray.name) >= 0) {
+        options.validator[optionArray.name] = optionArray.options;
+      } else {
+        options[optionArray.name] = optionArray.options;
       }
+    });
 
-      var rules = buildRules($elt);
+    return options;
+  };
 
-      if (options.rules) {
-        rules = _.merge(rules, options.rules);
-        delete options.rules;
-      }
+  var create = function create($elt, options) {
+    if (isCreated($elt)) {
+      return;
+    }
 
-      options = _.merge(options, buildOptions($elt) || {});
-      $elt.data('validator-config', _.clone(options));
-      createValidator($elt, rules, options);
-    };
+    var rules = buildRules($elt);
 
-    var destroy = function ($elts) {
-      $elts.removeData('validator-instance validator-config');
-      $elts.off('.validator');
-    };
+    if (options.rules) {
+      rules = _.merge(rules, options.rules);
+      delete options.rules;
+    }
 
-    var createValidator = function ($elt, rules, options) {
-      $elt.data('validator-instance', new Validator(rules, options.validator || {}));
+    options = _.merge(options, buildOptions($elt) || {});
+    $elt.data('validator-config', _.clone(options));
+    createValidator($elt, rules, options);
+  };
 
-      if (options.event) {
-        bindEvents($elt, options);
-      }
-    };
+  var _destroy = function _destroy($elts) {
+    $elts.removeData('validator-instance validator-config');
+    $elts.off('.validator');
+  };
 
-    var bindEvents = function ($elt, options) {
-      var events = _.isArray(options.event) ? options.event : [options.event];
+  var createValidator = function createValidator($elt, rules, options) {
+    $elt.data('validator-instance', new Validator(rules, options.validator || {}));
 
-      if (events.length > 0 && _.isFunction(options.validated)) {
-        _.forEach(events, function (event) {
-          if (_.isString(event)) {
-            event = {
-              type: event
-            };
-          }
+    if (options.event) {
+      bindEvents($elt, options);
+    }
+  };
 
-          switch (event.type) {
-            case 'keyup':
-            case 'keydown':
-              $elt.on(event.type, function () {
-                var v = $elt.val();
-
-                if (event.length) {
-                  if (v && v.length > event.length) {
-                    validate($elt, options.validated, {});
-                  }
-                } else {
-                  validate($elt, options.validated, {});
-                }
-              });
-              break;
-
-            case 'change':
-            case 'blur':
-              $elt.on(event.type, function () {
-                validate($elt, options.validated, {});
-              });
-              break;
-
-            default:
-              $.error('unknown event type to be bound to validation : ' + event.type);
-          }
-        });
-      }
-    };
+  var bindEvents = function bindEvents($elt, options) {
+    var events = _.isArray(options.event) ? options.event : [options.event];
 
-    var validate = function ($elt, callback, options) {
-      var value = $elt.val(),
-          defaults = $elt.data('validator-config'),
-          execCallback = function (results) {
-        var valid; //always trigger an event "validated" with associated results:
-
-        $elt.trigger('validated', {
-          elt: $elt[0],
-          results: results
-        }); //call the callback function is given:
-
-        if (_.isFunction(callback)) {
-          valid = _.where(results, {
-            type: 'failure'
-          }).length === 0;
-          callback.call($elt[0], valid, results);
+    if (events.length > 0 && _.isFunction(options.validated)) {
+      _.forEach(events, function (event) {
+        if (_.isString(event)) {
+          event = {
+            type: event
+          };
         }
-      };
 
-      if (defaults.allowEmpty && value === '') {
-        execCallback([new Report('success', {
-          validator: 'allowEmpty'
-        })]);
-      } else {
-        $elt.data('validator-instance').validate(value, options || {}, execCallback);
+        switch (event.type) {
+          case 'keyup':
+          case 'keydown':
+            $elt.on(event.type, function () {
+              var v = $elt.val();
+
+              if (event.length) {
+                if (v && v.length > event.length) {
+                  _validate($elt, options.validated, {});
+                }
+              } else {
+                _validate($elt, options.validated, {});
+              }
+            });
+            break;
+
+          case 'change':
+          case 'blur':
+            $elt.on(event.type, function () {
+              _validate($elt, options.validated, {});
+            });
+            break;
+
+          default:
+            $.error('unknown event type to be bound to validation : ' + event.type);
+        }
+      });
+    }
+  };
+
+  var _validate = function _validate($elt, callback, options) {
+    var value = $elt.val(),
+        defaults = $elt.data('validator-config'),
+        execCallback = function execCallback(results) {
+      var valid; //always trigger an event "validated" with associated results:
+
+      $elt.trigger('validated', {
+        elt: $elt[0],
+        results: results
+      }); //call the callback function is given:
+
+      if (_.isFunction(callback)) {
+        valid = _.where(results, {
+          type: 'failure'
+        }).length === 0;
+        callback.call($elt[0], valid, results);
       }
     };
 
+    if (defaults.allowEmpty && value === '') {
+      execCallback([new Report('success', {
+        validator: 'allowEmpty'
+      })]);
+    } else {
+      $elt.data('validator-instance').validate(value, options || {}, execCallback);
+    }
+  };
+
 });

package/dist/waitForMedia.js

@@ -56,7 +56,7 @@ define(['jquery'], function ($) { 'use strict';
         /**
          * The function to be executed whenever an image is considered loaded
          */
-        imageLoaded = function () {
+        imageLoaded = function imageLoaded() {
           $(this).trigger('loaded' + _ns).off('load' + _ns).off('error' + _ns);
           loaded++;
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@oat-sa/tao-core-ui",
-    "version": "1.57.0",
+    "version": "1.58.2",
     "displayName": "TAO Core UI",
     "description": "UI libraries of TAO",
     "scripts": {
@@ -44,14 +44,14 @@
     "devDependencies": {
         "@babel/core": "^7.15.5",
         "@babel/preset-env": "^7.15.6",
-        "@oat-sa/browserslist-config-tao": "^1.0.1",
+        "@oat-sa/browserslist-config-tao": "^0.3.1",
         "@oat-sa/eslint-config-tao": "^1.1.1",
         "@oat-sa/expr-eval": "^1.3.0",
         "@oat-sa/prettier-config": "^0.1.1",
         "@oat-sa/rollup-plugin-wildcard-external": "^0.1.0",
         "@oat-sa/tao-core-libs": "^0.4.4",
         "@oat-sa/tao-core-sdk": "^1.20.0",
-        "@oat-sa/tao-core-shared-libs": "^1.0.5",
+        "@oat-sa/tao-core-shared-libs": "^1.4.0",
         "@oat-sa/tao-qunit-testrunner": "^1.0.3",
         "async": "^0.2.10",
         "autoprefixer": "^9.5.1",