@w5s/eslint-config 2.4.4 → 3.0.0

package/src/config/test.ts

@@ -0,0 +1,44 @@
+import { interopDefault, Project } from '@w5s/dev';
+import { StylisticConfig, type PluginOptionsBase, type Config } from '../type.js';
+import type { RuleOptions } from '../typegen/test.js';
+
+const sourceGlob = Project.extensionsToGlob(Project.sourceExtensions());
+const defaultFiles = [
+  `**/__mocks__/**/${sourceGlob}`,
+  `**/__tests__/**/${sourceGlob}`,
+  `**/?(*.)+(spec|test)${sourceGlob.slice(1)}`,
+];
+
+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 { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
+
+  return [
+    {
+      name: 'w5s/test/setup',
+      plugins: {
+        test: vitestPlugin,
+      },
+    },
+    {
+      files,
+      name: 'w5s/test/rules',
+      rules: {
+        ...vitestPlugin.configs.recommended.rules,
+        ...(stylisticEnabled
+          ? {}
+          : {}),
+        ...rules,
+      },
+    },
+  ] as [Config, Config] satisfies Array<Config>;
+}
+
+export namespace test {
+  export type Rules = RuleOptions;
+
+  export interface Options extends PluginOptionsBase<Rules> {}
+}

package/src/config/ts.ts

@@ -0,0 +1,97 @@
+/* eslint-disable ts/no-non-null-assertion */
+import { ESLintConfig, interopDefault, Project } from '@w5s/dev';
+import { StylisticConfig, type PluginOptionsBase, type Config } from '../type.js';
+import type { RuleOptions } from '../typegen/ts.js';
+import { createRules } from './createRules.js';
+
+const defaultFiles = [`**/${Project.extensionsToGlob(Project.queryExtensions(['typescript', 'typescriptreact']))}`];
+
+export async function ts(options: ts.Options = {}) {
+  const [tsPlugin, tsParser] = await Promise.all([
+    interopDefault(import('@typescript-eslint/eslint-plugin')),
+    interopDefault(import('@typescript-eslint/parser')),
+  ] as const);
+  const tsRecommendedRules = tsPlugin.configs['eslint-recommended']!.overrides![0]!.rules!;
+  const tsStrictRules = tsPlugin.configs['strict']!.rules!;
+  const tsTypeCheckedRules = tsPlugin.configs['recommended-type-checked-only']!.rules!;
+  const { files = defaultFiles, rules = {}, stylistic = true, typeChecked = false } = options;
+  const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
+
+  return [
+    {
+      name: 'w5s/ts/setup',
+      plugins: {
+        ts: tsPlugin,
+      },
+    },
+    {
+      files,
+      languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+          sourceType: 'module',
+          // extraFileExtensions: componentExts.map(ext => `.${ext}`),
+          // ...typeAware
+          //   ? {
+          //       projectService: {
+          //         allowDefaultProject: ['./*.js'],
+          //         defaultProject: tsconfigPath,
+          //       },
+          //       tsconfigRootDir: process.cwd(),
+          //     }
+          //   : {},
+          // ...parserOptions as any,
+        },
+      },
+      name: 'w5s/ts/rules',
+      rules: {
+        ...ESLintConfig.renameRules(
+          tsRecommendedRules,
+          { '@typescript-eslint': 'ts' },
+        ),
+        ...ESLintConfig.renameRules(
+          tsStrictRules,
+          { '@typescript-eslint': 'ts' },
+        ),
+        'ts/ban-ts-comment': [
+          'warn',
+          {
+            'minimumDescriptionLength': 3,
+            'ts-check': false,
+            'ts-expect-error': 'allow-with-description',
+            'ts-ignore': 'allow-with-description',
+            'ts-nocheck': true,
+          },
+        ],
+        'ts/no-empty-object-type': 'off',
+        'ts/no-explicit-any': 'off', // if any is explicit then it's wanted
+        'ts/no-namespace': 'off', // We don't agree with community, namespaces are great and not deprecated
+        ...createRules('ts/'),
+        ...(stylisticEnabled
+          ? {}
+          : {}),
+        ...rules,
+      },
+    },
+    ...(typeChecked
+      ? [{
+          files: defaultFiles,
+          // ignores: ignoresTypeAware,
+          name: 'w5s/ts/rules-type-checked',
+          rules: {
+            ...ESLintConfig.renameRules(
+              tsTypeCheckedRules,
+              { '@typescript-eslint': 'ts' },
+            ),
+          },
+        }] as const
+      : []),
+  ] as ([Config, Config] | [Config, Config, Config]) satisfies Array<Config>;
+}
+export namespace ts {
+  export type Rules = RuleOptions;
+
+  export interface Options extends PluginOptionsBase<Rules> {
+    typeChecked?: boolean;
+  }
+}

