feat: lazy compilation

crates/node_binding/binding.d.ts

@@ -174,7 +174,8 @@ export enum BuiltinPluginName {
   SwcJsMinimizerRspackPlugin = 'SwcJsMinimizerRspackPlugin',
   SwcCssMinimizerRspackPlugin = 'SwcCssMinimizerRspackPlugin',
   BundlerInfoRspackPlugin = 'BundlerInfoRspackPlugin',
-  JsLoaderRspackPlugin = 'JsLoaderRspackPlugin'
+  JsLoaderRspackPlugin = 'JsLoaderRspackPlugin',
+  LazyCompilation = 'LazyCompilation'
 }
 
 export function cleanupGlobalTrace(): void
@@ -907,6 +908,14 @@ export interface RawJavascriptParserOptions {
   url: string
 }
 
+export interface RawLazyCompilationOption {
+  module: (err: Error | null, arg: RawModuleArg) => any
+  test?: RawRegexMatcher
+  entries: boolean
+  imports: boolean
+  cacheable: boolean
+}
+
 export interface RawLibraryAuxiliaryComment {
   root?: string
   commonjs?: string
@@ -942,6 +951,11 @@ export interface RawLimitChunkCountPluginOptions {
   maxChunks: number
 }
 
+export interface RawModuleArg {
+  module: string
+  path: string
+}
+
 export interface RawModuleFilenameTemplateFnCtx {
   identifier: string
   shortIdentifier: string
@@ -956,6 +970,12 @@ export interface RawModuleFilenameTemplateFnCtx {
   namespace: string
 }
 
+export interface RawModuleInfo {
+  active: boolean
+  client: string
+  data: string
+}
+
 export interface RawModuleOptions {
   rules: Array<RawModuleRule>
   parser?: Record<string, RawParserOptions>

crates/rspack_binding_options/Cargo.toml

@@ -37,6 +37,7 @@ rspack_plugin_hmr                     = { path = "../rspack_plugin_hmr" }
 rspack_plugin_html                    = { path = "../rspack_plugin_html" }
 rspack_plugin_javascript              = { path = "../rspack_plugin_javascript" }
 rspack_plugin_json                    = { path = "../rspack_plugin_json" }
+rspack_plugin_lazy_compilation        = { path = "../rspack_plugin_lazy_compilation" }
 rspack_plugin_library                 = { path = "../rspack_plugin_library" }
 rspack_plugin_limit_chunk_count       = { path = "../rspack_plugin_limit_chunk_count" }
 rspack_plugin_merge_duplicate_chunks  = { path = "../rspack_plugin_merge_duplicate_chunks" }

crates/rspack_binding_options/src/options/raw_builtins/mod.rs

@@ -2,6 +2,7 @@ mod raw_banner;
 mod raw_bundle_info;
 mod raw_copy;
 mod raw_html;
+mod raw_lazy_compilation;
 mod raw_limit_chunk_count;
 mod raw_mf;
 mod raw_progress;
@@ -10,7 +11,7 @@ mod raw_to_be_deprecated;
 
 use napi::{bindgen_prelude::FromNapiValue, JsUnknown};
 use napi_derive::napi;
-use rspack_core::{BoxPlugin, Define, DefinePlugin, PluginExt, Provide, ProvidePlugin};
+use rspack_core::{BoxPlugin, Define, DefinePlugin, Plugin, PluginExt, Provide, ProvidePlugin};
 use rspack_error::Result;
 use rspack_ids::{
   DeterministicChunkIdsPlugin, DeterministicModuleIdsPlugin, NamedChunkIdsPlugin,
@@ -58,6 +59,7 @@ use rspack_plugin_warn_sensitive_module::WarnCaseSensitiveModulesPlugin;
 use rspack_plugin_wasm::{enable_wasm_loading_plugin, AsyncWasmPlugin};
 use rspack_plugin_web_worker_template::web_worker_template_plugin;
 use rspack_plugin_worker::WorkerPlugin;
+use rspack_regex::RspackRegex;
 
 pub use self::{
   raw_banner::RawBannerPluginOptions, raw_copy::RawCopyRspackPluginOptions,
@@ -67,6 +69,7 @@ pub use self::{
 };
 use self::{
   raw_bundle_info::{RawBundlerInfoModeWrapper, RawBundlerInfoPluginOptions},
+  raw_lazy_compilation::{JsBackend, RawLazyCompilationOption},
   raw_mf::{RawConsumeSharedPluginOptions, RawContainerReferencePluginOptions, RawProvideOptions},
 };
 use crate::{
@@ -142,6 +145,7 @@ pub enum BuiltinPluginName {
   // rspack js adapter plugins
   // naming format follow XxxRspackPlugin
   JsLoaderRspackPlugin,
+  LazyCompilation,
 }
 
 #[napi(object)]
@@ -403,6 +407,24 @@ impl BuiltinPlugin {
           JsLoaderResolverPlugin::new(downcast_into::<JsLoaderRunner>(self.options)?).boxed(),
         );
       }
+      BuiltinPluginName::LazyCompilation => {
+        let options = downcast_into::<RawLazyCompilationOption>(self.options)?;
+        let js_backend = JsBackend::from(&options);
+        plugins.push(Box::new(
+          rspack_plugin_lazy_compilation::plugin::LazyCompilationPlugin::new(
+            options.cacheable,
+            js_backend,
+            options.test.map(|s| {
+              RspackRegex::with_flags(&s.source, &s.flags).unwrap_or_else(|_| {
+                let msg = format!("[lazyCompilation]incorrect regex {:?}", s);
+                panic!("{msg}");
+              })
+            }),
+            options.entries,
+            options.imports,
+          ),
+        ) as Box<dyn Plugin>)
+      }
     }
     Ok(())
   }

crates/rspack_binding_options/src/options/raw_builtins/raw_lazy_compilation.rs

@@ -0,0 +1,70 @@
+use napi_derive::napi;
+use rspack_core::ModuleIdentifier;
+use rspack_napi::threadsafe_function::ThreadsafeFunction;
+use rspack_plugin_lazy_compilation::backend::{Backend, ModuleInfo};
+
+use crate::RawRegexMatcher;
+
+#[napi(object)]
+pub struct RawModuleInfo {
+  pub active: bool,
+  pub client: String,
+  pub data: String,
+}
+
+#[napi(object, object_to_js = false)]
+pub struct RawLazyCompilationOption {
+  pub module: ThreadsafeFunction<RawModuleArg, RawModuleInfo>,
+  pub test: Option<RawRegexMatcher>,
+  pub entries: bool,
+  pub imports: bool,
+  pub cacheable: bool,
+}
+
+#[napi(object)]
+pub struct RawModuleArg {
+  pub module: String,
+  pub path: String,
+}
+
+pub(crate) struct JsBackend {
+  module: ThreadsafeFunction<RawModuleArg, RawModuleInfo>,
+}
+
+impl std::fmt::Debug for JsBackend {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("JsBackend").finish()
+  }
+}
+
+impl From<&RawLazyCompilationOption> for JsBackend {
+  fn from(value: &RawLazyCompilationOption) -> Self {
+    Self {
+      module: value.module.clone(),
+    }
+  }
+}
+
+#[async_trait::async_trait]
+impl Backend for JsBackend {
+  async fn module(
+    &mut self,
+    identifier: ModuleIdentifier,
+    path: String,
+  ) -> rspack_error::Result<ModuleInfo> {
+    let module_info = self
+      .module
+      .call(RawModuleArg {
+        module: identifier.to_string(),
+        path,
+      })
+      .await
+      .expect("channel should have result");
+
+    Ok(ModuleInfo {
+      active: module_info.active,
+      client: module_info.client,
+      data: module_info.data,
+    })
+  }
+}

crates/rspack_core/src/dependency/dependency_type.rs

@@ -93,6 +93,7 @@ pub enum DependencyType {
   /// Webpack is included
   WebpackIsIncluded,
   LoaderImport,
+  LazyImport,
   Custom(Box<str>), // TODO it will increase large layout size
 }
 
@@ -149,6 +150,7 @@ impl DependencyType {
       DependencyType::ProvideModuleForShared => Cow::Borrowed("provide module for shared"),
       DependencyType::ConsumeSharedFallback => Cow::Borrowed("consume shared fallback"),
       DependencyType::WebpackIsIncluded => Cow::Borrowed("__webpack_is_included__"),
+      DependencyType::LazyImport => Cow::Borrowed("lazy import()"),
     }
   }
 }

