@tsslint/config 3.0.0-alpha.0 → 3.0.0-alpha.1

package/bin/tsslint-docgen.js

@@ -0,0 +1,98 @@
+#!/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;
+}
+
+const dtsGeneratePath = path.resolve(__dirname, '..', 'index.ts');
+if (fs.existsSync(dtsGeneratePath)) {
+	console.log('Skip dts docgen in development environment.');
+	process.exit(0);
+}
+
+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