@chanyuxi/eslint-waltz 1.3.2 → 1.5.0

package/README.md

@@ -1,106 +1,95 @@
-# @chanyuxi/eslint-waltz
-
-Composable ESLint flat config for JavaScript, TypeScript, JSONC, React, Tailwind CSS, Perfectionist, and Vitest.
-
-Requires Node.js `>=20.19.0`.
-
-## Install
-
-Install the package, ESLint, and the peer dependencies used by the default configuration:
-
-```bash
-pnpm add -D @chanyuxi/eslint-waltz eslint eslint-plugin-jsonc eslint-plugin-import-x eslint-plugin-perfectionist jsonc-eslint-parser
-```
-
-`@eslint/js`, `@stylistic/eslint-plugin`, `globals`, and `jsonc-parser` are included automatically.
-
-Install peers only for the optional modules you enable:
-
-```bash
-# TypeScript
-pnpm add -D typescript-eslint
-
-# React
-pnpm add -D eslint-plugin-react-x eslint-plugin-react-debug eslint-plugin-react-dom eslint-plugin-react-hooks-extra eslint-plugin-react-naming-convention eslint-plugin-react-web-api
-
-# Tailwind CSS
-pnpm add -D eslint-plugin-tailwindcss tailwindcss
-
-# .gitignore support
-pnpm add -D eslint-config-flat-gitignore
-
-# Vitest
-pnpm add -D @vitest/eslint-plugin vitest
-```
-
-## Usage
-
-```ts
-// eslint.config.ts
-import waltz from '@chanyuxi/eslint-waltz'
-
-export default waltz({
-  ts: true,
-  react: true,
-})
-```
-
-Enabled by default:
-
-- JavaScript and stylistic rules
-- JSONC rules
-- import validation
-- Perfectionist with `recommended-alphabetical`
-
-Optional: `ts`, `react`, `tailwindcss`, `gitignore`, and `vitest`.
-
-More options are documented in the exported TypeScript types.
-
-The potentially expensive module-resolution rules are disabled by default. Enable
-them explicitly when your project needs them:
-
-```ts
-export default waltz({
-  imports: {
-    overrides: {
-      'imports/named': 'error',
-      'imports/namespace': 'error',
-    },
-  },
-})
-```
-
-## TypeScript file scope
-
-When `ts.files` is provided, it is the maximum TypeScript scope used by the
-other modules that automatically include TypeScript files. JavaScript files
-keep their normal scope, and a module's own `files` option can override this
-limit. Vitest additionally intersects its test-file patterns with this scope.
-
-```ts
-export default waltz({
-  ts: { files: ['src/**/*.ts'] },
-  react: true,
-})
-```
-
-## VS Code synchronization
-
-Run this command from your project root to enable ESLint fix-on-save settings
-while preserving existing `.vscode/settings.json` values and comments:
-
-```bash
-npx eslint-waltz sync-vscode
-```
-
-React plugin settings can be customized when needed:
-
-```ts
-export default waltz({
-  react: {
-    settings: {
-      'react-x': { importSource: 'preact' },
-    },
-  },
-})
-```
+# @chanyuxi/eslint-waltz
+
+Composable ESLint flat config for JavaScript, TypeScript, JSONC, imports, React, Tailwind CSS, Perfectionist, and Vitest.
+
+Requires Node.js `>=20.19.0`.
+
+## Quick start
+
+Run the interactive initializer from your project root:
+
+```bash
+pnpm dlx @chanyuxi/eslint-waltz init
+```
+
+The initializer detects your package manager and existing dependencies, creates
+`eslint.config.ts`, installs missing dependencies for the selected features,
+and can configure ESLint fix-on-save in VS Code while preserving existing
+settings and comments.
+
+If the package is already installed, use its local binary:
+
+```bash
+pnpm exec eslint-waltz init
+```
+
+## Configuration
+
+```ts
+// eslint.config.ts
+import waltz from '@chanyuxi/eslint-waltz'
+
+export default waltz({
+  ts: true,
+  react: true,
+})
+```
+
+The default configuration includes JavaScript, stylistic rules, JSONC,
+import validation, and Perfectionist's `recommended-alphabetical` preset.
+Optional modules are enabled with `ts`, `react`, `tailwindcss`, `gitignore`,
+and `vitest`. All options are fully typed.
+
+## CLI
+
+```bash
+eslint-waltz init     # create or update eslint.config.ts
+eslint-waltz version  # print the installed version
+```
+
+Use `eslint-waltz --help` to see the available commands. VS Code
+fix-on-save synchronization is part of `init`.
+
+## Advanced options
+
+### TypeScript scope
+
+`ts.files` limits the TypeScript files included by modules that automatically
+support TypeScript. JavaScript files keep their normal scope, and a module's
+own `files` option can narrow or override it. Vitest also intersects its test
+patterns with this scope.
+
+```ts
+export default waltz({
+  ts: { files: ['src/**/*.ts'] },
+  react: true,
+})
+```
+
+### Module resolution
+
+Potentially expensive module-resolution rules are disabled by default. Enable
+only the rules you need:
+
+```ts
+export default waltz({
+  imports: {
+    overrides: {
+      'imports/named': 'error',
+      'imports/namespace': 'error',
+    },
+  },
+})
+```
+
+### React settings
+
+```ts
+export default waltz({
+  react: {
+    settings: {
+      'react-x': { importSource: 'preact' },
+    },
+  },
+})
+```

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import process$1 from 'node:process';
-import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { readFile, mkdir, writeFile, rm, access } from 'node:fs/promises';
 import { join } from 'node:path';
