up n_m

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/ProcessLike.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This interface describes Node.js process that is potentially able to communicate over IPC channel
+ */
+interface ProcessLike {
+    pid?: string | number;
+    send?: (message: any, sendHandle?: any, options?: any, callback?: (error: any) => void) => boolean;
+    on: (event: any, listener: any) => any;
+    off: (event: any, listener?: any) => any;
+    connected?: boolean;
+    disconnect?: () => void;
+}
+export { ProcessLike };

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/ProcessLike.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/RpcIpcMessageChannel.d.ts

@@ -0,0 +1,3 @@
+import { RpcMessageChannel } from '../index';
+declare function createRpcIpcMessageChannel(servicePath: string, memoryLimit?: number): RpcMessageChannel;
+export { createRpcIpcMessageChannel };

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/RpcIpcMessageChannel.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const RpcIpcMessagePort_1 = require("./RpcIpcMessagePort");
+function createRpcIpcMessageChannel(servicePath, memoryLimit = 2048) {
+    const port = RpcIpcMessagePort_1.createRpcIpcForkedProcessMessagePort(servicePath, memoryLimit);
+    // linked by the child_process IPC implementation - no manual linking needed
+    return index_1.createRpcMessageChannel(port, port);
+}
+exports.createRpcIpcMessageChannel = createRpcIpcMessageChannel;

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/RpcIpcMessagePort.d.ts

@@ -0,0 +1,5 @@
+import { ProcessLike } from './ProcessLike';
+import { RpcMessagePort } from '../index';
+declare function createRpcIpcMessagePort(process: ProcessLike): RpcMessagePort;
+declare function createRpcIpcForkedProcessMessagePort(filePath: string, memoryLimit?: number, autoRecreate?: boolean): RpcMessagePort;
+export { createRpcIpcMessagePort, createRpcIpcForkedProcessMessagePort };

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

@@ -0,0 +1,150 @@
+"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;

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/error/RpcIpcMessagePortClosedError.d.ts

@@ -0,0 +1,7 @@
+import { RpcMessagePortClosedError } from '../../error/RpcMessagePortClosedError';
+declare class RpcIpcMessagePortClosedError extends RpcMessagePortClosedError {
+    readonly code?: string | number | null | undefined;
+    readonly signal?: string | null | undefined;
+    constructor(message: string, code?: string | number | null | undefined, signal?: string | null | undefined);
+}
+export { RpcIpcMessagePortClosedError };

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/error/RpcIpcMessagePortClosedError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RpcMessagePortClosedError_1 = require("../../error/RpcMessagePortClosedError");
+class RpcIpcMessagePortClosedError extends RpcMessagePortClosedError_1.RpcMessagePortClosedError {
+    constructor(message, code, signal) {
+        super(message);
+        this.code = code;
+        this.signal = signal;
+        this.name = 'RpcIpcMessagePortClosedError';
+    }
+}
+exports.RpcIpcMessagePortClosedError = RpcIpcMessagePortClosedError;

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RpcIpcMessagePort';
+export * from './RpcIpcMessageChannel';

node_modules/fork-ts-checker-webpack-plugin/lib/rpc/rpc-ipc/index.js

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./RpcIpcMessagePort"));
+__export(require("./RpcIpcMessageChannel"));