@tsslint/config 2.0.7 → 3.0.0-alpha.1

package/lib/tslint-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tslint-types.js.map

package/lib/tslint.d.ts

@@ -0,0 +1,27 @@
+import type * as TSSLint from '@tsslint/types';
+import type { TSLintRulesConfig } from './tslint-types.js';
+type Severity = boolean | 'error' | 'warn';
+/**
+ * Converts a TSLint rules configuration to TSSLint rules.
+ *
+ * ⚠️ **Type definitions not generated**
+ *
+ * Please add `@tsslint/config` to `pnpm.onlyBuiltDependencies` in your `package.json` to allow the postinstall script to run.
+ *
+ * ```json
+ * {
+ *   "pnpm": {
+ *     "onlyBuiltDependencies": ["@tsslint/config"]
+ *   }
+ * }
+ * ```
+ *
+ * After that, run `pnpm install` again to generate type definitions.
+ *
+ * If the type definitions become outdated, please run `npx tsslint-docgen` to update them.
+ */
+export declare function importTSLintRules(config: {
+    [K in keyof TSLintRulesConfig]: Severity | [Severity, ...TSLintRulesConfig[K]];
+}): Promise<TSSLint.Rules>;
+export declare function getTSLintRulesDirectories(): [string, string][];
+export {};

