@w5s/eslint-config 3.6.0 → 3.7.0

package/src/config/e18e.ts

@@ -0,0 +1,71 @@
+import { interopDefault } from '@w5s/dev';
+import { StylisticConfig, type Config, type PluginOptionsBase } from '../type.js';
+import type { RuleOptions } from '../typegen/e18e.js';
+import { sourceGlob } from '../glob.js';
+
+const defaultFiles = [sourceGlob];
+
+/**
+ * @see https://e18e.dev
+ * @param options
+ */
+export async function e18e(options: e18e.Options = {}) {
+  const [e18ePlugin] = await Promise.all([interopDefault(import('@e18e/eslint-plugin'))] as const);
+  const { files = defaultFiles, rules = {}, stylistic = true, modernization = true, moduleReplacements = false, performanceImprovements = true } = options;
+  const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
+
+  return [
+    {
+      name: 'w5s/e18e/setup',
+      plugins: {
+        e18e: e18ePlugin,
+      },
+    },
+    {
+      name: 'w5s/e18e/rules',
+      files,
+      rules: {
+        ...modernization ? e18ePlugin.configs.modernization.rules : {},
+        ...moduleReplacements ? e18ePlugin.configs.moduleReplacements.rules : {},
+        ...performanceImprovements ? e18ePlugin.configs.performanceImprovements.rules : {},
+
+        // Disable dangerous (also prefer unicorn)
+        'e18e/prefer-array-from-map': 'off',
+        'e18e/prefer-array-to-reversed': 'off',
+        'e18e/prefer-array-to-sorted': 'off',
+        'e18e/prefer-array-to-spliced': 'off',
+        'e18e/prefer-spread-syntax': 'off',
+
+        ...(stylisticEnabled ? {} : {}),
+        ...rules,
+      },
+    },
+  ] as [Config, Config] satisfies Array<Config>;
+}
+
+export namespace e18e {
+  export type Rules = RuleOptions;
+
+  export interface Options extends PluginOptionsBase<Rules> {
+    /**
+     * Include modernization default configuration
+     *
+     * @default true
+     */
+    modernization?: boolean;
+
+    /**
+     * Include moduleReplacements default configuration
+     *
+     * @default false
+     */
+    moduleReplacements?: boolean;
+
+    /**
+     * Include performanceImprovements default configuration
+     *
+     * @default true
+     */
+    performanceImprovements?: boolean;
+  }
+}

package/src/config/es.ts

