active_frontend 14.0.99 → 14.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81d929bbda4bb03643b3f14d0b48b1bfa7185a7c
-  data.tar.gz: a1f515f1c2608a3ec7b7693057b632e53034c162
+  metadata.gz: f57c9edde86486ff06bfd1b06a40ee8c37bb369e
+  data.tar.gz: 458fcea810df0496b760427523b2e1ddf12de5de
 SHA512:
-  metadata.gz: a949db01af534d560057a6a2d0563ff539be89f411948938f9535fea216144e2a203fbff2159fcdc7c91de4279d1575bb5037209d8f1071ff568e8756e9e98f7
-  data.tar.gz: 342a4d9a68ac7b28baa3e0ead15c3373c71b5e588713d17e9ba461724d99d4132f7481a7c4a576f35888b5db32c98ce89745a8ab94fc13c9cb69d6c9daa1bbe7
+  metadata.gz: dd62aead62296100fe505794f36fe0fee9b5be6f1eadb4c9b283e3a26900036cc1480d4fa5c2925ad289b0cb2479aad7c0afe4e188d2f11f25a414043c5eac25
+  data.tar.gz: bedb7761b4179de6a64f41f527a4c4239afdb6d832ded11013740f8148585ca9c789ec9190a1b514f71f3ea307402c96d22d02a553e9a2af881dd0017d70c7d8

data/lib/active_frontend/version.rb

@@ -1,3 +1,3 @@
 module ActiveFrontend
-  VERSION = '14.0.99'.freeze
+  VERSION = '14.1.0'.freeze
 end

data/lib/generators/active_frontend/templates/install.js

@@ -30,6 +30,7 @@
 //= require base/_selectpicker
 //= require base/_timepicker
 //= require base/_typeahead
+//= require base/_tag
 //= require base/_timeago
 //= require base/_switch
 //= require base/_timezone
@@ -44,5 +45,6 @@
 //= require extensions/_copy
 //= require extensions/_funnel
 //= require extensions/_map
+//= require extensions/_push
 //= require extensions/_wysiwyg
 //

data/lib/generators/active_frontend/templates/install.scss

@@ -46,6 +46,7 @@
 @import 'components/selectpicker';
 @import 'components/timepicker';
 @import 'components/typeahead';
+@import 'components/tag';
 @import 'components/ad';
 @import 'components/label_and_badge';
 @import 'components/breadcrumb';

data/vendor/assets/javascripts/active_frontend.js

@@ -30,6 +30,7 @@
 //= require base/_selectpicker
 //= require base/_timepicker
 //= require base/_typeahead
+//= require base/_tag
 //= require base/_timeago
 //= require base/_switch
 //= require base/_timezone
@@ -44,5 +45,6 @@
 //= require extensions/_copy
 //= require extensions/_funnel
 //= require extensions/_map
+//= require extensions/_push
 //= require extensions/_wysiwyg
 //

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

