@tsslint/core 1.5.4 → 1.5.5

package/index.js

@@ -1,25 +1,17 @@
 "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;
@@ -32,498 +24,493 @@ 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) {
-			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 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 && !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, { dot: true });
+                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.4",
+	"version": "1.5.5",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.5.4",
+		"@tsslint/types": "1.5.5",
 		"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": "02cbc403c85b4224b5ccd732dc96f7a0991a6ae2"
+	"gitHead": "aa1bd7ed5b26cab99048001d1efa8880260f0c6e"
 }