Release v1.4.1

Fix for scrolling to top in unsupported firefox

.gitignore

@@ -1,2 +1,3 @@
+npm-debug.log
 bower_components
 node_modules

bower.json

@@ -1,9 +1,9 @@
 {
   "name": "clipboard",
-  "version": "1.2.0",
+  "version": "1.4.1",
   "description": "Modern copy to clipboard. No Flash. Just 2kb",
   "license": "MIT",
-  "main": "src/clipboard.js",
+  "main": "dist/clipboard.js",
   "keywords": [
     "clipboard",
     "copy",

contributing.md

@@ -0,0 +1,28 @@
+# Contributing guide
+
+Want to contribute to Clipboard.js? Awesome!
+There are many ways you can contribute, see below.
+
+## Opening issues
+
+Open an issue to report bugs or to propose new features.
+
+- Reporting bugs: describe the bug as clearly as you can, including steps to reproduce, what happened and what you were expecting to happen. Also include browser version, OS and other related software's (npm, Node.js, etc) versions when applicable.
+
+- Proposing features: explain the proposed feature, what it should do, why it is useful, how users should use it. Give us as much info as possible so it will be easier to discuss, access and implement the proposed feature. When you're unsure about a certain aspect of the feature, feel free to leave it open for others to discuss and find an appropriate solution.
+
+## Proposing pull requests
+
+Pull requests are very welcome. Note that if you are going to propose drastic changes, be sure to open an issue for discussion first, to make sure that your PR will be accepted before you spend effort coding it.
+
+Fork the Clipboard.js repository, clone it locally and create a branch for your proposed bug fix or new feature. Avoid working directly on the master branch.
+
+Implement your bug fix or feature, write tests to cover it and make sure all tests are passing (run a final `npm test` to make sure everything is correct). Then commit your changes, push your bug fix/feature branch to the origin (your forked repo) and open a pull request to the upstream (the repository you originally forked)'s master branch.
+
+## Documentation
+
+Documentation is extremely important and takes a fair deal of time and effort to write and keep updated. Please submit any and all improvements you can make to the repository's docs.
+
+## Known issues
+If you're using npm@3 you'll probably face some issues related to peerDependencies.
+https://github.com/npm/npm/issues/9204

dist/clipboard.js

@@ -0,0 +1,614 @@
+(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){
+/**
+ * Module dependencies.
+ */
+
+var closest = require('closest')
+  , event = require('component-event');
+
+/**
+ * Delegate event `type` to `selector`
+ * and invoke `fn(e)`. A callback function
+ * is returned which may be passed to `.unbind()`.
+ *
+ * @param {Element} el
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+// Some events don't bubble, so we want to bind to the capture phase instead
+// when delegating.
+var forceCaptureEvents = ['focus', 'blur'];
+
+exports.bind = function(el, selector, type, fn, capture){
+  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;
+
+  return event.bind(el, type, function(e){
+    var target = e.target || e.srcElement;
+    e.delegateTarget = closest(target, selector, true, el);
+    if (e.delegateTarget) fn.call(el, e);
+  }, capture);
+};
+
+/**
+ * Unbind event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;
+
+  event.unbind(el, type, fn, capture);
+};
+
+},{"closest":2,"component-event":4}],2:[function(require,module,exports){
+var matches = require('matches-selector')
+
+module.exports = function (element, selector, checkYoSelf) {
+  var parent = checkYoSelf ? element : element.parentNode
+
+  while (parent && parent !== document) {
+    if (matches(parent, selector)) return parent;
+    parent = parent.parentNode
+  }
+}
+
+},{"matches-selector":3}],3:[function(require,module,exports){
+
+/**
+ * Element prototype.
+ */
+
+var proto = Element.prototype;
+
+/**
+ * Vendor function.
+ */
+
+var vendor = proto.matchesSelector
+  || proto.webkitMatchesSelector
+  || proto.mozMatchesSelector
+  || proto.msMatchesSelector
+  || proto.oMatchesSelector;
+
+/**
+ * Expose `match()`.
+ */
+
+module.exports = match;
+
+/**
+ * Match `el` to `selector`.
+ *
+ * @param {Element} el
+ * @param {String} selector
+ * @return {Boolean}
+ * @api public
+ */
+
+function match(el, selector) {
+  if (vendor) return vendor.call(el, selector);
+  var nodes = el.parentNode.querySelectorAll(selector);
+  for (var i = 0; i < nodes.length; ++i) {
+    if (nodes[i] == el) return true;
+  }
+  return false;
+}
+},{}],4:[function(require,module,exports){
+var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
+    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
+    prefix = bind !== 'addEventListener' ? 'on' : '';
+
+/**
+ * Bind `el` event `type` to `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.bind = function(el, type, fn, capture){
+  el[bind](prefix + type, fn, capture || false);
+  return fn;
+};
+
+/**
+ * Unbind `el` event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+  el[unbind](prefix + type, fn, capture || false);
+  return fn;
+};
+},{}],5:[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;
+    var fn = function () {
+      self.off(name, fn);
+      callback.apply(ctx, arguments);
+    };
+    
+    return this.on(name, fn, 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) 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;
+
+},{}],6:[function(require,module,exports){
+/**
+ * Inner class which performs selection from either `text` or `target`
+ * properties and then executes copy or cut operations.
+ */
+'use strict';
+
+exports.__esModule = true;
+
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+var ClipboardAction = (function () {
+    /**
+     * @param {Object} options
+     */
+
+    function ClipboardAction(options) {
+        _classCallCheck(this, ClipboardAction);
+
+        this.resolveOptions(options);
+        this.initSelection();
+    }
+
+    /**
+     * Defines base properties passed from constructor.
+     * @param {Object} options
+     */
+
+    ClipboardAction.prototype.resolveOptions = 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 = '';
+    };
+
+    /**
+     * Decides which selection strategy is going to be applied based
+     * on the existence of `text` and `target` properties.
+     */
+
+    ClipboardAction.prototype.initSelection = function initSelection() {
+        if (this.text && this.target) {
+            throw new Error('Multiple attributes declared, use either "target" or "text"');
+        } else if (this.text) {
+            this.selectFake();
+        } else if (this.target) {
+            this.selectTarget();
+        } else {
+            throw new Error('Missing required attributes, use either "target" or "text"');
+        }
+    };
+
+    /**
+     * Creates a fake textarea element, sets its value from `text` property,
+     * and makes a selection on it.
+     */
+
+    ClipboardAction.prototype.selectFake = function selectFake() {
+        var _this = this;
+
+        this.removeFake();
+
+        this.fakeHandler = document.body.addEventListener('click', function () {
+            return _this.removeFake();
+        });
+
+        this.fakeElem = document.createElement('textarea');
+        this.fakeElem.style.position = 'absolute';
+        this.fakeElem.style.left = '-9999px';
+        this.fakeElem.style.top = (window.pageYOffset || document.documentElement.scrollTop) + 'px';
+        this.fakeElem.setAttribute('readonly', '');
+        this.fakeElem.value = this.text;
+        this.selectedText = this.text;
+
+        document.body.appendChild(this.fakeElem);
+
+        this.fakeElem.select();
+        this.copyText();
+    };
+
+    /**
+     * Only removes the fake element after another click event, that way
+     * an user can hit `Ctrl+C` to copy because selection still exists.
+     */
+
+    ClipboardAction.prototype.removeFake = function removeFake() {
+        if (this.fakeHandler) {
+            document.body.removeEventListener('click');
+            this.fakeHandler = null;
+        }
+
+        if (this.fakeElem) {
+            document.body.removeChild(this.fakeElem);
+            this.fakeElem = null;
+        }
+    };
+
+    /**
+     * Selects the content from element passed on `target` property.
+     */
+
+    ClipboardAction.prototype.selectTarget = function selectTarget() {
+        if (this.target.nodeName === 'INPUT' || this.target.nodeName === 'TEXTAREA') {
+            this.target.select();
+            this.selectedText = this.target.value;
+        } else {
+            var range = document.createRange();
+            var selection = window.getSelection();
+
+            range.selectNodeContents(this.target);
+            selection.addRange(range);
+            this.selectedText = selection.toString();
+        }
+
+        this.copyText();
+    };
+
+    /**
+     * Executes the copy operation based on the current selection.
+     */
+
+    ClipboardAction.prototype.copyText = function copyText() {
+        var succeeded = undefined;
+
+        try {
+            succeeded = document.execCommand(this.action);
+        } catch (err) {
+            succeeded = false;
+        }
+
+        this.handleResult(succeeded);
+    };
+
+    /**
+     * Fires an event based on the copy operation result.
+     * @param {Boolean} succeeded
+     */
+
+    ClipboardAction.prototype.handleResult = function handleResult(succeeded) {
+        if (succeeded) {
+            this.emitter.emit('success', {
+                action: this.action,
+                text: this.selectedText,
+                trigger: this.trigger,
+                clearSelection: this.clearSelection.bind(this)
+            });
+        } else {
+            this.emitter.emit('error', {
+                action: this.action,
+                trigger: this.trigger,
+                clearSelection: this.clearSelection.bind(this)
+            });
+        }
+    };
+
+    /**
+     * Removes current selection and focus from `target` element.
+     */
+
+    ClipboardAction.prototype.clearSelection = function clearSelection() {
+        if (this.target) {
+            this.target.blur();
+        }
+
+        window.getSelection().removeAllRanges();
+    };
+
+    /**
+     * Sets the `action` to be performed which can be either 'copy' or 'cut'.
+     * @param {String} action
+     */
+
+    /**
+     * Destroy lifecycle.
+     */
+
+    ClipboardAction.prototype.destroy = function destroy() {
+        this.removeFake();
+    };
+
+    _createClass(ClipboardAction, [{
+        key: 'action',
+        set: function set() {
+            var action = arguments.length <= 0 || arguments[0] === undefined ? 'copy' : arguments[0];
+
+            this._action = action;
+
+            if (this._action !== 'copy' && this._action !== 'cut') {
+                throw new Error('Invalid "action" value, use either "copy" or "cut"');
+            }
+        },
+
+        /**
+         * Gets the `action` property.
+         * @return {String}
+         */
+        get: function get() {
+            return this._action;
+        }
+
+        /**
+         * Sets the `target` property using an element
+         * that will be have its content copied.
+         * @param {Element} target
+         */
+    }, {
+        key: 'target',
+        set: function set(target) {
+            if (target !== undefined) {
+                if (target && typeof target === 'object' && target.nodeType === 1) {
+                    this._target = target;
+                } else {
+                    throw new Error('Invalid "target" value, use a valid Element');
+                }
+            }
+        },
+
+        /**
+         * Gets the `target` property.
+         * @return {String|HTMLElement}
+         */
+        get: function get() {
+            return this._target;
+        }
+    }]);
+
+    return ClipboardAction;
+})();
+
+exports['default'] = ClipboardAction;
+module.exports = exports['default'];
+
+},{}],7:[function(require,module,exports){
+'use strict';
+
+exports.__esModule = true;
+
+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'); } }
+
+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 _clipboardAction = require('./clipboard-action');
+
+var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
+
+var _delegateEvents = require('delegate-events');
+
+var _delegateEvents2 = _interopRequireDefault(_delegateEvents);
+
+var _tinyEmitter = require('tiny-emitter');
+
+var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
+
+/**
+ * Base class which takes a selector, delegates a click event to it,
+ * and instantiates a new `ClipboardAction` on each click.
+ */
+
+var Clipboard = (function (_Emitter) {
+    _inherits(Clipboard, _Emitter);
+
+    /**
+     * @param {String} selector
+     * @param {Object} options
+     */
+
+    function Clipboard(selector, options) {
+        _classCallCheck(this, Clipboard);
+
+        _Emitter.call(this);
+
+        this.resolveOptions(options);
+        this.delegateClick(selector);
+    }
+
+    /**
+     * Helper function to retrieve attribute value.
+     * @param {String} suffix
+     * @param {Element} element
+     */
+
+    /**
+     * Defines if attributes would be resolved using internal setter functions
+     * or custom functions that were passed in the constructor.
+     * @param {Object} options
+     */
+
+    Clipboard.prototype.resolveOptions = 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;
+    };
+
+    /**
+     * Delegates a click event on the passed selector.
+     * @param {String} selector
+     */
+
+    Clipboard.prototype.delegateClick = function delegateClick(selector) {
+        var _this = this;
+
+        this.binding = _delegateEvents2['default'].bind(document.body, selector, 'click', function (e) {
+            return _this.onClick(e);
+        });
+    };
+
+    /**
+     * Undelegates a click event on body.
+     * @param {String} selector
+     */
+
+    Clipboard.prototype.undelegateClick = function undelegateClick() {
+        _delegateEvents2['default'].unbind(document.body, 'click', this.binding);
+    };
+
+    /**
+     * Defines a new `ClipboardAction` on each click event.
+     * @param {Event} e
+     */
+
+    Clipboard.prototype.onClick = function onClick(e) {
+        if (this.clipboardAction) {
+            this.clipboardAction = null;
+        }
+
+        this.clipboardAction = new _clipboardAction2['default']({
+            action: this.action(e.delegateTarget),
+            target: this.target(e.delegateTarget),
+            text: this.text(e.delegateTarget),
+            trigger: e.delegateTarget,
+            emitter: this
+        });
+    };
+
+    /**
+     * Default `action` lookup function.
+     * @param {Element} trigger
+     */
+
+    Clipboard.prototype.defaultAction = function defaultAction(trigger) {
+        return getAttributeValue('action', trigger);
+    };
+
+    /**
+     * Default `target` lookup function.
+     * @param {Element} trigger
+     */
+
+    Clipboard.prototype.defaultTarget = function defaultTarget(trigger) {
+        var selector = getAttributeValue('target', trigger);
+
+        if (selector) {
+            return document.querySelector(selector);
+        }
+    };
+
+    /**
+     * Default `text` lookup function.
+     * @param {Element} trigger
+     */
+
+    Clipboard.prototype.defaultText = function defaultText(trigger) {
+        return getAttributeValue('text', trigger);
+    };
+
+    /**
+     * Destroy lifecycle.
+     */
+
+    Clipboard.prototype.destroy = function destroy() {
+        this.undelegateClick();
+
+        if (this.clipboardAction) {
+            this.clipboardAction.destroy();
+            this.clipboardAction = null;
+        }
+    };
+
+    return Clipboard;
+})(_tinyEmitter2['default']);
+
+function getAttributeValue(suffix, element) {
+    var attribute = 'data-clipboard-' + suffix;
+
+    if (!element.hasAttribute(attribute)) {
+        return;
+    }
+
+    return element.getAttribute(attribute);
+}
+
+exports['default'] = Clipboard;
+module.exports = exports['default'];
+
+},{"./clipboard-action":6,"delegate-events":1,"tiny-emitter":5}]},{},[7])(7)
+});