package/lib/tslint.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importTSLintRules = importTSLintRules;
+exports.getTSLintRulesDirectories = getTSLintRulesDirectories;
+const fs = require("fs");
+const path = require("path");
+const noop = () => { };
+/**
+ * Converts a TSLint rules configuration to TSSLint rules.
+ *
+ * ⚠️ **Type definitions not generated**
+ *
+ * Please add `@tsslint/config` to `pnpm.onlyBuiltDependencies` in your `package.json` to allow the postinstall script to run.
+ *
+ * ```json
+ * {
+ *   "pnpm": {
+ *     "onlyBuiltDependencies": ["@tsslint/config"]
+ *   }
+ * }
+ * ```
+ *
+ * After that, run `pnpm install` again to generate type definitions.
+ *
+ * If the type definitions become outdated, please run `npx tsslint-docgen` to update them.
+ */
+async function importTSLintRules(config) {
+    const rules = {};
+    const rulesDirectories = getTSLintRulesDirectories();
+    for (const [ruleName, severityOrOptions] of Object.entries(config)) {
+        let severity;
+        let options;
+        if (Array.isArray(severityOrOptions)) {
+            [severity, ...options] = severityOrOptions;
+        }
+        else {
+            severity = severityOrOptions;
+            options = [];
+        }
+        if (!severity) {
+            rules[ruleName] = noop;
+            continue;
+        }
+        const ruleModule = await loadTSLintRule(ruleName, rulesDirectories);
+        if (!ruleModule) {
+            throw new Error(`Failed to resolve TSLint rule "${ruleName}".`);
+        }
+        rules[ruleName] = convertRule(ruleModule, options, severity === 'error'
+            ? 1
+            : severity === 'warn'
+                ? 0
+                : 3);
+    }
+    return rules;
+}
+function getTSLintRulesDirectories() {
+    const directories = [];
+    let dir = __dirname;
+    while (true) {
+        const tslintJsonPath = path.join(dir, 'tslint.json');
+        if (fs.existsSync(tslintJsonPath)) {
+            try {
+                let content = fs.readFileSync(tslintJsonPath, 'utf8');
+                // Remove comments
+                content = content.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1');
+                const tslintJson = JSON.parse(content);
+                if (tslintJson.rulesDirectory) {
+                    const rulesDirs = Array.isArray(tslintJson.rulesDirectory)
+                        ? tslintJson.rulesDirectory
+                        : [tslintJson.rulesDirectory];
+                    for (const rulesDir of rulesDirs) {
+                        directories.push([rulesDir, path.resolve(dir, rulesDir)]);
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore parse errors
+            }
+            break;
+        }
+        const parentDir = path.resolve(dir, '..');
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
+    }
+    return directories;
+}
+async function loadTSLintRule(ruleName, rulesDirectories) {
+    const camelCaseName = ruleName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const ruleFileName = `${camelCaseName.charAt(0).toUpperCase() + camelCaseName.slice(1)}Rule.js`;
+    for (const [, rulesDir] of rulesDirectories) {
+        const rulePath = path.resolve(rulesDir, ruleFileName);
+        if (fs.existsSync(rulePath)) {
+            const mod = require(rulePath);
+            return mod.Rule;
+        }
+    }
+    let dir = __dirname;
+    while (true) {
+        const nodeModulesDir = path.join(dir, 'node_modules');
+        if (fs.existsSync(nodeModulesDir)) {
+            const tslintDir = path.join(nodeModulesDir, 'tslint', 'lib', 'rules');
+            if (fs.existsSync(tslintDir)) {
+                const rulePath = path.join(tslintDir, ruleFileName);
+                if (fs.existsSync(rulePath)) {
+                    const mod = require(rulePath);
+                    return mod.Rule;
+                }
+            }
+        }
+        const parentDir = path.resolve(dir, '..');
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
+    }
+}
+function convertRule(Rule, ruleArguments = [], category = 3) {
+    const rule = new Rule({
+        ruleName: Rule.metadata?.ruleName ?? 'unknown',
+        ruleArguments,
+        ruleSeverity: 'warning',
+        disabledIntervals: [],
+    });
+    return ({ typescript: ts, file, report, ...ctx }) => {
+        if (Rule.metadata?.typescriptOnly) {
+            const scriptKind = file.scriptKind;
+            if (scriptKind === ts.ScriptKind.JS || scriptKind === ts.ScriptKind.JSX) {
+                return;
+            }
+        }
+        const failures = 'applyWithProgram' in rule
+            ? rule.applyWithProgram(file, ctx.program)
+            : rule.apply(file);
+        for (const failure of failures) {
+            const reporter = report(failure.getFailure(), failure.getStartPosition().getPosition(), failure.getEndPosition().getPosition()).at(new Error(), Number.MAX_VALUE);
+            if (category === 0) {
+                reporter.asWarning();
+            }
+            else if (category === 1) {
+                reporter.asError();
+            }
+            else if (category === 2) {
+                reporter.asSuggestion();
+            }
+            if (failure.hasFix()) {
+                const ruleName = Rule.metadata?.ruleName;
+                reporter.withFix(ruleName ? `Fix with ${ruleName}` : 'Fix', () => {
+                    const fix = failure.getFix();
+                    const replaces = Array.isArray(fix) ? fix : fix ? [fix] : [];
+                    return [{
+                            fileName: file.fileName,
+                            textChanges: replaces.map(replace => ({
+                                newText: replace.text,
+                                span: {
+                                    start: replace.start,
+                                    length: replace.length,
+                                },
+                            })),
+                        }];
+                });
+            }
+        }
+    };
+}
+//# sourceMappingURL=tslint.js.map

package/package.json

@@ -1,7 +1,13 @@
 {
 	"name": "@tsslint/config",
-	"version": "2.0.7",
+	"version": "3.0.0-alpha.1",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22.6.0"
+	},
+	"bin": {
+		"tsslint-docgen": "./bin/tsslint-docgen.js"
+	},
 	"files": [
 		"**/*.js",
 		"**/*.d.ts"
@@ -11,10 +17,29 @@
 		"url": "https://github.com/johnsoncodehk/tsslint.git",
 		"directory": "packages/config"
 	},
+	"scripts": {
+		"postinstall": "tsslint-docgen"
+	},
 	"dependencies": {
-		"@tsslint/types": "2.0.7",
+		"@tsslint/types": "3.0.0-alpha.1",
 		"minimatch": "^10.0.1",
 		"ts-api-utils": "^2.0.0"
 	},
-	"gitHead": "db83a7c7526c3245d2ffa6fe1c9fb04e77387959"
-}
+	"devDependencies": {
+		"@tsslint/compat-eslint": "3.0.0-alpha.1",
+		"tslint": "^6.1.3"
+	},
+	"peerDependencies": {
+		"@tsslint/compat-eslint": "3.0.0-alpha.0",
+		"tsl": "^1.0.28"
+	},
+	"peerDependenciesMeta": {
+		"@tsslint/compat-eslint": {
+			"optional": true
+		},
+		"tsl": {
+			"optional": true
+		}
+	},
+	"gitHead": "eacd205927cda18d084e78cc21115578792f3955"
+}