@mouse_484/eslint-config 4.0.4 → 4.2.0

package/bin/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { execSync, spawn } from 'node:child_process'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import process from 'node:process'
-import { resolveCommand } from 'package-manager-detector/commands'
-import { detect } from 'package-manager-detector/detect'
+import { execSync, spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { resolveCommand } from 'package-manager-detector/commands';
+import { detect } from 'package-manager-detector/detect';
 
 /**
  * @typedef {object} PackageInfo
@@ -17,20 +17,20 @@ import { detect } from 'package-manager-detector/detect'
 const SOURCE = {
   name: '@antfu/eslint-config',
   import: 'antfu',
-}
+};
 
 /** @type {PackageInfo} */
 const TARGET = {
   name: '@mouse_484/eslint-config',
   import: 'mouse',
-}
+};
 
-const PACKAGE_JSON_FILE = 'package.json'
-const ESLINT_CONFIG_JS_FILE = 'eslint.config.js'
-const ESLINT_CONFIG_MJS_FILE = 'eslint.config.mjs'
+const PACKAGE_JSON_FILE = 'package.json';
+const ESLINT_CONFIG_JS_FILE = 'eslint.config.js';
+const ESLINT_CONFIG_MJS_FILE = 'eslint.config.mjs';
 
 // infinite loop prevention
-const isRunningFromSourcePackage = process.argv[1].includes(SOURCE.name)
+const isRunningFromSourcePackage = process.argv[1].includes(SOURCE.name);
 
 /**
  * Execute command with spawn
@@ -39,114 +39,114 @@ const isRunningFromSourcePackage = process.argv[1].includes(SOURCE.name)
  * @returns {Promise<void>}
  */
 function runCommand(command, args = []) {
-  console.info(`Running: ${command} ${args.join(' ')}`)
-  const spawnedProcess = spawn(command, args, { stdio: 'inherit' })
+  console.info(`Running: ${command} ${args.join(' ')}`);
+  const spawnedProcess = spawn(command, args, { stdio: 'inherit' });
 
   return new Promise((resolve, reject) => {
     spawnedProcess.on('close', (code) => {
       if (code === 0) {
         setTimeout(() => {
-          resolve()
-        }, 300)
+          resolve();
+        }, 300);
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
       }
-      else {
-        reject(new Error(`Command failed with exit code ${code}`))
-      }
-    })
-    spawnedProcess.on('error', reject)
-  })
+    });
+    spawnedProcess.on('error', reject);
+  });
 }
 
 /**
  * Update JSON file with transform function
  * @param {string} filePath - JSON file path
- * @param {(data: any) => any} updateFn - Transform function
+ * @param {(data: any) => any} updateFunction - Transform function
  */
-async function updateJSONFile(filePath, updateFn) {
-  const content = await fs.readFile(filePath, 'utf-8')
-  const data = JSON.parse(content)
-  const updated = updateFn(data)
-  await fs.writeFile(filePath, JSON.stringify(updated, null, 2))
-  return updated
+async function updateJSONFile(filePath, updateFunction) {
+  const content = await fs.readFile(filePath, 'utf8');
+  const data = JSON.parse(content);
+  const updated = updateFunction(data);
+  await fs.writeFile(filePath, JSON.stringify(updated, undefined, 2));
+  return updated;
 }
 
 async function main() {
-  console.info('Starting ESLint config setup...')
+  console.info('Starting ESLint config setup...');
 
   if (isRunningFromSourcePackage) {
     console.error(
       `Please run this script from the root of your project, not from ${SOURCE.name} package.`,
-    )
-    process.exitCode = 1
-    return
+    );
+    process.exitCode = 1;
+    return;
   }
 
-  const pm = await detect()
+  const pm = await detect();
   if (!pm) {
     console.error(
       'Could not detect package manager. '
       + 'Please ensure you are in a project with a package.json file.',
-    )
-    process.exitCode = 1
-    return
+    );
+    process.exitCode = 1;
+    return;
   }
 
-  const installCmd = resolveCommand(pm.agent, 'add', ['-D', SOURCE.name])
-  await runCommand(installCmd.command, installCmd.args)
-  console.info(`Installed ${SOURCE.name}`)
+  const installCmd = resolveCommand(pm.agent, 'add', ['-D', SOURCE.name]);
+  await runCommand(installCmd.command, installCmd.args);
+  console.info(`Installed ${SOURCE.name}`);
 
