active_frontend 13.3.0 → 14.0.0

data/vendor/assets/javascripts/base/_carousel.js

@@ -0,0 +1,237 @@
++function ($) {
+  'use strict';
+
+  // CAROUSEL CLASS DEFINITION
+  // =========================
+
+  var Carousel = function (element, options) {
+    this.$element = $(element);
+    this.$indicators = this.$element.find('.carousel-indicators');
+    this.options = options;
+    this.paused = null;
+    this.sliding = null;
+    this.interval = null;
+    this.$active = null;
+    this.$items = null;
+
+    this.options.keyboard && this.$element.on('keydown.bs.carousel', $.proxy(this.keydown, this));
+
+    this.options.pause === 'hover' && !('ontouchstart' in document.documentElement) && this.$element
+      .on('mouseenter.bs.carousel', $.proxy(this.pause, this))
+      .on('mouseleave.bs.carousel', $.proxy(this.cycle, this));
+  };
+
+  Carousel.VERSION = '1.0.0';
+  Carousel.TRANSITION_DURATION = 600;
+  Carousel.DEFAULTS = {
+    interval: 5000,
+    pause: 'hover',
+    wrap: true,
+    keyboard: true
+  };
+
+  Carousel.prototype.constructor = Carousel;
+
+  Carousel.prototype.keydown = function (e) {
+    if (/input|textarea/i.test(e.target.tagName)) return;
+    switch (e.which) {
+      case 37: this.prev(); break;
+      case 39: this.next(); break;
+      default: return;
+    }
+
+    e.preventDefault();
+  };
+
+  Carousel.prototype.cycle = function (e) {
+    e || (this.paused = false);
+
+    this.interval && clearInterval(this.interval);
+
+    this.options.interval &&
+      !this.paused &&
+      (this.interval = setInterval($.proxy(this.next, this), this.options.interval));
+
+    return this;
+  };
+
+  Carousel.prototype.getItemIndex = function (item) {
+    this.$items = item.parent().children('.item');
+    return this.$items.index(item || this.$active);
+  };
+
+  Carousel.prototype.getItemForDirection = function (direction, active) {
+    var activeIndex = this.getItemIndex(active);
+    var willWrap = (direction === 'prev' && activeIndex === 0) ||
+                   (direction === 'next' && activeIndex === (this.$items.length - 1));
+
+    if (willWrap && !this.options.wrap) return active;
+
+    var delta = direction === 'prev' ? -1 : 1;
+    var itemIndex = (activeIndex + delta) % this.$items.length;
+
+    return this.$items.eq(itemIndex);
+  };
+
+  Carousel.prototype.to = function (pos) {
+    var that = this;
+    var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'));
+
+    if (pos > (this.$items.length - 1) || pos < 0) return;
+    if (this.sliding) return this.$element.one('slid.bs.carousel', function () { that.to(pos); });
+    if (activeIndex === pos) return this.pause().cycle();
+
+    return this.slide(pos > activeIndex ? 'next' : 'prev', this.$items.eq(pos));
+  };
+
+  Carousel.prototype.pause = function (e) {
+    e || (this.paused = true);
+
+    if (this.$element.find('.next, .prev').length && $.support.transition) {
+      this.$element.trigger($.support.transition.end);
+      this.cycle(true);
+    }
+
+    this.interval = clearInterval(this.interval);
+
+    return this;
+  };
+
+  Carousel.prototype.next = function () {
+    if (this.sliding) return;
+    return this.slide('next');
+  };
+
+  Carousel.prototype.prev = function () {
+    if (this.sliding) return;
+    return this.slide('prev');
+  };
+
+  Carousel.prototype.slide = function (type, next) {
+    var $active = this.$element.find('.item.active');
+    var $next = next || this.getItemForDirection(type, $active);
+    var isCycling = this.interval;
+    var direction = type === 'next' ? 'left' : 'right';
+    var that = this;
+
+    if ($next.hasClass('active')) return (this.sliding = false);
+
+    var relatedTarget = $next[0];
+    var slideEvent = $.Event('slide.bs.carousel', {
+      relatedTarget: relatedTarget,
+      direction: direction
+    });
+
+    this.$element.trigger(slideEvent);
+    if (slideEvent.isDefaultPrevented()) return;
+
+    this.sliding = true;
+
+    isCycling && this.pause();
+
+    if (this.$indicators.length) {
+      this.$indicators.find('.active').removeClass('active');
+
+      var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)]);
+
+      $nextIndicator && $nextIndicator.addClass('active');
+    }
+
+    var slidEvent = $.Event('slid.bs.carousel', { relatedTarget: relatedTarget, direction: direction }); // yes, "slid"
+
+    if ($.support.transition && this.$element.hasClass('slide')) {
+      $next.addClass(type);
+      $next[0].offsetWidth;
+      $active.addClass(direction);
+      $next.addClass(direction);
+      $active
+        .one('bsTransitionEnd', function () {
+          $next.removeClass([type, direction].join(' ')).addClass('active');
+          $active.removeClass(['active', direction].join(' '));
+          that.sliding = false;
+          setTimeout(function () {
+            that.$element.trigger(slidEvent);
+          }, 0);
+        })
+        .emulateTransitionEnd(Carousel.TRANSITION_DURATION);
+    } else {
+      $active.removeClass('active');
+      $next.addClass('active');
+      this.sliding = false;
+      this.$element.trigger(slidEvent);
+    }
+
+    isCycling && this.cycle();
+
+    return this;
+  };
+
+  // CAROUSEL PLUGIN DEFINITION
+  // ==========================
+
+  function Plugin(option) {
+    return this.each(function () {
+      var $this = $(this);
+      var data = $this.data('bs.carousel');
+      var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option === 'object' && option);
+      var action = typeof option === 'string' ? option : options.slide;
+
+      if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)));
+
+      if (typeof option === 'number') {
+        data.to(option);
+      } else if (action) {
+        data[action]();
+      } else if (options.interval) {
+        data.pause().cycle();
+      }
+    });
+  }
+
+  var old = $.fn.carousel;
+
+  $.fn.carousel = Plugin;
+  $.fn.carousel.Constructor = Carousel;
+
+  // CAROUSEL NO CONFLICT
+  // ====================
+
+  $.fn.carousel.noConflict = function () {
+    $.fn.carousel = old;
+    return this;
+  };
+
+  // CAROUSEL DATA-API
+  // =================
+
+  var clickHandler = function (e) {
+    var href;
+    var $this = $(this);
+    var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, ''));
+
+    if (!$target.hasClass('carousel')) return;
+
+    var options = $.extend({}, $target.data(), $this.data());
+    var slideIndex = $this.attr('data-slide-to');
+
+    if (slideIndex) options.interval = false;
+
+    Plugin.call($target, options);
+
+    if (slideIndex) $target.data('bs.carousel').to(slideIndex);
+
+    e.preventDefault();
+  };
+
+  $(document)
+    .on('click.bs.carousel.data-api', '[data-slide]', clickHandler)
+    .on('click.bs.carousel.data-api', '[data-slide-to]', clickHandler)
+    .on('ready.bs.carousel.data-api', function () {
+      $('[data-ride="carousel"]').each(function () {
+        var $this = $(this);
+        if ($this.data('carousel')) return;
+        Plugin.call($this, $this.data());
+      });
+    });
+
+}(jQuery);

