0
# Rspack Core
1

2
Rspack is a high-performance JavaScript bundler built in Rust that offers strong compatibility with the webpack ecosystem. It serves as a drop-in replacement for webpack with significantly faster build speeds, featuring lightning-fast Hot Module Replacement (HMR), built-in incremental compilation, and first-class Module Federation support.
3

4
## Package Information
5

6
- **Package Name**: @rspack/core
7
- **Package Type**: npm
8
- **Language**: JavaScript/TypeScript with Rust bindings
9
- **Installation**: `npm install @rspack/core`
10

11
## Core Imports
12

13
```typescript
14
import rspack from "@rspack/core";
15
import { Compiler, Compilation, Configuration } from "@rspack/core";
16
```
17

18
For CommonJS:
19

20
```javascript
21
const rspack = require("@rspack/core");
22
const { Compiler, Compilation } = require("@rspack/core");
23
```
24

25
## Basic Usage
26

27
```typescript
28
import rspack from "@rspack/core";
29

30
// Simple build configuration
31
const config = {
32
  entry: "./src/index.js",
33
  output: {
34
    path: __dirname + "/dist",
35
    filename: "bundle.js",
36
  },
37
  mode: "production",
38
};
39

40
// Create and run compiler
41
const compiler = rspack(config);
42
compiler.run((err, stats) => {
43
  if (err) {
44
    console.error(err);
45
    return;
46
  }
47
  console.log(stats?.toString());
48
});
49
```
50

51
## Architecture
52

53
Rspack is built around several key components:
54

55
- **Compiler**: Main compilation controller that manages the build process and hooks system
56
- **Compilation**: Individual build process instance with assets, modules, and chunks
57
- **Configuration System**: Comprehensive options for build behavior, optimization, and plugins
58
- **Plugin System**: Tapable-based hooks allowing deep customization of the build process
59
- **Module System**: Module resolution, loading, and transformation pipeline
60
- **Hot Module Replacement**: Development-time module swapping without full page reload
61
- **Module Federation**: Micro-frontend architecture for sharing code between applications
62

63
## Capabilities
64

65
### Core Bundling
66

67
Main bundling functions and compiler creation for building JavaScript applications.
68

69
```typescript { .api }
70
function rspack(options: Configuration): Compiler;
71
function rspack(options: Configuration[]): MultiCompiler;
72
function rspack(
73
  options: Configuration | Configuration[],
74
  callback: (err: Error | null, stats?: Stats | MultiStats) => void
75
): Compiler | MultiCompiler | null;
76

77
function createCompiler(options: Configuration): Compiler;
78
function createMultiCompiler(options: Configuration[]): MultiCompiler;
79
```
80

81
[Core Bundling](./core-bundling.md)
82

83
### Configuration
84

85
Comprehensive configuration options covering entry points, output, optimization, plugins, and development settings.
86

87
```typescript { .api }
88
interface Configuration {
89
  entry?: Entry;
90
  output?: Output;
91
  mode?: Mode;
92
  target?: Target;
93
  module?: ModuleOptions;
94
  resolve?: ResolveOptions;
95
  plugins?: Plugin[];
96
  optimization?: Optimization;
97
  experiments?: Experiments;
98
  devServer?: DevServer;
99
  devtool?: DevTool;
100
  externals?: Externals;
101
  stats?: StatsValue;
102
}
103

104
type Mode = "development" | "production" | "none";
105
type Entry = string | string[] | EntryObject | EntryFunction;
106
```
107

108
[Configuration](./configuration.md)
109

110
### Plugin System
111

112
Built-in plugins for optimization, development, asset processing, and build customization.
113

114
```typescript { .api }
115
interface RspackPluginInstance {
116
  apply(compiler: Compiler): void;
117
}
118

119
type RspackPluginFunction = (this: Compiler, compiler: Compiler) => void;
120
type Plugin = RspackPluginInstance | RspackPluginFunction | Falsy;
121

122
// Core plugins
123
class DefinePlugin extends RspackBuiltinPlugin {
124
  constructor(options: DefinePluginOptions);
125
}
126

127
class HotModuleReplacementPlugin extends RspackBuiltinPlugin {}
128
class ProvidePlugin extends RspackBuiltinPlugin {
129
  constructor(options: ProvidePluginOptions);
130
}
131
```
132

133
[Plugin System](./plugins.md)
134

135
### Hot Module Replacement
136

137
Development-time module replacement system for fast iteration without losing application state.
138

