Rsbuild instance

This section describes all the properties and methods on the Rsbuild instance object.

rsbuild.context

rsbuild.context is a read-only object that provides some context information, which can be accessed in two ways:

Access through the context property of the Rsbuild instance:

import { createRsbuild } from '@rsbuild/core';

const rsbuild = createRsbuild({
  // ...
});

console.log(rsbuild.context);

Access through the api.context of the Rsbuild plugin:

export const myPlugin = {
  name: 'my-plugin',
  setup(api) {
    console.log(api.context);
  },
};

context.version

The version of @rsbuild/core currently in use.

Type:

type Version = string;

context.rootPath

The root path of the current build, corresponding to the cwd option of the createRsbuild method.

Type:

type RootPath = string;

context.distPath

The absolute path of the output directory, corresponding to the output.distPath.root config in RsbuildConfig.

When multiple environments exist, Rsbuild attempts to find the parent distPath of all environments as context.distPath.

To get the absolute path to a specific environment's output directory, use environment.distPath.

Type:

type DistPath = string;

context.cachePath

The absolute path of the build cache files.

Type:

type CachePath = string;

context.callerName

The name of the framework or tool that is currently invoking Rsbuild, the same as the callerName option in the createRsbuild method.

Type: string
Default: 'rsbuild'
Example:

myPlugin.ts

export const myPlugin = {
  name: 'my-plugin',
  setup(api) {
    const { callerName } = api.context;

    if (callerName === 'rslib') {
      // ...
    } else if (callerName === 'rsbuild') {
      // ...
    }
  },
};

Here are some tools based on Rsbuild that have already set the callerName value:

Name	callerName
Rslib	`'rslib'`
Rstest	`'rstest'`
Rspress	`'rspress'`
Rspeedy	`'rspeedy'`

context.devServer

Dev server information when running in dev mode. Available after the dev server has been created.

Type:

type DevServer = {
  hostname: string;
  port: number;
  https: boolean;
};

Example:

import { createRsbuild } from '@rsbuild/core';

async function main() {
  const rsbuild = createRsbuild({
    // ...
  });
  await rsbuild.startDevServer();

  console.log(rsbuild.context.devServer); // { hostname: 'localhost', port: 3000, https: false }
}

context.action

The current action type.

Type:

type Action = 'dev' | 'build' | 'preview' | undefined;

context.action is set when running CLI commands or calling Rsbuild instance methods:

dev: set when running rsbuild dev or rsbuild.startDevServer()
build: set when running rsbuild build or rsbuild.build()
preview: set when running rsbuild preview or rsbuild.preview()

For example:

if (rsbuild.context.action === 'dev') {
  // do something
}

context.bundlerType

The bundler type for the current build.

Type:

type bundlerType = 'rspack' | 'webpack';

Rsbuild internally supports switching to webpack for comparative testing, so this field is provided for differentiation. Usually, you do not need to use this field.

rsbuild.build

Runs a production build, generating optimized production bundles and writing them to the output directory.

Type:

type BuildOptions = {
  /**
   * Whether to watch for file changes and rebuild.
   * @default false
   */
  watch?: boolean;
};

function Build(options?: BuildOptions): Promise<{
  /**
   * Rspack's [stats](https://rspack.rs/api/javascript-api/stats) object.
   */
  stats?: Rspack.Stats | Rspack.MultiStats;
  /**
   * Close the build and call the `onCloseBuild` hook.
   * In watch mode, this method will stop watching.
   */
  close: () => Promise<void>;
}>;

Example:

import { logger } from '@rsbuild/core';

// Example 1: run build
await rsbuild.build();

// Example 2: build and handle the error
try {
  await rsbuild.build();
} catch (err) {
  logger.error('Failed to build.');
  logger.error(err);
  process.exit(1);
}

// Example 3: build and get all assets
const { stats } = await rsbuild.build();

if (stats) {
  const { assets } = stats.toJson({
    // exclude unused fields to improve performance
    all: false,
    assets: true,
  });
  console.log(assets);
}

Monitor file changes

To watch file changes and re-build, set the watch option to true.

await rsbuild.build({
  watch: true,
});