@@ -0,0 +1,649 @@
++function ($) {
+  'use strict';
+
+  // TAG CLASS DEFINITION
+  // ====================
+
+  var Tag = function (element, options) {
+    this.isInit = true;
+    this.itemsArray = [];
+    this.$element = $(element);
+    this.$element.hide();
+    this.isSelect = (element.tagName === 'SELECT');
+    this.multiple = (this.isSelect && element.hasAttribute('multiple'));
+    this.objectItems = options && options.itemValue;
+    this.placeholderText = element.hasAttribute('placeholder') ? this.$element.attr('placeholder') : '';
+    this.inputSize = Math.max(1, this.placeholderText.length);
+    this.$container = $('<div class="form-tags"></div>');
+    this.$input = $('<input type="text" placeholder="' + this.placeholderText + '"/>').appendTo(this.$container);
+    this.$element.before(this.$container);
+    this.build(options);
+    this.isInit = false;
+  };
+
+  Tag.VERSION = '1.0.0';
+  Tag.DEFAULTS = {
+    itemText: function(item) {
+      return this.itemValue(item);
+    },
+    itemTitle: function(item) {
+      return null;
+    },
+    itemValue: function(item) {
+      return item ? item.toString() : item;
+    },
+    onTagExists: function(item, $tag) {},
+    tagClass: function(item) {
+      return 'label';
+    },
+    addOnBlur: true,
+    allowDuplicates: false,
+    cancelConfirmKeysOnEmpty: false,
+    confirmKeys: [13, 44],
+    delimiter: ',',
+    delimiterRegex: null,
+    focusClass: 'focus',
+    freeInput: true,
+    maxChars: undefined,
+    maxTags: undefined,
+    triggerChange: true,
+    trimValue: true
+  };
+
+  Tag.prototype.constructor = Tag;
+
+  Tag.prototype.stopTimer = function () {
+    return clearTimeout(this.interval);
+  };
+
+  Tag.prototype.getHtmlAttributes = function (item) {
+    if (this.options.itemAttributes === undefined) return '';
+
+    var res = ' ';
+    var itemAttributes = this.options.itemAttributes;
+
+    for (var e in itemAttributes) {
+      if (typeof itemAttributes[e] !== 'function') {
+        res += e + '="' + itemAttributes[e].toString() + '"';
+      } else {
+        res += e + '="' + itemAttributes[e](item) + '"';
+      }
+    }
+
+    return res;
+  };
+
+  Tag.prototype.add = function(item, dontPushVal, options) {
+    var _self = this;
+
+    if (_self.options.maxTags && _self.itemsArray.length >= _self.options.maxTags) return;
+    if (item !== false && !item) return;
+
+    if (typeof item === "string" && _self.options.trimValue) {
+      item = $.trim(item);
+    }
+
+    if (typeof item === 'object' && !_self.objectItems) throw("Can't add objects when itemValue option is not set");
+    if (item.toString().match(/^\s*$/)) return;
+    if (_self.isSelect && !_self.multiple && _self.itemsArray.length > 0) _self.remove(_self.itemsArray[0]);
+
+    if (typeof item === 'string' && this.$element[0].tagName === 'INPUT') {
+      var delimiter = (_self.options.delimiterRegex) ? _self.options.delimiterRegex : _self.options.delimiter;
+      var items = item.split(delimiter);
+
+      if (items.length > 1) {
+        for (var i = 0; i < items.length; i++) {
+          this.add(items[i], true);
+        }
+
+        if (!dontPushVal) _self.pushVal(_self.options.triggerChange);
+
+        return;
+      }
+    }
+
+    var itemValue = _self.options.itemValue(item);
+    var itemText = _self.options.itemText(item);
+    var tagClass = _self.options.tagClass(item);
+    var itemTitle = _self.options.itemTitle(item);
+
+    var existing = $.grep(_self.itemsArray, function(item) {
+      return _self.options.itemValue(item) === itemValue;
+    })[0];
+
+    if (existing && !_self.options.allowDuplicates) {
+      if (_self.options.onTagExists) {
+        var $existingTag = $('.tag', _self.$container).filter(function () {
+          return $(this).data('item') === existing;
+        });
+
+        _self.options.onTagExists(item, $existingTag);
+      }
+
+      return;
+    }
+
+    if (_self.items().toString().length + item.length + 1 > _self.options.maxInputLength) return;
+
+    var beforeItemAddEvent = $.Event('beforeItemAdd', {
+      item: item,
+      cancel: false,
+      options: options
+    });
+
+    _self.$element.trigger(beforeItemAddEvent);
+
+    if (beforeItemAddEvent.cancel) return;
+
+    _self.itemsArray.push(item);
+
+    var attrs = _self.getHtmlAttributes(item);
+    var $tag = $('<span ' +
+                 _self.htmlEncode(attrs) +
+                 ' class="tag ' +
+                 _self.htmlEncode(tagClass) +
+                 (itemTitle !== null ? ('" title="' + itemTitle) : '') +
+                 '">' +
+                 _self.htmlEncode(itemText) +
+                 '<span data-role="remove"></span></span>');
+
+    $tag.data('item', item);
+
+    _self.findInputWrapper()
+      .before($tag);
+
+    $tag.after(' ');
+
+    var optionExists = (
+      $('option[value="' + encodeURIComponent(itemValue) + '"]', _self.$element).length ||
+      $('option[value="' + _self.htmlEncode(itemValue) + '"]', _self.$element).length
+    );
+
+    if (_self.isSelect && !optionExists) {
+      var $option = $('<option selected>' + _self.htmlEncode(itemText) + '</option>');
+
+      $option.data('item', item)
+        .attr('value', itemValue);
+      _self.$element.append($option);
+    }
+
+    if (!dontPushVal) _self.pushVal(_self.options.triggerChange);
+
+    if (_self.options.maxTags === _self.itemsArray.length || _self.items().toString().length === _self.options.maxInputLength) {
+      _self.$container
+        .addClass('form-tags-max');
+    }
+
+    if ($('.typeahead', _self.$container).length) {
+      setTimeout(function () {
+        _self.$input.val('');
+      }, 0);
+    }
+
+    if (this.isInit) {
+      _self.$element.trigger($.Event('itemAddedOnInit', {
+        item: item,
+        options: options
+      }));
+    } else {
+      _self.$element.trigger($.Event('itemAdded', {
+        item: item,
+        options: options
+      }));
+    }
+  };
+
+  Tag.prototype.remove = function(item, dontPushVal, options) {
+    var _self = this;
+
+    if (_self.objectItems) {
+      if (typeof item === 'object') {
+        item = $.grep(_self.itemsArray, function (other) {
+          return _self.options.itemValue(other) === _self.options.itemValue(item);
+        });
+      } else {
+        item = $.grep(_self.itemsArray, function (other) {
+          return _self.options.itemValue(other) ===  item;
+        });
+      }
+
+      item = item[item.length-1];
+    }
+
+    if (item) {
+      var beforeItemRemoveEvent = $.Event('beforeItemRemove', {
+        item: item,
+        cancel: false,
+        options: options
+      });
+
+      _self.$element.trigger(beforeItemRemoveEvent);
+
+      if (beforeItemRemoveEvent.cancel) return;
+
+      $('.tag', _self.$container).filter(function () {
+        return $(this).data('item') === item;
+      }).remove();
+      $('option', _self.$element).filter(function () {
+        return $(this).data('item') === item;
+      }).remove();
+
+      if ($.inArray(item, _self.itemsArray) !== -1) _self.itemsArray.splice($.inArray(item, _self.itemsArray), 1);
+    }
+
+    if (!dontPushVal) _self.pushVal(_self.options.triggerChange);
+
+    if (_self.options.maxTags > _self.itemsArray.length) _self.$container.removeClass('form-tags-max');
+
+    _self.$element
+      .trigger($.Event('itemRemoved',  {
+        item: item,
+        options: options
+      }));
+  };
+
+  Tag.prototype.removeAll = function() {
+    $('.tag', this.$container).remove();
+    $('option', this.$element).remove();
+
+    while(this.itemsArray.length > 0) this.itemsArray.pop();
+
+    this.pushVal(this.options.triggerChange);
+  };
+
+  Tag.prototype.refresh = function() {
+    var _self = this;
+
+    $('.tag', _self.$container).each(function() {
+      var $tag = $(this);
+      var item = $tag.data('item');
+      var itemValue = _self.options.itemValue(item);
+      var itemText = _self.options.itemText(item);
+      var tagClass = _self.options.tagClass(item);
+
+      $tag.attr('class', null);
+      $tag.addClass('tag ' + _self.htmlEncode(tagClass));
+      $tag.contents()
+          .filter(function () {
+        return this.nodeType == 3;
+      })[0].nodeValue = _self.htmlEncode(itemText);
+
+      if (_self.isSelect) {
+        var option = $('option', _self.$element).filter(function () {
+          return $(this).data('item') === item;
+        });
+
+        option.attr('value', itemValue);
+      }
+    });
+  };
+
+  Tag.prototype.items = function() {
+    return this.itemsArray;
+  };
+
+  Tag.prototype.pushVal = function() {
+    var _self = this;
+    var val = $.map(_self.items(), function (item) {
+      return _self.options.itemValue(item).toString();
+    });
+
+    _self.$element.val(val, true);
+
+    if (_self.options.triggerChange) _self.$element.trigger('change');
+  };
+
+  Tag.prototype.build = function(options) {
+    var _self = this;
+
+    _self.options = $.extend({}, Tag.DEFAULTS, options);
+
+    if (_self.objectItems) _self.options.freeInput = false;
+
+    _self.makeOptionItemFunction(_self.options, 'itemValue');
+    _self.makeOptionItemFunction(_self.options, 'itemText');
+    _self.makeOptionFunction(_self.options, 'tagClass');
+
+    if (_self.$element.data('source') || _self.options.typeahead) {
+      var typeahead = _self.$element.data('source');
+
+      if (typeahead === undefined) {
+        typeahead = _self.options.typeahead || {};
+      } else {
+        typeahead = { source: typeahead };
+      }
+
+      _self.makeOptionFunction(typeahead, 'source');
+
+      _self.$input.typeahead($.extend({}, typeahead, {
+        source: function (query, process) {
+          function processItems(items) {
+            var texts = [];
+
+            for (var i = 0; i < items.length; i++) {
+              var text = _self.options.itemText(items[i]);
+              map[text] = items[i];
+              texts.push(text);
+            }
+            process(texts);
+          }
+
+          this.map = {};
+          var map = this.map;
+          var data = typeahead.source(query);
+
+          $.when(data).then(processItems);
+        },
+        updater: function (text) {
+          _self.add(this.map[text]);
+          return this.map[text];
+        },
+        matcher: function (text) {
+          return (text.toLowerCase().indexOf(this.query.trim().toLowerCase()) !== -1);
+        },
+        sorter: function (texts) {
+          return texts.sort();
+        },
+        highlighter: function (text) {
+          var i = text.indexOf('<small');
+          var old = '';
+
+          if (i > 0) {
+            old = text.substring(i, text.length);
+            text = text.substring(0, i - 1);
+          }
+
+          var regex = new RegExp('(' + this.query + ')', 'gi');
+          return text.replace(regex, '<strong>$1</strong>') + old;
+        }
+      }));
+    }
+
+    _self.$container.on('click', $.proxy(function(event) {
+      if (! _self.$element.attr('disabled')) _self.$input.removeAttr('disabled');
+
+      _self.$input.focus();
+    }, _self));
+
+    if (_self.options.addOnBlur && _self.options.freeInput) {
+      _self.$input.on('focusout', $.proxy(function(event) {
+        if ($('.typeahead', _self.$container).length === 0) {
+          _self.add(_self.$input.val());
+          _self.$input.val('');
+        }
+      }, _self));
+    }
+
+    _self.$container.on({
+      focusin: function() {
+        _self.$container.addClass(_self.options.focusClass);
+      },
+      focusout: function() {
+        _self.$container.removeClass(_self.options.focusClass);
+      },
+    });
+
+    _self.$container.on('keydown input', 'input', $.proxy(function(event) {
+      var $input = $(event.target);
+      var $inputWrapper = _self.findInputWrapper();
+
+      if (_self.$element.attr('disabled')) {
+        _self.$input.attr('disabled', 'disabled');
+        return;
+      }
+
+      switch (event.which) {
+        case 8:
+          if (_self.doGetCaretPosition($input[0]) === 0) {
+            var prev = $inputWrapper.prev();
+
+            if (prev.length) _self.remove(prev.data('item'));
+          }
+          break;
+        case 46:
+          if (_self.doGetCaretPosition($input[0]) === 0) {
+            var next = $inputWrapper.next();
+
+            if (next.length) _self.remove(next.data('item'));
+          }
+          break;
+        case 37:
+          var $prevTag = $inputWrapper.prev();
+
+          if ($input.val().length === 0 && $prevTag[0]) {
+            $prevTag.before($inputWrapper);
+            $input.focus();
+          }
+          break;
+        case 39:
+          var $nextTag = $inputWrapper.next();
+
+          if ($input.val().length === 0 && $nextTag[0]) {
+            $nextTag.after($inputWrapper);
+            $input.focus();
+          }
+          break;
+       default:
+           // ignore
+       }
+
+      var textLength = $input.val().length;
+      var wordSpace = Math.ceil(textLength / 5);
+      var size = textLength + wordSpace + 1;
+
+      $input.attr('size', Math.max(this.inputSize, $input.val().length));
+    }, _self));
+
+    _self.$container.on('keypress', 'input', $.proxy(function(event) {
+       var $input = $(event.target);
+
+       if (_self.$element.attr('disabled')) {
+          _self.$input.attr('disabled', 'disabled');
+          return;
+       }
+
+       var text = $input.val();
+       var maxLengthReached = _self.options.maxChars && text.length >= _self.options.maxChars;
+
+       if (_self.options.freeInput && (_self.keyCombinationInList(event, _self.options.confirmKeys) || maxLengthReached)) {
+         if (text.length !== 0) {
+           _self.add(maxLengthReached ? text.substr(0, _self.options.maxChars) : text);
+           $input.val('');
+         }
+
+         if (_self.options.cancelConfirmKeysOnEmpty === false) event.preventDefault();
+       }
+
+       var textLength = $input.val().length;
+       var wordSpace = Math.ceil(textLength / 5);
+       var size = textLength + wordSpace + 1;
+
+       $input.attr('size', Math.max(this.inputSize, $input.val().length));
+    }, _self));
+
+    _self.$container.on('click', '[data-role=remove]', $.proxy(function(event) {
+      if (_self.$element.attr('disabled')) return;
+
+      _self.remove($(event.target).closest('.tag').data('item'));
+    }, _self));
+
+    if (_self.options.itemValue === Tag.DEFAULTS.itemValue) {
+      if (_self.$element[0].tagName === 'INPUT') {
+        _self.add(_self.$element.val());
+      } else {
+        $('option', _self.$element).each(function() {
+          _self.add($(this).attr('value'), true);
+        });
+      }
+    }
+  };
+
+  Tag.prototype.destroy = function() {
+    var _self = this;
+
+    this.$container
+      .off('keypress', 'input')
+      .off('click', '[role=remove]')
+      .remove();
+
+    this.$element
+      .removeData('tagsinput')
+      .show();
+  };
+
+  Tag.prototype.focus = function() {
+    this.$input.focus();
+  };
+
+  Tag.prototype.input = function() {
+    return this.$input;
+  };
+
+  Tag.prototype.findInputWrapper = function() {
+    var elt = this.$input[0];
+    var container = this.$container[0];
+
+    while (elt && elt.parentNode !== container) {
+      elt = elt.parentNode;
+    }
+
+    return $(elt);
+  };
+
+  Tag.prototype.makeOptionItemFunction = function (options, key) {
+    if (typeof options[key] !== 'function') {
+      var propertyName = options[key];
+
+      options[key] = function(item) {
+        return item[propertyName];
+      };
+    }
+  };
+
+  Tag.prototype.makeOptionFunction = function (options, key) {
+    if (typeof options[key] !== 'function') {
+      var value = options[key];
+
+      options[key] = function() {
+        return value;
+      };
+    }
+  };
+
+  Tag.prototype.doGetCaretPosition = function (oField) {
+    var iCaretPos = 0;
+
+    if (document.selection) {
+      oField.focus ();
+
+      var oSel = document.selection.createRange();
+
+      oSel.moveStart('character', -oField.value.length);
+
+      iCaretPos = oSel.text.length;
+    } else if (oField.selectionStart || oField.selectionStart == '0') {
+      iCaretPos = oField.selectionStart;
+    }
+
+    return (iCaretPos);
+  };
+
+  Tag.prototype.keyCombinationInList = function (keyPressEvent, lookupList) {
+    var found = false;
+
+    $.each(lookupList, function (index, keyCombination) {
+      if (typeof (keyCombination) === 'number' && keyPressEvent.which === keyCombination) {
+        found = true;
+        return false;
+      }
+
+      if (keyPressEvent.which === keyCombination.which) {
+        var alt = !keyCombination.hasOwnProperty('altKey') || keyPressEvent.altKey === keyCombination.altKey;
+        var shift = !keyCombination.hasOwnProperty('shiftKey') || keyPressEvent.shiftKey === keyCombination.shiftKey;
+        var ctrl = !keyCombination.hasOwnProperty('ctrlKey') || keyPressEvent.ctrlKey === keyCombination.ctrlKey;
+
+        if (alt && shift && ctrl) {
+          found = true;
+          return false;
+        }
+      }
+    });
+
+    return found;
+  };
+
+  Tag.prototype.htmlEncode = function (value) {
+    if (value) {
+      return $('<div />').text(value).html();
+    } else {
+      return '';
+    }
+  };
+
+  // TAG PLUGIN DEFINITION
+  // =====================
+
+  function Plugin(arg1, arg2, arg3) {
+    var results = [];
+
+    this.each(function () {
+      var _self = $(this);
+      var tagsinput = _self.data('tagsinput');
+
+      if (!tagsinput) {
+        tagsinput = new Tag(this, arg1);
+
+        _self.data('tagsinput', tagsinput);
+
+        results.push(tagsinput);
+
+        if (this.tagName === 'SELECT') $('option', _self).attr('selected', 'selected');
+
+        _self.val(_self.val());
+      } else if (!arg1 && !arg2) {
+        results.push(tagsinput);
+      } else if (tagsinput[arg1] !== undefined) {
+        var retVal;
+
+        if (tagsinput[arg1].length === 3 && arg3 !== undefined){
+          retVal = tagsinput[arg1](arg2, null, arg3);
+        } else {
+          retVal = tagsinput[arg1](arg2);
+        }
+
+        if (retVal !== undefined) results.push(retVal);
+      }
+    });
+
+    if (typeof arg1 === 'string') {
+      return results.length > 1 ? results : results[0];
+    } else {
+      return results;
+    }
+  }
+
+  var old = $.fn.tag;
+
+  $.fn.tag = Plugin;
+  $.fn.tag.Constructor = Tag;
+
+  // TAG NO CONFLICT
+  // ===============
+
+  $.fn.tag.noConflict = function () {
+    $.fn.tag = old;
+    return this;
+  };
+
+  // TAG DATA-API
+  // ============
+
+  $(document).on('ready.bs.tag.data-api', function () {
+    $('[data-toggle="tag"]').each(function () {
+      var $this = $(this);
+      if ($this.data('tag')) return;
+      Plugin.call($this, $this.data());
+    });
+  });
+
+}(jQuery);