data/vendor/assets/javascripts/base/_collapse.js

@@ -0,0 +1,200 @@
++function ($) {
+  'use strict';
+
+  // COLLAPSE PUBLIC CLASS DEFINITION
+  // ================================
+
+  var Collapse = function (element, options) {
+    this.$element = $(element);
+    this.options = $.extend({}, Collapse.DEFAULTS, options);
+
+    this.transitioning = null;
+    this.$trigger = $('[data-toggle="collapse"][href="#' + element.id + '"],' +
+                      '[data-toggle="collapse"][data-target="#' + element.id + '"]');
+
+    if (this.options.parent) {
+      this.$parent = this.getParent();
+    } else {
+      this.addAriaAndCollapsedClass(this.$element, this.$trigger);
+    }
+
+    if (this.options.toggle) this.toggle();
+  };
+
+  Collapse.VERSION = '1.0.0';
+  Collapse.TRANSITION_DURATION = 350;
+  Collapse.DEFAULTS = {
+    toggle: true
+  };
+
+  Collapse.prototype.constructor = Collapse;
+
+  Collapse.prototype.dimension = function () {
+    var hasWidth = this.$element.hasClass('width');
+    return hasWidth ? 'width' : 'height';
+  };
+
+  Collapse.prototype.show = function () {
+    if (this.transitioning || this.$element.hasClass('in')) return;
+
+    var activesData;
+    var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing');
+
+    if (actives && actives.length) {
+      activesData = actives.data('bs.collapse');
+      if (activesData && activesData.transitioning) return;
+    }
+
+    var startEvent = $.Event('show.bs.collapse');
+    this.$element.trigger(startEvent);
+
+    if (startEvent.isDefaultPrevented()) return;
+    if (actives && actives.length) {
+      Plugin.call(actives, 'hide');
+      activesData || actives.data('bs.collapse', null);
+    }
+
+    var dimension = this.dimension();
+
+    this.$element
+      .removeClass('collapse')
+      .addClass('collapsing')[dimension](0)
+      .attr('aria-expanded', true);
+
+    this.$trigger
+      .removeClass('collapsed')
+      .attr('aria-expanded', true);
+
+    this.transitioning = 1;
+
+    var complete = function () {
+      this.$element
+        .removeClass('collapsing')
+        .addClass('collapse in')[dimension]('');
+      this.transitioning = 0;
+      this.$element
+        .trigger('shown.bs.collapse');
+    };
+
+    if (!$.support.transition) return complete.call(this);
+
+    var scrollSize = $.camelCase(['scroll', dimension].join('-'));
+
+    this.$element
+      .one('bsTransitionEnd', $.proxy(complete, this))
+      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize]);
+  };
+
+  Collapse.prototype.hide = function () {
+    if (this.transitioning || !this.$element.hasClass('in')) return;
+
+    var startEvent = $.Event('hide.bs.collapse');
+    this.$element.trigger(startEvent);
+    if (startEvent.isDefaultPrevented()) return;
+
+    var dimension = this.dimension();
+
+    this.$element[dimension](this.$element[dimension]())[0].offsetHeight;
+
+    this.$element
+      .addClass('collapsing')
+      .removeClass('collapse in')
+      .attr('aria-expanded', false);
+
+    this.$trigger
+      .addClass('collapsed')
+      .attr('aria-expanded', false);
+
+    this.transitioning = 1;
+
+    var complete = function () {
+      this.transitioning = 0;
+      this.$element
+        .removeClass('collapsing')
+        .addClass('collapse')
+        .trigger('hidden.bs.collapse');
+    };
+
+    if (!$.support.transition) return complete.call(this);
+
+    this.$element
+      [dimension](0)
+      .one('bsTransitionEnd', $.proxy(complete, this))
+      .emulateTransitionEnd(Collapse.TRANSITION_DURATION);
+  };
+
+  Collapse.prototype.toggle = function () {
+    this[this.$element.hasClass('in') ? 'hide' : 'show']();
+  };
+
+  Collapse.prototype.getParent = function () {
+    return $(this.options.parent)
+      .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')
+      .each($.proxy(function (i, element) {
+        var $element = $(element);
+        this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element);
+      }, this))
+      .end();
+  };
+
+  Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {
+    var isOpen = $element.hasClass('in');
+
+    $element.attr('aria-expanded', isOpen);
+    $trigger
+      .toggleClass('collapsed', !isOpen)
+      .attr('aria-expanded', isOpen);
+  };
+
+  function getTargetFromTrigger($trigger) {
+    var href;
+    var target = $trigger.attr('data-target') ||
+                 (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '');
+
+    return $(target);
+  }
+
+  // COLLAPSE PLUGIN DEFINITION
+  // ==========================
+
+  function Plugin(option) {
+    return this.each(function () {
+      var $this = $(this);
+      var data = $this.data('bs.collapse');
+      var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option === 'object' && option);
+
+      if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false;
+      if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)));
+      if (typeof option === 'string') data[option]();
+    });
+  }
+
+  var old = $.fn.collapse;
+
+  $.fn.collapse = Plugin;
+  $.fn.collapse.Constructor = Collapse;
+
+  // COLLAPSE NO CONFLICT
+  // ====================
+
+  $.fn.collapse.noConflict = function () {
+    $.fn.collapse = old;
+    return this;
+  };
+
+  // COLLAPSE DATA-API
+  // =================
+
+  $(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
+    var $this = $(this);
+
+    if (!$this.attr('data-target')) e.preventDefault();
+
+    var $target = getTargetFromTrigger($this);
+    var data = $target.data('bs.collapse');
+    var option = data ? 'toggle' : $this.data();
+
+    Plugin.call($target, option);
+  });
+
+}(jQuery);

