Configuration Options

webpack is configured with an options object, usually exported from a webpack.config.js file. Every build validates that object against the options schema (schemas/WebpackOptions.json), so unknown or malformed options fail with a descriptive error. This page is generated from that schema and lists every supported option; named types link to their full definitions in the API documentation.

Set the value of require.amd and define.amd. Or disable AMD support.

export default {
  amd: false,
};

Report the first error as a hard error instead of tolerating it.

export default {
  bail: true,
};

Cache generated modules and chunks to improve performance for multiple incremental builds.

export default {
  cache: { type: "filesystem" },
};

Additionally cache computation of modules that are unchanged and reference only unchanged modules. Only used when type is set to "memory".

export default {
  cache: {
    type: "memory",
    cacheUnaffected: true,
  },
};

Number of generations unused cache entries stay in memory cache at minimum (1 = may be removed after unused for a single compilation, ..., Infinity: kept forever). Only used when type is set to "memory".

export default {
  cache: {
    type: "memory",
    maxGenerations: 0,
  },
};

In memory caching.

export default {
  cache: {
    type: "memory",
  },
};

Allows to collect unused memory allocated during deserialization. This requires copying data into smaller buffers and has a performance cost. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    allowCollectingMemory: true,
  },
};

Dependencies the build depends on (in multiple categories, default categories: 'defaultWebpack'). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    buildDependencies: {},
  },
};

Base directory for the cache (defaults to node_modules/.cache/webpack). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    cacheDirectory: '...',
  },
};

Locations for the cache (defaults to cacheDirectory / name). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    cacheLocation: '...',
  },
};

Compression type used for the cache files. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    compression: "gzip",
  },
};

Algorithm used for generation the hash (see node.js crypto package). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    hashAlgorithm: '...',
  },
};

Time in ms after which idle period the cache storing should happen. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    idleTimeout: 0,
  },
};

Time in ms after which idle period the cache storing should happen when larger changes has been detected (cumulative build time > 2 x avg cache store time). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    idleTimeoutAfterLargeChanges: 0,
  },
};

Time in ms after which idle period the initial cache storing should happen. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    idleTimeoutForInitialStore: 0,
  },
};

List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    immutablePaths: [],
  },
};

List of paths that are managed by a package manager and can be trusted to not be modified otherwise. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    managedPaths: [],
  },
};

Time for which unused cache entries stay in the filesystem cache at minimum (in milliseconds). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    maxAge: 0,
  },
};

Number of generations unused cache entries stay in memory cache at minimum (0 = no memory cache used, 1 = may be removed after unused for a single compilation, ..., Infinity: kept forever). Cache entries will be deserialized from disk when removed from memory cache. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    maxMemoryGenerations: 0,
  },
};

Additionally cache computation of modules that are unchanged and reference only unchanged modules in memory. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    memoryCacheUnaffected: true,
  },
};

Name for the cache. Different names will lead to different coexisting caches. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    name: '...',
  },
};

Track and log detailed timing information for individual cache items. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    profile: true,
  },
};

Enable/disable readonly mode. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    readonly: true,
  },
};

When to store data to the filesystem. (pack: Store data when compiler is idle in a single file). Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    store: "pack",
  },
};

Version of the cache data. Different versions won't allow to reuse the cache and override existing content. Update the version when config changed in a way which doesn't allow to reuse cache. This will invalidate the cache. Only used when type is set to "filesystem".

export default {
  cache: {
    type: "filesystem",
    version: '...',
  },
};

The base directory (absolute path!) for resolving the entry option. If output.pathinfo is set, the included pathinfo is shortened to this directory.

export default {
  context: '...',
};

References to other configurations to depend on.

export default {
  dependencies: [],
};

Options for the webpack-dev-server.

export default {
  devServer: false,
};

A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).

export default {
  devtool: "eval",
};

Enable and configure the Dotenv plugin to load environment variables from .env files.

export default {
  dotenv: true,
};

The directory from which .env files are loaded. Can be an absolute path, false will disable the .env file loading.

export default {
  dotenv: {
    dir: '...',
  },
};

Only expose environment variables that start with these prefixes. Defaults to 'WEBPACK_'.

export default {
  dotenv: {
    prefix: '...',
  },
};

Template patterns for .env file names. Use [mode] as placeholder for the webpack mode. Defaults to ['.env', '.env.local', '.env.[mode]', '.env.[mode].local'].

export default {
  dotenv: {
    template: [],
  },
};

The entry point(s) of the compilation.

export default {
  entry: '...',
};

Enables/Disables experiments (experimental features with relax SemVer compatibility).

export default {
  experiments: {},
};

Support WebAssembly as asynchronous EcmaScript Module.