karma.conf.js

@@ -10,6 +10,8 @@ module.exports = function(karma) {
             './node_modules/phantomjs-polyfill/bind-polyfill.js'
         ],
 
+        exclude: ['test/module-systems.js'],
+
         preprocessors: {
             'src/**/*.js' : ['browserify'],
             'test/**/*.js': ['browserify']

package.json

@@ -1,35 +1,51 @@
 {
   "name": "clipboard",
-  "version": "1.2.0",
+  "version": "1.4.1",
   "description": "Modern copy to clipboard. No Flash. Just 2kb",
   "repository": "zenorocha/clipboard.js",
-  "main": "src/clipboard.js",
   "license": "MIT",
+  "main": "dist/clipboard.js",
+  "browser": "src/clipboard.js",
+  "browserify": {
+    "transform": [
+      [
+        "babelify",
+        {
+          "loose": "all"
+        }
+      ]
+    ]
+  },
   "keywords": [
     "clipboard",
     "copy",
     "cut"
   ],
   "dependencies": {
+    "babelify": "^6.3.0",
+    "browserify": "^11.2.0",
     "delegate-events": "^1.1.1",
     "tiny-emitter": "^1.0.0"
   },
   "devDependencies": {
-    "babelify": "^6.3.0",
-    "browserify": "^11.1.0",
     "karma": "^0.13.10",
-    "karma-browserify": "^4.3.0",
+    "karma-browserify": "^4.4.0",
     "karma-chai": "^0.1.0",
     "karma-mocha": "^0.2.0",
     "karma-phantomjs-launcher": "^0.2.1",
     "karma-sinon": "^1.0.4",
+    "mocha": "^2.3.3",
     "phantomjs-polyfill": "0.0.1",
-    "uglify": "^0.1.5"
+    "uglify": "^0.1.5",
+    "watchify": "^3.4.0"
   },
   "scripts": {
-    "publish": "npm run build && npm run minify",
-    "build": "browserify src/clipboard.js -t [babelify --loose all] -o dist/clipboard.min.js",
-    "minify": "uglify -s dist/clipboard.min.js -o dist/clipboard.min.js",
-    "test": "karma start --single-run"
+    "build": "npm run build-debug && npm run build-min",
+    "build-debug": "browserify src/clipboard.js -s Clipboard -o dist/clipboard.js",
+    "build-min": "uglify -s dist/clipboard.js -o dist/clipboard.min.js",
+    "build-watch": "watchify src/clipboard.js -s Clipboard -o dist/clipboard.js -v",
+    "test": "npm run test-browser && npm run test-server",
+    "test-browser": "karma start --single-run",
+    "test-server": "mocha test/module-systems.js"
   }
 }

readme.md

@@ -4,11 +4,11 @@
 
 > Modern copy to clipboard. No Flash. Just 2kb
 
-<a href="http://zenorocha.github.io/clipboard.js/"><img width="728" src="https://cloud.githubusercontent.com/assets/398893/9983535/5ab0a950-5fb4-11e5-9602-e73c0b661883.jpg" alt="Demo"></a>
+<a href="https://zenorocha.github.io/clipboard.js/"><img width="728" src="https://cloud.githubusercontent.com/assets/398893/9983535/5ab0a950-5fb4-11e5-9602-e73c0b661883.jpg" alt="Demo"></a>
 
 ## Why
 
-Copy text to the clipboard shouldn't be hard. It shouldn't require dozens of steps to configure or hundreds of KBs to load. But most of all, it shouldn't depend on Flash or any bloated framework.
+Copying text to the clipboard shouldn't be hard. It shouldn't require dozens of steps to configure or hundreds of KBs to load. But most of all, it shouldn't depend on Flash or any bloated framework.
 
 That's why clipboard.js exists.
 
@@ -30,12 +30,18 @@ If you're not into package management, just [download a ZIP](https://github.com/
 
 ## Setup
 
-First, include the script located on the `dist` folder
+First, include the script located on the `dist` folder.
 
 ```html
 <script src="dist/clipboard.min.js"></script>
 ```
 
+Or load it from a CDN.
+
+```html
+<script src="https://cdn.rawgit.com/zenorocha/clipboard.js/master/dist/clipboard.min.js"></script>
+```
+
 Now, you need to instantiate it using a DOM selector. This selector corresponds to the trigger element(s), for example `<button class="btn">`.
 
 ```js
@@ -56,7 +62,7 @@ A pretty common use case is to copy content from another element. You can do tha
 
 The value you include on this attribute needs to match another's element selector.
 
-<a href="http://zenorocha.github.io/clipboard.js/#demo-target"><img width="473" alt="example-2" src="https://cloud.githubusercontent.com/assets/398893/9983467/a4946aaa-5fb1-11e5-9780-f09fcd7ca6c8.png"></a>
+<a href="https://zenorocha.github.io/clipboard.js/#example-target"><img width="473" alt="example-2" src="https://cloud.githubusercontent.com/assets/398893/9983467/a4946aaa-5fb1-11e5-9780-f09fcd7ca6c8.png"></a>
 
 ```html
 <!-- Target -->
@@ -74,7 +80,7 @@ Additionally, you can define a `data-clipboard-action` attribute to specify if y
 
 If you omit this attribute, `copy` will be used by default.
 
-<a href="http://zenorocha.github.io/clipboard.js/#demo-action"><img width="473" alt="example-3" src="https://cloud.githubusercontent.com/assets/398893/10000358/7df57b9c-6050-11e5-9cd1-fbc51d2fd0a7.png"></a>
+<a href="https://zenorocha.github.io/clipboard.js/#example-action"><img width="473" alt="example-3" src="https://cloud.githubusercontent.com/assets/398893/10000358/7df57b9c-6050-11e5-9cd1-fbc51d2fd0a7.png"></a>
 
 ```html
 <!-- Target -->
@@ -92,7 +98,7 @@ As you may expect, the `cut` action only works on `<input>` or `<textarea>` elem
 
 Truth is, you don't even need another element to copy its content from. You can just include a `data-clipboard-text` attribute in your trigger element.
 
-<a href="http://zenorocha.github.io/clipboard.js/#demo-text"><img width="147" alt="example-1" src="https://cloud.githubusercontent.com/assets/398893/10000347/6e16cf8c-6050-11e5-9883-1c5681f9ec45.png"></a>
+<a href="https://zenorocha.github.io/clipboard.js/#example-text"><img width="147" alt="example-1" src="https://cloud.githubusercontent.com/assets/398893/10000347/6e16cf8c-6050-11e5-9883-1c5681f9ec45.png"></a>
 
 ```html
 <!-- Trigger -->
@@ -101,30 +107,6 @@ Truth is, you don't even need another element to copy its content from. You can
 </button>
 ```
 
-## Advanced Usage
-
-If you don't want to modify your HTML, there's a pretty handy imperative API for you to use. All you need to do is declare a function, do your thing, and return a value.
-
-For instance, if you want to dynamically set a `target`, you'll need to return a Node.
-
-```js
-new Clipboard('.btn', {
-    target: function(trigger) {
-        return trigger.nextElementSibling;
-    }
-});
-```
-
-If you want to dynamically set a `text`, you'll return a String.
-
-```js
-new Clipboard('.btn', {
-    text: function(trigger) {
-        return trigger.getAttribute('aria-label');
-    }
-});
-```
-
 ## Events
 
 There are cases where you'd like to show some user feedback or capture what has been selected after a copy/cut operation.
@@ -148,13 +130,44 @@ clipboard.on('error', function(e) {
 });
 ```
 
-For a live demonstration, open this [site](http://zenorocha.github.io/clipboard.js/) and just your console :)
+For a live demonstration, open this [site](https://zenorocha.github.io/clipboard.js/) and just your console :)
+
+## Advanced Options
+
+If you don't want to modify your HTML, there's a pretty handy imperative API for you to use. All you need to do is declare a function, do your thing, and return a value.
+
+For instance, if you want to dynamically set a `target`, you'll need to return a Node.
+
+```js
+new Clipboard('.btn', {
+    target: function(trigger) {
+        return trigger.nextElementSibling;
+    }
+});
+```
+
+If you want to dynamically set a `text`, you'll return a String.
+
+```js
+new Clipboard('.btn', {
+    text: function(trigger) {
+        return trigger.getAttribute('aria-label');
+    }
+});
+```
+
+Also, with are working with single page apps, you may want to manage the lifecycle of the DOM more precisely. Here's how you clean up the events and objects that we create.
+
+```js
+var clipboard = new Clipboard('.btn');
+clipboard.destroy();
+```
 
 ## Browser Support
 
 This library relies on both [Selection](https://developer.mozilla.org/en-US/docs/Web/API/Selection) and [execCommand](https://developer.mozilla.org/en-US/docs/Web/API/Document/execCommand) APIs. The second one is supported in the following browsers.
 
-| <img src="http://zenorocha.github.io/clipboard.js/assets/images/chrome.png" width="48px" height="48px" alt="Chrome logo"> | <img src="http://zenorocha.github.io/clipboard.js/assets/images/firefox.png" width="48px" height="48px" alt="Firefox logo"> | <img src="http://zenorocha.github.io/clipboard.js/assets/images/ie.png" width="48px" height="48px" alt="Internet Explorer logo"> | <img src="http://zenorocha.github.io/clipboard.js/assets/images/opera.png" width="48px" height="48px" alt="Opera logo"> | <img src="http://zenorocha.github.io/clipboard.js/assets/images/safari.png" width="48px" height="48px" alt="Safari logo"> |
+| <img src="https://zenorocha.github.io/clipboard.js/assets/images/chrome.png" width="48px" height="48px" alt="Chrome logo"> | <img src="https://zenorocha.github.io/clipboard.js/assets/images/firefox.png" width="48px" height="48px" alt="Firefox logo"> | <img src="https://zenorocha.github.io/clipboard.js/assets/images/ie.png" width="48px" height="48px" alt="Internet Explorer logo"> | <img src="https://zenorocha.github.io/clipboard.js/assets/images/opera.png" width="48px" height="48px" alt="Opera logo"> | <img src="https://zenorocha.github.io/clipboard.js/assets/images/safari.png" width="48px" height="48px" alt="Safari logo"> |
 |:---:|:---:|:---:|:---:|:---:|
 | 42+ ✔ | 41+ ✔ | 9+ ✔ | 29+ ✔ | Nope ✘ |
 
@@ -162,7 +175,7 @@ Although copy/cut operations with [execCommand](https://developer.mozilla.org/en
 
 That means you can show a tooltip saying `Copied!` when `success` event is called and `Press Ctrl+C to copy` when `error` event is called because the text is already selected.
 
-For a live demonstration, open this [site](http://zenorocha.github.io/clipboard.js/) on Safari.
+For a live demonstration, open this [site](https://zenorocha.github.io/clipboard.js/) on Safari.
 
 ## License
 

src/clipboard-action.js

@@ -1,12 +1,21 @@
 /**
- * Inner class which performs selection and copy operations.
+ * Inner class which performs selection from either `text` or `target`
+ * properties and then executes copy or cut operations.
  */
 class ClipboardAction {
     /**
-     * Initializes selection from either `text` or `target` property.
      * @param {Object} options
      */
     constructor(options) {
+        this.resolveOptions(options);
+        this.initSelection();
+    }
+
+    /**
+     * Defines base properties passed from constructor.
+     * @param {Object} options
+     */
+    resolveOptions(options = {}) {
         this.action  = options.action;
         this.emitter = options.emitter;
         this.target  = options.target;
@@ -14,7 +23,13 @@ class ClipboardAction {
         this.trigger = options.trigger;
 
         this.selectedText = '';
+    }
 
+    /**
+     * Decides which selection strategy is going to be applied based
+     * on the existence of `text` and `target` properties.
+     */
+    initSelection() {
         if (this.text && this.target) {
             throw new Error('Multiple attributes declared, use either "target" or "text"');
         }
@@ -30,7 +45,7 @@ class ClipboardAction {
     }
 
     /**
-     * Creates a fake input element, sets its value from `text` property,
+     * Creates a fake textarea element, sets its value from `text` property,
      * and makes a selection on it.
      */
     selectFake() {
@@ -38,9 +53,10 @@ class ClipboardAction {
 
         this.fakeHandler = document.body.addEventListener('click', () => this.removeFake());
 
-        this.fakeElem = document.createElement('input');
+        this.fakeElem = document.createElement('textarea');
         this.fakeElem.style.position = 'absolute';
         this.fakeElem.style.left = '-9999px';
+        this.fakeElem.style.top = (window.pageYOffset || document.documentElement.scrollTop) + 'px';
         this.fakeElem.setAttribute('readonly', '');
         this.fakeElem.value = this.text;
         this.selectedText = this.text;
@@ -140,8 +156,8 @@ class ClipboardAction {
      * Sets the `action` to be performed which can be either 'copy' or 'cut'.
      * @param {String} action
      */
-    set action(action) {
-        this._action = action || 'copy';
+    set action(action = 'copy') {
+        this._action = action;
 
         if (this._action !== 'copy' && this._action !== 'cut') {
             throw new Error('Invalid "action" value, use either "copy" or "cut"');
@@ -157,8 +173,8 @@ class ClipboardAction {
     }
 
     /**
-     * Sets the `target` property using an element that will be have its content
-     * copied.
+     * Sets the `target` property using an element
+     * that will be have its content copied.
      * @param {Element} target
      */
     set target(target) {
@@ -179,6 +195,13 @@ class ClipboardAction {
     get target() {
         return this._target;
     }
+
+    /**
+     * Destroy lifecycle.
+     */
+    destroy() {
+        this.removeFake();
+    }
 }
 
 export default ClipboardAction;

src/clipboard.js

@@ -2,15 +2,12 @@ import ClipboardAction from './clipboard-action';
 import Delegate from 'delegate-events';
 import Emitter from 'tiny-emitter';
 
-const prefix = 'data-clipboard-';
-
 /**
  * Base class which takes a selector, delegates a click event to it,
  * and instantiates a new `ClipboardAction` on each click.
  */
 class Clipboard extends Emitter {
     /**
-     * Delegates a click event on the passed selector.
      * @param {String} selector
      * @param {Object} options
      */
@@ -18,56 +15,41 @@ class Clipboard extends Emitter {
         super();
 
         this.resolveOptions(options);
-
-        Delegate.bind(document.body, selector, 'click', (e) => this.initialize(e));
+        this.delegateClick(selector);
     }
 
     /**
-     * Defines if attributes would be resolved using an internal setter function
-     * or a custom function that was passed in the constructor.
+     * Defines if attributes would be resolved using internal setter functions
+     * or custom functions that were passed in the constructor.
      * @param {Object} options
      */
-    resolveOptions(options) {
-        options = options || {};
-
-        this.action = (typeof options.action === 'function') ? options.action : this.setAction;
-        this.target = (typeof options.target === 'function') ? options.target : this.setTarget;
-        this.text   = (typeof options.text   === 'function') ? options.text   : this.setText;
+    resolveOptions(options = {}) {
+        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;
     }
 
     /**
-     * Sets the `action` lookup function.
-     * @param {Element} trigger
+     * Delegates a click event on the passed selector.
+     * @param {String} selector
      */
-    setAction(trigger) {
-        return trigger.getAttribute(prefix + 'action');
+    delegateClick(selector) {
+        this.binding = Delegate.bind(document.body, selector, 'click', (e) => this.onClick(e));
     }
 
     /**
-     * Sets the `target` lookup function.
-     * @param {Element} trigger
+     * Undelegates a click event on body.
+     * @param {String} selector
      */
-    setTarget(trigger) {
-        let target = trigger.getAttribute(prefix + 'target');
-
-        if (target) {
-            return document.querySelector(target);
-        }
-    }
-
-    /**
-     * Sets the `text` lookup function.
-     * @param {Element} trigger
-     */
-    setText(trigger) {
-        return trigger.getAttribute(prefix + 'text');
+    undelegateClick() {
+        Delegate.unbind(document.body, 'click', this.binding);
     }
 
     /**
      * Defines a new `ClipboardAction` on each click event.
      * @param {Event} e
      */
-    initialize(e) {
+    onClick(e) {
         if (this.clipboardAction) {
             this.clipboardAction = null;
         }
@@ -80,8 +62,62 @@ class Clipboard extends Emitter {
             emitter : this
         });
     }
+
+    /**
+     * Default `action` lookup function.
+     * @param {Element} trigger
+     */
+    defaultAction(trigger) {
+        return getAttributeValue('action', trigger);
+    }
+
+    /**
+     * Default `target` lookup function.
+     * @param {Element} trigger
+     */
+    defaultTarget(trigger) {
+        let selector = getAttributeValue('target', trigger);
+
+        if (selector) {
+            return document.querySelector(selector);
+        }
+    }
+
+    /**
+     * Default `text` lookup function.
+     * @param {Element} trigger
+     */
+    defaultText(trigger) {
+        return getAttributeValue('text', trigger);
+    }
+
+    /**
+     * Destroy lifecycle.
+     */
+    destroy() {
+        this.undelegateClick();
+
+        if (this.clipboardAction) {
+            this.clipboardAction.destroy();
+            this.clipboardAction = null;
+        }
+    }
+}
+
+
+/**
+ * Helper function to retrieve attribute value.
+ * @param {String} suffix
+ * @param {Element} element
+ */
+function getAttributeValue(suffix, element) {
+    let attribute = `data-clipboard-${suffix}`;
+
+    if (!element.hasAttribute(attribute)) {
+        return;
+    }
+
+    return element.getAttribute(attribute);
 }
 
 export default Clipboard;
-
-global.Clipboard = Clipboard;

test/clipboard-action.js

@@ -1,4 +1,3 @@
-import Clipboard from '../src/clipboard-action';
 import ClipboardAction from '../src/clipboard-action';
 import Emitter from 'tiny-emitter';
 
@@ -19,7 +18,23 @@ describe('ClipboardAction', () => {
         document.body.innerHTML = '';
     });
 
-    describe('#constructor', () => {
+    describe('#resolveOptions', () => {
+        it('should set base properties', () => {
+            let clip = new ClipboardAction({
+                emitter: new Emitter(),
+                text: 'foo'
+            });
+
+            assert.property(clip, 'action');
+            assert.property(clip, 'emitter');
+            assert.property(clip, 'target');
+            assert.property(clip, 'text');
+            assert.property(clip, 'trigger');
+            assert.property(clip, 'selectedText');
+        });
+    });
+
+    describe('#initSelection', () => {
         it('should throw an error since both "text" and "target" were passed', done => {
             try {
                 new ClipboardAction({
@@ -35,9 +50,7 @@ describe('ClipboardAction', () => {
 
         it('should throw an error since neither "text" nor "target" were passed', done => {
             try {
-                new ClipboardAction({
-                    action: ''
-                });
+                new ClipboardAction();
             }
             catch(e) {
                 assert.equal(e.message, 'Missing required attributes, use either "target" or "text"');
@@ -131,7 +144,7 @@ describe('ClipboardAction', () => {
         it('should fire a success event on browsers that support copy command', done => {
             global.stub.returns(true);
 
-            let emitter = new Emitter()
+            let emitter = new Emitter();
 
             emitter.on('success', () => {
                 done();
@@ -146,7 +159,7 @@ describe('ClipboardAction', () => {
         it('should fire an error event on browsers that support copy command', done => {
             global.stub.returns(false);
 
-            let emitter = new Emitter()
+            let emitter = new Emitter();
 
             emitter.on('error', () => {
                 done();
@@ -212,4 +225,18 @@ describe('ClipboardAction', () => {
             assert.equal(selectedText, '');
         });
     });
+
+    describe('#destroy', () => {
+        it('should destroy an existing fake element', () => {
+            let clip = new ClipboardAction({
+                emitter: new Emitter(),
+                text: 'blah'
+            });
+
+            clip.selectFake();
+            clip.destroy();
+
+            assert.equal(clip.fakeElem, null);
+        });
+    });
 });

test/clipboard.js

@@ -1,5 +1,6 @@
 import Clipboard from '../src/clipboard';
 import ClipboardAction from '../src/clipboard-action';
+import Delegate from 'delegate-events';
 
 describe('Clipboard', () => {
     before(() => {
@@ -18,36 +19,82 @@ describe('Clipboard', () => {
     });
 
     describe('#resolveOptions', function() {
+        before(() => {
+            global.fn = function() {};
+        });
+
         it('should set action as a function', () => {
-            var fn = function() {};
-            var clipboard = new Clipboard('.btn', {
-                action: fn
+            let clipboard = new Clipboard('.btn', {
+                action: global.fn
             });
-            assert.equal(fn, clipboard.action);
+
+            assert.equal(global.fn, clipboard.action);
         });
 
         it('should set target as a function', () => {
-            var fn = function() {};
-            var clipboard = new Clipboard('.btn', {
-                target: fn
+            let clipboard = new Clipboard('.btn', {
+                target: global.fn
             });
-            assert.equal(fn, clipboard.target);
+
+            assert.equal(global.fn, clipboard.target);
         });
 
         it('should set text as a function', () => {
-            var fn = function() {};
-            var clipboard = new Clipboard('.btn', {
-                text: fn
+            let clipboard = new Clipboard('.btn', {
+                text: global.fn
             });
-            assert.equal(fn, clipboard.text);
+
+            assert.equal(global.fn, clipboard.text);
         });
     });
 
-    describe('#initialize', () => {
+    describe('#delegateClick', function() {
+        before(() => {
+            global.spy = sinon.spy(Delegate, 'bind');
+        });
+
+        after(() => {
+            global.spy.restore();
+        });
+
+        it('should delegate a click event to the passed selector', () => {
+            let element = document.body;
+            let selector = '.btn';
+            let event = 'click';
+
+            let clipboard = new Clipboard(selector);
+
+            assert.ok(global.spy.calledOnce);
+            assert.ok(global.spy.calledWith(element, selector, event));
+        });
+    });
+
+    describe('#undelegateClick', function() {
+        before(() => {
+            global.spy = sinon.spy(Delegate, 'unbind');
+        });
+
+        after(() => {
+            global.spy.restore();
+        });
+
+        it('should undelegate a click event', () => {
+            let element = document.body;
+            let event = 'click';
+
+            let clipboard = new Clipboard('.btn');
+            clipboard.undelegateClick();
+
+            assert.ok(global.spy.calledOnce);
+            assert.ok(global.spy.calledWith(element, event));
+        });
+    });
+
+    describe('#onClick', () => {
         it('should create a new instance of ClipboardAction', () => {
             let clipboard = new Clipboard('.btn');
 
-            clipboard.initialize(global.event);
+            clipboard.onClick(global.event);
             assert.instanceOf(clipboard.clipboardAction, ClipboardAction);
         });
 
@@ -58,7 +105,7 @@ describe('Clipboard', () => {
                         return null;
                     }
                 });
-                clipboard.initialize(global.event);
+                clipboard.onClick(global.event);
             }
             catch(e) {
                 assert.equal(e.message, 'Invalid "target" value, use a valid Element');
@@ -66,4 +113,15 @@ describe('Clipboard', () => {
             }
         });
     });
+
+    describe('#destroy', () => {
+        it('should destroy an existing instance of ClipboardAction', () => {
+            let clipboard = new Clipboard('.btn');
+
+            clipboard.onClick(global.event);
+            clipboard.destroy();
+
+            assert.equal(clipboard.clipboardAction, null);
+        });
+    });
 });

test/module-systems.js

@@ -0,0 +1,15 @@
+var assert = require('chai').assert;
+var browserify = require('browserify');
+
+describe('CommonJS', function() {
+    it('should import the lib in a commonjs env without babel', function(done) {
+        browserify('./dist/clipboard.js').bundle(function(err) {
+            assert.equal(err, null);
+            done();
+        });
+    });
+});
+
+describe('AMD', function() {
+    // TODO: Write test case
+});