source: frontend/node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/RpcIpcMessagePort.js

"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;