-  const execCmd = resolveCommand(pm.agent, 'execute', [SOURCE.name])
-  await runCommand(execCmd.command, execCmd.args)
+  const execCmd = resolveCommand(pm.agent, 'execute', [SOURCE.name]);
+  await runCommand(execCmd.command, execCmd.args);
 
-  console.info(`Start replacing the config from ${SOURCE.name} to ${TARGET.name}`)
+  console.info(`Start replacing the config from ${SOURCE.name} to ${TARGET.name}`);
 
-  const cwd = process.cwd()
-  const packageJSONPath = path.join(cwd, PACKAGE_JSON_FILE)
+  const cwd = process.cwd();
+  const packageJSONPath = path.join(cwd, PACKAGE_JSON_FILE);
 
-  const pkg = await updateJSONFile(packageJSONPath, (pkgData) => {
-    pkgData.devDependencies = pkgData.devDependencies || {}
-    delete pkgData.devDependencies[SOURCE.name]
+  const package_ = await updateJSONFile(packageJSONPath, (packageData) => {
+    packageData.devDependencies = packageData.devDependencies || {};
+    delete packageData.devDependencies[SOURCE.name];
 
-    let targetVersion
+    let targetVersion;
     try {
-      targetVersion = execSync(`npm view ${TARGET.name} dist-tags.latest`).toString().trim()
-    }
-    catch (error) {
+      targetVersion = execSync(`npm view ${TARGET.name} dist-tags.latest`).toString().trim();
+    } catch (error) {
       console.warn(
         `Warning: Could not fetch latest version for ${TARGET.name}, using 'latest'. `
         + `Error: ${error.message}`,
-      )
-      targetVersion = 'latest'
+      );
+      targetVersion = 'latest';
     }
-    TARGET.version = targetVersion
-    pkgData.devDependencies[TARGET.name] = targetVersion
+    TARGET.version = targetVersion;
+    packageData.devDependencies[TARGET.name] = targetVersion;
 
-    pkgData.scripts = {
-      ...pkgData.scripts,
+    packageData.scripts = {
+      ...packageData.scripts,
       'lint': 'eslint .',
       'lint:fix': 'eslint --fix .',
-    }
+    };
 
-    return pkgData
-  })
+    return packageData;
+  });
 
-  const configExt = pkg.type === 'module' ? 'js' : 'mjs'
-  const eslintConfigFile = configExt === 'js' ? ESLINT_CONFIG_JS_FILE : ESLINT_CONFIG_MJS_FILE
-  const configPath = path.join(cwd, eslintConfigFile)
+  const configExtension = package_.type === 'module' ? 'js' : 'mjs';
+  const eslintConfigFile = configExtension === 'js'
+    ? ESLINT_CONFIG_JS_FILE
+    : ESLINT_CONFIG_MJS_FILE;
+  const configPath = path.join(cwd, eslintConfigFile);
 
-  let configContent = await fs.readFile(configPath, 'utf-8')
+  let configContent = await fs.readFile(configPath, 'utf8');
   configContent = configContent
     .replace(
       `import ${SOURCE.import} from '${SOURCE.name}'`,
       `import ${TARGET.import} from '${TARGET.name}'`,
     )
-    .replace(new RegExp(`(?<!['"])${SOURCE.import}(?!['"])`, 'g'), TARGET.import)
-  await fs.writeFile(configPath, configContent)
+    .replaceAll(new RegExp(`(?<!['"])${SOURCE.import}(?!['"])`, 'g'), TARGET.import);
+  await fs.writeFile(configPath, configContent);
 
-  const finalInstallCmd = resolveCommand(pm.agent, 'install', [])
-  await runCommand(finalInstallCmd.command, finalInstallCmd.args)
+  const finalInstallCmd = resolveCommand(pm.agent, 'install', []);
+  await runCommand(finalInstallCmd.command, finalInstallCmd.args);
 
-  console.info(`Successfully replaced the config from ${SOURCE.name} to ${TARGET.name}`)
+  console.info(`Successfully replaced the config from ${SOURCE.name} to ${TARGET.name}`);
 }
 
-main()
+await main();

