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

package/dist-types/configChain.d.ts

@@ -24,18 +24,26 @@ export declare const CHAIN_ID: {
         readonly CSS: "css";
         /** Rule for raw CSS */
         readonly CSS_RAW: "css-raw";
+        /** Rule for inline CSS */
+        readonly CSS_INLINE: "css-inline";
         /** Rule for Less */
         readonly LESS: "less";
         /** Rule for raw Less */
         readonly LESS_RAW: "less-raw";
+        /** Rule for inline Less */
+        readonly LESS_INLINE: "less-inline";
         /** Rule for Sass */
         readonly SASS: "sass";
         /** Rule for raw Sass */
         readonly SASS_RAW: "sass-raw";
+        /** Rule for inline Sass */
+        readonly SASS_INLINE: "sass-inline";
         /** Rule for stylus */
         readonly STYLUS: "stylus";
         /** Rule for raw stylus */
         readonly STYLUS_RAW: "stylus-raw";
+        /** Rule for inline stylus */
+        readonly STYLUS_INLINE: "stylus-inline";
         /** Rule for svg */
         readonly SVG: "svg";
         /** Rule for pug */

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/plugins/css.d.ts

@@ -1,4 +1,4 @@
 import type { CSSLoaderOptions, NormalizedEnvironmentConfig, RsbuildPlugin, Rspack } from '../types';
-export declare const getLightningCSSLoaderOptions: (config: NormalizedEnvironmentConfig, targets: string[]) => Rspack.LightningcssLoaderOptions;
+export declare const getLightningCSSLoaderOptions: (config: NormalizedEnvironmentConfig, targets: string[], minify: boolean) => Rspack.LightningcssLoaderOptions;
 export declare const normalizeCssLoaderOptions: (options: CSSLoaderOptions, exportOnlyLocals: boolean) => CSSLoaderOptions;
 export declare const pluginCss: () => RsbuildPlugin;

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.1",
+  "version": "1.3.0-beta.3",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -46,16 +46,17 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "1.3.0-beta.0",
+    "@rspack/core": "1.3.0-beta.1",
     "@rspack/lite-tapable": "~1.0.1",
     "@swc/helpers": "^0.5.15",
     "core-js": "~3.41.0",
     "jiti": "^2.4.2"
   },
   "devDependencies": {
-    "@rslib/core": "0.5.4",
+    "@rslib/core": "0.5.5",
     "@types/connect": "3.4.38",
-    "@types/node": "^22.13.10",
+    "@types/cors": "^2.8.17",
+    "@types/node": "^22.13.11",
     "@types/on-finished": "2.3.4",
     "@types/webpack-bundle-analyzer": "4.7.0",
     "@types/ws": "^8.18.0",
@@ -83,7 +84,7 @@
     "reduce-configs": "^1.1.0",
     "rsbuild-dev-middleware": "0.2.0",
     "rslog": "^1.2.3",
-    "rspack-chain": "^1.2.2",
+    "rspack-chain": "^1.2.3",
     "rspack-manifest-plugin": "5.0.3",
     "sirv": "^3.0.1",
     "style-loader": "3.3.4",

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,41 +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;
 }
+
+/**
+ * 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 '*?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;
 }
@@ -229,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;
@@ -247,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>;