@rspack/core 0.5.7-canary-dcd4782-20240312094134 → 0.5.7-canary-1f35c13-20240313091234

package/dist/Compilation.d.ts

@@ -36,7 +36,7 @@ export interface Asset {
 }
 export interface LogEntry {
     type: string;
-    args: any[];
+    args?: any[];
     time?: number;
     trace?: string[];
 }

package/dist/Compilation.js

@@ -473,14 +473,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             const logEntry = {
                 time: Date.now(),
                 type,
-                // @ts-expect-error
                 args,
-                // @ts-expect-error
                 trace
             };
             if (this.hooks.log.call(name, logEntry) === undefined) {
                 if (logEntry.type === Logger_1.LogType.profileEnd) {
-                    if (typeof console.profileEnd === "function") {
+                    if (typeof console.profileEnd === "function" && logEntry.args) {
                         console.profileEnd(`[${name}] ${logEntry.args[0]}`);
                     }
                 }
@@ -493,7 +491,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 }
                 logEntries.push(logEntry);
                 if (logEntry.type === Logger_1.LogType.profile) {
-                    if (typeof console.profile === "function") {
+                    if (typeof console.profile === "function" && logEntry.args) {
                         console.profile(`[${name}] ${logEntry.args[0]}`);
                     }
                 }

package/dist/Compiler.d.ts

@@ -12,7 +12,7 @@ import * as binding from "@rspack/binding";
 import * as tapable from "tapable";
 import * as liteTapable from "./lite-tapable";
 import { Callback } from "tapable";
-import type { WatchOptions } from "watchpack";
+import { WatchOptions } from "./config";
 import { EntryNormalized, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance } from "./config";
 import { RuleSetCompiler } from "./RuleSetCompiler";
 import { Stats } from "./Stats";
@@ -48,7 +48,7 @@ declare class Compiler {
     ruleSet: RuleSetCompiler;
     watchFileSystem: WatchFileSystem;
     intermediateFileSystem: any;
-    watchMode: boolean;
+    watchMode?: boolean;
     context: string;
     modifiedFiles?: ReadonlySet<string>;
     cache: Cache;
@@ -67,7 +67,7 @@ declare class Compiler {
         contextModuleFactory: tapable.SyncHook<ContextModuleFactory>;
         initialize: tapable.SyncHook<[]>;
         shouldEmit: tapable.SyncBailHook<[Compilation], boolean>;
-        infrastructureLog: tapable.SyncBailHook<[string, string, any[]], true>;
+        infrastructureLog: tapable.SyncBailHook<[string, string, any[]?], true>;
         beforeRun: tapable.AsyncSeriesHook<[Compiler]>;
         run: tapable.AsyncSeriesHook<[Compiler]>;
         emit: tapable.AsyncSeriesHook<[Compilation]>;
@@ -111,7 +111,7 @@ declare class Compiler {
      */
     rebuild(modifiedFiles?: ReadonlySet<string>, removedFiles?: ReadonlySet<string>, callback?: (error: Error | null) => void): void;
     compile(callback: Callback<Error, Compilation>): void;
-    watch(watchOptions: WatchOptions, handler: Callback<Error, Stats>): Watching;
+    watch(watchOptions: WatchOptions, handler: (error?: Error, stats?: Stats) => void): Watching | void;
     purgeInputFileSystem(): void;
     close(callback: (error?: Error | null) => void): void;
     getAsset(name: string): Buffer | null;

package/dist/Compiler.js

@@ -259,9 +259,7 @@ class Compiler {
                 }
             }
             else {
-                if (
-                // @ts-expect-error
-                this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+                if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
                     if (this.infrastructureLogger !== undefined) {
                         this.infrastructureLogger(name, type, args);
                     }
@@ -270,8 +268,7 @@ class Compiler {
         }, (childName) => {
             if (typeof name === "function") {
                 if (typeof childName === "function") {
-                    // @ts-expect-error
-                    return this.getInfrastructureLogger(_ => {
+                    return this.getInfrastructureLogger(() => {
                         if (typeof name === "function") {
                             name = name();
                             if (!name) {
@@ -324,7 +321,6 @@ class Compiler {
         const startTime = Date.now();
         this.running = true;
         const doRun = () => {
-            // @ts-expect-error
             const finalCallback = (err, stats) => {
                 this.idle = true;
                 this.cache.beginIdle();
@@ -336,7 +332,7 @@ class Compiler {
                 if (callback) {
                     callback(err, stats);
                 }
-                this.hooks.afterDone.call(stats);
+                stats && this.hooks.afterDone.call(stats);
             };
             this.hooks.beforeRun.callAsync(this, err => {
                 if (err) {
@@ -447,12 +443,10 @@ class Compiler {
     }
     watch(watchOptions, handler) {
         if (this.running) {
-            // @ts-expect-error
             return handler(new ConcurrentCompilationError_1.default());
         }
         this.running = true;
         this.watchMode = true;
-        // @ts-expect-error
         this.watching = new Watching_1.Watching(this, watchOptions, handler);
         return this.watching;
     }
@@ -647,7 +641,7 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         };
     });
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    return res;
+    return [res, resolveData.createData];
 }, _Compiler_contextModuleFactoryBeforeResolve = async function _Compiler_contextModuleFactoryBeforeResolve(resourceData) {
     var _a;
     let res = await ((_a = this.compilation.contextModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.beforeResolve.promise(resourceData));

package/dist/MultiCompiler.js

@@ -240,8 +240,8 @@ class MultiCompiler {
             }, (compiler, watching, _done) => {
                 if (compiler.watching !== watching)
                     return;
-                if (!watching.running)
-                    watching.invalidate();
+                if (!(watching === null || watching === void 0 ? void 0 : watching.running))
+                    watching === null || watching === void 0 ? void 0 : watching.invalidate();
             }, handler);
             // @ts-expect-error
             return new MultiWatching_1.default(watchings, this);

package/dist/Watching.d.ts

@@ -33,7 +33,6 @@ 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

@@ -150,9 +150,6 @@ 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/index.d.ts

@@ -50,7 +50,6 @@ export * from "./HtmlRspackPlugin";
 export * from "./CopyRspackPlugin";
 export * from "./SwcJsMinimizerPlugin";
 export * from "./SwcCssMinimizerPlugin";
-export * from "./lazy-compilation/plugin";
 import { RawBuiltins, RawCssModulesConfig } from "@rspack/binding";
 import { RspackOptionsNormalized } from "..";
 type BuiltinsCssConfig = {

package/dist/builtin-plugin/index.js

@@ -68,7 +68,6 @@ __exportStar(require("./HtmlRspackPlugin"), exports);
 __exportStar(require("./CopyRspackPlugin"), exports);
 __exportStar(require("./SwcJsMinimizerPlugin"), exports);
 __exportStar(require("./SwcCssMinimizerPlugin"), exports);
-__exportStar(require("./lazy-compilation/plugin"), exports);
 function resolveTreeShaking(treeShaking, production) {
     return treeShaking !== undefined
         ? treeShaking.toString()

package/dist/config/normalization.d.ts

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

package/dist/config/normalization.js

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

package/dist/config/zod.d.ts

@@ -3154,34 +3154,8 @@ 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.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
-}, "strip", z.ZodTypeAny, {
-    imports?: boolean | undefined;
-    entries?: boolean | undefined;
-    test?: RegExp | undefined;
-}, {
-    imports?: boolean | undefined;
-    entries?: boolean | undefined;
-    test?: RegExp | undefined;
-}>;
-export type LazyCompilationOptions = z.infer<typeof lazyCompilationOptions>;
 declare const experiments: z.ZodObject<{
-    lazyCompilation: z.ZodUnion<[z.ZodOptional<z.ZodBoolean>, z.ZodObject<{
-        imports: z.ZodOptional<z.ZodBoolean>;
-        entries: z.ZodOptional<z.ZodBoolean>;
-        test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
-    }, "strip", z.ZodTypeAny, {
-        imports?: boolean | undefined;
-        entries?: boolean | undefined;
-        test?: RegExp | undefined;
-    }, {
-        imports?: boolean | undefined;
-        entries?: boolean | undefined;
-        test?: RegExp | undefined;
-    }>]>;
+    lazyCompilation: z.ZodOptional<z.ZodBoolean>;
     asyncWebAssembly: z.ZodOptional<z.ZodBoolean>;
     outputModule: z.ZodOptional<z.ZodBoolean>;
     topLevelAwait: z.ZodOptional<z.ZodBoolean>;
@@ -3217,11 +3191,7 @@ declare const experiments: z.ZodObject<{
         } | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
-    lazyCompilation?: boolean | {
-        imports?: boolean | undefined;
-        entries?: boolean | undefined;
-        test?: RegExp | undefined;
-    } | undefined;
+    lazyCompilation?: boolean | undefined;
     asyncWebAssembly?: boolean | undefined;
     outputModule?: boolean | undefined;
     topLevelAwait?: boolean | undefined;
@@ -3237,11 +3207,7 @@ declare const experiments: z.ZodObject<{
         } | undefined;
     } | undefined;
 }, {
-    lazyCompilation?: boolean | {
-        imports?: boolean | undefined;
-        entries?: boolean | undefined;
-        test?: RegExp | undefined;
-    } | undefined;
+    lazyCompilation?: boolean | undefined;
     asyncWebAssembly?: boolean | undefined;
     outputModule?: boolean | undefined;
     topLevelAwait?: boolean | undefined;
@@ -3263,19 +3229,19 @@ export type Watch = z.infer<typeof watch>;
 declare const watchOptions: z.ZodObject<{
     aggregateTimeout: z.ZodOptional<z.ZodNumber>;
     followSymlinks: z.ZodOptional<z.ZodBoolean>;
-    ignored: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodString]>>;
+    ignored: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodString]>, z.ZodFunction<z.ZodTuple<[z.ZodString], null>, z.ZodBoolean>]>>;
     poll: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodBoolean]>>;
     stdin: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     aggregateTimeout?: number | undefined;
     followSymlinks?: boolean | undefined;
-    ignored?: string | RegExp | string[] | undefined;
+    ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
     poll?: number | boolean | undefined;
     stdin?: boolean | undefined;
 }, {
     aggregateTimeout?: number | undefined;
     followSymlinks?: boolean | undefined;
-    ignored?: string | RegExp | string[] | undefined;
+    ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
     poll?: number | boolean | undefined;
     stdin?: boolean | undefined;
 }>;
@@ -3723,19 +3689,7 @@ 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.ZodUnion<[z.ZodOptional<z.ZodBoolean>, z.ZodObject<{
-            imports: z.ZodOptional<z.ZodBoolean>;
-            entries: z.ZodOptional<z.ZodBoolean>;
-            test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
-        }, "strip", z.ZodTypeAny, {
-            imports?: boolean | undefined;
-            entries?: boolean | undefined;
-            test?: RegExp | undefined;
-        }, {
-            imports?: boolean | undefined;
-            entries?: boolean | undefined;
-            test?: RegExp | undefined;
-        }>]>;
+        lazyCompilation: z.ZodOptional<z.ZodBoolean>;
         asyncWebAssembly: z.ZodOptional<z.ZodBoolean>;
         outputModule: z.ZodOptional<z.ZodBoolean>;
         topLevelAwait: z.ZodOptional<z.ZodBoolean>;
@@ -3771,11 +3725,7 @@ export declare const rspackOptions: z.ZodObject<{
             } | undefined;
         }>>;
     }, "strict", z.ZodTypeAny, {
-        lazyCompilation?: boolean | {
-            imports?: boolean | undefined;
-            entries?: boolean | undefined;
-            test?: RegExp | undefined;
-        } | undefined;
+        lazyCompilation?: boolean | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -3791,11 +3741,7 @@ export declare const rspackOptions: z.ZodObject<{
             } | undefined;
         } | undefined;
     }, {
-        lazyCompilation?: boolean | {
-            imports?: boolean | undefined;
-            entries?: boolean | undefined;
-            test?: RegExp | undefined;
-        } | undefined;
+        lazyCompilation?: boolean | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -3928,19 +3874,19 @@ export declare const rspackOptions: z.ZodObject<{
     watchOptions: z.ZodOptional<z.ZodObject<{
         aggregateTimeout: z.ZodOptional<z.ZodNumber>;
         followSymlinks: z.ZodOptional<z.ZodBoolean>;
-        ignored: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodString]>>;
+        ignored: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodString]>, z.ZodFunction<z.ZodTuple<[z.ZodString], null>, z.ZodBoolean>]>>;
         poll: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodBoolean]>>;
         stdin: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         aggregateTimeout?: number | undefined;
         followSymlinks?: boolean | undefined;
-        ignored?: string | RegExp | string[] | undefined;
+        ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
         poll?: number | boolean | undefined;
         stdin?: boolean | undefined;
     }, {
         aggregateTimeout?: number | undefined;
         followSymlinks?: boolean | undefined;
-        ignored?: string | RegExp | string[] | undefined;
+        ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
         poll?: number | boolean | undefined;
         stdin?: boolean | undefined;
     }>>;
@@ -4738,14 +4684,10 @@ export declare const rspackOptions: z.ZodObject<{
         devtoolModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
         devtoolFallbackModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
     } | undefined;
-    target?: false | "node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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;
+    target?: false | "node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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?: "production" | "development" | "none" | undefined;
     experiments?: {
-        lazyCompilation?: boolean | {
-            imports?: boolean | undefined;
-            entries?: boolean | undefined;
-            test?: RegExp | undefined;
-        } | undefined;
+        lazyCompilation?: boolean | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -4808,7 +4750,7 @@ export declare const rspackOptions: z.ZodObject<{
     watchOptions?: {
         aggregateTimeout?: number | undefined;
         followSymlinks?: boolean | undefined;
-        ignored?: string | RegExp | string[] | undefined;
+        ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
         poll?: number | boolean | undefined;
         stdin?: boolean | undefined;
     } | undefined;
@@ -5068,14 +5010,10 @@ export declare const rspackOptions: z.ZodObject<{
         devtoolModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
         devtoolFallbackModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
     } | undefined;
-    target?: false | "node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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;
+    target?: false | "node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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?: "production" | "development" | "none" | undefined;
     experiments?: {
-        lazyCompilation?: boolean | {
-            imports?: boolean | undefined;
-            entries?: boolean | undefined;
-            test?: RegExp | undefined;
-        } | undefined;
+        lazyCompilation?: boolean | undefined;
         asyncWebAssembly?: boolean | undefined;
         outputModule?: boolean | undefined;
         topLevelAwait?: boolean | undefined;
@@ -5138,7 +5076,7 @@ export declare const rspackOptions: z.ZodObject<{
     watchOptions?: {
         aggregateTimeout?: number | undefined;
         followSymlinks?: boolean | undefined;
-        ignored?: string | RegExp | string[] | undefined;
+        ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
         poll?: number | boolean | undefined;
         stdin?: boolean | undefined;
     } | undefined;

package/dist/config/zod.js

@@ -690,13 +690,8 @@ 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).optional()
-});
 const experiments = zod_1.z.strictObject({
-    lazyCompilation: zod_1.z.boolean().optional().or(lazyCompilationOptions),
+    lazyCompilation: zod_1.z.boolean().optional(),
     asyncWebAssembly: zod_1.z.boolean().optional(),
     outputModule: zod_1.z.boolean().optional(),
     topLevelAwait: zod_1.z.boolean().optional(),
@@ -727,6 +722,7 @@ const watchOptions = zod_1.z.strictObject({
         .array()
         .or(zod_1.z.instanceof(RegExp))
         .or(zod_1.z.string())
+        .or(zod_1.z.function(zod_1.z.tuple([zod_1.z.string()])).returns(zod_1.z.boolean()))
         .optional(),
     poll: zod_1.z.number().or(zod_1.z.boolean()).optional(),
     stdin: zod_1.z.boolean().optional()

package/dist/exports.d.ts

@@ -128,14 +128,10 @@ export declare const config: {
             devtoolModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
             devtoolFallbackModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
         } | undefined;
-        target?: false | "node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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;
+        target?: false | "node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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?: "production" | "development" | "none" | undefined;
         experiments?: {
-            lazyCompilation?: boolean | {
-                imports?: boolean | undefined;
-                entries?: boolean | undefined;
-                test?: RegExp | undefined;
-            } | undefined;
+            lazyCompilation?: boolean | undefined;
             asyncWebAssembly?: boolean | undefined;
             outputModule?: boolean | undefined;
             topLevelAwait?: boolean | undefined;
@@ -198,7 +194,7 @@ export declare const config: {
         watchOptions?: {
             aggregateTimeout?: number | undefined;
             followSymlinks?: boolean | undefined;
-            ignored?: string | RegExp | string[] | undefined;
+            ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
             poll?: number | boolean | undefined;
             stdin?: boolean | undefined;
         } | undefined;
@@ -460,14 +456,10 @@ export declare const config: {
             devtoolModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
             devtoolFallbackModuleFilenameTemplate?: string | ((args_0: any) => any) | undefined;
         } | undefined;
-        target?: false | "node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "web" | "es5" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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;
+        target?: false | "node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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` | ("node" | "async-node" | "es5" | "web" | "webworker" | "es3" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "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?: "production" | "development" | "none" | undefined;
         experiments?: {
-            lazyCompilation?: boolean | {
-                imports?: boolean | undefined;
-                entries?: boolean | undefined;
-                test?: RegExp | undefined;
-            } | undefined;
+            lazyCompilation?: boolean | undefined;
             asyncWebAssembly?: boolean | undefined;
             outputModule?: boolean | undefined;
             topLevelAwait?: boolean | undefined;
@@ -530,7 +522,7 @@ export declare const config: {
         watchOptions?: {
             aggregateTimeout?: number | undefined;
             followSymlinks?: boolean | undefined;
-            ignored?: string | RegExp | string[] | undefined;
+            ignored?: string | RegExp | string[] | ((args_0: string) => boolean) | undefined;
             poll?: number | boolean | undefined;
             stdin?: boolean | undefined;
         } | undefined;

package/dist/node/NodeWatchFileSystem.d.ts

@@ -7,7 +7,8 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import Watchpack, { WatchOptions } from "watchpack";
+import Watchpack from "watchpack";
+import { WatchOptions } from "../config";
 import { FileSystemInfoEntry, Watcher, WatchFileSystem } from "../util/fs";
 export default class NodeWatchFileSystem implements WatchFileSystem {
     inputFileSystem: any;

package/dist/rspackOptionsApply.js

@@ -170,15 +170,6 @@ 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(lazyOptions.entries || true, lazyOptions.imports || true, lazyOptions.test
-                ? {
-                    source: lazyOptions.test.source,
-                    flags: lazyOptions.test.flags
-                }
-                : undefined).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.5.7-canary-dcd4782-20240312094134",
+  "version": "0.5.7-canary-1f35c13-20240313091234",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "A Fast Rust-based Web Bundler",
@@ -55,9 +55,9 @@
     "styled-components": "^6.0.8",
     "terser": "5.27.2",
     "wast-loader": "^1.11.4",
-    "@rspack/plugin-minify": "^0.5.7-canary-dcd4782-20240312094134",
-    "@rspack/core": "0.5.7-canary-dcd4782-20240312094134",
-    "@rspack/plugin-node-polyfill": "^0.5.7-canary-dcd4782-20240312094134"
+    "@rspack/core": "0.5.7-canary-1f35c13-20240313091234",
+    "@rspack/plugin-minify": "^0.5.7-canary-1f35c13-20240313091234",
+    "@rspack/plugin-node-polyfill": "^0.5.7-canary-1f35c13-20240313091234"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.0.8",
@@ -72,7 +72,7 @@
     "webpack-sources": "3.2.3",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1",
-    "@rspack/binding": "0.5.7-canary-dcd4782-20240312094134"
+    "@rspack/binding": "0.5.7-canary-1f35c13-20240313091234"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"

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

@@ -1,27 +0,0 @@
-/// <reference types="node" />
-import type { Compiler } from "../..";
-/**
- * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
- * @returns {BackendHandler} backend
- */
-declare const getBackend: (options: any) => (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

@@ -1,144 +0,0 @@
-/*
-    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;
-/**
- * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
- * @returns {BackendHandler} backend
- */
-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 => {
-                    console.log("server shutdown");
-                    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

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

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

@@ -1,6 +0,0 @@
-"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.LazyCompilation, (module, dispose, entries, imports, test) => ({ module, dispose, imports, entries, test }), "compilation");

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

@@ -1,10 +0,0 @@
-import type { Compiler } from "../..";
-import { RawRegexMatcher } from "@rspack/binding";
-export default class LazyCompilationPlugin {
-    entries: boolean;
-    imports: boolean;
-    test?: RawRegexMatcher;
-    constructor(entries: boolean, imports: boolean, test?: RawRegexMatcher);
-    apply(compiler: Compiler): void;
-}
-export { LazyCompilationPlugin };

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

@@ -1,57 +0,0 @@
-"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(entries, imports, test) {
-        this.entries = entries;
-        this.imports = imports;
-        this.test = test;
-    }
-    apply(compiler) {
-        const backend = (0, backend_1.default)({
-            client: require.resolve(`../../../hot/lazy-compilation-${compiler.options.externalsPresets.node ? "node" : "web"}.js`)
-        });
-        new lazyCompilation_1.BuiltinLazyCompilationPlugin(backend_1.moduleImpl, backend_1.dispose, 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;