package/jsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "noEmit": true,
+    "strict": true,
+    "checkJs": true,
+    "target": "ES2020",
+    "moduleResolution": "node"
+  },
+  "include": ["src"]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mouse_484/eslint-config",
   "type": "module",
-  "version": "4.0.4",
+  "version": "4.2.0",
   "author": "mouse_484",
   "license": "MIT",
   "homepage": "https://github.com/mouse484/config/tree/main/packages/eslint",

package/src/configs/astro.js

@@ -0,0 +1,16 @@
+import { GLOB_ASTRO } from '@antfu/eslint-config';
+import { createConfigs } from '../lib/factory.js';
+
+export default createConfigs({
+  name: 'astro',
+  baseWithOption: 'astro',
+  configs: [
+    {
+      name: 'general',
+      files: [GLOB_ASTRO],
+      rules: {
+        'astro/no-set-html-directive': 'error',
+      },
+    },
+  ],
+});

package/src/configs/base.js

@@ -0,0 +1,13 @@
+import { createConfigs } from '../lib/factory.js';
+
+export default createConfigs({
+  name: 'base',
+  configs: [
+    {
+      name: 'antfu',
+      rules: {
+        'antfu/top-level-function': 'off',
+      },
+    },
+  ],
+});

package/src/configs/stylistic.js

@@ -0,0 +1,41 @@
+import { GLOB_MARKDOWN } from '@antfu/eslint-config';
+import { createConfigs } from '../lib/factory.js';
+
+export default createConfigs({
+  name: 'stylistic',
+  baseWithOption: 'stylistic',
+  configs: [
+    {
+      name: 'general',
+      rules: {
+        'style/max-len': [
+          'error',
+          {
+            code: 100,
+            tabWidth: 2,
+            comments: 120,
+            ignoreUrls: true,
+          },
+        ],
+        'style/brace-style': [
+          'error',
+          '1tbs',
+        ],
+        'style/semi': ['error', 'always'],
+      },
+    },
+    {
+      name: 'markdown',
+      files: [GLOB_MARKDOWN],
+      rules: {
+        'style/max-len': [
+          'error',
+          {
+            ignoreUrls: true,
+            ignorePattern: String.raw`^\s*\|`,
+          },
+        ],
+      },
+    },
+  ],
+});

package/src/configs/svelte.js

@@ -0,0 +1,32 @@
+import { GLOB_SVELTE } from '@antfu/eslint-config';
+import { CASES } from '../const/cases.js';
+import { GLOB_SVELTE_ROUTES } from '../const/glob.js';
+import { createConfigs } from '../lib/factory.js';
+
+export default createConfigs({
+  name: 'svelte',
+  baseWithOption: 'svelte',
+  configs: [
+    {
+      name: 'components',
+      withOptions: ['unicorn'],
+      files: [GLOB_SVELTE],
+      rules: {
+        'unicorn/filename-case': [
+          'error',
+          {
+            case: CASES.camelCase,
+          },
+        ],
+      },
+    },
+    {
+      name: 'kit/routes',
+      withOptions: ['unicorn'],
+      files: [GLOB_SVELTE_ROUTES],
+      rules: {
+        'unicorn/filename-case': 'off',
+      },
+    },
+  ],
+});

package/src/configs/tailwind.js

@@ -0,0 +1,28 @@
+import eslintPluginReadableTailwind from 'eslint-plugin-readable-tailwind';
+import { createConfigs } from '../lib/factory.js';
+
+export default createConfigs({
+  name: 'tailwind',
+  baseWithOption: 'tailwind',
+  configs: [
+    (meta) => {
+      return {
+        name: 'readable-tailwind',
+        plugins: {
+          'readable-tailwind': eslintPluginReadableTailwind,
+        },
+        rules: {
+          ...eslintPluginReadableTailwind.configs.warning.rules,
+          'readable-tailwind/multiline': ['warn', {
+            group: 'emptyLine',
+          }],
+        },
+        settings: {
+          'readable-tailwind': {
+            entryPoint: meta?.entryPoint,
+          },
+        },
+      };
+    },
+  ],
+});

package/src/configs/unicorn.js

