up n_m

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

@@ -0,0 +1,6 @@
+import { Reporter } from './Reporter';
+/**
+ * This higher order reporter aggregates too frequent getReport requests to avoid unnecessary computation.
+ */
+declare function createAggregatedReporter<TReporter extends Reporter>(reporter: TReporter): TReporter;
+export { createAggregatedReporter };

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

@@ -0,0 +1,60 @@
+"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 OperationCanceledError_1 = require("../error/OperationCanceledError");
+const FilesChange_1 = require("./FilesChange");
+/**
+ * This higher order reporter aggregates too frequent getReport requests to avoid unnecessary computation.
+ */
+function createAggregatedReporter(reporter) {
+    let pendingPromise;
+    let queuedIndex = 0;
+    let queuedChanges = [];
+    const aggregatedReporter = Object.assign(Object.assign({}, reporter), { getReport: (change) => __awaiter(this, void 0, void 0, function* () {
+            if (!pendingPromise) {
+                let resolvePending;
+                pendingPromise = new Promise((resolve) => {
+                    resolvePending = () => {
+                        resolve();
+                        pendingPromise = undefined;
+                    };
+                });
+                return reporter
+                    .getReport(change)
+                    .then((report) => (Object.assign(Object.assign({}, report), { close() {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            yield report.close();
+                            resolvePending();
+                        });
+                    } })))
+                    .catch((error) => {
+                    resolvePending();
+                    throw error;
+                });
+            }
+            else {
+                const currentIndex = ++queuedIndex;
+                queuedChanges.push(change);
+                return pendingPromise.then(() => {
+                    if (queuedIndex === currentIndex) {
+                        const change = FilesChange_1.aggregateFilesChanges(queuedChanges);
+                        queuedChanges = [];
+                        return aggregatedReporter.getReport(change);
+                    }
+                    else {
+                        throw new OperationCanceledError_1.OperationCanceledError('getReport canceled - new report requested.');
+                    }
+                });
+            }
+        }) });
+    return aggregatedReporter;
+}
+exports.createAggregatedReporter = createAggregatedReporter;

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

@@ -0,0 +1,16 @@
+import { Compiler } from 'webpack';
+interface FilesChange {
+    changedFiles?: string[];
+    deletedFiles?: string[];
+}
+declare function getFilesChange(compiler: Compiler): FilesChange;
+declare function updateFilesChange(compiler: Compiler, change: FilesChange): void;
+declare function clearFilesChange(compiler: Compiler): void;
+/**
+ * Computes aggregated files change based on the subsequent files changes.
+ *
+ * @param changes List of subsequent files changes
+ * @returns Files change that represents all subsequent changes as a one event
+ */
+declare function aggregateFilesChanges(changes: FilesChange[]): FilesChange;
+export { FilesChange, getFilesChange, updateFilesChange, clearFilesChange, aggregateFilesChanges };

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

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const substract_1 = __importDefault(require("../utils/array/substract"));
+const unique_1 = __importDefault(require("../utils/array/unique"));
+// we ignore package.json file because of https://github.com/TypeStrong/fork-ts-checker-webpack-plugin/issues/674
+const IGNORED_FILES = ['package.json'];
+const isIgnoredFile = (file) => IGNORED_FILES.some((ignoredFile) => file.endsWith(`/${ignoredFile}`) || file.endsWith(`\\${ignoredFile}`));
+const compilerFilesChangeMap = new WeakMap();
+function getFilesChange(compiler) {
+    const { changedFiles = [], deletedFiles = [] } = compilerFilesChangeMap.get(compiler) || {
+        changedFiles: [],
+        deletedFiles: [],
+    };
+    return {
+        changedFiles: changedFiles.filter((changedFile) => !isIgnoredFile(changedFile)),
+        deletedFiles: deletedFiles.filter((deletedFile) => !isIgnoredFile(deletedFile)),
+    };
+}
+exports.getFilesChange = getFilesChange;
+function updateFilesChange(compiler, change) {
+    compilerFilesChangeMap.set(compiler, aggregateFilesChanges([getFilesChange(compiler), change]));
+}
+exports.updateFilesChange = updateFilesChange;
+function clearFilesChange(compiler) {
+    compilerFilesChangeMap.delete(compiler);
+}
+exports.clearFilesChange = clearFilesChange;
+/**
+ * Computes aggregated files change based on the subsequent files changes.
+ *
+ * @param changes List of subsequent files changes
+ * @returns Files change that represents all subsequent changes as a one event
+ */
+function aggregateFilesChanges(changes) {
+    let changedFiles = [];
+    let deletedFiles = [];
+    for (const change of changes) {
+        changedFiles = unique_1.default(substract_1.default(changedFiles, change.deletedFiles).concat(change.changedFiles || []));
+        deletedFiles = unique_1.default(substract_1.default(deletedFiles, change.changedFiles).concat(change.deletedFiles || []));
+    }
+    return {
+        changedFiles,
+        deletedFiles,
+    };
+}
+exports.aggregateFilesChanges = aggregateFilesChanges;

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

@@ -0,0 +1,7 @@
+interface FilesMatch {
+    files: string[];
+    dirs: string[];
+    excluded: string[];
+    extensions: string[];
+}
+export { FilesMatch };

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

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

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

@@ -0,0 +1,8 @@
+import { FilesMatch } from './FilesMatch';
+import { Issue } from '../issue';
+interface Report {
+    getDependencies(): Promise<FilesMatch>;
+    getIssues(): Promise<Issue[]>;
+    close(): Promise<void>;
+}
+export { Report };

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

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

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

@@ -0,0 +1,6 @@
+import { FilesChange } from './FilesChange';
+import { Report } from './Report';
+interface Reporter {
+    getReport(change: FilesChange): Promise<Report>;
+}
+export { Reporter };

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

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

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

@@ -0,0 +1,7 @@
+export * from './Report';
+export * from './Reporter';
+export * from './AggregatedReporter';
+export * from './FilesChange';
+export * from './FilesMatch';
+export * from './reporter-rpc/ReporterRpcClient';
+export * from './reporter-rpc/ReporterRpcService';

node_modules/fork-ts-checker-webpack-plugin/lib/reporter/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("./AggregatedReporter"));
+__export(require("./FilesChange"));
+__export(require("./reporter-rpc/ReporterRpcClient"));
+__export(require("./reporter-rpc/ReporterRpcService"));

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;