up n_m

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

@@ -0,0 +1,10 @@
+import { RpcProcedure, RpcProcedurePayload, RpcProcedureResult } from './RpcProcedure';
+import { RpcMessagePort } from './RpcMessagePort';
+interface RpcClient {
+    readonly isConnected: () => boolean;
+    readonly connect: () => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly dispatchCall: <TProcedure extends RpcProcedure>(procedure: TProcedure, payload: RpcProcedurePayload<TProcedure>) => Promise<RpcProcedureResult<TProcedure>>;
+}
+declare function createRpcClient(port: RpcMessagePort): RpcClient;
+export { RpcClient, createRpcClient };

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

@@ -0,0 +1,78 @@
+"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 RpcMessage_1 = require("./RpcMessage");
+const RpcRemoteError_1 = require("./error/RpcRemoteError");
+/* eslint-enable @typescript-eslint/no-explicit-any */
+function createRpcClient(port) {
+    let callIndex = 0;
+    const callbacks = new Map();
+    let isListenerRegistered = false;
+    const returnOrThrowListener = (message) => __awaiter(this, void 0, void 0, function* () {
+        if (RpcMessage_1.isRpcReturnMessage(message)) {
+            const key = RpcMessage_1.getRpcMessageKey(message);
+            const callback = callbacks.get(key);
+            if (callback) {
+                callback.return(message.payload);
+                callbacks.delete(key);
+            }
+        }
+        if (RpcMessage_1.isRpcThrowMessage(message)) {
+            const key = RpcMessage_1.getRpcMessageKey(message);
+            const callback = callbacks.get(key);
+            if (callback) {
+                callback.throw(new RpcRemoteError_1.RpcRemoteError(message.payload.message, message.payload.stack));
+                callbacks.delete(key);
+            }
+        }
+    });
+    const errorListener = (error) => __awaiter(this, void 0, void 0, function* () {
+        callbacks.forEach((callback, key) => {
+            callback.throw(error);
+            callbacks.delete(key);
+        });
+    });
+    return {
+        isConnected: () => port.isOpen() && isListenerRegistered,
+        connect: () => __awaiter(this, void 0, void 0, function* () {
+            if (!port.isOpen()) {
+                yield port.open();
+            }
+            if (!isListenerRegistered) {
+                port.addMessageListener(returnOrThrowListener);
+                port.addErrorListener(errorListener);
+                isListenerRegistered = true;
+            }
+        }),
+        disconnect: () => __awaiter(this, void 0, void 0, function* () {
+            if (isListenerRegistered) {
+                port.removeMessageListener(returnOrThrowListener);
+                port.removeErrorListener(errorListener);
+                isListenerRegistered = false;
+            }
+            if (port.isOpen()) {
+                yield port.close();
+            }
+        }),
+        dispatchCall: (procedure, payload) => __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const call = RpcMessage_1.createRpcCall(procedure, callIndex++, payload);
+                const key = RpcMessage_1.getRpcMessageKey(call);
+                callbacks.set(key, { return: resolve, throw: reject });
+                port.dispatchMessage(call).catch((error) => {
+                    callbacks.delete(key);
+                    reject(error);
+                });
+            });
+        }),
+    };
+}
+exports.createRpcClient = createRpcClient;

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