data/vendor/assets/javascripts/extensions/_push.js

@@ -0,0 +1,372 @@
+(function (global, factory) {
+  'use strict';
+
+  if (typeof define === 'function' && define.amd) {
+    define(function () {
+      return new (factory(global, global.document))();
+    });
+  } else if (typeof module !== 'undefined' && module.exports) {
+    module.exports = new (factory(global, global.document))();
+  } else {
+    global.Push = new (factory(global, global.document))();
+  }
+})(typeof window !== 'undefined' ? window : this, function (w, d) {
+  var Push = function () {
+    var
+    self = this,
+    isUndefined = function (obj) { return obj === undefined; },
+    isString = function (obj) { return typeof obj === 'string'; },
+    isFunction = function (obj) { return obj && {}.toString.call(obj) === '[object Function]'; },
+    currentId = 0,
+    incompatibilityErrorMessage = 'PushError: push.js is incompatible with browser.',
+    notifications = {},
+    lastWorkerPath = null,
+
+    closeNotification = function (id) {
+      var errored = false;
+      var notification = notifications[id];
+
+      if (typeof notification !== 'undefined') {
+        if (notification.close) {
+          notification.close();
+        } else if (notification.cancel) {
+          notification.cancel();
+        } else if (w.external && w.external.msIsSiteMode) {
+          w.external.msSiteModeClearIconOverlay();
+        } else {
+          errored = true;
+          throw new Error('Unable to close notification: unknown interface');
+        }
+
+        if (!errored) return removeNotification(id);
+      }
+
+      return false;
+    },
+
+    addNotification = function (notification) {
+      var id = currentId;
+
+      notifications[id] = notification;
+      currentId++;
+
+      return id;
+    },
+
+    removeNotification = function (id) {
+      var dict = {};
+      var success = false;
+      var key;
+
+      for (key in notifications) {
+        if (notifications.hasOwnProperty(key)) {
+          if (key != id) {
+            dict[key] = notifications[key];
+          } else {
+            success = true;
+          }
+        }
+      }
+
+      notifications = dict;
+
+      return success;
+    },
+
+    prepareNotification = function (id, options) {
+      var wrapper;
+
+      wrapper = {
+        get: function () {
+          return notifications[id];
+        },
+        close: function () {
+          closeNotification(id);
+        }
+      };
+
+      if (options.timeout) {
+        setTimeout(function () {
+          wrapper.close();
+        }, options.timeout);
+      }
+
+      return wrapper;
+    },
+
+    createCallback = function (title, options, resolve) {
+      var notification;
+      var onClose;
+
+      options = options || {};
+
+      self.lastWorkerPath = options.serviceWorker || 'serviceWorker.js';
+
+      onClose = function (id) {
+        removeNotification(id);
+
+        if (isFunction(options.onClose)) {
+          options.onClose.call(this, notification);
+        }
+      };
+
+      if (w.Notification) {
+        try {
+          notification =  new w.Notification(title, {
+            icon: (isString(options.icon) || isUndefined(options.icon)) ? options.icon : options.icon.x32,
+            body: options.body,
+            tag: options.tag,
+            requireInteraction: options.requireInteraction,
+            silent: options.silent
+          });
+        } catch (e) {
+          if (w.navigator) {
+            w.navigator.serviceWorker.register(self.lastWorkerPath);
+            w.navigator.serviceWorker.ready.then(function (registration) {
+              var localData = {
+                id: currentId,
+                link: options.link,
+                origin: document.location.href,
+                onClick: (isFunction(options.onClick)) ? options.onClick.toString() : '',
+                onClose: (isFunction(options.onClose)) ? options.onClose.toString() : ''
+              };
+
+              if (typeof options.data !== 'undefined' && options.data !== null) {
+                localData = Object.assign(localData, options.data);
+              }
+
+              registration.showNotification(title, {
+                icon: options.icon,
+                body: options.body,
+                vibrate: options.vibrate,
+                tag: options.tag,
+                data: localData,
+                requireInteraction: options.requireInteraction
+              }).then(function() {
+                var id;
+
+                registration.getNotifications().then(function(notifications) {
+                  id = addNotification(notifications[notifications.length - 1]);
+
+                  registration.active.postMessage('');
+                  navigator.serviceWorker.addEventListener('message', function (event) {
+                    var data = JSON.parse(event.data);
+
+                    if (data.action === 'close' && Number.isInteger(data.id)) removeNotification(data.id);
+                  });
+
+                  resolve(prepareNotification(id, options));
+                });
+              });
+            });
+          }
+        }
+      } else if (w.webkitNotifications) {
+        notification = w.webkitNotifications.createNotification(
+          options.icon,
+          title,
+          options.body
+        );
+
+        notification.show();
+      } else if (navigator.mozNotification) {
+        notification = navigator.mozNotification.createNotification(
+            title,
+            options.body,
+            options.icon
+        );
+
+        notification.show();
+      } else if (w.external && w.external.msIsSiteMode()) {
+        w.external.msSiteModeClearIconOverlay();
+        w.external.msSiteModeSetIconOverlay(
+          ((isString(options.icon) || isUndefined(options.icon)) ? options.icon : options.icon.x16),
+          title
+        );
+        w.external.msSiteModeActivate();
+
+        notification = {};
+      } else {
+        throw new Error('Unable to create notification: unknown interface');
+      }
+
+      if (typeof(notification) !== 'undefined') {
+        var id = addNotification(notification);
+        var wrapper = prepareNotification(id, options);
+
+        if (isFunction(options.onShow)) notification.addEventListener('show', options.onShow);
+        if (isFunction(options.onError)) notification.addEventListener('error', options.onError);
+        if (isFunction(options.onClick)) notification.addEventListener('click', options.onClick);
+
+        notification.addEventListener('close', function() {
+          onClose(id);
+        });
+        notification.addEventListener('cancel', function() {
+          onClose(id);
+        });
+
+        resolve(wrapper);
+      }
+
+      resolve({});
+    },
+
+    Permission = {
+      DEFAULT: 'default',
+      GRANTED: 'granted',
+      DENIED: 'denied'
+    },
+
+    Permissions = [Permission.GRANTED, Permission.DEFAULT, Permission.DENIED];
+
+    self.Permission = Permission;
+
+    self.Permission.request = function (onGranted, onDenied) {
+      var existing = self.Permission.get();
+
+      if (!self.isSupported) {
+        throw new Error(incompatibilityErrorMessage);
+      }
+
+      callback = function (result) {
+        switch (result) {
+          case self.Permission.GRANTED:
+            if (onGranted) onGranted();
+            break;
+          case self.Permission.DENIED:
+            if (onDenied) onDenied();
+            break;
+          default:
+            // Nothing
+        }
+      };
+
+      if (existing !== self.Permission.DEFAULT) {
+        callback(existing);
+      } else if (w.Notification && w.Notification.requestPermission) {
+        Notification.requestPermission(callback);
+      } else if (w.webkitNotifications && w.webkitNotifications.checkPermission) {
+        w.webkitNotifications.requestPermission(callback);
+      } else {
+        throw new Error(incompatibilityErrorMessage);
+      }
+    };
+
+    self.Permission.has = function () {
+      return Permission.get() === Permission.GRANTED;
+    };
+
+    self.Permission.get = function () {
+      var permission;
+
+      if (!self.isSupported) {
+        throw new Error(incompatibilityErrorMessage);
+      }
+
+      if (w.Notification && w.Notification.permissionLevel) {
+        permission = w.Notification.permissionLevel;
+      } else if (w.webkitNotifications && w.webkitNotifications.checkPermission) {
+        permission = Permissions[w.webkitNotifications.checkPermission()];
+      } else if (w.Notification && w.Notification.permission) {
+        permission = w.Notification.permission;
+      } else if (navigator.mozNotification) {
+        permission = Permission.GRANTED;
+      } else if (w.external && w.external.msIsSiteMode() !== undefined) {
+        permission = w.external.msIsSiteMode() ? Permission.GRANTED : Permission.DEFAULT;
+      } else {
+        throw new Error(incompatibilityErrorMessage);
+      }
+
+      return permission;
+    };
+
+    self.isSupported = (function () {
+      var isSupported = false;
+
+      try {
+        isSupported = !!(w.Notification ||
+          w.webkitNotifications ||
+          navigator.mozNotification ||
+          (w.external && w.external.msIsSiteMode() !== undefined));
+      } catch (e) {
+        // Nothing
+      }
+
+      return isSupported;
+    })();
+
+    self.create = function (title, options) {
+      var promiseCallback;
+
+      if (!self.isSupported) {
+        throw new Error(incompatibilityErrorMessage);
+      }
+
+      if (!isString(title)) {
+        throw new Error('PushError: Title of notification must be a string');
+      }
+
+      if (!self.Permission.has()) {
+        promiseCallback = function(resolve, reject) {
+          self.Permission.request(function() {
+            try {
+              createCallback(title, options, resolve);
+            } catch (e) {
+              reject(e);
+            }
+          }, function() {
+            reject('Permission request declined');
+          });
+        };
+      } else {
+        promiseCallback = function(resolve, reject) {
+          try {
+            createCallback(title, options, resolve);
+          } catch (e) {
+            reject(e);
+          }
+        };
+      }
+
+      return new Promise(promiseCallback);
+    };
+
+    self.count = function () {
+      var count = 0;
+      var key;
+
+      for (key in notifications) {
+        count++;
+      }
+
+      return count;
+    },
+
+    self.__lastWorkerPath = function () {
+      return self.lastWorkerPath;
+    },
+
+    self.close = function (tag) {
+      var key;
+
+      for (key in notifications) {
+        notification = notifications[key];
+
+        if (notification.tag === tag) return closeNotification(key);
+      }
+    },
+
+    self.clear = function () {
+      var success = true;
+      var key;
+
+      for (key in notifications) {
+        success = success && closeNotification(key);
+      }
+
+      return success;
+    };
+  };
+
+  return Push;
+});

