@tsslint/config 2.0.7 → 3.0.0-alpha.1

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,27 @@
+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 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 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,122 @@
+"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 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 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