@rsbuild/core 1.3.0-beta.2 → 1.3.0-beta.3

package/dist-types/helpers/index.d.ts

@@ -1,4 +1,3 @@
-import { URL } from 'node:url';
 import type { Compiler as WebpackCompiler, MultiCompiler as WebpackMultiCompiler } from 'webpack';
 import color from '../../compiled/picocolors/index.js';
 import type RspackChain from '../../compiled/rspack-chain/index.js';
@@ -25,7 +24,6 @@ export declare const getPublicPathFromChain: (chain: RspackChain, withSlash?: bo
 export declare const getPublicPathFromCompiler: (compiler: Rspack.Compiler | Rspack.Compilation) => string;
 export declare const urlJoin: (base: string, path: string) => string;
 export declare const canParse: (url: string) => boolean;
-export declare const parseUrl: (url: string) => URL | null;
 export declare const ensureAssetPrefix: (url: string, assetPrefix?: Rspack.PublicPath) => string;
 export declare function getFilename(config: NormalizedConfig | NormalizedEnvironmentConfig, type: 'js', isProd: boolean, isServer?: boolean): Rspack.Filename;
 export declare function getFilename(config: NormalizedConfig | NormalizedEnvironmentConfig, type: 'css', isProd: boolean): Rspack.CssFilename;

package/dist-types/provider/createCompiler.d.ts

@@ -1,28 +1,6 @@
-import type { DevConfig, Rspack, ServerConfig } from '../types';
+import type { Rspack } from '../types';
 import { type InitConfigsOptions } from './initConfigs';
 export declare function createCompiler(options: InitConfigsOptions): Promise<{
     compiler: Rspack.Compiler | Rspack.MultiCompiler;
     rspackConfigs: Rspack.Configuration[];
 }>;
-export type MiddlewareCallbacks = {
-    onInvalid: () => void;
-    onDone: (stats: any) => void;
-};
-export type DevMiddlewareOptions = {
-    /** To ensure HMR works, the devMiddleware need inject the HMR client path into page when HMR enable. */
-    clientPaths?: string[];
-    clientConfig: DevConfig['client'];
-    publicPath?: string;
-    /** When liveReload is disabled, the page does not reload. */
-    liveReload?: boolean;
-    etag?: 'weak' | 'strong';
-    /** The options need by compiler middleware (like webpackMiddleware) */
-    headers?: Record<string, string | string[]>;
-    writeToDisk?: boolean | ((filename: string, compilationName?: string) => boolean);
-    stats?: boolean;
-    /** should trigger when compiler hook called */
-    callbacks: MiddlewareCallbacks;
-    /** whether use Server Side Render */
-    serverSideRender?: boolean;
-    serverConfig: ServerConfig;
-};

package/dist-types/server/{compilerDevMiddleware.d.ts → compilationManager.d.ts}

@@ -1,7 +1,6 @@
-import type { IncomingMessage } from 'node:http';
-import type { Socket } from 'node:net';
 import type { EnvironmentContext, DevConfig as OriginDevConfig, Rspack, ServerConfig } from '../types';
-import { type DevMiddlewareAPI } from './devMiddleware';
+import { type CompilationMiddleware } from './compilationMiddleware';
+import { SocketServer } from './socketServer';
 type Options = {
     publicPaths: string[];
     environments: Record<string, EnvironmentContext>;
@@ -14,18 +13,18 @@ type Options = {
  * 1. setup rsbuild-dev-middleware
  * 2. establish webSocket connect
  */
-export declare class CompilerDevMiddleware {
-    middleware: DevMiddlewareAPI;
+export declare class CompilationManager {
+    middleware: CompilationMiddleware;
+    outputFileSystem: Rspack.OutputFileSystem;
     private devConfig;
     private serverConfig;
-    private compiler;
+    compiler: Rspack.Compiler | Rspack.MultiCompiler;
     private publicPaths;
-    private socketServer;
+    socketServer: SocketServer;
     constructor({ dev, server, compiler, publicPaths, environments }: Options);
     init(): Promise<void>;
-    upgrade(req: IncomingMessage, sock: Socket, head: any): void;
     close(): Promise<void>;
-    sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
-    private setupDevMiddleware;
+    readFileSync: (fileName: string) => string;
+    private setupCompilationMiddleware;
 }
 export {};

package/dist-types/server/compilationMiddleware.d.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Compiler, MultiCompiler } from '@rspack/core';
+import type { DevConfig, NextFunction, ServerConfig } from '../types';
+export declare const isClientCompiler: (compiler: {
+    options: {
+        target?: Compiler["options"]["target"];
+    };
+}) => boolean;
+type ServerCallbacks = {
+    onInvalid: (compilationId?: string, fileName?: string | null) => void;
+    onDone: (stats: any) => void;
+};
+export declare const setupServerHooks: (compiler: Compiler, { onDone, onInvalid }: ServerCallbacks) => void;
+type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>;
+export type CompilationMiddlewareOptions = {
+    /**
+     * To ensure HMR works, the devMiddleware need inject the HMR client path into page when HMR enable.
+     */
+    clientPaths?: string[];
+    /**
+     * Should trigger when compiler hook called
+     */
+    callbacks: ServerCallbacks;
+    devConfig: DevConfig;
+    serverConfig: ServerConfig;
+};
+export type CompilationMiddleware = Middleware & {
+    close: (callback: (err: Error | null | undefined) => void) => any;
+};
+/**
+ * The CompilationMiddleware handles compiler setup for development:
+ * - Call `compiler.watch` (handled by rsbuild-dev-middleware)
+ * - Inject the HMR client path into page
+ * - Notify server when compiler hooks are triggered
+ */
+export declare const getCompilationMiddleware: (compiler: Compiler | MultiCompiler, options: CompilationMiddlewareOptions) => Promise<CompilationMiddleware>;
+export {};

package/dist-types/server/devMiddlewares.d.ts

@@ -0,0 +1,22 @@
+import type { DevConfig, EnvironmentAPI, InternalContext, RequestHandler, ServerConfig } from '../types';
+import type { CompilationManager } from './compilationManager';
+import type { UpgradeEvent } from './helper';
+export type RsbuildDevMiddlewareOptions = {
+    pwd: string;
+    dev: DevConfig;
+    server: ServerConfig;
+    context: InternalContext;
+    environments: EnvironmentAPI;
+    compilationManager?: CompilationManager;
+    /**
+     * Callbacks returned by the `onBeforeStartDevServer` hook.
+     */
+    postCallbacks: (() => void)[];
+};
+export type Middlewares = Array<RequestHandler | [string, RequestHandler]>;
+export type GetDevMiddlewaresResult = {
+    close: () => Promise<void>;
+    onUpgrade: UpgradeEvent;
+    middlewares: Middlewares;
+};
+export declare const getDevMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<GetDevMiddlewaresResult>;

package/dist-types/server/middlewares.d.ts

@@ -1,5 +1,6 @@
 import type Connect from '../../compiled/connect/index.js';
-import type { EnvironmentAPI, HtmlFallback, RequestHandler as Middleware, Rspack } from '../types';
+import type { EnvironmentAPI, HtmlFallback, RequestHandler as Middleware } from '../types';
+import type { CompilationManager } from './compilationManager';
 export declare const faviconFallbackMiddleware: Middleware;
 export declare const getRequestLoggerMiddleware: () => Promise<Connect.NextHandleFunction>;
 export declare const notFoundMiddleware: Middleware;
@@ -9,8 +10,7 @@ export declare const optionsFallbackMiddleware: Middleware;
  */
 export declare const getHtmlCompletionMiddleware: (params: {
     distPath: string;
-    callback: Middleware;
-    outputFileSystem: Rspack.OutputFileSystem;
+    compilationManager: CompilationManager;
 }) => Middleware;
 /**
  * handle `server.base`
@@ -23,9 +23,8 @@ export declare const getBaseMiddleware: (params: {
  */
 export declare const getHtmlFallbackMiddleware: (params: {
     distPath: string;
-    callback: Middleware;
+    compilationManager: CompilationManager;
     htmlFallback?: HtmlFallback;
-    outputFileSystem: Rspack.OutputFileSystem;
 }) => Middleware;
 /**
  * Support viewing served files via `/rsbuild-dev-server` route

package/dist-types/server/socketServer.d.ts

@@ -14,7 +14,7 @@ export declare class SocketServer {
     private initialChunks;
     private heartbeatTimer;
     constructor(options: DevConfig);
-    upgrade(req: IncomingMessage, sock: Socket, head: any): void;
+    upgrade: (req: IncomingMessage, sock: Socket, head: any) => void;
     private checkSockets;
     private clearHeartbeatTimer;
     prepare(): Promise<void>;

package/dist-types/server/watchFiles.d.ts

@@ -1,11 +1,11 @@
 import type { FSWatcher } from '../../compiled/chokidar/index.js';
 import type { ChokidarOptions, DevConfig, ServerConfig } from '../types';
-import type { CompileMiddlewareAPI } from './getDevMiddlewares';
+import type { CompilationManager } from './compilationManager';
 type WatchFilesOptions = {
     dev: DevConfig;
     server: ServerConfig;
-    compileMiddlewareAPI?: CompileMiddlewareAPI;
     root: string;
+    compilationManager?: CompilationManager;
 };
 export type WatchFilesResult = {
     close(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "1.3.0-beta.2",
+  "version": "1.3.0-beta.3",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -55,6 +55,7 @@
   "devDependencies": {
     "@rslib/core": "0.5.5",
     "@types/connect": "3.4.38",
+    "@types/cors": "^2.8.17",
     "@types/node": "^22.13.11",
     "@types/on-finished": "2.3.4",
     "@types/webpack-bundle-analyzer": "4.7.0",

package/types.d.ts

@@ -5,6 +5,49 @@
  */
 interface ImportMetaEnv {
   [key: string]: any;
+  /**
+   * The value of the `mode` configuration.
+   * @example
+   * if (import.meta.env.MODE === 'development') {
+   *   console.log('development mode');
+   * }
+   */
+  MODE: 'development' | 'production' | 'none';
+  /**
+   * If `mode` is `'development'`, the value is `true`; otherwise, it is `false`.
+   * @example
+   * if (import.meta.env.DEV) {
+   *   console.log('development mode');
+   * }
+   */
+  DEV: boolean;
+  /**
+   * If `mode` is `'production'`, the value is `true`; otherwise, it is `false`.
+   * @example
+   * if (import.meta.env.PROD) {
+   *   console.log('production mode');
+   * }
+   */
+  PROD: boolean;
+  /**
+   * The value of the `server.base` configuration.
+   * @example
+   * const image = new Image();
+   * // Equivalent to "/foo/favicon.ico"
+   * image.src = `${import.meta.env.BASE_URL}/favicon.ico`;
+   */
+  BASE_URL: string;
+  /**
+   * The URL prefix of static assets
+   * - In development, it is equivalent to the value set by `dev.assetPrefix`.
+   * - In production, it is equivalent to the value set by `output.assetPrefix`.
+   * - Rsbuild will automatically remove the trailing slash from `assetPrefix`
+   * to make string concatenation easier.
+   * @example
+   * const image = new Image();
+   * image.src = `${import.meta.env.ASSET_PREFIX}/favicon.ico`;
+   */
+  ASSET_PREFIX: string;
 }
 interface ImportMeta {
   readonly env: ImportMetaEnv;
@@ -150,9 +193,6 @@ declare module '*.opus' {
   export default src;
 }
 
-/**
- * Configuration files
- */
 /**
  * @requires [@rsbuild/plugin-yaml](https://www.npmjs.com/package/@rsbuild/plugin-yaml)
  */
@@ -160,6 +200,9 @@ declare module '*.yaml' {
   const content: Record<string, any>;
   export default content;
 }
+/**
+ * @requires [@rsbuild/plugin-yaml](https://www.npmjs.com/package/@rsbuild/plugin-yaml)
+ */
 declare module '*.yml' {
   const content: Record<string, any>;
   export default content;
@@ -173,69 +216,37 @@ declare module '*.toml' {
 }
 
 /**
- * Queries
+ * Imports the file as a URL string.
+ * @note Only works for static assets by default.
+ * @example
+ * import logoUrl from './logo.png?url'
+ * console.log(logoUrl) // 'http://example.com/logo.123456.png'
  */
 declare module '*?url' {
   const content: string;
   export default content;
 }
-declare module '*?inline' {
-  const content: string;
-  export default content;
-}
 
 /**
- * Inline CSS
+ * Imports the file content as a base64 encoded string.
+ * @note Only works for static assets and CSS files by default.
+ * @example
+ * import logo from './logo.svg?inline'
+ * console.log(logo) // 'data:image/svg+xml;base64,...'
  */
-declare module '*.css?inline' {
-  const content: string;
-  export default content;
-}
-declare module '*.scss?inline' {
-  const content: string;
-  export default content;
-}
-declare module '*.sass?inline' {
-  const content: string;
-  export default content;
-}
-declare module '*.less?inline' {
-  const content: string;
-  export default content;
-}
-declare module '*.styl?inline' {
-  const content: string;
-  export default content;
-}
-declare module '*.stylus?inline' {
+declare module '*?inline' {
   const content: string;
   export default content;
 }
 
 /**
- * Raw CSS
+ * Imports the raw content of the file as a string.
+ * @note Only works for static assets and CSS files by default.
+ * @example
+ * import raw from './logo.svg?raw'
+ * console.log(raw) // '<svg viewBox="0 0 24 24">...</svg>'
  */
-declare module '*.css?raw' {
-  const content: string;
-  export default content;
-}
-declare module '*.scss?raw' {
-  const content: string;
-  export default content;
-}
-declare module '*.sass?raw' {
-  const content: string;
-  export default content;
-}
-declare module '*.less?raw' {
-  const content: string;
-  export default content;
-}
-declare module '*.styl?raw' {
-  const content: string;
-  export default content;
-}
-declare module '*.stylus?raw' {
+declare module '*?raw' {
   const content: string;
   export default content;
 }
@@ -257,6 +268,9 @@ declare module '*.module.scss' {
   const classes: CSSModuleClasses;
   export default classes;
 }
+/**
+ * @requires [@rsbuild/plugin-sass](https://www.npmjs.com/package/@rsbuild/plugin-sass)
+ */
 declare module '*.module.sass' {
   const classes: CSSModuleClasses;
   export default classes;
@@ -275,6 +289,9 @@ declare module '*.module.styl' {
   const classes: CSSModuleClasses;
   export default classes;
 }
+/**
+ * @requires [@rsbuild/plugin-stylus](https://www.npmjs.com/package/@rsbuild/plugin-stylus)
+ */
 declare module '*.module.stylus' {
   const classes: CSSModuleClasses;
   export default classes;

package/dist-types/plugins/lazyCompilation.d.ts

@@ -1,2 +0,0 @@
-import type { RsbuildPlugin } from '../types';
-export declare const pluginLazyCompilation: () => RsbuildPlugin;

package/dist-types/server/devMiddleware.d.ts

@@ -1,27 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Compiler, MultiCompiler } from '@rspack/core';
-import type { DevMiddlewareOptions } from '../provider/createCompiler';
-import type { NextFunction } from '../types';
-type ServerCallbacks = {
-    onInvalid: (compilationId?: string, fileName?: string | null) => void;
-    onDone: (stats: any) => void;
-};
-export declare const isClientCompiler: (compiler: {
-    options: {
-        target?: Compiler["options"]["target"];
-    };
-}) => boolean;
-export declare const setupServerHooks: (compiler: Compiler, hookCallbacks: ServerCallbacks) => void;
-export type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>;
-export type DevMiddlewareAPI = Middleware & {
-    close: (callback: (err: Error | null | undefined) => void) => any;
-};
-/**
- * The rsbuild/server do nothing about compiler, the devMiddleware need do such things to ensure dev works well:
- * - Call compiler.watch （normally did by rsbuild-dev-middleware）.
- * - Inject the HMR client path into page （the HMR client rsbuild/server already provide）.
- * - Notify server when compiler hooks are triggered.
- */
-export type DevMiddleware = (options: DevMiddlewareOptions) => Promise<DevMiddlewareAPI>;
-export declare const getDevMiddleware: (multiCompiler: Compiler | MultiCompiler) => Promise<NonNullable<DevMiddleware>>;
-export {};

package/dist-types/server/getDevMiddlewares.d.ts

@@ -1,30 +0,0 @@
-import type { DevConfig, EnvironmentAPI, RequestHandler, Rspack, ServerConfig, SetupMiddlewaresServer } from '../types';
-import type { UpgradeEvent } from './helper';
-export type CompileMiddlewareAPI = {
-    middleware: RequestHandler;
-    sockWrite: SetupMiddlewaresServer['sockWrite'];
-    onUpgrade: UpgradeEvent;
-    close: () => Promise<void>;
-};
-export type RsbuildDevMiddlewareOptions = {
-    pwd: string;
-    dev: DevConfig;
-    server: ServerConfig;
-    environments: EnvironmentAPI;
-    compileMiddlewareAPI?: CompileMiddlewareAPI;
-    outputFileSystem: Rspack.OutputFileSystem;
-    output: {
-        distPath: string;
-    };
-    /**
-     * Callbacks returned by the `onBeforeStartDevServer` hook.
-     */
-    postCallbacks: (() => void)[];
-};
-export type Middlewares = Array<RequestHandler | [string, RequestHandler]>;
-export type GetMiddlewaresResult = {
-    close: () => Promise<void>;
-    onUpgrade: UpgradeEvent;
-    middlewares: Middlewares;
-};
-export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<GetMiddlewaresResult>;