@tsslint/core 0.0.3

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.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@tsslint/config';
+export declare function getBuiltInPlugins(withStack: boolean): Plugin[];
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,174 @@
+"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.getBuiltInPlugins = void 0;
+const ErrorStackParser = __importStar(require("error-stack-parser"));
+function getBuiltInPlugins(withStack) {
+    if (withStack) {
+        require('source-map-support').install();
+    }
+    return [
+        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 = {
+                        ...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, trace = true) {
+                        return report(ts.DiagnosticCategory.Error, message, start, end, trace);
+                    }
+                    function reportWarning(message, start, end, trace = true) {
+                        return report(ts.DiagnosticCategory.Warning, message, start, end, trace);
+                    }
+                    function reportSuggestion(message, start, end, trace = true) {
+                        return report(ts.DiagnosticCategory.Suggestion, message, start, end, trace);
+                    }
+                    function report(category, message, start, end, trace) {
+                        const error = {
+                            category,
+                            code: currentRuleId,
+                            messageText: message,
+                            file: sourceFile,
+                            start,
+                            length: end - start,
+                            source: 'tsslint',
+                            relatedInformation: [],
+                        };
+                        const stacks = trace ? 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)) {
+                                    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);
+                                if (withStack) {
+                                    error.relatedInformation?.push({
+                                        category: ts.DiagnosticCategory.Message,
+                                        code: 0,
+                                        file: stackFile,
+                                        start: pos,
+                                        length: 0,
+                                        messageText: '',
+                                    });
+                                    error.relatedInformation?.push({
+                                        category: ts.DiagnosticCategory.Message,
+                                        code: 0,
+                                        file: configSourceFile,
+                                        start: 0,
+                                        length: 0,
+                                        messageText: '',
+                                    });
+                                }
+                            }
+                        }
+                        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(({
+                                    diagnostic: error,
+                                    title,
+                                    start,
+                                    end,
+                                    getEdits,
+                                }));
+                                return this;
+                            },
+                        };
+                    }
+                },
+                getFixes(fileName, start, end, diagnostics) {
+                    const fixesMap = getFileFixes(fileName);
+                    const result = [];
+                    for (const [_ruleId, fixes] of fixesMap) {
+                        for (let i = 0; i < fixes.length; i++) {
+                            const fix = fixes[i];
+                            if (diagnostics && !diagnostics.includes(fix.diagnostic)) {
+                                continue;
+                            }
+                            if ((fix.start >= start && fix.start <= end) ||
+                                (fix.end >= start && fix.end <= end) ||
+                                (start >= fix.start && start <= fix.end) ||
+                                (end >= fix.start && end <= fix.end)) {
+                                result.push({
+                                    fixName: `tsslint: ${fix.title}`,
+                                    description: fix.title,
+                                    changes: fix.getEdits(),
+                                });
+                            }
+                        }
+                    }
+                    return result;
+                },
+            };
+            function getFileFixes(fileName) {
+                if (!fileFixes.has(fileName)) {
+                    fileFixes.set(fileName, new Map());
+                }
+                return fileFixes.get(fileName);
+            }
+        },
+    ];
+}
+exports.getBuiltInPlugins = getBuiltInPlugins;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,21 @@
+{
+	"name": "@tsslint/core",
+	"version": "0.0.3",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/johnsoncodehk/tsslint.git",
+		"directory": "packages/core"
+	},
+	"dependencies": {
+		"error-stack-parser": "^2.1.4",
+		"source-map-support": "^0.5.19"
+	},
+	"devDependencies": {
+		"@tsslint/config": "0.0.3"
+	}
+}