@tsslint/config 3.0.0-alpha.0 → 3.0.0

package/bin/tsslint-docgen.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env -S node --experimental-strip-types --no-warnings
+
+const path = require('path');
+const fs = require('fs');
+const nodeModulesDirs = [];
+
+let dir = __dirname;
+
+while (true) {
+	const nodeModuleDir = path.join(dir, 'node_modules');
+	if (fs.existsSync(nodeModuleDir)) {
+		nodeModulesDirs.push(nodeModuleDir);
+	}
+	const parentDir = path.resolve(dir, '..');
+	if (parentDir === dir) {
+		break;
+	}
+	dir = parentDir;
+}
+
+try {
+	const { generateESlintTypes } = require('../lib/eslint-gen');
+	const { generateTSLintTypes } = require('../lib/tslint-gen');
+
+	generateESlintTypes(nodeModulesDirs).then(({ dts, stats }) => {
+		fs.writeFileSync(path.resolve(__dirname, '..', 'lib', 'eslint-types.d.ts'), dts);
+
+		const indexPath = path.resolve(__dirname, '..', 'lib', 'eslint.d.ts');
+		if (fs.existsSync(indexPath)) {
+			let indexContent = fs.readFileSync(indexPath, 'utf8');
+			const fnIndex = indexContent.indexOf('export declare function importESLintRules');
+			const jsDocEnd = indexContent.lastIndexOf('*/', fnIndex) + 2;
+			const jsDocStart = indexContent.lastIndexOf('/**', jsDocEnd);
+
+			if (jsDocStart !== -1 && jsDocEnd !== -1 && jsDocStart < fnIndex) {
+				const statsTable = [
+					'| Plugin | Rules |',
+					'| :--- | :--- |',
+					...Object.entries(stats)
+						.filter(([_, count]) => count > 0)
+						.sort((a, b) => b[1] - a[1])
+						.map(([name, count]) => `| <span>${name}</span> | ${count} |`),
+				].join('\n * ');
+
+				const newJsDoc = `/**
+ * Converts an ESLint rules configuration to TSSLint rules.
+ *
+ * ${statsTable}
+ *
+ * If you have added new ESLint plugins, please run \`npx tsslint-docgen\` to update this list.
+ */`;
+				indexContent = indexContent.slice(0, jsDocStart) + newJsDoc + indexContent.slice(jsDocEnd);
+				fs.writeFileSync(indexPath, indexContent);
+			}
+		}
+	});
+	generateTSLintTypes(nodeModulesDirs).then(({ dts, stats }) => {
+		fs.writeFileSync(path.resolve(__dirname, '..', 'lib', 'tslint-types.d.ts'), dts);
+
+		const indexPath = path.resolve(__dirname, '..', 'lib', 'tslint.d.ts');
+		if (fs.existsSync(indexPath)) {
+			let indexContent = fs.readFileSync(indexPath, 'utf8');
+			const fnIndex = indexContent.indexOf('export declare function importTSLintRules');
+			const jsDocEnd = indexContent.lastIndexOf('*/', fnIndex) + 2;
+			const jsDocStart = indexContent.lastIndexOf('/**', jsDocEnd);
+
+			if (jsDocStart !== -1 && jsDocEnd !== -1 && jsDocStart < fnIndex) {
+				const statsTable = [
+					'| Dir | Rules |',
+					'| :--- | :--- |',
+					...Object.entries(stats)
+						.filter(([_, count]) => count > 0)
+						.sort((a, b) => b[1] - a[1])
+						.map(([name, count]) => `| <span>${name}</span> | ${count} |`),
+				].join('\n * ');
+
+				const newJsDoc = `/**
+ * Converts a TSLint rules configuration to TSSLint rules.
+ *
+ * ${statsTable}
+ *
+ * If you have added new TSLint plugins, please run \`npx tsslint-docgen\` to update this list.
+ */`;
+				indexContent = indexContent.slice(0, jsDocStart) + newJsDoc + indexContent.slice(jsDocEnd);
+				fs.writeFileSync(indexPath, indexContent);
+			}
+		}
+	});
+}
+catch (err) {
+	console.error(err);
+}

package/index.d.ts

@@ -1,7 +1,10 @@
 export * from '@tsslint/types';
+export * from './lib/eslint.js';
 export { create as createCategoryPlugin } from './lib/plugins/category.js';
 export { create as createDiagnosticsPlugin } from './lib/plugins/diagnostics.js';
 export { create as createIgnorePlugin } from './lib/plugins/ignore.js';