@@ -0,0 +1,6 @@
+declare type RpcDispatcher = <TMessage>(message: TMessage) => Promise<void>;
+interface RpcHost {
+    dispatch: RpcDispatcher;
+    register: (dispatch: RpcDispatcher) => void;
+}
+export { RpcHost, RpcDispatcher };

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,26 @@
+import { RpcProcedure, RpcProcedurePayload, RpcProcedureResult } from './RpcProcedure';
+interface RpcMessage<TType extends string = string, TProcedure extends RpcProcedure = RpcProcedure, TPayload = unknown> {
+    rpc: true;
+    type: TType;
+    procedure: TProcedure;
+    id: number;
+    payload: TPayload;
+    source?: string;
+}
+interface RpcRemoteError {
+    message: string;
+    stack?: string;
+}
+declare type RpcCall<TProcedure extends RpcProcedure> = RpcMessage<'call', TProcedure, RpcProcedurePayload<TProcedure>>;
+declare type RpcReturn<TProcedure extends RpcProcedure> = RpcMessage<'return', TProcedure, RpcProcedureResult<TProcedure>>;
+declare type RpcThrow<TProcedure extends RpcProcedure> = RpcMessage<'throw', TProcedure, RpcRemoteError>;
+declare function createRpcMessage<TType extends string = string, TProcedure extends RpcProcedure = RpcProcedure, TPayload = unknown>(procedure: TProcedure, id: number, type: TType, payload: TPayload, source?: string): RpcMessage<TType, TProcedure, TPayload>;
+declare function createRpcCall<TProcedure extends RpcProcedure>(procedure: TProcedure, index: number, payload: RpcProcedurePayload<TProcedure>): RpcCall<TProcedure>;
+declare function createRpcReturn<TProcedure extends RpcProcedure>(procedure: TProcedure, index: number, payload: RpcProcedureResult<TProcedure>): RpcReturn<TProcedure>;
+declare function createRpcThrow<TProcedure extends RpcProcedure, TError = Error>(procedure: TProcedure, index: number, payload: RpcRemoteError): RpcThrow<TProcedure>;
+declare function isRpcMessage<TType extends string = string, TProcedure extends RpcProcedure = RpcProcedure>(candidate: unknown): candidate is RpcMessage<TType, TProcedure>;
+declare function isRpcCallMessage<TType extends string = string, TProcedure extends RpcProcedure = RpcProcedure>(candidate: unknown): candidate is RpcCall<TProcedure>;
+declare function isRpcReturnMessage<TType extends string = string, TProcedure extends RpcProcedure = RpcProcedure>(candidate: unknown): candidate is RpcReturn<TProcedure>;
+declare function isRpcThrowMessage<TType extends string = string, TProcedure extends RpcProcedure = RpcProcedure>(candidate: unknown): candidate is RpcThrow<TProcedure>;
+declare function getRpcMessageKey(message: RpcMessage): string;
+export { RpcMessage, RpcCall, RpcReturn, RpcThrow, createRpcMessage, createRpcCall, createRpcReturn, createRpcThrow, isRpcMessage, isRpcCallMessage, isRpcReturnMessage, isRpcThrowMessage, getRpcMessageKey, };

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createRpcMessage(procedure, id, type, payload, source) {
+    return {
+        rpc: true,
+        type,
+        id,
+        procedure,
+        payload,
+        source,
+    };
+}
+exports.createRpcMessage = createRpcMessage;
+function createRpcCall(procedure, index, payload) {
+    return createRpcMessage(procedure, index, 'call', payload);
+}
+exports.createRpcCall = createRpcCall;
+function createRpcReturn(procedure, index, payload) {
+    return createRpcMessage(procedure, index, 'return', payload);
+}
+exports.createRpcReturn = createRpcReturn;
+function createRpcThrow(procedure, index, payload) {
+    return createRpcMessage(procedure, index, 'throw', payload);
+}
+exports.createRpcThrow = createRpcThrow;
+function isRpcMessage(candidate) {
+    return !!(typeof candidate === 'object' && candidate && candidate.rpc);
+}
+exports.isRpcMessage = isRpcMessage;
+function isRpcCallMessage(candidate) {
+    return isRpcMessage(candidate) && candidate.type === 'call';
+}
+exports.isRpcCallMessage = isRpcCallMessage;
+function isRpcReturnMessage(candidate) {
+    return isRpcMessage(candidate) && candidate.type === 'return';
+}
+exports.isRpcReturnMessage = isRpcReturnMessage;
+function isRpcThrowMessage(candidate) {
+    return isRpcMessage(candidate) && candidate.type === 'throw';
+}
+exports.isRpcThrowMessage = isRpcThrowMessage;
+function getRpcMessageKey(message) {
+    return `${message.procedure}_${message.id}`;
+}
+exports.getRpcMessageKey = getRpcMessageKey;

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