package/src/config/unicorn.ts

@@ -0,0 +1,68 @@
+import { interopDefault } from '@w5s/dev';
+import { StylisticConfig, type Config, type PluginOptionsBase } from '../type.js';
+import type { RuleOptions } from '../typegen/unicorn.js';
+
+export async function unicorn(options: unicorn.Options = {}) {
+  const [unicornPlugin] = await Promise.all([
+    interopDefault(import('eslint-plugin-unicorn')),
+  ] as const);
+  const { rules = {}, stylistic = true } = options;
+  const { enabled: stylisticEnabled } = StylisticConfig.from(stylistic);
+
+  return [
+    {
+      name: 'w5s/unicorn/setup',
+      plugins: {
+        unicorn: unicornPlugin,
+      },
+    },
+    {
+      name: 'w5s/unicorn/rules',
+      rules: {
+        ...(unicornPlugin.configs.recommended?.rules),
+        // Disabled for safety
+        'unicorn/consistent-destructuring': 'off',
+        'unicorn/consistent-function-scoping': 'off', // Too many false positive
+        'unicorn/filename-case': 'off',
+        'unicorn/import-index': 'off', // Not playing well with ES Module
+        'unicorn/new-for-builtins': 'off', // error, @see https://github.com/sindresorhus/eslint-plugin-unicorn/issues/122
+        'unicorn/no-array-callback-reference': 'off', // Many false positive reported
+        'unicorn/no-array-for-each': 'off', // This rule could change browser compatibility
+        'unicorn/no-array-method-this-argument': 'off', // Many false positive reported
+        'unicorn/no-array-reduce': 'off', // Array#reduce can be used
+        'unicorn/no-console-spaces': 'off',
+        'unicorn/no-fn-reference-in-iterator': 'off', // error ?
+        'unicorn/no-nested-ternary': 'off',
+        'unicorn/no-null': 'off', // https://github.com/sindresorhus/eslint-plugin-unicorn/issues/612
+        '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',
+        'unicorn/prefer-set-has': 'off',
+        'unicorn/prevent-abbreviations': 'off', // This rule is so dangerous : it potentially break code while fixing in many cases !!
+        'unicorn/throw-new-error': 'off', // Creating errors with call signature is OK
+        ...(stylisticEnabled
+          ? {}
+          : {}),
+        ...rules,
+      },
+    },
+    // TODO: move to another file ?
+    {
+      name: 'w5s/unicorn/overrides',
+      files: ['**/*.config.cjs', '**/*.config.js'],
+      rules: {
+        'unicorn/prefer-module': 'off',
+      },
+    },
+  ] as [Config, Config, Config] satisfies Array<Config>;
+}
+
+export namespace unicorn {
+  export type Rules = RuleOptions;
+
+  export interface Options extends PluginOptionsBase<Rules> {}
+}

package/src/config/yml.ts

