node_modules ignore

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

@@ -0,0 +1 @@
+export declare function exposeRpc(fn: (...args: any[]) => any): void;

server/node_modules/fork-ts-checker-webpack-plugin/lib/rpc/expose-rpc.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exposeRpc = void 0;
+const process_1 = __importDefault(require("process"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function exposeRpc(fn) {
+    const sendMessage = (message) => new Promise((resolve, reject) => {
+        if (!process_1.default.send) {
+            reject(new Error(`Process ${process_1.default.pid} doesn't have IPC channels`));
+        }
+        else if (!process_1.default.connected) {
+            reject(new Error(`Process ${process_1.default.pid} doesn't have open IPC channels`));
+        }
+        else {
+            process_1.default.send(message, undefined, undefined, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+        }
+    });
+    const handleMessage = (message) => __awaiter(this, void 0, void 0, function* () {
+        if (message.type === 'call') {
+            if (!process_1.default.send) {
+                // process disconnected - skip
+                return;
+            }
+            let value;
+            let error;
+            try {
+                value = yield fn(...message.args);
+            }
+            catch (fnError) {
+                error = fnError;
+            }
+            try {
+                if (error) {
+                    yield sendMessage({
+                        type: 'reject',
+                        id: message.id,
+                        error,
+                    });
+                }
+                else {
+                    yield sendMessage({
+                        type: 'resolve',
+                        id: message.id,
+                        value,
+                    });
+                }
+            }
+            catch (sendError) {
+                // we can't send things back to the parent process - let's use stdout to communicate error
+                if (error) {
+                    console.error(error);
+                }
+                console.error(sendError);
+            }
+        }
+    });
+    process_1.default.on('message', handleMessage);
+}
+exports.exposeRpc = exposeRpc;

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

@@ -0,0 +1,5 @@
+export { exposeRpc } from './expose-rpc';
+export { wrapRpc } from './wrap-rpc';
+export { createRpcWorker, getRpcWorkerData, RpcWorker } from './rpc-worker';
+export { RpcExitError } from './rpc-error';
+export { RpcRemoteMethod } from './types';

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcExitError = exports.getRpcWorkerData = exports.createRpcWorker = exports.wrapRpc = exports.exposeRpc = void 0;
+var expose_rpc_1 = require("./expose-rpc");
+Object.defineProperty(exports, "exposeRpc", { enumerable: true, get: function () { return expose_rpc_1.exposeRpc; } });
+var wrap_rpc_1 = require("./wrap-rpc");
+Object.defineProperty(exports, "wrapRpc", { enumerable: true, get: function () { return wrap_rpc_1.wrapRpc; } });
+var rpc_worker_1 = require("./rpc-worker");
+Object.defineProperty(exports, "createRpcWorker", { enumerable: true, get: function () { return rpc_worker_1.createRpcWorker; } });
+Object.defineProperty(exports, "getRpcWorkerData", { enumerable: true, get: function () { return rpc_worker_1.getRpcWorkerData; } });
+var rpc_error_1 = require("./rpc-error");
+Object.defineProperty(exports, "RpcExitError", { enumerable: true, get: function () { return rpc_error_1.RpcExitError; } });

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

@@ -0,0 +1,6 @@
+declare class RpcExitError extends Error {
+    readonly code?: string | number | null | undefined;
+    readonly signal?: string | null | undefined;
+    constructor(message: string, code?: string | number | null | undefined, signal?: string | null | undefined);
+}
+export { RpcExitError };

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcExitError = void 0;
+class RpcExitError extends Error {
+    constructor(message, code, signal) {
+        super(message);
+        this.code = code;
+        this.signal = signal;
+        this.name = 'RpcExitError';
+    }
+}
+exports.RpcExitError = RpcExitError;

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { ChildProcess } from 'child_process';
+import type { RpcMethod, RpcRemoteMethod } from './types';
+interface RpcWorkerBase {
+    connect(): void;
+    terminate(): void;
+    readonly connected: boolean;
+    readonly process: ChildProcess | undefined;
+}
+declare type RpcWorker<T extends RpcMethod = RpcMethod> = RpcWorkerBase & RpcRemoteMethod<T>;
+declare function createRpcWorker<T extends RpcMethod>(modulePath: string, data: unknown, memoryLimit?: number): RpcWorker<T>;
+declare function getRpcWorkerData(): unknown;
+export { createRpcWorker, getRpcWorkerData, RpcWorker };

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

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRpcWorkerData = exports.createRpcWorker = void 0;
+const child_process = __importStar(require("child_process"));
+const process = __importStar(require("process"));
+const wrap_rpc_1 = require("./wrap-rpc");
+const WORKER_DATA_ENV_KEY = 'WORKER_DATA';
+function createRpcWorker(modulePath, data, memoryLimit) {
+    const options = {
+        env: Object.assign(Object.assign({}, process.env), { [WORKER_DATA_ENV_KEY]: JSON.stringify(data || {}) }),
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        serialization: 'advanced',
+    };
+    if (memoryLimit) {
+        options.execArgv = [`--max-old-space-size=${memoryLimit}`];
+    }
+    let childProcess;
+    let remoteMethod;
+    const worker = {
+        connect() {
+            if (childProcess && !childProcess.connected) {
+                childProcess.kill('SIGTERM');
+                childProcess = undefined;
+                remoteMethod = undefined;
+            }
+            if (!(childProcess === null || childProcess === void 0 ? void 0 : childProcess.connected)) {
+                childProcess = child_process.fork(modulePath, options);
+                remoteMethod = (0, wrap_rpc_1.wrapRpc)(childProcess);
+            }
+        },
+        terminate() {
+            if (childProcess) {
+                childProcess.kill('SIGTERM');
+                childProcess = undefined;
+                remoteMethod = undefined;
+            }
+        },
+        get connected() {
+            return Boolean(childProcess === null || childProcess === void 0 ? void 0 : childProcess.connected);
+        },
+        get process() {
+            return childProcess;
+        },
+    };
+    return Object.assign((...args) => {
+        if (!worker.connected) {
+            // try to auto-connect
+            worker.connect();
+        }
+        if (!remoteMethod) {
+            return Promise.reject('Worker is not connected - cannot perform RPC.');
+        }
+        return remoteMethod(...args);
+    }, worker);
+}
+exports.createRpcWorker = createRpcWorker;
+function getRpcWorkerData() {
+    return JSON.parse(process.env[WORKER_DATA_ENV_KEY] || '{}');
+}
+exports.getRpcWorkerData = getRpcWorkerData;

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

@@ -0,0 +1,19 @@
+interface RpcCallMessage {
+    type: 'call';
+    id: string;
+    args: unknown[];
+}
+interface RpcResolveMessage {
+    type: 'resolve';
+    id: string;
+    value: unknown;
+}
+interface RpcRejectMessage {
+    type: 'reject';
+    id: string;
+    error: unknown;
+}
+declare type RpcMessage = RpcCallMessage | RpcResolveMessage | RpcRejectMessage;
+declare type RpcMethod = (...args: any[]) => any;
+declare type RpcRemoteMethod<T extends RpcMethod> = T extends (...args: infer A) => infer R ? R extends Promise<any> ? (...args: A) => R : (...args: A) => Promise<R> : (...args: unknown[]) => Promise<unknown>;
+export { RpcCallMessage, RpcResolveMessage, RpcRejectMessage, RpcMessage, RpcMethod, RpcRemoteMethod, };

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

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

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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { ChildProcess } from 'child_process';
+import type { RpcRemoteMethod } from './types';
+export declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess): RpcRemoteMethod<T>;

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

@@ -0,0 +1,79 @@
+"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 });
+exports.wrapRpc = void 0;
+const controlled_promise_1 = require("../utils/async/controlled-promise");
+const rpc_error_1 = require("./rpc-error");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrapRpc(childProcess) {
+    return ((...args) => __awaiter(this, void 0, void 0, function* () {
+        if (!childProcess.send) {
+            throw new Error(`Process ${childProcess.pid} doesn't have IPC channels`);
+        }
+        else if (!childProcess.connected) {
+            throw new Error(`Process ${childProcess.pid} doesn't have open IPC channels`);
+        }
+        const id = uuid();
+        // create promises
+        const { promise: resultPromise, resolve: resolveResult, reject: rejectResult, } = (0, controlled_promise_1.createControlledPromise)();
+        const { promise: sendPromise, resolve: resolveSend, reject: rejectSend, } = (0, controlled_promise_1.createControlledPromise)();
+        const handleMessage = (message) => {
+            if ((message === null || message === void 0 ? void 0 : message.id) === id) {
+                if (message.type === 'resolve') {
+                    // assume the contract is respected
+                    resolveResult(message.value);
+                    removeHandlers();
+                }
+                else if (message.type === 'reject') {
+                    rejectResult(message.error);
+                    removeHandlers();
+                }
+            }
+        };
+        const handleClose = (code, signal) => {
+            rejectResult(new rpc_error_1.RpcExitError(code
+                ? `Process ${childProcess.pid} exited with code ${code}` +
+                    (signal ? ` [${signal}]` : '')
+                : `Process ${childProcess.pid} exited` + (signal ? ` [${signal}]` : ''), code, signal));
+            removeHandlers();
+        };
+        // to prevent event handler leaks
+        const removeHandlers = () => {
+            childProcess.off('message', handleMessage);
+            childProcess.off('close', handleClose);
+        };
+        // add event listeners
+        childProcess.on('message', handleMessage);
+        childProcess.on('close', handleClose);
+        // send call message
+        childProcess.send({
+            type: 'call',
+            id,
+            args,
+        }, (error) => {
+            if (error) {
+                rejectSend(error);
+                removeHandlers();
+            }
+            else {
+                resolveSend(undefined);
+            }
+        });
+        return sendPromise.then(() => resultPromise);
+    }));
+}
+exports.wrapRpc = wrapRpc;
+function uuid() {
+    return new Array(4)
+        .fill(0)
+        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+        .join('-');
+}