Change prettier config

Author: Shinigami92

.eslintrc.js

@@ -5,18 +5,18 @@ module.exports = defineConfig({
   ignorePatterns: ['src/index.js', '.eslintrc.js'],
   env: {
     es6: true,
-    node: true
+    node: true,
   },
   extends: [
     'eslint:recommended',
     'plugin:@typescript-eslint/recommended',
     'plugin:@typescript-eslint/recommended-requiring-type-checking',
-    'plugin:prettier/recommended'
+    'plugin:prettier/recommended',
   ],
   parser: '@typescript-eslint/parser',
   parserOptions: {
     project: ['./tsconfig.json'],
-    warnOnUnsupportedTypeScriptVersion: false
+    warnOnUnsupportedTypeScriptVersion: false,
   },
   plugins: ['@typescript-eslint', 'prettier'],
   rules: {
@@ -27,10 +27,16 @@ module.exports = defineConfig({
     semi: ['error', 'always'],
 
     '@typescript-eslint/ban-ts-comment': 'off',
-    '@typescript-eslint/explicit-function-return-type': ['error', { allowExpressions: true }],
+    '@typescript-eslint/explicit-function-return-type': [
+      'error',
+      { allowExpressions: true },
+    ],
     '@typescript-eslint/interface-name-prefix': 'off',
     '@typescript-eslint/member-ordering': 'off',
-    '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
+    '@typescript-eslint/consistent-type-imports': [
+      'error',
+      { prefer: 'type-imports' },
+    ],
     '@typescript-eslint/no-explicit-any': 'off',
     '@typescript-eslint/no-inferrable-types': 'off',
     '@typescript-eslint/no-non-null-assertion': 'off',
@@ -41,6 +47,9 @@ 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 }]
-  }
+    '@typescript-eslint/typedef': [
+      'warn',
+      { memberVariableDeclaration: true, variableDeclaration: true },
+    ],
+  },
 });

.prettierrc.cjs

@@ -5,13 +5,6 @@
  */
 module.exports = {
   plugins: [require.resolve('prettier-plugin-organize-imports')],
-
-  arrowParens: 'always',
-  bracketSpacing: true,
-  printWidth: 120,
-  semi: true,
   singleQuote: true,
-  tabWidth: 2,
-  trailingComma: 'none',
-  useTabs: false
+  trailingComma: 'all',
 };

.vscode/extensions.json

@@ -1,3 +1,9 @@
 {
-  "recommendations": ["esbenp.prettier-vscode", "dbaeumer.vscode-eslint", "streetsidesoftware.code-spell-checker"]
+  "recommendations": [
+    "dbaeumer.vscode-eslint",
+    "editorconfig.editorconfig",
+    "esbenp.prettier-vscode",
+    "pflannery.vscode-versionlens",
+    "streetsidesoftware.code-spell-checker"
+  ]
 }

README.md

