@tsslint/typescript-plugin 0.0.0 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.js

@@ -22,51 +22,207 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-const watchConfig_1 = require("./lib/watchConfig");
 const builtInPlugins_1 = require("./lib/builtInPlugins");
 const path = __importStar(require("path"));
+const languageServiceDecorators = new WeakMap();
 const init = (modules) => {
     const { typescript: ts } = modules;
     const pluginModule = {
         create(info) {
-            const tsconfig = info.project.projectKind === ts.server.ProjectKind.Configured
-                ? info.project.getProjectName()
-                : undefined;
-            if (!tsconfig) {
-                return info.languageService;
+            if (!languageServiceDecorators.has(info.languageService)) {
+                const tsconfig = info.project.projectKind === ts.server.ProjectKind.Configured
+                    ? info.project.getProjectName()
+                    : undefined;
+                if (tsconfig) {
+                    languageServiceDecorators.set(info.languageService, decorateLanguageService(ts, tsconfig, info));
+                }
+            }
+            languageServiceDecorators.get(info.languageService)?.update(info.config);
+            return info.languageService;
+        },
+    };
+    return pluginModule;
+};
+function decorateLanguageService(ts, tsconfig, info) {
+    const getCompilerOptionsDiagnostics = info.languageService.getCompilerOptionsDiagnostics;
+    const getSyntacticDiagnostics = info.languageService.getSyntacticDiagnostics;
+    const getApplicableRefactors = info.languageService.getApplicableRefactors;
+    const getEditsForRefactor = info.languageService.getEditsForRefactor;
+    let configFile;
+    let configFileBuildContext;
+    let configFileDiagnostics = [];
+    let config;
+    let plugins = [];
+    info.languageService.getCompilerOptionsDiagnostics = () => {
+        return getCompilerOptionsDiagnostics().concat(configFileDiagnostics);
+    };
+    info.languageService.getSyntacticDiagnostics = fileName => {
+        let errors = getSyntacticDiagnostics(fileName);
+        errors = errors.concat(configFileDiagnostics);
+        const sourceFile = info.languageService.getProgram()?.getSourceFile(fileName);
+        if (!sourceFile) {
+            return errors;
+        }
+        const token = info.languageServiceHost.getCancellationToken?.();
+        for (const plugin of plugins) {
+            if (token?.isCancellationRequested()) {
+                break;
             }
-            if (!info.config.configFile) {
-                return info.languageService;
+            if (plugin.lint) {
+                let pluginResult = plugin.lint?.(sourceFile, config?.rules ?? {});
+                for (const plugin of plugins) {
+                    if (plugin.resolveResult) {
+                        pluginResult = plugin.resolveResult(pluginResult);
+                    }
+                }
+                errors = errors.concat(pluginResult);
             }
-            let configFile;
+        }
+        if (config?.debug) {
+            errors.push({
+                category: ts.DiagnosticCategory.Message,
+                source: 'tsslint',
+                code: 'debug-info',
+                messageText: JSON.stringify({
+                    rules: Object.keys(config?.rules ?? {}),
+                    plugins: plugins.length,
+                    configFile,
+                    tsconfig,
+                }, null, 2),
+                file: sourceFile,
+                start: 0,
+                length: 0,
+            });
+        }
+        return errors;
+    };
+    info.languageService.getApplicableRefactors = (fileName, positionOrRange, ...rest) => {
+        let refactors = getApplicableRefactors(fileName, positionOrRange, ...rest);
+        const sourceFile = info.languageService.getProgram()?.getSourceFile(fileName);
+        if (!sourceFile) {
+            return refactors;
+        }
+        const token = info.languageServiceHost.getCancellationToken?.();
+        for (const plugin of plugins) {
+            if (token?.isCancellationRequested()) {
+                break;
+            }
+            refactors = refactors.concat(plugin.getFixes?.(sourceFile, positionOrRange) ?? []);
+        }
+        return refactors;
+    };
+    info.languageService.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, ...rest) => {
+        const sourceFile = info.languageService.getProgram()?.getSourceFile(fileName);
+        if (!sourceFile) {
+            return;
+        }
+        for (const plugin of plugins) {
+            const edits = plugin.fix?.(sourceFile, refactorName, actionName);
+            if (edits) {
+                return { edits };
+            }
+        }
+        return getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, ...rest);
+    };
+    return { update };
+    async function update(pluginConfig) {
+        let configOptionSpan = { start: 0, length: 0 };
+        let newConfigFile;
+        let configImportPath;
+        let configResolveError;
+        const jsonConfigFile = ts.readJsonConfigFile(tsconfig, ts.sys.readFile);
+        try {
+            configImportPath = require.resolve('@tsslint/config', { paths: [path.dirname(tsconfig)] });
+        }
+        catch (err) {
+            configResolveError = err;
+            configFileDiagnostics = [{
+                    category: ts.DiagnosticCategory.Error,
+                    code: 0,
+                    messageText: String(err),
+                    file: jsonConfigFile,
+                    start: 0,
+                    length: 0,
+                }];
+            return;
+        }
+        const { findConfigFile, watchConfigFile } = require(configImportPath);
+        if (pluginConfig?.configFile) {
+            configOptionSpan = {
+                start: jsonConfigFile.text.indexOf(pluginConfig.configFile) - 1,
+                length: pluginConfig.configFile.length + 2,
+            };
             try {
-                configFile = path.resolve(tsconfig, '..', info.config.configFile);
+                newConfigFile = require.resolve(pluginConfig.configFile, { paths: [path.dirname(tsconfig)] });
             }
             catch (err) {
-                // TODO: show error in tsconfig.json
+                configResolveError = err;
+            }
+        }
+        else {
+            newConfigFile = findConfigFile(tsconfig);
+        }
+        if (newConfigFile !== configFile) {
+            configFile = newConfigFile;
+            config = undefined;
+            plugins = [];
+            configFileBuildContext?.dispose();
+            configFileDiagnostics = [];
+            if (configResolveError) {
+                configFileDiagnostics.push({
+                    category: ts.DiagnosticCategory.Error,
+                    code: 0,
+                    messageText: String(configResolveError),
+                    file: jsonConfigFile,
+                    start: configOptionSpan.start,
+                    length: configOptionSpan.length,
+                });
             }
             if (!configFile) {
-                return info.languageService;
+                return;
             }
-            let config;
-            let plugins = [];
-            const languageServiceHost = info.languageServiceHost;
-            const languageService = info.languageService;
             const projectContext = {
                 configFile,
                 tsconfig,
-                languageServiceHost,
-                languageService,
+                languageServiceHost: info.languageServiceHost,
+                languageService: info.languageService,
                 typescript: ts,
             };
-            decorateLanguageService();
-            (0, watchConfig_1.watchConfig)(configFile, async (_config, result) => {
+            configFileBuildContext = await watchConfigFile(configFile, async (_config, { errors, warnings }) => {
                 config = _config;
+                configFileDiagnostics = [
+                    ...errors.map(error => [error, ts.DiagnosticCategory.Error]),
+                    ...warnings.map(error => [error, ts.DiagnosticCategory.Warning]),
+                ].map(([error, category]) => {
+                    const diag = {
+                        category,
+                        source: 'tsslint',
+                        code: 0,
+                        messageText: 'Failed to build config',
+                        file: jsonConfigFile,
+                        start: configOptionSpan.start,
+                        length: configOptionSpan.length,
+                    };
+                    if (error.location) {
+                        const fileName = path.resolve(error.location.file);
+                        const fileText = ts.sys.readFile(error.location.file);
+                        const sourceFile = ts.createSourceFile(fileName, fileText ?? '', ts.ScriptTarget.Latest, true);
+                        diag.relatedInformation = [{
+                                category,
+                                code: error.id,
+                                messageText: error.text,
+                                file: sourceFile,
+                                start: sourceFile.getPositionOfLineAndCharacter(error.location.line - 1, error.location.column),
+                                length: error.location.lineText.length,
+                            }];
+                    }
+                    return diag;
+                });
                 if (config) {
                     plugins = await Promise.all([
                         ...builtInPlugins_1.builtInPlugins,
                         ...config.plugins ?? []
-                    ].map(plugin => plugin(projectContext, result)));
+                    ].map(plugin => plugin(projectContext)));
                     for (const plugin of plugins) {
                         if (plugin.resolveRules) {
                             config.rules = plugin.resolveRules(config.rules ?? {});
@@ -75,66 +231,8 @@ const init = (modules) => {
                 }
                 info.project.refreshDiagnostics();
             });
-            return languageService;
-            function decorateLanguageService() {
-                const getSyntacticDiagnostics = languageService.getSyntacticDiagnostics;
-                const getApplicableRefactors = languageService.getApplicableRefactors;
-                const getEditsForRefactor = languageService.getEditsForRefactor;
-                languageService.getSyntacticDiagnostics = fileName => {
-                    let errors = getSyntacticDiagnostics(fileName);
-                    const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
-                    if (!sourceFile) {
-                        return errors;
-                    }
-                    const token = languageServiceHost.getCancellationToken?.();
-                    for (const plugin of plugins) {
-                        if (token?.isCancellationRequested()) {
-                            break;
-                        }
-                        if (plugin.lint) {
-                            let pluginResult = plugin.lint?.(sourceFile, config?.rules ?? {});
-                            for (const plugin of plugins) {
-                                if (plugin.resolveResult) {
-                                    pluginResult = plugin.resolveResult(pluginResult);
-                                }
-                            }
-                            errors = errors.concat(pluginResult);
-                        }
-                    }
-                    return errors;
-                };
-                languageService.getApplicableRefactors = (fileName, positionOrRange, ...rest) => {
-                    let refactors = getApplicableRefactors(fileName, positionOrRange, ...rest);
-                    const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
-                    if (!sourceFile) {
-                        return refactors;
-                    }
-                    const token = languageServiceHost.getCancellationToken?.();
-                    for (const plugin of plugins) {
-                        if (token?.isCancellationRequested()) {
-                            break;
-                        }
-                        refactors = refactors.concat(plugin.getFixes?.(sourceFile, positionOrRange) ?? []);
-                    }
-                    return refactors;
-                };
-                languageService.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, ...rest) => {
-                    const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
-                    if (!sourceFile) {
-                        return;
-                    }
-                    for (const plugin of plugins) {
-                        const edits = plugin.fix?.(sourceFile, refactorName, actionName);
-                        if (edits) {
-                            return { edits };
-                        }
-                    }
-                    return getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, ...rest);
-                };
-            }
-        },
-    };
-    return pluginModule;
-};
+        }
+    }
+}
 module.exports = init;
 //# sourceMappingURL=index.js.map

package/lib/builtInPlugins.d.ts

@@ -1,3 +1,3 @@
-import { Plugin } from '@tsslint/config';
+import type { Plugin } from '@tsslint/config';
 export declare const builtInPlugins: Plugin[];
 //# sourceMappingURL=builtInPlugins.d.ts.map

package/lib/builtInPlugins.js

@@ -25,37 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.builtInPlugins = void 0;
 const ErrorStackParser = __importStar(require("error-stack-parser"));
+require('source-map-support').install();
 exports.builtInPlugins = [
-    (ctx, { warnings, errors }) => {
-        const ts = ctx.typescript;
-        return {
-            lint(sourceFile) {
-                if (sourceFile.fileName !== ctx.configFile) {
-                    return [];
-                }
-                return [
-                    ...errors.map(error => [error, ts.DiagnosticCategory.Error]),
-                    ...warnings.map(error => [error, ts.DiagnosticCategory.Warning]),
-                ].map(([error, category]) => {
-                    const diag = {
-                        category,
-                        source: 'tsslint-esbuild',
-                        code: error.id,
-                        messageText: JSON.stringify(error, null, 2),
-                        file: sourceFile,
-                        start: 0,
-                        length: 0,
-                    };
-                    // TODO: parse error.notes for relatedInformation
-                    return diag;
-                });
-            },
-        };
-    },
     ctx => {
         const ts = ctx.typescript;
         const fileFixes = new Map();
         const sourceFiles = new Map();
+        const configSourceFile = ts.createSourceFile(ctx.configFile, ts.sys.readFile(ctx.configFile) ?? '', ts.ScriptTarget.Latest, true);
         return {
             lint(sourceFile, rules) {
                 const rulesContext = {
@@ -78,16 +54,16 @@ exports.builtInPlugins = [
                     rule(rulesContext);
                 }
                 return result;
-                function reportError(message, start, end) {
-                    return report(ts.DiagnosticCategory.Error, message, start, end);
+                function reportError(message, start, end, trace = true) {
+                    return report(ts.DiagnosticCategory.Error, message, start, end, trace);
                 }
-                function reportWarning(message, start, end) {
-                    return report(ts.DiagnosticCategory.Warning, message, start, end);
+                function reportWarning(message, start, end, trace = true) {
+                    return report(ts.DiagnosticCategory.Warning, message, start, end, trace);
                 }
-                function reportSuggestion(message, start, end) {
-                    return report(ts.DiagnosticCategory.Suggestion, message, start, end);
+                function reportSuggestion(message, start, end, trace = true) {
+                    return report(ts.DiagnosticCategory.Suggestion, message, start, end, trace);
                 }
-                function report(category, message, start, end) {
+                function report(category, message, start, end, trace) {
                     const error = {
                         category,
                         code: currentRuleId,
@@ -98,7 +74,7 @@ exports.builtInPlugins = [
                         source: 'tsslint',
                         relatedInformation: [],
                     };
-                    const stacks = ErrorStackParser.parse(new Error());
+                    const stacks = trace ? ErrorStackParser.parse(new Error()) : [];
                     if (stacks.length >= 3) {
                         const stack = stacks[2];
                         if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
@@ -107,31 +83,26 @@ exports.builtInPlugins = [
                                 fileName = fileName.substring('file://'.length);
                             }
                             if (!sourceFiles.has(fileName)) {
-                                sourceFiles.set(fileName, ts.createSourceFile(fileName, ctx.languageServiceHost.readFile(fileName), ts.ScriptTarget.Latest, true));
+                                const text = ctx.languageServiceHost.readFile(fileName) ?? '';
+                                sourceFiles.set(fileName, ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true));
                             }
                             const stackFile = sourceFiles.get(fileName);
                             const pos = stackFile?.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1);
-                            let reportNode;
-                            stackFile.forEachChild(function visit(node) {
-                                if (node.end < pos || reportNode) {
-                                    return;
-                                }
-                                if (node.pos <= pos) {
-                                    if (node.getStart() === pos) {
-                                        reportNode = node;
-                                    }
-                                    else {
-                                        node.forEachChild(visit);
-                                    }
-                                }
-                            });
                             error.relatedInformation?.push({
                                 category: ts.DiagnosticCategory.Message,
                                 code: 0,
                                 file: stackFile,
                                 start: pos,
-                                length: reportNode?.end ? reportNode.end - pos : 0,
-                                messageText: '👈 Reporter',
+                                length: 0,
+                                messageText: 'Related rule file',
+                            });
+                            error.relatedInformation?.push({
+                                category: ts.DiagnosticCategory.Message,
+                                code: 0,
+                                file: configSourceFile,
+                                start: 0,
+                                length: 0,
+                                messageText: 'Related config file',
                             });
                         }
                     }

package/lib/watchConfig.d.ts

@@ -1,14 +1,4 @@
 import type { Config } from '@tsslint/config';
-import esbuild = require('esbuild');
-export declare function watchConfig(tsConfigPath: string, onBuild: (config: Config | undefined, result: esbuild.BuildResult) => void): Promise<esbuild.BuildContext<{
-    entryPoints: string[];
-    bundle: true;
-    outfile: string;
-    format: "cjs";
-    platform: "node";
-    plugins: {
-        name: string;
-        setup(build: esbuild.PluginBuild): void;
-    }[];
-}>>;
+import rollup = require('rollup');
+export declare function watchConfig(tsConfigPath: string, onBuild: (config: Config | undefined, result: Error | undefined) => void): Promise<rollup.RollupBuild>;
 //# sourceMappingURL=watchConfig.d.ts.map

package/lib/watchConfig.js

@@ -1,56 +1,88 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.watchConfig = void 0;
-const esbuild = require("esbuild");
+const rollup = require("rollup");
 const path = require("path");
 async function watchConfig(tsConfigPath, onBuild) {
-    const outDir = path.resolve(path.dirname(require.resolve('@tsslint/typescript-plugin/package.json')), '..', '.tsslint');
-    const outFileName = path
-        .relative(outDir, tsConfigPath)
-        .replace(/\.\./g, '__up')
-        .replace(/\//g, '__slash')
-        + '.cjs';
+    const outDir = path.resolve(__dirname, '..', '..', '.tsslint');
+    const outFileName = btoa(path.relative(outDir, tsConfigPath)) + '.cjs';
     const outFile = path.join(outDir, outFileName);
-    const ctx = await esbuild.context({
-        entryPoints: [tsConfigPath],
-        bundle: true,
-        outfile: outFile,
-        format: 'cjs',
-        platform: 'node',
+    // const ctx = await esbuild.context({
+    // 	entryPoints: [tsConfigPath],
+    // 	bundle: true,
+    // 	sourcemap: true,
+    // 	outfile: outFile,
+    // 	format: 'cjs',
+    // 	platform: 'node',
+    // 	plugins: [{
+    // 		name: 'tsslint',
+    // 		setup(build) {
+    // 			build.onResolve({ filter: /.*/ }, args => {
+    // 				if (!args.path.endsWith('.ts')) {
+    // 					try {
+    // 						const jsPath = require.resolve(args.path, { paths: [args.resolveDir] });
+    // 						return {
+    // 							path: jsPath,
+    // 							external: true,
+    // 						};
+    // 					} catch { }
+    // 				}
+    // 				return {};
+    // 			});
+    // 			build.onEnd(result => {
+    // 				let config: Config | undefined;
+    // 				if (!result.errors.length) {
+    // 					try {
+    // 						config = require(outFile).default;
+    // 						delete require.cache[outFile!];
+    // 					} catch (e) {
+    // 						result.errors.push({ text: String(e) } as any);
+    // 					}
+    // 				}
+    // 				onBuild(config, result);
+    // 			});
+    // 		},
+    // 	}],
+    // });
+    const bundle = await rollup.rollup({
+        input: tsConfigPath,
+        output: {
+            file: outFile,
+            format: 'cjs',
+            sourcemap: true,
+        },
+        watch: {},
+        external: ['typescript'],
         plugins: [{
                 name: 'tsslint',
-                setup(build) {
-                    build.onResolve({ filter: /.*/ }, args => {
-                        if (!args.path.endsWith('.ts')) {
-                            try {
-                                const jsPath = require.resolve(args.path, { paths: [args.resolveDir] });
-                                return {
-                                    path: jsPath,
-                                    external: true,
-                                };
-                            }
-                            catch { }
+                resolveId(id, importer) {
+                    if (!id.endsWith('.ts') && importer) {
+                        try {
+                            const jsPath = require.resolve(id, { paths: [path.dirname(importer)] });
+                            return {
+                                id: jsPath,
+                                external: true,
+                            };
                         }
-                        return {};
-                    });
-                    build.onEnd(result => {
-                        let config;
-                        if (!result.errors.length) {
-                            try {
-                                config = require(outFile).default;
-                                delete require.cache[outFile];
-                            }
-                            catch (e) {
-                                result.errors.push({ text: String(e) });
-                            }
+                        catch { }
+                    }
+                },
+                buildEnd(error) {
+                    let config;
+                    if (!error) {
+                        try {
+                            config = require(outFile).default;
+                            delete require.cache[outFile];
+                        }
+                        catch (e) {
+                            error = { message: String(e) };
                         }
-                        onBuild(config, result);
-                    });
+                    }
+                    onBuild(config, error);
                 },
             }],
     });
-    await ctx.watch();
-    return ctx;
+    return bundle;
 }
 exports.watchConfig = watchConfig;
 //# sourceMappingURL=watchConfig.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/typescript-plugin",
-	"version": "0.0.0",
+	"version": "0.0.2",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,8 +12,11 @@
 		"directory": "packages/typescript-plugin"
 	},
 	"dependencies": {
-		"@tsslint/config": "0.0.0",
 		"error-stack-parser": "^2.1.4",
-		"esbuild": "^0.19.9"
-	}
+		"source-map-support": "^0.5.19"
+	},
+	"devDependencies": {
+		"@tsslint/config": "0.0.2"
+	},
+	"gitHead": "bdca2792d8b64a11c7c1632c80a2bf25b4985c15"
 }