data/vendor/assets/stylesheets/active_frontend.scss

@@ -46,6 +46,7 @@
 @import 'components/selectpicker';
 @import 'components/timepicker';
 @import 'components/typeahead';
+@import 'components/tag';
 @import 'components/ad';
 @import 'components/label_and_badge';
 @import 'components/breadcrumb';

data/vendor/assets/stylesheets/blocks/_form.scss

@@ -5,6 +5,7 @@
 // Selects
 // Checkboxes & Radios
 // Notes
+// Tags
 // Labels
 // Addons
 
@@ -43,7 +44,8 @@ input { overflow: visible; }
 optgroup { font-weight: text-weight(semibold); }
 input,
 select,
-textarea {
+textarea,
+.form-tags {
   @include appearance(none);
   @include transition(all 0.3s ease-in-out);
   background: color(white);
@@ -59,7 +61,8 @@ textarea {
 }
 input:not([type='submit']),
 select,
-textarea {
+textarea,
+.form-tags {
   box-shadow: inset 0 2px 0 0 darkish-color(light-haze);
 
   &.dark {
@@ -80,11 +83,13 @@ textarea {
     color: color(gray);
     font-weight: text-weight(normal) !important;
   }
-  &:focus {
+  &:focus,
+  &.focus {
     box-shadow: inset 0 2px 0 0 transparentize(color(blue), 0.5);
     border-color: color(blue);
   }
-  &:focus:invalid {
+  &:focus:invalid,
+  &.focus:invalid {
     box-shadow: inset 0 2px 0 0 transparentize(color(red), 0.5);
     border-color: color(red);
   }
@@ -436,6 +441,24 @@ textarea {
   margin: -10px 0 10px;
 }
 
+// Tags
+// ==================================================
+.form-tags {
+  white-space: normal;
+
+  input,
+  input:focus {
+    background: color(transparent);
+    border: 0;
+    box-shadow: none;
+    display: inline-block;
+    outline: none;
+    margin: 0;
+    padding: 0;
+    width: auto;
+  }
+}
+
 // Labels
 // ==================================================
 .form-input,

data/vendor/assets/stylesheets/components/_tag.scss

@@ -0,0 +1,23 @@
+// Table of Contents
+// ==================================================
+// Tag
+
+// scss-lint:disable ImportantRule
+
+// Tag
+// ==================================================
+.tag {
+  margin: 2px 2px 2px 0;
+  padding-right: 22px !important;
+
+  [data-role='remove'] {
+    cursor: pointer;
+    margin-left: 5px;
+
+    &::after {
+      content: '\39';
+      font-family: 'dripicons';
+      position: absolute;
+    }
+  }
+}

data/vendor/assets/stylesheets/components/_typeahead.scss

@@ -10,11 +10,9 @@
   margin-top: 10px;
   z-index: 1060;
 
-  > li > a b { color: color(blue); }
-}
-x {
-  display: block;
-  color: color(gray);
-  font-style: italic;
-  font-weight: normal;
+  > li > a b,
+  > li.active > a {
+    color: color(blue);
+    font-weight: text-weight(semibold);
+  }
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_frontend
 version: !ruby/object:Gem::Version
-  version: 14.0.99
+  version: 14.1.0
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-13 00:00:00.000000000 Z
+date: 2017-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -238,6 +238,7 @@ files:
 - vendor/assets/javascripts/base/_switch.js
 - vendor/assets/javascripts/base/_tab.js
 - vendor/assets/javascripts/base/_table.js
+- vendor/assets/javascripts/base/_tag.js
 - vendor/assets/javascripts/base/_timeago.js
 - vendor/assets/javascripts/base/_timepicker.js
 - vendor/assets/javascripts/base/_timezone.js
@@ -251,6 +252,7 @@ files:
 - vendor/assets/javascripts/extensions/_copy.js
 - vendor/assets/javascripts/extensions/_funnel.js
 - vendor/assets/javascripts/extensions/_map.js
+- vendor/assets/javascripts/extensions/_push.js
 - vendor/assets/javascripts/extensions/_wysiwyg.js
 - vendor/assets/stylesheets/.DS_Store
 - vendor/assets/stylesheets/.keep
@@ -303,6 +305,7 @@ files:
 - vendor/assets/stylesheets/components/_sidebar.scss
 - vendor/assets/stylesheets/components/_spinner.scss
 - vendor/assets/stylesheets/components/_switch.scss
+- vendor/assets/stylesheets/components/_tag.scss
 - vendor/assets/stylesheets/components/_timepicker.scss
 - vendor/assets/stylesheets/components/_tooltip.scss
 - vendor/assets/stylesheets/components/_transition.scss