- Jump To … +
  <<< back to documentation base.js constraint.js defaults.js factory.js field.js form.js main.js multiple.js pubsub.js remote.js ui.js utils.js validator.js validator_registry.js

- # base.js

- ¶

      import $ from 'jquery';
      import Utils from './utils';

      var Base = function () {
        this.__id__ = Utils.generateID();
      };

      Base.prototype = {
        asyncSupport: true, // Deprecated

        _pipeAccordingToValidationResult: function () {
          var pipe = () => {
            var r = $.Deferred();
            if (true !== this.validationResult)
              r.reject();
            return r.resolve().promise();
          };
          return [pipe, pipe];
        },

        actualizeOptions: function () {
          Utils.attr(this.element, this.options.namespace, this.domOptions);
          if (this.parent && this.parent.actualizeOptions)
            this.parent.actualizeOptions();
          return this;
        },

        _resetOptions: function (initOptions) {
          this.domOptions = Utils.objectCreate(this.parent.options);
          this.options = Utils.objectCreate(this.domOptions);

- ¶

  Shallow copy of ownProperties of initOptions:

          for (var i in initOptions) {
            if (initOptions.hasOwnProperty(i))
              this.options[i] = initOptions[i];
          }
          this.actualizeOptions();
        },

        _listeners: null,

- ¶

  Register a callback for the given event name Callback is called with context as the first argument and the `this` The context is the current parsley instance, or window.Parsley if global A return value of `false` will interrupt the calls

        on: function (name, fn) {
          this._listeners = this._listeners || {};
          var queue = this._listeners[name] = this._listeners[name] || [];
          queue.push(fn);

          return this;
        },

- ¶

  Deprecated. Use `on` instead

        subscribe: function(name, fn) {
          $.listenTo(this, name.toLowerCase(), fn);
        },

- ¶

  Unregister a callback (or all if none is given) for the given event name

        off: function (name, fn) {
          var queue = this._listeners && this._listeners[name];
          if (queue) {
            if (!fn) {
              delete this._listeners[name];
            } else {
              for (var i = queue.length; i--; )
                if (queue[i] === fn)
                  queue.splice(i, 1);
            }
          }
          return this;
        },

- ¶

  Deprecated. Use `off`

        unsubscribe: function(name, fn) {
          $.unsubscribeTo(this, name.toLowerCase());
        },

- ¶

  Trigger an event of the given name A return value of `false` interrupts the callback chain Returns false if execution was interrupted

        trigger: function (name, target, extraArg) {
          target = target || this;
          var queue = this._listeners && this._listeners[name];
          var result;
          var parentResult;
          if (queue) {
            for (var i = queue.length; i--; ) {
              result = queue[i].call(target, target, extraArg);
              if (result === false) return result;
            }
          }
          if (this.parent) {
            return this.parent.trigger(name, target, extraArg);
          }
          return true;
        },

        asyncIsValid: function (group, force) {
          Utils.warnOnce("asyncIsValid is deprecated; please use whenValid instead");
          return this.whenValid({group, force});
        },

        _findRelated: function () {
          return this.options.multiple ?
            $(this.parent.element.querySelectorAll(`[${this.options.namespace}multiple="${this.options.multiple}"]`))
          : this.$element;
        }
      };

      export default Base;