lib: change event signature

lib/connection.js

@@ -106,7 +106,7 @@ Connection.prototype.callback = function(packetId, error, result) {
 // Send an event packet over the connection
 //   interfaceName - name of an interface
 //   eventName - name of an event
-//   args - event arguments as an object
+//   args - event arguments as an array
 //
 Connection.prototype.emitRemoteEvent = function(
   interfaceName, eventName, args
@@ -539,7 +539,7 @@ Connection.prototype._processEventPacket = function(packet, keys) {
 
   const remoteProxy = this.remoteProxies[interfaceName];
   if (remoteProxy) {
-    remoteProxy.emit(eventName, eventArgs, true);
+    remoteProxy._emitLocal(eventName, eventArgs);
   }
 };
 

lib/remote-proxy.js

@@ -24,22 +24,21 @@ function RemoteProxy(connection, interfaceName, methods = []) {
 
 util.inherits(RemoteProxy, events.EventEmitter);
 
-// Emit an event. By default, when the dontRetranslate parameter is false or
-// undefined, the event is also emmited on the other part of the JSTP
-// connection so all the 'on' handlers will work on both sides regardless of
-// where event has been emitted. However, you can turn it off by setting
-// dontRetranslate to true.
+// Emit an event.
 //   eventName - name of an event
-//   eventArgs - object of event arguments
-//   dontRetranslate - turn off sending the corresponding event packet over the
-//                     JSTP connection
+//   eventArgs - event arguments
 //
-RemoteProxy.prototype.emit = function(eventName, eventArgs, dontRetranslate) {
-  if (!dontRetranslate) {
-    this._connection.emitRemoteEvent(this._interfaceName, eventName, eventArgs);
-  }
+RemoteProxy.prototype.emit = function(eventName, ...eventArgs) {
+  this._connection.emitRemoteEvent(this._interfaceName, eventName, eventArgs);
+  this._emitLocal(eventName, eventArgs);
+};
 
-  events.EventEmitter.prototype.emit.call(this, eventName, eventArgs);
+// Emit local event.
+//   eventName - name of an event
+//   eventArgs - array of event arguments
+//
+RemoteProxy.prototype._emitLocal = function(eventName, eventArgs = []) {
+  events.EventEmitter.prototype.emit.call(this, eventName, ...eventArgs);
 };
 
 // Create a method in a remote proxy that will call the corresponding remote

test/unit/connection.test.js

@@ -533,7 +533,7 @@ describe('JSTP Connection', () => {
 
   describe('event', () => {
     testPacketSending('event', (connection, transport) => {
-      const eventArgs = { arg: 'value' };
+      const eventArgs = [ 'value' ];
 
       const sendSpy = chai.spy((data) => {
         const packet = jstp.parse(data);

test/unit/remote-proxy.test.js

@@ -20,7 +20,7 @@ describe('RemoteProxy', () => {
     emitRemoteEvent() { },
 
     processEventPacket() {
-      proxy.emit('testEvent', 'payload', true);
+      proxy._emitLocal('testEvent', ['payload1', 'payload2']);
     }
   };
 
@@ -64,22 +64,22 @@ describe('RemoteProxy', () => {
   it('must emit events through the network and locally', () => {
     const handler = chai.spy();
     proxy.on('testEvent', handler);
-    proxy.emit('testEvent', 'payload');
+    proxy.emit('testEvent', 'payload1', 'payload2');
 
     expect(eventSpy).to.have.been.called.exactly(1);
     expect(eventSpy).to.have.been.called.with(
-      'testInterface', 'testEvent', 'payload');
+      'testInterface', 'testEvent', ['payload1', 'payload2']);
 
     expect(handler).to.have.been.called.exactly(1);
-    expect(handler).to.have.been.called.with('payload');
+    expect(handler).to.have.been.called.with('payload1', 'payload2');
   });
 
   it('must not re-emit events back', () => {
     const handler = chai.spy();
     proxy.on('testEvent', handler);
     connectionMock.processEventPacket();
 
-    expect(handler).to.have.been.called.with('payload');
+    expect(handler).to.have.been.called.with('payload1', 'payload2');
     expect(eventSpy).to.not.have.been.called();
   });
 });