@rspack/core 0.6.5-canary-2456d69-20240515093621 → 0.6.5-canary-5042eed-20240515115707

package/dist/Watching.d.ts

@@ -24,6 +24,7 @@ export declare class Watching {
     watch(files: Iterable<string>, dirs: Iterable<string>, missing: Iterable<string>): void;
     close(callback?: () => void): void;
     invalidate(callback?: Callback<Error, void>): void;
+    lazyCompilationInvalidate(files: Set<string>): void;
     /**
      * The reason why this is _done instead of #done, is that in Webpack,
      * it will rewrite this function to another function

package/dist/Watching.js

@@ -160,6 +160,9 @@ class Watching {
         this.onChange();
         __classPrivateFieldGet(this, _Watching_instances, "m", _Watching_invalidate).call(this);
     }
+    lazyCompilationInvalidate(files) {
+        __classPrivateFieldGet(this, _Watching_instances, "m", _Watching_invalidate).call(this, new Map(), new Map(), files, new Set());
+    }
     _done(error, compilation) {
         this.running = false;
         let stats = undefined;

package/dist/builtin-plugin/base.js

@@ -38,7 +38,7 @@ function createBuiltinPlugin(name, options) {
 }
 exports.createBuiltinPlugin = createBuiltinPlugin;
 function create(name, resolve, 
-// `affectedHooks` is used to inform `createChildCompile` about which builtin plugin can be reversed.
+// `affectedHooks` is used to inform `createChildCompile` about which builtin plugin can be reserved.
 // However, this has a drawback as it doesn't represent the actual condition but merely serves as an indicator.
 affectedHooks) {
     class Plugin extends RspackBuiltinPlugin {

package/dist/builtin-plugin/index.d.ts

@@ -58,6 +58,7 @@ export * from "./SwcJsMinimizerPlugin";
 export * from "./WarnCaseSensitiveModulesPlugin";
 export * from "./WebWorkerTemplatePlugin";
 export * from "./WorkerPlugin";
+export * from "./lazy-compilation/plugin";
 import { RawBuiltins } from "@rspack/binding";
 import { RspackOptionsNormalized } from "..";
 export interface Builtins {

package/dist/builtin-plugin/index.js

@@ -76,6 +76,7 @@ __exportStar(require("./SwcJsMinimizerPlugin"), exports);
 __exportStar(require("./WarnCaseSensitiveModulesPlugin"), exports);
 __exportStar(require("./WebWorkerTemplatePlugin"), exports);
 __exportStar(require("./WorkerPlugin"), exports);
+__exportStar(require("./lazy-compilation/plugin"), exports);
 function resolveTreeShaking(treeShaking, production) {
     return treeShaking !== undefined
         ? treeShaking.toString()

package/dist/builtin-plugin/lazy-compilation/backend.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse, ServerOptions as ServerOptionsImport } from "http";
+import type { ListenOptions, Server } from "net";
+import type { Compiler } from "../..";
+import type { SecureContextOptions, TlsOptions } from "tls";
+export interface LazyCompilationDefaultBackendOptions {
+    /**
+     * A custom client.
+     */
+    client?: string;
+    /**
+     * Specifies where to listen to from the server.
+     */
+    listen?: number | ListenOptions | ((server: Server) => void);
+    /**
+     * Specifies the protocol the client should use to connect to the server.
+     */
+    protocol?: "http" | "https";
+    /**
+     * Specifies how to create the server handling the EventSource requests.
+     */
+    server?: ServerOptionsImport<typeof IncomingMessage> | ServerOptionsHttps<typeof IncomingMessage, typeof ServerResponse> | (() => Server);
+}
+export type ServerOptionsHttps<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse = typeof ServerResponse> = SecureContextOptions & TlsOptions & ServerOptionsImport<Request, Response>;
+declare const getBackend: (options: Omit<LazyCompilationDefaultBackendOptions, "client"> & {
+    client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>;
+}) => (compiler: Compiler, callback: (err: any, obj?: {
+    dispose: (callback: (err: any) => void) => void;
+    module: (args: {
+        module: string;
+        path: string;
+    }) => {
+        data: string;
+        client: string;
+        active: boolean;
+    };
+} | undefined) => void) => void;
+export default getBackend;
+export declare function dispose(callback: any): void;
+export declare function moduleImpl(args: {
+    module: string;
+    path: string;
+}): {
+    active: boolean;
+    data: string;
+    client: string;
+};