Close build

rsbuild.build() returns a close() method that stops the build process.

In watch mode, calling the close() method will stop watching:

const buildResult = await rsbuild.build({
  watch: true,
});
await buildResult.close();

In non-watch mode, also call the close() method to end the build, which triggers the onCloseBuild hook for cleanup operations.

const buildResult = await rsbuild.build();
await buildResult.close();

Stats object

In non-watch mode, rsbuild.build() returns an Rspack stats object.

For example, use the stats.toJson() method to get asset information:

const result = await rsbuild.build();
const { stats } = result;

if (stats) {
  const { assets } = stats.toJson({
    // exclude unused fields to improve performance
    all: false,
    assets: true,
  });
  console.log(assets);
}

rsbuild.startDevServer

Starts the local dev server. This method will:

Start a development server to serve your application
Watch for file changes and trigger recompilation

Type:

type StartDevServerOptions = {
  /**
   * Whether to get port silently and not print any logs.
   * @default false
   */
  getPortSilently?: boolean;
};

type StartServerResult = {
  /**
   * The URLs that server is listening on.
   */
  urls: string[];
  /**
   * The actual port used by the server.
   */
  port: number;
  server: {
    /**
     * Close the server.
     * In development mode, this will call the `onCloseDevServer` hook.
     */
    close: () => Promise<void>;
  };
};

function StartDevServer(
  options?: StartDevServerOptions,
): Promise<StartServerResult>;

Example:

Start dev server:

import { logger } from '@rsbuild/core';

// Start dev server
await rsbuild.startDevServer();

// Start dev server and handle the error
try {
  await rsbuild.startDevServer();
} catch (err) {
  logger.error('Failed to start dev server.');
  logger.error(err);
  process.exit(1);
}

Once the dev server starts successfully, these logs appear:

  ➜ Local:    http://localhost:3000
  ➜ Network:  http://192.168.0.1:3000

startDevServer returns these parameters:

urls: URLs to access dev server.
port: The actual listening port number.
server: Server instance object.

const { urls, port } = await rsbuild.startDevServer();
console.log(urls); // ['http://localhost:3000', 'http://192.168.0.1:3000']
console.log(port); // 3000

Close server

Call the close() method to close the dev server, trigger the onCloseDevServer hook, and perform cleanup operations.

const { server } = await rsbuild.startDevServer();
await server.close();

Get port silently

When the default startup port is occupied, Rsbuild automatically increments the port number until it finds an available one. This process outputs a prompt log. To suppress this log, set getPortSilently to true.

await rsbuild.startDevServer({
  getPortSilently: true,
});

rsbuild.createDevServer

Rsbuild includes a built-in dev server designed to improve the development experience. When you run the rsbuild dev command, the server starts automatically and provides features such as page preview, routing, and hot module reloading.

To integrate the Rsbuild dev server into a custom server, you can use the createDevServer method to create a dev server instance. Please refer to Dev server API for all available APIs.
To use Rsbuild dev server to start the project directly, you can use the rsbuild.startDevServer method directly. rsbuild.startDevServer is actually syntactic sugar for the following code:

const server = await rsbuild.createDevServer();
await server.listen();

rsbuild.preview

Starts a server to preview the production build locally. This method should be executed after rsbuild.build.

Type:

type PreviewOptions = {
  /**
   * Whether to get port silently
   * @default false
   */
  getPortSilently?: boolean;
  /**
   * Whether to check if the dist directory exists and is not empty.
   * @default true
   */
  checkDistDir?: boolean;
};

type StartServerResult = {
  /**
   * The URLs that server is listening on.
   */
  urls: string[];
  /**
   * The actual port used by the server.
   */
  port: number;
  server: {
    /**
     * Close the server.
     */
    close: () => Promise<void>;
  };
};

function preview(options?: PreviewOptions): Promise<StartServerResult>;

Example:

Start the server:

import { logger } from '@rsbuild/core';

// Start preview server
await rsbuild.preview();

// Start preview server and handle the error
try {
  await rsbuild.preview();
} catch (err) {
  logger.error('Failed to start preview server.');
  logger.error(err);
  process.exit(1);
}

