@tsslint/core 2.0.7 → 3.0.0-alpha.1

package/index.d.ts

@@ -1,5 +1,3 @@
-export * from './lib/build';
-export * from './lib/watch';
 import type { Config, LinterContext, Rule, Rules } from '@tsslint/types';
 import type * as ts from 'typescript';
 export type FileLintCache = [
@@ -11,7 +9,7 @@ export type FileLintCache = [
     minimatchResult: Record<string, boolean>
 ];
 export type Linter = ReturnType<typeof createLinter>;
-export declare function createLinter(ctx: LinterContext, rootDir: string, config: Config | Config[], handleError: (diag: ts.DiagnosticWithLocation, err: Error, stackOffset: number) => void, syntaxOnlyLanguageService?: ts.LanguageService & {
+export declare function createLinter(ctx: LinterContext, rootDir: string, config: Config | Config[], getRelatedInformations: (err: Error, stackIndex: number) => ts.DiagnosticRelatedInformation[], syntaxOnlyLanguageService?: ts.LanguageService & {
     getNonBoundSourceFile?(fileName: string): ts.SourceFile;
 }): {
     lint(fileName: string, cache?: FileLintCache): ts.DiagnosticWithLocation[];

package/index.js

@@ -1,27 +1,11 @@
 "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 __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;
 exports.combineCodeFixes = combineCodeFixes;
 exports.applyTextChanges = applyTextChanges;
-__exportStar(require("./lib/build"), exports);
-__exportStar(require("./lib/watch"), exports);
 const path = require("path");
 const minimatch = require("minimatch");
-function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageService) {
+function createLinter(ctx, rootDir, config, getRelatedInformations, syntaxOnlyLanguageService) {
     const ts = ctx.typescript;
     const fileRules = new Map();
     const fileConfigs = new Map();
@@ -51,30 +35,21 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                 const program = ctx.languageService.getProgram();
                 const file = ctx.languageService.getProgram().getSourceFile(fileName);
                 rulesContext = {
-                    ...ctx,
+                    typescript: ctx.typescript,
                     file,
-                    sourceFile: file,
                     program,
                     report,
-                    reportError: report,
-                    reportWarning: report,
-                    reportSuggestion: report,
                 };
             }
             else {
                 const file = getNonBoundSourceFile(fileName);
                 rulesContext = {
-                    ...ctx,
-                    languageService: syntaxOnlyLanguageService,
+                    typescript: ctx.typescript,
                     get program() {
                         throw new Error('Not supported');
                     },
                     file,
-                    sourceFile: file,
                     report,
-                    reportError: report,
-                    reportWarning: report,
-                    reportSuggestion: report,
                 };
             }
             lintResults.set(fileName, [rulesContext.file, new Map(), []]);
@@ -118,10 +93,10 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                         shouldRetry = true;
                     }
                     else if (err instanceof Error) {
-                        report(err.stack ?? err.message, 0, 0, ts.DiagnosticCategory.Message, 0, err);
+                        report(err.stack ?? err.message, 0, 0).at(err, 0);
                     }
                     else {
-                        report(String(err), 0, 0, ts.DiagnosticCategory.Message, Number.MAX_VALUE);
+                        report(String(err), 0, 0).at(new Error(), Number.MAX_VALUE);
                     }
                 }
                 if (cache && !rule2Mode.get(currentRuleId)) {
@@ -174,29 +149,37 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
             }
             lintResult[2] = lintResult[2].filter(refactor => diagnosticSet.has(refactor.diagnostic));
             return diagnostics;
-            function report(message, start, end, category = ts.DiagnosticCategory.Message, stackOffset = 1, err) {
+            function report(message, start, end) {
                 const error = {
-                    category,
+                    category: ts.DiagnosticCategory.Message,
                     code: currentRuleId,
                     messageText: message,
                     file: rulesContext.file,
                     start,
                     length: end - start,
                     source: 'tsslint',
-                    relatedInformation: [],
+                    get relatedInformation() {
+                        return relatedInformation ??= getRelatedInformations(location[0], location[1]);
+                    },
+                    set relatedInformation(value) {
+                        relatedInformation = value;
+                    },
                 };
+                let location = [new Error(), 1];
+                let relatedInformation;
+                let cachedObj;
                 if (cache && !rule2Mode.get(currentRuleId)) {
-                    cache[1][currentRuleId] ??= [false, []];
-                    cache[1][currentRuleId][1].push({
+                    cachedObj = {
                         ...error,
                         file: undefined,
                         relatedInformation: error.relatedInformation?.map(info => ({
                             ...info,
                             file: info.file ? { fileName: info.file.fileName } : undefined,
                         })),
-                    });
+                    };
+                    cache[1][currentRuleId] ??= [false, []];
+                    cache[1][currentRuleId][1].push(cachedObj);
                 }
-                handleError(error, err ?? new Error(), stackOffset);
                 let lintResult = lintResults.get(fileName);
                 if (!lintResult) {
                     lintResults.set(fileName, lintResult = [rulesContext.file, new Map(), []]);
@@ -206,6 +189,22 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                 diagnostic2Fixes.set(error, []);
                 const fixes = diagnostic2Fixes.get(error);
                 return {
+                    at(err, stack) {
+                        location = [err, stack];
+                        return this;
+                    },
+                    asWarning() {
+                        error.category = ts.DiagnosticCategory.Warning;
+                        return this;
+                    },
+                    asError() {
+                        error.category = ts.DiagnosticCategory.Error;
+                        return this;
+                    },
+                    asSuggestion() {
+                        error.category = ts.DiagnosticCategory.Suggestion;
+                        return this;
+                    },
                     withDeprecated() {
                         error.reportsDeprecated = true;
                         return this;
@@ -215,15 +214,27 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                         return this;
                     },
                     withFix(title, getEdits) {
-                        fixes.push(({ title, getEdits }));
+                        fixes.push({ title, getEdits });
                         return this;
                     },
                     withRefactor(title, getEdits) {
-                        refactors.push(({
+                        refactors.push({
                             diagnostic: error,
                             title,
                             getEdits,
-                        }));
+                        });
+                        return this;
+                    },
+                    withoutCache() {
+                        if (cachedObj) {
+                            const ruleCache = cache?.[1][currentRuleId];
+                            if (ruleCache) {
+                                const index = ruleCache[1].indexOf(cachedObj);
+                                if (index >= 0) {
+                                    ruleCache[1].splice(index, 1);
+                                }
+                            }
+                        }
                         return this;
                     },
                 };
@@ -255,10 +266,10 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                 }
                 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)) {
+                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({
@@ -266,7 +277,7 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                             description: action.title,
                             changes: action.getEdits(),
                             fixId: 'tsslint',
-                            fixAllDescription: 'Fix all TSSLint errors'
+                            fixAllDescription: 'Fix all TSSLint errors',
                         });
                     }
                     for (const { plugins } of configs) {
@@ -291,10 +302,10 @@ function createLinter(ctx, rootDir, config, handleError, syntaxOnlyLanguageServi
                 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)) {
+                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,

package/package.json

@@ -1,7 +1,10 @@
 {
 	"name": "@tsslint/core",
-	"version": "2.0.7",
+	"version": "3.0.0-alpha.1",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22.6.0"
+	},
 	"files": [
 		"**/*.js",
 		"**/*.d.ts"
@@ -12,15 +15,8 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "2.0.7",
-		"esbuild": ">=0.17.0",
+		"@tsslint/types": "3.0.0-alpha.1",
 		"minimatch": "^10.0.1"
 	},
-	"devDependencies": {
-		"@clack/prompts": "^0.8.2"
-	},
-	"scripts": {
-		"postinstall": "node scripts/cleanCache.js"
-	},
-	"gitHead": "db83a7c7526c3245d2ffa6fe1c9fb04e77387959"
-}
+	"gitHead": "eacd205927cda18d084e78cc21115578792f3955"
+}

package/lib/build.d.ts

@@ -1 +0,0 @@
-export declare function buildConfig(configFilePath: string, createHash?: (path: string) => string, spinner?: ReturnType<typeof import('@clack/prompts').spinner>, stopSnipper?: (message: string, code?: number) => void): Promise<string | undefined>;

package/lib/build.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildConfig = buildConfig;
-const watch_1 = require("./watch");
-const _path = require("path");
-function buildConfig(configFilePath, createHash, 
-// @ts-expect-error
-spinner, stopSnipper) {
-    const buildStart = Date.now();
-    const configFileDisplayPath = _path.relative(process.cwd(), configFilePath);
-    spinner?.message('Building ' + configFileDisplayPath);
-    return new Promise(async (resolve) => {
-        try {
-            await (0, watch_1.watchConfig)(configFilePath, builtConfig => {
-                if (builtConfig) {
-                    stopSnipper?.('Built ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms');
-                }
-                else {
-                    stopSnipper?.('Failed to build ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms', 1);
-                }
-                resolve(builtConfig);
-            }, false, createHash);
-        }
-        catch (e) {
-            stopSnipper?.('Failed to build ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms', 1);
-            resolve(undefined);
-        }
-    });
-}
-//# sourceMappingURL=build.js.map

package/lib/watch.d.ts

@@ -1,14 +0,0 @@
-import esbuild = require('esbuild');
-export declare function watchConfig(configFilePath: string, onBuild: (config: string | undefined, result: esbuild.BuildResult) => void, watch?: boolean, createHash?: (path: string) => string): Promise<esbuild.BuildContext<{
-    entryPoints: string[];
-    bundle: true;
-    sourcemap: true;
-    outfile: string;
-    format: "esm";
-    platform: "node";
-    plugins: {
-        name: string;
-        setup(build: esbuild.PluginBuild): void;
-    }[];
-}>>;
-export declare function getDotTsslintPath(configFilePath: string): string;

package/lib/watch.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.watchConfig = watchConfig;
-exports.getDotTsslintPath = getDotTsslintPath;
-const esbuild = require("esbuild");
-const _path = require("path");
-const fs = require("fs");
-const url = require("url");
-async function watchConfig(configFilePath, onBuild, watch = true, createHash = btoa) {
-    const outDir = getDotTsslintPath(configFilePath);
-    const outFileName = createHash(_path.relative(outDir, configFilePath)) + '.mjs';
-    const outFile = _path.join(outDir, outFileName);
-    const resultHandler = (result) => {
-        if (!result.errors.length) {
-            onBuild(outFile, result);
-        }
-        else {
-            onBuild(undefined, result);
-        }
-    };
-    const ctx = await esbuild.context({
-        entryPoints: [configFilePath],
-        bundle: true,
-        sourcemap: true,
-        outfile: outFile,
-        format: 'esm',
-        platform: 'node',
-        plugins: [{
-                name: 'tsslint',
-                setup(build) {
-                    build.onResolve({ filter: /.*/ }, ({ path, resolveDir }) => {
-                        if (!isTsFile(path)) {
-                            try {
-                                const maybeJsPath = require.resolve(path, { paths: [resolveDir] });
-                                if (!isTsFile(maybeJsPath) && fs.existsSync(maybeJsPath)) {
-                                    return {
-                                        path: url.pathToFileURL(maybeJsPath).toString(),
-                                        external: true,
-                                    };
-                                }
-                            }
-                            catch { }
-                        }
-                        return {};
-                    });
-                    if (watch) {
-                        build.onEnd(resultHandler);
-                    }
-                },
-            }],
-    });
-    if (watch) {
-        await ctx.watch();
-    }
-    else {
-        try {
-            const result = await ctx.rebuild(); // could throw
-            await ctx.dispose();
-            resultHandler(result);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    return ctx;
-}
-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/scripts/cleanCache.js

@@ -1,20 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-let dir = __dirname;
-
-while (true) {
-	const cachePath = path.join(dir, 'node_modules', '.tsslint');
-	if (fs.existsSync(cachePath)) {
-		console.log(`Removing ${cachePath}`);
-		fs.rmSync(cachePath, { recursive: true });
-		break;
-	}
-
-	const parentDir = path.resolve(dir, '..');
-	if (parentDir === dir) {
-		break;
-	}
-
-	dir = parentDir;
-}