active_frontend 13.3.0 → 14.0.0

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

@@ -0,0 +1,224 @@
++function ($) {
+  'use strict';
+
+  // TABLE CLASS DEFINITION
+  // ======================
+
+  var Table = function (element, options) {
+    this.$element = $(element);
+    this.options = $.extend({}, Table.DEFAULTS, options);
+
+    this.init();
+  };
+
+  Table.VERSION = '1.0.0';
+  Table.DEFAULTS = {
+    templates: {
+      downArrow: '<i class="icon-chevron-down pull-right"></i>',
+      noArrow: '<i class="icon-minus pull-right"></i>',
+      upArrow: '<i class="icon-chevron-up pull-right"></i>'
+    }
+  };
+
+  Table.prototype.constructor = Table;
+
+  Table.prototype.init = function () {
+    this.setSortableColumns();
+    this.setSortableClone();
+  };
+
+  Table.prototype.setSortableClone = function () {
+    this.$container = $('<span>')
+      .addClass('bsTableClone')
+      .css({
+        display: 'none',
+        height: 0,
+        position: 'absolute',
+        width: 0
+      });
+
+    this.$container.append(this.$element.clone());
+    this.$element.parent().append(this.$container);
+  };
+
+  Table.prototype.setSortableColumns = function () {
+    var _self = this;
+
+    this.$element.find('thead tr th').each(function () {
+      var trTh = $(this);
+
+      if (trTh.hasClass('no-sort') === false) {
+        trTh.addClass('sort');
+
+        _self.setSortStatus(trTh, 'sortable');
+        _self.bindSortClick(trTh);
+      }
+    });
+  };
+
+  Table.prototype.setSortStatus = function (trTh, type) {
+    trTh.attr('data-sort', type);
+
+    var icon = trTh.find('.bsTableIcon').first();
+
+    if (icon !== null) icon.remove();
+
+    switch (type) {
+      case 'up':
+        icon = this.options.templates.upArrow;
+        break;
+      case 'down':
+        icon = this.options.templates.downArrow;
+        break;
+      default:
+        icon = this.options.templates.noArrow;
+        break;
+    }
+
+    icon = $(icon).addClass('bsTableIcon');
+
+    trTh.append(icon);
+  };
+
+  Table.prototype.bindSortClick = function (trTh) {
+    var bindEvent = 'click';
+
+    trTh.unbind(bindEvent);
+    trTh.bind(bindEvent, this.initSortClick(trTh));
+  };
+
+  Table.prototype.initSortClick = function (trTh) {
+    var _self = this;
+    var table = this.$element;
+
+    var sortClick = function () {
+      var dataSort = trTh.attr('data-sort');
+      var trThParentTh = trTh.parent().find('th');
+      var reSort = 'sortable';
+
+      trThParentTh.each(function () {
+        var th = $(this);
+
+        if (th.hasClass('no-sort') === false) _self.setSortStatus(th, 'sortable');
+      });
+
+      switch (dataSort) {
+        case 'up':
+          reSort = 'down';
+          break;
+        case 'down':
+          reSort = 'sortable';
+          break;
+        default:
+          reSort = 'up';
+          break;
+      }
+
+      _self.setSortStatus(trTh, reSort);
+
+      var colIndex = 0;
+      var sudoColIndex = 0;
+
+      trThParentTh.each(function () {
+        if ($(this).attr('data-sort') === reSort) {
+          sudoColIndex = colIndex;
+          return false;
+        } else {
+          colIndex++;
+        }
+      });
+
+      var numeric = true;
+      var clonedTable = _self.$container.find('table');
+      var clonedTr = clonedTable.find('tbody tr');
+      var clonedColVals = [];
+      var clonedRowsMap = {};
+      var i = 0;
+
+      for (i = 0; i < clonedTr.length; i++) {
+        var currentRow = clonedTable.find('tbody tr:eq(' + i + ')');
+        var key = currentRow.children('td:eq(' + sudoColIndex + ')').html();
+
+        if ($.isNumeric(key)) {
+          var trailing_i;
+
+          trailing_i = (i + 1) / (clonedTr.length + 1);
+          trailing_i = trailing_i.toString();
+          trailing_i = trailing_i.substr(2);
+
+          if (key.indexOf('.') === -1) {
+            key = key + '.' + trailing_i;
+          } else {
+            key = key + trailing_i;
+          }
+        } else {
+          key = key + ':' + i;
+          numeric = false;
+        }
+
+        clonedColVals.push(key);
+        clonedRowsMap[key] = currentRow.clone();
+      }
+
+      if (reSort !== 'sortable') {
+        if (numeric) {
+          clonedColVals.sort(function (a, b) {
+            return a - b;
+          });
+        } else {
+          clonedColVals.sort();
+        }
+
+        if (reSort === 'up') clonedColVals.reverse();
+      }
+
+      var tbody = table.find('tbody');
+      tbody.html('');
+
+      for (i = 0; i < clonedColVals.length; i++) {
+        tbody.append(clonedRowsMap[clonedColVals[i]]);
+      }
+    };
+
+    return sortClick;
+  };
+
+  // TABLE PLUGIN DEFINITION
+  // =======================
+
+  function Plugin(option) {
+    return this.each(function () {
+      var $this = $(this);
+      var data = $this.data('bs.table');
+      var options = typeof option === 'object' && option;
+
+      if (!data) $this.data('bs.table', (data = new Table(this, options)));
+      if (typeof option === 'string') data[option]();
+    });
+  }
+
+  var old = $.fn.table;
+
+  $.fn.table = Plugin;
+  $.fn.table.Constructor = Table;
+
+  // TABLE NO CONFLICT
+  // =================
+
+  $.fn.table.noConflict = function () {
+    $.fn.table = old;
+    return this;
+  };
+
+  // TABLE DATA-API
+  // ==============
+
+  $(document).on('ready.bs.table.data-api', function () {
+    $('[data-toggle="table"]').each(function () {
+      var $this = $(this);
+      if ($this.data('table')) return;
+      Plugin.call($this, $this.data());
+    });
+  });
+
+}(jQuery);

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