@@ -0,0 +1,70 @@
+/* eslint-disable ts/no-non-null-assertion */
+import { interopDefault, Project } from '@w5s/dev';
+import { StylisticConfig, type Config, type PluginOptionsBase } from '../type.js';
+import type { RuleOptions } from '../typegen/yml.js';
+
+const defaultFiles = [`**/${Project.extensionsToGlob(Project.queryExtensions(['yaml']))}`];
+
+export async function yml(options: yml.Options = {}) {
+  const [ymlPlugin, ymlParser] = await Promise.all([
+    interopDefault(import('eslint-plugin-yml')),
+    interopDefault(import('yaml-eslint-parser')),
+  ] as const);
+  const { files = defaultFiles, rules = {}, stylistic = true } = options;
+  const { enabled: stylisticEnabled, indent, quotes } = StylisticConfig.from(stylistic);
+
+  return [
+    {
+      name: 'w5s/yml/setup',
+      plugins: {
+        yml: ymlPlugin,
+      },
+    },
+    {
+      files,
+      languageOptions: {
+        parser: ymlParser,
+      },
+      name: 'w5s/yml/rules',
+      rules: {
+        ...(ymlPlugin.configs['flat/recommended'][0]!.rules),
+        ...(ymlPlugin.configs['flat/recommended'][1]!.rules),
+        ...(ymlPlugin.configs['flat/recommended'][2]!.rules),
+        ...(stylisticEnabled
+          ? {
+              // ...(ymlPlugin.configs['flat/standard'][3]!.rules),
+              // 'yml/array-bracket-spacing': ['error', 'never'],
+              // 'yml/comma-dangle': ['error', 'never'],
+              // 'yml/comma-style': ['error', 'last'],
+
+              // 'yml/object-curly-newline': ['error', { consistent: true, multiline: true }],
+              // 'yml/object-curly-spacing': ['error', 'always'],
+              // 'yml/object-property-newline': ['error', { allowMultiplePropertiesPerLine: true }],
+              // 'yml/quote-props': 'error',
+
+              'style/spaced-comment': 'off', // Fix
+
+              'yml/block-mapping-question-indicator-newline': 'error',
+              'yml/block-sequence-hyphen-indicator-newline': 'error',
+              'yml/flow-mapping-curly-newline': 'error',
+              'yml/flow-mapping-curly-spacing': 'error',
+              'yml/flow-sequence-bracket-newline': 'error',
+              'yml/flow-sequence-bracket-spacing': 'error',
+              'yml/indent': ['error', indent === 'tab' ? 2 : indent],
+              'yml/key-spacing': ['error', { afterColon: true, beforeColon: false }],
+              'yml/no-tab-indent': 'error',
+              'yml/quotes': ['error', { avoidEscape: true, prefer: quotes === 'backtick' ? 'single' as const : quotes }],
+              'yml/spaced-comment': 'error',
+            }
+          : {}),
+        ...rules,
+      },
+    },
+  ] as [Config, Config] satisfies Array<Config>;
+}
+
+export namespace yml {
+  export type Rules = RuleOptions;
+
+  export interface Options extends PluginOptionsBase<Rules> {}
+}

package/src/config.ts

@@ -0,0 +1,11 @@
+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/node.js';
+export * from './config/stylistic.js';
+export * from './config/test.js';
+export * from './config/ts.js';
+export * from './config/unicorn.js';
+export * from './config/yml.js';

package/src/defineConfig.ts