@@ -0,0 +1,10 @@
+import { RpcMessagePort } from './RpcMessagePort';
+interface RpcMessageChannel {
+    readonly servicePort: RpcMessagePort;
+    readonly clientPort: RpcMessagePort;
+    readonly isOpen: () => boolean;
+    readonly open: () => Promise<void>;
+    readonly close: () => Promise<void>;
+}
+declare function createRpcMessageChannel(servicePort: RpcMessagePort, clientPort: RpcMessagePort, linkPorts?: () => Promise<void>, unlinkPorts?: () => Promise<void>): RpcMessageChannel;
+export { RpcMessageChannel, createRpcMessageChannel };

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

@@ -0,0 +1,49 @@
+"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 });
+function createRpcMessageChannel(servicePort, clientPort, linkPorts, unlinkPorts) {
+    // if there is not link and unlink function provided, we assume that channel is automatically linked
+    let arePortsLinked = !linkPorts && !unlinkPorts;
+    return {
+        servicePort,
+        clientPort,
+        isOpen: () => servicePort.isOpen() && clientPort.isOpen() && arePortsLinked,
+        open: () => __awaiter(this, void 0, void 0, function* () {
+            if (!servicePort.isOpen()) {
+                yield servicePort.open();
+            }
+            if (!clientPort.isOpen()) {
+                yield clientPort.open();
+            }
+            if (!arePortsLinked) {
+                if (linkPorts) {
+                    yield linkPorts();
+                }
+                arePortsLinked = true;
+            }
+        }),
+        close: () => __awaiter(this, void 0, void 0, function* () {
+            if (arePortsLinked) {
+                if (unlinkPorts) {
+                    yield unlinkPorts();
+                }
+                arePortsLinked = false;
+            }
+            if (servicePort.isOpen()) {
+                yield servicePort.close();
+            }
+            if (clientPort.isOpen()) {
+                yield clientPort.close();
+            }
+        }),
+    };
+}
+exports.createRpcMessageChannel = createRpcMessageChannel;

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

@@ -0,0 +1,14 @@
+declare type RpcMessageDispatch = <TMessage>(message: TMessage) => Promise<void>;
+declare type RpcMessageListener = RpcMessageDispatch;
+declare type RpcErrorListener = (error: Error) => void;
+interface RpcMessagePort {
+    readonly dispatchMessage: RpcMessageDispatch;
+    readonly addMessageListener: (listener: RpcMessageListener) => void;
+    readonly removeMessageListener: (listener: RpcMessageListener) => void;
+    readonly addErrorListener: (listener: RpcErrorListener) => void;
+    readonly removeErrorListener: (listener: RpcErrorListener) => void;
+    readonly isOpen: () => boolean;
+    readonly open: () => Promise<void>;
+    readonly close: () => Promise<void>;
+}
+export { RpcMessagePort, RpcMessageDispatch, RpcMessageListener, RpcErrorListener };

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,5 @@
+interface RpcProcedure<TPayload = unknown, TResult = unknown> extends String {
+}
+declare type RpcProcedurePayload<TProcedure> = TProcedure extends RpcProcedure<infer TPayload, infer TResult> ? TPayload : never;
+declare type RpcProcedureResult<TProcedure> = TProcedure extends RpcProcedure<infer TPayload, infer TResult> ? TResult : never;
+export { RpcProcedure, RpcProcedurePayload, RpcProcedureResult };

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+import { RpcProcedure } from './RpcProcedure';
+import { RpcMessagePort } from './RpcMessagePort';
+declare type RpcCallHandler<TPayload = any, TResult = any> = (payload: TPayload) => Promise<TResult>;
+interface RpcService {
+    readonly isOpen: () => boolean;
+    readonly open: () => Promise<void>;
+    readonly close: () => Promise<void>;
+    readonly addCallHandler: <TPayload, TResult>(procedure: RpcProcedure<TPayload, TResult>, handler: RpcCallHandler<TPayload, TResult>) => void;
+    readonly removeCallHandler: <TPayload, TResult>(procedure: RpcProcedure<TPayload, TResult>) => void;
+}
+declare function createRpcService(port: RpcMessagePort): RpcService;
+export { RpcService, createRpcService };

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

@@ -0,0 +1,63 @@
+"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 RpcMessage_1 = require("./RpcMessage");
+function createRpcService(port) {
+    const handlers = new Map();
+    let isListenerRegistered = false;
+    const callListener = (message) => __awaiter(this, void 0, void 0, function* () {
+        if (RpcMessage_1.isRpcCallMessage(message)) {
+            const handler = handlers.get(message.procedure);
+            try {
+                if (!handler) {
+                    throw new Error(`No handler found for procedure ${message.procedure}.`);
+                }
+                const result = yield handler(message.payload);
+                yield port.dispatchMessage(RpcMessage_1.createRpcReturn(message.procedure, message.id, result));
+            }
+            catch (error) {
+                yield port.dispatchMessage(RpcMessage_1.createRpcThrow(message.procedure, message.id, {
+                    message: error.toString(),
+                    stack: error.stack,
+                }));
+            }
+        }
+    });
+    return {
+        isOpen: () => port.isOpen() && isListenerRegistered,
+        open: () => __awaiter(this, void 0, void 0, function* () {
+            if (!port.isOpen()) {
+                yield port.open();
+            }
+            if (!isListenerRegistered) {
+                port.addMessageListener(callListener);
+                isListenerRegistered = true;
+            }
+        }),
+        close: () => __awaiter(this, void 0, void 0, function* () {
+            if (isListenerRegistered) {
+                port.removeMessageListener(callListener);
+                isListenerRegistered = false;
+            }
+            if (port.isOpen()) {
+                yield port.close();
+            }
+        }),
+        addCallHandler: (procedure, handler) => {
+            if (handlers.has(procedure)) {
+                throw new Error(`Handler for '${procedure}' procedure has been already registered`);
+            }
+            handlers.set(procedure, handler);
+        },
+        removeCallHandler: (procedure) => handlers.delete(procedure),
+    };
+}
+exports.createRpcService = createRpcService;

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

@@ -0,0 +1,3 @@
+declare class RpcMessagePortClosedError extends Error {
+}
+export { RpcMessagePortClosedError };

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RpcMessagePortClosedError extends Error {
+}
+exports.RpcMessagePortClosedError = RpcMessagePortClosedError;

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

@@ -0,0 +1,6 @@
+declare class RpcRemoteError extends Error {
+    readonly stack?: string | undefined;
+    constructor(message: string, stack?: string | undefined);
+    toString(): string;
+}
+export { RpcRemoteError };

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RpcRemoteError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.stack = stack;
+    }
+    toString() {
+        if (this.stack) {
+            return [this.message, this.stack].join('\n');
+        }
+        else {
+            return this.message;
+        }
+    }
+}
+exports.RpcRemoteError = RpcRemoteError;

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

@@ -0,0 +1,7 @@
+export * from './RpcMessage';
+export * from './RpcProcedure';
+export * from './RpcClient';
+export * from './RpcHost';
+export * from './RpcService';
+export * from './RpcMessagePort';
+export * from './RpcMessageChannel';

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

@@ -0,0 +1,9 @@
+"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("./RpcMessage"));
+__export(require("./RpcClient"));
+__export(require("./RpcService"));
+__export(require("./RpcMessageChannel"));

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