+export * from './lib/tsl.js';
+export * from './lib/tslint.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

@@ -20,12 +20,15 @@ exports.definePlugin = definePlugin;
 exports.defineConfig = defineConfig;
 exports.isCLI = isCLI;
 __exportStar(require("@tsslint/types"), exports);
+__exportStar(require("./lib/eslint.js"), exports);
 var category_js_1 = require("./lib/plugins/category.js");
 Object.defineProperty(exports, "createCategoryPlugin", { enumerable: true, get: function () { return category_js_1.create; } });
 var diagnostics_js_1 = require("./lib/plugins/diagnostics.js");
 Object.defineProperty(exports, "createDiagnosticsPlugin", { enumerable: true, get: function () { return diagnostics_js_1.create; } });
 var ignore_js_1 = require("./lib/plugins/ignore.js");
 Object.defineProperty(exports, "createIgnorePlugin", { enumerable: true, get: function () { return ignore_js_1.create; } });
+__exportStar(require("./lib/tsl.js"), exports);
+__exportStar(require("./lib/tslint.js"), exports);
 function defineRule(rule) {
     return rule;
 }

package/lib/eslint-gen.d.ts

@@ -0,0 +1,4 @@
+export declare function generateESlintTypes(nodeModulesDirs: string[], loader?: (mod: string) => Promise<any>): Promise<{
+    dts: string;
+    stats: Record<string, number>;
+}>;