preview returns the following parameters:

urls: URLs to access server.
port: The actual listening port number.
server: Server instance object.

const { urls, port } = await rsbuild.preview();
console.log(urls); // ['http://localhost:3000', 'http://192.168.0.1:3000']
console.log(port); // 3000

Close server

Calling the close() method will close the preview server.

const { server } = await rsbuild.preview();
await server.close();

rsbuild.createCompiler

Creates an Rspack Compiler instance. If there are multiple environments for this build, the return value is MultiCompiler.

Type:

function CreateCompiler(): Promise<Compiler | MultiCompiler>;

Example:

const compiler = await rsbuild.createCompiler();

You do not need to use this API unless you need to custom the dev server or other advanced scenarios.

rsbuild.addPlugins

Registers one or more Rsbuild plugins, which can be called multiple times.

This method needs to be called before compiling. If it is called after compiling, it will not affect the compilation result.

Type:

type AddPluginsOptions = { before?: string; environment?: string };

function AddPlugins(
  plugins: Array<RsbuildPlugin | Falsy>,
  options?: AddPluginsOptions,
): void;

Example:

rsbuild.addPlugins([pluginFoo(), pluginBar()]);

// Insert before the bar plugin
rsbuild.addPlugins([pluginFoo()], { before: 'bar' });

// Add plugin for node environment
rsbuild.addPlugins([pluginFoo()], { environment: 'node' });

rsbuild.getPlugins

Gets all the Rsbuild plugins registered in the current Rsbuild instance.

Type:

function GetPlugins(options?: {
  /**
   * Get the plugins in the specified environment.
   * If environment is not specified, get the global plugins.
   */
  environment: string;
}): RsbuildPlugin[];

Example:

// get all plugins
console.log(rsbuild.getPlugins());

// get plugins in `web` environment
console.log(rsbuild.getPlugins({ environment: 'web' }));

rsbuild.removePlugins

Removes one or more Rsbuild plugins, which can be called multiple times.

This method needs to be called before compiling. If it is called after compiling, it will not affect the compilation result.

Type:

function RemovePlugins(pluginNames: string[]): void;

Example:

// add plugin
const pluginFoo = pluginFoo();
rsbuild.addPlugins(pluginFoo);

// remove plugin
rsbuild.removePlugins([pluginFoo.name]);

rsbuild.isPluginExists

Determines if a plugin has been registered in the current Rsbuild instance.

If the environment parameter is not specified, it checks if the plugin exists in the globally registered plugins.
If the environment parameter is specified, it checks if the plugin exists in the specified environment.
Type:

function IsPluginExists(
  pluginName: string,
  options?: {
    /**
     * Whether it exists in the specified environment.
     * If environment is not specified, determine whether the plugin is a global plugin.
     */
    environment: string;
  },
): boolean;

Example:

const pluginFoo = {
  name: 'plugin-foo',
  setup(api) {
    // ...
  },
};

const rsbuild = createRsbuild({
  config: {
    plugins: [pluginFoo],
  },
});

rsbuild.isPluginExists(pluginFoo.name); // true

Or check if a plugin exists in a specified environment:

const rsbuild = createRsbuild({
  config: {
    environments: {
      web: {
        plugins: [pluginFoo],
      },
    },
  },
});

rsbuild.isPluginExists(pluginFoo.name, {
  environment: 'web',
}); // true

rsbuild.initConfigs

Initialize and return the internal Rspack configurations used by Rsbuild. This method processes all plugins and configurations to generate the final Rspack configs.

Note: You typically do not need to call this method directly since it is automatically invoked by methods like rsbuild.build and rsbuild.startDevServer.

Type:

type InitConfigsOptions = {
  /**
   * The current action type.
   * - dev: will be set when running `rsbuild dev` or `rsbuild.startDevServer()`
   * - build: will be set when running `rsbuild build` or `rsbuild.build()`
   * - preview: will be set when running `rsbuild preview` or `rsbuild.preview()`
   */
  action?: 'dev' | 'build' | 'preview';
};

function InitConfigs(options?: InitConfigsOptions): Promise<{
  rspackConfigs: Rspack.Configuration[];
}>;

