Initial commit

Author: goodtimeaj

.bowerrc

@@ -0,0 +1,3 @@
+{
+  "directory": "test/bower_components"
+}

.gitignore

@@ -0,0 +1,3 @@
+/node_modules
+/build
+/test/bower_components

Gruntfile.js

@@ -0,0 +1,63 @@
+module.exports = function(grunt) {
+  'use strict'
+
+  grunt.initConfig({
+    uglify: {
+      options: {
+        mangle: false,
+        compress: false,
+        preserveComments: function(node, comment) {
+          return !!comment.value.match(/(license|copyright|MIT)/i)
+        }
+      },
+      all: {
+        files: {
+          'build/debounce-event.min.js': ['build/debounce-event.js']
+        }
+      }
+    },
+    copy: {
+      build: {
+        expand: true,
+        cwd: 'src/',
+        src: ['**/*'],
+        dest: 'build/'
+      },
+      dist: {
+        expand: true,
+        cwd: 'build/',
+        src: ['**/*'],
+        dest: 'dist/'
+      }
+    },
+    shell: {
+      mochaPhantomJS: {
+        command: './node_modules/mocha-phantomjs/bin/mocha-phantomjs test/test.html'
+      },
+      installBowerComponents: {
+        command: 'bower install'
+      }
+    }
+  })
+
+  grunt.loadNpmTasks('grunt-contrib-copy')
+  grunt.loadNpmTasks('grunt-contrib-uglify')
+  grunt.loadNpmTasks('grunt-shell')
+
+  grunt.registerTask('install', 'shell:installBowerComponents')
+
+  grunt.registerTask('build', [
+    'copy:build',
+    'uglify'
+  ])
+
+  grunt.registerTask('test', 'shell:mochaPhantomJS')
+
+  grunt.registerTask('dist', [
+    'build',
+    'test',
+    'copy:dist'
+  ])
+
+  grunt.registerTask('default', 'build')
+}

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Greg Stallings
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,106 @@
+# Debounce Event
+
+Debounces batched browser event callback execution until the last event within a given time period. The utility returns a key upon event/callback attachment which can be later used to attach multiple callbacks to the same debounced event batch by given element, event name, and timeout. Debounced event batches can be manually detached, or will detach automatically if the callback is specified to be executed only once.
+
+## Usage
+
+### Include
+
+Script include creates global `DebounceEvent`:
+
+```html
+<script src="debounce-event.min.js"></script>
+```
+
+
+AMD:
+
+```html
+<script src="debounce-event.min.js"></script>
+<script>
+  define([debounce-event], function() {
+     // do something
+  })
+<script>
+```
+
+
+CommonJS:
+
+```bash
+npm install debounce-event
+```
+
+```javascript
+require 'debounce-event'
+```
+
+### API
+
+#### Debounce Initializer Parameters
+
+`DebounceEvent.attach()` takes an object with the following named parameters:
+
+| Name | Description | Required |
+| ---- | ----------- | -------- |
+| eventName | Name of the browser event to handle. | if `eventKey` not given |
+| elem | DOM element to attach the event handler. | if `eventKey` not given |
+| done | Callback to execute on the debounced event. | always |
+| timeout | Timeout (ms) at which to debounce the event before executing the callback. | always |
+| once | True if the callback should execute only once. If the event is the only event in its group, its handler will be detached after the callback executes. Default is `false`. | no |
+| eventKey | Previously returned key of an event group to add this callback. If this parameter is specified, `eventName` and `elem` are not used since an event group uses a common event handler. | no |
+
+#### Example
+
+```javascript
+// Register the first event in a new event batch, set to execute only once
+var eventKey = DebounceEvent.attach({
+  eventName: 'resize',
+  elem: window,
+  done: function() {
+    console.log('done 1')
+  },
+  timeout: 200,
+  once: true
+})
+
+// Register the second event in an existing event batch given the previous
+// event key
+DebounceEvent.attach({
+  eventKey: eventKey1,
+  done: function() {
+    console.log('done 2')
+  },
+  once: true
+})
+
+// Register the third event in a new event batch
+var eventKey2 = DebounceEvent.attach({
+  eventName: 'resize',
+  elem: window,
+  done: function() {
+    console.log('done 3')
+  },
+  timeout: 300
+})
+
+// Manually detach the given event group
+DebounceEvent.detach(eventKey2)
+```
+
+## Development
+
+```bash
+$ cd debounce-event
+$ npm install
+$ grunt install
+$ grunt build
+$ grunt test
+
+# Build for release
+$ grunt dist
+```
+
+## License
+
+Copyright (c) 2016 Greg Stallings. See [LICENSE](https://github.com/gregstallings/debounce-event/blob/master/LICENSE) for details.

bower.json

@@ -0,0 +1,25 @@
+{
+  "name": "debounce-event",
+  "description": "Debounces batched browser event callback execution until the last event within a given time period. The utility provides support for attaching multiple callbacks to the same debounced event batch, manual detaching of batches, and the option to execute callbacks only once.",
+  "main": [
+    "dist/debounce-event.min.js"
+  ],
+  "devDependencies": {
+    "jquery": "2.1.4",
+    "requirejs": "2.1.22",
+    "mocha": "2.3.4",
+    "chai": "3.4.2"
+  },
+  "moduleType": [
+    "amd",
+    "globals",
+    "node"
+  ],
+  "keywords": [
+    "debounce",
+    "throttle",
+    "event"
+  ],
+  "author": "Greg Stallings <[email protected]>",
+  "license": "MIT"
+}

dist/debounce-event.js

@@ -0,0 +1,105 @@
+/*!
+ * Debounce Event
+ * https://github.com/gregstallings/debounce-event
+ *
+ * Copyright 2016 Greg Stallings
+ * Released under the MIT license
+ */
+;(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define([], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    module.exports = factory()
+  } else {
+    root.DebounceEvent = factory()
+  }
+}(this, function() {
+  'use strict'
+
+  var keyCount = 0
+  var eventGroups = {}
+
+  function debounceEvent(eventKey, elem, eventName, timeout) {
+    var that = this
+    var count = 0
+    var eventGroup = eventGroups[eventKey]
+    var items = eventGroup.items
+
+    var listener = function() {
+      var id = (++count)
+
+      setTimeout(function() {
+        if (id === count) {
+          var toRemove = []
+
+          for (var i = 0; i < items.length; i++) {
+            items[i][0].call(that)
+
+            // Remove if only once
+            if (items[i][1]) {
+              toRemove.push(i)
+            }
+          }
+
+          // Remove elements marked for removal
+          for (var i = toRemove.length - 1; i >= 0; i--) {
+            items.splice(toRemove[i], 1)
+          }
+
+          // Detach event handler and delete event group if empty
+          if (items.length === 0) {
+            DebounceEvent.detach(eventKey)
+          }
+        }
+      }, timeout)
+    }
+
+    elem.addEventListener(eventName, listener)
+
+    // Register other properties on the event group for use by the detach
+    // handler
+    eventGroup.elem = elem
+    eventGroup.eventName = eventName
+    eventGroup.listener = listener
+  }
+
+  function eventKeyNotRegistered(key) {
+    throw new Error("Given event key '" + key + "' not registered")
+  }
+
+  var DebounceEvent = {
+    attach: function(obj) {
+      var eventKey
+      var once = obj.hasOwnProperty('once') ? obj.once : false
+
+      if (obj.hasOwnProperty('eventKey')) {
+        eventKey = obj.eventKey
+        if (!eventGroups.hasOwnProperty(eventKey)) {
+          eventKeyNotRegistered(eventKey)
+        }
+
+        eventGroups[eventKey].items.push([obj.done, once])
+      } else {
+        eventKey = keyCount++
+        eventGroups[eventKey] = {}
+        eventGroups[eventKey].items = []
+        eventGroups[eventKey].items.push([obj.done, once])
+        debounceEvent(eventKey, obj.elem, obj.eventName, obj.timeout)
+      }
+
+      return eventKey
+    },
+
+    detach: function(eventKey) {
+      if (!eventGroups.hasOwnProperty(eventKey)) {
+        eventKeyNotRegistered(eventKey)
+      }
+
+      var eventGroup = eventGroups[eventKey]
+      eventGroup.elem.removeEventListener(eventGroup.eventName, eventGroup.listener)
+      delete eventGroups[eventKey]
+    }
+  }
+
+  return DebounceEvent
+}));

dist/debounce-event.min.js

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Debounce Event Example</title>
+</head>
+<body>
+  <script src="../src/debounce-event.js"></script>
+  <script src="window-resize.js"></script>
+</body>
+</html>