Generate eslint rules

Author: Shinigami92

scripts/generate-rule-files.ts

@@ -2,6 +2,7 @@
 import eslintPluginTypeScript from '@typescript-eslint/eslint-plugin';
 import { camelCase, pascalCase } from 'change-case';
 import type { Rule } from 'eslint';
+import * as eslint from 'eslint';
 // @ts-expect-error
 import eslintPluginJSDoc from 'eslint-plugin-jsdoc';
 // @ts-expect-error
@@ -35,6 +36,10 @@ const PRETTIER_OPTIONS: Options = {
 };
 
 const generationMap: Record<string, Plugin> = {
+  eslint: {
+    name: 'Eslint',
+    rules: Object.fromEntries(new eslint.Linter().getRules().entries())
+  },
   jsdoc: {
     name: 'JSDoc',
     rules: (eslintPluginJSDoc as Plugin).rules
@@ -65,28 +70,50 @@ async function main(): Promise<void> {
 
     fs.mkdirSync(ruleProviderDir, { mode: 0o755, recursive: true });
 
+    const failedRules: string[] = [];
     for (const [ruleName, { meta }] of Object.entries(rules)) {
-      const rulePath: string = path.resolve(ruleProviderDir, `${ruleName}.d.ts`);
-      let ruleContent: string = "import type { RuleConfig } from '../rule-config';";
+      try {
+        const rulePath: string = path.resolve(ruleProviderDir, `${ruleName}.d.ts`);
+        let ruleContent: string = "import type { RuleConfig } from '../rule-config';";
 
-      const ruleNamePascalCase: string = pascalCase(ruleName);
+        const ruleNamePascalCase: string = pascalCase(ruleName);
 
-      let description: string = upperCaseFirst(meta?.docs?.description ?? '');
-      if (description.length > 0 && !description.endsWith('.')) {
-        description += '.';
-      }
-      const seeDocLink: string = meta?.docs?.url ? `@see [${ruleName}](${meta.docs.url})` : '';
-
-      const schema: JSONSchema4 | JSONSchema4[] | undefined = meta?.schema;
-      const mainSchema: JSONSchema4 | undefined = Array.isArray(schema) ? schema[0] : schema;
-      const sideSchema: JSONSchema4 | undefined =
-        schema && Array.isArray(schema) && schema.length > 1 ? schema[1] : undefined;
-      const thirdSchema: JSONSchema4 | undefined =
-        schema && Array.isArray(schema) && schema.length > 2 ? schema[2] : undefined;
-      if (mainSchema) {
-        if (sideSchema) {
-          if (thirdSchema) {
-            const ruleSetting: string = await compile(thirdSchema, `${ruleNamePascalCase}Setting`, {
+        let description: string = upperCaseFirst(meta?.docs?.description ?? '');
+        if (description.length > 0 && !description.endsWith('.')) {
+          description += '.';
+        }
+        const seeDocLink: string = meta?.docs?.url ? `@see [${ruleName}](${meta.docs.url})` : '';
+
+        const schema: JSONSchema4 | JSONSchema4[] | undefined = meta?.schema;
+        const mainSchema: JSONSchema4 | undefined = Array.isArray(schema) ? schema[0] : schema;
+        const sideSchema: JSONSchema4 | undefined =
+          schema && Array.isArray(schema) && schema.length > 1 ? schema[1] : undefined;
+        const thirdSchema: JSONSchema4 | undefined =
+          schema && Array.isArray(schema) && schema.length > 2 ? schema[2] : undefined;
+        if (mainSchema) {
+          if (sideSchema) {
+            if (thirdSchema) {
+              const ruleSetting: string = await compile(thirdSchema, `${ruleNamePascalCase}Setting`, {
+                bannerComment: '',
+                style: {
+                  bracketSpacing: true,
+                  printWidth: 120,
+                  semi: true,
+                  singleQuote: true,
+                  tabWidth: 2,
+                  trailingComma: 'none',
+                  useTabs: false
+                },
+                unknownAny: false
+              });
+              ruleContent += `
+
+/**
+ * Setting.
+ */
+${ruleSetting}`;
+            }
+            const ruleConfig: string = await compile(sideSchema, `${ruleNamePascalCase}Config`, {
               bannerComment: '',
               style: {
                 bracketSpacing: true,
@@ -102,11 +129,12 @@ async function main(): Promise<void> {
             ruleContent += `
 
 /**
- * Setting.
+ * Config.
  */
-${ruleSetting}`;
+${ruleConfig}`;
           }
-          const ruleConfig: string = await compile(sideSchema, `${ruleNamePascalCase}Config`, {
+
+          const ruleOption: string = await compile(mainSchema, `${ruleNamePascalCase}Option`, {
             bannerComment: '',
             style: {
               bracketSpacing: true,
@@ -119,29 +147,8 @@ ${ruleSetting}`;
             },
             unknownAny: false
           });
-          ruleContent += `
 
-/**
- * Config.
- */
-${ruleConfig}`;
-        }
-
-        const ruleOption: string = await compile(mainSchema, `${ruleNamePascalCase}Option`, {
-          bannerComment: '',
-          style: {
-            bracketSpacing: true,
-            printWidth: 120,
-            semi: true,
-            singleQuote: true,
-            tabWidth: 2,
-            trailingComma: 'none',
-            useTabs: false
-          },
-          unknownAny: false
-        });
-
-        ruleContent += `
+          ruleContent += `
 
 /**
  * Option.
@@ -152,13 +159,13 @@ ${ruleOption}
  * Options.
  */
 export type ${ruleNamePascalCase}Options = [${ruleNamePascalCase}Option?${
-          sideSchema ? `, ${ruleNamePascalCase}Config?${thirdSchema ? `, ${ruleNamePascalCase}Setting?` : ''}` : ''
-        }];`;
-      }
+            sideSchema ? `, ${ruleNamePascalCase}Config?${thirdSchema ? `, ${ruleNamePascalCase}Setting?` : ''}` : ''
+          }];`;
+        }
 
-      // TODO: Add third option
+        // TODO: Add third option
 
-      ruleContent += `
+        ruleContent += `
 
   /**
    * ${description}
@@ -178,16 +185,23 @@ export type ${ruleNamePascalCase}Options = [${ruleNamePascalCase}Option?${
      *
      * ${seeDocLink}
      */
-    '${prefix ?? camelCase(pluginName)}/${ruleName}': ${ruleNamePascalCase}RuleConfig;
+    '${
+      pluginName !== 'eslint' ? `${prefix ?? camelCase(pluginName)}/` : ''
+    }${ruleName}': ${ruleNamePascalCase}RuleConfig;
   }
   `;
-      ruleContent = format(ruleContent, PRETTIER_OPTIONS);
-      fs.writeFileSync(rulePath, ruleContent);
+        ruleContent = format(ruleContent, PRETTIER_OPTIONS);
+        fs.writeFileSync(rulePath, ruleContent);
+      } catch (error) {
+        console.log(`Failed to generate rule ${ruleName} for ${name}`, error);
+        failedRules.push(ruleName);
+      }
     }
 
     // Generating index.d.ts for rules
     const indexPath: string = path.resolve(ruleProviderDir, 'index.d.ts');
     let indexContent: string = Object.keys(rules)
+      .filter((name) => !failedRules.includes(name))
       .map((name) => `import type { ${pascalCase(name)}Rule } from './${name}';`)
       .join('\n');
 
@@ -197,6 +211,7 @@ export type ${ruleNamePascalCase}Options = [${ruleNamePascalCase}Option?${
  * All ${name} rules.
  */
 export type ${name}Rules = ${Object.keys(rules)
+      .filter((name) => !failedRules.includes(name))
       .map((name) => `${pascalCase(name)}Rule`)
       .join(' & ')}
 `;

src/rules/eslint/accessor-pairs.d.ts

@@ -0,0 +1,36 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ * Option.
+ */
+export interface AccessorPairsOption {
+  getWithoutSet?: boolean;
+  setWithoutGet?: boolean;
+  enforceForClassMembers?: boolean;
+}
+
+/**
+ * Options.
+ */
+export type AccessorPairsOptions = [AccessorPairsOption?];
+
+/**
+ * Enforce getter and setter pairs in objects and classes.
+ *
+ * @see [accessor-pairs](https://eslint.org/docs/rules/accessor-pairs)
+ */
+export type AccessorPairsRuleConfig = RuleConfig<AccessorPairsOptions>;
+
+/**
+ * Enforce getter and setter pairs in objects and classes.
+ *
+ * @see [accessor-pairs](https://eslint.org/docs/rules/accessor-pairs)
+ */
+export interface AccessorPairsRule {
+  /**
+   * Enforce getter and setter pairs in objects and classes.
+   *
+   * @see [accessor-pairs](https://eslint.org/docs/rules/accessor-pairs)
+   */
+  'accessor-pairs': AccessorPairsRuleConfig;
+}

src/rules/eslint/array-bracket-newline.d.ts

@@ -0,0 +1,37 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ * Option.
+ */
+export type ArrayBracketNewlineOption =
+  | ('always' | 'never' | 'consistent')
+  | {
+      multiline?: boolean;
+      minItems?: number | null;
+    };
+
+/**
+ * Options.
+ */
+export type ArrayBracketNewlineOptions = [ArrayBracketNewlineOption?];
+
+/**
+ * Enforce linebreaks after opening and before closing array brackets.
+ *
+ * @see [array-bracket-newline](https://eslint.org/docs/rules/array-bracket-newline)
+ */
+export type ArrayBracketNewlineRuleConfig = RuleConfig<ArrayBracketNewlineOptions>;
+
+/**
+ * Enforce linebreaks after opening and before closing array brackets.
+ *
+ * @see [array-bracket-newline](https://eslint.org/docs/rules/array-bracket-newline)
+ */
+export interface ArrayBracketNewlineRule {
+  /**
+   * Enforce linebreaks after opening and before closing array brackets.
+   *
+   * @see [array-bracket-newline](https://eslint.org/docs/rules/array-bracket-newline)
+   */
+  'array-bracket-newline': ArrayBracketNewlineRuleConfig;
+}

src/rules/eslint/array-bracket-spacing.d.ts

@@ -0,0 +1,41 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ * Config.
+ */
+export interface ArrayBracketSpacingConfig {
+  singleValue?: boolean;
+  objectsInArrays?: boolean;
+  arraysInArrays?: boolean;
+}
+
+/**
+ * Option.
+ */
+export type ArrayBracketSpacingOption = 'always' | 'never';
+
+/**
+ * Options.
+ */
+export type ArrayBracketSpacingOptions = [ArrayBracketSpacingOption?, ArrayBracketSpacingConfig?];
+
+/**
+ * Enforce consistent spacing inside array brackets.
+ *
+ * @see [array-bracket-spacing](https://eslint.org/docs/rules/array-bracket-spacing)
+ */
+export type ArrayBracketSpacingRuleConfig = RuleConfig<ArrayBracketSpacingOptions>;
+
+/**
+ * Enforce consistent spacing inside array brackets.
+ *
+ * @see [array-bracket-spacing](https://eslint.org/docs/rules/array-bracket-spacing)
+ */
+export interface ArrayBracketSpacingRule {
+  /**
+   * Enforce consistent spacing inside array brackets.
+   *
+   * @see [array-bracket-spacing](https://eslint.org/docs/rules/array-bracket-spacing)
+   */
+  'array-bracket-spacing': ArrayBracketSpacingRuleConfig;
+}

src/rules/eslint/array-callback-return.d.ts

@@ -0,0 +1,35 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ * Option.
+ */
+export interface ArrayCallbackReturnOption {
+  allowImplicit?: boolean;
+  checkForEach?: boolean;
+}
+
+/**
+ * Options.
+ */
+export type ArrayCallbackReturnOptions = [ArrayCallbackReturnOption?];
+
+/**
+ * Enforce `return` statements in callbacks of array methods.
+ *
+ * @see [array-callback-return](https://eslint.org/docs/rules/array-callback-return)
+ */
+export type ArrayCallbackReturnRuleConfig = RuleConfig<ArrayCallbackReturnOptions>;
+
+/**
+ * Enforce `return` statements in callbacks of array methods.
+ *
+ * @see [array-callback-return](https://eslint.org/docs/rules/array-callback-return)
+ */
+export interface ArrayCallbackReturnRule {
+  /**
+   * Enforce `return` statements in callbacks of array methods.
+   *
+   * @see [array-callback-return](https://eslint.org/docs/rules/array-callback-return)
+   */
+  'array-callback-return': ArrayCallbackReturnRuleConfig;
+}

src/rules/eslint/array-element-newline.d.ts

@@ -0,0 +1,46 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ * Option.
+ */
+export type ArrayElementNewlineOption =
+  | []
+  | [
+      | BasicConfig
+      | {
+          ArrayExpression?: BasicConfig;
+          ArrayPattern?: BasicConfig;
+        }
+    ];
+export type BasicConfig =
+  | ('always' | 'never' | 'consistent')
+  | {
+      multiline?: boolean;
+      minItems?: number | null;
+    };
+
+/**
+ * Options.
+ */
+export type ArrayElementNewlineOptions = [ArrayElementNewlineOption?];
+
+/**
+ * Enforce line breaks after each array element.
+ *
+ * @see [array-element-newline](https://eslint.org/docs/rules/array-element-newline)
+ */
+export type ArrayElementNewlineRuleConfig = RuleConfig<ArrayElementNewlineOptions>;
+
+/**
+ * Enforce line breaks after each array element.
+ *
+ * @see [array-element-newline](https://eslint.org/docs/rules/array-element-newline)
+ */
+export interface ArrayElementNewlineRule {
+  /**
+   * Enforce line breaks after each array element.
+   *
+   * @see [array-element-newline](https://eslint.org/docs/rules/array-element-newline)
+   */
+  'array-element-newline': ArrayElementNewlineRuleConfig;
+}