Important
ESLint 10 + JSX: This release supports ESLint 10 (while keeping ESLint 9 support). JSX/TSX files are still parsed and the JSX style rules still apply, but the React-specific logic rules (from eslint-plugin-react) are temporarily removed because eslint-plugin-react is not yet compatible with ESLint 10 (jsx-eslint/eslint-plugin-react#3977). They return once a v10-compatible React plugin is adopted. Tracking: #350.
Note
ESM, Node.js and TypeScript versions: neostandard is now an ESM package requiring Node.js ^22.13.0 || >=24. CommonJS configs keep working unchanged — require('neostandard') returns the neostandard function with plugins and resolveIgnoresFromGitignore attached, same as before (they are also proper ESM named exports, the preferred form). For the ts option, the supported TypeScript range for the installed typescript package tops out at 6.0 (typescript-eslint's peer is <6.1.0, and TypeScript 7 ships no compiler API for tooling until 7.1) — TypeScript 7 users should install typescript@npm:@typescript/typescript6 for linting and alias TS7 separately for tsc, per Microsoft's side-by-side guidance.
- Quick Start
- Configuration options
- Extending
- Additional exports
- Missing for 1.0.0 release
- Differences to standard / eslint-config-standard 17.x
- Config helper
- Readme badges
- Mission statement
- Governance
- Used by
npm install -D neostandard eslint- (Validate that it runs cleanly by running
npx neostandard --help, see #267) npx neostandard --migrate > eslint.config.js(uses our config helper)- Replace
standardwitheslintin all places where you runstandard, eg."scripts"and.github/workflows/(neostandardCLI tracked in #2) - (Add ESLint editor integration, eg. VS Code ESLint extension)
- Cleanup:
npm uninstall standard- Remove unused
"standard"top level key from yourpackage.json - Deactivate
standardspecific integrations if you no longer use them (eg. vscode-standard))
-
npm install -D neostandard eslint -
Add an
eslint.config.js:Using config helper:
npx neostandard --esm > eslint.config.jsOr to get CommonJS:
npx neostandard > eslint.config.jsOr manually create the file as ESM:
import { neostandard } from 'neostandard' export default neostandard({ // options })
Or as CommonJS:
module.exports = require('neostandard')({ // options })
-
Run
neostandardby running ESLint, eg. usingnpx eslint,npx eslint --fixor similar
All examples below use ESM (ECMAScript Modules) syntax. If you're using CommonJS (CJS), replace the import/export statements with the following:
// Replace
import { neostandard } from 'neostandard'
export default neostandard({ /* options */ })
// With
const neostandard = require('neostandard')
module.exports = neostandard({ /* options */ })Here's a basic example of how to configure neostandard:
import { neostandard } from 'neostandard'
export default neostandard({
ts: true, // an option
// Add other options here
})The options below allow you to customize neostandard for your project. Use them to add global variables, ignore files, enable TypeScript support, and more.
-
env-string[]- adds additional globals by importing them from the globals npm moduleimport { neostandard } from 'neostandard' export default neostandard({ env: ['browser', 'mocha'], // Add browser and mocha global variables })
-
files-string[]- additional file patterns to match. Uses the same shape as ESLintfilesimport { neostandard } from 'neostandard' export default neostandard({ files: ['src/**/*.js', 'tests/**/*.js'], // Also lint these patterns (neostandard's built-in JS/TS patterns still apply) })
-
filesTs-string[]- additional file patterns for the TypeScript configs to match. Uses the same shape as ESLintfilesimport { neostandard } from 'neostandard' export default neostandard({ ts: true, // Enable TypeScript support filesTs: ['src/**/*.ts', 'tests/**/*.ts'], // Also lint these as TypeScript (neostandard's built-in TS patterns still apply) })
-
globals-string[] | object- an array of names of globals or an object of the same shape as ESLintlanguageOptions.globalsUsing an array:
import { neostandard } from 'neostandard' export default neostandard({ globals: ['$', 'jQuery'], // Treat $ and jQuery as global variables })
Using an object:
import { neostandard } from 'neostandard' export default neostandard({ globals: { $: 'readonly', // $ is a read-only global jQuery: 'writable', // jQuery can be modified localStorage: 'off', // Disable the localStorage global }, })
-
ignores-string[]- glob patterns that prevent neostandard's own config layers from applying to matching files. These are not global ignores: other configs in your flat config can still lint those files. This is a change from v0.13.0; see ESLint's ignore documentation.import { neostandard } from 'neostandard' export default neostandard({ ignores: ['dist/**/*', 'tests/**'], // Skip these files in neostandard's config layers })
To ignore files globally across all configs (the v0.13.0 behavior), use ESLint's
globalIgnores()instead:import { globalIgnores } from 'eslint/config' import { neostandard, resolveIgnoresFromGitignore } from 'neostandard' export default [ globalIgnores(resolveIgnoresFromGitignore()), ...neostandard(), ]
-
noJsx-boolean- if set, skips JSX parsing and the JSX style rules. (Note: the React-specific logic rules are currently not included regardless — pending ESLint 10 support; see the note at the top and #350) -
noStyle-boolean- if set, no style rules will be added. Especially useful when combined with Prettier, dprint or similarimport { neostandard } from 'neostandard' export default neostandard({ noStyle: true, // Disable style-related rules (useful with Prettier or dprint) })
-
semi-boolean- if set, enforce rather than forbid semicolons (same assemistandarddid)import { neostandard } from 'neostandard' export default neostandard({ semi: true, // Enforce semicolons (like semistandard) })
-
ts-boolean- if set, TypeScript syntax will be supported and*.ts(including*.d.ts) will be checked. To add additional file patterns to the TypeScript checks, usefilesTsimport { neostandard } from 'neostandard' export default neostandard({ ts: true, // Enable TypeScript support and lint .ts files })
The neostandard() function returns an ESLint config array which is intended to be exported directly or, if you want to modify or extend the config, can be combined with other configs using ESLint's defineConfig helper (from eslint/config):
import { defineConfig } from 'eslint/config'
import { neostandard } from 'neostandard'
import jsdoc from 'eslint-plugin-jsdoc'
export default defineConfig([
...neostandard(),
jsdoc.configs['flat/recommended-typescript-flavor'],
])Do note that neostandard() is intended to be a complete linting config in itself, only extend it if you have needs that goes beyond what neostandard provides, and open an issue if you believe neostandard itself should be extended or changed in that direction.
It's recommended to stay compatible with the plain config when extending and only make your config stricter, not relax any of the rules, as your project would then still pass when using just the plain neostandard-config, which helps people know what baseline to expect from your project.
Warning
Scope your rule-tweak layers. neostandard defines its plugins only for the JS/TS files it owns, so a config object that adjusts eg. @stylistic/* rules without a files scope applies to every lintable file — and as soon as any other language is linted (package.json via eslint-plugin-package-json, @eslint/json, @eslint/markdown, …) that file sees a rule for a plugin that isn't defined there, which is a fatal could not find plugin config error. Scope such layers with the exported globs:
import { defineConfig } from 'eslint/config'
import { globs, neostandard } from 'neostandard'
export default defineConfig([
...neostandard(),
{
files: [...globs.all], // the same files neostandard itself touches
rules: {
'@stylistic/comma-dangle': ['warn', { arrays: 'always-multiline' }],
},
},
])neostandard scopes all of its rules to the JavaScript and TypeScript files it owns (.js, .cjs, .mjs, .jsx, .ts, .tsx, plus whatever you add through the files / filesTs options). It will not apply its rules to other languages, so it composes directly with the official ESLint language plugins:
import { defineConfig } from 'eslint/config'
import { neostandard } from 'neostandard'
import markdown from '@eslint/markdown'
import json from '@eslint/json'
export default defineConfig([
...neostandard(),
...markdown.configs.recommended,
{ ...json.configs.recommended, files: ['**/*.json'], language: 'json/json' },
])Fenced code blocks inside Markdown (the virtual *.md/*.js files produced by @eslint/markdown's processor) are intentionally not linted by neostandard for now — see #296. To lint them yourself, add your own config block scoped to **/*.md/**.
If you need to apply neostandard to a non-default set of files (or scope it to a subdirectory), wrap it with ESLint's defineConfig and its extends — the parent files/ignores propagate into every layer:
import { defineConfig } from 'eslint/config'
import { neostandard } from 'neostandard'
export default defineConfig([
{ files: ['packages/app/**/*.js'], extends: [neostandard()] },
])As of neostandard v0.13.0, eslint-plugin-import-x has been removed to reduce dependency weight and installation complexity. For most projects, TypeScript's compiler (tsc) provides superior import/export checking with full project context.
If you still need ESLint-based import checking, you can add it back manually:
import { defineConfig } from 'eslint/config'
import { neostandard } from 'neostandard'
import importX from 'eslint-plugin-import-x'
export default defineConfig([
...neostandard(),
{
plugins: {
'import-x': importX
},
rules: {
'import-x/export': 'error',
'import-x/first': 'error',
'import-x/no-absolute-path': ['error', { esmodule: true, commonjs: true, amd: false }],
'import-x/no-duplicates': 'error',
'import-x/no-named-default': 'error',
'import-x/no-webpack-loader-syntax': 'error',
}
}
])For TypeScript projects, you may also want to add the TypeScript resolver:
import { defineConfig } from 'eslint/config'
import { neostandard } from 'neostandard'
import importX from 'eslint-plugin-import-x'
import { createTypeScriptImportResolver } from 'eslint-import-resolver-typescript'
export default defineConfig([
...neostandard(),
{
plugins: {
'import-x': importX
},
settings: {
'import-x/resolver-next': [
createTypeScriptImportResolver({
project: './tsconfig.json'
})
]
},
rules: {
'import-x/export': 'error',
'import-x/first': 'error',
'import-x/no-absolute-path': ['error', { esmodule: true, commonjs: true, amd: false }],
'import-x/no-duplicates': 'error',
'import-x/no-named-default': 'error',
'import-x/no-webpack-loader-syntax': 'error',
}
}
])Recommended alternative: Use TypeScript's compiler for import checking instead:
tsc --noEmitThis provides more comprehensive checking including type imports, module resolution, and cross-file validation.
Finds a .gitignore file that resides in the same directory as the ESLint config file and returns matching glob patterns. Passing them to neostandard({ ignores }) skips those files in neostandard's layers only. To skip them for every config, pass the patterns to ESLint's globalIgnores() (the v0.13.0 behavior).
Global ESM example:
import { globalIgnores } from 'eslint/config'
import { neostandard, resolveIgnoresFromGitignore } from 'neostandard'
export default [
globalIgnores(resolveIgnoresFromGitignore()),
...neostandard(),
]To scope the ignores to neostandard only, pass them as an option instead:
import { neostandard, resolveIgnoresFromGitignore } from 'neostandard'
export default neostandard({
ignores: resolveIgnoresFromGitignore(),
})CommonJS (global ignores):
const { globalIgnores } = require('eslint/config')
const neostandard = require('neostandard')
module.exports = [
globalIgnores(neostandard.resolveIgnoresFromGitignore()),
...neostandard(),
]neostandard exports all the ESLint plugins that it uses. This to ensure that users who need to reference the plugin themselves will use the exact same instance of the plugin, which is a necessity when a plugin prefix is defined in multiple places.
@stylistic- export of@stylistic/eslint-pluginn- export ofeslint-plugin-npromise- export ofeslint-plugin-promisetypescript-eslint- export oftypescript-eslint
(The react plugin export is temporarily removed along with the React logic rules — see the note at the top.)
If one eg. wants to add the eslint-plugin-n recommended config, then one can do:
import { defineConfig } from 'eslint/config'
import { neostandard, plugins } from 'neostandard'
export default defineConfig([
...neostandard(),
plugins.n.configs['flat/recommended'],
])Full list in 1.0.0 milestone
- Open governance, resolving governance issue
- Built for ESLint 9 and ESLint 10
- Relies on ESLint flat config to bundle plugins rather than custom
standard-engine - Replaces deprecated ESLint style rules with
eslint-stylisticrules - Defaults to the
standardbehaviour of bundling JSX-support (ported fromeslint-config-standard-jsx) with anoJsxoption that deactivates it; the React-specific logic rules are temporarily removed pending ESLint 10 compatibility of the React plugin (see #350) - Built in options replaces need for separate modules
tsoption makes*.tsfiles be checked as well (used to be handled byts-standard)semioption enforces rather than ban semicolons (used to be handled bysemistandard)noStyleoption deactivates style rules (used to require something likeeslint-config-prettier)
@stylistic/comma-dangle– changed – set to ignore dangling commas in arrays, objects, imports, exports and is it set towarnrather thanerror@stylistic/no-multi-spaces– changed – setsignoreEOLCommentstotrue, useful for aligning comments across multiple linedot-notation– deactivated – clashes with thenoPropertyAccessFromIndexSignaturecheck in TypeScriptn/no-deprecated-api– changed – changed towarninstead oferroras they are not urgent to fix
You can use the provided CLI tool to generate a config for you:
neostandard --semi --ts > eslint.config.jsTo see all available flags, run:
neostandard --helpThe CLI tool can also migrate an existing "standard" configuration from package.json:
neostandard --migrate > eslint.config.jsMigrations can also be extended, so to eg. migrate a semistandard setup, do:
neostandard --semi --migrate > eslint.config.jsYes! If you use neostandard in your project, you can include one of these badges in
your readme to let people know that your code is using the neostandard style.
[](https://github.com/neostandard/neostandard)[](https://github.com/neostandard/neostandard)[](https://github.com/neostandard/neostandard)Prior to the 1.0.0 release we are still rapidly evolving with fixes and improvements to reach rule parity with standard, hence more breaking changes will be experienced until then, as well as evolution of this statement
neostandard intends to set an expectable baseline for project linting that's descriptive of best practices rather than prescriptive of any opinionated approach.
neostandardrules describes current best practices in the community and help align developers, contributors and maintainers along thoseneostandardrules are not a tool to promote changed practices within the community by prescribing new such practicesneostandardrule changes and additions should be aligned with projects prior to being released, by eg. sending PR:s to them to align them ahead of time. When new best practices are incompatible with current best practices, rules should first be relaxed to allow for both approaches, then be made stricter when the community has moved to the new approachneostandardrule changes and additions should improve the description of project best practices, not prescribe new practicesneostandardshould, when faced with no clear best practice, avoid adding such a rule as it risks becoming prescriptive rather than descriptive. If leaving out such a rule would makeneostandardan incomplete baseline config, and the community is split between a few clear alternatives (such assemi), then making it configurable can enable it to still be added, but that should only be done in exceptional cases
neostandard is a community project with open governance.
See GOVERNANCE.md for specifics.
A subset of some of the projects that rely on neostandard: