@tsslint/typescript-plugin 0.0.0

package/index.d.ts

@@ -0,0 +1,4 @@
+import type * as ts from 'typescript/lib/tsserverlibrary.js';
+declare const init: ts.server.PluginModuleFactory;
+export = init;
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,140 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const watchConfig_1 = require("./lib/watchConfig");
+const builtInPlugins_1 = require("./lib/builtInPlugins");
+const path = __importStar(require("path"));
+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 (!info.config.configFile) {
+                return info.languageService;
+            }
+            let configFile;
+            try {
+                configFile = path.resolve(tsconfig, '..', info.config.configFile);
+            }
+            catch (err) {
+                // TODO: show error in tsconfig.json
+            }
+            if (!configFile) {
+                return info.languageService;
+            }
+            let config;
+            let plugins = [];
+            const languageServiceHost = info.languageServiceHost;
+            const languageService = info.languageService;
+            const projectContext = {
+                configFile,
+                tsconfig,
+                languageServiceHost,
+                languageService,
+                typescript: ts,
+            };
+            decorateLanguageService();
+            (0, watchConfig_1.watchConfig)(configFile, async (_config, result) => {
+                config = _config;
+                if (config) {
+                    plugins = await Promise.all([
+                        ...builtInPlugins_1.builtInPlugins,
+                        ...config.plugins ?? []
+                    ].map(plugin => plugin(projectContext, result)));
+                    for (const plugin of plugins) {
+                        if (plugin.resolveRules) {
+                            config.rules = plugin.resolveRules(config.rules ?? {});
+                        }
+                    }
+                }
+                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

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

package/lib/builtInPlugins.js

@@ -0,0 +1,207 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtInPlugins = void 0;
+const ErrorStackParser = __importStar(require("error-stack-parser"));
+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();
+        return {
+            lint(sourceFile, rules) {
+                const rulesContext = {
+                    ...ctx,
+                    sourceFile,
+                    reportError,
+                    reportWarning,
+                    reportSuggestion,
+                };
+                const token = ctx.languageServiceHost.getCancellationToken?.();
+                const result = [];
+                const fixes = getFileFixes(sourceFile.fileName);
+                fixes.clear();
+                let currentRuleId;
+                for (const [id, rule] of Object.entries(rules)) {
+                    if (token?.isCancellationRequested()) {
+                        break;
+                    }
+                    currentRuleId = id;
+                    rule(rulesContext);
+                }
+                return result;
+                function reportError(message, start, end) {
+                    return report(ts.DiagnosticCategory.Error, message, start, end);
+                }
+                function reportWarning(message, start, end) {
+                    return report(ts.DiagnosticCategory.Warning, message, start, end);
+                }
+                function reportSuggestion(message, start, end) {
+                    return report(ts.DiagnosticCategory.Suggestion, message, start, end);
+                }
+                function report(category, message, start, end) {
+                    const error = {
+                        category,
+                        code: currentRuleId,
+                        messageText: message,
+                        file: sourceFile,
+                        start,
+                        length: end - start,
+                        source: 'tsslint',
+                        relatedInformation: [],
+                    };
+                    const stacks = ErrorStackParser.parse(new Error());
+                    if (stacks.length >= 3) {
+                        const stack = stacks[2];
+                        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 (!sourceFiles.has(fileName)) {
+                                sourceFiles.set(fileName, ts.createSourceFile(fileName, ctx.languageServiceHost.readFile(fileName), 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',
+                            });
+                        }
+                    }
+                    result.push(error);
+                    return {
+                        withDeprecated() {
+                            error.reportsDeprecated = true;
+                            return this;
+                        },
+                        withUnnecessary() {
+                            error.reportsUnnecessary = true;
+                            return this;
+                        },
+                        withFix(title, getEdits) {
+                            if (!fixes.has(currentRuleId)) {
+                                fixes.set(currentRuleId, []);
+                            }
+                            fixes.get(currentRuleId).push(({
+                                title,
+                                start,
+                                end,
+                                getEdits,
+                            }));
+                            return this;
+                        },
+                    };
+                }
+            },
+            getFixes(sourceFile, positionOrRange) {
+                const start = typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos;
+                const end = typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.end;
+                const fixes = getFileFixes(sourceFile.fileName);
+                const refactors = [];
+                for (const [errorCode, _fixes] of fixes) {
+                    for (let i = 0; i < _fixes.length; i++) {
+                        const fix = _fixes[i];
+                        if ((start <= fix.start && end >= fix.end) ||
+                            (start >= fix.start && start <= fix.end) ||
+                            (end >= fix.start && end <= fix.end)) {
+                            if (refactors[refactors.length - 1]?.name !== 'tsslint/fix') {
+                                refactors.push({
+                                    name: 'tsslint/fix',
+                                    description: 'Fix ' + errorCode,
+                                    actions: [],
+                                });
+                            }
+                            refactors[refactors.length - 1].actions.push({
+                                name: errorCode + '-' + i,
+                                description: fix.title,
+                            });
+                        }
+                    }
+                }
+                return refactors;
+            },
+            fix(sourceFile, refactorName, actionName) {
+                if (refactorName === 'tsslint/fix') {
+                    const errorCode = actionName.substring(0, actionName.lastIndexOf('-'));
+                    const fixIndex = actionName.substring(actionName.lastIndexOf('-') + 1);
+                    const fix = getFileFixes(sourceFile.fileName).get(errorCode)[Number(fixIndex)];
+                    return fix.getEdits();
+                }
+            },
+        };
+        function getFileFixes(fileName) {
+            if (!fileFixes.has(fileName)) {
+                fileFixes.set(fileName, new Map());
+            }
+            return fileFixes.get(fileName);
+        }
+    },
+];
+//# sourceMappingURL=builtInPlugins.js.map

package/lib/watchConfig.d.ts

@@ -0,0 +1,14 @@
+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;
+    }[];
+}>>;
+//# sourceMappingURL=watchConfig.d.ts.map

package/lib/watchConfig.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchConfig = void 0;
+const esbuild = require("esbuild");
+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 outFile = path.join(outDir, outFileName);
+    const ctx = await esbuild.context({
+        entryPoints: [tsConfigPath],
+        bundle: 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;
+                        if (!result.errors.length) {
+                            try {
+                                config = require(outFile).default;
+                                delete require.cache[outFile];
+                            }
+                            catch (e) {
+                                result.errors.push({ text: String(e) });
+                            }
+                        }
+                        onBuild(config, result);
+                    });
+                },
+            }],
+    });
+    await ctx.watch();
+    return ctx;
+}
+exports.watchConfig = watchConfig;
+//# sourceMappingURL=watchConfig.js.map

package/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "@tsslint/typescript-plugin",
+	"version": "0.0.0",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/johnsoncodehk/tsslint.git",
+		"directory": "packages/typescript-plugin"
+	},
+	"dependencies": {
+		"@tsslint/config": "0.0.0",
+		"error-stack-parser": "^2.1.4",
+		"esbuild": "^0.19.9"
+	}
+}