@tsslint/config 1.3.6 → 1.4.1

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from '@tsslint/types';
+export { create as createIgnorePlugin } from './lib/plugins/ignore.js';
 import type { Config, Plugin, Rule } from '@tsslint/types';
 export declare function defineRule(rule: Rule): Rule;
 export declare function definePlugin(plugin: Plugin): Plugin;

package/index.js

@@ -14,10 +14,13 @@ 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.createIgnorePlugin = void 0;
 exports.defineRule = defineRule;
 exports.definePlugin = definePlugin;
 exports.defineConfig = defineConfig;
 __exportStar(require("@tsslint/types"), exports);
+var ignore_js_1 = require("./lib/plugins/ignore.js");
+Object.defineProperty(exports, "createIgnorePlugin", { enumerable: true, get: function () { return ignore_js_1.create; } });
 function defineRule(rule) {
     return rule;
 }

package/lib/plugins/ignore.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '@tsslint/types';
+export declare function create(cmd: string, reportsUnusedComments: boolean, reg?: RegExp, completeReg1?: RegExp, completeReg2?: RegExp): Plugin;

package/lib/plugins/ignore.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const ts_api_utils_1 = require("ts-api-utils");
+function create(cmd, reportsUnusedComments, reg = new RegExp(`//\\s*${cmd}\\b[ \\t]*(?<ruleId>\\S*)\\b`), completeReg1 = /^\s*\/\/(\s*)([\S]*)?$/, completeReg2 = new RegExp(`//\\s*${cmd}\\b[ \\t]*(\\S*)?$`)) {
+    return ({ typescript: ts, languageService }) => {
+        const reportedRulesOfFile = new Map();
+        const { getCompletionsAtPosition } = languageService;
+        languageService.getCompletionsAtPosition = (fileName, position, ...rest) => {
+            let result = getCompletionsAtPosition(fileName, position, ...rest);
+            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                return result;
+            }
+            const reportedRules = reportedRulesOfFile.get(fileName);
+            const line = sourceFile.getLineAndCharacterOfPosition(position).line;
+            const lineStart = sourceFile.getPositionOfLineAndCharacter(line, 0);
+            const prefix = sourceFile.text.slice(lineStart, position);
+            const matchCmd = completeReg1
+                ? prefix.match(completeReg1)
+                : undefined;
+            if (matchCmd) {
+                const nextLineRules = reportedRules?.filter(([, reportedLine]) => reportedLine === line + 1) ?? [];
+                const item = {
+                    name: cmd,
+                    insertText: matchCmd[1].length ? cmd : ` ${cmd}`,
+                    kind: ts.ScriptElementKind.keyword,
+                    sortText: 'a',
+                    replacementSpan: matchCmd[2]
+                        ? {
+                            start: position - matchCmd[2].length,
+                            length: matchCmd[2].length,
+                        }
+                        : undefined,
+                    labelDetails: {
+                        description: nextLineRules.length >= 2
+                            ? `Ignore ${nextLineRules.length} issues in next line`
+                            : nextLineRules.length
+                                ? 'Ignore 1 issue in next line'
+                                : undefined,
+                    }
+                };
+                if (result) {
+                    result.entries.push(item);
+                }
+                else {
+                    result = {
+                        isGlobalCompletion: false,
+                        isMemberCompletion: false,
+                        isNewIdentifierLocation: false,
+                        entries: [item],
+                    };
+                }
+            }
+            else if (reportedRules?.length) {
+                const matchRule = completeReg2
+                    ? prefix.match(completeReg2)
+                    : undefined;
+                if (matchRule) {
+                    const visited = new Set();
+                    for (const [ruleId] of reportedRules) {
+                        if (visited.has(ruleId)) {
+                            continue;
+                        }
+                        visited.add(ruleId);
+                        const reportedLines = reportedRules
+                            .filter(([r]) => r === ruleId)
+                            .map(([, l]) => l + 1);
+                        const item = {
+                            name: ruleId,
+                            kind: ts.ScriptElementKind.keyword,
+                            sortText: ruleId,
+                            replacementSpan: matchRule[1]
+                                ? {
+                                    start: position - matchRule[1].length,
+                                    length: matchRule[1].length,
+                                }
+                                : undefined,
+                            labelDetails: {
+                                description: `Reported in line${reportedLines.length >= 2 ? 's' : ''} ${reportedLines.join(', ')}`,
+                            },
+                        };
+                        if (result) {
+                            result.entries.push(item);
+                        }
+                        else {
+                            result = {
+                                isGlobalCompletion: false,
+                                isMemberCompletion: false,
+                                isNewIdentifierLocation: false,
+                                entries: [item],
+                            };
+                        }
+                    }
+                }
+            }
+            return result;
+        };
+        return {
+            resolveDiagnostics(sourceFile, results) {
+                if (!reportsUnusedComments &&
+                    !results.some(error => error.source === 'tsslint')) {
+                    return results;
+                }
+                const disabledLines = new Map();
+                const disabledLinesByRules = new Map();
+                (0, ts_api_utils_1.forEachComment)(sourceFile, (fullText, { pos, end }) => {
+                    const commentText = fullText.substring(pos, end);
+                    const comment = commentText.match(reg);
+                    if (comment?.index === undefined) {
+                        return;
+                    }
+                    const index = comment.index + pos;
+                    const line = sourceFile.getLineAndCharacterOfPosition(index).line + 1;
+                    const ruleId = comment.groups?.ruleId;
+                    if (ruleId) {
+                        if (!disabledLinesByRules.has(ruleId)) {
+                            disabledLinesByRules.set(ruleId, new Map());
+                        }
+                        disabledLinesByRules.get(ruleId).set(line, {
+                            start: index,
+                            end: index + comment[0].length,
+                        });
+                    }
+                    else {
+                        disabledLines.set(line, {
+                            start: index,
+                            end: index + comment[0].length,
+                        });
+                    }
+                });
+                let reportedRules = reportedRulesOfFile.get(sourceFile.fileName);
+                if (!reportedRules) {
+                    reportedRules = [];
+                    reportedRulesOfFile.set(sourceFile.fileName, reportedRules);
+                }
+                reportedRules.length = 0;
+                results = results.filter(error => {
+                    if (error.source !== 'tsslint') {
+                        return true;
+                    }
+                    const line = sourceFile.getLineAndCharacterOfPosition(error.start).line;
+                    reportedRules.push([error.code, line]);
+                    if (disabledLines.has(line)) {
+                        disabledLines.get(line).used = true;
+                        return false;
+                    }
+                    const disabledLinesByRule = disabledLinesByRules.get(error.code);
+                    if (disabledLinesByRule?.has(line)) {
+                        disabledLinesByRule.get(line).used = true;
+                        return false;
+                    }
+                    return true;
+                });
+                if (reportsUnusedComments) {
+                    for (const state of disabledLines.values()) {
+                        if (!state.used) {
+                            results.push({
+                                file: sourceFile,
+                                start: state.start,
+                                length: state.end - state.start,
+                                code: 'tsslint:unused-ignore-comment',
+                                messageText: `Unused ${cmd} comment.`,
+                                source: 'tsslint',
+                                category: 1,
+                            });
+                        }
+                    }
+                    for (const disabledLinesByRule of disabledLinesByRules.values()) {
+                        for (const state of disabledLinesByRule.values()) {
+                            if (!state.used) {
+                                results.push({
+                                    file: sourceFile,
+                                    start: state.start,
+                                    length: state.end - state.start,
+                                    code: 'tsslint:unused-ignore-comment',
+                                    messageText: `Unused ${cmd} comment.`,
+                                    source: 'tsslint',
+                                    category: 1,
+                                });
+                            }
+                        }
+                    }
+                }
+                return results;
+            },
+            resolveCodeFixes(sourceFile, diagnostic, codeFixes) {
+                if (diagnostic.source !== 'tsslint' || diagnostic.start === undefined) {
+                    return codeFixes;
+                }
+                const line = sourceFile.getLineAndCharacterOfPosition(diagnostic.start).line;
+                codeFixes.push({
+                    fixName: cmd,
+                    description: `Ignore with ${cmd}`,
+                    changes: [
+                        {
+                            fileName: sourceFile.fileName,
+                            textChanges: [{
+                                    newText: `// ${cmd} ${diagnostic.code}\n`,
+                                    span: {
+                                        start: sourceFile.getPositionOfLineAndCharacter(line, 0),
+                                        length: 0,
+                                    },
+                                }],
+                        },
+                    ],
+                });
+                return codeFixes;
+            },
+        };
+    };
+}
+//# sourceMappingURL=ignore.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/config",
-	"version": "1.3.6",
+	"version": "1.4.1",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,8 @@
 		"directory": "packages/config"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.3.6"
+		"@tsslint/types": "1.4.1",
+		"ts-api-utils": "^2.0.0"
 	},
-	"gitHead": "d153aa87c92803b4c20fef1f5cf2799f1a599099"
+	"gitHead": "54f42ec9414029a356fa19a762260f03392563fa"
 }