139
```typescript { .api }
140
interface Hot {
141
  accept(
142
    modules?: string | string[],
143
    callback?: (outdatedDependencies: string[]) => void,
144
    errorHandler?: (err: Error, context: any) => void
145
  ): void;
146
  decline(module?: string | string[]): void;
147
  dispose(callback: (data: any) => void): void;
148
  status(): HotUpdateStatus;
149
  check(autoApply?: boolean): Promise<(string | number)[] | null>;
150
  apply(options?: ApplyOptions): Promise<(string | number)[] | null>;
151
  data: any;
152
}
153

154
type HotUpdateStatus = "idle" | "check" | "prepare" | "ready" | "dispose" | "apply" | "abort" | "fail";
155
```
156

157
[Hot Module Replacement](./hmr.md)
158

159
### Module Federation
160

161
Micro-frontend architecture enabling code sharing between independent applications at runtime.
162

163
```typescript { .api }
164
class ModuleFederationPlugin extends RspackBuiltinPlugin {
165
  constructor(options: ModuleFederationPluginOptions);
166
}
167

168
interface ModuleFederationPluginOptions {
169
  name: string;
170
  filename?: string;
171
  exposes?: Exposes;
172
  remotes?: Remotes;  
173
  shared?: Shared;
174
  runtimePlugins?: string[];
175
  shareStrategy?: "version-first" | "loaded-first";
176
}
177

178
class ContainerPlugin extends RspackBuiltinPlugin {
179
  constructor(options: ContainerPluginOptions);
180
}
181

182
class ContainerReferencePlugin extends RspackBuiltinPlugin {
183
  constructor(options: ContainerReferencePluginOptions);
184
}
185
```
186

187
[Module Federation](./module-federation.md)
188

189
### Loaders
190

191
Built-in loaders for transforming modules during the build process.
192

193
```typescript { .api }
194
interface SwcLoaderOptions {
195
  jsc?: SwcLoaderJscConfig;
196
  module?: SwcLoaderModuleConfig;
197
  env?: SwcLoaderEnvConfig;
198
  isModule?: boolean;
199
  rspackExperiments?: {
200
    import?: any[];
201
    collectTypeScriptInfo?: boolean;
202
  };
203
}
204

205
interface LightningcssLoaderOptions {
206
  minify?: boolean;
207
  targets?: any;
208
  include?: number;
209
  exclude?: number;
210
  drafts?: any;
211
  nonStandard?: any;
212
  pseudoClasses?: any;
213
}
214
```
215

216
[Loaders](./loaders.md)
217

218
## Types
219

220
### Core Types
221

222
```typescript { .api }
223
class Compiler {
224
  options: Configuration;
225
  hooks: CompilerHooks;
226
  outputPath: string;
227
  name?: string;
228
  
229
  run(callback: (err: Error | null, stats?: Stats) => void): void;
230
  watch(
231
    options: WatchOptions,
232
    callback: (err: Error | null, stats?: Stats) => void
233
  ): Watching;
234
  close(callback: () => void): void;
235
}
236

237
class Compilation {
238
  assets: Record<string, Asset>;
239
  chunks: Set<Chunk>;
240
  modules: Set<Module>;
241
  moduleGraph: ModuleGraph;
242
  hooks: CompilationHooks;
243
}
244

245
class MultiCompiler {
246
  compilers: Compiler[];
247
  hooks: MultiCompilerHooks;
248
  
249
  run(callback: (err: Error | null, stats?: MultiStats) => void): void;
250
  watch(
251
    options: WatchOptions | WatchOptions[],
252
    callback: (err: Error | null, stats?: MultiStats) => void
253
  ): MultiWatching;
254
}
255

256
class Stats {
257
  compilation: Compilation;
258
  toString(options?: StatsOptions): string;
259
  toJson(options?: StatsOptions): StatsCompilation;
260
}
261
```
262

263
### Asset and Module Types
264

265
```typescript { .api }
266
interface Asset {
267
  source(): string | Buffer;
268
  size(): number;
269
  info?: AssetInfo;
270
}
271

272
interface AssetInfo {
273
  immutable?: boolean;
274
  minimized?: boolean;
275
  development?: boolean;
276
  hotModuleReplacement?: boolean;
277
  sourceFilename?: string;
278
  javascriptModule?: boolean;
279
}
280

281
class Module {
282
  type: string;
283
  context?: string;
284
  resource?: string;
285
  request?: string;
286
}
287

288
class Chunk {
289
  name?: string;
290
  id?: string | number;
291
  ids: (string | number)[];
292
  files: Set<string>;
293
  runtime: Set<string>;
294
}
295
```
296

297
### Error Types
298

299
```typescript { .api }
300
class RspackError extends Error {
301
  name: string;
302
  message: string;
303
  stack?: string;
304
}
305

306
class ValidationError extends Error {
307
  name: "ValidationError";
308
  errors: string[];
309
}
310

311
type RspackSeverity = "error" | "warning";
312
```