Design Converter
- Technologies
Flutter
React
Shopify
Flutter
React
Shopify
- Resource
Discord
Discord
Design Converter
Flutter
React
Shopify
Flutter
React
Shopify
Discord
Discord
Education
Last updated on Mar 18, 2025
•17 mins read
Last updated on Mar 18, 2025
•17 mins read
Upgrading to the latest linting standards will make your development workflow smoother and your project’s code better. Migration to ESLint 9 is hard, but with this blog, you’ll be fine.
This article covers everything you need to know about upgrading to ESLint 9. You’ll learn how to prepare your project, handle breaking changes, and update your config file without stress.
We’ll start with the basics like the new flat config format and the new config system. Then we’ll go through troubleshooting common issues and make sure your setup works with popular plugins.
Before we continue, let’s take a look at a high-level technical overview to help you visualize the migration process.
The first step in any migration is proper preparation. Developers need to assess their current configuration setups (e.g., their .eslintrc file). It is crucial to back up your existing configuration file before initiating any migration script. Start by reviewing the breaking changes that come with ESLint v9. These changes include a new default configuration file structure and the removal of several legacy features.
Begin by ensuring that your development environment is ready, particularly by confirming that your Node.js version meets the requirement; ESLint v9 officially drops support for Node.js versions lower than v18.18. This update not only improves performance but also aligns your project with modern JavaScript standards.
Moreover, you should identify which file types and .eslintrc configuration file formats are affected. With the migration to v9, all configurations must now be defined using the new flat config file format. This means that whether your configuration file is in JSON, YAML, or JavaScript, it will need to be updated.
It is also advisable to verify that all your popular plugins and ESLint plugin import modules are up to date. This ensures that when you configure ESLint, every custom plugin works as intended. Preparing ahead will help reduce the risk of encountering unexpected parsing errors during the migration process.
Understanding the breaking changes is critical for a successful migration. ESLint v9 introduces significant modifications that affect how developers write their configuration file. One of the most notable changes is the introduction of the new flat config format, which replaces the older .eslintrc style.
These breaking changes also affect several ESLint rules, including no-unused-vars and other rules designed to improve code quality. For example, some ESLint plugin and ESLint plugin import rules have been modified to enforce stricter checks. Developers should double-check their configurations to ensure that custom rules are still compatible.
Furthermore, with ESLint v9, configuration comments in the source code no longer override the configuration file’s settings when only severity is specified. This means that if you have been using configuration comments for quick fixes, you may need to adjust your approach. It is essential to review every instance where such behavior was previously acceptable.
In addition, breaking changes have affected the way the .eslintignore file is interpreted. Now, ignoring files must be more explicit and robust. Ensure that any environment variable used for ignoring files is set correctly.
The flat config format is a major part of ESLint v9, offering a more straightforward and flexible approach to defining your configuration file. By using a configuration array, you can now structure your configuration in a more organized manner, making it easier to read and maintain.
This new flat config format simplifies the process of defining rules for various file types and supports different glob pattern configurations. When you configure ESLint with the flat config file, you can manage your rules with greater precision and clarity.
Take a look at this code snippet demonstrating a basic flat config file:
1export default [ 2 { 3 files: ["*.js", "*.ts"], 4 languageOptions: { 5 parser: require("typescript-eslint-parser"), 6 parserOptions: { project: "./tsconfig.json" }, 7 }, 8 rules: { 9 "no-unused-vars": "error", 10 "no-console": "warn", 11 }, 12 }, 13];
In the snippet above, the export default keyword is used to define the configuration array. This new configuration not only streamlines the configuration file but also enhances overall code quality. With this format, you are able to import ESLint and JavaScript modules directly into your configuration file.
As you transition, remember that every configuration file now adheres to the new format, which means that even your .eslintrc file must be updated. The benefits include improved visibility of applied rules and easier management of multiple configurations.
The configuration file is the cornerstone of your migration. Every developer must update their configuration file to meet the new system requirements. This file is responsible for specifying custom rules, file extensions, and additional rules that govern your linting process.
The configuration file plays a crucial role in managing various file types (e.g., .js, .cjs, .mjs, and .ts). Developers should carefully review the generated configuration file produced by the migration script. Note that a generated configuration file might require manual adjustments post-migration, as the migration script only supports simple JavaScript configuration files.
A robust configuration file enables you to set specific rules for different environments. For example, you might need to define globals for browser environments and specific settings for Node.js projects. The new configuration system facilitates such flexibility by allowing you to define a configuration array that contains separate configurations for each file group.
Furthermore, developers can use compatibility utilities within the configuration file to handle legacy code issues. This is particularly important for projects that heavily rely on custom rules and complex .eslintrc logic.
One of the most valuable tools for this process is the ESLint Configuration Migrator. This migration script helps convert your old .eslintrc file into the new flat config file format. By running npx eslint migrate config, you can automatically generate a new configuration file that adheres to the latest configuration system.
The ESLint Configuration Migrator supports most basic configurations and converts them into the new format. However, it is important to review the generated configuration file after running the migrator. Manual adjustments may be necessary to ensure that every custom plugin and additional rule is correctly configured.
This tool also assists in managing command-line options. For example, it will update your command-line usage to incorporate changes like the new --quiet flag behavior, which now excludes rules set to warn from being executed. Developers should be mindful of these changes as they update ESLint on the command line.
Keep in mind that while the migrator covers most cases, more complex .eslintrc setups might require a careful review post-migration. By ensuring your configuration file aligns with the new flat config format, you can avoid many common errors and improve your code quality.
Migrating your existing configuration file is a detailed process that involves running the migration script and refining the output. You can run npx eslint migrate config from the command line, which automates much of the conversion of your .eslintrc file to a new configuration file.
After executing the migration script, developers must examine the generated configuration file closely. Often, there will be areas that need manual intervention, especially if your previous .eslintrc file contained logic that the migrator could not interpret. It is essential to adjust settings—such as those for TypeScript ESLint and global imports—to ensure full compatibility with TypeScript ESLint configurations.
During the migration process, be aware of specific command-line arguments passed to the migrator. These arguments help generate a CommonJS file if necessary. For example, adding the --commonjs flag during execution will produce a CommonJS file for environments that require it.
The process of migrating your configuration file can feel overwhelming at first, but with the help of the ESLint Configuration Migrator and a thorough review of the generated file, you can achieve a smooth migration to v9.
Once your configuration file has been migrated, the next step is to configure ESLint using the new system. This involves not only updating your configuration file but also familiarizing yourself with the new flat config structure and its implications.
Configuring ESLint now requires you to write a configuration that uses a configuration array. This array allows you to define rules clearly and concisely and supports multiple configurations for different file types. This approach is especially beneficial for projects that require specific rules based on file extensions.
For example, if you need to set different rules for JavaScript and TypeScript files, you can define a separate entry in your configuration array for each file group. Consider the following code snippet:
1export default [ 2 { 3 files: ["*.js", "*.cjs"], 4 rules: { 5 "no-console": "error", 6 "no-unused-vars": "warn", 7 }, 8 }, 9 { 10 files: ["*.ts", "*.mjs"], 11 languageOptions: { 12 parser: require("typescript-eslint-parser"), 13 parserOptions: { project: "./tsconfig.json" }, 14 }, 15 rules: { 16 "no-unused-vars": "error", 17 "no-console": "warn", 18 }, 19 }, 20];
This setup not only boosts code quality but also ensures that your configuration file is future-proof and adheres to the latest ESLint standards.
Managing TypeScript ESLint configurations is an integral part of upgrading to ESLint v9. The new configuration system streamlines how you set up TypeScript ESLint by allowing you to import and integrate the TypeScript ESLint parser directly into your configuration file. This approach provides a unified configuration that covers both JavaScript and TypeScript projects.
When configuring TypeScript ESLint, ensure that you update ESLint and the TypeScript ESLint modules within your configuration file. You may need to manually configure additional rules specific to TypeScript ESLint—such as setting up the parser and managing parser options—to avoid any parsing errors during linting. Leveraging the new configuration system can simplify the integration of custom plugin setups.
Properly managing TypeScript ESLint ensures that your project adheres to both the new flat config file standards and best practices for TypeScript ESLint integration. This guarantees that your configuration remains robust and scalable for future updates.
Keeping your ESLint updated is essential for benefiting from the latest improvements and compatibility enhancements. Upgrading to ESLint v9 ensures that you can leverage the new configuration file and flat config format, as well as take advantage of enhanced command-line features and plugin integrations.
Before updating ESLint, review the breaking changes and verify that your project's Node.js version meets the requirements. Run a simple command-line test to check your current ESLint version and then update ESLint using your package manager. For example:
1npm install eslint@latest --save-dev
After the update, run ESLint on your project to check for any errors or warnings. This step is critical to ensuring that the new configuration system is functioning correctly and that there are no issues with custom or additional rules.
Remember to update any references to eslint migrate config .eslintrc.json in your project documentation and verify that the newly generated configuration file is being used by your command-line tools.
ESLint v9 introduces changes to linter options and command-line flags that require your attention. One notable update is the behavior of the --quiet flag, which now excludes rules set to warn. This change affects how you interpret errors and warnings when running ESLint on the command line.
Moreover, the removal of the --no-eslintrc flag means that you must now rely solely on your configuration file for defining rules. When configuring ESLint on the command line, ensure that you adjust any custom flags and update documentation accordingly.
The new configuration file enforces that all ESLint command-line operations use the flat config format. As a result, updating ESLint on the command line becomes a straightforward process that aligns with modern linting practices. Additionally, note that the --output-file flag now writes a file even when the output is empty—a critical detail when automating linting as part of a continuous integration process.
With the migration to v9, several features and rules have been removed or deprecated. For example, the require-jsdoc and valid-jsdoc rules are no longer supported, so developers must update their configuration file accordingly. This removal emphasizes the need to replace deprecated rules with new ones and adjust any configurations that relied on legacy behavior.
When dealing with removed features, update your .eslintrc file and configuration file to eliminate outdated rules. In some cases, multiple configurations that were previously managed via inline configuration comments are now processed collectively. Reviewing and removing such outdated rules will help avoid parsing errors during linting.
Maintaining high code quality is a top priority during the migration process. By updating your configuration file to the new flat config format, you not only improve readability but also enforce stricter custom rules that enhance code quality. Custom rules are essential for ensuring that your files adhere to the best coding practices.
When configuring ESLint, you can define custom rules for various file types. For example, you might set up specific rules for JavaScript files and different rules for TypeScript files. This is achieved by using a configuration array that targets specific file extensions and file paths.
Consider the following example, which demonstrates how to configure custom rules using glob patterns:
1export default [ 2 { 3 files: ["src//*.js"], 4 rules: { 5 "no-unused-vars": "error", 6 "no-console": "warn", 7 }, 8 }, 9 { 10 files: ["src//*.ts"], 11 languageOptions: { 12 parser: require("typescript-eslint-parser"), 13 parserOptions: { project: "./tsconfig.json" }, 14 }, 15 rules: { 16 "no-unused-vars": "error", 17 "no-console": "warn", 18 }, 19 }, 20];
This new configuration not only defines specific rules for different file types but also leverages popular plugins that have been updated to support the new flat config file format. By doing so, you are taking advantage of the latest ESLint version and ensuring that your configuration file remains robust and scalable.
Despite careful planning, errors may still arise during the migration. Troubleshooting these common errors is an essential step to ensure a successful migration. The generated configuration file may sometimes produce a parsing error or trigger a no-unused-vars warning if the rules are not set up correctly.
When you encounter an error, the first step is to review your configuration file in detail. Run npx eslint migrate config .eslintrc.json and perform a thorough lint check on your files. Common error messages often point to specific issues within your configuration, such as misconfigured custom rules or incompatible plugins.
It is also helpful to check the command-line output for hints about which specific files or keys are causing issues. In many cases, resolving these errors simply requires updating the configuration file or adjusting the glob pattern to target the correct file types.
Don’t hesitate to use compatibility utilities or refer to additional documentation provided by TypeScript ESLint when troubleshooting. This proactive approach can save time and reduce frustration during the migration process.
A significant aspect of migrating to ESLint v9 is ensuring that all plugins are compatible with the new configuration system. Many popular plugins have been updated, but it is important to verify that each ESLint plugin referenced in your configuration file is fully compatible with ESLint v9.
Start by reviewing the release notes for each plugin and updating them as necessary. Your configuration file should reflect any required changes by these plugins, including modifications to custom plugin settings and import directives. Developers should note that the configuration file must be updated to accommodate new plugin versions that adhere to the new flat config format.
Regularly double-check plugin compatibility, especially after updating ESLint. Running ESLint on the command line and reviewing any error messages can help you identify issues related to outdated plugins or configuration discrepancies.
Optimizing your project’s configuration is the final step in ensuring a smooth migration to v9. After updating your configuration file and reviewing the generated file, take some time to fine-tune your settings. This includes refining custom rules, managing file extensions, and verifying that your environment variable settings for ignoring files are correct.
Optimizing your configuration file not only improves code quality but also streamlines the linting process. By configuring ESLint to recognize the new flat config format, you benefit from a simpler, more efficient system that minimizes redundancy. Developers should also define necessary globals and ensure the correct parser is used.
A well-optimized configuration file is easier to maintain and less prone to errors. Regularly update references to eslint migrate config .eslintrc.json and review your configuration after major project changes. This practice will help you maintain a consistent and error-free development environment.
Future-proofing your ESLint setup means preparing your configuration for ESLint v10 and beyond. The new flat config file format, which has been the default since ESLint v9, is designed to be robust and adaptable to future changes. Ensuring that your configuration file adheres to the new system will simplify future migrations and updates.
Developers should update any references to eslint migrate config .eslintrc.json and adopt the new configuration file as their standard. This transition involves not only updating custom rules but also verifying that all plugins and TypeScript ESLint configurations are aligned with the new flat config standards.
Keep an eye on compatibility utilities provided by ESLint and popular plugins. As new features are introduced, additional rules may be added to the configuration file. Staying proactive by reviewing breaking changes and periodically double-checking configurations will help you avoid surprises down the road.
Practical code snippets are invaluable for understanding the migration process. In this section, we will review several examples that demonstrate how to set up your new configuration file and integrate various plugins and rules. These examples show you how to use export default to expose your configuration array while incorporating both JavaScript and TypeScript ESLint settings.
Here is an example snippet that demonstrates a basic setup using the new flat config file format:
1// Basic configuration file using flat config 2export default [ 3 { 4 files: ["*.js"], 5 rules: { 6 "no-console": "warn", 7 "no-unused-vars": "error", 8 }, 9 }, 10 { 11 files: ["*.ts"], 12 languageOptions: { 13 parser: require("typescript-eslint-parser"), 14 parserOptions: { project: "./tsconfig.json" }, 15 }, 16 rules: { 17 "no-unused-vars": "error", 18 "no-console": "warn", 19 }, 20 }, 21];
For those looking to configure ESLint via the command line, here is a helpful snippet:
1npx eslint migrate config .eslintrc.json --commonjs
This command runs the migration script and outputs a generated configuration file, which you can then refine further. Such code quality improvements lead to fewer errors and a more maintainable project over time.
Migrating to ESLint v9 doesn’t have to be overwhelming. With a bit of planning and a clear understanding of the changes, you can make the transition smooth and straightforward. The new flat config format and tools like the ESLint Configuration Migrator can simplify the process and improve code consistency.
The key is to keep your configuration file organized. Make sure it reflects the latest TypeScript ESLint settings, custom plugin configurations, and command-line updates. This will help avoid conflicts and keep your linting process running smoothly.
Take the next step by checking your current .eslintrc file and running npx eslint migrate config to generate a new one. Update your custom rules and fine-tune your setup to keep your codebase clean and consistent. Migrating to ESLint v9 is a chance to improve your development workflow—one step at a time.
Tired of manually designing screens, coding on weekends, and technical debt? Let DhiWise handle it for you!
You can build an e-commerce store, healthcare app, portfolio, blogging website, social media or admin panel right away. Use our library of 40+ pre-built free templates to create your first application using DhiWise.
