@depup/fork-ts-checker-webpack-plugin 9.1.0-depup.0

package/lib/hooks/tap-done-to-async-get-issues.js

@@ -0,0 +1,86 @@
+"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.tapDoneToAsyncGetIssues = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const stats_formatter_1 = require("../formatter/stats-formatter");
+const webpack_formatter_1 = require("../formatter/webpack-formatter");
+const infrastructure_logger_1 = require("../infrastructure-logger");
+const issue_webpack_error_1 = require("../issue/issue-webpack-error");
+const plugin_hooks_1 = require("../plugin-hooks");
+const is_pending_1 = require("../utils/async/is-pending");
+const wait_1 = require("../utils/async/wait");
+function tapDoneToAsyncGetIssues(compiler, config, state) {
+    const hooks = (0, plugin_hooks_1.getPluginHooks)(compiler);
+    const { debug } = (0, infrastructure_logger_1.getInfrastructureLogger)(compiler);
+    compiler.hooks.done.tap('ForkTsCheckerWebpackPlugin', (stats) => __awaiter(this, void 0, void 0, function* () {
+        if (stats.compilation.compiler !== compiler) {
+            // run only for the compiler that the plugin was registered for
+            return;
+        }
+        const issuesPromise = state.issuesPromise;
+        let issues;
+        try {
+            if (yield (0, is_pending_1.isPending)(issuesPromise)) {
+                hooks.waiting.call(stats.compilation);
+                config.logger.log(chalk_1.default.cyan('Type-checking in progress...'));
+            }
+            else {
+                // wait 10ms to log issues after webpack stats
+                yield (0, wait_1.wait)(10);
+            }
+            issues = yield issuesPromise;
+        }
+        catch (error) {
+            hooks.error.call(error, stats.compilation);
+            return;
+        }
+        if (!issues || // some error has been thrown
+            state.issuesPromise !== issuesPromise // we have a new request - don't show results for the old one
+        ) {
+            return;
+        }
+        debug(`Got ${(issues === null || issues === void 0 ? void 0 : issues.length) || 0} issues from getIssuesWorker.`);
+        // filter list of issues by provided issue predicate
+        issues = issues.filter(config.issue.predicate);
+        // modify list of issues in the plugin hooks
+        issues = hooks.issues.call(issues, stats.compilation);
+        const formatter = (0, webpack_formatter_1.createWebpackFormatter)(config.formatter.format, config.formatter.pathType);
+        if (issues.length) {
+            // follow webpack's approach - one process.write to stderr with all errors and warnings
+            config.logger.error(issues.map((issue) => formatter(issue)).join('\n'));
+            // print stats of the compilation
+            config.logger.log((0, stats_formatter_1.statsFormatter)(issues, stats));
+        }
+        else {
+            config.logger.log(chalk_1.default.green('No typescript errors found.'));
+        }
+        // report issues to webpack-dev-server, if it's listening
+        // skip reporting if there are no issues, to avoid an extra hot reload
+        if (issues.length && state.webpackDevServerDoneTap) {
+            issues.forEach((issue) => {
+                const error = new issue_webpack_error_1.IssueWebpackError(config.formatter.format(issue), config.formatter.pathType, issue);
+                if (issue.severity === 'warning') {
+                    stats.compilation.warnings.push(error);
+                }
+                else {
+                    stats.compilation.errors.push(error);
+                }
+            });
+            debug('Sending issues to the webpack-dev-server.');
+            state.webpackDevServerDoneTap.fn(stats);
+        }
+    }));
+}
+exports.tapDoneToAsyncGetIssues = tapDoneToAsyncGetIssues;

package/lib/hooks/tap-error-to-log-message.d.ts

@@ -0,0 +1,4 @@
+import type * as webpack from 'webpack';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+declare function tapErrorToLogMessage(compiler: webpack.Compiler, config: ForkTsCheckerWebpackPluginConfig): void;
+export { tapErrorToLogMessage };

