@tsslint/core 1.5.18 → 1.6.1

package/index.d.ts

@@ -1,6 +1,6 @@
 export * from './lib/build';
 export * from './lib/watch';
-import type { Config, ProjectContext, Rule, Rules, FormattingProcess } from '@tsslint/types';
+import type { Config, LinterContext, Rule, Rules } from '@tsslint/types';
 import type * as ts from 'typescript';
 export type FileLintCache = [
     mtime: number,
@@ -8,14 +8,12 @@ export type FileLintCache = [
         hasFix: boolean,
         diagnostics: ts.DiagnosticWithLocation[]
     ]>,
-    minimatchResult: Record<string, boolean>,
-    formated: boolean
+    minimatchResult: Record<string, boolean>
 ];
 export type Linter = ReturnType<typeof createLinter>;
-export declare function createLinter(ctx: ProjectContext, rootDir: string, config: Config | Config[], mode: 'cli' | 'typescript-plugin', syntaxOnlyLanguageService?: ts.LanguageService & {
+export declare function createLinter(ctx: LinterContext, rootDir: string, config: Config | Config[], handleError: (diag: ts.DiagnosticWithLocation, err: Error, stackOffset: number) => void, syntaxOnlyLanguageService?: ts.LanguageService & {
     getNonBoundSourceFile?(fileName: string): ts.SourceFile;
 }): {
-    format(sourceFile: ts.SourceFile, minimatchCache?: FileLintCache[2]): ts.TextChange[];
     lint(fileName: string, cache?: FileLintCache): ts.DiagnosticWithLocation[];
     hasCodeFixes(fileName: string): boolean;
     getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[], minimatchCache?: FileLintCache[2]): ts.CodeFixAction[];
@@ -26,10 +24,8 @@ export declare function createLinter(ctx: ProjectContext, rootDir: string, confi
         include: string[] | undefined;
         exclude: string[] | undefined;
         rules: Rules;
-        formatting: FormattingProcess[] | undefined;
         plugins: import("@tsslint/types").PluginInstance[];
     }[];
 };
-export declare function createRelatedInformation(ts: typeof import('typescript'), err: Error, stackOffset: number): ts.DiagnosticRelatedInformation | undefined;
 export declare function combineCodeFixes(fileName: string, fixes: ts.CodeFixAction[]): ts.TextChange[];
 export declare function applyTextChanges(baseSnapshot: ts.IScriptSnapshot, textChanges: ts.TextChange[]): ts.IScriptSnapshot;

package/index.js

@@ -15,18 +15,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinter = createLinter;
-exports.createRelatedInformation = createRelatedInformation;
 exports.combineCodeFixes = combineCodeFixes;
 exports.applyTextChanges = applyTextChanges;
 __exportStar(require("./lib/build"), exports);
 __exportStar(require("./lib/watch"), exports);
-const ErrorStackParser = require("error-stack-parser");
 const path = require("path");
 const minimatch = require("minimatch");
-function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
+function createLinter(ctx, rootDir, config, handleError, 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])
@@ -34,7 +31,6 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
         include: config.include,
         exclude: config.exclude,
         rules: config.rules ?? {},
-        formatting: config.formatting,
         plugins: (config.plugins ?? []).map(plugin => plugin(ctx)),
     }));
     const normalizedPath = new Map();
@@ -42,49 +38,10 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
     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 rules = getRulesForFile(fileName, cache?.[2]);
             const typeAwareMode = !getNonBoundSourceFile
                 || shouldEnableTypeAware && !Object.keys(rules).some(ruleId => !rule2Mode.has(ruleId));
             const rulesContext = typeAwareMode
@@ -104,7 +61,7 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
                     reportSuggestion,
                 };
             const token = ctx.languageServiceHost.getCancellationToken?.();
-            const configs = getFileConfigs(fileName, cache?.[2]);
+            const configs = getConfigsForFile(fileName, cache?.[2]);
             lintResults.set(fileName, [rulesContext.sourceFile, new Map(), []]);
             const lintResult = lintResults.get(fileName);
             for (const [ruleId, rule] of Object.entries(rules)) {
@@ -225,12 +182,8 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
                         })),
                     });
                 }
-                if (mode === 'typescript-plugin' && typeof stackOffset === 'number') {
-                    err ??= new Error();
-                    const relatedInfo = createRelatedInformation(ts, err, stackOffset);
-                    if (relatedInfo) {
-                        error.relatedInformation.push(relatedInfo);
-                    }
+                if (typeof stackOffset === 'number') {
+                    handleError(error, err ?? new Error(), stackOffset);
                 }
                 let lintResult = lintResults.get(fileName);
                 if (!lintResult) {
@@ -282,7 +235,7 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
                 return [];
             }
             const sourceFile = lintResult[0];
-            const configs = getFileConfigs(fileName, minimatchCache);
+            const configs = getConfigsForFile(fileName, minimatchCache);
             const result = [];
             for (const [diagnostic, actions] of lintResult[1]) {
                 if (diagnostics?.length && !diagnostics.includes(diagnostic)) {
@@ -352,27 +305,14 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
                 }
             }
         },
-        getRules: getFileRules,
-        getConfigs: getFileConfigs,
+        getRules: getRulesForFile,
+        getConfigs: getConfigsForFile,
     };
-    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) {
+    function getRulesForFile(fileName, minimatchCache) {
         let rules = fileRules.get(fileName);
         if (!rules) {
             rules = {};
-            const configs = getFileConfigs(fileName, minimatchCache);
+            const configs = getConfigsForFile(fileName, minimatchCache);
             for (const config of configs) {
                 collectRules(rules, config.rules, []);
             }
@@ -387,16 +327,7 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
         }
         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) {
+    function getConfigsForFile(fileName, minimatchCache) {
         let result = fileConfigs.get(fileName);
         if (!result) {
             result = configs.filter(({ include, exclude }) => {
@@ -409,68 +340,34 @@ function createLinter(ctx, rootDir, config, mode, syntaxOnlyLanguageService) {
                 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 result;
+        function _minimatch(pattern) {
+            if (minimatchCache) {
+                if (pattern in minimatchCache) {
+                    return minimatchCache[pattern];
                 }
-                return res;
             }
+            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;
+    function collectRules(record, rules, paths) {
+        for (const [path, rule] of Object.entries(rules)) {
+            if (typeof rule === 'object') {
+                collectRules(record, rule, [...paths, path]);
+                continue;
             }
-            catch { }
+            record[[...paths, path].join('/')] = rule;
         }
-        return {
-            category: ts.DiagnosticCategory.Message,
-            code: 0,
-            file: relatedFile,
-            start: pos,
-            length: 0,
-            messageText: 'at ' + (stack.functionName ?? '<anonymous>'),
-        };
     }
 }
 function combineCodeFixes(fileName, fixes) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.5.18",
+	"version": "1.6.1",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,8 +12,7 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.5.18",
-		"error-stack-parser": "^2.1.4",
+		"@tsslint/types": "1.6.1",
 		"esbuild": ">=0.17.0",
 		"minimatch": "^10.0.1"
 	},
@@ -23,5 +22,5 @@
 	"scripts": {
 		"postinstall": "node scripts/cleanCache.js"
 	},
-	"gitHead": "037ab1b5d72098fcf01c750420a98db8d8f28ba6"
+	"gitHead": "875699df671c2d9a8331c930af8c549ebab19f17"
 }