+import { outro, note, intro, cancel, select, multiselect, confirm, CANCEL_SYMBOL } from '@clack/prompts';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -1508,30 +1510,430 @@ async function syncVSCodeSettings(cwd = process.cwd()) {
     return { changed, filePath };
 }
 
-async function main() {
-    const [command] = process$1.argv.slice(2);
-    if (command === '--help' || command === '-h') {
-        printHelp();
-        return;
-    }
-    if (command !== 'sync-vscode') {
-        printHelp();
-        process$1.exitCode = 1;
-        return;
-    }
-    const result = await syncVSCodeSettings();
-    console.log(result.changed
-        ? `Updated ${result.filePath}`
-        : `${result.filePath} is already synchronized`);
+const packageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+const perfectionistPresets = [
+    'recommended-alphabetical',
+    'recommended-natural',
+    'recommended-line-length',
+    'recommended-custom',
+];
+const features = [
+    'json',
+    'imports',
+    'perfectionist',
+    'typescript',
+    'react',
+    'tailwindcss',
+    'gitignore',
+    'vitest',
+];
+const eslintConfigFiles = [
+    'eslint.config.ts',
+    'eslint.config.mts',
+    'eslint.config.cts',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+];
+class PromptCancelledError extends Error {
+}
+async function runInit(runtime) {
+    const cwd = runtime.cwd ?? process$1.cwd();
+    const output = runtime.output ?? process$1.stdout;
+    const prompts = runtime.prompts
+        ?? createClackPrompts(runtime.input ?? process$1.stdin, output);
+    try {
+        prompts.intro(`eslint-waltz ${runtime.metadata.version}`);
+        const projectPackage = await readProjectPackage(cwd);
+        const existingConfigs = await findExistingConfigs(cwd);
+        if (existingConfigs.length > 0) {
+            const shouldReplace = await prompts.confirm(`Replace ${existingConfigs.join(', ')} with eslint.config.ts?`, false);
+            if (!shouldReplace) {
+                prompts.cancel('Initialization cancelled.');
+                return;
+            }
+        }
+        const installed = getInstalledDependencies(projectPackage);
+        const selections = await collectSelections(cwd, projectPackage, installed, prompts);
+        const requiredDependencies = getRequiredDependencies(runtime.metadata, selections);
+        const missingDependencies = requiredDependencies.filter(({ name }) => !installed.has(name));
+        let shouldInstall = false;
+        if (missingDependencies.length > 0) {
+            prompts.note(missingDependencies.map(({ spec }) => spec).join('\n'), 'Dependencies to install');
+            shouldInstall = await prompts.confirm('Install these dependencies?', true);
+        }
+        if (shouldInstall) {
+            const install = runtime.install ?? installDependencies;
+            await install(selections.packageManager, missingDependencies.map(({ spec }) => spec), cwd);
+        }
+        const configPath = join(cwd, 'eslint.config.ts');
+        await writeFile(configPath, createConfig(selections), 'utf8');
+        for (const fileName of existingConfigs) {
+            if (fileName !== 'eslint.config.ts') {
+                await rm(join(cwd, fileName));
+            }
+        }
+        const completed = [
+            `${existingConfigs.length > 0 ? 'Updated' : 'Created'} ${configPath}`,
+        ];
+        if (selections.vscode) {
+            const result = await syncVSCodeSettings(cwd);
+            completed.push(result.changed
+                ? `Updated ${result.filePath}`
+                : `${result.filePath} is already synchronized`);
+        }
+        if (missingDependencies.length > 0 && !shouldInstall) {
+            prompts.note(formatInstallCommand(selections.packageManager, missingDependencies.map(({ spec }) => spec)), 'Dependency installation skipped');
+        }
+        prompts.note(completed.join('\n'), 'Files');
+        prompts.outro('eslint-waltz is ready.');
+    }
+    catch (error) {
+        if (error instanceof PromptCancelledError) {
+            prompts.cancel('Initialization cancelled.');
+            return;
+        }
+        throw error;
+    }
+}
+async function collectSelections(cwd, projectPackage, installed, prompts) {
+    const detectedPackageManager = await detectPackageManager(cwd, projectPackage);
+    const packageManager = await prompts.select('Which package manager should install the dependencies?', packageManagers.map(value => ({ label: value, value })), detectedPackageManager);
+    const selectedFeatures = await prompts.multiselect('Which features should be enabled?', [
+        { hint: 'default', label: 'JSON and JSONC', value: 'json' },
+        { hint: 'default', label: 'Import validation', value: 'imports' },
+        { hint: 'default', label: 'Perfectionist sorting', value: 'perfectionist' },
+        { label: 'TypeScript', value: 'typescript' },
+        { label: 'React', value: 'react' },
+        { label: 'Tailwind CSS', value: 'tailwindcss' },
+        { label: '.gitignore', value: 'gitignore' },
+        { label: 'Vitest', value: 'vitest' },
+    ], await detectInitialFeatures(cwd, installed));
+    const enabledFeatures = new Set(selectedFeatures);
+    for (const feature of enabledFeatures) {
+        if (!isFeature(feature)) {
+            throw new Error(`Unsupported feature: ${feature}`);
+        }
+    }
+    const perfectionist = enabledFeatures.has('perfectionist')
+        ? await selectPerfectionistPreset(prompts)
+        : 'recommended-alphabetical';
+    const vscode = await prompts.confirm('Configure VS Code fix-on-save settings?', await fileExists(join(cwd, '.vscode')));
+    if (!isPackageManager(packageManager)) {
+        throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+    return {
+        features: enabledFeatures,
+        packageManager,
+        perfectionist,
+        vscode,
+    };
+}
+function createClackPrompts(input, output) {
+    const io = { input, output };
+    return {
+        cancel: message => cancel(message, io),
+        async confirm(message, initial) {
+            return unwrapPromptResult(await confirm({
+                ...io,
+                initialValue: initial,
+                message,
+            }));
+        },
+        intro: message => intro(message, io),
+        async multiselect(message, choices, initial) {
+            return unwrapPromptResult(await multiselect({
+                ...io,
+                initialValues: initial,
+                message,
+                options: [...choices],
+                required: false,
+            }));
+        },
+        note: (message, title) => note(message, title, io),
+        outro: message => outro(message, io),
+        async select(message, choices, initial) {
+            return unwrapPromptResult(await select({
+                ...io,
+                initialValue: initial,
+                message,
+                options: [...choices],
+            }));
+        },
+    };
+}
+function createConfig(selections) {
+    const options = [];
+    const { features } = selections;
+    if (features.has('gitignore')) {
+        options.push('  gitignore: true,');
+    }
+    if (!features.has('imports')) {
+        options.push('  imports: false,');
+    }
+    if (!features.has('json')) {
+        options.push('  json: false,');
+    }
+    if (!features.has('perfectionist')) {
+        options.push('  perfectionist: false,');
+    }
+    else if (selections.perfectionist !== 'recommended-alphabetical') {
+        options.push(`  perfectionist: { preset: '${selections.perfectionist}' },`);
+    }
+    if (features.has('react')) {
+        options.push('  react: true,');
+    }
+    if (features.has('tailwindcss')) {
+        options.push('  tailwindcss: true,');
+    }
+    if (features.has('typescript')) {
+        options.push('  ts: true,');
+    }
+    if (features.has('vitest')) {
+        options.push('  vitest: true,');
+    }
+    const invocation = options.length === 0
+        ? 'waltz()'
+        : `waltz({\n${options.join('\n')}\n})`;
+    return `import waltz from '@chanyuxi/eslint-waltz'\n\nexport default ${invocation}\n`;
+}
+async function detectInitialFeatures(cwd, installed) {
+    const initial = ['json', 'imports', 'perfectionist'];
+    if (installed.has('typescript')
+        || installed.has('typescript-eslint')
+        || await fileExists(join(cwd, 'tsconfig.json'))) {
+        initial.push('typescript');
+    }
+    if (installed.has('react') || installed.has('preact')) {
+        initial.push('react');
+    }
+    if (installed.has('tailwindcss')) {
+        initial.push('tailwindcss');
+    }
+    if (await fileExists(join(cwd, '.gitignore'))) {
+        initial.push('gitignore');
+    }
+    if (installed.has('vitest')) {
+        initial.push('vitest');
+    }
+    return initial;
+}
+async function detectPackageManager(cwd, projectPackage) {
+    const configured = projectPackage.packageManager?.split('@')[0];
+    if (isPackageManager(configured)) {
+        return configured;
+    }
+    const lockFiles = [
+        ['pnpm', 'pnpm-lock.yaml'],
+        ['yarn', 'yarn.lock'],
+        ['bun', 'bun.lock'],
+        ['bun', 'bun.lockb'],
+        ['npm', 'package-lock.json'],
+    ];
+    for (const [packageManager, lockFile] of lockFiles) {
+        if (await fileExists(join(cwd, lockFile))) {
+            return packageManager;
+        }
+    }
+    return 'npm';
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findExistingConfigs(cwd) {
+    const results = await Promise.all(eslintConfigFiles.map(async (fileName) => ({
+        exists: await fileExists(join(cwd, fileName)),
+        fileName,
+    })));
+    return results.filter(result => result.exists).map(result => result.fileName);
+}
+function formatInstallCommand(packageManager, dependencies) {
+    return getInstallCommand(packageManager, dependencies).join(' ');
 }
-function printHelp() {
-    console.log(`Usage: eslint-waltz <command>
-
-Commands:
-  sync-vscode  Create or update .vscode/settings.json for ESLint fix-on-save
+function getDependencySpec(metadata, name) {
+    if (name === metadata.name) {
+        return `${name}@${metadata.version}`;
+    }
+    const version = metadata.peerDependencies?.[name]
+        ?? metadata.dependencies?.[name]
+        ?? metadata.devDependencies?.[name];
+    return version ? `${name}@${version}` : name;
+}
+function getInstallCommand(packageManager, dependencies) {
+    switch (packageManager) {
+        case 'npm':
+            return ['npm', 'install', '--save-dev', ...dependencies];
+        case 'yarn':
+            return ['yarn', 'add', '--dev', ...dependencies];
+        default:
+            return [packageManager, 'add', '-D', ...dependencies];
+    }
+}
+function getInstalledDependencies(projectPackage) {
+    return new Set([
+        ...Object.keys(projectPackage.dependencies ?? {}),
+        ...Object.keys(projectPackage.devDependencies ?? {}),
+        ...Object.keys(projectPackage.optionalDependencies ?? {}),
+    ]);
+}
+function getRequiredDependencies(metadata, selections) {
+    const names = [metadata.name, 'eslint', 'jiti'];
+    const { features } = selections;
+    if (features.has('gitignore')) {
+        names.push('eslint-config-flat-gitignore');
+    }
+    if (features.has('imports')) {
+        names.push('eslint-plugin-import-x');
+    }
+    if (features.has('json')) {
+        names.push('eslint-plugin-jsonc', 'jsonc-eslint-parser');
+    }
+    if (features.has('perfectionist')) {
+        names.push('eslint-plugin-perfectionist');
+    }
+    if (features.has('react')) {
+        names.push('eslint-plugin-react-debug', 'eslint-plugin-react-dom', 'eslint-plugin-react-hooks-extra', 'eslint-plugin-react-naming-convention', 'eslint-plugin-react-web-api', 'eslint-plugin-react-x');
+    }
+    if (features.has('tailwindcss')) {
+        names.push('eslint-plugin-tailwindcss', 'tailwindcss');
+    }
+    if (features.has('typescript')) {
+        names.push('typescript', 'typescript-eslint');
+    }
+    if (features.has('vitest')) {
+        names.push('@vitest/eslint-plugin', 'vitest');
+    }
+    return names.map(name => ({
+        name,
+        spec: getDependencySpec(metadata, name),
+    }));
+}
+async function installDependencies(packageManager, dependencies, cwd) {
+    const [command, ...args] = getInstallCommand(packageManager, dependencies);
+    const child = spawn(command, args, {
+        cwd,
+        shell: process$1.platform === 'win32',
+        stdio: 'inherit',
+    });
+    await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${command} exited with code ${code ?? 'unknown'}.`));
+            }
+        });
+    });
+}
+function isFeature(value) {
+    return features.some(feature => feature === value);
+}
+function isPackageManager(value) {
+    return packageManagers.some(packageManager => packageManager === value);
+}
+function isPerfectionistPreset(value) {
+    return perfectionistPresets.some(preset => preset === value);
+}
+async function readProjectPackage(cwd) {
+    const filePath = join(cwd, 'package.json');
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`package.json was not found in ${cwd}.`);
+        }
+        throw new Error(`Unable to read ${filePath}: ${error instanceof Error ? error.message : error}`);
+    }
+}
+async function selectPerfectionistPreset(prompts) {
+    const preset = await prompts.select('Which Perfectionist preset should be used?', [
+        {
+            hint: 'recommended',
+            label: 'Alphabetical',
+            value: 'recommended-alphabetical',
+        },
+        { label: 'Natural', value: 'recommended-natural' },
+        { label: 'Line length', value: 'recommended-line-length' },
+        { label: 'Custom', value: 'recommended-custom' },
+    ], 'recommended-alphabetical');
+    if (!isPerfectionistPreset(preset)) {
+        throw new Error(`Unsupported Perfectionist preset: ${preset}`);
+    }
+    return preset;
+}
+function unwrapPromptResult(result) {
+    if (result === CANCEL_SYMBOL) {
+        throw new PromptCancelledError();
+    }
+    return result;
+}
+
+async function readPackageMetadata() {
+    for (const relativePath of ['../package.json', '../../package.json']) {
+        try {
+            const source = await readFile(new URL(relativePath, import.meta.url), 'utf8');
+            const metadata = JSON.parse(source);
+            if (metadata.name === '@chanyuxi/eslint-waltz') {
+                return metadata;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    throw new Error('Unable to locate the eslint-waltz package metadata.');
+}
+
+async function runCli(args, runtime = {}) {
+    const output = runtime.output ?? process$1.stdout;
+    const [command, ...rest] = args;
+    if ((command === '--help' || command === '-h') && rest.length === 0) {
+        printHelp(output);
+        return 0;
+    }
+    if (command === 'version' && rest.length === 0) {
+        const metadata = runtime.metadata ?? await readPackageMetadata();
+        output.write(`${metadata.version}\n`);
+        return 0;
+    }
+    if (command === 'init' && rest.length === 0) {
+        const metadata = runtime.metadata ?? await readPackageMetadata();
+        await runInit({
+            cwd: runtime.cwd,
+            input: runtime.input,
+            install: runtime.install,
+            metadata,
+            output,
+            prompts: runtime.prompts,
+        });
+        return 0;
+    }
+    printHelp(output);
+    return 1;
+}
+function printHelp(output) {
+    output.write(`Usage: eslint-waltz <command>
+
+Commands:
+  version  Display the installed eslint-waltz version
+  init     Interactively create eslint.config.ts
 `);
 }
-main().catch((error) => {
+
+runCli(process$1.argv.slice(2)).then((exitCode) => {
+    process$1.exitCode = exitCode;
+}, (error) => {
     console.error(error instanceof Error ? error.message : error);
     process$1.exitCode = 1;
 });

package/dist/core.d.ts

@@ -0,0 +1,5 @@
+import { WaltzOptions, LinterConfig } from './types.js';
+
+declare function waltz(options?: WaltzOptions, ...orders: LinterConfig[]): Promise<LinterConfig[]>;
+
+export { waltz as default };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { WaltzOptions, LinterConfig } from './types.js';
-export { ImportsOptions, JsOptions, JsoncOptions, PerfectionistOptions, PerfectionistPreset, ReactOptions, SharedOptions, StylisticOptions, TailwindcssOptions, TsOptions, UnresolvedLinterConfig, VitestOptions } from './types.js';
+import waltz from './core.js';
+export { ImportsOptions, JsOptions, JsoncOptions, LinterConfig, PerfectionistOptions, PerfectionistPreset, ReactOptions, SharedOptions, StylisticOptions, TailwindcssOptions, TsOptions, UnresolvedLinterConfig, VitestOptions, WaltzOptions } from './types.js';
 
-declare function waltz(options?: WaltzOptions, ...orders: LinterConfig[]): Promise<LinterConfig[]>;
 
-export { LinterConfig, WaltzOptions, waltz as default };
+
+export { waltz as default };

package/dist/index.js

@@ -92,32 +92,6 @@ const JSON_FILES = '**/*.{json,json5,jsonc}';
 const PACKAGE_JSON_FILES = ['**/package.json'];
 const TS_CONFIG_FILES = ['**/[jt]sconfig.json', '**/[jt]sconfig.*.json'];
 const INTERNAL_IMPORT_GLOB = '@/**';
-function getImportOrderGroups() {
-    return [
-        'type',
-        'builtin',
-        'external',
-        'internal',
-        'parent',
-        'sibling',
-        'index',
-        'object',
-        'unknown',
-    ];
-}
-function getPerfectionistImportGroups() {
-    return [
-        'type',
-        'builtin',
-        'external',
-        'internal',
-        'parent',
-        'sibling',
-        'index',
-        'style',
-        'unknown',
-    ];
-}
 
 function getScriptFiles(scope) {
     return scope.isEnableTypeScript
@@ -200,7 +174,17 @@ async function importsConfig(scriptScope, options = {}) {
                     orderImportKind: 'asc',
                 },
                 'distinctGroup': false,
-                'groups': getImportOrderGroups(),
+                'groups': [
+                    'type',
+                    'builtin',
+                    'external',
+                    'internal',
+                    'parent',
+                    'sibling',
+                    'index',
+                    'object',
+                    'unknown',
+                ],
                 'named': true,
                 'newlines-between': 'always',
                 'pathGroups': [
@@ -606,7 +590,17 @@ async function perfectionistConfig(options = {}, scriptScope) {
                     'error',
                     {
                         ...importSortOptions,
-                        groups: getPerfectionistImportGroups(),
+                        groups: [
+                            'type',
+                            'builtin',
+                            'external',
+                            'internal',
+                            'parent',
+                            'sibling',
+                            'index',
+                            'style',
+                            'unknown',
+                        ],
                         internalPattern: ['^@/.+'],
                     },
                 ],
@@ -1115,6 +1109,12 @@ async function waltz(options = {}, ...orders) {
     const isEnableReact = !!options.react;
     const { scriptScope } = resolveFileScopes(options);
     const configs = [];
+    if (options.globalIgnores) {
+        configs.push({
+            ignores: options.globalIgnores,
+            name: 'waltz/global-ignores',
+        });
+    }
     if (options.gitignore) {
         configs.push(gitignore(options.gitignore));
     }

package/dist/types.d.ts

@@ -88,6 +88,13 @@ interface WaltzOptions {
      * @see https://github.com/antfu/eslint-config-flat-gitignore
      */
     gitignore?: boolean | FlatGitignoreOptions;
+    /**
+     * Glob patterns to ignore globally.
+     *
+     * These patterns are applied by ESLint before any of Waltz's file-scoped
+     * configurations.
+     */
+    globalIgnores?: Linter.Config['ignores'];
     /**
      * Enable rules for validating imports and exports. Import ordering is
      * provided by Perfectionist when enabled, and by `imports/order` otherwise.

package/package.json

@@ -1,151 +1,152 @@
-{
-  "name": "@chanyuxi/eslint-waltz",
-  "type": "module",
-  "version": "1.3.2",
-  "packageManager": "pnpm@10.4.1",
-  "description": "A composable ESLint flat config for JavaScript, TypeScript, JSONC, imports, React, Tailwind CSS, Perfectionist, and Vitest.",
-  "author": "chanyuxi <2438149743@qq.com> (https://github.com/chanyuxi)",
-  "license": "ISC",
-  "homepage": "https://github.com/chanyuxi/eslint-waltz",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/chanyuxi/eslint-waltz.git"
-  },
-  "bugs": {
-    "url": "https://github.com/chanyuxi/eslint-waltz/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "chanyuxi",
-    "eslint",
-    "config",
-    "integration"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
-  "bin": {
-    "eslint-waltz": "dist/cli.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=20.19.0"
-  },
-  "scripts": {
-    "build": "rimraf ./dist && pnpm gen && rollup -c rollup.config.ts --configPlugin @rollup/plugin-typescript",
-    "gen": "tsx scripts/typegen.ts",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "typeCheck": "pnpm gen && tsc --noEmit -p tsconfig.test.json",
-    "test": "vitest run",
-    "check": "pnpm run typeCheck && pnpm run lint && pnpm run test",
-    "changeset": "changeset",
-    "version": "changeset version && pnpm install --lockfile-only",
-    "release": "changeset publish",
-    "prepack": "pnpm build",
-    "prepare": "husky"
-  },
-  "peerDependencies": {
-    "@vitest/eslint-plugin": "^1.6.27",
-    "eslint": "^10.10.0",
-    "eslint-config-flat-gitignore": "^2.4.0",
-    "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsonc": "^3.4.2",
-    "eslint-plugin-perfectionist": "^5.11.0",
-    "eslint-plugin-react-debug": "^5.19.0",
-    "eslint-plugin-react-dom": "^5.19.0",
-    "eslint-plugin-react-hooks-extra": "^2.13.0",
-    "eslint-plugin-react-naming-convention": "^5.19.0",
-    "eslint-plugin-react-web-api": "^5.19.0",
-    "eslint-plugin-react-x": "^5.19.0",
-    "eslint-plugin-tailwindcss": "^4.4.0",
-    "jsonc-eslint-parser": "^3.3.0",
-    "tailwindcss": "^4.0.0",
-    "typescript-eslint": "^8.70.0"
-  },
-  "peerDependenciesMeta": {
-    "@vitest/eslint-plugin": {
-      "optional": true
-    },
-    "eslint-config-flat-gitignore": {
-      "optional": true
-    },
-    "eslint-plugin-react-debug": {
-      "optional": true
-    },
-    "eslint-plugin-react-dom": {
-      "optional": true
-    },
-    "eslint-plugin-react-hooks-extra": {
-      "optional": true
-    },
-    "eslint-plugin-react-naming-convention": {
-      "optional": true
-    },
-    "eslint-plugin-react-web-api": {
-      "optional": true
-    },
-    "eslint-plugin-react-x": {
-      "optional": true
-    },
-    "eslint-plugin-tailwindcss": {
-      "optional": true
-    },
-    "tailwindcss": {
-      "optional": true
-    },
-    "typescript-eslint": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "@eslint/js": "^10.0.1",
-    "@stylistic/eslint-plugin": "^5.10.0",
-    "globals": "^17.12.0",
-    "jsonc-parser": "^3.3.1"
-  },
-  "devDependencies": {
-    "@changesets/cli": "^3.0.2",
-    "@commitlint/cli": "^19.8.1",
-    "@commitlint/config-conventional": "^19.8.1",
-    "@commitlint/types": "^19.8.1",
-    "@rollup/plugin-commonjs": "^28.0.6",
-    "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-typescript": "^12.1.4",
-    "@types/node": "^24.1.0",
-    "@vitest/eslint-plugin": "^1.6.27",
-    "eslint": "^10.10.0",
-    "eslint-config-flat-gitignore": "^2.4.0",
-    "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsonc": "^3.4.2",
-    "eslint-plugin-perfectionist": "^5.11.0",
-    "eslint-plugin-react-debug": "^5.19.0",
-    "eslint-plugin-react-dom": "^5.19.0",
-    "eslint-plugin-react-hooks-extra": "^2.13.0",
-    "eslint-plugin-react-naming-convention": "^5.19.0",
-    "eslint-plugin-react-web-api": "^5.19.0",
-    "eslint-plugin-react-x": "^5.19.0",
-    "eslint-plugin-tailwindcss": "^4.4.0",
-    "eslint-typegen": "^2.3.1",
-    "husky": "^9.1.7",
-    "jiti": "^2.7.0",
-    "jsonc-eslint-parser": "^3.3.0",
-    "rimraf": "^6.0.1",
-    "rollup": "^4.46.2",
-    "rollup-plugin-dts": "^6.2.1",
-    "tailwindcss": "^4.3.3",
-    "tslib": "^2.8.1",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.70.0",
-    "vitest": "^4.0.18"
-  }
-}
+{
+  "name": "@chanyuxi/eslint-waltz",
+  "type": "module",
+  "version": "1.5.0",
+  "packageManager": "pnpm@10.4.1",
+  "description": "A composable ESLint flat config for JavaScript, TypeScript, JSONC, imports, React, Tailwind CSS, Perfectionist, and Vitest.",
+  "author": "chanyuxi <2438149743@qq.com> (https://github.com/chanyuxi)",
+  "license": "ISC",
+  "homepage": "https://github.com/chanyuxi/eslint-waltz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chanyuxi/eslint-waltz.git"
+  },
+  "bugs": {
+    "url": "https://github.com/chanyuxi/eslint-waltz/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "chanyuxi",
+    "eslint",
+    "config",
+    "integration"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "eslint-waltz": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "rimraf ./dist && pnpm gen && rollup -c rollup.config.ts --configPlugin @rollup/plugin-typescript",
+    "gen": "tsx scripts/typegen.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typeCheck": "pnpm gen && tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest run",
+    "check": "pnpm run typeCheck && pnpm run lint && pnpm run test",
+    "changeset": "changeset",
+    "version": "changeset version && pnpm install --lockfile-only",
+    "release": "changeset publish",
+    "prepack": "pnpm build",
+    "prepare": "husky"
+  },
+  "peerDependencies": {
+    "@vitest/eslint-plugin": "^1.6.27",
+    "eslint": "^10.10.0",
+    "eslint-config-flat-gitignore": "^2.4.0",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-jsonc": "^3.4.2",
+    "eslint-plugin-perfectionist": "^5.11.0",
+    "eslint-plugin-react-debug": "^5.19.0",
+    "eslint-plugin-react-dom": "^5.19.0",
+    "eslint-plugin-react-hooks-extra": "^2.13.0",
+    "eslint-plugin-react-naming-convention": "^5.19.0",
+    "eslint-plugin-react-web-api": "^5.19.0",
+    "eslint-plugin-react-x": "^5.19.0",
+    "eslint-plugin-tailwindcss": "^4.4.0",
+    "jsonc-eslint-parser": "^3.3.0",
+    "tailwindcss": "^4.0.0",
+    "typescript-eslint": "^8.70.0"
+  },
+  "peerDependenciesMeta": {
+    "@vitest/eslint-plugin": {
+      "optional": true
+    },
+    "eslint-config-flat-gitignore": {
+      "optional": true
+    },
+    "eslint-plugin-react-debug": {
+      "optional": true
+    },
+    "eslint-plugin-react-dom": {
+      "optional": true
+    },
+    "eslint-plugin-react-hooks-extra": {
+      "optional": true
+    },
+    "eslint-plugin-react-naming-convention": {
+      "optional": true
+    },
+    "eslint-plugin-react-web-api": {
+      "optional": true
+    },
+    "eslint-plugin-react-x": {
+      "optional": true
+    },
+    "eslint-plugin-tailwindcss": {
+      "optional": true
+    },
+    "tailwindcss": {
+      "optional": true
+    },
+    "typescript-eslint": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "globals": "^17.12.0",
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^3.0.2",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@commitlint/types": "^19.8.1",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@types/node": "^24.1.0",
+    "@vitest/eslint-plugin": "^1.6.27",
+    "eslint": "^10.10.0",
+    "eslint-config-flat-gitignore": "^2.4.0",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-jsonc": "^3.4.2",
+    "eslint-plugin-perfectionist": "^5.11.0",
+    "eslint-plugin-react-debug": "^5.19.0",
+    "eslint-plugin-react-dom": "^5.19.0",
+    "eslint-plugin-react-hooks-extra": "^2.13.0",
+    "eslint-plugin-react-naming-convention": "^5.19.0",
+    "eslint-plugin-react-web-api": "^5.19.0",
+    "eslint-plugin-react-x": "^5.19.0",
+    "eslint-plugin-tailwindcss": "^4.4.0",
+    "eslint-typegen": "^2.3.1",
+    "husky": "^9.1.7",
+    "jiti": "^2.7.0",
+    "jsonc-eslint-parser": "^3.3.0",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.46.2",
+    "rollup-plugin-dts": "^6.2.1",
+    "tailwindcss": "^4.3.3",
+    "tslib": "^2.8.1",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^4.0.18"
+  }
+}