active_frontend 14.0.80 → 14.0.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26f7d6c60198c236566908ce470752f07eafc567
-  data.tar.gz: 88ffb6f56d5f9cf115a007cbae049f983a670f74
+  metadata.gz: 89561af6ed088ed080187332c73c80be8cb12c91
+  data.tar.gz: 73ae8b120387fee13410c469a07279a41cbbcfff
 SHA512:
-  metadata.gz: 89129309ff6370cd03149c63ee8c613544a6299369be28fe8f778867a4f5fa88b128af7bd13e2d556b4233eecee9361b1046b1c9c5d4a4f7945e3610e64392ab
-  data.tar.gz: 8749fc2fe027b08be732d735c84029be1fe2cf2bada74d39ff0e6143f294e9b6b89f8fb30586f498a0b9f6605e92d9adbeffe96e8f16220a184ce9938201d39c
+  metadata.gz: a8450019cbeb9a6033074ad449e989e8c0269942b4e58a00167392a84f6a63edda440e04563bef3f03b9eecf90b72752761e25f0c60218d9141444f691ddd3d2
+  data.tar.gz: 629cb40ede38167b660b2db308205c98ed7215d0a8d6667bb206576750cf252aca7567604bb8094a18da97f231cdc6f9cfaa35c699fd5a394f9ebc2de367dcf0

data/lib/active_frontend/version.rb

@@ -1,3 +1,3 @@
 module ActiveFrontend
-  VERSION = '14.0.80'.freeze
+  VERSION = '14.0.81'.freeze
 end

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

@@ -40,6 +40,7 @@
 // ==================================================
 //= require extensions/_calendar
 //= require extensions/_chart
+//= require extensions/_copy
 //= require extensions/_map
 //= require extensions/_wysiwyg
 //

data/vendor/assets/javascripts/active_frontend.js

@@ -40,6 +40,7 @@
 // ==================================================
 //= require extensions/_calendar
 //= require extensions/_chart
+//= require extensions/_copy
 //= require extensions/_map
 //= require extensions/_wysiwyg
 //

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

