ESLint plugin with rules that help validate proper imports.
Latest commit b5a962f Feb 16, 2017 @ntdb ntdb committed with jfmengels Add `count` option to `newline-after-import` (#742)
* Add `newlines` option to `newline-after-import`

* Add tests for `newline-after-import` option and fix linter errors in test file

* Fix broken tests, add docs


* Add schema and further testing for `newlines` option on `newline-after-import`

* Change `newlines` option to `count` for `newline-after-import` rule

* Fix missing plural in docs

* Add links in changelog and thank @ntdb :)

* Add links to rules in changelog
Failed to load latest commit information.
config Merge branch 'v2' Sep 24, 2016
docs/rules Add `count` option to `newline-after-import` (#742) Feb 16, 2017
memo-parser first draft: eslint-module-utils as a separate package Jul 2, 2016
resolvers actually bump to webpack 0.8.1 😅 (it's been too long) Jan 19, 2017
src Add `count` option to `newline-after-import` (#742) Feb 16, 2017
tests Add `count` option to `newline-after-import` (#742) Feb 16, 2017
utils bump utils/v2, v2.2.0 Nov 7, 2016
.babelrc Merge branch 'master' into v2 Jul 13, 2016
.coveralls.yml set up coveralls Nov 14, 2015
.editorconfig reverted Makefile changes to .editorconfig Jan 17, 2016
.eslintrc.yml enabled no-extraneous-dependencies to avoid this in the future Oct 6, 2016
.gitignore printing test coverage out to console for resolvers (#440) Jul 17, 2016
.travis.yml travis: remove Node 0.10 Jul 2, 2016 Add `count` option to `newline-after-import` (#742) Feb 16, 2017 (#258) May 23, 2016
LICENSE Initial commit Apr 18, 2015 Add `no-anonymous-default-export` rule (#712) Jan 21, 2017 first draft of release steps in `` Nov 2, 2016
appveyor.yml cleaned up build (fix #417) + made coverage work again (fix #403) try… Jul 12, 2016
gulpfile.js cleaned up build (fix #417) + made coverage work again (fix #403) try… Jul 12, 2016
import.sublime-project Sublime: ignore coverage Jul 26, 2016
package.json Use `read-pkg-up` over `pkg-up`. (#680) Dec 15, 2016


build status Coverage Status win32 build status npm npm downloads

This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, and prevent issues with misspelling of file paths and import names. All the goodness that the ES2015+ static module syntax intends to provide, marked up in your editor.

IF YOU ARE USING THIS WITH SUBLIME: see the bottom section for important info.


Static analysis:

  • Ensure imports point to a file/module that can be resolved. (no-unresolved)
  • Ensure named imports correspond to a named export in the remote file. (named)
  • Ensure a default export is present, given a default import. (default)
  • Ensure imported namespaces contain dereferenced properties as they are dereferenced. (namespace)
  • Restrict which files can be imported in a given folder (no-restricted-paths)
  • Forbid import of modules using absolute paths (no-absolute-path)
  • Forbid require() calls with expressions (no-dynamic-require)
  • Prevent importing the submodules of other modules (no-internal-modules)
  • Forbid Webpack loader syntax in imports (no-webpack-loader-syntax)

Helpful warnings:

Module systems:

  • Report potentially ambiguous parse goal (script vs. module) (unambiguous)
  • Report CommonJS require calls and module.exports or exports.*. (no-commonjs)
  • Report AMD require and define calls. (no-amd)
  • No Node.js builtin modules. (no-nodejs-modules)

Style guide:


npm install eslint-plugin-import -g

or if you manage ESLint as a dev dependency:

# inside your project's working tree
npm install eslint-plugin-import --save-dev

All rules are off by default. However, you may configure them manually in your .eslintrc.(yml|json|js), or extend one of the canned configs:

  - eslint:recommended
  - plugin:import/errors
  - plugin:import/warnings

# or configure manually:
  - import

  import/no-unresolved: [2, {commonjs: true, amd: true}]
  import/named: 2
  import/namespace: 2
  import/default: 2
  import/export: 2
  # etc...


With the advent of module bundlers and the current state of modules and module syntax specs, it's not always obvious where import x from 'module' should look to find the file behind module.

Up through v0.10ish, this plugin has directly used substack's resolve plugin, which implements Node's import behavior. This works pretty well in most cases.

However, Webpack allows a number of things in import module source strings that Node does not, such as loaders (import 'file!./whatever') and a number of aliasing schemes, such as externals: mapping a module id to a global name at runtime (allowing some modules to be included more traditionally via script tags).

In the interest of supporting both of these, v0.11 introduces resolvers.

Currently Node and Webpack resolution have been implemented, but the resolvers are just npm packages, so third party packages are supported (and encouraged!).

You can reference resolvers in several ways(in order of precedence):

  • as a conventional eslint-import-resolver name, like eslint-import-resolver-foo:
# .eslintrc.yml
  # uses 'eslint-import-resolver-foo':
  import/resolver: foo
// .eslintrc.js
module.exports = {
  settings: {
    'import/resolver': {
      foo: { someConfig: value }
  • with a full npm module name, like my-awesome-npm-module:
# .eslintrc.yml
  import/resolver: 'my-awesome-npm-module'
// .eslintrc.js
module.exports = {
  settings: {
    'import/resolver': {
      'my-awesome-npm-module': { someConfig: value }
  • with a filesystem path to resolver, defined in this example as a computed property name:
// .eslintrc.js
module.exports = {
  settings: {
    'import/resolver': {
      [path.resolve('../../../my-resolver')]: { someConfig: value }

Relative paths will be resolved relative to the source's nearest package.json or the process's current working directory if no package.json is found.

If you are interesting in writing a resolver, see the spec for more details.


You may set the following settings in your .eslintrc:


A list of file extensions that will be parsed as modules and inspected for exports.

This defaults to ['.js'], unless you are using the react shared config, in which case it is specified as ['.js', '.jsx'].

Note that this is different from (and likely a subset of) any import/resolver extensions settings, which may include .json, .coffee, etc. which will still factor into the no-unresolved rule.

Also, the following import/ignore patterns will overrule this list.


A list of regex strings that, if matched by a path, will not report the matching module if no exports are found. In practice, this means rules other than no-unresolved will not report on any imports with (absolute filesystem) paths matching this pattern.

no-unresolved has its own ignore setting.

    - \.coffee$          # fraught with parse errors
    - \.(scss|less|css)$ # can't parse unprocessed CSS modules, either


An array of additional modules to consider as "core" modules--modules that should be considered resolved but have no path on the filesystem. Your resolver may already define some of these (for example, the Node resolver knows about fs and path), so you need not redefine those.

For example, Electron exposes an electron module:

import 'electron'  // without extra config, will be flagged as unresolved!

that would otherwise be unresolved. To avoid this, you may provide electron as a core module:

# .eslintrc.yml
  import/core-modules: [ electron ]

In Electron's specific case, there is a shared config named electron that specifies this for you.

Contribution of more such shared configs for other platforms are welcome!


An array of folders. Resolved modules only from those folders will be considered as "external". By default - ["node_modules"]. Makes sense if you have configured your path or webpack to handle your internal paths differently and want to considered modules from some folders, for example bower_components or jspm_modules, as "external".


A map from parsers to file extension arrays. If a file extension is matched, the dependency parser will require and use the map key as the parser instead of the configured ESLint parser. This is useful if you're inter-op-ing with TypeScript directly using Webpack, for example:

# .eslintrc.yml
    typescript-eslint-parser: [ .ts, .tsx ]

In this case, typescript-eslint-parser must be installed and require-able from the running eslint module's location (i.e., install it as a peer of ESLint).

This is currently only tested with typescript-eslint-parser but should theoretically work with any moderately ESTree-compliant parser.

It's difficult to say how well various plugin features will be supported, too, depending on how far down the rabbit hole goes. Submit an issue if you find strange behavior beyond here, but steel your heart against the likely outcome of closing with wontfix.


See resolvers.


Settings for cache behavior. Memoization is used at various levels to avoid the copious amount of fs.statSync/module parse calls required to correctly report errors.

For normal eslint console runs, the cache lifetime is irrelevant, as we can strongly assume that files should not be changing during the lifetime of the linter process (and thus, the cache in memory)

For long-lasting processes, like eslint_d or eslint-loader, however, it's important that there be some notion of staleness.

If you never use eslint_d or eslint-loader, you may set the cache lifetime to Infinity and everything should be fine:

# .eslintrc.yml
    lifetime: ∞  # or Infinity

Otherwise, set some integer, and cache entries will be evicted after that many seconds have elapsed:

# .eslintrc.yml
    lifetime: 5  # 30 is the default


SublimeLinter-eslint introduced a change to support .eslintignore files which altered the way file paths are passed to ESLint when linting during editing. This change sends a relative path instead of the absolute path to the file (as ESLint normally provides), which can make it impossible for this plugin to resolve dependencies on the filesystem.

This workaround should no longer be necessary with the release of ESLint 2.0, when .eslintignore will be updated to work more like a .gitignore, which should support proper ignoring of absolute paths via --stdin-filename.

In the meantime, see roadhump/SublimeLinter-eslint#58 for more details and discussion, but essentially, you may find you need to add the following SublimeLinter config to your Sublime project file:

            "path": "code"
                "chdir": "${project}/code"

Note that ${project}/code matches the code provided at folders[0].path.

The purpose of the chdir setting, in this case, is to set the working directory from which ESLint is executed to be the same as the directory on which SublimeLinter-eslint bases the relative path it provides.

See the SublimeLinter docs on chdir for more information, in case this does not work with your project.

If you are not using .eslintignore, or don't have a Sublime project file, you can also do the following via a .sublimelinterrc file in some ancestor directory of your code:

  "linters": {
    "eslint": {
      "args": ["--stdin-filename", "@"]

I also found that I needed to set rc_search_limit to null, which removes the file hierarchy search limit when looking up the directory tree for .sublimelinterrc:

In Package Settings / SublimeLinter / User Settings:

  "user": {
    "rc_search_limit": null

I believe this defaults to 3, so you may not need to alter it depending on your project folder max depth.