package/dist/builtin-plugin/lazy-compilation/backend.js

@@ -0,0 +1,139 @@
+/*
+    MIT License http://www.opensource.org/licenses/mit-license.php
+    Author Tobias Koppers @sokra
+*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleImpl = exports.dispose = void 0;
+const getBackend = (options) => (compiler, callback) => {
+    const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+    const activeModules = new Map();
+    const filesByKey = new Map();
+    const prefix = "/lazy-compilation-using-";
+    const isHttps = options.protocol === "https" ||
+        (typeof options.server === "object" &&
+            ("key" in options.server || "pfx" in options.server));
+    const createServer = typeof options.server === "function"
+        ? options.server
+        : (() => {
+            const http = isHttps ? require("https") : require("http");
+            return http.createServer.bind(http, options.server);
+        })();
+    const listen = typeof options.listen === "function"
+        ? options.listen
+        : (server) => {
+            let listen = options.listen;
+            if (typeof listen === "object" && !("port" in listen))
+                listen = { ...listen, port: undefined };
+            server.listen(listen);
+        };
+    const protocol = options.protocol || (isHttps ? "https" : "http");
+    const requestListener = (req, res) => {
+        const keys = req.url.slice(prefix.length).split("@");
+        req.socket.on("close", () => {
+            setTimeout(() => {
+                for (const key of keys) {
+                    const oldValue = activeModules.get(key) || 0;
+                    activeModules.set(key, oldValue - 1);
+                    if (oldValue === 1) {
+                        logger.log(`${key} is no longer in use. Next compilation will skip this module.`);
+                    }
+                }
+            }, 120000);
+        });
+        req.socket.setNoDelay(true);
+        res.writeHead(200, {
+            "content-type": "text/event-stream",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "*",
+            "Access-Control-Allow-Headers": "*"
+        });
+        res.write("\n");
+        const moduleActivated = [];
+        for (const key of keys) {
+            const oldValue = activeModules.get(key) || 0;
+            activeModules.set(key, oldValue + 1);
+            if (oldValue === 0) {
+                logger.log(`${key} is now in use and will be compiled.`);
+                moduleActivated.push(key);
+            }
+        }
+        if (moduleActivated.length && compiler.watching) {
+            compiler.watching.lazyCompilationInvalidate(new Set(moduleActivated.map(key => filesByKey.get(key))));
+        }
+    };
+    const server = createServer();
+    server.on("request", requestListener);
+    let isClosing = false;
+    const sockets = new Set();
+    server.on("connection", socket => {
+        sockets.add(socket);
+        socket.on("close", () => {
+            sockets.delete(socket);
+        });
+        if (isClosing)
+            socket.destroy();
+    });
+    server.on("clientError", e => {
+        if (e.message !== "Server is disposing")
+            logger.warn(e);
+    });
+    server.on("listening", (err) => {
+        if (err)
+            return callback(err);
+        const addr = server.address();
+        if (typeof addr === "string")
+            throw new Error("addr must not be a string");
+        const urlBase = addr.address === "::" || addr.address === "0.0.0.0"
+            ? `${protocol}://localhost:${addr.port}`
+            : addr.family === "IPv6"
+                ? `${protocol}://[${addr.address}]:${addr.port}`
+                : `${protocol}://${addr.address}:${addr.port}`;
+        logger.log(`Server-Sent-Events server for lazy compilation open at ${urlBase}.`);
+        const result = {
+            dispose(callback) {
+                isClosing = true;
+                // Removing the listener is a workaround for a memory leak in node.js
+                server.off("request", requestListener);
+                server.close(err => {
+                    callback(err);
+                });
+                for (const socket of sockets) {
+                    socket.destroy(new Error("Server is disposing"));
+                }
+            },
+            module({ module: originalModule, path }) {
+                const key = `${encodeURIComponent(originalModule.replace(/\\/g, "/").replace(/@/g, "_")).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
+                filesByKey.set(key, path);
+                const active = activeModules.get(key) > 0;
+                return {
+                    client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+                    data: key,
+                    active
+                };
+            }
+        };
+        state.module = result.module;
+        state.dispose = result.dispose;
+        callback(null, result);
+    });
+    listen(server);
+};
+exports.default = getBackend;
+function unimplemented() {
+    throw new Error("access before initialization");
+}
+const state = {
+    module: unimplemented,
+    dispose: unimplemented
+};
+function dispose(callback) {
+    state.dispose(callback);
+    state.dispose = unimplemented;
+    state.module = unimplemented;
+}
+exports.dispose = dispose;
+function moduleImpl(args) {
+    return state.module(args);
+}
+exports.moduleImpl = moduleImpl;

package/dist/builtin-plugin/lazy-compilation/lazyCompilation.d.ts

@@ -0,0 +1,30 @@
+import { BuiltinPluginName, JsModule, RawRegexMatcher } from "@rspack/binding";
+export declare const BuiltinLazyCompilationPlugin: {
+    new (module: (args: {
+        module: string;
+        path: string;
+    }) => {
+        active: boolean;
+        data: string;
+        client: string;
+    }, cacheable: boolean, entries: boolean, imports: boolean, test?: RawRegexMatcher | ((m: JsModule) => boolean) | undefined): {
+        name: BuiltinPluginName;
+        _options: {
+            module: (args: {
+                module: string;
+                path: string;
+            }) => {
+                active: boolean;
+                data: string;
+                client: string;
+            };
+            cacheable: boolean;
+            imports: boolean;
+            entries: boolean;
+            test: RawRegexMatcher | ((m: JsModule) => boolean) | undefined;
+        };
+        affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
+        raw(): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("../../Compiler").Compiler): void;
+    };
+};

package/dist/builtin-plugin/lazy-compilation/lazyCompilation.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltinLazyCompilationPlugin = void 0;
+const binding_1 = require("@rspack/binding");
+const base_1 = require("../base");
+exports.BuiltinLazyCompilationPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.LazyCompilationPlugin, (module, cacheable, entries, imports, test) => ({ module, cacheable, imports, entries, test }), "thisCompilation");

package/dist/builtin-plugin/lazy-compilation/plugin.d.ts

@@ -0,0 +1,13 @@
+import type { Compiler } from "../..";
+import { LazyCompilationDefaultBackendOptions } from "./backend";
+import { JsModule, RawRegexMatcher } from "@rspack/binding";
+export default class LazyCompilationPlugin {
+    cacheable: boolean;
+    entries: boolean;
+    imports: boolean;
+    test?: RawRegexMatcher | ((m: JsModule) => boolean);
+    backend?: LazyCompilationDefaultBackendOptions;
+    constructor(cacheable: boolean, entries: boolean, imports: boolean, test?: RawRegexMatcher | ((m: JsModule) => boolean), backend?: LazyCompilationDefaultBackendOptions);
+    apply(compiler: Compiler): void;
+}
+export { LazyCompilationPlugin };

package/dist/builtin-plugin/lazy-compilation/plugin.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyCompilationPlugin = void 0;
+const lazyCompilation_1 = require("./lazyCompilation");
+const backend_1 = __importStar(require("./backend"));
+class LazyCompilationPlugin {
+    constructor(cacheable, entries, imports, test, backend) {
+        this.cacheable = cacheable;
+        this.entries = entries;
+        this.imports = imports;
+        this.test = test;
+        this.backend = backend;
+    }
+    apply(compiler) {
+        const backend = (0, backend_1.default)({
+            ...this.backend,
+            client: require.resolve(`../../../hot/lazy-compilation-${compiler.options.externalsPresets.node ? "node" : "web"}.js`)
+        });
+        new lazyCompilation_1.BuiltinLazyCompilationPlugin(backend_1.moduleImpl, this.cacheable, this.entries, this.imports, this.test).apply(compiler);
+        let initialized = false;
+        compiler.hooks.beforeCompile.tapAsync("LazyCompilationPlugin", (_params, callback) => {
+            if (initialized)
+                return callback();
+            backend(compiler, (err, result) => {
+                if (err)
+                    return callback(err);
+                initialized = true;
+                callback();
+            });
+        });
+        compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
+            (0, backend_1.dispose)(callback);
+        });
+    }
+}
+exports.default = LazyCompilationPlugin;
+exports.LazyCompilationPlugin = LazyCompilationPlugin;

package/dist/config/normalization.d.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type { Compilation } from "../Compilation";
-import type { AssetModuleFilename, Bail, Builtins, CacheOptions, ChunkFilename, ChunkLoading, ChunkLoadingGlobal, Clean, Context, CrossOriginLoading, CssChunkFilename, CssFilename, Dependencies, DevServer, DevTool, DevtoolFallbackModuleFilenameTemplate, DevtoolModuleFilenameTemplate, DevtoolNamespace, EnabledLibraryTypes, EnabledWasmLoadingTypes, EntryFilename, EntryRuntime, Externals, ExternalsPresets, ExternalsType, Filename, GeneratorOptionsByModuleType, GlobalObject, HashDigest, HashDigestLength, HashFunction, HashSalt, HotUpdateChunkFilename, HotUpdateGlobal, HotUpdateMainFilename, Iife, ImportFunctionName, InfrastructureLogging, LibraryOptions, Mode, Name, Node, NoParseOption, Optimization, OutputModule, ParserOptionsByModuleType, Path, Performance, Plugins, Profile, PublicPath, Resolve, RspackFutureOptions, RspackOptions, RuleSetRules, ScriptType, SnapshotOptions, SourceMapFilename, StatsValue, StrictModuleErrorHandling, Target, TrustedTypes, UniqueName, WasmLoading, Watch, WatchOptions, WebassemblyModuleFilename, WorkerPublicPath } from "./zod";
+import type { AssetModuleFilename, Bail, Builtins, CacheOptions, ChunkFilename, ChunkLoading, ChunkLoadingGlobal, Clean, Context, CrossOriginLoading, CssChunkFilename, CssFilename, Dependencies, DevServer, DevTool, DevtoolFallbackModuleFilenameTemplate, DevtoolModuleFilenameTemplate, DevtoolNamespace, EnabledLibraryTypes, EnabledWasmLoadingTypes, EntryFilename, EntryRuntime, Externals, ExternalsPresets, ExternalsType, Filename, GeneratorOptionsByModuleType, GlobalObject, HashDigest, HashDigestLength, HashFunction, HashSalt, HotUpdateChunkFilename, HotUpdateGlobal, HotUpdateMainFilename, Iife, ImportFunctionName, InfrastructureLogging, LibraryOptions, Mode, Name, Node, NoParseOption, Optimization, OutputModule, ParserOptionsByModuleType, Path, Performance, Plugins, Profile, PublicPath, Resolve, RspackFutureOptions, RspackOptions, RuleSetRules, ScriptType, SnapshotOptions, SourceMapFilename, StatsValue, StrictModuleErrorHandling, Target, TrustedTypes, UniqueName, WasmLoading, Watch, WatchOptions, WebassemblyModuleFilename, WorkerPublicPath, LazyCompilationOptions } from "./zod";
 export declare const getNormalizedRspackOptions: (config: RspackOptions) => RspackOptionsNormalized;
 export type EntryDynamicNormalized = () => Promise<EntryStaticNormalized>;
 export type EntryNormalized = EntryDynamicNormalized | EntryStaticNormalized;
@@ -78,7 +78,7 @@ export interface ModuleOptionsNormalized {
     noParse?: NoParseOption;
 }
 export interface ExperimentsNormalized {
-    lazyCompilation?: boolean;
+    lazyCompilation?: false | LazyCompilationOptions;
     asyncWebAssembly?: boolean;
     outputModule?: boolean;
     topLevelAwait?: boolean;

package/dist/config/normalization.js

@@ -190,7 +190,8 @@ const getNormalizedRspackOptions = (config) => {
         performance: config.performance,
         plugins: nestedArray(config.plugins, p => [...p]),
         experiments: nestedConfig(config.experiments, experiments => ({
-            ...experiments
+            ...experiments,
+            lazyCompilation: optionalNestedConfig(experiments.lazyCompilation, options => (options === true ? {} : options))
         })),
         watch: config.watch,
         watchOptions: cloneObject(config.watchOptions),

package/dist/config/zod.d.ts

@@ -4502,8 +4502,34 @@ declare const rspackFutureOptions: z.ZodObject<{
     } | undefined;
 }>;
 export type RspackFutureOptions = z.infer<typeof rspackFutureOptions>;
+declare const lazyCompilationOptions: z.ZodObject<{
+    imports: z.ZodOptional<z.ZodBoolean>;
+    entries: z.ZodOptional<z.ZodBoolean>;
+    test: z.ZodOptional<z.ZodUnion<[z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodType<Module, z.ZodTypeDef, Module>], z.ZodUnknown>, z.ZodBoolean>]>>;
+}, "strip", z.ZodTypeAny, {
+    imports?: boolean | undefined;
+    entries?: boolean | undefined;
+    test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+}, {
+    imports?: boolean | undefined;
+    entries?: boolean | undefined;
+    test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+}>;
+export type LazyCompilationOptions = z.infer<typeof lazyCompilationOptions>;
 declare const experiments: z.ZodObject<{
-    lazyCompilation: z.ZodOptional<z.ZodBoolean>;
+    lazyCompilation: z.ZodUnion<[z.ZodOptional<z.ZodBoolean>, z.ZodObject<{
+        imports: z.ZodOptional<z.ZodBoolean>;
+        entries: z.ZodOptional<z.ZodBoolean>;
+        test: z.ZodOptional<z.ZodUnion<[z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodType<Module, z.ZodTypeDef, Module>], z.ZodUnknown>, z.ZodBoolean>]>>;
+    }, "strip", z.ZodTypeAny, {
+        imports?: boolean | undefined;
+        entries?: boolean | undefined;
+        test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+    }, {
+        imports?: boolean | undefined;
+        entries?: boolean | undefined;
+        test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+    }>]>;
     asyncWebAssembly: z.ZodOptional<z.ZodBoolean>;
     outputModule: z.ZodOptional<z.ZodBoolean>;
     topLevelAwait: z.ZodOptional<z.ZodBoolean>;
@@ -4535,7 +4561,11 @@ declare const experiments: z.ZodObject<{
         } | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
-    lazyCompilation?: boolean | undefined;
+    lazyCompilation?: boolean | {
+        imports?: boolean | undefined;
+        entries?: boolean | undefined;
+        test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+    } | undefined;
     asyncWebAssembly?: boolean | undefined;
     outputModule?: boolean | undefined;
     topLevelAwait?: boolean | undefined;
@@ -4549,7 +4579,11 @@ declare const experiments: z.ZodObject<{
         } | undefined;
     } | undefined;
 }, {
-    lazyCompilation?: boolean | undefined;
+    lazyCompilation?: boolean | {
+        imports?: boolean | undefined;
+        entries?: boolean | undefined;
+        test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+    } | undefined;
     asyncWebAssembly?: boolean | undefined;
     outputModule?: boolean | undefined;
     topLevelAwait?: boolean | undefined;
@@ -5183,7 +5217,19 @@ export declare const rspackOptions: z.ZodObject<{
     target: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["web", "webworker", "es3", "es5", "es2015", "es2016", "es2017", "es2018", "es2019", "es2020", "es2021", "es2022", "browserslist"]>, z.ZodLiteral<"node">]>, z.ZodLiteral<"async-node">]>, z.ZodType<`node${number}`, z.ZodTypeDef, `node${number}`>]>, z.ZodType<`async-node${number}`, z.ZodTypeDef, `async-node${number}`>]>, z.ZodType<`node${number}.${number}`, z.ZodTypeDef, `node${number}.${number}`>]>, z.ZodType<`async-node${number}.${number}`, z.ZodTypeDef, `async-node${number}.${number}`>]>, z.ZodLiteral<"electron-main">]>, z.ZodType<`electron${number}-main`, z.ZodTypeDef, `electron${number}-main`>]>, z.ZodType<`electron${number}.${number}-main`, z.ZodTypeDef, `electron${number}.${number}-main`>]>, z.ZodLiteral<"electron-renderer">]>, z.ZodType<`electron${number}-renderer`, z.ZodTypeDef, `electron${number}-renderer`>]>, z.ZodType<`electron${number}.${number}-renderer`, z.ZodTypeDef, `electron${number}.${number}-renderer`>]>, z.ZodLiteral<"electron-preload">]>, z.ZodType<`electron${number}-preload`, z.ZodTypeDef, `electron${number}-preload`>]>, z.ZodType<`electron${number}.${number}-preload`, z.ZodTypeDef, `electron${number}.${number}-preload`>]>]>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["web", "webworker", "es3", "es5", "es2015", "es2016", "es2017", "es2018", "es2019", "es2020", "es2021", "es2022", "browserslist"]>, z.ZodLiteral<"node">]>, z.ZodLiteral<"async-node">]>, z.ZodType<`node${number}`, z.ZodTypeDef, `node${number}`>]>, z.ZodType<`async-node${number}`, z.ZodTypeDef, `async-node${number}`>]>, z.ZodType<`node${number}.${number}`, z.ZodTypeDef, `node${number}.${number}`>]>, z.ZodType<`async-node${number}.${number}`, z.ZodTypeDef, `async-node${number}.${number}`>]>, z.ZodLiteral<"electron-main">]>, z.ZodType<`electron${number}-main`, z.ZodTypeDef, `electron${number}-main`>]>, z.ZodType<`electron${number}.${number}-main`, z.ZodTypeDef, `electron${number}.${number}-main`>]>, z.ZodLiteral<"electron-renderer">]>, z.ZodType<`electron${number}-renderer`, z.ZodTypeDef, `electron${number}-renderer`>]>, z.ZodType<`electron${number}.${number}-renderer`, z.ZodTypeDef, `electron${number}.${number}-renderer`>]>, z.ZodLiteral<"electron-preload">]>, z.ZodType<`electron${number}-preload`, z.ZodTypeDef, `electron${number}-preload`>]>, z.ZodType<`electron${number}.${number}-preload`, z.ZodTypeDef, `electron${number}.${number}-preload`>]>, "many">]>>;
     mode: z.ZodOptional<z.ZodEnum<["development", "production", "none"]>>;
     experiments: z.ZodOptional<z.ZodObject<{
-        lazyCompilation: z.ZodOptional<z.ZodBoolean>;
+        lazyCompilation: z.ZodUnion<[z.ZodOptional<z.ZodBoolean>, z.ZodObject<{
+            imports: z.ZodOptional<z.ZodBoolean>;
+            entries: z.ZodOptional<z.ZodBoolean>;
+            test: z.ZodOptional<z.ZodUnion<[z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodType<Module, z.ZodTypeDef, Module>], z.ZodUnknown>, z.ZodBoolean>]>>;
+        }, "strip", z.ZodTypeAny, {
+            imports?: boolean | undefined;
+            entries?: boolean | undefined;
+            test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+        }, {
+            imports?: boolean | undefined;
+            entries?: boolean | undefined;
+            test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+        }>]>;
         asyncWebAssembly: z.ZodOptional<z.ZodBoolean>;
         outputModule: z.ZodOptional<z.ZodBoolean>;
         topLevelAwait: z.ZodOptional<z.ZodBoolean>;
@@ -5215,7 +5261,11 @@ export declare const rspackOptions: z.ZodObject<{
             } | undefined;
         }>>;
     }, "strict", z.ZodTypeAny, {
-        lazyCompilation?: boolean | undefined;
+        lazyCompilation?: boolean | {
+            imports?: boolean | undefined;
+            entries?: boolean | undefined;
+            test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+        } | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -5229,7 +5279,11 @@ export declare const rspackOptions: z.ZodObject<{
             } | undefined;
         } | undefined;
     }, {
-        lazyCompilation?: boolean | undefined;
+        lazyCompilation?: boolean | {
+            imports?: boolean | undefined;
+            entries?: boolean | undefined;
+            test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+        } | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -6661,7 +6715,11 @@ export declare const rspackOptions: z.ZodObject<{
     target?: false | "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "node" | "async-node" | "web" | "webworker" | "browserslist" | `node${number}` | `async-node${number}` | `node${number}.${number}` | `async-node${number}.${number}` | "electron-main" | `electron${number}-main` | `electron${number}.${number}-main` | "electron-renderer" | `electron${number}-renderer` | `electron${number}.${number}-renderer` | "electron-preload" | `electron${number}-preload` | `electron${number}.${number}-preload` | ("es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "node" | "async-node" | "web" | "webworker" | "browserslist" | `node${number}` | `async-node${number}` | `node${number}.${number}` | `async-node${number}.${number}` | "electron-main" | `electron${number}-main` | `electron${number}.${number}-main` | "electron-renderer" | `electron${number}-renderer` | `electron${number}.${number}-renderer` | "electron-preload" | `electron${number}-preload` | `electron${number}.${number}-preload`)[] | undefined;
     mode?: "none" | "development" | "production" | undefined;
     experiments?: {
-        lazyCompilation?: boolean | undefined;
+        lazyCompilation?: boolean | {
+            imports?: boolean | undefined;
+            entries?: boolean | undefined;
+            test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+        } | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -7085,7 +7143,11 @@ export declare const rspackOptions: z.ZodObject<{
     target?: false | "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "node" | "async-node" | "web" | "webworker" | "browserslist" | `node${number}` | `async-node${number}` | `node${number}.${number}` | `async-node${number}.${number}` | "electron-main" | `electron${number}-main` | `electron${number}.${number}-main` | "electron-renderer" | `electron${number}-renderer` | `electron${number}.${number}-renderer` | "electron-preload" | `electron${number}-preload` | `electron${number}.${number}-preload` | ("es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "node" | "async-node" | "web" | "webworker" | "browserslist" | `node${number}` | `async-node${number}` | `node${number}.${number}` | `async-node${number}.${number}` | "electron-main" | `electron${number}-main` | `electron${number}.${number}-main` | "electron-renderer" | `electron${number}-renderer` | `electron${number}.${number}-renderer` | "electron-preload" | `electron${number}-preload` | `electron${number}.${number}-preload`)[] | undefined;
     mode?: "none" | "development" | "production" | undefined;
     experiments?: {
-        lazyCompilation?: boolean | undefined;
+        lazyCompilation?: boolean | {
+            imports?: boolean | undefined;
+            entries?: boolean | undefined;
+            test?: RegExp | ((args_0: Module, ...args_1: unknown[]) => boolean) | undefined;
+        } | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;

package/dist/config/zod.js

@@ -749,8 +749,16 @@ const rspackFutureOptions = zod_1.z.strictObject({
     })
         .optional()
 });
+const lazyCompilationOptions = zod_1.z.object({
+    imports: zod_1.z.boolean().optional(),
+    entries: zod_1.z.boolean().optional(),
+    test: zod_1.z
+        .instanceof(RegExp)
+        .or(zod_1.z.function().args(zod_1.z.custom()).returns(zod_1.z.boolean()))
+        .optional()
+});
 const experiments = zod_1.z.strictObject({
-    lazyCompilation: zod_1.z.boolean().optional(),
+    lazyCompilation: zod_1.z.boolean().optional().or(lazyCompilationOptions),
     asyncWebAssembly: zod_1.z.boolean().optional(),
     outputModule: zod_1.z.boolean().optional(),
     topLevelAwait: zod_1.z.boolean().optional(),

package/dist/rspackOptionsApply.js

@@ -14,6 +14,7 @@ exports.RspackOptionsApply = void 0;
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 const assert_1 = __importDefault(require("assert"));
+const Module_1 = require("./Module");
 const graceful_fs_1 = __importDefault(require("../compiled/graceful-fs"));
 const builtin_plugin_1 = require("./builtin-plugin");
 const EntryOptionPlugin_1 = __importDefault(require("./lib/EntryOptionPlugin"));
@@ -25,7 +26,7 @@ const cleverMerge_1 = require("./util/cleverMerge");
 class RspackOptionsApply {
     constructor() { }
     process(options, compiler) {
-        var _a;
+        var _a, _b, _c, _d;
         (0, assert_1.default)(options.output.path, "options.output.path should have value after `applyRspackOptionsDefaults`");
         compiler.outputPath = options.output.path;
         compiler.name = options.name;
@@ -163,6 +164,24 @@ class RspackOptionsApply {
                 new builtin_plugin_1.MangleExportsPlugin(options.optimization.mangleExports !== "size").apply(compiler);
             }
         }
+        if (options.experiments.lazyCompilation) {
+            const lazyOptions = options.experiments.lazyCompilation;
+            new builtin_plugin_1.LazyCompilationPlugin(
+            // this is only for test
+            // @ts-expect-error cacheable is hide
+            (_b = lazyOptions.cacheable) !== null && _b !== void 0 ? _b : true, (_c = lazyOptions.entries) !== null && _c !== void 0 ? _c : true, (_d = lazyOptions.imports) !== null && _d !== void 0 ? _d : true, typeof lazyOptions.test === "function"
+                ? function (jsModule) {
+                    return lazyOptions.test.call(lazyOptions, new Module_1.Module(jsModule));
+                }
+                : lazyOptions.test
+                    ? {
+                        source: lazyOptions.test.source,
+                        flags: lazyOptions.test.flags
+                    }
+                    : undefined, 
+            // @ts-expect-error backend is hide
+            lazyOptions.backend).apply(compiler);
+        }
         if (options.output.enabledLibraryTypes &&
             options.output.enabledLibraryTypes.length > 0) {
             for (const type of options.output.enabledLibraryTypes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "0.6.5-canary-2456d69-20240515093621",
+  "version": "0.6.5-canary-5042eed-20240515115707",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "A Fast Rust-based Web Bundler",
@@ -71,8 +71,8 @@
     "watchpack": "^2.4.0",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1",
-    "@rspack/core": "0.6.5-canary-2456d69-20240515093621",
-    "@rspack/plugin-minify": "^0.6.5-canary-2456d69-20240515093621"
+    "@rspack/plugin-minify": "^0.6.5-canary-5042eed-20240515115707",
+    "@rspack/core": "0.6.5-canary-5042eed-20240515115707"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.1.6",
@@ -80,7 +80,7 @@
     "enhanced-resolve": "5.12.0",
     "tapable": "2.2.1",
     "webpack-sources": "3.2.3",
-    "@rspack/binding": "0.6.5-canary-2456d69-20240515093621"
+    "@rspack/binding": "0.6.5-canary-5042eed-20240515115707"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"