Proyectos de Subversion LeadersLinked - Antes de SPA

/*!

 * Bootstrap Confirmation (v4.1.0)

 * @copyright 2013 Nimit Suwannagate <ethaizone@hotmail.com>

 * @copyright 2014-2018 Damien "Mistic" Sorel <contact@git.strangeplanet.fr>

 * @licence Apache License, Version 2.0

 */

(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('jquery'), require('bootstrap')) :

  typeof define === 'function' && define.amd ? define(['jquery', 'bootstrap'], factory) :

  (global = global || self, factory(global.jQuery));

}(this, function ($) { 'use strict';

  $ = $ && $.hasOwnProperty('default') ? $['default'] : $;

  function _defineProperties(target, props) {

    for (var i = 0; i < props.length; i++) {

      var descriptor = props[i];

      descriptor.enumerable = descriptor.enumerable || false;

      descriptor.configurable = true;

      if ("value" in descriptor) descriptor.writable = true;

      Object.defineProperty(target, descriptor.key, descriptor);

    }

  }

  function _createClass(Constructor, protoProps, staticProps) {

    if (protoProps) _defineProperties(Constructor.prototype, protoProps);

    if (staticProps) _defineProperties(Constructor, staticProps);

    return Constructor;

  }

  function _defineProperty(obj, key, value) {

    if (key in obj) {

      Object.defineProperty(obj, key, {

        value: value,

        enumerable: true,

        configurable: true,

        writable: true

      });

    } else {

      obj[key] = value;

    }

    return obj;

  }

  function _objectSpread(target) {

    for (var i = 1; i < arguments.length; i++) {

      var source = arguments[i] != null ? arguments[i] : {};

      var ownKeys = Object.keys(source);

      if (typeof Object.getOwnPropertySymbols === 'function') {

        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {

          return Object.getOwnPropertyDescriptor(source, sym).enumerable;

        }));

      }

      ownKeys.forEach(function (key) {

        _defineProperty(target, key, source[key]);

      });

    }

    return target;

  }

  function _inheritsLoose(subClass, superClass) {

    subClass.prototype = Object.create(superClass.prototype);

    subClass.prototype.constructor = subClass;

    subClass.__proto__ = superClass;

  }

  if (typeof $.fn.popover === 'undefined' || $.fn.popover.Constructor.VERSION.split('.').shift() !== '4') {

    throw new Error('Bootstrap Confirmation 4 requires Bootstrap Popover 4');

  }

  var Popover = $.fn.popover.Constructor;

  /**

   * ------------------------------------------------------------------------

   * Constants

   * ------------------------------------------------------------------------

   */

  var NAME = 'confirmation';

  var VERSION = '4.1.0';

  var DATA_KEY = "bs." + NAME;

  var EVENT_KEY = "." + DATA_KEY;

  var JQUERY_NO_CONFLICT = $.fn[NAME];

  var BTN_CLASS_BASE = 'h-100 d-flex align-items-center';

  var BTN_CLASS_DEFAULT = 'btn btn-sm';

  var DefaultType = _objectSpread({}, Popover.DefaultType, {

    singleton: 'boolean',

    popout: 'boolean',

    copyAttributes: '(string|array)',

    onConfirm: 'function',

    onCancel: 'function',

    btnOkClass: 'string',

    btnOkLabel: 'string',

    btnOkIconClass: 'string',

    btnOkIconContent: 'string',

    btnCancelClass: 'string',

    btnCancelLabel: 'string',

    btnCancelIconClass: 'string',

    btnCancelIconContent: 'string',

    buttons: 'array'

  });

  var Default = _objectSpread({}, Popover.Default, {

    _attributes: {},

    _selector: null,

    placement: 'top',

    title: 'Are you sure?',

    trigger: 'click',

    confirmationEvent: undefined,

    content: '',

    singleton: false,

    popout: false,

    copyAttributes: 'href target',

    onConfirm: $.noop,

    onCancel: $.noop,

    btnOkClass: BTN_CLASS_DEFAULT + " btn-primary",

    btnOkLabel: 'Yes',

    btnOkIconClass: '',

    btnOkIconContent: '',

    btnCancelClass: BTN_CLASS_DEFAULT + " btn-secondary",

    btnCancelLabel: 'No',

    btnCancelIconClass: '',

    btnCancelIconContent: '',

    buttons: [],

    // @formatter:off

    template: "\n<div class=\"popover confirmation\">\n  <div class=\"arrow\"></div>\n  <h3 class=\"popover-header\"></h3>\n  <div class=\"popover-body\">\n    <p class=\"confirmation-content\"></p>\n    <div class=\"confirmation-buttons text-center\">\n      <div class=\"btn-group\"></div>\n    </div>\n  </div>\n</div>" // @formatter:on

  });

  if (Default.whiteList) {

    Default.whiteList['*'].push('data-apply', 'data-dismiss');

  }

  var ClassName = {

    FADE: 'fade',

    SHOW: 'show'

  };

  var Selector = {

    TITLE: '.popover-header',

    CONTENT: '.confirmation-content',

    BUTTONS: '.confirmation-buttons .btn-group'

  };

  var Keymap = {

    13: 'Enter',

    27: 'Escape',

    39: 'ArrowRight',

    40: 'ArrowDown'

  };

  var Event = {

    HIDE: "hide" + EVENT_KEY,

    HIDDEN: "hidden" + EVENT_KEY,

    SHOW: "show" + EVENT_KEY,

    SHOWN: "shown" + EVENT_KEY,

    INSERTED: "inserted" + EVENT_KEY,

    CLICK: "click" + EVENT_KEY,

    FOCUSIN: "focusin" + EVENT_KEY,

    FOCUSOUT: "focusout" + EVENT_KEY,

    MOUSEENTER: "mouseenter" + EVENT_KEY,

    MOUSELEAVE: "mouseleave" + EVENT_KEY,

    CONFIRMED: "confirmed" + EVENT_KEY,

    CANCELED: "canceled" + EVENT_KEY,

    KEYUP: "keyup" + EVENT_KEY

  };

  /**

   * ------------------------------------------------------------------------

   * Class Definition

   * ------------------------------------------------------------------------

   */

  // keep track of the last openned confirmation for keyboard navigation

  var activeConfirmation;

  var Confirmation =

  /*#__PURE__*/

  function (_Popover) {

    _inheritsLoose(Confirmation, _Popover);

    _createClass(Confirmation, null, [{

      key: "VERSION",

      // Getters

      get: function get() {

        return VERSION;

      }

    }, {

      key: "Default",

      get: function get() {

        return Default;

      }

    }, {

      key: "NAME",

      get: function get() {

        return NAME;

      }

    }, {

      key: "DATA_KEY",

      get: function get() {

        return DATA_KEY;

      }

    }, {

      key: "Event",

      get: function get() {

        return Event;

      }

    }, {

      key: "EVENT_KEY",

      get: function get() {

        return EVENT_KEY;

      }

    }, {

      key: "DefaultType",

      get: function get() {

        return DefaultType;

      } // Constructor

    }]);

    function Confirmation(element, config) {

      var _this;

      _this = _Popover.call(this, element, config) || this;

      if ((_this.config.popout || _this.config.singleton) && !_this.config.rootSelector) {

        throw new Error('The rootSelector option is required to use popout and singleton features since jQuery 3.');

      } // keep trace of selectors

      _this._isDelegate = false;

      if (config.selector) {

        // container of buttons

        config._selector = config.rootSelector + " " + config.selector;

        _this.config._selector = config._selector;

      } else if (config._selector) {

        // children of container

        _this.config._selector = config._selector;

        _this._isDelegate = true;

      } else {

        // standalone

        _this.config._selector = config.rootSelector;

      }

      if (_this.config.confirmationEvent === undefined) {

        _this.config.confirmationEvent = _this.config.trigger;

      }

      if (!_this.config.selector) {

        _this._copyAttributes();

      }

      _this._setConfirmationListeners();

      return _this;

    } // Overrides

    var _proto = Confirmation.prototype;

    _proto.isWithContent = function isWithContent() {

      return true;

    };

    _proto.setContent = function setContent() {

      var $tip = $(this.getTipElement());

      var content = this._getContent();

      if (typeof content === 'function') {

        content = content.call(this.element);

      }

      this.setElementContent($tip.find(Selector.TITLE), this.getTitle());

      $tip.find(Selector.CONTENT).toggle(!!content);

      if (content) {

        this.setElementContent($tip.find(Selector.CONTENT), content);

      }

      if (this.config.buttons.length > 0) {

        this._setButtons($tip, this.config.buttons);

      } else {

        this._setStandardButtons($tip);

      }

      $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);

      this._setupKeyupEvent();

    };

    _proto.dispose = function dispose() {

      $('body').off(Event.CLICK + "." + this.uid);

      this.eventBody = false;

      this._cleanKeyupEvent();

      _Popover.prototype.dispose.call(this);

    };

    _proto.hide = function hide(callback) {

      this._cleanKeyupEvent();

      _Popover.prototype.hide.call(this, callback);

    } // Private

    /**

     * Copy the value of `copyAttributes` on the config object

     * @private

     */

    ;

    _proto._copyAttributes = function _copyAttributes() {

      var _this2 = this;

      this.config._attributes = {};

      if (this.config.copyAttributes) {

        if (typeof this.config.copyAttributes === 'string') {

          this.config.copyAttributes = this.config.copyAttributes.split(' ');

        }

      } else {

        this.config.copyAttributes = [];

      }

      this.config.copyAttributes.forEach(function (attr) {

        _this2.config._attributes[attr] = $(_this2.element).attr(attr);

      });

    }

    /**

     * Custom event listeners for popouts and singletons

     * @private

     */

    ;

    _proto._setConfirmationListeners = function _setConfirmationListeners() {

      var self = this;

      if (!this.config.selector) {

        // cancel original event

        $(this.element).on(this.config.trigger, function (e, ack) {

          if (!ack) {

            e.preventDefault();

            e.stopPropagation();

            e.stopImmediatePropagation();

          }

        }); // manage singleton

        $(this.element).on(Event.SHOWN, function () {

          if (self.config.singleton) {

            // close all other popover already initialized

            $(self.config._selector).not($(this)).filter(function () {

              return $(this).data(DATA_KEY) !== undefined;

            }).confirmation('hide');

          }

        });

      } else {

        // cancel original event

        $(this.element).on(this.config.trigger, this.config.selector, function (e, ack) {

          if (!ack) {

            e.preventDefault();

            e.stopPropagation();

            e.stopImmediatePropagation();

          }

        });

      }

      if (!this._isDelegate) {

        // manage popout

        this.eventBody = false;

        this.uid = this.element.id || Confirmation.getUID(NAME + "_group");

        $(this.element).on(Event.SHOWN, function () {

          if (self.config.popout && !self.eventBody) {

            self.eventBody = $('body').on(Event.CLICK + "." + self.uid, function (e) {

              if ($(self.config._selector).is(e.target) || $(self.config._selector).has(e.target).length > 0) {

                return;

              } // close all popover already initialized

              $(self.config._selector).filter(function () {

                return $(this).data(DATA_KEY) !== undefined;

              }).confirmation('hide');

              $('body').off(Event.CLICK + "." + self.uid);

              self.eventBody = false;

            });

          }

        });

      }

    }

    /**

     * Init the standard ok/cancel buttons

     * @param $tip

     * @private

     */

    ;

    _proto._setStandardButtons = function _setStandardButtons($tip) {

      var buttons = [{

        class: this.config.btnOkClass,

        label: this.config.btnOkLabel,

        iconClass: this.config.btnOkIconClass,

        iconContent: this.config.btnOkIconContent,

        attr: this.config._attributes

      }, {

        class: this.config.btnCancelClass,

        label: this.config.btnCancelLabel,

        iconClass: this.config.btnCancelIconClass,

        iconContent: this.config.btnCancelIconContent,

        cancel: true

      }];

      this._setButtons($tip, buttons);

    }

    /**

     * Init the buttons

     * @param $tip

     * @param buttons

     * @private

     */

    ;

    _proto._setButtons = function _setButtons($tip, buttons) {

      var self = this;

      var $group = $tip.find(Selector.BUTTONS).empty();

      buttons.forEach(function (button) {

        var btn = $('<a href="#"></a>').addClass(BTN_CLASS_BASE).addClass(button.class || BTN_CLASS_DEFAULT + " btn-secondary").html(button.label || '').attr(button.attr || {});

        if (button.iconClass || button.iconContent) {

          btn.prepend($('<i></i>').addClass(button.iconClass || '').text(button.iconContent || ''));

        }

        btn.one('click', function (e) {

          if ($(this).attr('href') === '#') {

            e.preventDefault();

          }

          if (button.onClick) {

            button.onClick.call($(self.element));

          }

          if (button.cancel) {

            self.config.onCancel.call(self.element, button.value);

            $(self.element).trigger(Event.CANCELED, [button.value]);

          } else {

            self.config.onConfirm.call(self.element, button.value);

            $(self.element).trigger(Event.CONFIRMED, [button.value]);

            $(self.element).trigger(self.config.confirmationEvent, [true]);

          }

          self.hide();

        });

        $group.append(btn);

      });

    }

    /**

     * Install the keyboatd event handler

     * @private

     */

    ;

    _proto._setupKeyupEvent = function _setupKeyupEvent() {

      activeConfirmation = this;

      $(window).off(Event.KEYUP).on(Event.KEYUP, this._onKeyup.bind(this));

    }

    /**

     * Remove the keyboard event handler

     * @private

     */

    ;

    _proto._cleanKeyupEvent = function _cleanKeyupEvent() {

      if (activeConfirmation === this) {

        activeConfirmation = undefined;

        $(window).off(Event.KEYUP);

      }

    }

    /**

     * Event handler for keyboard navigation

     * @param event

     * @private

     */

    ;

    _proto._onKeyup = function _onKeyup(event) {

      if (!this.tip) {

        this._cleanKeyupEvent();

        return;

      }

      var $tip = $(this.getTipElement());

      var key = event.key || Keymap[event.keyCode || event.which];

      var $group = $tip.find(Selector.BUTTONS);

      var $active = $group.find('.active');

      var $next;

      switch (key) {

        case 'Escape':

          this.hide();

          break;

        case 'ArrowRight':

          if ($active.length && $active.next().length) {

            $next = $active.next();

          } else {

            $next = $group.children().first();

          }

          $active.removeClass('active');

          $next.addClass('active').focus();

          break;

        case 'ArrowLeft':

          if ($active.length && $active.prev().length) {

            $next = $active.prev();

          } else {

            $next = $group.children().last();

          }

          $active.removeClass('active');

          $next.addClass('active').focus();

          break;

        default:

          break;

      }

    } // Static

    /**

     * Generates an uui, copied from Bootrap's utils

     * @param {string} prefix

     * @returns {string}

     */

    ;

    Confirmation.getUID = function getUID(prefix) {

      var uid = prefix;

      do {

        // eslint-disable-next-line no-bitwise

        uid += ~~(Math.random() * 1000000); // "~~" acts like a faster Math.floor() here

      } while (document.getElementById(uid));

      return uid;

    };

    Confirmation._jQueryInterface = function _jQueryInterface(config) {

      return this.each(function () {

        var data = $(this).data(DATA_KEY);

        var _config = typeof config === 'object' ? config : {};

        _config.rootSelector = $(this).selector || _config.rootSelector; // this.selector removed in jQuery > 3

        if (!data && /destroy|hide/.test(config)) {

          return;

        }

        if (!data) {

          data = new Confirmation(this, _config);

          $(this).data(DATA_KEY, data);

        }

        if (typeof config === 'string') {

          if (typeof data[config] === 'undefined') {

            throw new TypeError("No method named \"" + config + "\"");

          }

          data[config]();

        }

      });

    };

    return Confirmation;

  }(Popover);

  /**

   * ------------------------------------------------------------------------

   * jQuery

   * ------------------------------------------------------------------------

   */

  $.fn[NAME] = Confirmation._jQueryInterface;

  $.fn[NAME].Constructor = Confirmation;

  $.fn[NAME].noConflict = function () {

    $.fn[NAME] = JQUERY_NO_CONFLICT;

    return Confirmation._jQueryInterface;

  };

}));

//# sourceMappingURL=bootstrap-confirmation.js.map