@@ -0,0 +1,694 @@
+(function (f) {
+  if (typeof exports === 'object' &&typeof module !== 'undefined') {
+    module.exports = f();
+  } else if (typeof define === 'function' && define.amd) {
+    define([], f);
+  } else {
+    var g;
+
+    if (typeof window !== 'undefined') {
+      g = window;
+    } else if (typeof global !== 'undefined') {
+      g = global;
+    } else if (typeof self !== 'undefined') {
+      g = self;
+    } else {
+      g = this;
+    }
+
+    g.Clipboard = f();
+  }
+})
+
+(function() {
+  var define, module, exports;
+
+  return (function e(t, n, r) {
+    function s(o, u) {
+      if(!n[o]) {
+        if(!t[o]) {
+          var a = typeof require == 'function' && require;
+
+          if(!u && a) return a(o,!0);
+          if(i) return i(o,!0);
+
+          var f = new Error("Cannot find module '" + o + "'");
+
+          throw f.code = "MODULE_NOT_FOUND", f
+        }
+
+        var l = n[o] = {
+          exports:{}
+        };
+
+        t[o][0].call(l.exports, function(e) {
+          var n=t[o][1][e];
+          return s(n ? n:e);
+        }, l, l.exports, e, t, n, r)}
+
+        return n[o].exports;
+      }
+
+      var i = typeof require == 'function' && require;
+
+      for (var o = 0; o < r.length; o++) s(r[o]);
+
+      return s;
+    })({ 1: [function(require, module, exports) {
+
+var DOCUMENT_NODE_TYPE = 9;
+
+if (typeof Element !== 'undefined' && !Element.prototype.matches) {
+  var proto = Element.prototype;
+
+  proto.matches = proto.matchesSelector ||
+                  proto.mozMatchesSelector ||
+                  proto.msMatchesSelector ||
+                  proto.oMatchesSelector ||
+                  proto.webkitMatchesSelector;
+}
+
+function closest (element, selector) {
+  while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
+    if (element.matches(selector)) return element;
+    element = element.parentNode;
+  }
+}
+
+module.exports = closest;
+
+}, {}], 2:[function(require, module, exports) {
+var closest = require('./closest');
+
+function delegate(element, selector, type, callback, useCapture) {
+  var listenerFn = listener.apply(this, arguments);
+
+  element.addEventListener(type, listenerFn, useCapture);
+
+  return {
+    destroy: function() {
+      element.removeEventListener(type, listenerFn, useCapture);
+    }
+  };
+}
+
+function listener(element, selector, type, callback) {
+  return function(e) {
+    e.delegateTarget = closest(e.target, selector);
+
+    if (e.delegateTarget) callback.call(element, e);
+  };
+}
+
+module.exports = delegate;
+
+}, { './closest': 1 }], 3: [function(require, module, exports) {
+
+exports.node = function(value) {
+  return value !== undefined &&
+    value instanceof HTMLElement &&
+    value.nodeType === 1;
+};
+
+exports.nodeList = function(value) {
+  var type = Object.prototype.toString.call(value);
+
+  return value !== undefined &&
+    (type === '[object NodeList]' || type === '[object HTMLCollection]') &&
+    ('length' in value) &&
+    (value.length === 0 || exports.node(value[0]));
+};
+
+exports.string = function(value) {
+  return typeof value === 'string' ||
+    value instanceof String;
+};
+
+exports.fn = function(value) {
+  var type = Object.prototype.toString.call(value);
+
+  return type === '[object Function]';
+};
+
+}, {}], 4: [function(require, module, exports){
+var is = require('./is');
+var delegate = require('delegate');
+
+function listen(target, type, callback) {
+  if (!target && !type && !callback) {
+    throw new Error('Missing required arguments');
+  }
+
+  if (!is.string(type)) {
+    throw new TypeError('Second argument must be a String');
+  }
+
+  if (!is.fn(callback)) {
+    throw new TypeError('Third argument must be a Function');
+  }
+
+  if (is.node(target)) {
+    return listenNode(target, type, callback);
+  }
+  else if (is.nodeList(target)) {
+    return listenNodeList(target, type, callback);
+  }
+  else if (is.string(target)) {
+    return listenSelector(target, type, callback);
+  }
+  else {
+    throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
+  }
+}
+
+function listenNode(node, type, callback) {
+  node.addEventListener(type, callback);
+
+  return {
+    destroy: function() {
+      node.removeEventListener(type, callback);
+    }
+  };
+}
+
+function listenNodeList(nodeList, type, callback) {
+  Array.prototype.forEach.call(nodeList, function(node) {
+    node.addEventListener(type, callback);
+  });
+
+  return {
+    destroy: function() {
+      Array.prototype.forEach.call(nodeList, function(node) {
+        node.removeEventListener(type, callback);
+      });
+    }
+  };
+}
+
+function listenSelector(selector, type, callback) {
+  return delegate(document.body, selector, type, callback);
+}
+
+module.exports = listen;
+
+}, { './is': 3, 'delegate': 2 }], 5: [function(require, module, exports) {
+function select(element) {
+  var selectedText;
+
+  if (element.nodeName === 'SELECT') {
+    element.focus();
+    selectedText = element.value;
+  } else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
+    var isReadOnly = element.hasAttribute('readonly');
+
+    if (!isReadOnly) element.setAttribute('readonly', '');
+
+    element.select();
+    element.setSelectionRange(0, element.value.length);
+
+    if (!isReadOnly) element.removeAttribute('readonly');
+
+    selectedText = element.value;
+  } else {
+    if (element.hasAttribute('contenteditable')) element.focus();
+
+    var selection = window.getSelection();
+    var range = document.createRange();
+
+    range.selectNodeContents(element);
+    selection.removeAllRanges();
+    selection.addRange(range);
+
+    selectedText = selection.toString();
+  }
+
+  return selectedText;
+}
+
+module.exports = select;
+
+}, {}], 6: [function(require, module, exports) {
+function E () {
+  // Keep this empty so it's easier to inherit from
+  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+}
+
+E.prototype = {
+  on: function (name, callback, ctx) {
+    var e = this.e || (this.e = {});
+
+    (e[name] || (e[name] = [])).push({
+      fn: callback,
+      ctx: ctx
+    });
+
+    return this;
+  },
+
+  once: function (name, callback, ctx) {
+    var self = this;
+    function listener () {
+      self.off(name, listener);
+      callback.apply(ctx, arguments);
+    }
+
+    listener._ = callback;
+    return this.on(name, listener, ctx);
+  },
+
+  emit: function (name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
+
+    return this;
+  },
+
+  off: function (name, callback) {
+    var e = this.e || (this.e = {});
+    var evts = e[name];
+    var liveEvents = [];
+
+    if (evts && callback) {
+      for (var i = 0, len = evts.length; i < len; i++) {
+        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+          liveEvents.push(evts[i]);
+      }
+    }
+
+    // Remove event from queue to prevent memory leak
+    // Suggested by https://github.com/lazd
+    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+
+    (liveEvents.length) ? e[name] = liveEvents : delete e[name];
+
+    return this;
+  }
+};
+
+module.exports = E;
+
+}, {}], 7: [function(require, module, exports) {
+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['module', 'select'], factory);
+  } else if (typeof exports !== 'undefined') {
+    factory(module, require('select'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod, global.select);
+    global.clipboardAction = mod.exports;
+  }
+})(this, function (module, _select) {
+  'use strict';
+
+  var _select2 = _interopRequireDefault(_select);
+
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+      default: obj
+    };
+  }
+
+  var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
+  };
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError('Cannot call a class as a function');
+    }
+  }
+
+  var _createClass = function () {
+    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);
+      }
+    }
+
+    return function (Constructor, protoProps, staticProps) {
+      if (protoProps) defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) defineProperties(Constructor, staticProps);
+      return Constructor;
+    };
+  }();
+
+  var ClipboardAction = function () {
+    function ClipboardAction(options) {
+      _classCallCheck(this, ClipboardAction);
+      this.resolveOptions(options);
+      this.initSelection();
+    }
+
+    _createClass(ClipboardAction, [{
+      key: 'resolveOptions',
+      value: function resolveOptions() {
+          var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+          this.action = options.action;
+          this.emitter = options.emitter;
+          this.target = options.target;
+          this.text = options.text;
+          this.trigger = options.trigger;
+
+          this.selectedText = '';
+      }
+    }, {
+      key: 'initSelection',
+      value: function initSelection() {
+        if (this.text) {
+            this.selectFake();
+        } else if (this.target) {
+            this.selectTarget();
+        }
+      }
+    }, {
+      key: 'selectFake',
+      value: function selectFake() {
+        var _this = this;
+
+        var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
+
+        this.removeFake();
+
+        this.fakeHandlerCallback = function () {
+            return _this.removeFake();
+        };
+        this.fakeHandler = document.body.addEventListener('click', this.fakeHandlerCallback) || true;
+
+        this.fakeElem = document.createElement('textarea');
+        // Prevent zooming on iOS
+        this.fakeElem.style.fontSize = '12pt';
+        // Reset box model
+        this.fakeElem.style.border = '0';
+        this.fakeElem.style.padding = '0';
+        this.fakeElem.style.margin = '0';
+        // Move element out of screen horizontally
+        this.fakeElem.style.position = 'absolute';
+        this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
+        // Move element to the same position vertically
+        var yPosition = window.pageYOffset || document.documentElement.scrollTop;
+        this.fakeElem.style.top = yPosition + 'px';
+
+        this.fakeElem.setAttribute('readonly', '');
+        this.fakeElem.value = this.text;
+
+        document.body.appendChild(this.fakeElem);
+
+        this.selectedText = (0, _select2.default)(this.fakeElem);
+        this.copyText();
+      }
+    }, {
+      key: 'removeFake',
+      value: function removeFake() {
+        if (this.fakeHandler) {
+          document.body.removeEventListener('click', this.fakeHandlerCallback);
+          this.fakeHandler = null;
+          this.fakeHandlerCallback = null;
+        }
+
+        if (this.fakeElem) {
+          document.body.removeChild(this.fakeElem);
+          this.fakeElem = null;
+        }
+      }
+    }, {
+      key: 'selectTarget',
+      value: function selectTarget() {
+        this.selectedText = (0, _select2.default)(this.target);
+        this.copyText();
+      }
+    }, {
+      key: 'copyText',
+      value: function copyText() {
+        var succeeded = void 0;
+
+        try {
+          succeeded = document.execCommand(this.action);
+        } catch (err) {
+          succeeded = false;
+        }
+
+        this.handleResult(succeeded);
+      }
+    }, {
+      key: 'handleResult',
+      value: function handleResult(succeeded) {
+        this.emitter.emit(succeeded ? 'success' : 'error', {
+          action: this.action,
+          text: this.selectedText,
+          trigger: this.trigger,
+          clearSelection: this.clearSelection.bind(this)
+        });
+      }
+    }, {
+      key: 'clearSelection',
+      value: function clearSelection() {
+        if (this.target) this.target.blur();
+        window.getSelection().removeAllRanges();
+      }
+    }, {
+      key: 'destroy',
+      value: function destroy() {
+        this.removeFake();
+      }
+    }, {
+      key: 'action',
+      set: function set() {
+        var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
+
+        this._action = action;
+
+        if (this._action !== 'copy' && this._action !== 'cut') {
+          throw new Error('Invalid "action" value, use either "copy" or "cut"');
+        }
+      },
+      get: function get() {
+        return this._action;
+      }
+    }, {
+      key: 'target',
+      set: function set(target) {
+        if (target !== undefined) {
+          if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
+            if (this.action === 'copy' && target.hasAttribute('disabled')) {
+              throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+            }
+
+            if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
+              throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
+            }
+
+            this._target = target;
+          } else {
+            throw new Error('Invalid "target" value, use a valid Element');
+          }
+        }
+      },
+      get: function get() {
+        return this._target;
+      }
+    }]);
+
+    return ClipboardAction;
+  }();
+
+  module.exports = ClipboardAction;
+});
+
+}, { 'select': 5}], 8: [function(require, module, exports) {
+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['module', './clipboard-action', 'tiny-emitter', 'good-listener'], factory);
+  } else if (typeof exports !== 'undefined') {
+    factory(module, require('./clipboard-action'), require('tiny-emitter'), require('good-listener'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod, global.clipboardAction, global.tinyEmitter, global.goodListener);
+    global.clipboard = mod.exports;
+  }
+})(this, function (module, _clipboardAction, _tinyEmitter, _goodListener) {
+  'use strict';
+
+  var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
+  var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
+  var _goodListener2 = _interopRequireDefault(_goodListener);
+
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+      default: obj
+    };
+  }
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  var _createClass = function () {
+    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);
+      }
+    }
+
+    return function (Constructor, protoProps, staticProps) {
+      if (protoProps) defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) defineProperties(Constructor, staticProps);
+      return Constructor;
+    };
+  }();
+
+  function _possibleConstructorReturn(self, call) {
+    if (!self) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return call && (typeof call === "object" || typeof call === 'function') ? call : self;
+  }
+
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== 'function' && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+
+    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+  }
+
+  var Clipboard = function (_Emitter) {
+    _inherits(Clipboard, _Emitter);
+
+    function Clipboard(trigger, options) {
+      _classCallCheck(this, Clipboard);
+
+      var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));
+
+      _this.resolveOptions(options);
+      _this.listenClick(trigger);
+      return _this;
+    }
+
+    _createClass(Clipboard, [{
+      key: 'resolveOptions',
+      value: function resolveOptions() {
+        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
+        this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
+        this.text = typeof options.text === 'function' ? options.text : this.defaultText;
+      }
+    }, {
+      key: 'listenClick',
+      value: function listenClick(trigger) {
+        var _this2 = this;
+
+        this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) {
+          return _this2.onClick(e);
+        });
+      }
+    }, {
+        key: 'onClick',
+        value: function onClick(e) {
+          var trigger = e.delegateTarget || e.currentTarget;
+
+          if (this.clipboardAction) {
+            this.clipboardAction = null;
+          }
+
+          this.clipboardAction = new _clipboardAction2.default({
+              action: this.action(trigger),
+              target: this.target(trigger),
+              text: this.text(trigger),
+              trigger: trigger,
+              emitter: this
+          });
+        }
+    }, {
+      key: 'defaultAction',
+      value: function defaultAction(trigger) {
+        return getAttributeValue('action', trigger);
+      }
+    }, {
+      key: 'defaultTarget',
+      value: function defaultTarget(trigger) {
+        var selector = getAttributeValue('target', trigger);
+
+        if (selector) return document.querySelector(selector);
+      }
+    }, {
+      key: 'defaultText',
+      value: function defaultText(trigger) {
+        return getAttributeValue('text', trigger);
+      }
+    }, {
+      key: 'destroy',
+      value: function destroy() {
+        this.listener.destroy();
+
+        if (this.clipboardAction) {
+          this.clipboardAction.destroy();
+          this.clipboardAction = null;
+        }
+      }
+    }], [{
+      key: 'isSupported',
+      value: function isSupported() {
+        var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
+
+        var actions = typeof action === 'string' ? [action] : action;
+        var support = !!document.queryCommandSupported;
+
+        actions.forEach(function (action) {
+          support = support && !!document.queryCommandSupported(action);
+        });
+
+        return support;
+      }
+    }]);
+
+    return Clipboard;
+  }(_tinyEmitter2.default);
+
+  function getAttributeValue(suffix, element) {
+    var attribute = 'data-clipboard-' + suffix;
+
+    if (!element.hasAttribute(attribute)) return;
+
+    return element.getAttribute(attribute);
+  }
+
+  module.exports = Clipboard;
+});
+
+}, { './clipboard-action': 7, 'good-listener': 4, 'tiny-emitter': 6 }]}, {}, [8])(8)
+});

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_frontend
 version: !ruby/object:Gem::Version
-  version: 14.0.80
+  version: 14.0.81
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-15 00:00:00.000000000 Z
+date: 2017-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -247,6 +247,7 @@ files:
 - vendor/assets/javascripts/base/_typeahead.js
 - vendor/assets/javascripts/extensions/_calendar.js
 - vendor/assets/javascripts/extensions/_chart.js
+- vendor/assets/javascripts/extensions/_copy.js
 - vendor/assets/javascripts/extensions/_map.js
 - vendor/assets/javascripts/extensions/_wysiwyg.js
 - vendor/assets/stylesheets/.DS_Store
@@ -324,7 +325,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: ActiveFrontend Responsive Web Framework