refactor(eslint): add defineRules and deprecate convertRules

Author: johnsoncodehk

packages/eslint/index.ts

@@ -29,25 +29,26 @@ const loader = async (moduleName: string) => {
 	return mod as any;
 };
 
+type S = 'error' | 'warn' | 'suggestion' | 'off' | 0 | 1 | 2;
+type O<T extends any[]> = S | [S, ...options: T];
+
 /**
- * Converts an ESLint rules configuration to TSSLint rules.
- *
- * The type definitions are generated when `@tsslint/eslint` is installed.
- * If the type definitions become outdated, please run
- * `node node_modules/@tsslint/eslint/scripts/generateDts.js` to update them.
+ * @deprecated Use `defineRules` instead
  */
 export async function convertRules(
-	rulesConfig: ESLintRulesConfig,
+	rulesConfig: { [K in keyof ESLintRulesConfig]: O<ESLintRulesConfig[K]> },
 	context: Partial<ESLint.Rule.RuleContext> = {}
 ) {
 	const rules: TSSLint.Rules = {};
 	for (const [rule, severityOrOptions] of Object.entries(rulesConfig)) {
 		let severity: boolean;
 		let options: any[];
 		if (Array.isArray(severityOrOptions)) {
+			// @ts-expect-error
 			[severity, ...options] = severityOrOptions;
 		}
 		else {
+			// @ts-expect-error
 			severity = severityOrOptions;
 			options = [];
 		}
@@ -59,7 +60,47 @@ export async function convertRules(
 			rules[rule] = noop;
 			continue;
 		}
-		const ruleModule = await getRuleByKey(rule);
+		const ruleModule = await loadRuleByKey(rule);
+		if (!ruleModule) {
+			throw new Error(`Failed to resolve rule "${rule}".`);
+		}
+		rules[rule] = convertRule(
+			ruleModule,
+			options,
+			{ id: rule, ...context }
+		);
+	}
+	return rules;
+}
+
+/**
+ * Converts an ESLint rules configuration to TSSLint rules.
+ *
+ * The type definitions are generated when `@tsslint/eslint` is installed.
+ * If the type definitions become outdated, please run
+ * `node node_modules/@tsslint/eslint/scripts/generateDts.js` to update them.
+ */
+export async function defineRules(
+	rulesConfig: { [K in keyof ESLintRulesConfig]: boolean | ESLintRulesConfig[K] },
+	context: Partial<ESLint.Rule.RuleContext> = {}
+) {
+	const rules: TSSLint.Rules = {};
+	for (const [rule, severityOrOptions] of Object.entries(rulesConfig)) {
+		let severity: boolean;
+		let options: any[];
+		if (Array.isArray(severityOrOptions)) {
+			severity = true;
+			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}".`);
 		}
@@ -96,16 +137,16 @@ function* resolveRuleKey(rule: string): Generator<[
 	}
 }
 
-async function getRuleByKey(rule: string): Promise<ESLint.Rule.RuleModule | undefined> {
+async function loadRuleByKey(rule: string): Promise<ESLint.Rule.RuleModule | undefined> {
 	for (const resolved of resolveRuleKey(rule)) {
-		const ruleModule = await getRule(...resolved);
+		const ruleModule = await loadRule(...resolved);
 		if (ruleModule) {
 			return ruleModule;
 		}
 	}
 }
 
-async function getRule(pluginName: string | undefined, ruleName: string): Promise<ESLint.Rule.RuleModule | undefined> {
+async function loadRule(pluginName: string | undefined, ruleName: string): Promise<ESLint.Rule.RuleModule | undefined> {
 	if (pluginName) {
 		plugins[pluginName] ??= loader(pluginName);
 		const plugin = await plugins[pluginName];

packages/eslint/lib/dtsGenerate.ts

@@ -17,8 +17,6 @@ export async function generate(
 	let dts = '';
 	let defId = 0;
 
-	line(`export type O<T extends any[]> = boolean | [boolean, ...options: T];`);
-	line(``);
 	line(`export interface ESLintRulesConfig {`);
 	indentLevel++;
 
@@ -136,9 +134,9 @@ export async function generate(
 		}
 
 		if (optionsType) {
-			line(`'${ruleKey}'?: O<${optionsType}>,`);
+			line(`'${ruleKey}'?: ${optionsType},`);
 		} else {
-			line(`'${ruleKey}'?: O<any[]>,`);
+			line(`'${ruleKey}'?: any[],`);
 		}
 	}
 

packages/eslint/lib/types.ts

@@ -1,5 +1,3 @@
-export type O<T extends any[]> = boolean | [boolean, ...options: T];
-
-export interface ESLintRulesConfig {
-	[key: string]: O<any[]>;
+export interface ESLintRulesConfig extends Record<string, any[]> {
+	[key: string]: any[];
 }

tsslint.config.ts

@@ -1,12 +1,12 @@
 import { defineConfig } from '@tsslint/config';
-import { convertRules } from '@tsslint/eslint';
+import { defineRules } from '@tsslint/eslint';
 
 export default defineConfig({
-	rules: await convertRules({
-		'@typescript-eslint/consistent-type-imports': ['warn', {
+	rules: await defineRules({
+		'@typescript-eslint/consistent-type-imports': [{
 			disallowTypeAnnotations: false,
 			fixStyle: 'inline-type-imports',
 		}],
-		'@typescript-eslint/no-unnecessary-type-assertion': 'warn',
+		'@typescript-eslint/no-unnecessary-type-assertion': true,
 	}),
 });