@tsslint/core 1.2.4 → 1.3.0

package/index.d.ts

@@ -2,11 +2,18 @@ export * from './lib/build';
 export * from './lib/watch';
 import type { Config, ProjectContext } from '@tsslint/types';
 import type * as ts from 'typescript';
+export type FileLintCache = [
+    mtime: number,
+    ruleFixes: Record<string, number>,
+    result: ts.DiagnosticWithLocation[],
+    resolvedResult: ts.DiagnosticWithLocation[],
+    minimatchResult: Record<string, boolean>
+];
 export type Linter = ReturnType<typeof createLinter>;
-export declare function createLinter(ctx: ProjectContext, config: Config | Config[], withStack: boolean): {
-    lint(fileName: string): ts.DiagnosticWithLocation[];
+export declare function createLinter(ctx: ProjectContext, config: Config | Config[], mode: 'cli' | 'typescript-plugin'): {
+    lint(fileName: string, cache?: FileLintCache): ts.DiagnosticWithLocation[];
     hasCodeFixes(fileName: string): boolean;
-    getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[]): ts.CodeFixAction[];
+    getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[], cache?: FileLintCache): ts.CodeFixAction[];
     getRefactors(fileName: string, start: number, end: number): ts.RefactorActionInfo[];
     getRefactorEdits(fileName: string, actionName: string): ts.FileTextChanges[] | undefined;
 };

package/index.js

@@ -22,8 +22,8 @@ __exportStar(require("./lib/watch"), exports);
 const ErrorStackParser = require("error-stack-parser");
 const path = require("path");
 const minimatch = require("minimatch");
