Compiler Hooks | webpack (original) (raw)

The Compiler module is the main engine that creates a compilation instance with all the options passed through the CLI or Node API. It extends theTapable class in order to register and call plugins. Most user-facing plugins are first registered on the Compiler.

When developing a plugin for webpack, you might want to know where each hook is called. To learn this, search for hooks.<hook name>.call across the webpack source.

Watching

The Compiler supports watching which monitors the file system and recompiles as files change. When in watch mode, the compiler will emit the additional events such as watchRun, watchClose, and invalid. This is typically used in development, usually under the hood of tools like webpack-dev-server, so that the developer doesn't need to re-compile manually every time. Watch mode can also be entered via theCLI.

Hooks

The following lifecycle hooks are exposed by the compiler and can be accessed as such:

compiler.hooks.someHook.tap('MyPlugin', (params) => {
  /* ... */
});

Depending on the hook type, tapAsync and tapPromise may also be available.

For the description of hook types, see the Tapable docs.

environment

SyncHook

Called while preparing the compiler environment, right after initializing the plugins in the configuration file.

afterEnvironment

SyncHook

Called right after the environment hook, when the compiler environment setup is complete.

entryOption

SyncBailHook

Called after the entry configuration from webpack options has been processed.

compiler.hooks.entryOption.tap('MyPlugin', (context, entry) => {
  /* ... */
});

afterPlugins

SyncHook

Called after setting up initial set of internal plugins.

afterResolvers

SyncHook

Triggered after resolver setup is complete.

initialize

SyncHook

Called when a compiler object is initialized.

beforeRun

AsyncSeriesHook

Adds a hook right before running the compiler.

run

AsyncSeriesHook

Hook into the compiler before it begins reading records.

watchRun

AsyncSeriesHook

Executes a plugin during watch mode after a new compilation is triggered but before the compilation is actually started.

normalModuleFactory

SyncHook

Called after a NormalModuleFactory is created.

contextModuleFactory

SyncHook

Runs a plugin after a ContextModuleFactory is created.

beforeCompile

AsyncSeriesHook

Executes a plugin after compilation parameters are created.

The compilationParams variable is initialized as follows:

compilationParams = {
  normalModuleFactory,
  contextModuleFactory,
};

This hook can be used to add/modify the compilation parameters:

compiler.hooks.beforeCompile.tapAsync('MyPlugin', (params, callback) => {
  params['MyPlugin - data'] = 'important stuff my plugin will use later';
  callback();
});

compile

SyncHook

Called right after beforeCompile, before a new compilation is created. This hook is not copied to child compilers.

thisCompilation

SyncHook

Executed while initializing the compilation, right before emitting the compilation event. This hook is not copied to child compilers.

compilation

SyncHook

Runs a plugin after a compilation has been created.

make

AsyncParallelHook

Executed before finishing the compilation. This hook is not copied to child compilers.

afterCompile

AsyncSeriesHook

Called after finishing and sealing the compilation.

shouldEmit

SyncBailHook

Called before emitting assets. Should return a boolean telling whether to emit.

compiler.hooks.shouldEmit.tap('MyPlugin', (compilation) => {
  // return true to emit the output, otherwise false
  return true;
});

emit

AsyncSeriesHook

Executed right before emitting assets to output dir. This hook is not copied to child compilers.

afterEmit

AsyncSeriesHook

Called after emitting assets to output directory. This hook is not copied to child compilers.

assetEmitted

AsyncSeriesHook

Executed when an asset has been emitted. Provides access to information about the emitted asset, such as its output path and byte content.

For example, you may access the asset's content buffer via info.content:

compiler.hooks.assetEmitted.tap(
  'MyPlugin',
  (file, { content, source, outputPath, compilation, targetPath }) => {
    console.log(content); // <Buffer 66 6f 6f 62 61 72>
  }
);

done

AsyncSeriesHook

Executed when the compilation has completed. This hook is not copied to child compilers.

additionalPass

AsyncSeriesHook

This hook allows you to do a one more additional pass of the build.

failed

SyncHook

Called if the compilation fails.

invalid

SyncHook

Executed when a watching compilation has been invalidated. This hook is not copied to child compilers.

watchClose

SyncHook

Called when a watching compilation has stopped.

shutdown

AsyncSeriesHook

Called when the compiler is closing.

infrastructureLog

SyncBailHook

Allows to use infrastructure logging when enabled in the configuration via infrastructureLogging option.

log

SyncBailHook

Allows to log into stats when enabled, see stats.logging, stats.loggingDebug and stats.loggingTrace options.