package/lib/eslint-gen.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateESlintTypes = generateESlintTypes;
+const fs = require("fs");
+const path = require("path");
+const variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+async function generateESlintTypes(nodeModulesDirs, loader = async (mod) => {
+    try {
+        return require(mod);
+    }
+    catch {
+        return await import(mod);
+    }
+}) {
+    let indentLevel = 0;
+    let dts = '';
+    let defId = 0;
+    line(`export interface ESLintRulesConfig {`);
+    indentLevel++;
+    const visited = new Set();
+    const defs = new Map();
+    const stats = {};
+    for (const nodeModulesDir of nodeModulesDirs) {
+        const pkgs = readdirDirSync(nodeModulesDir);
+        for (const pkg of pkgs) {
+            if (pkg.startsWith('@')) {
+                const subPkgs = readdirDirSync(path.join(nodeModulesDir, pkg));
+                for (const subPkg of subPkgs) {
+                    if (subPkg === 'eslint-plugin' || subPkg.startsWith('eslint-plugin-')) {
+                        const pluginName = `${pkg}/${subPkg}`;
+                        let plugin = await loader(pluginName);
+                        if ('default' in plugin) {
+                            plugin = plugin.default;
+                        }
+                        if (plugin.rules) {
+                            stats[pluginName] = 0;
+                            for (const ruleName in plugin.rules) {
+                                const rule = plugin.rules[ruleName];
+                                if (subPkg === 'eslint-plugin') {
+                                    if (addRule(pkg, ruleName, rule)) {
+                                        stats[pluginName]++;
+                                    }
+                                }
+                                else {
+                                    if (addRule(pkg, `${subPkg.slice('eslint-plugin-'.length)}/${ruleName}`, rule)) {
+                                        stats[pluginName]++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else if (pkg.startsWith('eslint-plugin-')) {
+                let plugin = await loader(pkg);
+                if ('default' in plugin) {
+                    plugin = plugin.default;
+                }
+                if (plugin.rules) {
+                    const scope = pkg.replace('eslint-plugin-', '');
+                    stats[pkg] = 0;
+                    for (const ruleName in plugin.rules) {
+                        const rule = plugin.rules[ruleName];
+                        if (addRule(scope, ruleName, rule)) {
+                            stats[pkg]++;
+                        }
+                    }
+                }
+            }
+            else if (pkg === 'eslint') {
+                const rulesDir = path.join(nodeModulesDir, pkg, 'lib', 'rules');
+                const ruleFiles = fs.readdirSync(rulesDir);
+                stats['eslint'] = 0;
+                for (const ruleFile of ruleFiles) {
+                    if (ruleFile.endsWith('.js')) {
+                        const ruleName = ruleFile.replace('.js', '');
+                        const rule = await loader(path.join(rulesDir, ruleFile));
+                        if (addRule(undefined, ruleName, rule)) {
+                            stats['eslint']++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    indentLevel--;
+    line(`}`);
+    line(``);
+    for (const [typeName, typeString] of defs.values()) {
+        line(`type ${typeName} = ${typeString};`);
+    }
+    return { dts, stats };
+    function addRule(scope, ruleName, rule) {
+        let ruleKey;
+        if (scope) {
+            ruleKey = `${scope}/${ruleName}`;
+        }
+        else {
+            ruleKey = `${ruleName}`;
+        }
+        if (visited.has(ruleKey)) {
+            return false;
+        }
+        visited.add(ruleKey);
+        const meta = rule.meta ?? {};
+        const { description, url } = meta.docs ?? {};
+        const { schema } = meta;
+        if (description || url) {
+            line(`/**`);
+            if (description) {
+                line(` * ${description.replace(/\*\//g, '* /')}`);
+            }
+            if (url) {
+                line(` * @see ${url}`);
+            }
+            line(` */`);
+        }
+        let optionsType;
+        if (schema) {
+            if (Array.isArray(schema)) {
+                const optionsTypes = [];
+                for (const item of schema) {
+                    const itemType = parseSchema(schema, item, indentLevel);
+                    optionsTypes.push(itemType);
+                }
+                optionsType = `[`;
+                optionsType += optionsTypes
+                    .map(type => `(${type})?`)
+                    .join(', ');
+                optionsType += `]`;
+            }
+            else {
+                optionsType = parseSchema(schema, schema, indentLevel);
+            }
+        }
+        if (optionsType) {
+            line(`'${ruleKey}'?: ${optionsType},`);
+        }
+        else {
+            line(`'${ruleKey}'?: any[],`);
+        }
+        return true;
+    }
+    function line(line) {
+        dts += indent(indentLevel) + line + '\n';
+    }
+    function parseSchema(schema, item, indentLevel) {
+        if (typeof item === 'object') {
+            if (item.$ref) {
+                const paths = item.$ref
+                    .replace('#/items/', '#/')
+                    .split('/').slice(1);
+                let current = schema;
+                for (const path of paths) {
+                    try {
+                        current = current[path];
+                    }
+                    catch {
+                        current = undefined;
+                        break;
+                    }
+                }
+                if (current) {
+                    let resolved = defs.get(current);
+                    if (!resolved) {
+                        resolved = [`Def${defId++}_${paths[paths.length - 1]}`, parseSchema(schema, current, 0)];
+                        defs.set(current, resolved);
+                    }
+                    return resolved[0];
+                }
+                else {
+                    console.error(`Failed to resolve schema path: ${item.$ref}`);
+                    return 'unknown';
+                }
+            }
+            else if (Array.isArray(item)) {
+                return item.map(item => parseSchema(schema, item, indentLevel)).join(' | ');
+            }
+            else if (Array.isArray(item.type)) {
+                return item.type.map((type) => parseSchema(schema, type, indentLevel)).join(' | ');
+            }
+            else if (item.properties) {
+                let res = `{\n`;
+                indentLevel++;
+                const properties = item.properties;
+                const requiredArr = item.required ?? [];
+                for (const key in properties) {
+                    const property = properties[key];
+                    if (property.description) {
+                        res += indent(indentLevel) + `/**\n`;
+                        res += indent(indentLevel) + ` * ${property.description.replace(/\*\//g, '* /')}\n`;
+                        res += indent(indentLevel) + ` */\n`;
+                    }
+                    const propertyType = parseSchema(schema, property, indentLevel);
+                    const isRequired = requiredArr.includes(key);
+                    if (!variableNameRegex.test(key)) {
+                        res += indent(indentLevel) + `'${key}'${isRequired ? '' : '?'}: ${propertyType},\n`;
+                    }
+                    else {
+                        res += indent(indentLevel) + `${key}${isRequired ? '' : '?'}: ${propertyType},\n`;
+                    }
+                }
+                indentLevel--;
+                res += indent(indentLevel) + `}`;
+                if (item.additionalProperties) {
+                    res += ` & `;
+                    res += parseAdditionalProperties(schema, item.additionalProperties, indentLevel);
+                }
+                return res;
+            }
+            else if (Array.isArray(item.required)) {
+                let res = `{ `;
+                const propertiesType = [];
+                for (const key of item.required) {
+                    const propertyType = `any`;
+                    if (!variableNameRegex.test(key)) {
+                        propertiesType.push(`'${key}': ${propertyType}`);
+                    }
+                    else {
+                        propertiesType.push(`${key}: ${propertyType}`);
+                    }
+                }
+                res += propertiesType.join(', ');
+                res += ` }`;
+                return res;
+            }
+            else if (item.const) {
+                return JSON.stringify(item.const);
+            }
+            else if (item.type === 'array') {
+                if (Array.isArray(item.items)) {
+                    return `[${item.items.map((item) => parseSchema(schema, item, indentLevel)).join(', ')}]`;
+                }
+                if (item.items) {
+                    return `(${parseSchema(schema, item.items, indentLevel)})[]`;
+                }
+                return `any[]`;
+            }
+            else if (item.enum) {
+                return item.enum.map((v) => JSON.stringify(v)).join(' | ');
+            }
+            else if (item.type) {
+                return parseSchema(schema, item.type, indentLevel);
+            }
+            else if (item.anyOf) {
+                return item.anyOf.map((item) => parseSchema(schema, item, indentLevel)).join(' | ');
+            }
+            else if (item.oneOf) {
+                return item.oneOf.map((item) => parseSchema(schema, item, indentLevel)).join(' | ');
+            }
+        }
+        else if (item === 'string' || item === 'boolean' || item === 'null' || item === 'number') {
+            return item;
+        }
+        else if (item === 'object') {
+            if (item.additionalProperties) {
+                return parseAdditionalProperties(schema, item.additionalProperties, indentLevel);
+            }
+            else {
+                return `{ [key: string]: unknown }`;
+            }
+        }
+        else if (item === 'integer') {
+            return 'number';
+        }
+        else if (item === 'array') {
+            return 'any[]';
+        }
+        return 'unknown';
+    }
+    function indent(indentLevel) {
+        return '\t'.repeat(indentLevel);
+    }
+    function parseAdditionalProperties(schema, item, indentLevel) {
+        if (item === true) {
+            return `{ [key: string]: unknown }`;
+        }
+        else {
+            return `{ [key: string]: ${parseSchema(schema, item, indentLevel)} }`;
+        }
+    }
+    function readdirDirSync(_path) {
+        return fs.readdirSync(_path, { withFileTypes: true })
+            .filter(dirent => {
+            if (dirent.isDirectory()) {
+                return true;
+            }
+            if (dirent.isSymbolicLink()) {
+                const fullPath = path.join(_path, dirent.name);
+                try {
+                    return fs.statSync(fullPath).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            }
+            return false;
+        })
+            .map(dirent => dirent.name);
+    }
+}
+//# sourceMappingURL=eslint-gen.js.map

package/lib/eslint-types.d.ts

@@ -0,0 +1,3 @@
+export interface ESLintRulesConfig extends Record<string, any[]> {
+    [key: string]: any[];
+}

package/lib/eslint-types.js

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

package/lib/eslint.d.ts

@@ -0,0 +1,15 @@
+import type * as TSSLint from '@tsslint/types';
+import type * as ESLint from 'eslint';
+import type { ESLintRulesConfig } from './eslint-types.js';
+type Severity = boolean | 'error' | 'warn';
+/**
+ * Converts an ESLint rules configuration to TSSLint rules.
+ *
+ * ⚠️ **Type definitions not generated**
+ *
+ * Please run `npx tsslint-docgen` to update them.
+ */
+export declare function importESLintRules(config: {
+    [K in keyof ESLintRulesConfig]: Severity | [Severity, ...ESLintRulesConfig[K]];
+}, context?: Partial<ESLint.Rule.RuleContext>): Promise<TSSLint.Rules>;
+export {};

package/lib/eslint.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importESLintRules = importESLintRules;
+const fs = require("fs");
+const path = require("path");
+const noop = () => { };
+const plugins = {};
+const loader = async (moduleName) => {
+    let mod;
+    try {
+        mod ??= require(moduleName);
+    }
+    catch { }
+    try {
+        mod ??= await import(moduleName);
+    }
+    catch { }
+    if (mod && 'default' in mod) {
+        return mod.default;
+    }
+    return mod;
+};
+/**
+ * Converts an ESLint rules configuration to TSSLint rules.
+ *
+ * ⚠️ **Type definitions not generated**
+ *
+ * Please run `npx tsslint-docgen` to update them.
+ */
+async function importESLintRules(config, context = {}) {
+    let convertRule;
+    try {
+        ({ convertRule } = await import('@tsslint/compat-eslint'));
+    }
+    catch {
+        throw new Error('Please install @tsslint/compat-eslint to use importESLintRules().');
+    }
+    const rules = {};
+    for (const [rule, severityOrOptions] of Object.entries(config)) {
+        let severity;
+        let options;
+        if (Array.isArray(severityOrOptions)) {
+            [severity, ...options] = severityOrOptions;
+        }
+        else {
+            severity = severityOrOptions;
+            options = [];
+        }
+        if (!severity) {
+            rules[rule] = noop;
+            continue;
+        }
+        const ruleModule = await loadRuleByKey(rule);
+        if (!ruleModule) {
+            throw new Error(`Failed to resolve rule "${rule}".`);
+        }
+        rules[rule] = convertRule(ruleModule, options, { id: rule, ...context }, severity === 'error'
+            ? 1
+            : severity === 'warn'
+                ? 0
+                : 3);
+    }
+    return rules;
+}
+function* resolveRuleKey(rule) {
+    const slashIndex = rule.indexOf('/');
+    if (slashIndex !== -1) {
+        let pluginName = rule.startsWith('@')
+            ? `${rule.slice(0, slashIndex)}/eslint-plugin`
+            : `eslint-plugin-${rule.slice(0, slashIndex)}`;
+        let ruleName = rule.slice(slashIndex + 1);
+        yield [pluginName, ruleName];
+        if (ruleName.indexOf('/') >= 0) {
+            pluginName += `-${ruleName.slice(0, ruleName.indexOf('/'))}`;
+            ruleName = ruleName.slice(ruleName.indexOf('/') + 1);
+            yield [pluginName, ruleName];
+        }
+    }
+    else {
+        yield [undefined, rule];
+    }
+}
+async function loadRuleByKey(rule) {
+    for (const resolved of resolveRuleKey(rule)) {
+        const ruleModule = await loadRule(...resolved);
+        if (ruleModule) {
+            return ruleModule;
+        }
+    }
+}
+async function loadRule(pluginName, ruleName) {
+    if (pluginName) {
+        plugins[pluginName] ??= loader(pluginName);
+        const plugin = await plugins[pluginName];
+        return plugin?.rules[ruleName];
+    }
+    let dir = __dirname;
+    while (true) {
+        const rulePath = path.join(dir, 'node_modules', 'eslint', 'lib', 'rules', `${ruleName}.js`);
+        if (fs.existsSync(rulePath)) {
+            return loader(rulePath);
+        }
+        const parentDir = path.resolve(dir, '..');
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
+    }
+}
+//# sourceMappingURL=eslint.js.map

package/lib/plugins/category.js

@@ -16,7 +16,7 @@ function create(config, source = 'tsslint') {
                 }
             }
             return diagnostics;
-        }
+        },
     });
     function match(code) {
         if (matchCache.has(code)) {

package/lib/plugins/ignore.js

@@ -48,7 +48,7 @@ function create(cmdOption, reportsUnusedComments) {
                             : nextLineRules.length
                                 ? 'Ignore 1 issue in next line'
                                 : undefined,
-                    }
+                    },
                 };
                 if (result) {
                     result.entries.push(item);
@@ -108,8 +108,8 @@ function create(cmdOption, reportsUnusedComments) {
         };
         return {
             resolveDiagnostics(file, results) {
-                if (!reportsUnusedComments &&
-                    !results.some(error => error.source === 'tsslint')) {
+                if (!reportsUnusedComments
+                    && !results.some(error => error.source === 'tsslint')) {
                     return results;
                 }
                 const comments = new Map();

package/lib/tsl.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '@tsslint/config';
+import type * as TSL from 'tsl' with { 'resolution-mode': 'import' };
+export declare function fromTSLRules(tslRules: TSL.Rule<unknown>[]): Record<string, Rule>;

package/lib/tsl.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromTSLRules = fromTSLRules;
+const fs = require("fs");
+const path = require("path");
+function fromTSLRules(tslRules) {
+    let dir = __dirname;
+    let tslDir;
+    while (true) {
+        const potential = path.join(dir, 'node_modules', 'tsl');
+        if (fs.existsSync(potential)) {
+            tslDir = potential;
+            break;
+        }
+        const parentDir = path.dirname(dir);
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
+    }
+    if (!tslDir) {
+        throw new Error('Failed to find tsl package in node_modules.');
+    }
+    const visitorEntriesFile = fs.readdirSync(tslDir).find(f => /^visitorEntries-.*\.js$/.test(f));
+    if (!visitorEntriesFile) {
+        throw new Error('Failed to find visitorEntries file in tsl package.');
+    }
+    const { getContextUtils, visitorEntries } = require(path.join(tslDir, visitorEntriesFile));
+    const rules = {};
+    for (const tslRule of tslRules) {
+        rules[tslRule.name] = convertTSLRule(tslRule, visitorEntries);
+    }
+    return rules;
+    function convertTSLRule(rule, visitorEntries) {
+        return ({ typescript: ts, file, program, report }) => {
+            const context1 = {
+                checker: program.getTypeChecker(),
+                rawChecker: program.getTypeChecker(),
+                sourceFile: file,
+                report: descriptor => {
+                    if ('node' in descriptor) {
+                        report(descriptor.message, descriptor.node.getStart(file), descriptor.node.getEnd())
+                            .at(new Error(), 1);
+                    }
+                    else {
+                        report(descriptor.message, descriptor.start, descriptor.end)
+                            .at(new Error(), 1);
+                    }
+                },
+                compilerOptions: program.getCompilerOptions(),
+                program,
+                utils: getContextUtils(() => program),
+            };
+            const context2 = { ...context1, data: rule.createData?.(context1) };
+            ts.forEachChild(file, function cb(node) {
+                const nodeType = visitorEntries.find(e => e[0] === node.kind)?.[1];
+                if (nodeType) {
+                    // @ts-expect-error
+                    rule.visitor[nodeType]?.(context2, node);
+                }
+                ts.forEachChild(node, cb);
+                if (nodeType) {
+                    // @ts-expect-error
+                    rule.visitor[`${nodeType}_exit`]?.(context2, node);
+                }
+            });
+        };
+    }
+}
+//# sourceMappingURL=tsl.js.map

package/lib/tslint-gen.d.ts

@@ -0,0 +1,4 @@
+export declare function generateTSLintTypes(nodeModulesDirs: string[], loader?: (mod: string) => Promise<any>): Promise<{
+    dts: string;
+    stats: Record<string, number>;
+}>;

package/lib/tslint-gen.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTSLintTypes = generateTSLintTypes;
+const fs = require("fs");
+const path = require("path");
+const tslint_1 = require("./tslint");
+const variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+async function generateTSLintTypes(nodeModulesDirs, loader = async (mod) => {
+    try {
+        return require(mod);
+    }
+    catch {
+        return await import(mod);
+    }
+}) {
+    let indentLevel = 0;
+    let dts = '';
+    let defId = 0;
+    line(`export interface TSLintRulesConfig {`);
+    indentLevel++;
+    const visited = new Set();
+    const defs = new Map();
+    const stats = {};
+    const rulesDirectories = (0, tslint_1.getTSLintRulesDirectories)();
+    for (const [rawDir, rulesDir] of rulesDirectories) {
+        if (fs.existsSync(rulesDir)) {
+            const ruleFiles = fs.readdirSync(rulesDir);
+            stats[rawDir] = 0;
+            for (const ruleFile of ruleFiles) {
+                if (ruleFile.endsWith('Rule.js') || ruleFile.endsWith('Rule.ts')) {
+                    const camelCaseName = ruleFile.slice(0, -'Rule.js'.length);
+                    const ruleName = camelCaseName.replace(/[A-Z]/g, (c, i) => (i === 0 ? c.toLowerCase() : '-' + c.toLowerCase()));
+                    if (!visited.has(ruleName)) {
+                        visited.add(ruleName);
+                        try {
+                            const rule = (await loader(path.join(rulesDir, ruleFile))).Rule;
+                            addRule(ruleName, rule.metadata, rawDir);
+                            stats[rawDir]++;
+                        }
+                        catch (e) {
+                            addRule(ruleName, undefined, rawDir, e);
+                            stats[rawDir]++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 2. Scan TSLint core rules
+    for (const nodeModulesDir of nodeModulesDirs) {
+        const tslintDir = path.join(nodeModulesDir, 'tslint', 'lib', 'rules');
+        if (fs.existsSync(tslintDir)) {
+            const ruleFiles = fs.readdirSync(tslintDir);
+            stats['tslint'] = stats['tslint'] || 0;
+            for (const ruleFile of ruleFiles) {
+                if (ruleFile.endsWith('Rule.js')) {
+                    const camelCaseName = ruleFile.replace('Rule.js', '');
+                    const ruleName = camelCaseName.replace(/[A-Z]/g, (c, i) => (i === 0 ? c.toLowerCase() : '-' + c.toLowerCase()));
+                    if (!visited.has(ruleName)) {
+                        visited.add(ruleName);
+                        const rule = (await loader(path.join(tslintDir, ruleFile))).Rule;
+                        addRule(ruleName, rule.metadata);
+                        stats['tslint']++;
+                    }
+                }
+            }
+        }
+    }
+    indentLevel--;
+    line(`}`);
+    line(``);
+    for (const [typeName, typeString] of defs.values()) {
+        line(`type ${typeName} = ${typeString};`);
+    }
+    return { dts, stats };
+    function addRule(ruleName, metadata, rulesDir, error) {
+        if (metadata || rulesDir || error) {
+            line(`/**`);
+            if (rulesDir) {
+                line(` * @rulesDirectory ${rulesDir}`);
+            }
+            if (error) {
+                line(` * @error ${error.message || error.toString()}`);
+            }
+            if (metadata?.description) {
+                for (const lineText of metadata.description.trim().split('\n')) {
+                    line(` * ${lineText.replace(/\*\//g, '* /')}`);
+                }
+            }
+            if (metadata?.descriptionDetails) {
+                line(` *`);
+                for (const lineText of metadata.descriptionDetails.trim().split('\n')) {
+                    line(` * ${lineText.replace(/\*\//g, '* /')}`);
+                }
+            }
+            if (metadata?.rationale) {
+                line(` *`);
+                line(` * @rationale`);
+                for (const lineText of metadata.rationale.trim().split('\n')) {
+                    line(` * ${lineText.replace(/\*\//g, '* /')}`);
+                }
+            }
+            if (metadata?.optionsDescription) {
+                line(` *`);
+                line(` * @options`);
+                for (const lineText of metadata.optionsDescription.trim().split('\n')) {
+                    line(` * ${lineText.replace(/\*\//g, '* /')}`);
+                }
+            }
+            if (metadata?.optionExamples) {
+                line(` *`);
+                line(` * @example`);
+                for (const example of metadata.optionExamples) {
+                    if (typeof example === 'string') {
+                        for (const lineText of example.trim().split('\n')) {
+                            line(` * ${lineText.replace(/\*\//g, '* /')}`);
+                        }
+                    }
+                    else {
+                        line(` * ${JSON.stringify(ruleName)}: ${JSON.stringify(example)}`);
+                    }
+                }
+            }
+            if (metadata?.type) {
+                line(` *`);
+                line(` * @type ${metadata.type}`);
+            }
+            if (metadata?.typescriptOnly) {
+                line(` *`);
+                line(` * @typescriptOnly`);
+            }
+            line(` */`);
+        }
+        let optionsType;
+        const schema = metadata?.options;
+        if (schema) {
+            if (Array.isArray(schema)) {
+                const optionsTypes = [];
+                for (const item of schema) {
+                    const itemType = parseSchema(schema, item, indentLevel);
+                    optionsTypes.push(itemType);
+                }
+                optionsType = `[`;
+                optionsType += optionsTypes
+                    .map(type => `(${type})?`)
+                    .join(', ');
+                optionsType += `]`;
+            }
+            else {
+                optionsType = parseSchema(schema, schema, indentLevel);
+            }
+        }
+        if (optionsType) {
+            line(`'${ruleName}'?: ${optionsType},`);
+        }
+        else {
+            line(`'${ruleName}'?: any[],`);
+        }
+    }
+    function line(line) {
+        dts += indent(indentLevel) + line + '\n';
+    }
+    function parseSchema(schema, item, indentLevel) {
+        if (typeof item === 'object' && item !== null) {
+            if (item.$ref) {
+                const paths = item.$ref
+                    .replace('#/items/', '#/')
+                    .split('/').slice(1);
+                let current = schema;
+                for (const path of paths) {
+                    try {
+                        current = current[path];
+                    }
+                    catch {
+                        current = undefined;
+                        break;
+                    }
+                }
+                if (current) {
+                    let resolved = defs.get(current);
+                    if (!resolved) {
+                        resolved = [`Def${defId++}_${paths[paths.length - 1]}`, parseSchema(schema, current, 0)];
+                        defs.set(current, resolved);
+                    }
+                    return resolved[0];
+                }
+                else {
+                    console.error(`Failed to resolve schema path: ${item.$ref}`);
+                    return 'unknown';
+                }
+            }
+            else if (Array.isArray(item)) {
+                return item.map(item => parseSchema(schema, item, indentLevel)).join(' | ');
+            }
+            else if (Array.isArray(item.type)) {
+                return item.type.map((type) => parseSchema(schema, type, indentLevel)).join(' | ');
+            }
+            else if (item.properties) {
+                let res = `{\n`;
+                indentLevel++;
+                const properties = item.properties;
+                const requiredArr = item.required ?? [];
+                for (const key in properties) {
+                    const property = properties[key];
+                    if (property.description) {
+                        res += indent(indentLevel) + `/**\n`;
+                        res += indent(indentLevel) + ` * ${property.description.replace(/\*\//g, '* /')}\n`;
+                        res += indent(indentLevel) + ` */\n`;
+                    }
+                    const propertyType = parseSchema(schema, property, indentLevel);
+                    const isRequired = requiredArr.includes(key);
+                    if (!variableNameRegex.test(key)) {
+                        res += indent(indentLevel) + `'${key}'${isRequired ? '' : '?'}: ${propertyType},\n`;
+                    }
+                    else {
+                        res += indent(indentLevel) + `${key}${isRequired ? '' : '?'}: ${propertyType},\n`;
+                    }
+                }
+                indentLevel--;
+                res += indent(indentLevel) + `}`;
+                if (item.additionalProperties) {
+                    res += ` & `;
+                    res += parseAdditionalProperties(schema, item.additionalProperties, indentLevel);
+                }
+                return res;
+            }
+            else if (Array.isArray(item.required)) {
+                let res = `{ `;
+                const propertiesType = [];
+                for (const key of item.required) {
+                    const propertyType = `any`;
+                    if (!variableNameRegex.test(key)) {
+                        propertiesType.push(`'${key}': ${propertyType}`);
+                    }
+                    else {
+                        propertiesType.push(`${key}: ${propertyType}`);
+                    }
+                }
+                res += propertiesType.join(', ');
+                res += ` }`;
+                return res;
+            }
+            else if (item.const) {
+                return JSON.stringify(item.const);
+            }
+            else if (item.type === 'array') {
+                if (Array.isArray(item.items)) {
+                    return `[${item.items.map((item) => parseSchema(schema, item, indentLevel)).join(', ')}]`;
+                }
+                if (item.items) {
+                    return `(${parseSchema(schema, item.items, indentLevel)})[]`;
+                }
+                return `any[]`;
+            }
+            else if (item.enum) {
+                return item.enum.map((v) => JSON.stringify(v)).join(' | ');
+            }
+            else if (item.type) {
+                return parseSchema(schema, item.type, indentLevel);
+            }
+            else if (item.anyOf) {
+                return item.anyOf.map((item) => parseSchema(schema, item, indentLevel)).join(' | ');
+            }
+            else if (item.oneOf) {
+                return item.oneOf.map((item) => parseSchema(schema, item, indentLevel)).join(' | ');
+            }
+        }
+        else if (item === 'string' || item === 'boolean' || item === 'null' || item === 'number') {
+            return item;
+        }
+        else if (item === 'object') {
+            if (item.additionalProperties) {
+                return parseAdditionalProperties(schema, item.additionalProperties, indentLevel);
+            }
+            else {
+                return `{ [key: string]: unknown }`;
+            }
+        }
+        else if (item === 'integer') {
+            return 'number';
+        }
+        else if (item === 'array') {
+            return 'any[]';
+        }
+        return 'unknown';
+    }
+    function indent(indentLevel) {
+        return '\t'.repeat(indentLevel);
+    }
+    function parseAdditionalProperties(schema, item, indentLevel) {
+        if (item === true) {
+            return `{ [key: string]: unknown }`;
+        }
+        else {
+            return `{ [key: string]: ${parseSchema(schema, item, indentLevel)} }`;
+        }
+    }
+}
+//# sourceMappingURL=tslint-gen.js.map

package/lib/tslint-types.d.ts

@@ -0,0 +1,3 @@
+export interface TSLintRulesConfig extends Record<string, any[]> {
+    [key: string]: any[];
+}

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,15 @@
+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 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,155 @@
+"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 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": "3.0.0-alpha.0",
+	"version": "3.0.0",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22.6.0"
+	},
+	"bin": {
+		"tsslint-docgen": "./bin/tsslint-docgen.js"
+	},
 	"files": [
 		"**/*.js",
 		"**/*.d.ts"
@@ -12,9 +18,25 @@
 		"directory": "packages/config"
 	},
 	"dependencies": {
-		"@tsslint/types": "3.0.0-alpha.0",
+		"@tsslint/types": "3.0.0",
 		"minimatch": "^10.0.1",
 		"ts-api-utils": "^2.0.0"
 	},
-	"gitHead": "ec683ca05f4360fac720bd8c567f4d9460d255e1"
-}
+	"devDependencies": {
+		"@tsslint/compat-eslint": "3.0.0",
+		"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": "69bc86cf2dd81f9e48fc15ed9b9f0351fa2fc19e"
+}