package/lib/hooks/tap-error-to-log-message.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tapErrorToLogMessage = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const plugin_hooks_1 = require("../plugin-hooks");
+const rpc_1 = require("../rpc");
+const abort_error_1 = require("../utils/async/abort-error");
+function tapErrorToLogMessage(compiler, config) {
+    const hooks = (0, plugin_hooks_1.getPluginHooks)(compiler);
+    hooks.error.tap('ForkTsCheckerWebpackPlugin', (error) => {
+        if (error instanceof abort_error_1.AbortError) {
+            return;
+        }
+        config.logger.error(String(error));
+        if (error instanceof rpc_1.RpcExitError) {
+            if (error.signal === 'SIGINT') {
+                config.logger.error(chalk_1.default.red('Issues checking service interrupted - If running in a docker container, this may be caused ' +
+                    "by the container running out of memory. If so, try increasing the container's memory limit " +
+                    'or lowering the `memoryLimit` value in the ForkTsCheckerWebpackPlugin configuration.'));
+            }
+            else {
+                config.logger.error(chalk_1.default.red('Issues checking service aborted - probably out of memory. ' +
+                    'Check the `memoryLimit` option in the ForkTsCheckerWebpackPlugin configuration.\n' +
+                    "If increasing the memory doesn't solve the issue, it's most probably a bug in the TypeScript."));
+            }
+        }
+    });
+}
+exports.tapErrorToLogMessage = tapErrorToLogMessage;

package/lib/hooks/tap-start-to-run-workers.d.ts

@@ -0,0 +1,8 @@
+import type * as webpack from 'webpack';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import type { RpcWorker } from '../rpc';
+import type { GetDependenciesWorker } from '../typescript/worker/get-dependencies-worker';
+import type { GetIssuesWorker } from '../typescript/worker/get-issues-worker';
+declare function tapStartToRunWorkers(compiler: webpack.Compiler, getIssuesWorker: RpcWorker<GetIssuesWorker>, getDependenciesWorker: RpcWorker<GetDependenciesWorker>, config: ForkTsCheckerWebpackPluginConfig, state: ForkTsCheckerWebpackPluginState): void;
+export { tapStartToRunWorkers };

package/lib/hooks/tap-start-to-run-workers.js