@@ -0,0 +1,270 @@
++function ($) {
+  'use strict';
+
+  // TIMEAGO CLASS DEFINITION
+  // ========================
+
+  var Timeago = function (element, options) {
+    this.$element = $(element);
+    this.settings = {
+      time: this.$element.data('time')
+    };
+    this.options = $.extend({}, Timeago.DEFAULTS, this.settings, options);
+
+    this.$time = this.options.time;
+
+    this.refresh();
+  };
+
+  Timeago.VERSION = '1.0.0';
+  Timeago.DEFAULTS = {
+    approximate: true,
+    maxRelative: false,
+    showNow: false,
+    showSeconds: false,
+    spacing: true,
+    text: {
+      prefixes: {
+        now: 'just now',
+        lt: 'less than a',
+        about: 'about',
+        over: 'over',
+        almost: 'almost',
+        ago: ''
+      },
+      suffix: ' ago',
+      units: {
+        second: 'second',
+        seconds: 'seconds',
+        minute: 'minute',
+        minutes: 'minutes',
+        hour: 'hour',
+        hours: 'hours',
+        day: 'day',
+        days: 'days',
+        month: 'month',
+        months: 'months',
+        year: 'year',
+        years: 'years'
+      }
+    }
+  };
+
+  Timeago.prototype.constructor = Timeago;
+
+  Timeago.prototype.startTimer = function () {
+    var _self = this;
+
+    return this.interval = setTimeout(function () {
+      return _self.refresh();
+    }, this.startInterval);
+  };
+
+  Timeago.prototype.stopTimer = function () {
+    return clearTimeout(this.interval);
+  };
+
+  Timeago.prototype.restartTimer = function () {
+    this.stopTimer();
+    return this.startTimer();
+  };
+
+  Timeago.prototype.refresh = function () {
+    this.updateTime();
+    return this.updateInterval();
+  };
+
+  Timeago.prototype.updateTime = function () {
+    var timeStr = this.timeAgoInWords(this.$time);
+
+    return this.$element.html(timeStr);
+  };
+
+  Timeago.prototype.updateInterval = function () {
+    var newestTime = this.parseStr(this.$time);
+    var distance = this.getTimeDistanceInSeconds(newestTime);
+
+    if (this.options.maxRelative && distance >= this.options.maxRelative) {
+      return this.stopTimer();
+    } else if (this.options.showNow && distance < this.options.showNow) {
+      this.startInterval = (this.options.showNow - distance) * 1000;
+      return this.restartTimer();
+    } else if (this.options.showSeconds && distance < 60) {
+      this.startInterval = 1000;
+      return this.restartTimer();
+    } else if (distance < 2700) {
+      this.startInterval = (60 - distance % 60) * 1000;
+      return this.restartTimer();
+    } else if (distance < 5400) {
+      this.startInterval = (5400 - distance) * 1000;
+      return this.restartTimer();
+    } else if (distance < 151200) {
+      this.startInterval = (3600 - distance % 3600) * 1000;
+      return this.restartTimer();
+    } else {
+      this.startInterval = (86400 - distance % 86400) * 1000;
+      return this.restartTimer();
+    }
+  };
+
+  Timeago.prototype.timeAgoInWords = function (timeStr) {
+    var absTime = this.parseStr(timeStr);
+    var distance = this.getTimeDistanceInSeconds(absTime);
+
+    if (this.options.showNow && this.options.showNow > distance) {
+      return this.options.text.prefixes.now;
+    } else if (this.options.maxRelative && this.options.maxRelative <= distance) {
+      return timeStr;
+    } else {
+      return '' +
+        this.options.text.prefixes.ago +
+        this.distanceOfTimeInWords(distance) +
+        this.options.text.suffix;
+    }
+  };
+
+  Timeago.prototype.parseStr = function (iso8601) {
+    var timeStr = $.trim(iso8601);
+
+    timeStr = timeStr.replace(/\.\d+/, '');
+    timeStr = timeStr.replace(/-/, '/').replace(/-/, '/');
+    timeStr = timeStr.replace(/T/, ' ').replace(/Z/, ' UTC');
+    timeStr = timeStr.replace(/([\+\-]\d\d)\:?(\d\d)/, ' $1$2');
+
+    return new Date(timeStr);
+  };
+
+  Timeago.prototype.getTimeDistanceInSeconds = function (absTime) {
+    var distance = new Date().getTime() - absTime.getTime();
+
+    return Math.round(Math.abs(distance) / 1000);
+  };
+
+  Timeago.prototype.distanceOfTimeInWords = function (distance) {
+    var about = this.options.approximate ? this.options.text.prefixes.about + ' ' : '';
+    var space = this.options.spacing ? ' ' : '';
+
+    if (distance < 60) {
+      if (this.options.showSeconds) {
+        if (distance === 0 || distance === 1) {
+          return '1' +
+            space +
+            this.options.text.units.second;
+        } else {
+          return '' +
+            distance +
+            space +
+            this.options.text.units.seconds;
+        }
+      } else {
+        return '' +
+          (this.options.approximate ? this.options.text.prefixes.lt + ' ' : '1' + space) +
+          this.options.text.units.minute;
+      }
+    } else if (distance < 120) {
+      return '1' +
+        space +
+        this.options.text.units.minute;
+    } else if (distance < 2700) {
+      return '' +
+        (Math.round(distance / 60)) +
+        space +
+        this.options.text.units.minutes;
+    } else if (distance < 5400) {
+      return '' +
+        about +
+        '1' +
+        space +
+        this.options.text.units.hour;
+    } else if (distance < 86400) {
+      return '' +
+        about +
+        (Math.round(distance / 3600)) +
+        space +
+        this.options.text.units.hours;
+    } else if (distance < 151200) {
+      return '1' +
+        space +
+        this.options.text.units.day;
+    } else if (distance < 2592000) {
+      return '' +
+        (Math.round(distance / 86400)) +
+        space +
+        this.options.text.units.days;
+    } else if (distance < 5184000) {
+      return '' +
+        about +
+        '1' +
+        space +
+        this.options.text.units.month;
+    } else if (distance < 31536000) {
+      return '' +
+        (Math.round(distance / 2592000)) +
+        space +
+        this.options.text.units.months;
+    } else if (distance < 39312000) {
+      return '' +
+        about +
+        '1' +
+        space +
+        this.options.text.units.year;
+    } else if (distance < 54864000) {
+      return '' +
+        about +
+        '1' +
+        space +
+        this.options.text.units.year;
+    } else if (distance < 63072000) {
+      return '' +
+        about +
+        '2' +
+        space +
+        this.options.text.units.years;
+    } else {
+      return '' +
+        about +
+        (Math.round(distance / 31536000)) +
+        space +
+        this.options.text.units.years;
+    }
+  };
+
+  // TIMEAGO PLUGIN DEFINITION
+  // =========================
+
+  function Plugin(option) {
+    return this.each(function () {
+      var $this = $(this);
+      var data = $this.data('bs.timeago');
+      var options = typeof option === 'object' && option;
+
+      if (!data) $this.data('bs.timeago', (data = new Timeago(this, options)));
+      if (typeof option === 'string') data[option]();
+    });
+  }
+
+  var old = $.fn.timeago;
+
+  $.fn.timeago = Plugin;
+  $.fn.timeago.Constructor = Timeago;
+
+  // TIMEAGO NO CONFLICT
+  // ===================
+
+  $.fn.timeago.noConflict = function () {
+    $.fn.timeago = old;
+    return this;
+  };
+
+  // TIMEAGO DATA-API
+  // ================
+
+  $(document).on('ready.bs.timeago.data-api', function () {
+    $('[data-toggle="timeago"]').each(function () {
+      var $this = $(this);
+      if ($this.data('timeago')) return;
+      Plugin.call($this, $this.data());
+    });
+  });
+
+}(jQuery);