@@ -9,7 +9,7 @@ import { esSourceGlob } from '../glob.js';
 const defaultFiles = [esSourceGlob];
 
 export async function es(options: es.Options) {
-  const { rules = {} } = options;
+  const { recommended = true, rules = {} } = options;
 
   return [
     {
@@ -44,14 +44,21 @@ export async function es(options: es.Options) {
       name: 'w5s/es/rules',
       files: defaultFiles,
       rules: {
-        ...eslintConfig.configs.recommended.rules,
-        ...esRules(),
+        ...(recommended ? es['recommended'] : {}),
         ...rules,
       },
     },
   ] as [Config, Config] satisfies Array<Config>;
 }
 
+/**
+ * Recommended rules
+ */
+es['recommended'] = {
+  ...eslintConfig.configs.recommended.rules,
+  ...esRules(),
+};
+
 export namespace es {
   export type Rules = RuleOptions;
 

package/src/config/imports.ts

@@ -3,7 +3,7 @@ import { type PluginOptionsBase, StylisticConfig, type Config } from '../type.js
 import type { RuleOptions } from '../typegen/import.js';
 
 export async function imports(options: imports.Options = {}) {
-  const { rules = {}, stylistic = true } = options;
+  const { rules = {}, recommended = true, stylistic = true } = options;
   const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
   const [importPlugin] = await Promise.all([interopDefault(import('eslint-plugin-import'))] as const);
   return [
@@ -13,17 +13,9 @@ export async function imports(options: imports.Options = {}) {
         import: importPlugin,
       },
       rules: {
-        // 'import/consistent-type-specifier-style': ['error', 'prefer-inline'],
-        'import/first': 'error',
-        'import/no-duplicates': 'error',
-        'import/no-mutable-exports': 'error',
-        'import/no-named-default': 'error',
-
+        ...(recommended ? imports['recommended'] : {}),
         ...(stylisticEnabled
-          ? {
-              // Stylistic rules
-              'import/newline-after-import': ['error', { count: 1 }],
-            }
+          ? imports['stylistic']
           : {}),
         ...rules,
       },
@@ -31,6 +23,24 @@ export async function imports(options: imports.Options = {}) {
   ] as [Config] satisfies Array<Config>;
 }
 
+/**
+ * Recommended rules
+ */
+imports['recommended'] = {
+  // 'import/consistent-type-specifier-style': ['error', 'prefer-inline'],
+  'import/first': 'error',
+  'import/no-duplicates': 'error',
+  'import/no-mutable-exports': 'error',
+  'import/no-named-default': 'error',
+};
+
+/**
+ * Stylistic rules
+ */
+imports['stylistic'] = {
+  'import/newline-after-import': ['error', { count: 1 }],
+};
+
 export namespace imports {
   export type Rules = RuleOptions;
 

package/src/config/jsdoc.ts

@@ -7,7 +7,12 @@ const defaultFiles = [sourceGlob];
 
 export async function jsdoc(options: jsdoc.Options = {}): Promise<readonly Config[]> {
   const [jsdocPlugin] = await Promise.all([interopDefault(import('eslint-plugin-jsdoc'))] as const);
-  const { files = defaultFiles, rules = {}, stylistic = true } = options;
+  const {
+    files = defaultFiles,
+    recommended = true,
+    rules = {},
+    stylistic = true,
+  } = options;
   const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
 
   return [
@@ -21,14 +26,20 @@ export async function jsdoc(options: jsdoc.Options = {}): Promise<readonly Confi
       name: 'w5s/jsdoc/rules',
       files,
       rules: {
-        ...jsdocPlugin.configs['flat/recommended-typescript-flavor'].rules,
-        'jsdoc/no-undefined-types': 'off', // https://github.com/gajus/eslint-plugin-jsdoc/issues/839
-        'jsdoc/require-hyphen-before-param-description': ['warn', 'always'],
-        'jsdoc/require-jsdoc': 'off',
-        'jsdoc/require-param-description': 'off',
-        'jsdoc/require-param-type': 'off',
-        'jsdoc/require-returns': 'off',
-        'jsdoc/valid-types': 'off', // FIXME: reports lots of false positive
+        ...(recommended ? jsdocPlugin.configs['flat/recommended-typescript-flavor'].rules : {}),
+
+        ...(recommended
+          ? {
+              'jsdoc/no-undefined-types': 'off', // https://github.com/gajus/eslint-plugin-jsdoc/issues/839
+              'jsdoc/require-hyphen-before-param-description': ['warn', 'always'],
+              'jsdoc/require-jsdoc': 'off',
+              'jsdoc/require-param-description': 'off',
+              'jsdoc/require-param-type': 'off',
+              'jsdoc/require-returns': 'off',
+              'jsdoc/valid-types': 'off', // FIXME: reports lots of false positive
+            }
+          : {}),
+
         // 'strict': ['error', 'safe'],
         ...(stylisticEnabled
           ? {

package/src/config/jsonc.ts

@@ -11,7 +11,12 @@ export async function jsonc(options: jsonc.Options = {}): Promise<readonly Confi
     interopDefault(import('eslint-plugin-jsonc')),
     interopDefault(import('jsonc-eslint-parser')),
   ] as const);
-  const { files = defaultFiles, rules = {}, stylistic = true } = options;
+  const {
+    files = defaultFiles,
+    recommended = true,
+    rules = {},
+    stylistic = true,
+  } = options;
   const { enabled: stylisticEnabled, indent } = StylisticConfig.from(stylistic);
 
   return [
@@ -28,7 +33,7 @@ export async function jsonc(options: jsonc.Options = {}): Promise<readonly Confi
       },
       name: 'w5s/jsonc/rules',
       rules: {
-        ...jsoncPlugin.configs['flat/recommended-with-json'][0]?.rules,
+        ...(recommended ? jsoncPlugin.configs['flat/recommended-with-json'][0]?.rules : {}),
         ...(stylisticEnabled
           ? {
               'jsonc/array-bracket-spacing': ['error', 'never'],

package/src/config/markdown.ts

@@ -7,7 +7,13 @@ const defaultFiles = [`**/${Project.extensionsToGlob(Project.queryExtensions(['m
 
 export async function markdown(options: markdown.Options = {}) {
   const [markdownPlugin] = await Promise.all([interopDefault(import('@eslint/markdown'))] as const);
-  const { language = 'markdown/gfm', files = defaultFiles, rules = {}, stylistic = true } = options;
+  const {
+    language = 'markdown/gfm',
+    files = defaultFiles,
+    recommended = true,
+    rules = {},
+    stylistic = true,
+  } = options;
   const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
 
   return [
@@ -24,7 +30,7 @@ export async function markdown(options: markdown.Options = {}) {
       // eslint-disable-next-line ts/no-non-null-assertion
       processor: mergeProcessors([markdownPlugin.processors!.markdown, processorPassThrough]),
       rules: {
-        ...markdownPlugin.configs.recommended.at(0)?.rules,
+        ...(recommended ? markdownPlugin.configs.recommended.at(0)?.rules : {}),
         ...(stylisticEnabled ? {} : {}),
         ...rules,
       },

package/src/config/next.ts

@@ -0,0 +1,50 @@
+import { ESLintConfig, interopDefault } from '@w5s/dev';
+import { type Config, type PluginOptionsBase } from '../type.js';
+import type { RuleOptions } from '../typegen/next.js';
+import { sourceGlob } from '../glob.js';
+
+const defaultFiles = [sourceGlob];
+
+export async function next(options: next.Options = {}) {
+  const [nextPlugin] = await Promise.all([
+    interopDefault(import('@next/eslint-plugin-next')),
+  ] as const);
+  const { files = defaultFiles, recommended = true, rules = {} } = options;
+
+  return [
+    {
+      name: 'w5s/next/setup',
+      plugins: {
+        next: nextPlugin,
+      },
+    },
+    {
+      name: 'w5s/next/rules',
+      files,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+        sourceType: 'module',
+      },
+      settings: {
+        react: {
+          version: 'detect',
+        },
+      },
+      rules: {
+        ...(recommended ? ESLintConfig.renameRules(nextPlugin.configs.recommended.rules ?? {}, { '@next/next': 'next' }) : {}),
+        ...(recommended ? ESLintConfig.renameRules(nextPlugin.configs['core-web-vitals'].rules ?? {}, { '@next/next': 'next' }) : {}),
+        ...rules,
+      },
+    },
+  ] as [Config, Config] satisfies Array<Config>;
+}
+
+export namespace next {
+  export type Rules = RuleOptions;
+
+  export interface Options extends Omit<PluginOptionsBase<Rules>, 'stylistic'> {}
+}

package/src/config/node.ts

@@ -6,7 +6,7 @@ export async function node(options: node.Options = {}) {
   const [nodePlugin] = await Promise.all([
     interopDefault(import('eslint-plugin-n')),
   ] as const);
-  const { rules = {} } = options;
+  const { recommended, rules = {} } = options;
   return [
     {
       name: 'w5s/node/setup',
@@ -17,18 +17,23 @@ export async function node(options: node.Options = {}) {
     {
       name: 'w5s/node/rules',
       rules: {
-        // 'node/handle-callback-err': ['error', '^(err|error|_error)$'],
-        'node/no-deprecated-api': 'error',
-        'node/no-exports-assign': 'error',
-        'node/no-new-require': 'error',
-        'node/no-path-concat': 'error',
-        // 'node/no-sync': 'error', FIXME: this rule uses typing without a way to disable it, so it causes errors in JS files
-        'node/prefer-global/buffer': ['error', 'never'],
-        'node/prefer-global/console': ['error', 'always'],
-        // 'node/prefer-global/process': ['error', 'never'],
-        'node/prefer-global/url': ['error', 'always'],
-        'node/prefer-global/url-search-params': ['error', 'always'],
-        'node/process-exit-as-throw': 'error',
+        ...(recommended
+          ? {
+              // 'node/handle-callback-err': ['error', '^(err|error|_error)$'],
+              'node/no-deprecated-api': 'error',
+              'node/no-exports-assign': 'error',
+              'node/no-new-require': 'error',
+              'node/no-path-concat': 'error',
+              // 'node/no-sync': 'error', FIXME: this rule uses typing without a way to disable it, so it causes errors in JS files
+              'node/prefer-global/buffer': ['error', 'never'],
+              'node/prefer-global/console': ['error', 'always'],
+              // 'node/prefer-global/process': ['error', 'never'],
+              'node/prefer-global/url': ['error', 'always'],
+              'node/prefer-global/url-search-params': ['error', 'always'],
+              'node/process-exit-as-throw': 'error',
+            }
+          : {}),
+
         ...rules,
       },
     },

package/src/config/test.ts

@@ -1,4 +1,4 @@
-import { interopDefault, Project } from '@w5s/dev';
+import { ESLintConfig, interopDefault, Project } from '@w5s/dev';
 import { StylisticConfig, type PluginOptionsBase, type Config } from '../type.js';
 import type { RuleOptions } from '../typegen/test.js';
 
@@ -13,7 +13,7 @@ export async function test(options: test.Options = {}) {
   const [vitestPlugin] = await Promise.all([
     interopDefault(import('@vitest/eslint-plugin')),
   ] as const);
-  const { files = defaultFiles, rules = {}, stylistic = true } = options;
+  const { files = defaultFiles, recommended = true, rules = {}, stylistic = true } = options;
   const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
 
   return [
@@ -27,7 +27,14 @@ export async function test(options: test.Options = {}) {
       files,
       name: 'w5s/test/rules',
       rules: {
-        ...vitestPlugin.configs.recommended.rules,
+        ...(recommended
+          ? ESLintConfig.renameRules(vitestPlugin.configs.recommended.rules, {
+              vitest: 'test',
+            })
+          : {}),
+        'test/valid-title': ESLintConfig.fixme(undefined),
+
+        'e18e/prefer-static-regex': 'off',
         ...(stylisticEnabled
           ? {}
           : {}),

package/src/config/unicorn.ts

@@ -7,7 +7,7 @@ const defaultFiles = [sourceGlob];
 
 export async function unicorn(options: unicorn.Options = {}) {
   const [unicornPlugin] = await Promise.all([interopDefault(import('eslint-plugin-unicorn'))] as const);
-  const { files = defaultFiles, rules = {}, stylistic = true } = options;
+  const { files = defaultFiles, recommended = true, rules = {}, stylistic = true } = options;
   const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
 
   return [
@@ -21,7 +21,7 @@ export async function unicorn(options: unicorn.Options = {}) {
       name: 'w5s/unicorn/rules',
       files,
       rules: {
-        ...unicornPlugin.configs.recommended?.rules,
+        ...(recommended ? unicornPlugin.configs.recommended?.rules : {}),
         // Disabled for safety
         'unicorn/consistent-destructuring': 'off',
         'unicorn/consistent-function-scoping': 'off', // Too many false positive
@@ -39,7 +39,6 @@ export async function unicorn(options: unicorn.Options = {}) {
         'unicorn/no-object-as-default-parameter': 'off',
         'unicorn/no-process-exit': 'off',
         'unicorn/no-unreadable-array-destructuring': 'off',
-        'unicorn/no-unused-properties': 'warn',
         'unicorn/no-useless-undefined': 'off',
         'unicorn/prefer-add-event-listener': 'off',
         'unicorn/prefer-default-parameters': 'off',

package/src/config/yml.ts

@@ -7,7 +7,7 @@ const defaultFiles = [ymlSourceGlob];
 
 export async function yml(options: yml.Options = {}) {
   const [ymlPlugin] = await Promise.all([interopDefault(import('eslint-plugin-yml'))] as const);
-  const { files = defaultFiles, rules = {}, stylistic = true } = options;
+  const { files = defaultFiles, recommended = true, rules = {}, stylistic = true } = options;
   const { enabled: stylisticEnabled, indent, quotes } = StylisticConfig.from(stylistic);
 
   return [
@@ -22,11 +22,13 @@ export async function yml(options: yml.Options = {}) {
       language: 'yml/yaml',
       name: 'w5s/yml/rules',
       rules: {
-        ...ymlPlugin.configs['recommended'].reduce(
-          (acc, config) => ({ ...acc, ...config.rules }),
-          // eslint-disable-next-line ts/consistent-type-assertions
-          {} as RuleOptions,
-        ),
+        ...(recommended
+          ? ymlPlugin.configs['recommended'].reduce(
+              (acc, config) => ({ ...acc, ...config.rules }),
+              // eslint-disable-next-line ts/consistent-type-assertions
+              {} as RuleOptions,
+            )
+          : {}),
         ...(stylisticEnabled
           ? {
               'style/spaced-comment': 'off', // Fix

package/src/config.ts

@@ -1,9 +1,11 @@
+export * from './config/e18e.js';
 export * from './config/es.js';
 export * from './config/ignores.js';
 export * from './config/jsdoc.js';
 export * from './config/jsonc.js';
 export * from './config/imports.js';
 export * from './config/markdown.js';
+export * from './config/next.js';
 export * from './config/node.js';
 export * from './config/stylistic.js';
 export * from './config/test.js';

package/src/defineConfig.ts

@@ -1,15 +1,18 @@
 import { ESLintConfig } from '@w5s/dev';
-import { jsdoc, jsonc, ignores, imports, markdown, node, ts, yml, unicorn, stylistic, es } from './config.js';
+import { jsdoc, jsonc, ignores, imports, markdown, next, node, ts, yml, unicorn, stylistic, es, e18e, test } from './config.js';
 import type { Config } from './type.js';
 
 export interface DefineConfigOptions extends ignores.Options {
+  e18e?: boolean | e18e.Options;
   es?: boolean | es.Options;
   import?: boolean | imports.Options;
   markdown?: boolean | markdown.Options;
   jsdoc?: boolean | jsdoc.Options;
   jsonc?: boolean | jsonc.Options;
+  next?: boolean | next.Options;
   node?: boolean | node.Options;
   stylistic?: boolean | stylistic.Options;
+  test?: boolean | test.Options;
   ts?: boolean | ts.Options;
   unicorn?: boolean | unicorn.Options;
   yml?: boolean | yml.Options;
@@ -25,49 +28,23 @@ export async function defineConfig(options: DefineConfigOptions = {}) {
         ? { enabled: optionsOrBoolean }
         : { enabled: true, ...optionsOrBoolean }) as T & { enabled: boolean },
     );
-  const esOptions = toOption(options.es);
-  const importOptions = toOption(options.import);
-  const jsdocOptions = toOption(options.jsdoc);
-  const jsoncOptions = toOption(options.jsonc);
-  const markdownOptions = toOption(options.markdown);
-  const nodeOptions = toOption(options.node);
-  const tsOptions = toOption(options.ts);
-  const unicornOptions = toOption(options.unicorn);
-  const ymlOptions = toOption(options.yml);
+  const includeEnabled = <T extends { enabled?: boolean }, R extends Promise<readonly Config[]>>(factory: (config: T) => R, input: T) =>
+    input.enabled ? [factory(input)] : [];
 
-  const returnValue: Array<Promise<Array<Config>>> = [];
-  const append = (config: Promise<ReadonlyArray<any>>) => {
-    returnValue.push(config as any);
-  };
-  append(es(esOptions));
-  append(ignores(options));
-
-  if (jsoncOptions.enabled) {
-    append(jsonc(jsoncOptions));
-  }
-  if (jsdocOptions.enabled) {
-    append(jsdoc(jsdocOptions));
-  }
-  if (stylisticOptions.enabled) {
-    append(stylistic(stylisticOptions));
-  }
-  if (importOptions.enabled) {
-    append(imports(importOptions));
-  }
-  if (markdownOptions.enabled) {
-    append(markdown(markdownOptions));
-  }
-  if (nodeOptions.enabled) {
-    append(node(nodeOptions));
-  }
-  if (tsOptions.enabled) {
-    append(ts(tsOptions));
-  }
-  if (ymlOptions.enabled) {
-    append(yml(ymlOptions));
-  }
-  if (unicornOptions.enabled) {
-    append(unicorn(unicornOptions));
-  }
-  return ESLintConfig.concat(...returnValue);
+  return ESLintConfig.concat(
+    ...includeEnabled(e18e, toOption(options.e18e)),
+    ...includeEnabled(es, toOption(options.es)),
+    ...includeEnabled(ts, toOption(options.ts)),
+    ...includeEnabled(ignores, toOption(options)),
+    ...includeEnabled(jsonc, toOption(options.jsonc)),
+    ...includeEnabled(jsdoc, toOption(options.jsdoc)),
+    ...includeEnabled(stylistic, toOption(options.stylistic)),
+    ...includeEnabled(imports, toOption(options.import)),
+    ...includeEnabled(markdown, toOption(options.markdown)),
+    ...includeEnabled(next, toOption(options.next)),
+    ...includeEnabled(node, toOption(options.node)),
+    ...includeEnabled(unicorn, toOption(options.unicorn)),
+    ...includeEnabled(yml, toOption(options.yml)),
+    ...includeEnabled(test, toOption(options.test)),
+  );
 }

package/src/type/PluginOptionsBase.ts

@@ -9,6 +9,11 @@ export interface PluginOptionsBase<Rules> {
    */
   rules?: Rules;
 
+  /**
+   * Include recommended settings
+   */
+  recommended?: boolean;
+
   /**
    * Stylistic options
    */