data/vendor/assets/javascripts/base/_colorpicker.js

@@ -0,0 +1,147 @@
++function ($) {
+  'use strict';
+
+  // COLORPICKER PUBLIC CLASS DEFINITION
+  // ===================================
+
+  var Colorpicker = function (element, options) {
+    this.$element = $(element);
+    this.options = $.extend({}, Colorpicker.DEFAULTS, options);
+
+    this.$active = false;
+    this.$widget = $(this.initWidget()).on('click', $.proxy(this.clickWidget, this));
+
+    this.init();
+  };
+
+  Colorpicker.VERSION = '1.0.0';
+  Colorpicker.DEFAULTS = {
+    callback: function (color) {},
+    colors: [
+      '#ABD026', '#72C914', '#32C9EA', '#007CFF', '#5C5CEB',
+      '#8C4BFB', '#FF5F84', '#F52F2E', '#FE921A', '#FFD613',
+      '#273448', '#8492A6', '#ECEFF5', '#FFFFFF'
+    ],
+    item: '<li><button type="button"></button></li>',
+    menu: '<ul class="colorpicker dropmenu caret"></ul>'
+  };
+
+  Colorpicker.prototype.constructor = Colorpicker;
+
+  Colorpicker.prototype.init = function () {
+    this.$element.on({
+      'focus.bs.timepicker': $.proxy(this.showWidget, this),
+      'click.bs.timepicker': $.proxy(this.showWidget, this),
+      'blur.bs.timepicker': $.proxy(this.setVal, this)
+    });
+  };
+
+  Colorpicker.prototype.clickWidget = function (e) {
+    e.stopPropagation();
+    e.preventDefault();
+
+    var color = $(e.target).data('color');
+
+    this.setVal(color);
+  };
+
+  Colorpicker.prototype.initWidget = function () {
+    var _self = this;
+    var menu = $(this.options.menu);
+
+    $.each(this.options.colors, function (index, value) {
+      var item = $(_self.options.item);
+
+      item.find('button')
+        .addClass('swatch bsColor')
+        .css({ background: value })
+        .data('color', value);
+
+      menu.append(item);
+    });
+
+    return menu;
+  };
+
+  Colorpicker.prototype.showWidget = function () {
+    if (this.$active) return;
+    if (this.$element.prop('disabled') || this.$element.prop('readonly')) return;
+    if (this.$widget.is(':visible')) return;
+
+    this.$container = $('<span>')
+      .addClass('btn-group dropdown open bsColorpicker')
+      .css({
+        height: 0,
+        position: 'absolute',
+        width: 0
+      });
+
+    this.$container.append(this.$widget);
+    this.$element.after(this.$container);
+    this.$active = true;
+
+    var _self = this;
+    $(document).on('mousedown.bs.colorpicker, touchend.bs.colorpicker', function (e) {
+      if (!(_self.$element.parent().find(e.target).length ||
+          _self.$widget.is(e.target) ||
+          _self.$widget.find(e.target).length)) {
+        _self.hideWidget();
+      }
+    });
+  };
+
+  Colorpicker.prototype.hideWidget = function () {
+    if (!this.$active) return;
+    if (!this.$widget.is(':visible')) return;
+
+    $(document).off('mousedown.bs.colorpicker, touchend.bs.colorpicker');
+    this.$widget.detach();
+    this.$container.remove();
+    this.$active = false;
+  };
+
+  Colorpicker.prototype.setVal = function (color) {
+    if (color == '[object Object]') return;
+    if (!this.$active) return;
+
+    this.$element.val(color);
+    this.options.callback(color);
+  };
+
+  // COLORPICKER PLUGIN DEFINITION
+  // =============================
+
+  function Plugin(option) {
+    return this.each(function () {
+      var $this = $(this);
+      var data = $this.data('bs.colorpicker');
+      var options = typeof option === 'object' && option;
+
+      if (!data) $this.data('bs.colorpicker', (data = new Colorpicker(this, options)));
+      if (typeof option === 'string') data[option]();
+    });
+  }
+
+  var old = $.fn.colorpicker;
+
+  $.fn.colorpicker = Plugin;
+  $.fn.colorpicker.Constructor = Colorpicker;
+
+  // COLORPICKER NO CONFLICT
+  // =======================
+
+  $.fn.colorpicker.noConflict = function () {
+    $.fn.colorpicker = old;
+    return this;
+  };
+
+  // COLORPICKER DATA-API
+  // ====================
+
+  $(document).on('focus.bs.colorpicker.data-api click.bs.colorpicker.data-api', '[data-toggle="colorpicker"]', function (e) {
+    var $this = $(this);
+    if ($this.data('colorpicker')) return;
+    Plugin.call($this, $this.data());
+  });
+
+}(jQuery);