crates/rspack_core/src/module_factory.rs

@@ -6,7 +6,7 @@ use sugar_path::SugarPathBuf;
 
 use crate::{BoxDependency, BoxModule, Context, FactoryMeta, ModuleIdentifier, Resolve};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ModuleFactoryCreateData {
   pub resolve_options: Option<Box<Resolve>>,
   pub context: Context,

crates/rspack_core/src/normal_module_factory.rs

@@ -6,7 +6,7 @@ use rspack_error::{error, Result};
 use rspack_hook::AsyncSeriesBailHook;
 use rspack_loader_runner::{get_scheme, Loader, Scheme};
 use sugar_path::{AsPath, SugarPath};
-use swc_core::common::Span;
+use swc_core::common::{util::take::Take, Span};
 
 use crate::{
   cache::Cache,
@@ -580,13 +580,16 @@ impl NormalModuleFactory {
         .unwrap_or_else(|| unreachable!())
     };
 
+    let mut diagnostics = data.diagnostics.take();
     let mut create_data = NormalModuleCreateData {
       dependency_type: data.dependency.dependency_type().clone(),
       resolve_data_request: dependency.request(),
       resource_resolve_data: after_resolve_create_data.resource.clone(),
       context: data.context.clone(),
-      diagnostics: &mut data.diagnostics,
+      diagnostics: &mut diagnostics,
+      create_data: data,
     };
+
     let module = if let Some(module) = self
       .plugin_driver
       .normal_module_factory_create_module(&mut create_data)
@@ -615,6 +618,7 @@ impl NormalModuleFactory {
       .plugin_driver
       .normal_module_factory_module(module, &mut create_data)
       .await?;
+    data.diagnostics = diagnostics;
 
     data.add_file_dependencies(file_dependencies);
     data.add_file_dependency(file_dependency);

crates/rspack_core/src/plugin/args.rs

@@ -10,8 +10,9 @@ use rustc_hash::FxHashSet as HashSet;
 
 use crate::{
   BoxModule, Chunk, ChunkInitFragments, ChunkUkey, Compilation, Context, ContextModuleFactory,
-  DependencyCategory, DependencyType, ErrorSpan, FactoryMeta, ModuleDependency, ModuleIdentifier,
-  NormalModuleFactory, Resolve, RuntimeGlobals, SharedPluginDriver, Stats,
+  DependencyCategory, DependencyType, ErrorSpan, FactoryMeta, ModuleDependency,
+  ModuleFactoryCreateData, ModuleIdentifier, NormalModuleFactory, Resolve, RuntimeGlobals,
+  SharedPluginDriver, Stats,
 };
 
 #[derive(Debug)]
@@ -80,6 +81,7 @@ pub struct NormalModuleCreateData<'a> {
   pub resource_resolve_data: ResourceData,
   pub context: Context,
   pub diagnostics: &'a mut Vec<Diagnostic>,
+  pub create_data: &'a ModuleFactoryCreateData,
 }
 
 #[derive(Debug)]

crates/rspack_core/src/utils/queue.rs

@@ -32,6 +32,14 @@ impl<T, K: Eq + PartialEq + std::hash::Hash> WorkerQueue<T, K> {
     }
   }
 
+  pub fn len(&self) -> usize {
+    self.inner.len()
+  }
+
+  pub fn is_empty(&self) -> bool {
+    self.inner.is_empty()
+  }
+
   pub fn add_task(&mut self, task: T) -> usize {
     self.inner.push_back(task);
     self.inner.len()

crates/rspack_database/src/database.rs

@@ -31,6 +31,14 @@ impl<Item: Any> Database<Item> {
     }
   }
 
+  pub fn len(&self) -> usize {
+    self.inner.len()
+  }
+
+  pub fn is_empty(&self) -> bool {
+    self.inner.is_empty()
+  }
+
   pub fn contains(&self, id: &Ukey<Item>) -> bool {
     self.inner.contains_key(id)
   }