Example:

const rspackConfigs = await rsbuild.initConfigs();

console.log(rspackConfigs);

const buildConfigs = await rsbuild.initConfigs({
  action: 'build',
});

console.log(buildConfigs);

rsbuild.inspectConfig

Inspects and debugs Rsbuild's internal configurations. It provides access to:

The resolved Rsbuild configuration
The environment-specific Rsbuild configurations
The generated Rspack configurations

The method serializes these configurations to strings and optionally writes them to disk for inspection.

Type:

type InspectConfigOptions = {
  /**
   * Inspect the config in the specified mode.
   * Available options: 'development' or 'production'.
   * @default 'development'
   */
  mode?: RsbuildMode;
  /**
   * Enables verbose mode to display the complete function
   * content in the configuration.
   * @default false
   */
  verbose?: boolean;
  /**
   * Specify the output path for inspection results.
   * @default 'output.distPath.root'
   */
  outputPath?: string;
  /**
   * Whether to write the inspection results to disk.
   * @default false
   */
  writeToDisk?: boolean;
  /**
   * Extra configurations to be output.
   * - key: The name of the configuration
   * - value: The configuration object
   */
  extraConfigs?: Record<string, unknown>;
};

async function InspectConfig(options?: InspectConfigOptions): Promise<{
  rsbuildConfig: string;
  bundlerConfigs: string[];
  environmentConfigs: string[];
  origin: {
    rsbuildConfig: RsbuildConfig;
    environmentConfigs: Record<string, EnvironmentConfig>;
    bundlerConfigs: BundlerConfigs[];
  };
}>;

Tip

To view the Rsbuild and Rspack configurations during the build process, use debug mode, or obtain them through hooks such as onBeforeBuild, onBeforeCreateCompile.

Example

Get the content of configs in string format:

const { rsbuildConfig, bundlerConfigs } = await rsbuild.inspectConfig();

console.log(rsbuildConfig, bundlerConfigs);

Write the config content to disk:

await rsbuild.inspectConfig({
  writeToDisk: true,
});

Output path

You can set the output path using outputPath. The default value is output.distPath.root.

If outputPath is a relative path, it will be concatenated relative to the value of output.distPath.root. You can also set outputPath to an absolute path, in which case the files will be written directly to that path. For example:

import path from 'node:path';

await rsbuild.inspectConfig({
  writeToDisk: true,
  outputPath: path.join(__dirname, 'custom-dir'),
});

rsbuild.onBeforeCreateCompiler

Provides the same functionality as the onBeforeCreateCompiler plugin hook.

A callback function that is triggered after the Compiler instance has been created, but before the build process begins. This hook is called when you run rsbuild.startDevServer, rsbuild.build, or rsbuild.createCompiler.

You can access the Rspack configuration array through the bundlerConfigs parameter. The array may contain one or more Rspack configurations. It depends on whether multiple environments are configured.

Type:

