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

package/dist/validator.js

@@ -1,282 +1,246 @@
 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;
-
-  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 = {},
+    $ = $ && 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);
-      }
-    }
-
-    this.each(function () {
-      var $this = $(this);
-
-      if (!isCreated($this)) {
-        create($this, opts);
+      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);
+        }
       }
-
-      if (method) {
-        if (isCreated($this)) {
-          ret = methods[method].apply($(this), args);
-        } else {
-          $.error('call of method of validator when it is not initialized');
+      this.each(function () {
+        var $this = $(this);
+        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');
+          }
         }
+      });
+      return ret === undefined ? this : ret;
+    };
+    $.fn.validator.defaults = {
+      allowEmpty: false,
+      validator: {
+        lazy: false
       }
-    });
-    return ret === undefined ? this : ret;
-  };
-
-  $.fn.validator.defaults = {
-    allowEmpty: false,
-    validator: {
-      lazy: false
+    };
+    function isCreated($elt) {
+      return typeof $elt.data('validator-config') === 'object';
     }
-  };
-
-  function isCreated($elt) {
-    return _typeof($elt.data('validator-config')) === 'object';
-  }
-
-  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;
+    var methods = {
+      destroy: function () {
+        destroy($(this));
+      },
+      validate: function (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
-
 
-      _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}
-   */
+        //event the callback is optional, since we may set an event listener instead
+        validate($(this), callback, options);
+      },
+      getValidator: function () {
+        return $(this).data('validator-instance');
+      }
+    };
 