@@ -53,7 +53,7 @@ module.exports = defineConfig({
   root: true,
   rules: {
     // rules...
-  }
+  },
 });
 ```
 

scripts/generate-rule-files.ts

@@ -35,55 +35,49 @@ const PRETTIER_OPTIONS: Options = {
   plugins: [require.resolve('prettier-plugin-organize-imports')],
 
   parser: 'typescript',
-  arrowParens: 'always',
-  bracketSpacing: true,
-  printWidth: 120,
-  semi: true,
   singleQuote: true,
-  tabWidth: 2,
-  trailingComma: 'none',
-  useTabs: false
+  trailingComma: 'all',
 };
 
 const generationMap: Record<string, Plugin> = {
   eslint: {
     name: 'Eslint',
-    rules: Object.fromEntries(new eslint.Linter().getRules().entries())
+    rules: Object.fromEntries(new eslint.Linter().getRules().entries()),
   },
   'typescript-eslint': {
     name: 'TypeScript',
     prefix: '@typescript-eslint',
-    rules: (eslintPluginTypeScript as Plugin).rules
+    rules: (eslintPluginTypeScript as Plugin).rules,
   },
   jsdoc: {
     name: 'JSDoc',
-    rules: (eslintPluginJSDoc as Plugin).rules
+    rules: (eslintPluginJSDoc as Plugin).rules,
   },
   node: {
     name: 'Node',
-    rules: (eslintPluginNode as Plugin).rules
+    rules: (eslintPluginNode as Plugin).rules,
   },
   spellcheck: {
     name: 'Spellcheck',
-    rules: (eslintPluginSpellcheck as Plugin).rules
+    rules: (eslintPluginSpellcheck as Plugin).rules,
   },
   unicorn: {
     name: 'Unicorn',
-    rules: (eslintPluginUnicorn as Plugin).rules
+    rules: (eslintPluginUnicorn as Plugin).rules,
   },
   vue: {
     name: 'Vue',
-    rules: (eslintPluginVue as Plugin).rules
+    rules: (eslintPluginVue as Plugin).rules,
   },
   'vue-i18n': {
     name: 'VueI18n',
     prefix: '@intlify/vue-i18n',
-    rules: (eslintPluginVueI18n as Plugin).rules
+    rules: (eslintPluginVueI18n as Plugin).rules,
   },
   'vue-pug-sfc': {
     name: 'VuePugSfc',
-    rules: (eslintPluginVuePugSfc as Plugin).rules
-  }
+    rules: (eslintPluginVuePugSfc as Plugin).rules,
+  },
 };
 
 // Generating rule files
@@ -106,62 +100,73 @@ async function main(): Promise<void> {
       try {
         const nestedDepth: number = ruleName.split('/').length;
 
-        const rulePath: string = path.resolve(ruleProviderDir, `${ruleName}.d.ts`);
-        let ruleContent: string = `import type { RuleConfig } from '${'../'.repeat(nestedDepth)}rule-config';`;
+        const rulePath: string = path.resolve(
+          ruleProviderDir,
+          `${ruleName}.d.ts`,
+        );
+        let ruleContent: string = `import type { RuleConfig } from '${'../'.repeat(
+          nestedDepth,
+        )}rule-config';`;
 
         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 seeDocLink: string = meta?.docs?.url
+          ? `@see [${ruleName}](${meta.docs.url})`
+          : '';
 
         const deprecated: boolean | undefined = meta?.deprecated;
 
         const schema: JSONSchema4 | JSONSchema4[] | undefined = meta?.schema;
         const schemaIsObject: boolean = !Array.isArray(schema);
-        const mainSchema: JSONSchema4 | undefined = Array.isArray(schema) ? schema[0] : 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;
+          schema && Array.isArray(schema) && schema.length > 1
+            ? schema[1]
+            : undefined;
         const thirdSchema: JSONSchema4 | undefined =
-          schema && Array.isArray(schema) && schema.length > 2 ? schema[2] : 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
+              const ruleSetting: string = await compile(
+                thirdSchema,
+                `${ruleNamePascalCase}Setting`,
+                {
+                  bannerComment: '',
+                  style: {
+                    singleQuote: true,
+                    trailingComma: 'all',
+                  },
+                  unknownAny: false,
                 },
-                unknownAny: false
-              });
+              );
               ruleContent += `
 
 /**
  * Setting.
  */
 ${ruleSetting}`;
             }
-            const ruleConfig: string = await compile(sideSchema, `${ruleNamePascalCase}Config`, {
-              bannerComment: '',
-              style: {
-                bracketSpacing: true,
-                printWidth: 120,
-                semi: true,
-                singleQuote: true,
-                tabWidth: 2,
-                trailingComma: 'none',
-                useTabs: false
+            const ruleConfig: string = await compile(
+              sideSchema,
+              `${ruleNamePascalCase}Config`,
+              {
+                bannerComment: '',
+                style: {
+                  singleQuote: true,
+                  trailingComma: 'all',
+                },
+                unknownAny: false,
               },
-              unknownAny: false
-            });
+            );
             ruleContent += `
 
 /**
@@ -170,19 +175,18 @@ ${ruleSetting}`;
 ${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
+          const ruleOption: string = await compile(
+            mainSchema,
+            `${ruleNamePascalCase}Option`,
+            {
+              bannerComment: '',
+              style: {
+                singleQuote: true,
+                trailingComma: 'all',
+              },
+              unknownAny: false,
             },
-            unknownAny: false
-          });
+          );
 
           ruleContent += `
 
@@ -199,7 +203,9 @@ export type ${ruleNamePascalCase}Options = ${
               ? `${ruleNamePascalCase}Option`
               : `[${ruleNamePascalCase}Option?${
                   sideSchema
-                    ? `, ${ruleNamePascalCase}Config?${thirdSchema ? `, ${ruleNamePascalCase}Setting?` : ''}`
+                    ? `, ${ruleNamePascalCase}Config?${
+                        thirdSchema ? `, ${ruleNamePascalCase}Setting?` : ''
+                      }`
                     : ''
                 }]`
           };`;