export default {
  experiments: {
    asyncWebAssembly: true,
  },
};

Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.

export default {
  experiments: {
    backCompat: true,
  },
};

Build http(s): urls using a lockfile and resource content cache.

export default {
  experiments: {
    buildHttp: { allowedUris: [] },
  },
};

List of allowed URIs (resp. the beginning of them).

export default {
  experiments: {
    buildHttp: {
      allowedUris: [],
    },
  },
};

Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.

export default {
  experiments: {
    buildHttp: {
      cacheLocation: '...',
    },
  },
};

When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.

export default {
  experiments: {
    buildHttp: {
      frozen: true,
    },
  },
};

Location of the lockfile.

export default {
  experiments: {
    buildHttp: {
      lockfileLocation: '...',
    },
  },
};

Proxy configuration, which can be used to specify a proxy server to use for HTTP requests.

export default {
  experiments: {
    buildHttp: {
      proxy: '...',
    },
  },
};

When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.

export default {
  experiments: {
    buildHttp: {
      upgrade: true,
    },
  },
};

Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.

export default {
  experiments: {
    cacheUnaffected: true,
  },
};

Enable css support.

export default {
  experiments: {
    css: true,
  },
};

Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.

export default {
  experiments: {
    deferImport: true,
  },
};

Apply defaults of next major version.

export default {
  experiments: {
    futureDefaults: true,
  },
};

Enable experimental HTML support. This flag does not by itself make .html files usable directly as entry points without additional HTML handling.

export default {
  experiments: {
    html: true,
  },
};

Compile entrypoints and import()s only when they are accessed.

export default {
  experiments: {
    lazyCompilation: true,
  },
};

Specifies the backend that should be used for handling client keep alive.

export default {
  experiments: {
    lazyCompilation: {
      backend: {},
    },
  },
};

Enable/disable lazy compilation for entries.

export default {
  experiments: {
    lazyCompilation: {
      entries: true,
    },
  },
};

Enable/disable lazy compilation for import() modules.

export default {
  experiments: {
    lazyCompilation: {
      imports: true,
    },
  },
};

Specify which entrypoints or import()ed modules should be lazily compiled. This is matched with the imported module and not the entrypoint name.

export default {
  experiments: {
    lazyCompilation: {
      test: '...',
    },
  },
};

Allow output javascript files as module source type.

export default {
  experiments: {
    outputModule: true,
  },
};

Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.

export default {
  experiments: {
    sourceImport: true,
  },
};

Support WebAssembly as synchronous EcmaScript Module (outdated).

export default {
  experiments: {
    syncWebAssembly: true,
  },
};

Enable typescript support.

export default {
  experiments: {
    typescript: true,
  },
};

Extend configuration from another configuration (only works when using webpack-cli).

export default {
  extends: '...',
};

Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on output.libraryTarget.

export default {
  externals: '...',
};

Specify externals depending on the layer.

export default {
  externals: {
    byLayer: {},
  },
};

Enable presets of externals for specific targets.

export default {
  externalsPresets: {},
};

Treat common electron built-in modules in main and preload context like 'electron', 'ipc' or 'shell' as external and load them via require() when used.

export default {
  externalsPresets: {
    electron: true,
  },
};

Treat electron built-in modules in the main context like 'app', 'ipc-main' or 'shell' as external and load them via require() when used.

export default {
  externalsPresets: {
    electronMain: true,
  },
};

Treat electron built-in modules in the preload context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.

export default {
  externalsPresets: {
    electronPreload: true,
  },
};

Treat electron built-in modules in the renderer context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.

export default {
  externalsPresets: {
    electronRenderer: true,
  },
};

Treat node.js built-in modules like fs, path or vm as external and load them via require() when used.

export default {
  externalsPresets: {
    node: true,
  },
};

Treat NW.js legacy nw.gui module as external and load it via require() when used.

export default {
  externalsPresets: {
    nwjs: true,
  },
};

Treat references to 'http(s)://...' and 'std:...' as external and load them via import when used (Note that this changes execution order as externals are executed before any other code in the chunk).

export default {
  externalsPresets: {
    web: true,
  },
};

Treat references to 'http(s)://...' and 'std:...' as external and load them via async import() when used (Note that this external type is an async module, which has various effects on the execution).

export default {
  externalsPresets: {
    webAsync: true,
  },
};

Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).

export default {
  externalsType: "var",
};

Ignore specific warnings.

export default {
  ignoreWarnings: [],
};

Options for infrastructure level logging.

export default {
  infrastructureLogging: {},
};

Only appends lines to the output. Avoids updating existing output e. g. for status messages. This option is only used when no custom console is provided.

export default {
  infrastructureLogging: {
    appendOnly: true,
  },
};

