11import { EventEmitter } from "events" ;
2- import { isPromise } from "./util" ;
2+ import { isPromise , EventCallback } from "./util" ;
33
44// tslint:disable no-any
55
@@ -64,6 +64,22 @@ export abstract class ClientProxy<T extends ClientServerProxy> extends EventEmit
6464 return this ;
6565 }
6666
67+ /**
68+ * Bind the event locally and ensure the event is bound on the server.
69+ */
70+ public addListener ( event : string , listener : ( ...args : any [ ] ) => void ) : this {
71+ this . catch ( this . proxy . bindDelayedEvent ( event ) ) ;
72+
73+ return super . on ( event , listener ) ;
74+ }
75+
76+ /**
77+ * Alias for `addListener`.
78+ */
79+ public on ( event : string , listener : ( ...args : any [ ] ) => void ) : this {
80+ return this . addListener ( event , listener ) ;
81+ }
82+
6783 /**
6884 * Original promise for the server proxy. Can be used to be passed as an
6985 * argument.
@@ -89,9 +105,9 @@ export abstract class ClientProxy<T extends ClientServerProxy> extends EventEmit
89105 ? unpromisify ( this . _proxyPromise )
90106 : this . _proxyPromise ;
91107 if ( this . bindEvents ) {
92- this . catch ( this . proxy . onEvent ( ( event , ...args ) : void => {
108+ this . proxy . onEvent ( ( event , ...args ) : void => {
93109 this . emit ( event , ...args ) ;
94- } ) ) ;
110+ } ) ;
95111 }
96112
97113 return this . _proxy ;
@@ -114,8 +130,27 @@ export abstract class ClientProxy<T extends ClientServerProxy> extends EventEmit
114130 }
115131}
116132
133+ export interface ServerProxyOptions < T > {
134+ /**
135+ * The events to bind immediately.
136+ */
137+ bindEvents : string [ ] ;
138+ /**
139+ * Events that signal the proxy is done.
140+ */
141+ doneEvents : string [ ] ;
142+ /**
143+ * Events that should only be bound when asked
144+ */
145+ delayedEvents ?: string [ ] ;
146+ /**
147+ * Whatever is emitting events (stream, child process, etc).
148+ */
149+ instance : T ;
150+ }
151+
117152/**
118- * Proxy to the actual instance on the server. Every method must only accept
153+ * The actual proxy instance on the server. Every method must only accept
119154 * serializable arguments and must return promises with serializable values.
120155 *
121156 * If a proxy itself has proxies on creation (like how ChildProcess has stdin),
@@ -125,17 +160,51 @@ export abstract class ClientProxy<T extends ClientServerProxy> extends EventEmit
125160 * Events listeners are added client-side (since all events automatically
126161 * forward to the client), so onDone and onEvent do not need to be asynchronous.
127162 */
128- export interface ServerProxy {
163+ export abstract class ServerProxy < T extends EventEmitter = EventEmitter > {
164+ public readonly instance : T ;
165+
166+ private readonly callbacks = < EventCallback [ ] > [ ] ;
167+
168+ public constructor ( private readonly options : ServerProxyOptions < T > ) {
169+ this . instance = options . instance ;
170+ }
171+
129172 /**
130173 * Dispose the proxy.
131174 */
132- dispose ( ) : Promise < void > ;
175+ public async dispose ( ) : Promise < void > {
176+ this . instance . removeAllListeners ( ) ;
177+ }
133178
134179 /**
135180 * This is used instead of an event to force it to be implemented since there
136181 * would be no guarantee the implementation would remember to emit the event.
137182 */
138- onDone ( cb : ( ) => void ) : void ;
183+ public onDone ( cb : ( ) => void ) : void {
184+ this . options . doneEvents . forEach ( ( event ) => {
185+ this . instance . on ( event , cb ) ;
186+ } ) ;
187+ }
188+
189+ /**
190+ * Bind an event that will not fire without first binding it and shouldn't be
191+ * bound immediately.
192+
193+ * For example, binding to `data` switches a stream to flowing mode, so we
194+ * don't want to do it until we're asked. Otherwise something like `pipe`
195+ * won't work because potentially some or all of the data will already have
196+ * been flushed out.
197+ */
198+ public async bindDelayedEvent ( event : string ) : Promise < void > {
199+ if ( this . options . delayedEvents
200+ && this . options . delayedEvents . includes ( event )
201+ && ! this . options . bindEvents . includes ( event ) ) {
202+ this . options . bindEvents . push ( event ) ;
203+ this . callbacks . forEach ( ( cb ) => {
204+ this . instance . on ( event , ( ...args : any [ ] ) => cb ( event , ...args ) ) ;
205+ } ) ;
206+ }
207+ }
139208
140209 /**
141210 * Listen to all possible events. On the client, this is to reduce boilerplate
@@ -147,15 +216,20 @@ export interface ServerProxy {
147216 *
148217 * This cannot be async because then we can bind to the events too late.
149218 */
150- // tslint:disable-next-line no-any
151- onEvent ( cb : ( event : string , ...args : any [ ] ) => void ) : void ;
219+ public onEvent ( cb : EventCallback ) : void {
220+ this . callbacks . push ( cb ) ;
221+ this . options . bindEvents . forEach ( ( event ) => {
222+ this . instance . on ( event , ( ...args : any [ ] ) => cb ( event , ...args ) ) ;
223+ } ) ;
224+ }
152225}
153226
154227/**
155228 * A server-side proxy stored on the client. The proxy ID only exists on the
156- * client-side version of the server proxy.
229+ * client-side version of the server proxy. The event listeners are handled by
230+ * the client and the remaining methods are proxied to the server.
157231 */
158- export interface ClientServerProxy extends ServerProxy {
232+ export interface ClientServerProxy < T extends EventEmitter = EventEmitter > extends ServerProxy < T > {
159233 proxyId : number | Module ;
160234}
161235
0 commit comments