@@ -0,0 +1,132 @@
+"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.tapStartToRunWorkers = void 0;
+const node_abort_controller_1 = require("node-abort-controller");
+const files_change_1 = require("../files-change");
+const infrastructure_logger_1 = require("../infrastructure-logger");
+const plugin_hooks_1 = require("../plugin-hooks");
+const plugin_pools_1 = require("../plugin-pools");
+const intercept_done_to_get_dev_server_tap_1 = require("./intercept-done-to-get-dev-server-tap");
+const tap_after_compile_to_get_issues_1 = require("./tap-after-compile-to-get-issues");
+const tap_done_to_async_get_issues_1 = require("./tap-done-to-async-get-issues");
+function tapStartToRunWorkers(compiler, getIssuesWorker, getDependenciesWorker, config, state) {
+    const hooks = (0, plugin_hooks_1.getPluginHooks)(compiler);
+    const { log, debug } = (0, infrastructure_logger_1.getInfrastructureLogger)(compiler);
+    compiler.hooks.run.tap('ForkTsCheckerWebpackPlugin', () => {
+        if (!state.initialized) {
+            debug('Initializing plugin for single run (not async).');
+            state.initialized = true;
+            state.watching = false;
+            (0, tap_after_compile_to_get_issues_1.tapAfterCompileToGetIssues)(compiler, config, state);
+        }
+    });
+    compiler.hooks.watchRun.tap('ForkTsCheckerWebpackPlugin', () => __awaiter(this, void 0, void 0, function* () {
+        if (!state.initialized) {
+            state.initialized = true;
+            state.watching = true;
+            if (config.async) {
+                debug('Initializing plugin for watch run (async).');
+                (0, tap_done_to_async_get_issues_1.tapDoneToAsyncGetIssues)(compiler, config, state);
+                (0, intercept_done_to_get_dev_server_tap_1.interceptDoneToGetDevServerTap)(compiler, config, state);
+            }
+            else {
+                debug('Initializing plugin for watch run (not async).');
+                (0, tap_after_compile_to_get_issues_1.tapAfterCompileToGetIssues)(compiler, config, state);
+            }
+        }
+    }));
+    compiler.hooks.compilation.tap('ForkTsCheckerWebpackPlugin', (compilation) => __awaiter(this, void 0, void 0, function* () {
+        if (compilation.compiler !== compiler) {
+            // run only for the compiler that the plugin was registered for
+            return;
+        }
+        // get current iteration number
+        const iteration = ++state.iteration;
+        // abort previous iteration
+        if (state.abortController) {
+            debug(`Aborting iteration ${iteration - 1}.`);
+            state.abortController.abort();
+        }
+        // create new abort controller for the new iteration
+        const abortController = new node_abort_controller_1.AbortController();
+        state.abortController = abortController;
+        let filesChange = {};
+        if (state.watching) {
+            filesChange = (0, files_change_1.consumeFilesChange)(compiler);
+            log([
+                'Calling reporter service for incremental check.',
+                `  Changed files: ${JSON.stringify(filesChange.changedFiles)}`,
+                `  Deleted files: ${JSON.stringify(filesChange.deletedFiles)}`,
+            ].join('\n'));
+        }
+        else {
+            log('Calling reporter service for single check.');
+        }
+        filesChange = yield hooks.start.promise(filesChange, compilation);
+        let aggregatedFilesChange = filesChange;
+        if (state.aggregatedFilesChange) {
+            aggregatedFilesChange = (0, files_change_1.aggregateFilesChanges)([aggregatedFilesChange, filesChange]);
+            debug([
+                `Aggregating with previous files change, iteration ${iteration}.`,
+                `  Changed files: ${JSON.stringify(aggregatedFilesChange.changedFiles)}`,
+                `  Deleted files: ${JSON.stringify(aggregatedFilesChange.deletedFiles)}`,
+            ].join('\n'));
+        }
+        state.aggregatedFilesChange = aggregatedFilesChange;
+        // submit one at a time for a single compiler
+        state.issuesPromise = (state.issuesPromise || Promise.resolve())
+            // resolve to undefined on error
+            .catch(() => undefined)
+            .then(() => {
+            // early return
+            if (abortController.signal.aborted) {
+                return undefined;
+            }
+            debug(`Submitting the getIssuesWorker to the pool, iteration ${iteration}.`);
+            return plugin_pools_1.issuesPool.submit(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    debug(`Running the getIssuesWorker, iteration ${iteration}.`);
+                    const issues = yield getIssuesWorker(aggregatedFilesChange, state.watching);
+                    if (state.aggregatedFilesChange === aggregatedFilesChange) {
+                        state.aggregatedFilesChange = undefined;
+                    }
+                    if (state.abortController === abortController) {
+                        state.abortController = undefined;
+                    }
+                    return issues;
+                }
+                catch (error) {
+                    hooks.error.call(error, compilation);
+                    return undefined;
+                }
+                finally {
+                    debug(`The getIssuesWorker finished its job, iteration ${iteration}.`);
+                }
+            }), abortController.signal);
+        });
+        debug(`Submitting the getDependenciesWorker to the pool, iteration ${iteration}.`);
+        state.dependenciesPromise = plugin_pools_1.dependenciesPool.submit(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                debug(`Running the getDependenciesWorker, iteration ${iteration}.`);
+                return yield getDependenciesWorker(filesChange);
+            }
+            catch (error) {
+                hooks.error.call(error, compilation);
+                return undefined;
+            }
+            finally {
+                debug(`The getDependenciesWorker finished its job, iteration ${iteration}.`);
+            }
+        })); // don't pass abortController.signal because getDependencies() is blocking
+    }));
+}
+exports.tapStartToRunWorkers = tapStartToRunWorkers;

package/lib/hooks/tap-stop-to-terminate-workers.d.ts

@@ -0,0 +1,5 @@
+import type * as webpack from 'webpack';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import type { RpcWorker } from '../rpc';
+declare function tapStopToTerminateWorkers(compiler: webpack.Compiler, getIssuesWorker: RpcWorker, getDependenciesWorker: RpcWorker, state: ForkTsCheckerWebpackPluginState): void;
+export { tapStopToTerminateWorkers };

package/lib/hooks/tap-stop-to-terminate-workers.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tapStopToTerminateWorkers = void 0;
+const infrastructure_logger_1 = require("../infrastructure-logger");
+function tapStopToTerminateWorkers(compiler, getIssuesWorker, getDependenciesWorker, state) {
+    const { debug } = (0, infrastructure_logger_1.getInfrastructureLogger)(compiler);
+    const terminateWorkers = () => {
+        debug('Compiler is going to close - terminating workers...');
+        getIssuesWorker.terminate();
+        getDependenciesWorker.terminate();
+    };
+    compiler.hooks.watchClose.tap('ForkTsCheckerWebpackPlugin', () => {
+        terminateWorkers();
+    });
+    compiler.hooks.done.tap('ForkTsCheckerWebpackPlugin', () => {
+        if (!state.watching) {
+            terminateWorkers();
+        }
+    });
+    compiler.hooks.failed.tap('ForkTsCheckerWebpackPlugin', () => {
+        if (!state.watching) {
+            terminateWorkers();
+        }
+    });
+}
+exports.tapStopToTerminateWorkers = tapStopToTerminateWorkers;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { ForkTsCheckerWebpackPlugin } from './plugin';
+export = ForkTsCheckerWebpackPlugin;

package/lib/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const plugin_1 = require("./plugin");
+module.exports = plugin_1.ForkTsCheckerWebpackPlugin;

package/lib/infrastructure-logger.d.ts