@@ -0,0 +1,62 @@
+import { jsdoc, jsonc, ignores, imports, node, ts, yml, unicorn, stylistic, es } from './config.js';
+import type { Config } from './type.js';
+
+export interface DefineConfigOptions extends ignores.Options {
+  es?: boolean | es.Options;
+  import?: boolean | imports.Options;
+  jsdoc?: boolean | jsdoc.Options;
+  jsonc?: boolean | jsonc.Options;
+  node?: boolean | node.Options;
+  stylistic?: boolean | stylistic.Options;
+  ts?: boolean | ts.Options;
+  unicorn?: boolean | unicorn.Options;
+  yml?: boolean | yml.Options;
+}
+
+export async function defineConfig(options: DefineConfigOptions = {}) {
+  const stylisticOptions = typeof options.stylistic === 'boolean' ? { enabled: options.stylistic } : { enabled: true, ...options.stylistic };
+  const withDefaultStylistic = <T>(options: T) => ({ stylistic: stylisticOptions, ...options });
+  const toOption = <T extends {}>(optionsOrBoolean: T | boolean | undefined) => withDefaultStylistic((typeof optionsOrBoolean === 'boolean' ? { 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 nodeOptions = toOption(options.node);
+  const tsOptions = toOption(options.ts);
+  const unicornOptions = toOption(options.unicorn);
+  const ymlOptions = toOption(options.yml);
+
+  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 (nodeOptions.enabled) {
+    append(node(nodeOptions));
+  }
+  if (tsOptions.enabled) {
+    append(ts(tsOptions));
+  }
+  if (ymlOptions.enabled) {
+    append(yml(ymlOptions));
+  }
+  if (unicornOptions.enabled) {
+    append(unicorn(unicornOptions));
+  }
+  const nested = await Promise.all(returnValue);
+  return nested.reduce((acc, curr) => [...acc, ...curr], [] as Array<Config>);
+}

package/src/index.ts

@@ -1,31 +1,3 @@
-import type eslint from 'eslint';
-import { ESLintConfig } from '@w5s/dev';
-import ignoreConfig from './rules/ignore.js';
-import esConfig from './es.js';
-import typescriptConfig from './typescript.js';
-import jestConfig from './jest.js';
-import jsonConfig from './json.js';
-import ymlConfig from './yml.js';
-
-function tryResolve(name: string) {
-  try {
-    require.resolve(name);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-const config: eslint.Linter.Config = ESLintConfig.concat(
-  ignoreConfig,
-  esConfig,
-  tryResolve('typescript') ? typescriptConfig : {},
-  jestConfig,
-  jsonConfig,
-  ymlConfig,
-  {
-    root: true,
-  },
-);
-
-export = config;
+export * from './defineConfig.js';
+export * from './config.js';
+export { defineConfig as default } from './defineConfig.js';

package/src/type/Config.ts

@@ -0,0 +1,5 @@
+import type { Linter } from 'eslint';
+
+export interface Config extends Omit<Linter.Config<Linter.RulesRecord>, 'plugins'> {
+  plugins?: Record<string, any>;
+}

package/src/type/PluginOptionsBase.ts

@@ -0,0 +1,14 @@
+import type { Linter } from 'eslint';
+import type { StylisticParameters } from './StylisticConfig.js';
+
+export interface PluginOptionsBase<Rules> {
+  files?: Linter.Config['files'];
+  /**
+   * Plugin rules
+   */
+  rules?: Rules;
+  /**
+   * Stylistic options
+   */
+  stylistic?: boolean | StylisticParameters;
+}

package/src/type/StylisticConfig.ts

@@ -0,0 +1,39 @@
+import type { StylisticCustomizeOptions } from '@stylistic/eslint-plugin';
+import prettierConfig from '@w5s/prettier-config';
+
+export interface StylisticConfig {
+  enabled: boolean;
+  indent: NonNullable<StylisticCustomizeOptions['indent']>;
+  quotes: NonNullable<StylisticCustomizeOptions['quotes']>;
+  jsx: NonNullable<StylisticCustomizeOptions['jsx']>;
+  semi: NonNullable<StylisticCustomizeOptions['semi']>;
+}
+
+export interface StylisticParameters extends Partial<StylisticConfig> {}
+
+const defaultConfig = {
+  enabled: true,
+  indent: prettierConfig.tabWidth ?? 2,
+  quotes: prettierConfig.singleQuote ? 'single' : 'double',
+  jsx: true,
+  semi: prettierConfig.semi ?? true,
+} satisfies StylisticConfig;
+
+/**
+ * @namespace
+ */
+export const StylisticConfig = {
+  /**
+   * Default config
+   */
+  default: defaultConfig,
+
+  /**
+   * Return a new StylisticConfig from input
+   *
+   * @param input
+   */
+  from(input: boolean | StylisticParameters): StylisticConfig {
+    return typeof input === 'boolean' ? { ...defaultConfig, enabled: input } : { ...defaultConfig, ...input };
+  },
+};

package/src/type.ts

@@ -0,0 +1,3 @@
+export * from './type/Config.js';
+export * from './type/PluginOptionsBase.js';
+export * from './type/StylisticConfig.js';