up n_m

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

@@ -0,0 +1,10 @@
+import { Reporter } from '../Reporter';
+import { RpcMessageChannel } from '../../rpc';
+interface ReporterRpcClient extends Reporter {
+    isConnected: () => boolean;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+}
+declare function createReporterRpcClient<TConfiguration extends object>(channel: RpcMessageChannel, configuration: TConfiguration): ReporterRpcClient;
+declare function composeReporterRpcClients(clients: ReporterRpcClient[]): ReporterRpcClient;
+export { ReporterRpcClient, createReporterRpcClient, composeReporterRpcClients };

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

@@ -0,0 +1,82 @@
+"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 });
+const rpc_1 = require("../../rpc");
+const ReporterRpcProcedure_1 = require("./ReporterRpcProcedure");
+const flatten_1 = __importDefault(require("../../utils/array/flatten"));
+function createReporterRpcClient(channel, configuration) {
+    const rpcClient = rpc_1.createRpcClient(channel.clientPort);
+    return {
+        isConnected: () => channel.isOpen() && rpcClient.isConnected(),
+        connect: () => __awaiter(this, void 0, void 0, function* () {
+            if (!channel.isOpen()) {
+                yield channel.open();
+            }
+            if (!rpcClient.isConnected()) {
+                try {
+                    yield rpcClient.connect();
+                    yield rpcClient.dispatchCall(ReporterRpcProcedure_1.configure, configuration);
+                }
+                catch (error) {
+                    // connect or configure was not successful -
+                    // close the reporter and re-throw an error
+                    yield rpcClient.disconnect();
+                    yield channel.close();
+                    throw error;
+                }
+            }
+        }),
+        disconnect: () => __awaiter(this, void 0, void 0, function* () {
+            if (rpcClient.isConnected()) {
+                yield rpcClient.disconnect();
+            }
+            if (channel.isOpen()) {
+                yield channel.close();
+            }
+        }),
+        getReport: (change) => __awaiter(this, void 0, void 0, function* () {
+            const reportId = yield rpcClient.dispatchCall(ReporterRpcProcedure_1.getReport, change);
+            return {
+                getDependencies() {
+                    return rpcClient.dispatchCall(ReporterRpcProcedure_1.getDependencies, reportId);
+                },
+                getIssues() {
+                    return rpcClient.dispatchCall(ReporterRpcProcedure_1.getIssues, reportId);
+                },
+                close() {
+                    return rpcClient.dispatchCall(ReporterRpcProcedure_1.closeReport, reportId);
+                },
+            };
+        }),
+    };
+}
+exports.createReporterRpcClient = createReporterRpcClient;
+function composeReporterRpcClients(clients) {
+    return {
+        isConnected: () => clients.every((client) => client.isConnected()),
+        connect: () => Promise.all(clients.map((client) => client.connect())).then(() => undefined),
+        disconnect: () => Promise.all(clients.map((client) => client.disconnect())).then(() => undefined),
+        getReport: (change) => Promise.all(clients.map((client) => client.getReport(change))).then((reports) => ({
+            getDependencies: () => Promise.all(reports.map((report) => report.getDependencies())).then((dependencies) => dependencies.reduce((mergedDependencies, singleDependencies) => ({
+                files: Array.from(new Set([...mergedDependencies.files, ...singleDependencies.files])),
+                dirs: Array.from(new Set([...mergedDependencies.dirs, ...singleDependencies.dirs])),
+                excluded: Array.from(new Set([...mergedDependencies.excluded, ...singleDependencies.excluded])),
+                extensions: Array.from(new Set([...mergedDependencies.extensions, ...singleDependencies.extensions])),
+            }), { files: [], dirs: [], excluded: [], extensions: [] })),
+            getIssues: () => Promise.all(reports.map((report) => report.getIssues())).then((issues) => flatten_1.default(issues)),
+            close: () => Promise.all(reports.map((report) => report.close())).then(() => undefined),
+        })),
+    };
+}
+exports.composeReporterRpcClients = composeReporterRpcClients;

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

