Autofix lint warnings

Author: matejchalk

scripts/docs.js

@@ -149,10 +149,10 @@ async function generateConfigDocs(config, allConfigs, peerDeps) {
       return [otherName, otherRuleIds];
     }),
   );
-  const extendedRuleIds = Object.values(extendedConfigs).flat();
+  const extendedRuleIds = new Set(Object.values(extendedConfigs).flat());
 
   const ruleIds = getAllEnabledRuleIds(config.flatConfig).filter(
-    ruleId => !extendedRuleIds.includes(ruleId),
+    ruleId => !extendedRuleIds.has(ruleId),
   );
 
   const eslint = new ESLint();
@@ -194,7 +194,7 @@ async function generateConfigDocs(config, allConfigs, peerDeps) {
         id,
       );
       const testLevel =
-        testEntry != null ? ruleLevelFromEntry(testEntry) : null;
+        testEntry == null ? null : ruleLevelFromEntry(testEntry);
 
       return {
         id,

scripts/helpers/configs.js

@@ -58,13 +58,13 @@ const configExtraPatterns = {
 };
 
 /** @type {(keyof typeof configDescriptions)[]} */
-const testConfigs = [
+const testConfigs = new Set([
   'jest',
   'vitest',
   'cypress',
   'playwright',
   'react-testing-library',
-];
+]);
 
 const tsConfigDocsReference = md`Refer to ${md.link('./typescript.md#🏗️-setup', "step 3 in TypeScript config's setup docs")} for how to set up tsconfig properly.`;
 
@@ -280,7 +280,7 @@ export function configExtraPattern(name) {
  */
 export function isConfigForTests(name) {
   // @ts-expect-error the point is to check if string is a union
-  return testConfigs.includes(name);
+  return testConfigs.has(name);
 }
 
 /**

scripts/helpers/format-config.js

@@ -235,7 +235,7 @@ function optionsPreview(options) {
  */
 function truncate(text, max) {
   if (text.length > max) {
-    return text.slice(0, max - 3) + '...';
+    return `${text.slice(0, max - 3)  }...`;
   }
   return text;
 }
@@ -244,5 +244,5 @@ function truncate(text, max) {
  * @param {string} content
  */
 function sanitizeRuleOptions(content) {
-  return content.replace(/\\/g, '\\\\').replace(/\*/g, '\\*');
+  return content.replace(/\\/g, '\\\\').replace(/\*/g, String.raw`\*`);
 }

scripts/helpers/format-readme.js

@@ -131,10 +131,10 @@ function mermaidDiagram(nodes, edges, orientation = 'TD') {
       .map(node => `    ${node.id}("${node.label}")`),
     ...edges.map(
       edge =>
-        '    ' +
+        `    ${ 
         [edge.from, edge.label ? `--${edge.label}-->` : '-->', edge.to].join(
           ' ',
-        ),
+        )}`,
     ),
   ].join('\n');
 }

src/configs/vitest.js

@@ -38,7 +38,7 @@ export default tseslint.config({
         // https://github.com/veritem/eslint-plugin-vitest#rules
         'vitest/consistent-test-filename': [
           'warn',
-          { pattern: '.*\\.spec\\.[tj]sx?$' },
+          { pattern: String.raw`.*\.spec\.[tj]sx?$` },
         ],
         'vitest/consistent-test-it': 'warn',
         'vitest/max-nested-describe': ['warn', { max: 2 }],

src/lib/utils.js

@@ -6,11 +6,7 @@
  * @returns {import('eslint').Linter.RulesRecord}
  */
 export function convertErrorsToWarnings(rules) {
-  return Object.entries(rules).reduce(
-    (acc, [ruleId, entry]) => ({
-      ...acc,
-      [ruleId]: entry === 'error' || entry === 2 ? 'warn' : entry,
-    }),
-    {},
-  );
+  return Object.fromEntries(Object.entries(rules).map(
+    ( [ruleId, entry]) => [ruleId, entry === 'error' || entry === 2 ? 'warn' : entry],
+  ));
 }

tests/configs/angular.spec.js

@@ -7,62 +7,63 @@ describe('angular config', () => {
   const { setup, teardown, loadConfig } = createLintUtils('angular');
 
   beforeAll(setup);
+
   afterAll(teardown);
 
-  test('should load config for TypeScript file', async () => {
+  it('should load config for TypeScript file', async () => {
     await expect(loadConfig('src/app/app.component.ts')).resolves.not.toThrow();
   });
 
-  test('should load config for HTML file', async () => {
+  it('should load config for HTML file', async () => {
     await expect(
       loadConfig('src/app/app.component.html'),
     ).resolves.not.toThrow();
   });
 
-  test('should not include template rules for non-HTML file', async () => {
+  it('should not include template rules for non-HTML file', async () => {
     const config = await loadConfig('src/app/app.component.ts');
     expect(Object.keys(config.rules ?? {}).join(',')).not.toContain(
       '@angular-eslint/template/',
     );
   });
 
-  test('should have explicitly added rule for TS file', async () => {
+  it('should have explicitly added rule for TS file', async () => {
     const config = await loadConfig('src/app/app.component.ts');
     expect(config.rules).toHaveProperty(
       '@angular-eslint/prefer-on-push-component-change-detection',
     );
   });
 
-  test('should have explicitly added rule for HTML file', async () => {
+  it('should have explicitly added rule for HTML file', async () => {
     const config = await loadConfig('src/app/app.component.html');
     expect(config.rules).toHaveProperty('@angular-eslint/template/no-any');
   });
 
-  test('should have rule from extended typescript config', async () => {
+  it('should have rule from extended typescript config', async () => {
     const config = await loadConfig('src/app/app.component.ts');
     expect(config.rules).toHaveProperty(
       '@typescript-eslint/no-non-null-assertion',
     );
   });
 
-  test('should have rule from extended recommended angular config', async () => {
+  it('should have rule from extended recommended angular config', async () => {
     const config = await loadConfig('src/app/app.component.ts');
     expect(config.rules).toHaveProperty('@angular-eslint/contextual-lifecycle');
   });
 
-  test('should have rule from extended recommended angular template config', async () => {
+  it('should have rule from extended recommended angular template config', async () => {
     const config = await loadConfig('src/app/app.component.html');
     expect(config.rules).toHaveProperty(
       '@angular-eslint/template/banana-in-box',
     );
   });
 
-  test('should have rule from extended angular template accessibility config', async () => {
+  it('should have rule from extended angular template accessibility config', async () => {
     const config = await loadConfig('src/app/app.component.html');
     expect(config.rules).toHaveProperty('@angular-eslint/template/alt-text');
   });
 
-  test('should have rule disabled if test file pattern matches', async () => {
+  it('should have rule disabled if test file pattern matches', async () => {
     const config = await loadConfig(
       'src/app/components/accordion/accordion.component.stories.ts',
     );

tests/configs/graphql.spec.js

@@ -10,28 +10,29 @@ describe('graphql config', () => {
   );
 
   beforeAll(setup);
+
   afterAll(teardown);
 
-  test('should have graphql plugin rules for GraphQL file', async () => {
+  it('should have graphql plugin rules for GraphQL file', async () => {
     const config = await loadConfig('src/schema.graphql');
     expect(Object.keys(config.rules ?? {}).join(',')).toContain(
       '@graphql-eslint/',
     );
   });
 
-  test('should have rule from extended schema config', async () => {
+  it('should have rule from extended schema config', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('@graphql-eslint/naming-convention');
   });
 
-  test('should have rule from extended relay config', async () => {
+  it('should have rule from extended relay config', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty(
       '@graphql-eslint/relay-connection-types',
     );
   });
 
-  test('should have customized rule', async () => {
+  it('should have customized rule', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('@graphql-eslint/description-style');
     expect(config.rules?.['@graphql-eslint/description-style']).toEqual([

tests/configs/javascript.spec.js

@@ -10,58 +10,59 @@ describe('javascript config', () => {
   );
 
   beforeAll(setup);
+
   afterAll(teardown);
 
-  test('should load config for JavaScript file', async () => {
+  it('should load config for JavaScript file', async () => {
     await expect(loadConfig('index.js')).resolves.not.toThrow();
   });
 
-  test('should load config for TypeScript file', async () => {
+  it('should load config for TypeScript file', async () => {
     await expect(loadConfig('src/utils.ts')).resolves.not.toThrow();
   });
 
-  test('should have explicitly added rule', async () => {
+  it('should have explicitly added rule', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('eqeqeq');
   });
 
-  test('should have implicitly extended rule', async () => {
+  it('should have implicitly extended rule', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('no-const-assign');
   });
 
-  test('should not include any rule which requires type checking', async () => {
+  it('should not include any rule which requires type checking', async () => {
     const rules = await loadRules();
     const rulesWithTypes = Object.entries(rules)
       .filter(([, meta]) => meta.docs?.['requiresTypeChecking'])
       .map(([ruleId]) => ruleId);
     expect(rulesWithTypes).toHaveLength(0);
   });
 
-  test('should have rule disabled if test file pattern matches', async () => {
+  it('should have rule disabled if test file pattern matches', async () => {
     const config = await loadConfig('utils.spec.js');
     expect(config.rules?.['@typescript-eslint/no-non-null-assertion']).toEqual([
       0,
     ]);
   });
 
-  test('should have rule disabled if known config file pattern matches', async () => {
+  it('should have rule disabled if known config file pattern matches', async () => {
     const config = await loadConfig('jest.config.ts');
     expect(config.rules?.['import/no-anonymous-default-export']).toEqual([0]);
   });
 
-  test('should have rule disabled if generated file pattern matches', async () => {
+  it('should have rule disabled if generated file pattern matches', async () => {
     const config = await loadConfig(
       'src/graphql/generated/introspection-result.ts',
     );
     expect(config.rules?.['unicorn/no-abusive-eslint-disable']).toEqual([0]);
   });
 
-  test('should not throw when linting project without tsconfig', async () => {
+  it('should not throw when linting project without tsconfig', async () => {
     await expect(lint(['*.js'])).resolves.not.toThrow();
   });
 
-  test('should only warn for all unicorn plugin rules', async () => {
+  it('should only warn for all unicorn plugin rules', async () => {
     const config = await loadConfig();
     const unicornErrorRules = Object.entries(config.rules ?? {})
       .filter(([ruleId]) => ruleId.startsWith('unicorn/'))

tests/configs/jest.spec.js

@@ -7,29 +7,30 @@ describe('jest config', () => {
   const { setup, teardown, loadConfig } = createLintUtils('jest', '*.spec.ts');
 
   beforeAll(setup);
+
   afterAll(teardown);
 
-  test('should not include jest rules for non-test file', async () => {
+  it('should not include jest rules for non-test file', async () => {
     const config = await loadConfig('lib/auth.ts');
     expect(Object.keys(config?.rules ?? {}).join(',')).not.toContain('jest/');
   });
 
-  test('should include jest rules for test file', async () => {
+  it('should include jest rules for test file', async () => {
     const config = await loadConfig('__test__/auth.spec.js');
     expect(Object.keys(config.rules ?? {}).join(',')).toContain('jest/');
   });
 
-  test('should have rule from extended recommended jest config', async () => {
+  it('should have rule from extended recommended jest config', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('jest/no-identical-title');
   });
 
-  test('should have explicitly added rule', async () => {
+  it('should have explicitly added rule', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('jest/no-test-return-statement');
   });
 
-  test('should have customized severity level for rule from extended config', async () => {
+  it('should have customized severity level for rule from extended config', async () => {
     const config = await loadConfig();
     expect(config.rules?.['jest/no-mocks-import']).toEqual([1]);
   });

tests/configs/ngrx.spec.js

@@ -7,27 +7,28 @@ describe('ngrx config', () => {
   const { setup, teardown, loadConfig } = createLintUtils('ngrx', '*.ts');
 
   beforeAll(setup);
+
   afterAll(teardown);
 
-  test('should load config for TypeScript file', async () => {
+  it('should load config for TypeScript file', async () => {
     await expect(
       loadConfig('src/app/store/auth.reducer.ts'),
     ).resolves.not.toThrow();
   });
 
-  test('should have explicitly added rule', async () => {
+  it('should have explicitly added rule', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('rxjs-x/no-unsafe-catch');
   });
 
-  test('should have rule from extended angular config', async () => {
+  it('should have rule from extended angular config', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty(
       '@angular-eslint/prefer-on-push-component-change-detection',
     );
   });
 
-  test('should have rule from extended recommended ngrx config', async () => {
+  it('should have rule from extended recommended ngrx config', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('@ngrx/good-action-hygiene');
   });

tests/configs/node.spec.js

@@ -10,23 +10,24 @@ describe('node config', () => {
   );
 
   beforeAll(setup);
+
   afterAll(teardown);
 
-  test('should load config for JavaScript file', async () => {
+  it('should load config for JavaScript file', async () => {
     await expect(loadConfig('src/utils.js')).resolves.not.toThrow();
   });
 
-  test('should have explicitly added rule', async () => {
+  it('should have explicitly added rule', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('n/prefer-promises/fs');
   });
 
-  test('should have rule from extended base config', async () => {
+  it('should have rule from extended base config', async () => {
     const config = await loadConfig();
     expect(config.rules).toHaveProperty('import/no-commonjs');
   });
 
-  test('should not include any rule which requires type checking', async () => {
+  it('should not include any rule which requires type checking', async () => {
     const rules = await loadRules();
     const rulesWithTypes = Object.entries(rules)
       .filter(([, meta]) => meta.docs?.['requiresTypeChecking'])