@tsslint/core 1.5.3 → 1.5.4

package/index.d.ts

@@ -23,8 +23,8 @@ export declare function createLinter(ctx: ProjectContext, rootDir: string, confi
     getRefactorEdits(fileName: string, actionName: string): ts.FileTextChanges[] | undefined;
     getRules: (fileName: string, minimatchCache: undefined | FileLintCache[2]) => Record<string, Rule>;
     getConfigs: (fileName: string, minimatchCache: undefined | FileLintCache[2]) => {
-        include: string[];
-        exclude: string[];
+        include: string[] | undefined;
+        exclude: string[] | undefined;
         rules: Rules;
         formatting: FormattingProcess[] | undefined;
         plugins: import("@tsslint/types").PluginInstance[];

package/index.js

@@ -1,17 +1,25 @@
 "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 __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);
+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 });
 exports.createLinter = createLinter;
@@ -24,493 +32,498 @@ const ErrorStackParser = require("error-stack-parser");
 const path = require("path");
 const minimatch = require("minimatch");
 function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
-    const ts = ctx.typescript;
-    const fileRules = new Map();
-    const fileFmtProcesses = new Map();
-    const fileConfigs = new Map();
-    const lintResults = new Map();
-    const configs = (Array.isArray(config) ? config : [config])
-        .map(config => ({
-        include: config.include ?? [],
-        exclude: config.exclude ?? [],
-        rules: config.rules ?? {},
-        formatting: config.formatting,
-        plugins: (config.plugins ?? []).map(plugin => plugin(ctx)),
-    }));
-    const normalizedPath = new Map();
-    const rule2Mode = new Map();
-    const getNonBoundSourceFile = syntaxOnlyLanguageService?.getNonBoundSourceFile;
-    let shouldEnableTypeAware = false;
-    return {
-        format(sourceFile, minimatchCache) {
-            const preprocess = getFileFmtProcesses(sourceFile.fileName, minimatchCache);
-            const changes = [];
-            const tmpChanges = [];
-            const fmtCtx = {
-                typescript: ts,
-                sourceFile,
-                insert(pos, text) {
-                    tmpChanges.push({ span: { start: pos, length: 0 }, newText: text });
-                },
-                remove(start, end) {
-                    tmpChanges.push({ span: { start, length: end - start }, newText: '' });
-                },
-                replace(start, end, text) {
-                    tmpChanges.push({ span: { start, length: end - start }, newText: text });
-                },
-            };
-            for (const process of preprocess) {
-                process(fmtCtx);
-                if (tmpChanges.every(a => {
-                    const aStart = a.span.start;
-                    const aEnd = aStart + a.span.length;
-                    for (const b of changes) {
-                        const bStart = b.span.start;
-                        const bEnd = bStart + b.span.length;
-                        if ((bStart >= aEnd && bStart > aStart)
-                            || (bEnd <= aStart && bEnd < aEnd)) {
-                            continue;
-                        }
-                        return false;
-                    }
-                    return true;
-                })) {
-                    changes.push(...tmpChanges);
-                }
-                tmpChanges.length = 0;
-            }
-            return changes;
-        },
-        lint(fileName, cache) {
-            let currentRuleId;
-            let shouldRetry = false;
-            const rules = getFileRules(fileName, cache?.[2]);
-            const typeAwareMode = !getNonBoundSourceFile
-                || shouldEnableTypeAware && !Object.keys(rules).some(ruleId => !rule2Mode.has(ruleId));
-            const rulesContext = typeAwareMode
-                ? {
-                    ...ctx,
-                    sourceFile: ctx.languageService.getProgram().getSourceFile(fileName),
-                    reportError,
-                    reportWarning,
-                    reportSuggestion,
-                }
-                : {
-                    ...ctx,
-                    languageService: syntaxOnlyLanguageService,
-                    sourceFile: getNonBoundSourceFile(fileName),
-                    reportError,
-                    reportWarning,
-                    reportSuggestion,
-                };
-            const token = ctx.languageServiceHost.getCancellationToken?.();
-            const configs = getFileConfigs(fileName, cache?.[2]);
-            lintResults.set(fileName, [rulesContext.sourceFile, new Map(), []]);
-            const lintResult = lintResults.get(fileName);
-            for (const [ruleId, rule] of Object.entries(rules)) {
-                if (token?.isCancellationRequested()) {
-                    break;
-                }
-                currentRuleId = ruleId;
-                const ruleCache = cache?.[1][currentRuleId];
-                if (ruleCache) {
-                    let lintResult = lintResults.get(fileName);
-                    if (!lintResult) {
-                        lintResults.set(fileName, lintResult = [rulesContext.sourceFile, new Map(), []]);
-                    }
-                    for (const cacheDiagnostic of ruleCache[1]) {
-                        lintResult[1].set({
-                            ...cacheDiagnostic,
-                            file: rulesContext.sourceFile,
-                            relatedInformation: cacheDiagnostic.relatedInformation?.map(info => ({
-                                ...info,
-                                file: info.file ? syntaxOnlyLanguageService.getNonBoundSourceFile(info.file.fileName) : undefined,
-                            })),
-                        }, []);
-                    }
-                    if (!typeAwareMode) {
-                        rule2Mode.set(currentRuleId, false);
-                    }
-                    continue;
-                }
-                try {
-                    rule(rulesContext);
-                    if (!typeAwareMode) {
-                        rule2Mode.set(currentRuleId, false);
-                    }
-                }
-                catch (err) {
-                    if (!typeAwareMode) {
-                        // console.log(`Rule "${currentRuleId}" is type aware.`);
-                        rule2Mode.set(currentRuleId, true);
-                        shouldRetry = true;
-                    }
-                    else if (err instanceof Error) {
-                        report(ts.DiagnosticCategory.Error, err.stack ?? err.message, 0, 0, 0, err);
-                    }
-                    else {
-                        report(ts.DiagnosticCategory.Error, String(err), 0, 0, false);
-                    }
-                }
-                if (cache && !rule2Mode.get(currentRuleId)) {
-                    cache[1][currentRuleId] ??= [false, []];
-                    for (const [_, fixes] of lintResult[1]) {
-                        if (fixes.length) {
-                            cache[1][currentRuleId][0] = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (shouldRetry) {
-                // Retry
-                shouldEnableTypeAware = true;
-                return this.lint(fileName, cache);
-            }
-            let diagnostics = [...lintResult[1].keys()];
-            try {
-                for (const { plugins } of configs) {
-                    for (const { resolveDiagnostics } of plugins) {
-                        if (resolveDiagnostics) {
-                            diagnostics = resolveDiagnostics(rulesContext.sourceFile, diagnostics);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                if (!typeAwareMode) {
-                    // Retry
-                    shouldEnableTypeAware = true;
-                    return this.lint(fileName, cache);
-                }
-                throw error;
-            }
-            // Remove fixes and refactors that removed by resolveDiagnostics
-            const diagnosticSet = new Set(diagnostics);
-            for (const diagnostic of [...lintResult[1].keys()]) {
-                if (!diagnosticSet.has(diagnostic)) {
-                    lintResult[1].delete(diagnostic);
-                }
-            }
-            lintResult[2] = lintResult[2].filter(refactor => diagnosticSet.has(refactor.diagnostic));
-            return diagnostics;
-            function reportError(message, start, end, stackOffset) {
-                return report(ts.DiagnosticCategory.Error, message, start, end, stackOffset);
-            }
-            function reportWarning(message, start, end, stackOffset) {
-                return report(ts.DiagnosticCategory.Warning, message, start, end, stackOffset);
-            }
-            function reportSuggestion(message, start, end, stackOffset) {
-                return report(ts.DiagnosticCategory.Suggestion, message, start, end, stackOffset);
-            }
-            function report(category, message, start, end, stackOffset = 2, err) {
-                const error = {
-                    category,
-                    code: currentRuleId,
-                    messageText: message,
-                    file: rulesContext.sourceFile,
-                    start,
-                    length: end - start,
-                    source: 'tsslint',
-                    relatedInformation: [],
-                };
-                if (cache && !rule2Mode.get(currentRuleId)) {
-                    cache[1][currentRuleId] ??= [false, []];
-                    cache[1][currentRuleId][1].push({
-                        ...error,
-                        file: undefined,
-                        relatedInformation: error.relatedInformation?.map(info => ({
-                            ...info,
-                            file: info.file ? { fileName: info.file.fileName } : undefined,
-                        })),
-                    });
-                }
-                if (mode === 'typescript-plugin' && typeof stackOffset === 'number') {
-                    err ??= new Error();
-                    const relatedInfo = createRelatedInformation(ts, err, stackOffset);
-                    if (relatedInfo) {
-                        error.relatedInformation.push(relatedInfo);
-                    }
-                }
-                let lintResult = lintResults.get(fileName);
-                if (!lintResult) {
-                    lintResults.set(fileName, lintResult = [rulesContext.sourceFile, new Map(), []]);
-                }
-                const diagnostic2Fixes = lintResult[1];
-                const refactors = lintResult[2];
-                diagnostic2Fixes.set(error, []);
-                const fixes = diagnostic2Fixes.get(error);
-                return {
-                    withDeprecated() {
-                        error.reportsDeprecated = true;
-                        return this;
-                    },
-                    withUnnecessary() {
-                        error.reportsUnnecessary = true;
-                        return this;
-                    },
-                    withFix(title, getEdits) {
-                        fixes.push(({ title, getEdits }));
-                        return this;
-                    },
-                    withRefactor(title, getEdits) {
-                        refactors.push(({
-                            diagnostic: error,
-                            title,
-                            getEdits,
-                        }));
-                        return this;
-                    },
-                };
-            }
-        },
-        hasCodeFixes(fileName) {
-            const lintResult = lintResults.get(fileName);
-            if (!lintResult) {
-                return false;
-            }
-            for (const [_, fixes] of lintResult[1]) {
-                if (fixes.length) {
-                    return true;
-                }
-            }
-            return false;
-        },
-        getCodeFixes(fileName, start, end, diagnostics, minimatchCache) {
-            const lintResult = lintResults.get(fileName);
-            if (!lintResult) {
-                return [];
-            }
-            const sourceFile = lintResult[0];
-            const configs = getFileConfigs(fileName, minimatchCache);
-            const result = [];
-            for (const [diagnostic, actions] of lintResult[1]) {
-                if (diagnostics?.length && !diagnostics.includes(diagnostic)) {
-                    continue;
-                }
-                const diagStart = diagnostic.start;
-                const diagEnd = diagStart + diagnostic.length;
-                if ((diagStart >= start && diagStart <= end) ||
-                    (diagEnd >= start && diagEnd <= end) ||
-                    (start >= diagStart && start <= diagEnd) ||
-                    (end >= diagStart && end <= diagEnd)) {
-                    let codeFixes = [];
-                    for (const action of actions) {
-                        codeFixes.push({
-                            fixName: `tsslint:${diagnostic.code}`,
-                            description: action.title,
-                            changes: action.getEdits(),
-                            fixId: 'tsslint',
-                            fixAllDescription: 'Fix all TSSLint errors'
-                        });
-                    }
-                    for (const { plugins } of configs) {
-                        for (const { resolveCodeFixes } of plugins) {
-                            if (resolveCodeFixes) {
-                                codeFixes = resolveCodeFixes(sourceFile, diagnostic, codeFixes);
-                            }
-                        }
-                    }
-                    result.push(...codeFixes);
-                }
-            }
-            return result;
-        },
-        getRefactors(fileName, start, end) {
-            const lintResult = lintResults.get(fileName);
-            if (!lintResult) {
-                return [];
-            }
-            const result = [];
-            for (let i = 0; i < lintResult[2].length; i++) {
-                const refactor = lintResult[2][i];
-                const diagStart = refactor.diagnostic.start;
-                const diagEnd = diagStart + refactor.diagnostic.length;
-                if ((diagStart >= start && diagStart <= end) ||
-                    (diagEnd >= start && diagEnd <= end) ||
-                    (start >= diagStart && start <= diagEnd) ||
-                    (end >= diagStart && end <= diagEnd)) {
-                    result.push({
-                        name: `tsslint:${i}`,
-                        description: refactor.title,
-                        kind: 'quickfix',
-                    });
-                }
-            }
-            return result;
-        },
-        getRefactorEdits(fileName, actionName) {
-            if (actionName.startsWith('tsslint:')) {
-                const lintResult = lintResults.get(fileName);
-                if (!lintResult) {
-                    return [];
-                }
-                const index = actionName.slice('tsslint:'.length);
-                const refactor = lintResult[2][Number(index)];
-                if (refactor) {
-                    return refactor.getEdits();
-                }
-            }
-        },
-        getRules: getFileRules,
-        getConfigs: getFileConfigs,
-    };
-    function getFileFmtProcesses(fileName, minimatchCache) {
-        if (!fileFmtProcesses.has(fileName)) {
-            const allPreprocess = [];
-            const configs = getFileConfigs(fileName, minimatchCache);
-            for (const { formatting } of configs) {
-                if (formatting) {
-                    allPreprocess.push(...formatting);
-                }
-            }
-            fileFmtProcesses.set(fileName, allPreprocess);
-        }
-        return fileFmtProcesses.get(fileName);
-    }
-    function getFileRules(fileName, minimatchCache) {
-        let rules = fileRules.get(fileName);
-        if (!rules) {
-            rules = {};
-            const configs = getFileConfigs(fileName, minimatchCache);
-            for (const config of configs) {
-                collectRules(rules, config.rules, []);
-            }
-            for (const { plugins } of configs) {
-                for (const { resolveRules } of plugins) {
-                    if (resolveRules) {
-                        rules = resolveRules(fileName, rules);
-                    }
-                }
-            }
-            fileRules.set(fileName, rules);
-        }
-        return rules;
-    }
-    function collectRules(record, rules, paths) {
-        for (const [path, rule] of Object.entries(rules)) {
-            if (typeof rule === 'object') {
-                collectRules(record, rule, [...paths, path]);
-                continue;
-            }
-            record[[...paths, path].join('/')] = rule;
-        }
-    }
-    function getFileConfigs(fileName, minimatchCache) {
-        let result = fileConfigs.get(fileName);
-        if (!result) {
-            result = configs.filter(({ include, exclude }) => {
-                if (exclude.some(_minimatch)) {
-                    return false;
-                }
-                if (include.length && !include.some(_minimatch)) {
-                    return false;
-                }
-                return true;
-            });
-            fileConfigs.set(fileName, result);
-            function _minimatch(pattern) {
-                if (minimatchCache) {
-                    if (pattern in minimatchCache) {
-                        return minimatchCache[pattern];
-                    }
-                }
-                let normalized = normalizedPath.get(pattern);
-                if (!normalized) {
-                    normalized = ts.server.toNormalizedPath(path.resolve(rootDir, pattern));
-                    normalizedPath.set(pattern, normalized);
-                }
-                const res = minimatch.minimatch(fileName, normalized);
-                if (minimatchCache) {
-                    minimatchCache[pattern] = res;
-                }
-                return res;
-            }
-        }
-        return result;
-    }
+	const ts = ctx.typescript;
+	const fileRules = new Map();
+	const fileFmtProcesses = new Map();
+	const fileConfigs = new Map();
+	const lintResults = new Map();
+	const configs = (Array.isArray(config) ? config : [config])
+		.map(config => ({
+			include: config.include,
+			exclude: config.exclude,
+			rules: config.rules ?? {},
+			formatting: config.formatting,
+			plugins: (config.plugins ?? []).map(plugin => plugin(ctx)),
+		}));
+	const normalizedPath = new Map();
+	const rule2Mode = new Map();
+	const getNonBoundSourceFile = syntaxOnlyLanguageService?.getNonBoundSourceFile;
+	let shouldEnableTypeAware = false;
+	return {
+		format(sourceFile, minimatchCache) {
+			const preprocess = getFileFmtProcesses(sourceFile.fileName, minimatchCache);
+			const changes = [];
+			const tmpChanges = [];
+			const fmtCtx = {
+				typescript: ts,
+				sourceFile,
+				insert(pos, text) {
+					tmpChanges.push({ span: { start: pos, length: 0 }, newText: text });
+				},
+				remove(start, end) {
+					tmpChanges.push({ span: { start, length: end - start }, newText: '' });
+				},
+				replace(start, end, text) {
+					tmpChanges.push({ span: { start, length: end - start }, newText: text });
+				},
+			};
+			for (const process of preprocess) {
+				process(fmtCtx);
+				if (tmpChanges.every(a => {
+					const aStart = a.span.start;
+					const aEnd = aStart + a.span.length;
+					for (const b of changes) {
+						const bStart = b.span.start;
+						const bEnd = bStart + b.span.length;
+						if ((bStart >= aEnd && bStart > aStart)
+							|| (bEnd <= aStart && bEnd < aEnd)) {
+							continue;
+						}
+						return false;
+					}
+					return true;
+				})) {
+					changes.push(...tmpChanges);
+				}
+				tmpChanges.length = 0;
+			}
+			return changes;
+		},
+		lint(fileName, cache) {
+			const configs = getFileConfigs(fileName, cache?.[2]);
+			if (!configs.length) {
+				lintResults.set(fileName, [rulesContext.sourceFile, new Map(), []]);
+				return [];
+			}
+
+			let currentRuleId;
+			let shouldRetry = false;
+			const rules = getFileRules(fileName, cache?.[2]);
+			const typeAwareMode = !getNonBoundSourceFile
+				|| shouldEnableTypeAware && !Object.keys(rules).some(ruleId => !rule2Mode.has(ruleId));
+			const rulesContext = typeAwareMode
+				? {
+					...ctx,
+					sourceFile: ctx.languageService.getProgram().getSourceFile(fileName),
+					reportError,
+					reportWarning,
+					reportSuggestion,
+				}
+				: {
+					...ctx,
+					languageService: syntaxOnlyLanguageService,
+					sourceFile: getNonBoundSourceFile(fileName),
+					reportError,
+					reportWarning,
+					reportSuggestion,
+				};
+			const token = ctx.languageServiceHost.getCancellationToken?.();
+			lintResults.set(fileName, [rulesContext.sourceFile, new Map(), []]);
+			const lintResult = lintResults.get(fileName);
+			for (const [ruleId, rule] of Object.entries(rules)) {
+				if (token?.isCancellationRequested()) {
+					break;
+				}
+				currentRuleId = ruleId;
+				const ruleCache = cache?.[1][currentRuleId];
+				if (ruleCache) {
+					let lintResult = lintResults.get(fileName);
+					if (!lintResult) {
+						lintResults.set(fileName, lintResult = [rulesContext.sourceFile, new Map(), []]);
+					}
+					for (const cacheDiagnostic of ruleCache[1]) {
+						lintResult[1].set({
+							...cacheDiagnostic,
+							file: rulesContext.sourceFile,
+							relatedInformation: cacheDiagnostic.relatedInformation?.map(info => ({
+								...info,
+								file: info.file ? syntaxOnlyLanguageService.getNonBoundSourceFile(info.file.fileName) : undefined,
+							})),
+						}, []);
+					}
+					if (!typeAwareMode) {
+						rule2Mode.set(currentRuleId, false);
+					}
+					continue;
+				}
+				try {
+					rule(rulesContext);
+					if (!typeAwareMode) {
+						rule2Mode.set(currentRuleId, false);
+					}
+				}
+				catch (err) {
+					if (!typeAwareMode) {
+						// console.log(`Rule "${currentRuleId}" is type aware.`);
+						rule2Mode.set(currentRuleId, true);
+						shouldRetry = true;
+					}
+					else if (err instanceof Error) {
+						report(ts.DiagnosticCategory.Error, err.stack ?? err.message, 0, 0, 0, err);
+					}
+					else {
+						report(ts.DiagnosticCategory.Error, String(err), 0, 0, false);
+					}
+				}
+				if (cache && !rule2Mode.get(currentRuleId)) {
+					cache[1][currentRuleId] ??= [false, []];
+					for (const [_, fixes] of lintResult[1]) {
+						if (fixes.length) {
+							cache[1][currentRuleId][0] = true;
+							break;
+						}
+					}
+				}
+			}
+			if (shouldRetry) {
+				// Retry
+				shouldEnableTypeAware = true;
+				return this.lint(fileName, cache);
+			}
+			let diagnostics = [...lintResult[1].keys()];
+			try {
+				for (const { plugins } of configs) {
+					for (const { resolveDiagnostics } of plugins) {
+						if (resolveDiagnostics) {
+							diagnostics = resolveDiagnostics(rulesContext.sourceFile, diagnostics);
+						}
+					}
+				}
+			}
+			catch (error) {
+				if (!typeAwareMode) {
+					// Retry
+					shouldEnableTypeAware = true;
+					return this.lint(fileName, cache);
+				}
+				throw error;
+			}
+			// Remove fixes and refactors that removed by resolveDiagnostics
+			const diagnosticSet = new Set(diagnostics);
+			for (const diagnostic of [...lintResult[1].keys()]) {
+				if (!diagnosticSet.has(diagnostic)) {
+					lintResult[1].delete(diagnostic);
+				}
+			}
+			lintResult[2] = lintResult[2].filter(refactor => diagnosticSet.has(refactor.diagnostic));
+			return diagnostics;
+			function reportError(message, start, end, stackOffset) {
+				return report(ts.DiagnosticCategory.Error, message, start, end, stackOffset);
+			}
+			function reportWarning(message, start, end, stackOffset) {
+				return report(ts.DiagnosticCategory.Warning, message, start, end, stackOffset);
+			}
+			function reportSuggestion(message, start, end, stackOffset) {
+				return report(ts.DiagnosticCategory.Suggestion, message, start, end, stackOffset);
+			}
+			function report(category, message, start, end, stackOffset = 2, err) {
+				const error = {
+					category,
+					code: currentRuleId,
+					messageText: message,
+					file: rulesContext.sourceFile,
+					start,
+					length: end - start,
+					source: 'tsslint',
+					relatedInformation: [],
+				};
+				if (cache && !rule2Mode.get(currentRuleId)) {
+					cache[1][currentRuleId] ??= [false, []];
+					cache[1][currentRuleId][1].push({
+						...error,
+						file: undefined,
+						relatedInformation: error.relatedInformation?.map(info => ({
+							...info,
+							file: info.file ? { fileName: info.file.fileName } : undefined,
+						})),
+					});
+				}
+				if (mode === 'typescript-plugin' && typeof stackOffset === 'number') {
+					err ??= new Error();
+					const relatedInfo = createRelatedInformation(ts, err, stackOffset);
+					if (relatedInfo) {
+						error.relatedInformation.push(relatedInfo);
+					}
+				}
+				let lintResult = lintResults.get(fileName);
+				if (!lintResult) {
+					lintResults.set(fileName, lintResult = [rulesContext.sourceFile, new Map(), []]);
+				}
+				const diagnostic2Fixes = lintResult[1];
+				const refactors = lintResult[2];
+				diagnostic2Fixes.set(error, []);
+				const fixes = diagnostic2Fixes.get(error);
+				return {
+					withDeprecated() {
+						error.reportsDeprecated = true;
+						return this;
+					},
+					withUnnecessary() {
+						error.reportsUnnecessary = true;
+						return this;
+					},
+					withFix(title, getEdits) {
+						fixes.push(({ title, getEdits }));
+						return this;
+					},
+					withRefactor(title, getEdits) {
+						refactors.push(({
+							diagnostic: error,
+							title,
+							getEdits,
+						}));
+						return this;
+					},
+				};
+			}
+		},
+		hasCodeFixes(fileName) {
+			const lintResult = lintResults.get(fileName);
+			if (!lintResult) {
+				return false;
+			}
+			for (const [_, fixes] of lintResult[1]) {
+				if (fixes.length) {
+					return true;
+				}
+			}
+			return false;
+		},
+		getCodeFixes(fileName, start, end, diagnostics, minimatchCache) {
+			const lintResult = lintResults.get(fileName);
+			if (!lintResult) {
+				return [];
+			}
+			const sourceFile = lintResult[0];
+			const configs = getFileConfigs(fileName, minimatchCache);
+			const result = [];
+			for (const [diagnostic, actions] of lintResult[1]) {
+				if (diagnostics?.length && !diagnostics.includes(diagnostic)) {
+					continue;
+				}
+				const diagStart = diagnostic.start;
+				const diagEnd = diagStart + diagnostic.length;
+				if ((diagStart >= start && diagStart <= end) ||
+					(diagEnd >= start && diagEnd <= end) ||
+					(start >= diagStart && start <= diagEnd) ||
+					(end >= diagStart && end <= diagEnd)) {
+					let codeFixes = [];
+					for (const action of actions) {
+						codeFixes.push({
+							fixName: `tsslint:${diagnostic.code}`,
+							description: action.title,
+							changes: action.getEdits(),
+							fixId: 'tsslint',
+							fixAllDescription: 'Fix all TSSLint errors'
+						});
+					}
+					for (const { plugins } of configs) {
+						for (const { resolveCodeFixes } of plugins) {
+							if (resolveCodeFixes) {
+								codeFixes = resolveCodeFixes(sourceFile, diagnostic, codeFixes);
+							}
+						}
+					}
+					result.push(...codeFixes);
+				}
+			}
+			return result;
+		},
+		getRefactors(fileName, start, end) {
+			const lintResult = lintResults.get(fileName);
+			if (!lintResult) {
+				return [];
+			}
+			const result = [];
+			for (let i = 0; i < lintResult[2].length; i++) {
+				const refactor = lintResult[2][i];
+				const diagStart = refactor.diagnostic.start;
+				const diagEnd = diagStart + refactor.diagnostic.length;
+				if ((diagStart >= start && diagStart <= end) ||
+					(diagEnd >= start && diagEnd <= end) ||
+					(start >= diagStart && start <= diagEnd) ||
+					(end >= diagStart && end <= diagEnd)) {
+					result.push({
+						name: `tsslint:${i}`,
+						description: refactor.title,
+						kind: 'quickfix',
+					});
+				}
+			}
+			return result;
+		},
+		getRefactorEdits(fileName, actionName) {
+			if (actionName.startsWith('tsslint:')) {
+				const lintResult = lintResults.get(fileName);
+				if (!lintResult) {
+					return [];
+				}
+				const index = actionName.slice('tsslint:'.length);
+				const refactor = lintResult[2][Number(index)];
+				if (refactor) {
+					return refactor.getEdits();
+				}
+			}
+		},
+		getRules: getFileRules,
+		getConfigs: getFileConfigs,
+	};
+	function getFileFmtProcesses(fileName, minimatchCache) {
+		if (!fileFmtProcesses.has(fileName)) {
+			const allPreprocess = [];
+			const configs = getFileConfigs(fileName, minimatchCache);
+			for (const { formatting } of configs) {
+				if (formatting) {
+					allPreprocess.push(...formatting);
+				}
+			}
+			fileFmtProcesses.set(fileName, allPreprocess);
+		}
+		return fileFmtProcesses.get(fileName);
+	}
+	function getFileRules(fileName, minimatchCache) {
+		let rules = fileRules.get(fileName);
+		if (!rules) {
+			rules = {};
+			const configs = getFileConfigs(fileName, minimatchCache);
+			for (const config of configs) {
+				collectRules(rules, config.rules, []);
+			}
+			for (const { plugins } of configs) {
+				for (const { resolveRules } of plugins) {
+					if (resolveRules) {
+						rules = resolveRules(fileName, rules);
+					}
+				}
+			}
+			fileRules.set(fileName, rules);
+		}
+		return rules;
+	}
+	function collectRules(record, rules, paths) {
+		for (const [path, rule] of Object.entries(rules)) {
+			if (typeof rule === 'object') {
+				collectRules(record, rule, [...paths, path]);
+				continue;
+			}
+			record[[...paths, path].join('/')] = rule;
+		}
+	}
+	function getFileConfigs(fileName, minimatchCache) {
+		let result = fileConfigs.get(fileName);
+		if (!result) {
+			result = configs.filter(({ include, exclude }) => {
+				if (exclude?.some(_minimatch)) {
+					return false;
+				}
+				if (include && !include.some(_minimatch)) {
+					return false;
+				}
+				return true;
+			});
+			fileConfigs.set(fileName, result);
+			function _minimatch(pattern) {
+				if (minimatchCache) {
+					if (pattern in minimatchCache) {
+						return minimatchCache[pattern];
+					}
+				}
+				let normalized = normalizedPath.get(pattern);
+				if (!normalized) {
+					normalized = ts.server.toNormalizedPath(path.resolve(rootDir, pattern));
+					normalizedPath.set(pattern, normalized);
+				}
+				const res = minimatch.minimatch(fileName, normalized);
+				if (minimatchCache) {
+					minimatchCache[pattern] = res;
+				}
+				return res;
+			}
+		}
+		return result;
+	}
 }
 const fsFiles = new Map();
 function createRelatedInformation(ts, err, stackOffset) {
-    const stacks = ErrorStackParser.parse(err);
-    if (stacks.length <= stackOffset) {
-        return;
-    }
-    const stack = stacks[stackOffset];
-    if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
-        let fileName = stack.fileName.replace(/\\/g, '/');
-        if (fileName.startsWith('file://')) {
-            fileName = fileName.substring('file://'.length);
-        }
-        if (fileName.includes('http-url:')) {
-            fileName = fileName.split('http-url:')[1];
-        }
-        const mtime = ts.sys.getModifiedTime?.(fileName)?.getTime() ?? 0;
-        const lastMtime = fsFiles.get(fileName)?.[1];
-        if (mtime !== lastMtime) {
-            const text = ts.sys.readFile(fileName);
-            fsFiles.set(fileName, [
-                text !== undefined,
-                mtime,
-                ts.createSourceFile(fileName, text ?? '', ts.ScriptTarget.Latest, true)
-            ]);
-        }
-        const [exist, _mtime, relatedFile] = fsFiles.get(fileName);
-        let pos = 0;
-        if (exist) {
-            try {
-                pos = relatedFile.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1) ?? 0;
-            }
-            catch { }
-        }
-        return {
-            category: ts.DiagnosticCategory.Message,
-            code: 0,
-            file: relatedFile,
-            start: pos,
-            length: 0,
-            messageText: 'at ' + (stack.functionName ?? '<anonymous>'),
-        };
-    }
+	const stacks = ErrorStackParser.parse(err);
+	if (stacks.length <= stackOffset) {
+		return;
+	}
+	const stack = stacks[stackOffset];
+	if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
+		let fileName = stack.fileName.replace(/\\/g, '/');
+		if (fileName.startsWith('file://')) {
+			fileName = fileName.substring('file://'.length);
+		}
+		if (fileName.includes('http-url:')) {
+			fileName = fileName.split('http-url:')[1];
+		}
+		const mtime = ts.sys.getModifiedTime?.(fileName)?.getTime() ?? 0;
+		const lastMtime = fsFiles.get(fileName)?.[1];
+		if (mtime !== lastMtime) {
+			const text = ts.sys.readFile(fileName);
+			fsFiles.set(fileName, [
+				text !== undefined,
+				mtime,
+				ts.createSourceFile(fileName, text ?? '', ts.ScriptTarget.Latest, true)
+			]);
+		}
+		const [exist, _mtime, relatedFile] = fsFiles.get(fileName);
+		let pos = 0;
+		if (exist) {
+			try {
+				pos = relatedFile.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1) ?? 0;
+			}
+			catch { }
+		}
+		return {
+			category: ts.DiagnosticCategory.Message,
+			code: 0,
+			file: relatedFile,
+			start: pos,
+			length: 0,
+			messageText: 'at ' + (stack.functionName ?? '<anonymous>'),
+		};
+	}
 }
 function combineCodeFixes(fileName, fixes) {
-    const changes = fixes
-        .map(fix => fix.changes)
-        .flat()
-        .filter(change => change.fileName === fileName && change.textChanges.length)
-        .sort((a, b) => b.textChanges[0].span.start - a.textChanges[0].span.start);
-    let lastChangeAt = Number.MAX_VALUE;
-    let finalTextChanges = [];
-    for (const change of changes) {
-        const textChanges = [...change.textChanges].sort((a, b) => a.span.start - b.span.start);
-        const firstChange = textChanges[0];
-        const lastChange = textChanges[textChanges.length - 1];
-        if (lastChangeAt >= lastChange.span.start + lastChange.span.length) {
-            lastChangeAt = firstChange.span.start;
-            finalTextChanges = finalTextChanges.concat(textChanges);
-        }
-    }
-    return finalTextChanges;
+	const changes = fixes
+		.map(fix => fix.changes)
+		.flat()
+		.filter(change => change.fileName === fileName && change.textChanges.length)
+		.sort((a, b) => b.textChanges[0].span.start - a.textChanges[0].span.start);
+	let lastChangeAt = Number.MAX_VALUE;
+	let finalTextChanges = [];
+	for (const change of changes) {
+		const textChanges = [...change.textChanges].sort((a, b) => a.span.start - b.span.start);
+		const firstChange = textChanges[0];
+		const lastChange = textChanges[textChanges.length - 1];
+		if (lastChangeAt >= lastChange.span.start + lastChange.span.length) {
+			lastChangeAt = firstChange.span.start;
+			finalTextChanges = finalTextChanges.concat(textChanges);
+		}
+	}
+	return finalTextChanges;
 }
 function applyTextChanges(baseSnapshot, textChanges) {
-    textChanges = [...textChanges].sort((a, b) => b.span.start - a.span.start);
-    let text = baseSnapshot.getText(0, baseSnapshot.getLength());
-    for (const change of textChanges) {
-        text = text.slice(0, change.span.start) + change.newText + text.slice(change.span.start + change.span.length);
-    }
-    return {
-        getText(start, end) {
-            return text.substring(start, end);
-        },
-        getLength() {
-            return text.length;
-        },
-        getChangeRange(oldSnapshot) {
-            if (oldSnapshot === baseSnapshot) {
-                // TODO
-            }
-            return undefined;
-        },
-    };
+	textChanges = [...textChanges].sort((a, b) => b.span.start - a.span.start);
+	let text = baseSnapshot.getText(0, baseSnapshot.getLength());
+	for (const change of textChanges) {
+		text = text.slice(0, change.span.start) + change.newText + text.slice(change.span.start + change.span.length);
+	}
+	return {
+		getText(start, end) {
+			return text.substring(start, end);
+		},
+		getLength() {
+			return text.length;
+		},
+		getChangeRange(oldSnapshot) {
+			if (oldSnapshot === baseSnapshot) {
+				// TODO
+			}
+			return undefined;
+		},
+	};
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.5.3",
+	"version": "1.5.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.5.3",
+		"@tsslint/types": "1.5.4",
 		"error-stack-parser": "^2.1.4",
 		"esbuild": ">=0.17.0",
 		"minimatch": "^10.0.1"
@@ -23,5 +23,5 @@
 	"scripts": {
 		"postinstall": "node scripts/cleanCache.js"
 	},
-	"gitHead": "563035c62d04ff2a5c393f4a37ab9635960de1d6"
+	"gitHead": "02cbc403c85b4224b5ccd732dc96f7a0991a6ae2"
 }