@@ -0,0 +1,9 @@
+import type * as webpack from 'webpack';
+export interface InfrastructureLogger {
+    log(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+}
+export declare function getInfrastructureLogger(compiler: webpack.Compiler): InfrastructureLogger;

package/lib/infrastructure-logger.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInfrastructureLogger = void 0;
+function getInfrastructureLogger(compiler) {
+    const logger = compiler.getInfrastructureLogger('ForkTsCheckerWebpackPlugin');
+    return {
+        log: logger.log.bind(logger),
+        debug: logger.debug.bind(logger),
+        error: logger.error.bind(logger),
+        warn: logger.warn.bind(logger),
+        info: logger.info.bind(logger),
+    };
+}
+exports.getInfrastructureLogger = getInfrastructureLogger;

package/lib/issue/index.d.ts

@@ -0,0 +1,3 @@
+export * from './issue';
+export * from './issue-severity';
+export * from './issue-location';

package/lib/issue/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./issue"), exports);
+__exportStar(require("./issue-severity"), exports);
+__exportStar(require("./issue-location"), exports);

package/lib/issue/issue-config.d.ts

@@ -0,0 +1,8 @@
+import type * as webpack from 'webpack';
+import type { IssueOptions } from './issue-options';
+import type { IssuePredicate } from './issue-predicate';
+interface IssueConfig {
+    predicate: IssuePredicate;
+}
+declare function createIssueConfig(compiler: webpack.Compiler, options: IssueOptions | undefined): IssueConfig;
+export { IssueConfig, createIssueConfig };

package/lib/issue/issue-config.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIssueConfig = void 0;
+const issue_match_1 = require("./issue-match");
+const issue_predicate_1 = require("./issue-predicate");
+function createIssuePredicateFromOption(context, option) {
+    if (Array.isArray(option)) {
+        return (0, issue_predicate_1.composeIssuePredicates)(option.map((option) => typeof option === 'function' ? option : (0, issue_match_1.createIssuePredicateFromIssueMatch)(context, option)));
+    }
+    return typeof option === 'function'
+        ? option
+        : (0, issue_match_1.createIssuePredicateFromIssueMatch)(context, option);
+}
+function createIssueConfig(compiler, options) {
+    const context = compiler.options.context || process.cwd();
+    if (!options) {
+        options = {};
+    }
+    const include = options.include
+        ? createIssuePredicateFromOption(context, options.include)
+        : (0, issue_predicate_1.createTrivialIssuePredicate)(true);
+    const exclude = options.exclude
+        ? createIssuePredicateFromOption(context, options.exclude)
+        : (0, issue_predicate_1.createTrivialIssuePredicate)(false);
+    return {
+        predicate: (issue) => include(issue) && !exclude(issue),
+    };
+}
+exports.createIssueConfig = createIssueConfig;

package/lib/issue/issue-location.d.ts

@@ -0,0 +1,8 @@
+import type { IssuePosition } from './issue-position';
+interface IssueLocation {
+    start: IssuePosition;
+    end: IssuePosition;
+}
+declare function compareIssueLocations(locationA?: IssueLocation, locationB?: IssueLocation): number;
+declare function formatIssueLocation(location: IssueLocation): string;
+export { IssueLocation, compareIssueLocations, formatIssueLocation };

package/lib/issue/issue-location.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatIssueLocation = exports.compareIssueLocations = void 0;
+const issue_position_1 = require("./issue-position");
+function compareIssueLocations(locationA, locationB) {
+    if (locationA === locationB) {
+        return 0;
+    }
+    if (!locationA) {
+        return -1;
+    }
+    if (!locationB) {
+        return 1;
+    }
+    return ((0, issue_position_1.compareIssuePositions)(locationA.start, locationB.start) ||
+        (0, issue_position_1.compareIssuePositions)(locationA.end, locationB.end));
+}
+exports.compareIssueLocations = compareIssueLocations;
+function formatIssueLocation(location) {
+    return `${location.start.line}:${location.start.column}`;
+}
+exports.formatIssueLocation = formatIssueLocation;

package/lib/issue/issue-match.d.ts

@@ -0,0 +1,5 @@
+import type { IssuePredicate } from './issue-predicate';
+import type { Issue } from './index';
+type IssueMatch = Partial<Pick<Issue, 'severity' | 'code' | 'file'>>;
+declare function createIssuePredicateFromIssueMatch(context: string, match: IssueMatch): IssuePredicate;
+export { IssueMatch, createIssuePredicateFromIssueMatch };

package/lib/issue/issue-match.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIssuePredicateFromIssueMatch = void 0;
+const path_1 = __importDefault(require("path"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const forward_slash_1 = require("../utils/path/forward-slash");
+function createIssuePredicateFromIssueMatch(context, match) {
+    return (issue) => {
+        const matchesSeverity = !match.severity || match.severity === issue.severity;
+        const matchesCode = !match.code || match.code === issue.code;
+        const matchesFile = !issue.file ||
+            (!!issue.file &&
+                (!match.file || (0, minimatch_1.default)((0, forward_slash_1.forwardSlash)(path_1.default.relative(context, issue.file)), match.file)));
+        return matchesSeverity && matchesCode && matchesFile;
+    };
+}
+exports.createIssuePredicateFromIssueMatch = createIssuePredicateFromIssueMatch;

package/lib/issue/issue-options.d.ts

@@ -0,0 +1,8 @@
+import type { IssueMatch } from './issue-match';
+import type { IssuePredicate } from './issue-predicate';
+type IssuePredicateOption = IssuePredicate | IssueMatch | (IssuePredicate | IssueMatch)[];
+interface IssueOptions {
+    include?: IssuePredicateOption;
+    exclude?: IssuePredicateOption;
+}
+export { IssueOptions, IssuePredicateOption };

package/lib/issue/issue-options.js

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

package/lib/issue/issue-position.d.ts

@@ -0,0 +1,6 @@
+interface IssuePosition {
+    line: number;
+    column: number;
+}
+declare function compareIssuePositions(positionA?: IssuePosition, positionB?: IssuePosition): number;
+export { IssuePosition, compareIssuePositions };

package/lib/issue/issue-position.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareIssuePositions = void 0;
+function compareIssuePositions(positionA, positionB) {
+    if (positionA === positionB) {
+        return 0;
+    }
+    if (!positionA) {
+        return -1;
+    }
+    if (!positionB) {
+        return 1;
+    }
+    return (Math.sign(positionA.line - positionB.line) || Math.sign(positionA.column - positionB.column));
+}
+exports.compareIssuePositions = compareIssuePositions;

package/lib/issue/issue-predicate.d.ts

@@ -0,0 +1,5 @@
+import type { Issue } from './index';
+type IssuePredicate = (issue: Issue) => boolean;
+declare function createTrivialIssuePredicate(result: boolean): IssuePredicate;
+declare function composeIssuePredicates(predicates: IssuePredicate[]): IssuePredicate;
+export { IssuePredicate, createTrivialIssuePredicate, composeIssuePredicates };

package/lib/issue/issue-predicate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeIssuePredicates = exports.createTrivialIssuePredicate = void 0;
+function createTrivialIssuePredicate(result) {
+    return () => result;
+}
+exports.createTrivialIssuePredicate = createTrivialIssuePredicate;
+function composeIssuePredicates(predicates) {
+    return (issue) => predicates.some((predicate) => predicate(issue));
+}
+exports.composeIssuePredicates = composeIssuePredicates;

package/lib/issue/issue-severity.d.ts

@@ -0,0 +1,4 @@
+type IssueSeverity = 'error' | 'warning';
+declare function isIssueSeverity(value: unknown): value is IssueSeverity;
+declare function compareIssueSeverities(severityA: IssueSeverity, severityB: IssueSeverity): number;
+export { IssueSeverity, isIssueSeverity, compareIssueSeverities };

package/lib/issue/issue-severity.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareIssueSeverities = exports.isIssueSeverity = void 0;
+function isIssueSeverity(value) {
+    return ['error', 'warning'].includes(value);
+}
+exports.isIssueSeverity = isIssueSeverity;
+function compareIssueSeverities(severityA, severityB) {
+    const [priorityA, priorityB] = [severityA, severityB].map((severity) => ['warning' /* 0 */, 'error' /* 1 */].indexOf(severity));
+    return Math.sign(priorityB - priorityA);
+}
+exports.compareIssueSeverities = compareIssueSeverities;

package/lib/issue/issue-webpack-error.d.ts

@@ -0,0 +1,9 @@
+import * as webpack from 'webpack';
+import type { FormatterPathType } from '../formatter';
+import type { Issue } from './issue';
+declare class IssueWebpackError extends webpack.WebpackError {
+    readonly issue: Issue;
+    readonly hideStack = true;
+    constructor(message: string, pathType: FormatterPathType, issue: Issue);
+}
+export { IssueWebpackError };

package/lib/issue/issue-webpack-error.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueWebpackError = void 0;
+const path_1 = __importDefault(require("path"));
+const webpack = __importStar(require("webpack"));
+const forward_slash_1 = require("../utils/path/forward-slash");
+const relative_to_context_1 = require("../utils/path/relative-to-context");
+const issue_location_1 = require("./issue-location");
+class IssueWebpackError extends webpack.WebpackError {
+    constructor(message, pathType, issue) {
+        super(message);
+        this.issue = issue;
+        this.hideStack = true;
+        // to display issue location using `loc` property, webpack requires `error.module` which
+        // should be a NormalModule instance.
+        // to avoid such a dependency, we do a workaround - error.file will contain formatted location instead
+        if (issue.file) {
+            this.file =
+                pathType === 'absolute'
+                    ? (0, forward_slash_1.forwardSlash)(path_1.default.resolve(issue.file))
+                    : (0, relative_to_context_1.relativeToContext)(issue.file, process.cwd());
+            if (issue.location) {
+                this.file += `:${(0, issue_location_1.formatIssueLocation)(issue.location)}`;
+            }
+        }
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.IssueWebpackError = IssueWebpackError;

package/lib/issue/issue.d.ts

@@ -0,0 +1,12 @@
+import type { IssueLocation } from './issue-location';
+import type { IssueSeverity } from './issue-severity';
+interface Issue {
+    severity: IssueSeverity;
+    code: string;
+    message: string;
+    file?: string;
+    location?: IssueLocation;
+}
+declare function isIssue(value: unknown): value is Issue;
+declare function deduplicateAndSortIssues(issues: Issue[]): Issue[];
+export { Issue, isIssue, deduplicateAndSortIssues };