Enables/Disables colorful output. This option is only used when no custom console is provided.

export default {
  infrastructureLogging: {
    colors: true,
  },
};

Custom console used for logging.

export default {
  infrastructureLogging: {
    console: undefined,
  },
};

Enable debug logging for specific loggers.

export default {
  infrastructureLogging: {
    debug: '...',
  },
};

Log level.

export default {
  infrastructureLogging: {
    level: "none",
  },
};

Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.

export default {
  infrastructureLogging: {
    stream: undefined,
  },
};

Custom values available in the loader context.

export default {
  loader: {},
};

Enable production optimizations or development hints.

export default {
  mode: "development",
};

Options affecting the normal modules (NormalModuleFactory).

export default {
  module: {},
};

An array of rules applied by default for modules.

export default {
  module: {
    defaultRules: [],
  },
};

Enable warnings for full dynamic dependencies.

export default {
  module: {
    exprContextCritical: true,
  },
};

Enable recursive directory lookup for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRecursive'.

export default {
  module: {
    exprContextRecursive: true,
  },
};

Sets the default regular expression for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRegExp'.

export default {
  module: {
    exprContextRegExp: true,
  },
};

Set the default request for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRequest'.

export default {
  module: {
    exprContextRequest: '...',
  },
};

Specify options for each generator.

export default {
  module: {
    generator: {},
  },
};

Generator options for asset modules.

export default {
  module: {
    generator: {
      asset: {},
    },
  },
};

No generator options are supported for this module type.

export default {
  module: {
    generator: {
      'asset/bytes': {},
    },
  },
};

Generator options for asset/inline modules.

export default {
  module: {
    generator: {
      'asset/inline': {},
    },
  },
};

Generator options for asset/resource modules.

export default {
  module: {
    generator: {
      'asset/resource': {},
    },
  },
};

No generator options are supported for this module type.

export default {
  module: {
    generator: {
      'asset/source': {},
    },
  },
};

Generator options for css modules.

export default {
  module: {
    generator: {
      css: {},
    },
  },
};

Generator options for css/module modules.

export default {
  module: {
    generator: {
      'css/auto': {},
    },
  },
};

Generator options for css/module modules.

export default {
  module: {
    generator: {
      'css/global': {},
    },
  },
};

Generator options for css/module modules.

export default {
  module: {
    generator: {
      'css/module': {},
    },
  },
};

Generator options for html modules.

export default {
  module: {
    generator: {
      html: {},
    },
  },
};

No generator options are supported for this module type.

export default {
  module: {
    generator: {
      javascript: {},
    },
  },
};

No generator options are supported for this module type.

export default {
  module: {
    generator: {
      'javascript/auto': {},
    },
  },
};

No generator options are supported for this module type.

export default {
  module: {
    generator: {
      'javascript/dynamic': {},
    },
  },
};

No generator options are supported for this module type.

export default {
  module: {
    generator: {
      'javascript/esm': {},
    },
  },
};

Generator options for json modules.

export default {
  module: {
    generator: {
      json: {},
    },
  },
};

Don't parse files matching. It's matched against the full resolved request.

export default {
  module: {
    noParse: '...',
  },
};

Specify options for each parser.

export default {
  module: {
    parser: {},
  },
};

Parser options for asset modules.

export default {
  module: {
    parser: {
      asset: {},
    },
  },
};

No parser options are supported for this module type.

export default {
  module: {
    parser: {
      'asset/bytes': {},
    },
  },
};

No parser options are supported for this module type.

export default {
  module: {
    parser: {
      'asset/inline': {},
    },
  },
};

No parser options are supported for this module type.

export default {
  module: {
    parser: {
      'asset/resource': {},
    },
  },
};

No parser options are supported for this module type.

export default {
  module: {
    parser: {
      'asset/source': {},
    },
  },
};

Parser options for css modules.

export default {
  module: {
    parser: {
      css: {},
    },
  },
};

Parser options for css/auto and css/module modules.

export default {
  module: {
    parser: {
      'css/auto': {},
    },
  },
};

Parser options for css/global modules.

export default {
  module: {
    parser: {
      'css/global': {},
    },
  },
};

Parser options for css/auto and css/module modules.

export default {
  module: {
    parser: {
      'css/module': {},
    },
  },
};

Parser options for javascript modules.

export default {
  module: {
    parser: {
      javascript: {},
    },
  },
};

Parser options for javascript modules.

export default {
  module: {
    parser: {
      'javascript/auto': {},
    },
  },
};

Parser options for javascript modules.

export default {
  module: {
    parser: {
      'javascript/dynamic': {},
    },
  },
};

Parser options for javascript modules.