Fix lint warnings

Author: Shinigami92

scripts/generate-rule-files/cli.ts

@@ -1,6 +1,6 @@
 import { run } from '.';
 
-const selectedPlugins = process.argv
+const selectedPlugins: string[] | undefined = process.argv
   .slice(2)
   .find((arg) => arg.startsWith('--plugins='))
   ?.replace('--plugins=', '')

scripts/generate-rule-files/index.ts

@@ -1,7 +1,7 @@
 import { logger } from '@poppinss/cliui';
 import { pascalCase } from 'change-case';
 import type { Rule } from 'eslint';
-import * as fs from 'node:fs';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import dedent from 'ts-dedent';
 import type { Plugin } from './contracts';
@@ -19,40 +19,40 @@ function generateRuleIndexFile(
   { rules, name }: Plugin,
   failedRules: string[],
 ): void {
-  const generatedRules = Object.keys(rules).filter(
+  const generatedRules: string[] = Object.keys(rules).filter(
     (ruleName) => !failedRules.includes(ruleName),
   );
 
   /**
    * Build all the import statements for the rules
    */
-  const rulesImports = generatedRules
+  const rulesImports: string = generatedRules
     .map((name) => `import type { ${pascalCase(name)}Rule } from './${name}';`)
     .join('\n');
 
   /**
    * Build the exported type that is an intersection of all the rules
    */
-  const rulesFinalIntersection = generatedRules
+  const rulesFinalIntersection: string = generatedRules
     .map((name) => `${pascalCase(name)}Rule`)
     .join(' & ');
 
-  const pluginRulesType = dedent(`
+  const pluginRulesType: string = dedent(`
     ${JsDocBuilder.build().add(`All ${name} rules.`).output()}
     export type ${name}Rules = ${rulesFinalIntersection};
   `);
 
   /**
    * Write the final index.d.ts file
    */
-  const fileContent = dedent(`
+  const fileContent: string = dedent(`
     ${rulesImports}
 
     ${pluginRulesType}
   `);
 
-  const indexPath = join(pluginDirectory, 'index.d.ts');
-  fs.writeFileSync(indexPath, format(fileContent));
+  const indexPath: string = join(pluginDirectory, 'index.d.ts');
+  writeFileSync(indexPath, format(fileContent));
 }
 
 /**
@@ -62,7 +62,9 @@ function printGenerationReport(
   rules: [string, Rule.RuleModule][],
   failedRules: string[],
 ): void {
-  const msg = `  ✅ Generated ${rules.length - failedRules.length} rules`;
+  const msg: string = `  ✅ Generated ${
+    rules.length - failedRules.length
+  } rules`;
   logger.logUpdate(logger.colors.green(msg));
   logger.logUpdatePersist();
 
@@ -81,11 +83,16 @@ async function generateRulesFiles(
 ): Promise<{ failedRules: string[] }> {
   const failedRules: string[] = [];
 
-  const rules = Object.entries(plugin.rules);
+  const rules: Array<[string, Rule.RuleModule]> = Object.entries(plugin.rules);
   for (const [ruleName, rule] of rules) {
     logger.logUpdate(logger.colors.yellow(`  Generating > ${ruleName}`));
 
-    const ruleFile = new RuleFile(plugin, pluginDirectory, ruleName, rule);
+    const ruleFile: RuleFile = new RuleFile(
+      plugin,
+      pluginDirectory,
+      ruleName,
+      rule,
+    );
     try {
       await ruleFile.generate();
       ruleFile.writeGeneratedContent();
@@ -106,34 +113,43 @@ function createPluginDirectory(
   pluginName: string,
   targetDirectory?: string,
 ): string {
-  const rulesDirectory = join(__dirname, targetDirectory || '../../src/rules');
-  const pluginDirectory = join(rulesDirectory, pluginName);
+  const rulesDirectory: string = join(
+    __dirname,
+    targetDirectory ?? '../../src/rules',
+  );
+  const pluginDirectory: string = join(rulesDirectory, pluginName);
 
-  if (fs.existsSync(pluginDirectory)) {
-    fs.rmSync(pluginDirectory, { recursive: true, force: true });
+  if (existsSync(pluginDirectory)) {
+    rmSync(pluginDirectory, { recursive: true, force: true });
   }
 
-  fs.mkdirSync(pluginDirectory, { mode: 0o755, recursive: true });
+  mkdirSync(pluginDirectory, { mode: 0o755, recursive: true });
   return pluginDirectory;
 }
 
-export async function run(options?: {
-  plugins?: string[];
-  targetDirectory?: string;
-}): Promise<void> {
-  const { plugins, targetDirectory } = options || {};
-  const wantedPlugins = plugins ?? Object.keys(pluginsMap);
+export async function run(
+  options: {
+    plugins?: string[];
+    targetDirectory?: string;
+  } = {},
+): Promise<void> {
+  const { plugins, targetDirectory } = options;
+
+  const wantedPlugins: string[] = plugins ?? Object.keys(pluginsMap);
 
   for (const pluginName of wantedPlugins) {
-    const plugin = pluginsMap[pluginName]!;
+    const plugin: Plugin = pluginsMap[pluginName]!;
 
     if (!plugin) {
       throw new Error(`Plugin ${pluginName} doesn't exist`);
     }
 
     logger.info(`Generating ${plugin.name} rules`);
 
-    const pluginDir = createPluginDirectory(pluginName, targetDirectory);
+    const pluginDir: string = createPluginDirectory(
+      pluginName,
+      targetDirectory,
+    );
     const { failedRules } = await generateRulesFiles(plugin, pluginDir);
 
     generateRuleIndexFile(pluginDir, plugin, failedRules);

scripts/generate-rule-files/src/format.ts

@@ -14,6 +14,6 @@ const PRETTIER_OPTIONS: Options = {
 /**
  * Format the given content with Prettier.
  */
-export const format = (content: string): string => {
+export function format(content: string): string {
   return prettierFormat(content, PRETTIER_OPTIONS);
-};
+}

scripts/generate-rule-files/src/json-schema-to-ts.ts

@@ -6,7 +6,7 @@ import { compile } from 'json-schema-to-typescript';
  * and that we don't need
  */
 function removeGarbageFromJsDocs(content: string): string {
-  const patterns = [
+  const patterns: RegExp[] = [
     /\* This interface was referenced by .+ JSON-Schema definition/,
     /\* via the `.+` "/,
   ];
@@ -24,7 +24,7 @@ export async function generateTypeFromSchema(
   schema: JSONSchema4,
   typeName: string,
 ): Promise<string> {
-  const result = await compile(schema, typeName, {
+  const result: string = await compile(schema, typeName, {
     format: false,
     bannerComment: '',
     style: { singleQuote: true, trailingComma: 'all' },

scripts/generate-rule-files/src/rule-file.ts

@@ -10,7 +10,7 @@ import { JsDocBuilder } from './js-doc-builder';
 import { generateTypeFromSchema } from './json-schema-to-ts';
 
 export class RuleFile {
-  private content = '';
+  private content: string = '';
   private readonly rulePath: string;
   private readonly ruleNamePascalCase: string;
 
@@ -31,7 +31,9 @@ export class RuleFile {
   }
 
   private assignSchemasInfo(): void {
-    const schema = this.rule.meta?.schema;
+    const schema: JSONSchema4 | JSONSchema4[] | undefined =
+      this.rule.meta?.schema;
+    // eslint-disable-next-line @typescript-eslint/typedef
     const isArray = Array.isArray(schema);
 
     this.mainSchema = isArray ? schema[0] : schema;
@@ -44,8 +46,9 @@ export class RuleFile {
    * Append the `import type { RuleConfig } at the top of the file
    */
   public appendRuleConfigImport(): void {
-    const nestedDepth = this.ruleName.split('/').length;
-    const ruleConfigImportPath = '../'.repeat(nestedDepth) + 'rule-config';
+    const nestedDepth: number = this.ruleName.split('/').length;
+    const ruleConfigImportPath: string =
+      '../'.repeat(nestedDepth) + 'rule-config';
     this.content += `import type { RuleConfig } from '${ruleConfigImportPath}'\n\n`;
   }
 
@@ -96,12 +99,12 @@ export class RuleFile {
     schema: JSONSchema4,
     comment: string,
   ): Promise<void> {
-    const type = await generateTypeFromSchema(
+    const type: string = await generateTypeFromSchema(
       schema,
       this.ruleNamePascalCase + comment,
     );
 
-    const jsdoc = JsDocBuilder.build().add(`${comment}.`).output();
+    const jsdoc: string = JsDocBuilder.build().add(`${comment}.`).output();
     this.content += `\n${jsdoc}`;
     this.content += `\n${type}\n`;
   }
@@ -127,9 +130,9 @@ export class RuleFile {
    * Append the rule type options to the file content
    */
   private appendRuleOptions(): void {
-    const ruleName = this.ruleNamePascalCase;
+    const ruleName: string = this.ruleNamePascalCase;
 
-    let type = '';
+    let type: string = '';
     if (!this.isSchemaArray) {
       type = `${ruleName}Option`;
     } else if (this.thirdSchema) {
@@ -148,8 +151,10 @@ export class RuleFile {
    * Append the rule config type to the file content
    */
   private appendRuleConfig(): void {
-    const ruleName = this.ruleNamePascalCase;
-    const genericContent = this.mainSchema ? `${ruleName}Options` : '[]';
+    const ruleName: string = this.ruleNamePascalCase;
+    const genericContent: string = this.mainSchema
+      ? `${ruleName}Options`
+      : '[]';
 
     this.content += this.generateTypeJsDoc() + '\n';
     this.content += `export type ${ruleName}RuleConfig = RuleConfig<${genericContent}>;\n\n`;
@@ -159,9 +164,9 @@ export class RuleFile {
    * Append the final rule interface to the file content
    */
   private appendRule(): void {
-    const ruleName = this.ruleNamePascalCase;
+    const ruleName: string = this.ruleNamePascalCase;
     const { prefix, name } = this.plugin;
-    let rulePrefix = (prefix ?? kebabCase(name)) + '/';
+    let rulePrefix: string = (prefix ?? kebabCase(name)) + '/';
     if (name === 'Eslint') {
       rulePrefix = '';
     }
@@ -178,7 +183,7 @@ export class RuleFile {
    * Create the directory of the rule file if it doesn't exist
    */
   private createRuleDirectory(): void {
-    const subPath = dirname(this.rulePath.toLowerCase());
+    const subPath: string = dirname(this.rulePath.toLowerCase());
     if (!existsSync(subPath)) {
       mkdirSync(subPath, { recursive: true });
     }

tests/generate-rule-files.test.ts

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 
+import type { Rule } from 'eslint';
 import { describe, expect, it } from 'vitest';
 import { generateTypeFromSchema } from '../scripts/generate-rule-files/src/json-schema-to-ts';
 import { RuleFile } from '../scripts/generate-rule-files/src/rule-file';
 
 describe('Json schema to ts', () => {
   it('Should remove garbage comments', async () => {
-    const result = await generateTypeFromSchema(
+    const result: string = await generateTypeFromSchema(
       {
         type: 'object',
         properties: {
@@ -30,29 +31,29 @@ describe('Json schema to ts', () => {
 
 describe('Rule File', () => {
   it('Main schema', async () => {
-    const rule = {
+    const rule: Rule.RuleModule = {
       meta: {
         docs: {
           description: 'My rule description',
           url: 'http://test.com/my-rule',
         },
         schema: [{ type: 'integer', minimum: 0 }],
       },
-    };
+    } as Rule.RuleModule;
 
-    const ruleFile = new RuleFile(
+    const ruleFile: RuleFile = new RuleFile(
       { name: 'my-plugin', rules: {} },
       'my-plugin',
       'my-rule',
-      rule as any,
+      rule,
     );
 
-    const content = await ruleFile.generate();
+    const content: string = await ruleFile.generate();
     expect(content).toMatchSnapshot();
   });
 
   it('Two schemas', async () => {
-    const rule = {
+    const rule: Rule.RuleModule = {
       meta: {
         docs: {
           description: 'My rule description',
@@ -63,21 +64,21 @@ describe('Rule File', () => {
           { type: 'string', minLength: 1 },
         ],
       },
-    };
+    } as Rule.RuleModule;
 
-    const ruleFile = new RuleFile(
+    const ruleFile: RuleFile = new RuleFile(
       { name: 'my-plugin', rules: {} },
       'my-plugin',
       'my-rule',
-      rule as any,
+      rule,
     );
 
-    const content = await ruleFile.generate();
+    const content: string = await ruleFile.generate();
     expect(content).toMatchSnapshot();
   });
 
   it('Three schemas', async () => {
-    const rule = {
+    const rule: Rule.RuleModule = {
       meta: {
         docs: {
           description: 'My rule description',
@@ -89,21 +90,21 @@ describe('Rule File', () => {
           { type: 'boolean' },
         ],
       },
-    };
+    } as Rule.RuleModule;
 
-    const ruleFile = new RuleFile(
+    const ruleFile: RuleFile = new RuleFile(
       { name: 'my-plugin', rules: {} },
       'my-plugin',
       'my-rule',
       rule as any,
     );
 
-    const content = await ruleFile.generate();
+    const content: string = await ruleFile.generate();
     expect(content).toMatchSnapshot();
   });
 
   it('Object schema', async () => {
-    const rule = {
+    const rule: Rule.RuleModule = {
       meta: {
         docs: {
           description: 'My rule description',
@@ -113,16 +114,16 @@ describe('Rule File', () => {
           type: 'object',
         },
       },
-    };
+    } as Rule.RuleModule;
 
-    const ruleFile = new RuleFile(
+    const ruleFile: RuleFile = new RuleFile(
       { name: 'my-plugin', rules: {} },
       'my-plugin',
       'my-rule',
       rule as any,
     );
 
-    const content = await ruleFile.generate();
+    const content: string = await ruleFile.generate();
     expect(content).toMatchSnapshot();
   });
 });