@mouse_484/eslint-config 5.3.9 → 5.4.1

package/README.md

@@ -4,8 +4,5 @@ ESLint Config based on [@antfu/eslint-config](https://github.com/antfu/eslint-co
 
 ## Usage
 ```
-@mouse_484/eslint-config@latest
+npx @mouse_484/eslint-config@latest
 ```
-
-> [!WARNING]
-> `npx` does not work. Use `pnpx` or run bin/cli.js directly after installation.

package/bin/cli.js

@@ -1,182 +1,114 @@
 #!/usr/bin/env node
-import { execSync, spawn } from 'node:child_process'
-import fs from 'node:fs/promises'
+import { spawn } from 'node:child_process'
+import { readFile, writeFile } 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
- * @property {string} name - Package name
- * @property {string} import - Import name in config
- * @property {string} [version] - Package version
- */
-
-/** @type {PackageInfo} */
-const SOURCE = {
-  name: '@antfu/eslint-config',
-  import: 'antfu',
+const PACKAGE_NAME = {
+  BASE: '@antfu/eslint-config',
+  CUSTOM: '@mouse_484/eslint-config',
 }
 
-/** @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'
-
-// infinite loop prevention
-const isRunningFromSourcePackage = process.argv[1].includes(SOURCE.name)
-
 /**
- * Execute command with spawn
- * @param {string} command - Command to execute
- * @param {string[]} args - Command arguments
- * @returns {Promise<void>}
+ * Simple logger function
+ * @param {*} message
  */
-function runCommand(command, args = []) {
-  console.info(`Running: ${command} ${args.join(' ')}`)
-  const spawnedProcess = spawn(command, args, { stdio: 'inherit', shell: true })
-
-  return new Promise((resolve, reject) => {
-    spawnedProcess.on('close', (code) => {
-      if (code === 0) {
-        setTimeout(() => {
-          resolve()
-        }, 300)
-      } else {
-        reject(new Error(`Command failed with exit code ${code}`))
-      }
-    })
-    spawnedProcess.on('error', reject)
-  })
+function logger(message) {
+  console.info('@mouse_484/eslint-config:', message)
 }
 
 /**
- * Execute antfu's CLI directly via node
- * @returns {Promise<void>}
+ * @type {(...args: Parameters<typeof import("package-manager-detector/commands").resolveCommand>) => Promise<void>}
  */
-async function runAntfuCLI() {
-  console.info('Running @antfu/eslint-config setup...')
-
-  const cwd = process.cwd()
-  const cliPath = path.join(cwd, 'node_modules', SOURCE.name, 'bin', 'index.js')
-
+function runAgentCommand(agent, command_, args_) {
+  const { command, args } = resolveCommand(agent, command_, args_)
   return new Promise((resolve, reject) => {
-    const nodeProcess = spawn('node', [cliPath], {
-      stdio: 'inherit',
-      cwd,
-      shell: true,
-    })
+    const child = spawn(
+      command,
+      args,
+      {
+        stdio: 'inherit',
+      },
+    )
 
-    nodeProcess.on('close', (code) => {
+    child.on('close', (code) => {
       if (code === 0) {
-        setTimeout(() => {
-          resolve()
-        }, 300)
+        resolve()
       } else {
-        reject(new Error(`Antfu CLI failed with exit code ${code}`))
+        reject(new Error(`Command failed: ${code} (${command} ${args.join(' ')})`))
       }
     })
-    nodeProcess.on('error', reject)
+    child.on('error', (error) => {
+      reject(error)
+    })
   })
 }
 
-/**
- * Update JSON file with transform function
- * @param {string} filePath - JSON file path
- * @param {(data: any) => any} updateFunction - Transform function
- */
-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...')
+  const cwd = process.cwd()
+  logger('Starting setup')
 
-  if (isRunningFromSourcePackage) {
-    console.error(
-      `Please run this script from the root of your project, not from ${SOURCE.name} package.`,
-    )
-    process.exitCode = 1
-    return
+  const packageManager = await detect() ?? {
+    name: 'npm',
+    agent: 'npm',
+    version: 'unknown',
   }
 
-  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
+  logger(`Detected package manager: ${packageManager.name}`)
+
+  logger(`Setting up base package ${PACKAGE_NAME.BASE}`)
+  await runAgentCommand(
+    packageManager.agent,
+    'execute',
+    [PACKAGE_NAME.BASE],
+  )
+  logger('Modifying base config to custom config')
+
+  logger(`Uninstalling base package ${PACKAGE_NAME.BASE}`)
+  await runAgentCommand(
+    packageManager.agent,
+    'uninstall',
+    [PACKAGE_NAME.BASE],
+  )
+  logger(`Installing custom package ${PACKAGE_NAME.CUSTOM}`)
+  await runAgentCommand(
+    packageManager.agent,
+    'install',
+    ['-D', PACKAGE_NAME.CUSTOM],
+  )
+
+  logger('Updating package.json scripts')
+  const packageJsonPath = path.join(cwd, 'package.json')
+  /**
+   * @type {{ scripts: Record<string, string>, type?: "module" }}
+   */
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'))
+  packageJson.scripts = {
+    ...packageJson.scripts,
+    'lint': 'eslint .',
+    'lint:fix': 'eslint --fix .',
   }
-
-  const installCmd = resolveCommand(pm.agent, 'add', ['-D', SOURCE.name])
-  await runCommand(installCmd.command, installCmd.args)
-  console.info(`Installed ${SOURCE.name}`)
-
-  await runAntfuCLI()
-
-  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 package_ = await updateJSONFile(packageJSONPath, (packageData) => {
-    packageData.devDependencies = packageData.devDependencies || {}
-    delete packageData.devDependencies[SOURCE.name]
-
-    let targetVersion
-    try {
-      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'
-    }
-    TARGET.version = targetVersion
-    packageData.devDependencies[TARGET.name] = targetVersion
-
-    packageData.scripts = {
-      ...packageData.scripts,
-      'lint': 'eslint .',
-      'lint:fix': 'eslint --fix .',
-    }
-
-    return packageData
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, undefined, 2), 'utf8')
+
+  logger('Updating config file')
+  const configPath = path.join(cwd, `eslint.config.${packageJson.type === 'module' ? 'js' : 'mjs'}`)
+  await writeFile(configPath, `
+import mouse from '${PACKAGE_NAME.CUSTOM}'
+
+export default mouse()
+`.trim(), 'utf8')
+
+  logger('Linting the project to verify setup')
+  await runAgentCommand(
+    packageManager.agent,
+    'run',
+    ['lint:fix'],
+  ).catch((error) => {
+    logger(`Linting failed: ${error.message}`)
   })
-
-  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, 'utf8')
-  configContent = configContent
-    .replace(
-      `import ${SOURCE.import} from '${SOURCE.name}'`,
-      `import ${TARGET.import} from '${TARGET.name}'`,
-    )
-    .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)
-
-  console.info(`Successfully replaced the config from ${SOURCE.name} to ${TARGET.name}`)
 }
 
 await main()
+console.info('---------------- Setup Complete ----------------')

package/package.json

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

package/src/configs/tailwind.js

@@ -6,28 +6,38 @@ export default createConfigs({
   baseWithOption: 'tailwind',
   configs: [
     (meta) => {
+      if (!meta?.entryPoint) return
+
       return {
         name: 'tailwind',
         plugins: {
           tailwind: eslintPluginBetterTailwindcss,
         },
         rules: {
-          // stylistic
-          'tailwind/multiline': ['warn', {
+          // Stylistic rules
+          'tailwind/enforce-consistent-line-wrapping': ['warn', {
             group: 'newLine',
           }],
-          'tailwind/no-unnecessary-whitespace': 'warn',
-          'tailwind/sort-classes': 'warn',
+          'tailwind/enforce-consistent-class-order': ['warn', {
+            order: 'improved',
+          }],
+          'tailwind/enforce-consistent-variable-syntax': 'warn',
+          'tailwind/enforce-consistent-important-position': 'error',
+          'tailwind/enforce-shorthand-classes': 'warn',
           'tailwind/no-duplicate-classes': 'error',
-          'tailwind/enforce-consistent-variable-syntax': 'error',
-          // correctness
-          'tailwind/no-unregistered-classes': 'off', // FIXME
+          'tailwind/no-deprecated-classes': 'error',
+          'tailwind/no-unnecessary-whitespace': 'warn',
+          // Correctness rules
+          'tailwind/no-unregistered-classes': ['error', {
+            ignore: [],
+            detectComponentClasses: true,
+          }],
           'tailwind/no-conflicting-classes': 'error',
-          'tailwind/no-restricted-classes': 'off',
+          'tailwind/no-restricted-classes': 'off', // arbitrary valuesの制限を今後検討
         },
         settings: {
-          tailwind: {
-            entryPoint: meta?.entryPoint,
+          'better-tailwindcss': {
+            entryPoint: meta.entryPoint,
           },
         },
       }

package/src/configs/typescript.js

@@ -0,0 +1,20 @@
+import { GLOB_TS } from '@antfu/eslint-config'
+import { createConfigs } from '../lib/factory.js'
+
+export default createConfigs({
+  name: 'typescript',
+  baseWithOption: 'typescript',
+  configs: [
+    (meta) => {
+      if (meta && 'tsconfigPath' in meta && meta.tsconfigPath) {
+        return {
+          name: 'type-aware',
+          files: [GLOB_TS],
+          rules: {
+            'ts/no-deprecated': 'error',
+          },
+        }
+      }
+    },
+  ],
+})

package/src/index.d.ts

@@ -1,15 +1,28 @@
-import type antfu from '@antfu/eslint-config'
+import type {
+  TypedFlatConfigItem as AntfuTypedFlatConfigItem,
+  OptionsConfig,
+  Rules,
+} from '@antfu/eslint-config'
+import type { Linter } from 'eslint'
+import type { FlatConfigComposer } from 'eslint-flat-config-utils'
+import type { RuleOptions } from './lib/rules.gen'
 
-type AntfuParameters = Parameters<typeof antfu>
-type AntfuOptions = AntfuParameters['0']
-type AntfuUserConfigs = AntfuParameters['1'][]
-
-export type Options = AntfuOptions & {
+type Awaitable<T> = T | Promise<T>
+export interface TypedFlatConfigItem extends Omit<AntfuTypedFlatConfigItem, 'rules'> {
+  rules?: Rules & RuleOptions
+}
+type Config = Awaitable<
+  TypedFlatConfigItem
+  | TypedFlatConfigItem[]
+  | FlatConfigComposer<any, any>
+  | Linter.Config[]
+>
+export interface Options extends OptionsConfig, Omit<TypedFlatConfigItem, 'files'> {
   tailwind?: false | { entryPoint: string }
 }
 
 export declare function mouse(
   options?: Options,
-  ...configs: AntfuUserConfigs
+  ...configs: Config[]
 ): ReturnType<typeof antfu>
 export default mouse

package/src/index.js

@@ -5,6 +5,7 @@ import perfectionist from './configs/perfectionist.js'
 import stylistic from './configs/stylistic.js'
 import svelte from './configs/svelte.js'
 import tailwind from './configs/tailwind.js'
+import typescript from './configs/typescript.js'
 import unicorn from './configs/unicorn.js'
 
 /** @type {import('.').mouse} */
@@ -25,6 +26,7 @@ async function mouse(options, ...userConfigs) {
     ...unicorn(options),
     ...perfectionist(options),
     // Language specific
+    ...typescript(options),
     ...astro(options),
     ...svelte(options),
     // Tools

package/src/lib/factory.d.ts

@@ -1,16 +1,16 @@
-import type { Rules, TypedFlatConfigItem } from '@antfu/eslint-config'
-import type { Options } from '..'
-import type { RuleOptions } from './rules.gen'
+import type { Options, TypedFlatConfigItem } from '..'
 
 interface ConfigItem extends TypedFlatConfigItem {
   withOptions?: (keyof Options)[]
   name: string
-  rules?: Rules & RuleOptions
 }
 
 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))[]
+  configs: (
+    ConfigItem
+    | ((meta?: OnlyObject<Options[T]>) => ConfigItem)
+  )[]
 }): (options: Options) => TypedFlatConfigItem[]

package/src/lib/factory.js

@@ -30,7 +30,10 @@ export function createConfigs({ name, baseWithOption, configs }) {
         }
         const meta = options[baseWithOption]
         // @ts-ignore
-        configItem = configItem(typeof meta === 'object' ? meta : undefined)
+        configItem = configItem(typeof meta === 'object' ? meta : undefined) ?? {}
+      }
+      if (!configItem) {
+        return []
       }
       const { name: configName, withOptions = [], ...restConfig } = configItem
       return createConfig(