Finished action

Adding the monolith node_modules dir for deployment

node_modules/rsvp/lib/rsvp/events.js

@@ -0,0 +1,205 @@
+
+function callbacksFor(object) {
+  let callbacks = object._promiseCallbacks;
+
+  if (!callbacks) {
+    callbacks = object._promiseCallbacks = {};
+  }
+
+  return callbacks;
+}
+
+/**
+  @class EventTarget
+  @for rsvp
+  @public
+*/
+export default {
+
+  /**
+    `EventTarget.mixin` extends an object with EventTarget methods. For
+    Example:
+
+    ```javascript
+    import EventTarget from 'rsvp';
+
+    let object = {};
+
+    EventTarget.mixin(object);
+
+    object.on('finished', function(event) {
+      // handle event
+    });
+
+    object.trigger('finished', { detail: value });
+    ```
+
+    `EventTarget.mixin` also works with prototypes:
+
+    ```javascript
+    import EventTarget from 'rsvp';
+
+    let Person = function() {};
+    EventTarget.mixin(Person.prototype);
+
+    let yehuda = new Person();
+    let tom = new Person();
+
+    yehuda.on('poke', function(event) {
+      console.log('Yehuda says OW');
+    });
+
+    tom.on('poke', function(event) {
+      console.log('Tom says OW');
+    });
+
+    yehuda.trigger('poke');
+    tom.trigger('poke');
+    ```
+
+    @method mixin
+    @for rsvp
+    @private
+    @param {Object} object object to extend with EventTarget methods
+  */
+  mixin(object) {
+    object.on      = this.on;
+    object.off     = this.off;
+    object.trigger = this.trigger;
+    object._promiseCallbacks = undefined;
+    return object;
+  },
+
+  /**
+    Registers a callback to be executed when `eventName` is triggered
+
+    ```javascript
+    object.on('event', function(eventInfo){
+      // handle the event
+    });
+
+    object.trigger('event');
+    ```
+
+    @method on
+    @for EventTarget
+    @private
+    @param {String} eventName name of the event to listen for
+    @param {Function} callback function to be called when the event is triggered.
+  */
+  on(eventName, callback) {
+    if (typeof callback !== 'function') {
+      throw new TypeError('Callback must be a function');
+    }
+
+    let allCallbacks = callbacksFor(this);
+    let callbacks = allCallbacks[eventName];
+
+    if (!callbacks) {
+      callbacks = allCallbacks[eventName] = [];
+    }
+
+    if (callbacks.indexOf(callback) === -1) {
+      callbacks.push(callback);
+    }
+  },
+
+  /**
+    You can use `off` to stop firing a particular callback for an event:
+
+    ```javascript
+    function doStuff() { // do stuff! }
+    object.on('stuff', doStuff);
+
+    object.trigger('stuff'); // doStuff will be called
+
+    // Unregister ONLY the doStuff callback
+    object.off('stuff', doStuff);
+    object.trigger('stuff'); // doStuff will NOT be called
+    ```
+
+    If you don't pass a `callback` argument to `off`, ALL callbacks for the
+    event will not be executed when the event fires. For example:
+
+    ```javascript
+    let callback1 = function(){};
+    let callback2 = function(){};
+
+    object.on('stuff', callback1);
+    object.on('stuff', callback2);
+
+    object.trigger('stuff'); // callback1 and callback2 will be executed.
+
+    object.off('stuff');
+    object.trigger('stuff'); // callback1 and callback2 will not be executed!
+    ```
+
+    @method off
+    @for rsvp
+    @private
+    @param {String} eventName event to stop listening to
+    @param {Function} [callback] optional argument. If given, only the function
+    given will be removed from the event's callback queue. If no `callback`
+    argument is given, all callbacks will be removed from the event's callback
+    queue.
+  */
+  off(eventName, callback) {
+    let allCallbacks = callbacksFor(this);
+
+    if (!callback) {
+      allCallbacks[eventName] = [];
+      return;
+    }
+
+    let callbacks = allCallbacks[eventName];
+    let index = callbacks.indexOf(callback);
+
+    if (index !== -1) {
+      callbacks.splice(index, 1);
+    }
+  },
+
+  /**
+    Use `trigger` to fire custom events. For example:
+
+    ```javascript
+    object.on('foo', function(){
+      console.log('foo event happened!');
+    });
+    object.trigger('foo');
+    // 'foo event happened!' logged to the console
+    ```
+
+    You can also pass a value as a second argument to `trigger` that will be
+    passed as an argument to all event listeners for the event:
+
+    ```javascript
+    object.on('foo', function(value){
+      console.log(value.name);
+    });
+
+    object.trigger('foo', { name: 'bar' });
+    // 'bar' logged to the console
+    ```
+
+    @method trigger
+    @for rsvp
+    @private
+    @param {String} eventName name of the event to be triggered
+    @param {*} [options] optional value to be passed to any event handlers for
+    the given `eventName`
+  */
+  trigger(eventName, options, label) {
+    let allCallbacks = callbacksFor(this);
+
+    let callbacks = allCallbacks[eventName];
+    if (callbacks) {
+      // Don't cache the callbacks.length since it may grow
+      let callback;
+      for (let i = 0; i < callbacks.length; i++) {
+        callback = callbacks[i];
+        callback(options, label);
+      }
+    }
+  }
+};