@@ -0,0 +1,30 @@
+import { GLOB_MARKDOWN_CODE_BLOCK, GLOB_README } from '../const/glob.js';
+import { createConfigs } from '../lib/factory.js';
+
+export default createConfigs({
+  name: 'unicorn',
+  baseWithOption: 'unicorn',
+  configs: [
+    {
+      name: 'general',
+      rules: {
+        'unicorn/prevent-abbreviations': [
+          'error',
+          {
+            allowList: {
+              Props: true,
+              args: true,
+            },
+          },
+        ],
+      },
+    },
+    {
+      name: 'filename-case',
+      files: [GLOB_README, GLOB_MARKDOWN_CODE_BLOCK],
+      rules: {
+        'unicorn/filename-case': 'off',
+      },
+    },
+  ],
+});

package/src/const/cases.js

@@ -0,0 +1,6 @@
+export const CASES = /** @type {const} */({
+  'camelCase': 'camelCase',
+  'PascalCase': 'pascalCase',
+  'snake_case': 'snakeCase',
+  'kebab-case': 'kebabCase',
+});

package/src/const/glob.js

@@ -0,0 +1,11 @@
+export { GLOB_SVELTE as GLOB_SVELTE_COMPONENTS } from '@antfu/eslint-config';
+
+export const GLOB_SVELTE_ROUTES = '**/src/routes/**/\+*.svelte';
+
+export const GLOB_README = '**/README.md';
+
+/**
+ * Code block in markdown
+ * @see https://github.com/eslint/markdown/blob/32d8cbd8b6d2d121225b5291c2f9a0ea6c2ccd00/docs/processors/markdown.md?plain=1#L96
+ */
+export const GLOB_MARKDOWN_CODE_BLOCK = '**/*.md/**';

package/src/index.js

@@ -1,125 +1,37 @@
-// @ts-check
-import antfu, {
-  GLOB_ASTRO,
-  GLOB_SVELTE,
-} from '@antfu/eslint-config'
-
-/** @type {Record<string, "camelCase" | "pascalCase" | "snakeCase" | "kebabCase">} */
-const CASES = {
-  'camelCase': 'camelCase',
-  'PascalCase': 'pascalCase',
-  'snake_case': 'snakeCase',
-  'kebab-case': 'kebabCase',
-}
-
-/** @type {import('@antfu/eslint-config')["antfu"]} */
+import antfu from '@antfu/eslint-config';
+import astro from './configs/astro.js';
+import base from './configs/base.js';
+import stylistic from './configs/stylistic.js';
+import svelte from './configs/svelte.js';
+import tailwind from './configs/tailwind.js';
+import unicorn from './configs/unicorn.js';
+
+/** @type {import('./lib/type.js').mouse} */
 async function mouse(options, ...userConfigs) {
   options = {
-    lessOpinionated: true,
     unicorn: {
       allRecommended: true,
     },
+    stylistic: true,
     ...options,
-  }
+  };
 
-  /** @type {import('@antfu/eslint-config').TypedFlatConfigItem[]} */
   const configs = [
-    {
-      name: 'mouse/antfu-config',
-      rules: {
-        'antfu/top-level-function': 'off',
-      },
-    },
-  ]
-
-  if (options?.stylistic) {
-    configs.push({
-      name: 'mouse/stylistic',
-      rules: {
-        'style/max-len': [
-          'error',
-          {
-            code: 100,
-            tabWidth: 2,
-            comments: 120,
-            ignoreUrls: true,
-          },
-        ],
-        'style/brace-style': [
-          'error',
-          '1tbs',
-        ],
-        'style/semi': ['error', 'always'],
-      },
-    })
-  }
-
-  if (options?.astro) {
-    configs.push({
-      name: 'mouse/astro',
-      files: [GLOB_ASTRO],
-      rules: {
-        'astro/no-set-html-directive': 'error',
-      },
-    })
-  }
-
-  if (options?.svelte) {
-    configs.push(
-      {
-        name: 'mouse/svelte/components',
-        files: [GLOB_SVELTE],
-        rules: {
-          'unicorn/filename-case': [
-            'error',
-            {
-              case: CASES.PascalCase,
-            },
-          ],
-        },
-      },
-      {
-        name: 'mouse/svelte/kit-routes',
-        files: ['**/src/routes/**/\+*.svelte'],
-        rules: {
-          'unicorn/filename-case': 'off',
-        },
-      },
-    )
-  }
-
-  if (options?.unicorn) {
-    configs.push({
-      name: 'mouse/unicorn',
-      rules: {
-        'unicorn/prevent-abbreviations': [
-          'error',
-          {
-            allowList: {
-              Props: true,
-            },
-          },
-        ],
-      },
-    }, {
-      name: 'mouse/unicorn/filename-case',
-      files: [
-        '**/README.md',
-        /**
-         * Code block in markdown
-         * @see https://github.com/eslint/markdown/blob/32d8cbd8b6d2d121225b5291c2f9a0ea6c2ccd00/docs/processors/markdown.md?plain=1#L96
-         */
-        '**/*.md/**',
-      ],
-      rules: {
-        'unicorn/filename-case': 'off',
-      },
-    })
-  }
-
-  return antfu(options, ...configs, ...userConfigs)
+    ...base(options),
+    // Code style
+    ...stylistic(options),
+    ...unicorn(options),
+    // Language specific
+    ...astro(options),
+    ...svelte(options),
+    // Tools
+    ...tailwind(options),
+  ];
+
+  return antfu(options, ...configs, ...userConfigs);
 }
 
