Write index.d.ts rules file

Author: Shinigami92

.eslintrc.js

@@ -11,15 +11,14 @@ module.exports = defineConfig({
     'eslint:recommended',
     'plugin:@typescript-eslint/recommended',
     'plugin:@typescript-eslint/recommended-requiring-type-checking',
-    'plugin:jsdoc/recommended',
     'plugin:prettier/recommended'
   ],
   parser: '@typescript-eslint/parser',
   parserOptions: {
     project: ['./tsconfig.json'],
     warnOnUnsupportedTypeScriptVersion: false
   },
-  plugins: ['@typescript-eslint', 'prettier', 'jsdoc', 'spellcheck', 'inclusive-language'],
+  plugins: ['@typescript-eslint', 'prettier'],
   rules: {
     curly: ['error'],
     'linebreak-style': ['error', 'unix'],
@@ -40,123 +39,6 @@ module.exports = defineConfig({
     '@typescript-eslint/prefer-optional-chain': 'warn',
     '@typescript-eslint/prefer-readonly': ['warn'],
     '@typescript-eslint/restrict-template-expressions': 'off',
-    '@typescript-eslint/typedef': ['warn', { memberVariableDeclaration: true, variableDeclaration: true }],
-
-    'jsdoc/match-description': [
-      'warn',
-      {
-        mainDescription: '/^[A-Z`].+?(\\.|:)(\\n\\n.*((\\n{1,2}- .+)|(_.+_)|`.+`|\\n\\n---))?$/us',
-        matchDescription: '^[A-Z`].+(\\.|`.+`)$',
-        contexts: ['any'],
-        tags: {
-          param: true,
-          returns: true
-        }
-      }
-    ],
-    'jsdoc/no-types': 'error',
-    'jsdoc/require-jsdoc': [
-      'warn',
-      {
-        contexts: [
-          'ClassDeclaration',
-          "ClassProperty:not([accessibility='private'])",
-          'ExportNamedDeclaration:has(VariableDeclaration)',
-          'FunctionExpression',
-          "MethodDefinition:not([accessibility='private']) > FunctionExpression",
-          'TSEnumDeclaration',
-          'TSInterfaceDeclaration',
-          'TSMethodSignature',
-          // 'TSPropertySignature',
-          'TSTypeAliasDeclaration'
-        ]
-      }
-    ],
-    'jsdoc/require-param-type': 'off',
-    'jsdoc/require-returns-type': 'off',
-    'jsdoc/tag-lines': 'off',
-
-    'spellcheck/spell-checker': [
-      'warn',
-      {
-        minLength: 3,
-        skipWords: [
-          'accessor',
-          'accessors',
-          'amd',
-          'applescript',
-          'argv',
-          'asyncgenerator',
-          'asynciterable',
-          'atomtest',
-          'backtick',
-          'backticks',
-          'browserify',
-          'cjs',
-          'commonjs',
-          'declarator',
-          'denylist',
-          'dom',
-          'ecma',
-          'embertest',
-          'esm',
-          'esnext',
-          'getters',
-          'globals',
-          'greasemonkey',
-          'inferrable',
-          'jsdoc',
-          'jsx',
-          'lang',
-          'len',
-          'linebreak',
-          'loc',
-          'multiline',
-          'nashorn',
-          'nocheck',
-          'nullish',
-          'phantomjs',
-          'pragma',
-          'prototypejs',
-          'readonly',
-          'scripthost',
-          'sharedmemory',
-          'singleline',
-          'tsconfig',
-          'typedarrays',
-          'unix',
-          'urls',
-          'vue',
-          'webextensions',
-          'webworker',
-          'wellknown',
-          'whitespace',
-          'writeable'
-        ]
-      }
-    ],
-
-    'inclusive-language/use-inclusive-words': [
-      'warn',
-      {
-        allowedTerms: [
-          {
-            term: '/master',
-            allowPartialMatches: true
-          }
-        ],
-        words: [
-          {
-            word: 'guys',
-            suggestions: ['folks']
-          }
-        ]
-      }
-    ]
-  },
-  settings: {
-    jsdoc: {
-      mode: 'typescript'
-    }
+    '@typescript-eslint/typedef': ['warn', { memberVariableDeclaration: true, variableDeclaration: true }]
   }
 });

package.json

@@ -40,8 +40,10 @@
   "devDependencies": {
     "@types/eslint": "~7.28.0",
     "@types/node": "~16.9.6",
+    "@types/prettier": "~2.4.1",
     "@typescript-eslint/eslint-plugin": "~4.31.2",
     "@typescript-eslint/parser": "~4.31.2",
+    "change-case": "~4.1.2",
     "eslint": "~7.32.0",
     "eslint-config-prettier": "~8.3.0",
     "eslint-plugin-inclusive-language": "~2.1.1",

scripts/generate-files.ts

@@ -1,42 +1,74 @@
-/* eslint-disable */
-
+import { pascalCase } from 'change-case';
 import type { Rule } from 'eslint';
 // @ts-expect-error
 import eslintPluginVue from 'eslint-plugin-vue';
 import * as fs from 'fs';
 import * as path from 'path';
+import type { Options } from 'prettier';
+import { format } from 'prettier';
 
 interface Plugin {
   rules: Record<string, Rule.RuleModule>;
 }
 
-function pascalCase(value: string): string {
-  return value.replace(/(\w)(\w*)/g, (_, g1, g2) => g1.toUpperCase() + g2.toLowerCase()).replace(/-/g, '');
-}
+const PRETTIER_OPTIONS: Options = {
+  parser: 'typescript',
+  arrowParens: 'always',
+  bracketSpacing: true,
+  printWidth: 120,
+  semi: true,
+  singleQuote: true,
+  tabWidth: 2,
+  trailingComma: 'none',
+  useTabs: false
+};
 
-const rulesDir = path.resolve(__dirname, '../src/rules');
+// Generating rule files
+const rulesDir: string = path.resolve(__dirname, '../src/rules');
 
-const ruleProviderDir = path.resolve(rulesDir, 'vue');
+const ruleProviderDir: string = path.resolve(rulesDir, 'vue');
 
 fs.mkdirSync(ruleProviderDir, { mode: 0o755, recursive: true });
 
 Object.entries((eslintPluginVue as Plugin).rules).forEach(([name, { meta }]) => {
-  const rulePath = path.resolve(ruleProviderDir, `${name}.d.ts`);
-  fs.writeFileSync(
-    rulePath,
-    `import type { RuleConfig } from '../rule-config';
+  const rulePath: string = path.resolve(ruleProviderDir, `${name}.d.ts`);
+  let ruleContent: string = `import type { RuleConfig } from '../rule-config';
 
-/**
- *
- */
-export type ${pascalCase(name)}RuleConfig = RuleConfig<[]>;
+  /**
+   *
+   */
+  export type ${pascalCase(name)}RuleConfig = RuleConfig<[]>;
+
+  /**
+   *
+   */
+  export interface ${pascalCase(name)}Rule {
+    /**
+     *
+     */
+    'vue/${name}': ${pascalCase(name)}RuleConfig;
+  }
+  `;
+  ruleContent = format(ruleContent, PRETTIER_OPTIONS);
+  fs.writeFileSync(rulePath, ruleContent);
+});
+
+// Generating index.d.ts for rules
+const indexPath: string = path.resolve(ruleProviderDir, 'index.d.ts');
+let indexContent: string = Object.keys((eslintPluginVue as Plugin).rules)
+  .map((name) => `import type { ${pascalCase(name)}Rule } from './${name}';`)
+  .join('\n');
+
+indexContent += `
 
 /**
- *
+ * All @typescript-eslint rules.
  */
-export interface ${pascalCase(name)}Rule {
-  'vue/${name}': any;
-}
-`
-  );
-});
+export type VueRules = ${Object.keys((eslintPluginVue as Plugin).rules)
+  .map((name) => `${pascalCase(name)}Rule`)
+  .join(' & ')}
+`;
+
+indexContent = format(indexContent, PRETTIER_OPTIONS);
+
+fs.writeFileSync(indexPath, indexContent);

src/rules/index.d.ts

@@ -5,6 +5,7 @@ import type { NodeRules } from './node';
 import type { RuleConfig } from './rule-config';
 import type { SpellcheckRules } from './spellcheck';
 import type { TypeScriptEslintRules } from './typescript-eslint';
+import type { VueRules } from './vue';
 
 /**
  * Rules.
@@ -18,5 +19,6 @@ export type Rules = Partial<
     ImportRules &
     JSDocRules &
     SpellcheckRules &
+    VueRules &
     Record<string, RuleConfig>
 >;

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

@@ -0,0 +1,16 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ *
+ */
+export type ArrayBracketNewlineRuleConfig = RuleConfig<[]>;
+
+/**
+ *
+ */
+export interface ArrayBracketNewlineRule {
+  /**
+   *
+   */
+  'vue/array-bracket-newline': ArrayBracketNewlineRuleConfig;
+}

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

@@ -0,0 +1,16 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ *
+ */
+export type ArrayBracketSpacingRuleConfig = RuleConfig<[]>;
+
+/**
+ *
+ */
+export interface ArrayBracketSpacingRule {
+  /**
+   *
+   */
+  'vue/array-bracket-spacing': ArrayBracketSpacingRuleConfig;
+}

src/rules/vue/arrow-spacing.d.ts

@@ -0,0 +1,16 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ *
+ */
+export type ArrowSpacingRuleConfig = RuleConfig<[]>;
+
+/**
+ *
+ */
+export interface ArrowSpacingRule {
+  /**
+   *
+   */
+  'vue/arrow-spacing': ArrowSpacingRuleConfig;
+}

src/rules/vue/attribute-hyphenation.d.ts

@@ -0,0 +1,16 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ *
+ */
+export type AttributeHyphenationRuleConfig = RuleConfig<[]>;
+
+/**
+ *
+ */
+export interface AttributeHyphenationRule {
+  /**
+   *
+   */
+  'vue/attribute-hyphenation': AttributeHyphenationRuleConfig;
+}

src/rules/vue/attributes-order.d.ts

@@ -0,0 +1,16 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ *
+ */
+export type AttributesOrderRuleConfig = RuleConfig<[]>;
+
+/**
+ *
+ */
+export interface AttributesOrderRule {
+  /**
+   *
+   */
+  'vue/attributes-order': AttributesOrderRuleConfig;
+}

src/rules/vue/block-lang.d.ts

@@ -0,0 +1,16 @@
+import type { RuleConfig } from '../rule-config';
+
+/**
+ *
+ */
+export type BlockLangRuleConfig = RuleConfig<[]>;
+
+/**
+ *
+ */
+export interface BlockLangRule {
+  /**
+   *
+   */
+  'vue/block-lang': BlockLangRuleConfig;
+}