-  var buildRules = function buildRules($elt) {
-    var rulesStr = $elt.data('validate'),
+    /**
+     * 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 tokenize(inputStr) {
-    var ret = []; //return object
+      return rules;
+    };
+    var tokenize = function (inputStr) {
+      var ret = []; //return object
 
-    var tokens = inputStr.split(/;/); //get name (and options) for every rules strings:
+      var tokens = inputStr.split(/;/);
 
-    _.each(tokens, function (token) {
-      token = $.trim(token);
-      var key,
+      //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 '';
+            key = k;
+            return '';
+          });
+        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
+          });
+        }
       });
-
-      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 buildOptions($elt) {
-    var optionsStr = $elt.data('validate-option'),
+      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 = _.clone($.fn.validator.defaults);
 
-    _.each(optionsArray, function (optionArray) {
-      if (_.indexOf(availableCoreValidatorOptions, optionArray.name) >= 0) {
-        options.validator[optionArray.name] = optionArray.options;
-      } else {
-        options[optionArray.name] = optionArray.options;
-      }
-    });
-
-    return options;
-  };
-
-  var create = function create($elt, options) {
-    if (isCreated($elt)) {
-      return;
-    }
-
-    var rules = buildRules($elt);
-
-    if (options.rules) {
-      rules = _.merge(rules, options.rules);
-      delete options.rules;
-    }
-
-    options = _.merge(options, buildOptions($elt) || {});
-    $elt.data('validator-config', _.clone(options));
-    createValidator($elt, rules, options);
-  };
-
-  var _destroy = function _destroy($elts) {
-    $elts.removeData('validator-instance validator-config');
-    $elts.off('.validator');
-  };
-
-  var createValidator = function createValidator($elt, rules, options) {
-    $elt.data('validator-instance', new Validator(rules, options.validator || {}));
-
-    if (options.event) {
-      bindEvents($elt, options);
-    }
-  };
-
-  var bindEvents = function bindEvents($elt, options) {
-    var events = _.isArray(options.event) ? options.event : [options.event];
-
-    if (events.length > 0 && _.isFunction(options.validated)) {
-      _.forEach(events, function (event) {
-        if (_.isString(event)) {
-          event = {
-            type: event
-          };
-        }
-
-        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);
+      //separate core.validator options from jquery.validator options
+      _.each(optionsArray, function (optionArray) {
+        if (_.indexOf(availableCoreValidatorOptions, optionArray.name) >= 0) {
+          options.validator[optionArray.name] = optionArray.options;
+        } else {
+          options[optionArray.name] = optionArray.options;
         }
       });
-    }
-  };
-
-  var _validate = function _validate($elt, callback, options) {
-    var value = $elt.val(),
+      return options;
+    };
+    var create = function ($elt, options) {
+      if (isCreated($elt)) {
+        return;
+      }
+      var rules = buildRules($elt);
+      if (options.rules) {
+        rules = _.merge(rules, options.rules);
+        delete options.rules;
+      }
+      options = _.merge(options, buildOptions($elt) || {});
+      $elt.data('validator-config', _.clone(options));
+      createValidator($elt, rules, options);
+    };
+    var destroy = function ($elts) {
+      $elts.removeData('validator-instance validator-config');
+      $elts.off('.validator');
+    };
+    var createValidator = function ($elt, rules, options) {
+      $elt.data('validator-instance', new Validator(rules, options.validator || {}));
+      if (options.event) {
+        bindEvents($elt, options);
+      }
+    };
+    var bindEvents = function ($elt, options) {
+      var events = _.isArray(options.event) ? options.event : [options.event];
+      if (events.length > 0 && _.isFunction(options.validated)) {
+        _.forEach(events, function (event) {
+          if (_.isString(event)) {
+            event = {
+              type: event
+            };
+          }
+          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 ($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);
+        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 (defaults.allowEmpty && value === '') {
+        execCallback([new Report('success', {
+          validator: 'allowEmpty'
+        })]);
+      } else {
+        $elt.data('validator-instance').validate(value, options || {}, execCallback);
       }
     };
 
-    if (defaults.allowEmpty && value === '') {
-      execCallback([new Report('success', {
-        validator: 'allowEmpty'
-      })]);
-    } else {
-      $elt.data('validator-instance').validate(value, options || {}, execCallback);
-    }
-  };
-
 });

package/dist/waitForMedia.js

@@ -2,74 +2,68 @@ define(['jquery'], function ($) { 'use strict';
 
     $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
 
-    /*
-     * 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) 2015 (original work) Open Assessment Technlogies SA ;
-     *
-     * @author Sam Sipasseuth <sam@taotesting.com>
-     * @requires jquery
+    /*
+     * 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) 2015 (original work) Open Assessment Technlogies SA ;
+     *
+     * @author Sam Sipasseuth <sam@taotesting.com>
+     * @requires jquery
      */
     var _ns = '.wait';
-    /**
-     * Register a plugin that enable waiting for all media being loaded
-     *
-     * @fires loaded.wait - fired when a media has been loaded
-     * @fires all-loaded.wait - fired when all media has been loaded
-     * @param {Function} [allLoadedCallback] - callback to be executed when all media has been loaded
-     * @returns {jQueryElement} for chaingin
-     */
 
+    /**
+     * Register a plugin that enable waiting for all media being loaded
+     *
+     * @fires loaded.wait - fired when a media has been loaded
+     * @fires all-loaded.wait - fired when all media has been loaded
+     * @param {Function} [allLoadedCallback] - callback to be executed when all media has been loaded
+     * @returns {jQueryElement} for chaingin
+     */
     $.fn.waitForMedia = function (allLoadedCallback) {
-      /**
-       * The callback function that is called after loading all the documents.
-       *
-       * @param {jQueryElement} $container The container element on which will be triggered an event.
-       * @returns {undefined}
+      /**
+       * The callback function that is called after loading all the documents.
+       *
+       * @param {jQueryElement} $container The container element on which will be triggered an event.
+       * @returns {undefined}
        */
       function allLoaded($container) {
         $container.trigger('all-loaded' + _ns);
-
         if (typeof allLoadedCallback === 'function') {
           allLoadedCallback.call($container[0]);
         }
       }
-
       return this.each(function () {
         var $container = $(this),
-            $img = $container.find('img[src]'),
-            count = $img.length,
-            loaded = 0,
-
-        /**
-         * The function to be executed whenever an image is considered loaded
-         */
-        imageLoaded = function imageLoaded() {
-          $(this).trigger('loaded' + _ns).off('load' + _ns).off('error' + _ns);
-          loaded++;
-
-          if (loaded === count) {
-            allLoaded($container);
-          }
-        };
-
+          $img = $container.find('img[src]'),
+          count = $img.length,
+          loaded = 0,
+          /**
+           * The function to be executed whenever an image is considered loaded
+           */
+          imageLoaded = function () {
+            $(this).trigger('loaded' + _ns).off('load' + _ns).off('error' + _ns);
+            loaded++;
+            if (loaded === count) {
+              allLoaded($container);
+            }
+          };
         if (count === 0) {
           allLoaded($container);
           return;
         }
-
         $img.each(function () {
           if (this.complete) {
             //the image is already loaded by the browser

package/dist/waitingDialog/css/waitingDialog.css

@@ -1,9 +1,9 @@
-/*
-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 */
@@ -39,5 +39,5 @@ Usage:
     text-align: center;
     margin-top: 1.5rem;
 }
-
+
 /*# sourceMappingURL=waitingDialog.css.map */