-export default mouse
-export { mouse }
-export * from '@antfu/eslint-config'
+export default mouse;
+export { mouse };
+export * from './const/glob.js';
+export * from '@antfu/eslint-config';

package/src/lib/factory.js

@@ -0,0 +1,43 @@
+/**
+ *
+ * @param {string} name
+ * @param {(keyof import('./type').Options)[]} withOptions
+ * @param {Omit<import('@antfu/eslint-config').TypedFlatConfigItem,'name'>} config
+ * @returns {(options: import('./type').Options) => import('@antfu/eslint-config').TypedFlatConfigItem|[]} _
+ */
+function createConfig(name, withOptions, config) {
+  return (options) => {
+    const allowApply = withOptions
+      ? withOptions.every(key => key in options)
+      : true;
+    if (!allowApply) {
+      return [];
+    }
+    return {
+      name: `mouse/${name}`,
+      ...config,
+    };
+  };
+}
+
+/** @type {import('./type').createConfigs} */
+export function createConfigs({ name, baseWithOption, configs }) {
+  return (options) => {
+    return configs.flatMap((configItem) => {
+      if (typeof configItem === 'function') {
+        if (!baseWithOption) {
+          throw new Error('baseWithOption is required when configItem is a function');
+        }
+        const meta = options[baseWithOption];
+        // @ts-ignore
+        configItem = configItem(typeof meta === 'object' ? meta : undefined);
+      }
+      const { name: configName, withOptions = [], ...restConfig } = configItem;
+      return createConfig(
+        `${name}/${configName}`,
+        baseWithOption ? [baseWithOption, ...withOptions] : withOptions,
+        restConfig,
+      )(options);
+    });
+  };
+}

package/src/lib/type.d.ts

@@ -0,0 +1,24 @@
+import type antfu from '@antfu/eslint-config';
+import type { TypedFlatConfigItem } from '@antfu/eslint-config';
+
+type AntfuParameters = Parameters<typeof antfu>;
+type AntfuOptions = AntfuParameters['0'];
+type AntfuUserConfigs = AntfuParameters['1'][];
+
+export type Options = AntfuOptions & {
+  tailwind?: boolean | { entryPoint?: string }
+};
+
+export declare function mouse(
+  options: Options,
+  ...configs: AntfuUserConfigs
+): ReturnType<typeof antfu>;
+
+// factoty
+type ConfigItem = TypedFlatConfigItem & { withOptions?: (keyof Options)[], name: string };
+type OnlyObject<T> = T extends object ? T : never;
+export declare function createConfigs<T extends keyof Options = undefined>(parameters: {
+  name: string
+  baseWithOption?: T
+  configs: (ConfigItem | ((meta?: OnlyObject<Options[T]>) => ConfigItem))[]
+}): (options: Options) => TypedFlatConfigItem[];

package/src/index.d.ts

@@ -1,10 +0,0 @@
-import type { Awaitable, OptionsConfig, TypedFlatConfigItem } from '@antfu/eslint-config'
-
-declare function mouse(
-  options: OptionsConfig & TypedFlatConfigItem,
-  ...userConfigs: Awaitable<TypedFlatConfigItem | TypedFlatConfigItem[]>[]
-): Promise<TypedFlatConfigItem>
-
-export default mouse
-export { mouse }
-export * from '@antfu/eslint-config'