Neverending Pile of Messages

    @rollup/plugin-node-resolve
    TypeScript icon, indicating that this package has built-in type declarations

    6.1.0 • Public • Published

    npm size libera manifesto

    @rollup/plugin-node-resolve

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

    Requirements

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

    Install

    Using npm:

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

    Usage

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

    import resolve from '@rollup/plugin-node-resolve';
    
    export default {
      input: 'src/index.js',
      output: {
        dir: 'output',
        format: 'cjs'
      },
      plugins: [resolve()]
    };

    Then call rollup either via the CLI or the API.

    Options

    mainFields

    Type: Array[...String]
    Default: ['module', 'main']
    Valid values: ['browser', 'jsnext', '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.

    module

    DEPRECATED: use "mainFields" instead

    Use pkg.module field for ES6 module if possible. This option takes precedence over both "jsnext" and "main" in the list if such are present.

    jsnext

    DEPRECATED: use "mainFields" instead

    Use pkg['jsnext:main'] if possible, legacy field pointing to ES6 module in third-party libraries, deprecated in favor of pkg.module, see: https://github.com/rollup/rollup/wiki/pkg.module. This option takes precedence over "main" in the list if such is present.

    main

    DEPRECATED: use "mainFields" instead

    Use pkg.main field or index.js, even if it's not an ES6 module (needs to be converted from CommonJS to ES6), see https://github.com/rollup/rollup-plugin-commonjs.

    browser

    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.

    extensions

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

    Resolve extensions other than .js in the order specified.

    preferBuiltins

    Type: Boolean
    Default: true

    Whether to prefer built-in modules (e.g. fs, path) or local ones with the same names

    jail

    Type: String
    Default: '/'

    Lock the module search in this path (like a chroot). Modules defined outside this path will be marked as external.

    only

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

    Example: only: ['some_module', /^@some_scope\/.*$/]

    modulesOnly

    Type: Boolean
    Default: false

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

    dedupe

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

    Force resolving for these modules to root's node_modules that helps to prevent bundling the same package multiple times if package is imported from dependencies.

    dedupe: [ 'react', 'react-dom' ]
    

    customResolveOptions

    Type: Boolean
    Default: null

    Any additional options that should be passed through to node-resolve.

    customResolveOptions: {
      moduleDirectory: 'js_modules'
    }
    

    rootDir

    Type: String
    Default: process.cwd()

    Root directory to resolve modules from. Used when resolving entrypoint imports, and when resolving deduplicated modules. Useful when executing rollup in a package of a monorepository.

    // 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-builtins 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: ...
    })

    Meta

    CONTRIBUTING

    LICENSE (MIT)

    Install

    npm i @rollup/plugin-node-resolve@6.1.0

    Version

    6.1.0

    License

    MIT

    Unpacked Size

    51.9 kB

    Total Files

    7

    Last publish

    Collaborators

    • shellscape
    • rich_harris
    • guybedford
    • lukastaegert