@@ -0,0 +1,10 @@
+import { RpcProcedure } from '../../rpc';
+import { FilesChange } from '../FilesChange';
+import { Issue } from '../../issue';
+import { FilesMatch } from '../FilesMatch';
+declare const configure: RpcProcedure<object, void>;
+declare const getReport: RpcProcedure<FilesChange, void>;
+declare const getDependencies: RpcProcedure<void, FilesMatch>;
+declare const getIssues: RpcProcedure<void, Issue[]>;
+declare const closeReport: RpcProcedure<void, void>;
+export { configure, getReport, getDependencies, getIssues, closeReport };

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configure = 'configure';
+exports.configure = configure;
+const getReport = 'getReport';
+exports.getReport = getReport;
+const getDependencies = 'getDependencies';
+exports.getDependencies = getDependencies;
+const getIssues = 'getIssues';
+exports.getIssues = getIssues;
+const closeReport = 'closeReport';
+exports.closeReport = closeReport;

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

@@ -0,0 +1,9 @@
+import { Reporter } from '../Reporter';
+import { RpcMessagePort } from '../../rpc';
+interface ReporterRpcService {
+    isOpen: () => boolean;
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+}
+declare function registerReporterRpcService<TConfiguration extends object>(servicePort: RpcMessagePort, reporterFactory: (configuration: TConfiguration) => Reporter): ReporterRpcService;
+export { ReporterRpcService, registerReporterRpcService };

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

@@ -0,0 +1,74 @@
+"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 rpc_1 = require("../../rpc");
+const ReporterRpcProcedure_1 = require("./ReporterRpcProcedure");
+function registerReporterRpcService(servicePort, reporterFactory) {
+    const rpcService = rpc_1.createRpcService(servicePort);
+    let reporterRegistered = false;
+    let report = undefined;
+    const registerReporter = () => {
+        rpcService.addCallHandler(ReporterRpcProcedure_1.configure, (configuration) => __awaiter(this, void 0, void 0, function* () {
+            rpcService.removeCallHandler(ReporterRpcProcedure_1.configure);
+            const reporter = reporterFactory(configuration);
+            rpcService.addCallHandler(ReporterRpcProcedure_1.getReport, (change) => __awaiter(this, void 0, void 0, function* () {
+                if (report) {
+                    throw new Error(`Close previous report before opening the next one.`);
+                }
+                report = yield reporter.getReport(change);
+            }));
+            rpcService.addCallHandler(ReporterRpcProcedure_1.getDependencies, () => {
+                if (!report) {
+                    throw new Error(`Cannot find active report.`);
+                }
+                return report.getDependencies();
+            });
+            rpcService.addCallHandler(ReporterRpcProcedure_1.getIssues, () => {
+                if (!report) {
+                    throw new Error(`Cannot find active report.`);
+                }
+                return report.getIssues();
+            });
+            rpcService.addCallHandler(ReporterRpcProcedure_1.closeReport, () => __awaiter(this, void 0, void 0, function* () {
+                report = undefined;
+            }));
+        }));
+    };
+    const unregisterReporter = () => {
+        rpcService.removeCallHandler(ReporterRpcProcedure_1.configure);
+        rpcService.removeCallHandler(ReporterRpcProcedure_1.getReport);
+        rpcService.removeCallHandler(ReporterRpcProcedure_1.getDependencies);
+        rpcService.removeCallHandler(ReporterRpcProcedure_1.getIssues);
+        rpcService.removeCallHandler(ReporterRpcProcedure_1.closeReport);
+    };
+    return {
+        isOpen: () => rpcService.isOpen() && reporterRegistered,
+        open: () => __awaiter(this, void 0, void 0, function* () {
+            if (!rpcService.isOpen()) {
+                yield rpcService.open();
+            }
+            if (!reporterRegistered) {
+                registerReporter();
+                reporterRegistered = true;
+            }
+        }),
+        close: () => __awaiter(this, void 0, void 0, function* () {
+            if (reporterRegistered) {
+                unregisterReporter();
+                reporterRegistered = false;
+            }
+            if (rpcService.isOpen()) {
+                yield rpcService.close();
+            }
+        }),
+    };
+}
+exports.registerReporterRpcService = registerReporterRpcService;