Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/RpcIpcMessagePort.js
f646e1f695a7paginated-inlines

RpcIpcMessagePort.js
View Options

			"use strict";
			var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
			function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
			return new (P \|\| (P = Promise))(function (resolve, reject) {
			function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
			function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
			function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
			step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
			});
			};
			Object.defineProperty(exports, "__esModule", { value: true });
			const child_process_1 = require("child_process");
			const RpcIpcMessagePortClosedError_1 = require("./error/RpcIpcMessagePortClosedError");
			function createRpcIpcMessagePort(process) {
			const messageListeners = new Set();
			const errorListeners = new Set();
			let closedError;
			const handleExit = (code, signal) => __awaiter(this, void 0, void 0, function* () {
			closedError = new RpcIpcMessagePortClosedError_1.RpcIpcMessagePortClosedError(code
			? `Process ${process.pid} exited with code "${code}" [${signal}]`
			: `Process ${process.pid} exited [${signal}].`, code, signal);
			errorListeners.forEach((listener) => {
			if (closedError) {
			listener(closedError);
			}
			});
			yield port.close();
			});
			const handleMessage = (message) => {
			messageListeners.forEach((listener) => {
			listener(message);
			});
			};
			process.on('message', handleMessage);
			process.on('exit', handleExit);
			const port = {
			dispatchMessage: (message) => __awaiter(this, void 0, void 0, function* () {
			return new Promise((resolve, reject) => {
			if (!process.connected) {
			reject(closedError \|\|
			new RpcIpcMessagePortClosedError_1.RpcIpcMessagePortClosedError(`Process ${process.pid} doesn't have open IPC channels`));
			}
			if (process.send) {
			process.send(Object.assign(Object.assign({}, message), { source: process.pid }), undefined, undefined, (sendError) => {
			if (sendError) {
			if (!closedError) {
			closedError = new RpcIpcMessagePortClosedError_1.RpcIpcMessagePortClosedError(`Cannot send the message - the message port has been closed for the process ${process.pid}.`);
			}
			reject(closedError);
			}
			else {
			resolve();
			}
			});
			}
			else {
			reject(new RpcIpcMessagePortClosedError_1.RpcIpcMessagePortClosedError(`Process ${process.pid} doesn't have IPC channels`));
			}
			});
			}),
			addMessageListener: (listener) => {
			messageListeners.add(listener);
			},
			removeMessageListener: (listener) => {
			messageListeners.delete(listener);
			},
			addErrorListener: (listener) => {
			errorListeners.add(listener);
			},
			removeErrorListener: (listener) => {
			errorListeners.delete(listener);
			},
			isOpen: () => !!process.connected,
			open: () => __awaiter(this, void 0, void 0, function* () {
			if (!process.connected \|\| closedError) {
			throw (closedError \|\|
			new RpcIpcMessagePortClosedError_1.RpcIpcMessagePortClosedError(`Cannot open closed IPC channel for process ${process.pid}.`));
			}
			}),
			close: () => __awaiter(this, void 0, void 0, function* () {
			process.off('message', handleMessage);
			process.off('exit', handleExit);
			messageListeners.clear();
			errorListeners.clear();
			if (process.disconnect && process.connected) {
			process.disconnect();
			}
			}),
			};
			return port;
			}
			exports.createRpcIpcMessagePort = createRpcIpcMessagePort;
			function createRpcIpcForkedProcessMessagePort(filePath, memoryLimit = 2048, autoRecreate = true) {
			function createChildProcess() {
			return child_process_1.fork(filePath, [], {
			execArgv: [`--max-old-space-size=${memoryLimit}`],
			stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
			});
			}
			const messageListeners = new Set();
			const errorListeners = new Set();
			let childProcess = createChildProcess();
			let port = createRpcIpcMessagePort(childProcess);
			return {
			dispatchMessage: (message) => port.dispatchMessage(message),
			addMessageListener: (listener) => {
			messageListeners.add(listener);
			return port.addMessageListener(listener);
			},
			removeMessageListener: (listener) => {
			messageListeners.delete(listener);
			return port.removeMessageListener(listener);
			},
			addErrorListener: (listener) => {
			errorListeners.add(listener);
			return port.addErrorListener(listener);
			},
			removeErrorListener: (listener) => {
			errorListeners.delete(listener);
			return port.removeErrorListener(listener);
			},
			isOpen: () => port.isOpen(),
			open: () => __awaiter(this, void 0, void 0, function* () {
			if (!port.isOpen() && autoRecreate) {
			// recreate the process and add existing message listeners
			childProcess = createChildProcess();
			port = createRpcIpcMessagePort(childProcess);
			messageListeners.forEach((listener) => {
			port.addMessageListener(listener);
			});
			errorListeners.forEach((listener) => {
			port.addErrorListener(listener);
			});
			}
			else {
			return port.open();
			}
			}),
			close: () => __awaiter(this, void 0, void 0, function* () {
			yield port.close();
			messageListeners.clear();
			errorListeners.clear();
			if (childProcess) {
			childProcess.kill('SIGTERM');
			childProcess = undefined;
			}
			}),
			};
			}
			exports.createRpcIpcForkedProcessMessagePort = createRpcIpcForkedProcessMessagePort;