-function createLinter(ctx, config, withStack) {
-    if (withStack) {
+function createLinter(ctx, config, mode) {
+    if (mode === 'typescript-plugin') {
         require('source-map-support').install({
             retrieveFile(path) {
                 if (!path.endsWith('.js.map')) {
@@ -44,85 +44,168 @@ function createLinter(ctx, config, withStack) {
             },
         });
     }
+    let languageServiceUsage = mode === 'typescript-plugin' ? 1 : 0;
     const ts = ctx.typescript;
+    const languageService = new Proxy(ctx.languageService, {
+        get(target, key, receiver) {
+            if (!languageServiceUsage && debug) {
+                console.log('Type-aware mode enabled');
+            }
+            languageServiceUsage++;
+            return Reflect.get(target, key, receiver);
+        },
+    });
     const fileRules = new Map();
     const fileConfigs = new Map();
     const fileFixes = new Map();
     const fileRefactors = new Map();
     const sourceFiles = new Map();
+    const snapshot2SourceFile = new WeakMap();
     const basePath = path.dirname(ctx.configFile);
     const configs = (Array.isArray(config) ? config : [config])
         .map(config => ({
+        include: config.include ?? [],
+        exclude: config.exclude ?? [],
         rules: config.rules ?? {},
-        includes: (config.include ?? []).map(include => {
-            return ts.server.toNormalizedPath(path.resolve(basePath, include));
-        }),
-        excludes: (config.exclude ?? []).map(exclude => {
-            return ts.server.toNormalizedPath(path.resolve(basePath, exclude));
-        }),
         plugins: (config.plugins ?? []).map(plugin => plugin(ctx)),
     }));
+    const normalizedPath = new Map();
     const debug = (Array.isArray(config) ? config : [config]).some(config => config.debug);
     return {
-        lint(fileName) {
-            let diagnostics = [];
+        lint(fileName, cache) {
+            let cacheableDiagnostics = [];
+            let uncacheableDiagnostics = [];
             let debugInfo;
+            let currentRuleId;
+            let currentIssues = 0;
+            let currentFixes = 0;
+            let currentRefactors = 0;
+            let currentRuleLanguageServiceUsage = 0;
+            let sourceFile;
+            let hasUncacheResult = false;
             if (debug) {
                 debugInfo = {
                     category: ts.DiagnosticCategory.Message,
                     code: 'debug',
                     messageText: '- Config: ' + ctx.configFile + '\n',
-                    file: ctx.languageService.getProgram().getSourceFile(fileName),
+                    file: getSourceFile(fileName),
                     start: 0,
                     length: 0,
                     source: 'tsslint',
                     relatedInformation: [],
                 };
-                diagnostics.push(debugInfo);
+                uncacheableDiagnostics.push(debugInfo);
             }
-            const rules = getFileRules(fileName);
+            const rules = getFileRules(fileName, cache);
             if (!rules || !Object.keys(rules).length) {
                 if (debugInfo) {
                     debugInfo.messageText += '- Rules: ❌ (no rules)\n';
                 }
-                return diagnostics;
-            }
-            const sourceFile = ctx.languageService.getProgram()?.getSourceFile(fileName);
-            if (!sourceFile) {
-                throw new Error(`No source file found for ${fileName}`);
             }
+            const prevLanguageServiceUsage = languageServiceUsage;
             const rulesContext = {
                 ...ctx,
-                sourceFile,
+                languageService,
+                get sourceFile() {
+                    return sourceFile ??= getSourceFile(fileName);
+                },
                 reportError,
                 reportWarning,
                 reportSuggestion,
             };
             const token = ctx.languageServiceHost.getCancellationToken?.();
-            const fixes = getFileFixes(sourceFile.fileName);
-            const refactors = getFileRefactors(sourceFile.fileName);
-            let currentRuleId;
-            let currentIssues = 0;
-            let currentFixes = 0;
-            let currentRefactors = 0;
+            const fixes = getFileFixes(fileName);
+            const refactors = getFileRefactors(fileName);
+            const cachedRules = new Map();
+            if (cache) {
+                for (const ruleId in cache[1]) {
+                    cachedRules.set(ruleId, cache[1][ruleId]);
+                }
+            }
             fixes.clear();
             refactors.length = 0;
             if (debugInfo) {
                 debugInfo.messageText += '- Rules:\n';
             }
-            const processRules = (rules, paths = []) => {
+            runRules(rules);
+            if (!!prevLanguageServiceUsage !== !!languageServiceUsage) {
+                return this.lint(fileName, cache);
+            }
+            const configs = getFileConfigs(fileName, cache);
+            if (cache) {
+                for (const [ruleId, fixes] of cachedRules) {
+                    cache[1][ruleId] = fixes;
+                }
+            }
+            let diagnostics;
+            if (hasUncacheResult) {
+                diagnostics = [
+                    ...(cacheableDiagnostics.length
+                        ? cacheableDiagnostics
+                        : (cache?.[2] ?? []).map(data => ({
+                            ...data,
+                            file: rulesContext.sourceFile,
+                            relatedInformation: data.relatedInformation?.map(info => ({
+                                ...info,
+                                file: info.file ? getSourceFile(info.file.fileName) : undefined,
+                            })),
+                        }))),
+                    ...uncacheableDiagnostics,
+                ];
+                for (const { plugins } of configs) {
+                    for (const { resolveDiagnostics } of plugins) {
+                        if (resolveDiagnostics) {
+                            diagnostics = resolveDiagnostics(rulesContext.sourceFile, diagnostics);
+                        }
+                    }
+                }
+                if (cache) {
+                    cache[3] = diagnostics.map(data => ({
+                        ...data,
+                        file: undefined,
+                        relatedInformation: data.relatedInformation?.map(info => ({
+                            ...info,
+                            file: info.file ? { fileName: info.file.fileName } : undefined,
+                        })),
+                    }));
+                }
+            }
+            else {
+                diagnostics = (cache?.[3] ?? []).map(data => ({
+                    ...data,
+                    file: rulesContext.sourceFile,
+                    relatedInformation: data.relatedInformation?.map(info => ({
+                        ...info,
+                        file: info.file ? getSourceFile(info.file.fileName) : undefined,
+                    })),
+                }));
+            }
+            const diagnosticSet = new Set(diagnostics);
+            for (const diagnostic of [...fixes.keys()]) {
+                if (!diagnosticSet.has(diagnostic)) {
+                    fixes.delete(diagnostic);
+                }
+            }
+            fileRefactors.set(fileName, refactors.filter(refactor => diagnosticSet.has(refactor.diagnostic)));
+            return diagnostics;
+            function runRules(rules, paths = []) {
                 for (const [path, rule] of Object.entries(rules)) {
                     if (token?.isCancellationRequested()) {
                         break;
                     }
                     if (typeof rule === 'object') {
-                        processRules(rule, [...paths, path]);
+                        runRules(rule, [...paths, path]);
                         continue;
                     }
+                    currentRuleLanguageServiceUsage = languageServiceUsage;
                     currentRuleId = [...paths, path].join('/');
                     currentIssues = 0;
                     currentFixes = 0;
                     currentRefactors = 0;
+                    if (cachedRules.has(currentRuleId)) {
+                        continue;
+                    }
+                    hasUncacheResult = true;
                     const start = Date.now();
                     try {
                         rule(rulesContext);
@@ -154,25 +237,12 @@ function createLinter(ctx, config, withStack) {
                             debugInfo.messageText += `  - ${currentRuleId} (❌ ${err && typeof err === 'object' && 'stack' in err ? err.stack : String(err)}})\n`;
                         }
                     }
-                }
-            };
-            processRules(rules);
-            const configs = getFileConfigs(fileName);
-            for (const { plugins } of configs) {
-                for (const { resolveDiagnostics } of plugins) {
-                    if (resolveDiagnostics) {
-                        diagnostics = resolveDiagnostics(sourceFile.fileName, diagnostics);
+                    if (cache && currentRuleLanguageServiceUsage === languageServiceUsage) {
+                        cachedRules.set(currentRuleId, currentFixes);
                     }
                 }
             }
-            const diagnosticSet = new Set(diagnostics);
-            for (const diagnostic of [...fixes.keys()]) {
-                if (!diagnosticSet.has(diagnostic)) {
-                    fixes.delete(diagnostic);
-                }
-            }
-            fileRefactors.set(fileName, refactors.filter(refactor => diagnosticSet.has(refactor.diagnostic)));
-            return diagnostics;
+            ;
             function reportError(message, start, end, traceOffset = 0) {
                 return report(ts.DiagnosticCategory.Error, message, start, end, traceOffset);
             }
@@ -187,13 +257,24 @@ function createLinter(ctx, config, withStack) {
                     category,
                     code: currentRuleId,
                     messageText: message,
-                    file: sourceFile,
+                    file: rulesContext.sourceFile,
                     start,
                     length: end - start,
                     source: 'tsslint',
                     relatedInformation: [],
                 };
-                if (withStack) {
+                const cacheable = currentRuleLanguageServiceUsage === languageServiceUsage;
+                if (cache && cacheable) {
+                    cache[2].push({
+                        ...error,
+                        file: undefined,
+                        relatedInformation: error.relatedInformation?.map(info => ({
+                            ...info,
+                            file: info.file ? { fileName: info.file.fileName } : undefined,
+                        })),
+                    });
+                }
+                if (mode === 'typescript-plugin') {
                     const stacks = traceOffset === false
                         ? []
                         : ErrorStackParser.parse(new Error());
@@ -205,7 +286,7 @@ function createLinter(ctx, config, withStack) {
                     }
                 }
                 fixes.set(error, []);
-                diagnostics.push(error);
+                (cacheable ? cacheableDiagnostics : uncacheableDiagnostics).push(error);
                 currentIssues++;
                 return {
                     withDeprecated() {
@@ -279,8 +360,8 @@ function createLinter(ctx, config, withStack) {
             }
             return false;
         },
-        getCodeFixes(fileName, start, end, diagnostics) {
-            const configs = getFileConfigs(fileName);
+        getCodeFixes(fileName, start, end, diagnostics, cache) {
+            const configs = getFileConfigs(fileName, cache);
             const fixesMap = getFileFixes(fileName);
             const result = [];
             for (const [diagnostic, actions] of fixesMap) {
@@ -306,7 +387,7 @@ function createLinter(ctx, config, withStack) {
                     for (const { plugins } of configs) {
                         for (const { resolveCodeFixes } of plugins) {
                             if (resolveCodeFixes) {
-                                codeFixes = resolveCodeFixes(fileName, diagnostic, codeFixes);
+                                codeFixes = resolveCodeFixes(getSourceFile(fileName), diagnostic, codeFixes);
                             }
                         }
                     }
@@ -346,11 +427,28 @@ function createLinter(ctx, config, withStack) {
             }
         },
     };
-    function getFileRules(fileName) {
+    function getSourceFile(fileName) {
+        if (languageServiceUsage) {
+            return ctx.languageService.getProgram().getSourceFile(fileName);
+        }
+        else {
+            const snapshot = ctx.languageServiceHost.getScriptSnapshot(fileName);
+            if (snapshot) {
+                if (!snapshot2SourceFile.has(snapshot)) {
+                    const sourceFile = ts.createSourceFile(fileName, snapshot.getText(0, snapshot.getLength()), ts.ScriptTarget.ESNext, true);
+                    snapshot2SourceFile.set(snapshot, sourceFile);
+                    return sourceFile;
+                }
+                return snapshot2SourceFile.get(snapshot);
+            }
+        }
+        throw new Error('No source file');
+    }
+    function getFileRules(fileName, cache) {
         let result = fileRules.get(fileName);
         if (!result) {
             result = {};
-            const configs = getFileConfigs(fileName);
+            const configs = getFileConfigs(fileName, cache);
             for (const { rules } of configs) {
                 result = {
                     ...result,
@@ -368,19 +466,36 @@ function createLinter(ctx, config, withStack) {
         }
         return result;
     }
-    function getFileConfigs(fileName) {
+    function getFileConfigs(fileName, cache) {
         let result = fileConfigs.get(fileName);
         if (!result) {
-            result = configs.filter(({ includes, excludes }) => {
-                if (excludes.some(pattern => minimatch.minimatch(fileName, pattern))) {
+            result = configs.filter(({ include, exclude }) => {
+                if (exclude.some(_minimatch)) {
                     return false;
                 }
-                if (includes.length && !includes.some(pattern => minimatch.minimatch(fileName, pattern))) {
+                if (include.length && !include.some(_minimatch)) {
                     return false;
                 }
                 return true;
             });
             fileConfigs.set(fileName, result);
+            function _minimatch(pattern) {
+                if (cache) {
+                    if (pattern in cache[4]) {
+                        return cache[4][pattern];
+                    }
+                }
+                let normalized = normalizedPath.get(pattern);
+                if (!normalized) {
+                    normalized = ts.server.toNormalizedPath(path.resolve(basePath, pattern));
+                    normalizedPath.set(pattern, normalized);
+                }
+                const res = minimatch.minimatch(fileName, normalized);
+                if (cache) {
+                    cache[4][pattern] = res;
+                }
+                return res;
+            }
         }
         return result;
     }

package/lib/cache.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectContext } from '@tsslint/types';
+export declare function loadCache(configFilePath: string, createHash?: (path: string) => string): ProjectContext['cache'];
+export declare function saveCache(configFilePath: string, cache: ProjectContext['cache'], createHash?: (path: string) => string): void;
+export declare function getDotTsslintPath(configFilePath: string): string;

package/lib/cache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCache = loadCache;
+exports.saveCache = saveCache;
+exports.getDotTsslintPath = getDotTsslintPath;
+const path = require("path");
+const fs = require("fs");
+function loadCache(configFilePath, createHash = btoa) {
+    const outDir = getDotTsslintPath(configFilePath);
+    const cacheFileName = createHash(path.relative(outDir, configFilePath)) + '.cache.json';
+    const cacheFilePath = path.join(outDir, cacheFileName);
+    const cacheFileStat = fs.statSync(cacheFilePath);
+    const configFileStat = fs.statSync(configFilePath);
+    if (cacheFileStat.isFile() && cacheFileStat.mtimeMs > configFileStat.mtimeMs) {
+        try {
+            return require(cacheFilePath);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+function saveCache(configFilePath, cache, createHash = btoa) {
+    const outDir = getDotTsslintPath(configFilePath);
+    const cacheFileName = createHash(path.relative(outDir, configFilePath)) + '.cache.json';
+    const cacheFilePath = path.join(outDir, cacheFileName);
+    fs.writeFileSync(cacheFilePath, JSON.stringify(cache));
+}
+function getDotTsslintPath(configFilePath) {
+    return path.resolve(configFilePath, '..', 'node_modules', '.tsslint');
+}
+//# sourceMappingURL=cache.js.map

package/lib/watch.d.ts

@@ -12,3 +12,4 @@ export declare function watchConfigFile(configFilePath: string, onBuild: (config
         setup(build: esbuild.PluginBuild): void;
     }[];
 }>>;
+export declare function getDotTsslintPath(configFilePath: string): string;

package/lib/watch.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.watchConfigFile = watchConfigFile;
+exports.getDotTsslintPath = getDotTsslintPath;
 const esbuild = require("esbuild");
 const _path = require("path");
 const fs = require("fs");
@@ -8,7 +9,7 @@ const url = require("url");
 const ErrorStackParser = require("error-stack-parser");
 async function watchConfigFile(configFilePath, onBuild, watch = true, createHash = btoa, logger = console) {
     let start;
-    const outDir = _path.resolve(configFilePath, '..', 'node_modules', '.tsslint');
+    const outDir = getDotTsslintPath(configFilePath);
     const outFileName = createHash(_path.relative(outDir, configFilePath)) + '.mjs';
     const outFile = _path.join(outDir, outFileName);
     const resultHandler = async (result) => {
@@ -135,4 +136,7 @@ async function watchConfigFile(configFilePath, onBuild, watch = true, createHash
 function isTsFile(path) {
     return path.endsWith('.ts') || path.endsWith('.tsx') || path.endsWith('.cts') || path.endsWith('.mts');
 }
+function getDotTsslintPath(configFilePath) {
+    return _path.resolve(configFilePath, '..', 'node_modules', '.tsslint');
+}
 //# sourceMappingURL=watch.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.2.4",
+	"version": "1.3.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,11 +12,11 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.2.4",
+		"@tsslint/types": "1.3.0",
 		"error-stack-parser": "^2.1.4",
 		"esbuild": ">=0.17.0",
 		"minimatch": "^10.0.1",
 		"source-map-support": "^0.5.21"
 	},
-	"gitHead": "818bc257e90e431ca8988477862238c70a4757ff"
+	"gitHead": "3dcc9b0ee6ff8ba8902749edca1892edb5e072d4"
 }