@@ -220,7 +226,9 @@ export type ${ruleNamePascalCase}Options = ${
    *
    * ${seeDocLink}
    */
-  export type ${ruleNamePascalCase}RuleConfig = RuleConfig<${mainSchema ? `${ruleNamePascalCase}Options` : '[]'}>;
+  export type ${ruleNamePascalCase}RuleConfig = RuleConfig<${
+          mainSchema ? `${ruleNamePascalCase}Options` : '[]'
+        }>;
 
   /**
    * ${description}${
@@ -254,13 +262,19 @@ export type ${ruleNamePascalCase}Options = ${
         if (nestedDepth > 1) {
           const subPath: string = rulePath.replace(/\/[\w-]+.d.ts$/, '');
           if (!fs.existsSync(subPath)) {
-            fs.mkdirSync(rulePath.replace(/\/[\w-]+.d.ts$/, ''), { recursive: true });
+            fs.mkdirSync(rulePath.replace(/\/[\w-]+.d.ts$/, ''), {
+              recursive: true,
+            });
           }
         }
         fs.writeFileSync(rulePath, ruleContent);
       } catch (error) {
         if (error instanceof Error) {
-          console.error(`Failed to generate rule '${ruleName}' for ${name}.\n`, error.stack, '\n');
+          console.error(
+            `Failed to generate rule '${ruleName}' for ${name}.\n`,
+            error.stack,
+            '\n',
+          );
         }
         failedRules.push(ruleName);
       }
@@ -270,7 +284,9 @@ export type ${ruleNamePascalCase}Options = ${
     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}';`)
+      .map(
+        (name) => `import type { ${pascalCase(name)}Rule } from './${name}';`,
+      )
       .join('\n');
 
     indexContent += `

scripts/generate-rule.js

@@ -29,15 +29,20 @@ function normalizeRuleProvider(provider) {
 
 console.log({ ruleName, ruleProvider });
 
-const ruleProviderDir = path.resolve(rulesDir, normalizeRuleProvider(ruleProvider));
+const ruleProviderDir = path.resolve(
+  rulesDir,
+  normalizeRuleProvider(ruleProvider),
+);
 const rulePath = path.resolve(ruleProviderDir, `${ruleName}.d.ts`);
 
 /**
  * @param {string} name
  * @param {string} provider
  */
 function generateRuleFileContent(name, provider) {
-  const PascalCase = name.replace(/(\w)(\w*)/g, (_, g1, g2) => g1.toUpperCase() + g2.toLowerCase()).replace(/-/g, '');
+  const PascalCase = name
+    .replace(/(\w)(\w*)/g, (_, g1, g2) => g1.toUpperCase() + g2.toLowerCase())
+    .replace(/-/g, '');
   const kebabCase = name;
 
   let RuleLink = '<RuleLink>';

src/extends/eslint-plugin-import.d.ts

@@ -3,4 +3,7 @@
  *
  * @see [Eslint import extensions](https://github.com/benmosher/eslint-plugin-import#installation)
  */
-export type ImportExtensions = 'plugin:import/errors' | 'plugin:import/warnings' | 'plugin:import/typescript';
+export type ImportExtensions =
+  | 'plugin:import/errors'
+  | 'plugin:import/warnings'
+  | 'plugin:import/typescript';

src/extends/eslint-plugin-unicorn.d.ts

@@ -3,4 +3,6 @@
  *
  * @see [Eslint Unicorn extensions](https://github.com/sindresorhus/eslint-plugin-unicorn)
  */
-export type UnicornExtensions = 'plugin:unicorn/recommended' | 'plugin:unicorn/all';
+export type UnicornExtensions =
+  | 'plugin:unicorn/recommended'
+  | 'plugin:unicorn/all';

src/index.d.ts

@@ -39,7 +39,10 @@ export interface EslintConfig {
    *
    * @see [Globals](https://eslint.org/docs/user-guide/configuring/language-options#specifying-globals)
    */
-  globals?: Record<string, 'readonly' | 'writable' | false | 'readable' | true | 'writeable' | 'off'>;
+  globals?: Record<
+    string,
+    'readonly' | 'writable' | false | 'readable' | true | 'writeable' | 'off'
+  >;
   /**
    * Parser.
    *