function OnBeforeCreateCompiler(
  callback: (params: {
    bundlerConfigs: Rspack.Configuration[];
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Example:

rsbuild.onBeforeCreateCompiler(({ bundlerConfigs }) => {
  console.log('the Rspack config is ', bundlerConfigs);
});

rsbuild.onAfterCreateCompiler

Provides the same functionality as the onAfterCreateCompiler plugin hook.

A callback function that is triggered after the compiler instance has been created, but before the build process. This hook is called when you run rsbuild.startDevServer, rsbuild.build, or rsbuild.createCompiler.

You can access the Compiler instance through the compiler parameter:

Type:

function OnAfterCreateCompiler(callback: (params: {
  compiler: Compiler | MultiCompiler;
  environments: Record<string, EnvironmentContext>;
}) => Promise<void> | void;): void;

Example:

rsbuild.onAfterCreateCompiler(({ compiler }) => {
  console.log('the compiler is ', compiler);
});

rsbuild.onBeforeBuild

Provides the same functionality as the onBeforeBuild plugin hook.

A callback function that is triggered before the production build is executed.

Moreover, you can use isWatch to determine whether it is watch mode, and use isFirstCompile to determine whether it is the first build on watch mode.

Type:

function OnBeforeBuild(
  callback: (params: {
    isWatch: boolean;
    isFirstCompile: boolean;
    bundlerConfigs?: Rspack.Configuration[];
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Example:

rsbuild.onBeforeBuild(({ bundlerConfigs }) => {
  console.log('the Rspack config is ', bundlerConfigs);
});

rsbuild.onAfterBuild

Provides the same functionality as the onAfterBuild plugin hook.

A callback function that is triggered after running the production build. You can access the build result information via the stats parameter.

Moreover, you can use isWatch to determine whether it is watch mode, and use isFirstCompile to determine whether it is the first build on watch mode.

Type:

function OnAfterBuild(
  callback: (params: {
    isFirstCompile: boolean;
    isWatch: boolean;
    stats?: Stats | MultiStats;
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Example:

rsbuild.onAfterBuild(({ stats }) => {
  console.log(stats?.toJson());
});

rsbuild.onCloseBuild

Provides the same functionality as the onCloseBuild plugin hook.

Called when closing the build instance. Can be used to perform cleanup operations when the building is closed.

Rsbuild CLI will automatically call this hook after running rsbuild build, while users of the JavaScript API need to manually call the build.close() method to trigger this hook.

Type:

function onCloseBuild(callback: () => Promise<void> | void): void;

Example:

rsbuild.onCloseBuild(async () => {
  console.log('close build!');
});

rsbuild.onBeforeStartDevServer

Provides the same functionality as the onBeforeStartDevServer plugin hook.

Called before starting the dev server.

Use the server parameter to get the dev server instance, see Dev server API for more information.

Type:

type OnBeforeStartDevServerFn = (params: {
  /**
   * The dev server instance, the same as the return value of `createDevServer`.
   */
  server: RsbuildDevServer;
  /**
   * Context information for all environments.
   */
  environments: Record<string, EnvironmentContext>;
}) => MaybePromise<void>;

function OnBeforeStartDevServer(callback: OnBeforeStartDevServerFn): void;

Example:

rsbuild.onBeforeStartDevServer(({ server, environments }) => {
  console.log('before starting dev server.');
  console.log('the server is ', server);
  console.log('the environments contexts are: ', environments);
});

See Plugin hooks - onBeforeStartDevServer for more details.

rsbuild.onAfterStartDevServer

Provides the same functionality as the onAfterStartDevServer plugin hook.

Called after starting the dev server, you can get the port number with the port parameter, and the page routes info with the routes parameter.

Type:

type Routes = Array<{
  entryName: string;
  pathname: string;
}>;

function OnAfterStartDevServer(
  callback: (params: {
    port: number;
    routes: Routes;
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Example:

rsbuild.onAfterStartDevServer(({ port, routes }) => {
  console.log('this port is: ', port);
  console.log('this routes is: ', routes);
});

rsbuild.onCloseDevServer

Provides the same functionality as the onCloseDevServer plugin hook.

Called when closing the dev server. Can be used to perform cleanup operations when the dev server is closed.

Rsbuild CLI will automatically call this hook at the appropriate time, while users of the JavaScript API need to manually call the server.close() method to trigger this hook.

Type:

function onCloseDevServer(callback: () => Promise<void> | void): void;

Example:

rsbuild.onCloseDevServer(async () => {
  console.log('close dev server!');
});

rsbuild.onBeforeStartProdServer

Provides the same functionality as the onBeforeStartProdServer plugin hook.

Called before starting the production preview server.

Type:

function OnBeforeStartProdServer(callback: () => Promise<void> | void): void;

Example:

rsbuild.onBeforeStartProdServer(() => {
  console.log('before start!');
});

rsbuild.onAfterStartProdServer

Provides the same functionality as the onAfterStartProdServer plugin hook.

Called after starting the production preview server, you can get the port number with the port parameter, and the page routes info with the routes parameter.

Type:

type Routes = Array<{
  entryName: string;
  pathname: string;
}>;

function OnAfterStartProdServer(
  callback: (params: {
    port: number;
    routes: Routes;
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Example:

rsbuild.onAfterStartProdServer(({ port, routes }) => {
  console.log('this port is: ', port);
  console.log('this routes is: ', routes);
});

rsbuild.onBeforeDevCompile

Provides the same functionality as the onBeforeDevCompile plugin hook.

A callback function that is triggered before the dev compile is executed.

Moreover, you can use isFirstCompile to determine whether it is the first compile.

Type:

function OnBeforeDevCompile(
  callback: (params: {
    isWatch: boolean;
    isFirstCompile: boolean;
    bundlerConfigs?: Rspack.Configuration[];
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Version: Added in v1.5.0

Example:

rsbuild.onBeforeDevCompile(({ bundlerConfigs }) => {
  console.log('the Rspack configs are ', bundlerConfigs);
});

rsbuild.onAfterDevCompile

Provides the same functionality as the onAfterDevCompile plugin hook.

Called after each development mode build, you can use isFirstCompile to determine whether it is the first build.

Type:

function OnAfterDevCompile(
  callback: (params: {
    isFirstCompile: boolean;
    stats: Stats | MultiStats;
    environments: Record<string, EnvironmentContext>;
  }) => Promise<void> | void,
): void;

Tip

The onAfterDevCompile hook was added in Rsbuild v1.5.0. For earlier versions, you can use the functionally identical onDevCompileDone hook.

Example:

rsbuild.onAfterDevCompile(({ isFirstCompile }) => {
  if (isFirstCompile) {
    console.log('first compile!');
  } else {
    console.log('re-compile!');
  }
});

rsbuild.onBeforeEnvironmentCompile

Provides the same functionality as the onBeforeEnvironmentCompile plugin hook.

Version: Added in v1.5.7
Example:

rsbuild.onBeforeEnvironmentCompile(({ bundlerConfig, environment }) => {
  console.log(
    `the bundler config for the ${environment.name} is `,
    bundlerConfig,
  );
});

rsbuild.onAfterEnvironmentCompile

Provides the same functionality as the onAfterEnvironmentCompile plugin hook.

Version: Added in v1.5.7
Example:

rsbuild.onAfterEnvironmentCompile(({ isFirstCompile, stats }) => {
  console.log(stats?.toJson(), isFirstCompile);
});

rsbuild.onExit

Provides the same functionality as the onExit plugin hook.

Called when the process is going to exit, this hook can only execute synchronous code.

Type:

function OnExit(callback: (context: { exitCode: number }) => void): void;

Example:

rsbuild.onExit(({ exitCode }) => {
  console.log('exit: ', exitCode);
});

rsbuild.getRsbuildConfig

Provides the same functionality as the getRsbuildConfig plugin API.

Get the Rsbuild config, this method must be called after the modifyRsbuildConfig hook is executed.

Type:

type GetRsbuildConfig = {
  (): Readonly<RsbuildConfig>;
  (type: 'original' | 'current'): Readonly<RsbuildConfig>;
  (type: 'normalized'): NormalizedConfig;
};

Parameters:

You can specify the type of Rsbuild config to read by using the type parameter:

// Get the original Rsbuild config defined by the user.
getRsbuildConfig('original');

// Get the current Rsbuild config.
// The content of this config will change at different execution stages of Rsbuild.
// For example, the content of the current Rsbuild config will be modified after running the `modifyRsbuildConfig` hook.
getRsbuildConfig('current');

// Get the normalized Rsbuild config.
// This method must be called after the `modifyRsbuildConfig` hook has been executed.
// It is equivalent to the `getNormalizedConfig` method.
getRsbuildConfig('normalized');

Example:

rsbuild.onBeforeBuild(() => {
  const config = rsbuild.getRsbuildConfig();
  console.log(config.html?.title);
});

rsbuild.getNormalizedConfig

Provides the same functionality as the getNormalizedConfig plugin API.

Get the normalized Rsbuild config for all environments or a specific one. Call this method only after the modifyRsbuildConfig hook has executed.

Compared with the api.getRsbuildConfig method, the config returned by this method has been normalized, and the type definition of the config will be narrowed. For example, the undefined type of config.html will be removed.

We recommend using this method to get the Rsbuild config.

Type:

/** Get the Rsbuild configuration of the specified environment */
function GetNormalizedConfig(options: {
  environment: string;
}): Readonly<NormalizedEnvironmentConfig>;

/** Get all Rsbuild configurations */
function GetNormalizedConfig(): Readonly<NormalizedConfig>;

Example:

rsbuild.onBeforeBuild(() => {
  const config = rsbuild.getNormalizedConfig();
  console.log(config.html.title);
});

rsbuild.expose

Provides the same functionality as the expose plugin API.

Version: Added in v1.5.0
Example:

rsbuild.expose('my-id', {
  value: 1,
  double: (val: number) => val * 2,
});

rsbuild.modifyRsbuildConfig

Provides the same functionality as the modifyRsbuildConfig plugin API.

Version: Added in v1.5.0
Example:

rsbuild.modifyRsbuildConfig((config) => {
  config.html ||= {};
  config.html.title = 'My Default Title';
});

rsbuild.modifyEnvironmentConfig

Provides the same functionality as the modifyEnvironmentConfig plugin API.

Version: Added in v1.5.0
Example:

rsbuild.modifyEnvironmentConfig((config, { name }) => {
  if (name !== 'web') {
    return config;
  }
  config.html.title = 'My Default Title';
});

#Rsbuild instance

#rsbuild.context

#context.version

#context.rootPath

#context.distPath

#context.cachePath

#context.callerName

#context.devServer

#context.action

#context.bundlerType

#rsbuild.build

#Monitor file changes

#Close build

#Stats object

#rsbuild.startDevServer

#Close server

#Get port silently

#rsbuild.createDevServer

#rsbuild.preview

#Close server

#rsbuild.createCompiler

#rsbuild.addPlugins

#rsbuild.getPlugins

#rsbuild.removePlugins

#rsbuild.isPluginExists

#rsbuild.initConfigs

#rsbuild.inspectConfig

#Example

#Output path

#rsbuild.onBeforeCreateCompiler

#rsbuild.onAfterCreateCompiler

#rsbuild.onBeforeBuild

#rsbuild.onAfterBuild

#rsbuild.onCloseBuild

#rsbuild.onBeforeStartDevServer

#rsbuild.onAfterStartDevServer

#rsbuild.onCloseDevServer

#rsbuild.onBeforeStartProdServer

#rsbuild.onAfterStartProdServer

#rsbuild.onBeforeDevCompile

#rsbuild.onAfterDevCompile

#rsbuild.onBeforeEnvironmentCompile

#rsbuild.onAfterEnvironmentCompile

#rsbuild.onExit

#rsbuild.getRsbuildConfig

#rsbuild.getNormalizedConfig

#rsbuild.expose

#rsbuild.modifyRsbuildConfig

#rsbuild.modifyEnvironmentConfig

Rsbuild instance

rsbuild.context

context.version

context.rootPath

context.distPath

context.cachePath

context.callerName

context.devServer

context.action

context.bundlerType

rsbuild.build

Monitor file changes

Close build

Stats object

rsbuild.startDevServer

Close server

Get port silently

rsbuild.createDevServer

rsbuild.preview

Close server

rsbuild.createCompiler

rsbuild.addPlugins

rsbuild.getPlugins

rsbuild.removePlugins

rsbuild.isPluginExists

rsbuild.initConfigs

rsbuild.inspectConfig

Example

Output path

rsbuild.onBeforeCreateCompiler

rsbuild.onAfterCreateCompiler

rsbuild.onBeforeBuild

rsbuild.onAfterBuild

rsbuild.onCloseBuild

rsbuild.onBeforeStartDevServer

rsbuild.onAfterStartDevServer

rsbuild.onCloseDevServer

rsbuild.onBeforeStartProdServer

rsbuild.onAfterStartProdServer

rsbuild.onBeforeDevCompile

rsbuild.onAfterDevCompile

rsbuild.onBeforeEnvironmentCompile

rsbuild.onAfterEnvironmentCompile

rsbuild.onExit

rsbuild.getRsbuildConfig

rsbuild.getNormalizedConfig

rsbuild.expose

rsbuild.modifyRsbuildConfig

rsbuild.modifyEnvironmentConfig