TypeScript event.fromNodeEventEmitter函数代码示例

		return mapEvent(onHello, webContents => {
			const onMessage = createScopedOnMessageEvent(webContents.getId());
			const protocol = new Protocol(webContents, onMessage);
			const onDidClientDisconnect = fromNodeEventEmitter<void>(webContents, 'destroyed');

			return { protocol, onDidClientDisconnect };
		});

	constructor() {
		super({
			send: r => { try { process.send(r); } catch (e) { /* not much to do */ } },
			onMessage: fromNodeEventEmitter(process, 'message', msg => msg)
		});

		process.once('disconnect', () => this.dispose());
	}

	private static getOnDidClientConnect(): Event<ClientConnectionEvent> {
		const onHello = fromNodeEventEmitter<WebContents>(ipcMain, 'ipc:hello', ({ sender }) => sender);

		return mapEvent(onHello, webContents => {
			const onMessage = createScopedOnMessageEvent(webContents.getId());
			const protocol = new Protocol(webContents, onMessage);
			const onDidClientDisconnect = fromNodeEventEmitter<void>(webContents, 'destroyed');

			return { protocol, onDidClientDisconnect };
		});
	}

	private static getOnDidClientConnect(): Event<ClientConnectionEvent> {
		const onHello = fromNodeEventEmitter<Electron.WebContents>(ipcMain, 'ipc:hello', ({ sender }) => sender);

		return mapEvent(onHello, webContents => {
			const onMessage = createScopedOnMessageEvent(webContents.id, 'ipc:message');
			const onDidClientDisconnect = signalEvent(createScopedOnMessageEvent(webContents.id, 'ipc:disconnect'));
			const protocol = new Protocol(webContents, onMessage);

			return { protocol, onDidClientDisconnect };
		});
	}

	private static createProtocol(): Protocol {
		const onMessage = fromNodeEventEmitter<string>(ipcRenderer, 'ipc:message', (_, message) => message);
		ipcRenderer.send('ipc:hello');
		return new Protocol(ipcRenderer, onMessage);
	}

	private get client(): IPCClient {
		if (!this._client) {
			const args = this.options && this.options.args ? this.options.args : [];
			const forkOpts: ForkOptions = Object.create(null);

			forkOpts.env = assign(deepClone(process.env), { 'VSCODE_PARENT_PID': String(process.pid) });

			if (this.options && this.options.env) {
				forkOpts.env = assign(forkOpts.env, this.options.env);
			}

			if (this.options && this.options.freshExecArgv) {
				forkOpts.execArgv = [];
			}

			if (this.options && typeof this.options.debug === 'number') {
				forkOpts.execArgv = ['--nolazy', '--inspect=' + this.options.debug];
			}

			if (this.options && typeof this.options.debugBrk === 'number') {
				forkOpts.execArgv = ['--nolazy', '--inspect-brk=' + this.options.debugBrk];
			}

			this.child = fork(this.modulePath, args, forkOpts);

			const onMessageEmitter = new Emitter<any>();
			const onRawMessage = fromNodeEventEmitter(this.child, 'message', msg => msg);

			onRawMessage(msg => {

				// Handle remote console logs specially
				if (isRemoteConsoleLog(msg)) {
					log(msg, `IPC Library: ${this.options.serverName}`);
					return null;
				}

				// Anything else goes to the outside
				onMessageEmitter.fire(msg);
			});

			const sender = this.options.useQueue ? createQueuedSender(this.child) : this.child;
			const send = r => this.child && this.child.connected && sender.send(r);
			const onMessage = onMessageEmitter.event;
			const protocol = { send, onMessage };

			this._client = new IPCClient(protocol);

			const onExit = () => this.disposeClient();
			process.once('exit', onExit);

			this.child.on('error', err => console.warn('IPC "' + this.options.serverName + '" errored with ' + err));

			this.child.on('exit', (code: any, signal: any) => {
				process.removeListener('exit', onExit);

				if (this.activeRequests) {
					this.activeRequests.forEach(req => req.cancel());
					this.activeRequests = [];
				}

				if (code !== 0 && signal !== 'SIGTERM') {
					console.warn('IPC "' + this.options.serverName + '" crashed with exit code ' + code + ' and signal ' + signal);
					this.disposeDelayer.cancel();
					this.disposeClient();
				}
			});
		}

		return this._client;
	}

function createScopedOnMessageEvent(senderId: number): Event<any> {
	const onMessage = fromNodeEventEmitter<IIPCEvent>(ipcMain, 'ipc:message', (event, message) => ({ event, message }));
	const onMessageFromSender = filterEvent(onMessage, ({ event }) => event.sender.getId() === senderId);
	return mapEvent(onMessageFromSender, ({ message }) => message);
}

function createScopedOnMessageEvent(senderId: number, eventName: string): Event<string> {
	const onMessage = fromNodeEventEmitter<IIPCEvent>(ipcMain, eventName, (event, message: string) => ({ event, message }));
	const onMessageFromSender = filterEvent(onMessage, ({ event }) => event.sender.id === senderId);
	return mapEvent(onMessageFromSender, ({ message }) => message);
}