up n_m

node_modules/fork-ts-checker-webpack-plugin/lib/issue/Issue.d.ts

@@ -0,0 +1,13 @@
+import { IssueSeverity } from './IssueSeverity';
+import { IssueLocation } from './IssueLocation';
+interface Issue {
+    origin: string;
+    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 };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/Issue.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IssueSeverity_1 = require("./IssueSeverity");
+const IssueLocation_1 = require("./IssueLocation");
+function isIssue(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        !!value.origin &&
+        IssueSeverity_1.isIssueSeverity(value.severity) &&
+        !!value.code &&
+        !!value.message);
+}
+exports.isIssue = isIssue;
+function compareStrings(stringA, stringB) {
+    if (stringA === stringB) {
+        return 0;
+    }
+    if (stringA === undefined || stringA === null) {
+        return -1;
+    }
+    if (stringB === undefined || stringB === null) {
+        return 1;
+    }
+    return stringA.toString().localeCompare(stringB.toString());
+}
+function compareIssues(issueA, issueB) {
+    return (IssueSeverity_1.compareIssueSeverities(issueA.severity, issueB.severity) ||
+        compareStrings(issueA.origin, issueB.origin) ||
+        compareStrings(issueA.file, issueB.file) ||
+        IssueLocation_1.compareIssueLocations(issueA.location, issueB.location) ||
+        compareStrings(issueA.code, issueB.code) ||
+        compareStrings(issueA.message, issueB.message) ||
+        0 /* EqualTo */);
+}
+function equalsIssues(issueA, issueB) {
+    return compareIssues(issueA, issueB) === 0;
+}
+function deduplicateAndSortIssues(issues) {
+    const sortedIssues = issues.filter(isIssue).sort(compareIssues);
+    return sortedIssues.filter((issue, index) => index === 0 || !equalsIssues(issue, sortedIssues[index - 1]));
+}
+exports.deduplicateAndSortIssues = deduplicateAndSortIssues;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueConfiguration.d.ts

@@ -0,0 +1,8 @@
+import webpack from 'webpack';
+import { IssuePredicate } from './IssuePredicate';
+import { IssueOptions } from './IssueOptions';
+interface IssueConfiguration {
+    predicate: IssuePredicate;
+}
+declare function createIssueConfiguration(compiler: webpack.Compiler, options: IssueOptions | undefined): IssueConfiguration;
+export { IssueConfiguration, createIssueConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueConfiguration.js

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueLocation.d.ts

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueLocation.js

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueMatch.d.ts

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueMatch.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 });
+const minimatch_1 = __importDefault(require("minimatch"));
+const path_1 = __importDefault(require("path"));
+const forwardSlash_1 = __importDefault(require("../utils/path/forwardSlash"));
+function createIssuePredicateFromIssueMatch(context, match) {
+    return (issue) => {
+        const matchesOrigin = !match.origin || match.origin === issue.origin;
+        const matchesSeverity = !match.severity || match.severity === issue.severity;
+        const matchesCode = !match.code || match.code === issue.code;
+        const matchesFile = !issue.file ||
+            (!!issue.file &&
+                (!match.file || minimatch_1.default(forwardSlash_1.default(path_1.default.relative(context, issue.file)), match.file)));
+        return matchesOrigin && matchesSeverity && matchesCode && matchesFile;
+    };
+}
+exports.createIssuePredicateFromIssueMatch = createIssuePredicateFromIssueMatch;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueOptions.d.ts

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueOptions.js

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePosition.d.ts

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePosition.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePredicate.d.ts

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePredicate.js

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueSeverity.d.ts

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

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueSeverity.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueWebpackError.d.ts

@@ -0,0 +1,8 @@
+import { Issue } from './Issue';
+declare class IssueWebpackError extends Error {
+    readonly issue: Issue;
+    readonly hideStack = true;
+    readonly file: string | undefined;
+    constructor(message: string, issue: Issue);
+}
+export { IssueWebpackError };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueWebpackError.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const IssueLocation_1 = require("./IssueLocation");
+const forwardSlash_1 = __importDefault(require("../utils/path/forwardSlash"));
+class IssueWebpackError extends Error {
+    constructor(message, 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 = forwardSlash_1.default(path_1.relative(process.cwd(), issue.file));
+            if (issue.location) {
+                this.file += `:${IssueLocation_1.formatIssueLocation(issue.location)}`;
+            }
+        }
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.IssueWebpackError = IssueWebpackError;

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

@@ -0,0 +1,3 @@
+export * from './Issue';
+export * from './IssueSeverity';
+export * from './IssueLocation';

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

@@ -0,0 +1,8 @@
+"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("./Issue"));
+__export(require("./IssueSeverity"));
+__export(require("./IssueLocation"));