0
# Core Configuration
1

2
Primary function for creating Nuxt-optimized ESLint configurations with extensive customization options and automatic feature detection.
3

4
## Capabilities
5

6
### Create Configuration for Nuxt
7

8
Creates an array of ESLint flat configs for Nuxt 3 projects with intelligent defaults and extensive customization options.
9

10
```typescript { .api }
11
/**
12
 * Create an array of ESLint flat configs for Nuxt 3, based on the given options.
13
 * Accepts appending user configs as rest arguments from the second argument.
14
 * 
15
 * For Nuxt apps, it's recommended to use @nuxt/eslint module instead.
16
 * @param options - Configuration options for features and directories
17
 * @param userConfigs - Additional user-provided configurations to append
18
 * @returns FlatConfigComposer for further configuration chaining
19
 */
20
function createConfigForNuxt(
21
  options?: NuxtESLintConfigOptions,
22
  ...userConfigs: ResolvableFlatConfig[]
23
): FlatConfigComposer;
24

25
interface NuxtESLintConfigOptions {
26
  /** Feature configuration options */
27
  features?: NuxtESLintFeaturesOptions;
28
  /** Directory structure configuration */
29
  dirs?: DirectoriesConfig;
30
}
31
```
32

33
**Usage Examples:**
34

35
```typescript
36
import { createConfigForNuxt } from "@nuxt/eslint-config";
37

38
// Minimal configuration with all defaults
39
export default createConfigForNuxt();
40

41
// Enable TypeScript with strict rules
42
export default createConfigForNuxt({
43
  features: {
44
    typescript: {
45
      strict: true,
46
      tsconfigPath: "./tsconfig.json"
47
    }
48
  }
49
});
50

51
// Full-featured configuration
52
export default createConfigForNuxt({
53
  features: {
54
    standalone: true,
55
    typescript: true,
56
    stylistic: {
57
      indent: 2,
58
      quotes: "single",
59
      semi: false
60
    },
61
    tooling: {
62
      jsdoc: true,
63
      unicorn: true,
64
      regexp: true
65
    },
66
    formatters: {
67
      css: "prettier",
68
      html: "prettier",
69
      markdown: "dprint"
70
    },
71
    import: {
72
      package: "eslint-plugin-import-x"
73
    }
74
  },
75
  dirs: {
76
    src: ["./src", "./app"],
77
    components: ["./src/components", "./components"],
78
    pages: ["./src/pages", "./pages"]
79
  }
80
},
81
// Additional custom rules
82
{
83
  rules: {
84
    "no-console": "warn",
85
    "prefer-const": "error"
86
  }
87
});
88
```
89

90
### Feature Configuration Options
91

92
Comprehensive configuration interface for enabling/disabling and customizing various ESLint features.
93

