Locate and bundle third-party dependencies in node_modules
Last updated a day ago by shellscape .
MIT · Repository · Bugs · Original npm · Tarball · package.json
$ cnpm install @rollup/plugin-node-resolve 
SYNC missed versions from official npm registry.

npm size libera manifesto


???? A Rollup plugin which locates modules using the Node resolution algorithm, for using third party modules in node_modules


This plugin requires an LTS Node version (v8.0.0+) and Rollup v1.20.0+.


Using npm:

npm install @rollup/plugin-node-resolve --save-dev


Create a rollup.config.js configuration file and import the plugin:

import { nodeResolve } from '@rollup/plugin-node-resolve';

export default {
  input: 'src/index.js',
  output: {
    dir: 'output',
    format: 'cjs'
  plugins: [nodeResolve()]

Then call rollup either via the CLI or the API.



Type: Boolean
Default: false

If true, instructs the plugin to use the "browser" property in package.json files to specify alternative files to load for bundling. This is useful when bundling for a browser environment. Alternatively, a value of 'browser' can be added to the mainFields option. If false, any "browser" properties in package files will be ignored. This option takes precedence over mainFields.


Type: Object
Default: null

An Object that specifies additional options that should be passed through to resolve.

customResolveOptions: {
  moduleDirectory: 'js_modules'


Type: Array[...String]
Default: []

An Array of modules names, which instructs the plugin to force resolving for the specified modules to the root node_modules. Helps to prevent bundling the same package multiple times if package is imported from dependencies.

dedupe: ['my-package', '@namespace/my-package'];

This will deduplicate bare imports such as:

import 'my-package';
import '@namespace/my-package';

And it will deduplicate deep imports such as:

import 'my-package/foo.js';
import '@namespace/my-package/bar.js';


Type: Array[...String]
Default: ['.mjs', '.js', '.json', '.node']

Specifies the extensions of files that the plugin will operate on.


Type: String
Default: '/'

Locks the module search within specified path (e.g. chroot). Modules defined outside this path will be marked as external.


Type: Array[...String]
Default: ['module', 'main']
Valid values: ['browser', 'jsnext:main', 'module', 'main']

Specifies the properties to scan within a package.json, used to determine the bundle entry point. The order of property names is significant, as the first-found property is used as the resolved entry point. If the array contains 'browser', key/values specified in the package.json browser property will be used.


DEPRECATED: use "resolveOnly" instead


Type: Boolean
Default: true

If true, the plugin will prefer built-in modules (e.g. fs, path). If false, the plugin will look for locally installed modules of the same name.


Type: Boolean
Default: false

If true, inspect resolved files to assert that they are ES2015 modules.


Type: Array[...String|RegExp]
Default: null

An Array which instructs the plugin to limit module resolution to those whose names match patterns in the array. Note: Modules not matching any patterns will be marked as external.

Example: resolveOnly: ['batman', /^@batcave\/.*$/]


Type: String
Default: process.cwd()

Specifies the root directory from which to resolve modules. Typically used when resolving entry-point imports, and when resolving deduplicated modules. Useful when executing rollup in a package of a mono-repository.

// Set the root directory to be the parent folder
rootDir: path.join(process.cwd(), '..')

Using with @rollup/plugin-commonjs

Since most packages in your node_modules folder are probably legacy CommonJS rather than JavaScript modules, you may need to use @rollup/plugin-commonjs:

// rollup.config.js
import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';

export default {
  input: 'main.js',
  output: {
    file: 'bundle.js',
    format: 'iife',
    name: 'MyModule'
  plugins: [resolve(), commonjs()]

Resolving Built-Ins (like fs)

This plugin won't resolve any builtins (e.g. fs). If you need to resolve builtins you can install local modules and set preferBuiltins to false, or install a plugin like rollup-plugin-node-polyfills which provides stubbed versions of these methods.

If you want to silence warnings about builtins, you can add the list of builtins to the externals option; like so:

import resolve from '@rollup/plugin-node-resolve';
import builtins from 'builtin-modules'
export default ({
  input: ...,
  plugins: [resolve()],
  external: builtins,
  output: ...




Current Tags

  • 8.4.0                                ...           latest (a day ago)

11 Versions

  • 8.4.0                                ...           a day ago
  • 8.1.0                                ...           22 days ago
  • 8.0.1                                ...           a month ago
  • 8.0.0                                ...           2 months ago
  • 7.1.3                                ...           3 months ago
  • 7.1.2                                ...           3 months ago
  • 7.1.1                                ...           5 months ago
  • 7.1.0                                ...           5 months ago
  • 7.0.0                                ...           6 months ago
  • 6.1.0                                ...           6 months ago
  • 6.0.0                                ...           7 months ago
Today 279
This Week 941
This Month 6,217
Last Day 662
Last Week 3,288
Last Month 13,500
Dependencies (7)
Dev Dependencies (10)
Dependents (421)

Copyright 2014 - 2016 © taobao.org |