EventKit now available on bower for browsers

.gitignore

@@ -1,5 +1,4 @@
 node_modules/
-lib/
 .DS_Store
 npm-debug.log
 *.swp

bower.json

@@ -0,0 +1,20 @@
+{
+  "name": "event-kit",
+  "version": "2.3.1",
+  "description": "Simple library for implementing and consuming evented APIs",
+  "main": [
+    "lib/event-kit.js"
+  ],
+  "keywords": [
+    "event",
+    "kit"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ]
+}

debug.log

@@ -0,0 +1,4 @@
+[0219/212305:ERROR:tcp_listen_socket.cc(76)] Could not bind socket to 127.0.0.1:6004
+[0219/212305:ERROR:node_debugger.cc(86)] Cannot start debugger server
+[0220/022115:ERROR:tcp_listen_socket.cc(76)] Could not bind socket to 127.0.0.1:6004
+[0220/022115:ERROR:node_debugger.cc(86)] Cannot start debugger server

lib/event-kit.js

@@ -0,0 +1,283 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(factory((global.EventKit = global.EventKit || {})));
+}(this, (function (exports) { 'use strict';
+
+var Disposable;
+
+Disposable = (function() {
+  Disposable.prototype.disposed = false;
+
+  Disposable.isDisposable = function(object) {
+    return typeof (object != null ? object.dispose : void 0) === "function";
+  };
+
+
+  /*
+  Section: Construction and Destruction
+   */
+
+  function Disposable(disposalAction) {
+    this.disposalAction = disposalAction;
+  }
+
+  Disposable.prototype.dispose = function() {
+    if (!this.disposed) {
+      this.disposed = true;
+      if (typeof this.disposalAction === "function") {
+        this.disposalAction();
+      }
+      this.disposalAction = null;
+    }
+  };
+
+  return Disposable;
+
+})();
+
+var Disposable$1 = Disposable;
+
+var Emitter;
+
+Emitter = (function() {
+  Emitter.exceptionHandlers = [];
+
+  Emitter.onEventHandlerException = function(exceptionHandler) {
+    if (this.exceptionHandlers.length === 0) {
+      this.dispatch = this.exceptionHandlingDispatch;
+    }
+    this.exceptionHandlers.push(exceptionHandler);
+    return new Disposable$1((function(_this) {
+      return function() {
+        _this.exceptionHandlers.splice(_this.exceptionHandlers.indexOf(exceptionHandler), 1);
+        if (_this.exceptionHandlers.length === 0) {
+          return _this.dispatch = _this.simpleDispatch;
+        }
+      };
+    })(this));
+  };
+
+  Emitter.simpleDispatch = function(handler, value) {
+    return handler(value);
+  };
+
+  Emitter.exceptionHandlingDispatch = function(handler, value) {
+    var exception, exceptionHandler, i, len, ref, results;
+    try {
+      return handler(value);
+    } catch (error) {
+      exception = error;
+      ref = this.exceptionHandlers;
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        exceptionHandler = ref[i];
+        results.push(exceptionHandler(exception));
+      }
+      return results;
+    }
+  };
+
+  Emitter.dispatch = Emitter.simpleDispatch;
+
+  Emitter.prototype.disposed = false;
+
+
+  /*
+  Section: Construction and Destruction
+   */
+
+  function Emitter() {
+    this.clear();
+  }
+
+  Emitter.prototype.clear = function() {
+    return this.handlersByEventName = {};
+  };
+
+  Emitter.prototype.dispose = function() {
+    this.handlersByEventName = null;
+    return this.disposed = true;
+  };
+
+
+  /*
+  Section: Event Subscription
+   */
+
+  Emitter.prototype.on = function(eventName, handler, unshift) {
+    var currentHandlers;
+    if (unshift == null) {
+      unshift = false;
+    }
+    if (this.disposed) {
+      throw new Error("Emitter has been disposed");
+    }
+    if (typeof handler !== 'function') {
+      throw new Error("Handler must be a function");
+    }
+    if (currentHandlers = this.handlersByEventName[eventName]) {
+      if (unshift) {
+        this.handlersByEventName[eventName] = [handler].concat(currentHandlers);
+      } else {
+        this.handlersByEventName[eventName] = currentHandlers.concat(handler);
+      }
+    } else {
+      this.handlersByEventName[eventName] = [handler];
+    }
+    return new Disposable$1(this.off.bind(this, eventName, handler));
+  };
+
+  Emitter.prototype.preempt = function(eventName, handler) {
+    return this.on(eventName, handler, true);
+  };
+
+  Emitter.prototype.off = function(eventName, handlerToRemove) {
+    var handler, i, len, newHandlers, oldHandlers;
+    if (this.disposed) {
+      return;
+    }
+    if (oldHandlers = this.handlersByEventName[eventName]) {
+      newHandlers = [];
+      for (i = 0, len = oldHandlers.length; i < len; i++) {
+        handler = oldHandlers[i];
+        if (handler !== handlerToRemove) {
+          newHandlers.push(handler);
+        }
+      }
+      if (newHandlers.length > 0) {
+        this.handlersByEventName[eventName] = newHandlers;
+      } else {
+        delete this.handlersByEventName[eventName];
+      }
+    }
+  };
+
+
+  /*
+  Section: Event Emission
+   */
+
+  Emitter.prototype.emit = function(eventName, value) {
+    var handler, handlers, i, len, ref;
+    if (handlers = (ref = this.handlersByEventName) != null ? ref[eventName] : void 0) {
+      for (i = 0, len = handlers.length; i < len; i++) {
+        handler = handlers[i];
+        this.constructor.dispatch(handler, value);
+      }
+    }
+  };
+
+  Emitter.prototype.getEventNames = function() {
+    return Object.keys(this.handlersByEventName);
+  };
+
+  Emitter.prototype.listenerCountForEventName = function(eventName) {
+    var ref, ref1;
+    return (ref = (ref1 = this.handlersByEventName[eventName]) != null ? ref1.length : void 0) != null ? ref : 0;
+  };
+
+  Emitter.prototype.getTotalListenerCount = function() {
+    var eventName, i, len, ref, result;
+    result = 0;
+    ref = Object.keys(this.handlersByEventName);
+    for (i = 0, len = ref.length; i < len; i++) {
+      eventName = ref[i];
+      result += this.handlersByEventName[eventName].length;
+    }
+    return result;
+  };
+
+  return Emitter;
+
+})();
+
+var Emitter$1 = Emitter;
+
+var CompositeDisposable;
+var Disposable$2;
+var assertDisposable;
+
+Disposable$2 = null;
+
+CompositeDisposable = (function() {
+  CompositeDisposable.prototype.disposed = false;
+
+
+  /*
+  Section: Construction and Destruction
+   */
+
+  function CompositeDisposable() {
+    var disposable, i, len;
+    this.disposables = new Set;
+    for (i = 0, len = arguments.length; i < len; i++) {
+      disposable = arguments[i];
+      this.add(disposable);
+    }
+  }
+
+  CompositeDisposable.prototype.dispose = function() {
+    if (!this.disposed) {
+      this.disposed = true;
+      this.disposables.forEach(function(disposable) {
+        return disposable.dispose();
+      });
+      this.disposables = null;
+    }
+  };
+
+
+  /*
+  Section: Managing Disposables
+   */
+
+  CompositeDisposable.prototype.add = function() {
+    var disposable, i, len;
+    if (!this.disposed) {
+      for (i = 0, len = arguments.length; i < len; i += 1) {
+        disposable = arguments[i];
+        assertDisposable(disposable);
+        this.disposables.add(disposable);
+      }
+    }
+  };
+
+  CompositeDisposable.prototype.remove = function(disposable) {
+    if (!this.disposed) {
+      this.disposables["delete"](disposable);
+    }
+  };
+
+  CompositeDisposable.prototype["delete"] = function(disposable) {
+    this.remove(disposable);
+  };
+
+  CompositeDisposable.prototype.clear = function() {
+    if (!this.disposed) {
+      this.disposables.clear();
+    }
+  };
+
+  return CompositeDisposable;
+
+})();
+
+assertDisposable = function(disposable) {
+  if (Disposable$2 == null) {
+    Disposable$2 = require('./disposable');
+  }
+  if (!Disposable$2.isDisposable(disposable)) {
+    throw new TypeError('Arguments to CompositeDisposable.add must have a .dispose() method');
+  }
+};
+
+var CompositeDisposable$1 = CompositeDisposable;
+
+exports.Emitter = Emitter$1;
+exports.Disposable = Disposable$1;
+exports.CompositeDisposable = CompositeDisposable$1;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

package.json

@@ -32,6 +32,8 @@
     "grunt-shell": "^0.2.2",
     "jasmine-focused": "^1.0.4",
     "rimraf": "^2.2.2",
+    "rollup": "^0.41.4",
+    "rollup-plugin-coffee-script": "^1.1.0",
     "temp": "^0.6.0"
   }
 }

rollup.js

@@ -0,0 +1,18 @@
+var rollup = require('rollup');
+var coffeescript = require('rollup-plugin-coffee-script')
+var cache;
+
+rollup.rollup({
+  entry: 'src/event-kit.coffee',
+  plugins: [
+    coffeescript()
+  ],
+  cache: cache
+}).then(function (bundle) {
+  bundle.write({
+    moduleName: 'EventKit',
+    format: 'umd',
+    watch: true,
+    dest: 'lib/event-kit.js'
+  });
+});

src/composite-disposable.coffee

@@ -20,7 +20,6 @@ Disposable = null
 #   destroy: ->
 #     @disposables.dispose()
 # ```
-module.exports =
 class CompositeDisposable
   disposed: false
 
@@ -85,3 +84,5 @@ assertDisposable = (disposable) ->
   unless Disposable.isDisposable(disposable)
     throw new TypeError('Arguments to CompositeDisposable.add must have a .dispose() method')
   return
+
+export default CompositeDisposable

src/disposable.coffee

@@ -1,6 +1,6 @@
 # Essential: A handle to a resource that can be disposed. For example,
 # {Emitter::on} returns disposables representing subscriptions.
-module.exports =
+
 class Disposable
   disposed: false
 
@@ -34,3 +34,5 @@ class Disposable
       @disposalAction?()
       @disposalAction = null
     return
+
+export default Disposable

src/emitter.coffee

@@ -1,4 +1,4 @@
-Disposable = require './disposable'
+import Disposable from './disposable.coffee'
 
 # Essential: Utility class to be used when implementing event-based APIs that
 # allows for handlers registered via `::on` to be invoked with calls to
@@ -21,7 +21,6 @@ Disposable = require './disposable'
 #       @emitter.emit 'did-change-name', name
 #     @name
 # ```
-module.exports =
 class Emitter
   @exceptionHandlers: []
 
@@ -161,3 +160,5 @@ class Emitter
     for eventName in Object.keys(@handlersByEventName)
       result += @handlersByEventName[eventName].length
     result
+
+export default Emitter