94
```typescript { .api }
95
interface NuxtESLintFeaturesOptions {
96
  /**
97
   * Setup basic JavaScript, TypeScript and Vue plugins and rules.
98
   * You might want to disable it when using other ESLint config that handles basic setup.
99
   * @default true
100
   */
101
  standalone?: boolean;
102

103
  /**
104
   * Enable rules for Nuxt module authors or library authors.
105
   * @experimental Changes might not follow semver
106
   * @default false
107
   */
108
  tooling?: boolean | ToolingOptions;
109

110
  /**
111
   * Enable the import plugin
112
   * @default true
113
   */
114
  import?: boolean | ImportPluginOptions;
115

116
  /**
117
   * Enable stylistic ESLint rules for formatting and code style check
118
   * @see https://eslint.style/guide/config-presets
119
   * @default false
120
   */
121
  stylistic?: boolean | StylisticCustomizeOptions;
122

123
  /**
124
   * Enable formatters to handle formatting for different file types.
125
   * Requires eslint-plugin-format to be installed.
126
   * @default false
127
   */
128
  formatters?: boolean | OptionsFormatters;
129

130
  /**
131
   * Options for Nuxt specific rules
132
   */
133
  nuxt?: NuxtSpecificOptions;
134

135
  /**
136
   * Enable TypeScript support. Can also be an object to config the options.
137
   * By default it enables automatically when typescript is installed in the project.
138
   */
139
  typescript?: boolean | TypeScriptOptions;
140
}
141

142
interface ToolingOptions {
143
  /**
144
   * Enable RegExp rules
145
   * @see https://github.com/ota-meshi/eslint-plugin-regexp
146
   * @default true
147
   */
148
  regexp?: boolean;
149
  
150
  /**
151
   * Enable Unicorn rules
152
   * @see https://github.com/sindresorhus/eslint-plugin-unicorn
153
   * @default true
154
   */
155
  unicorn?: boolean;
156
  
157
  /**
158
   * Enable jsdoc rules
159
   * @default true
160
   */
161
  jsdoc?: boolean;
162
}
163

164
interface TypeScriptOptions {
165
  /**
166
   * Enable strict rules
167
   * @see https://typescript-eslint.io/users/configs#strict
168
   * @default true
169
   */
170
  strict?: boolean;
171
  
172
  /**
173
   * Path to the tsconfig file, when this is provided, type-aware rules will be enabled.
174
   */
175
  tsconfigPath?: string;
176
}
177
```
178

179
### Directory Configuration
180

181
Configure directory structure for Nuxt project organization and rule application.
182

183
```typescript { .api }
184
interface DirectoriesConfig {
185
  /** Nuxt source directory */
186
  src?: string[];
187
  /** Root directory for nuxt project */
188
  root?: string[];
189
  /** Directory for pages */
190
  pages?: string[];
191
  /** Directory for layouts */
192
  layouts?: string[];
193
  /** Directory for components */
194
  components?: string[];
195
  /** Directory for components with prefix (ignores vue/multi-word-component-names) */
196
  componentsPrefixed?: string[];
197
  /** Directory for composables */
198
  composables?: string[];
199
  /** Directory for plugins */
200
  plugins?: string[];
201
  /** Directory for modules */
202
  modules?: string[];
203
  /** Directory for middleware */
204
  middleware?: string[];
205
  /** Directory for server */
206
  servers?: string[];
207
}
208
```
209

210
**Usage Examples:**
211

212
```typescript
213
// Custom directory structure
214
export default createConfigForNuxt({
215
  dirs: {
216
    root: ["."],
217
    src: ["./src"],
218
    pages: ["./src/pages"],
219
    components: ["./src/components", "./src/ui"],
220
    composables: ["./src/composables", "./src/utils"],
221
    plugins: ["./src/plugins"],
222
    middleware: ["./src/middleware"],
223
    servers: ["./src/server"]
224
  }
225
});
226

227
// Multi-app setup
228
export default createConfigForNuxt({
229
  dirs: {
230
    root: ["./apps/web", "./apps/admin"],
231
    src: ["./apps/web/src", "./apps/admin/src"],
232
    components: ["./shared/components", "./apps/*/components"]
233
  }
234
});
235
```
236

237
### Nuxt-Specific Options
238

239
Configuration options specific to Nuxt projects and development patterns.
240

241
```typescript { .api }
242
interface NuxtSpecificOptions {
243
  /**
244
   * Sort keys in nuxt.config to maintain a consistent order
245
   * @default true when features.stylistic is enabled
246
   */
247
  sortConfigKeys?: boolean;
248
}
249
```
250

251
### Import Plugin Options
252

253
Configuration for the import/export linting plugin with support for different implementations.
254

255
```typescript { .api }
256
interface ImportPluginOptions {
257
  /**
258
   * The import plugin to use
259
   * @default 'eslint-plugin-import-x'
260
   */
261
  package?: 'eslint-plugin-import-lite' | 'eslint-plugin-import-x';
262
}
263
```