feat: ✨ add central ensure plugin

crates/mako/src/compiler.rs

@@ -248,7 +248,6 @@ impl Compiler {
             Arc::new(plugins::runtime::MakoRuntime {}),
             Arc::new(plugins::invalid_webpack_syntax::InvalidWebpackSyntaxPlugin {}),
             Arc::new(plugins::hmr_runtime::HMRRuntimePlugin {}),
-            Arc::new(plugins::ensure_2::Ensure2 {}),
             Arc::new(plugins::wasm_runtime::WasmRuntimePlugin {}),
             Arc::new(plugins::async_runtime::AsyncRuntimePlugin {}),
             Arc::new(plugins::emotion::EmotionPlugin {}),
@@ -299,6 +298,10 @@ impl Compiler {
             plugins.push(Arc::new(plugins::ssu::SUPlus::new()));
         }
 
+        if args.watch && config.experimental.central_ensure {
+            plugins.push(Arc::new(plugins::central_ensure::CentralChunkEnsure {}));
+        }
+
         if let Some(minifish_config) = &config._minifish {
             let inject = if let Some(inject) = &minifish_config.inject {
                 let mut map = HashMap::new();

crates/mako/src/plugins.rs

@@ -1,11 +1,11 @@
 pub mod async_runtime;
 pub mod bundless_compiler;
+pub mod central_ensure;
 pub mod context_module;
 pub mod copy;
 pub mod detect_circular_dependence;
 pub mod duplicate_package_checker;
 pub mod emotion;
-pub mod ensure_2;
 pub mod graphviz;
 pub mod hmr_runtime;
 pub mod ignore;

crates/mako/src/plugins/central_ensure.rs

@@ -0,0 +1,76 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use anyhow::anyhow;
+
+use crate::compiler::Context;
+use crate::module::generate_module_id;
+use crate::plugin::Plugin;
+
+pub struct CentralChunkEnsure {}
+
+impl Plugin for CentralChunkEnsure {
+    fn name(&self) -> &str {
+        "dev_ensure2"
+    }
+    fn runtime_plugins(&self, context: &Arc<Context>) -> anyhow::Result<Vec<String>> {
+        let mg = context
+            .module_graph
+            .read()
+            .map_err(|e| anyhow!("Read_Module_Graph_error:\n{:?}", e))?;
+        let cg = context
+            .chunk_graph
+            .read()
+            .map_err(|e| anyhow!("Read_Chunk_Graph_error:\n{:?}", e))?;
+
+        let mut chunk_async_map: BTreeMap<String, Vec<String>> = Default::default();
+
+        mg.modules().iter().for_each(|module| {
+            let be_dynamic_imported = mg
+                .get_dependents(&module.id)
+                .iter()
+                .any(|(_, dep)| dep.resolve_type.is_dynamic_esm());
+
+            if be_dynamic_imported {
+                cg.get_chunk_for_module(&module.id)
+                    .iter()
+                    .for_each(|chunk| {
+                        let deps_chunks = cg
+                            .installable_descendants_chunk(&chunk.id)
+                            .iter()
+                            .map(|chunk_id| chunk_id.generate(context))
+                            .collect::<Vec<_>>();
+
+                        dbg!(&deps_chunks);
+
+                        chunk_async_map
+                            .insert(generate_module_id(&module.id.id, context), deps_chunks);
+                    });
+            }
+        });
+
+        // TODO: compress the map to reduce duplicated chunk ids
+        let ensure_map = serde_json::to_string(&chunk_async_map)?;
+
+        let runtime = format!(
+            r#"
+(function(){{
+  let map = {ensure_map};
+  requireModule.updateEnsuire2Map = function(newMaping) {{
+    map = newMaping;
+  }}
+  requireModule.ensure2 = function(chunkId){{
+    let toEnsure = map[chunkId];
+    if (toEnsure) {{
+      return Promise.all(toEnsure.map(function(c){{ return requireModule.ensure(c); }}))
+    }}else{{
+      return Promise.resolve();
+    }}
+  }};
+}})();
+"#
+        );
+
+        Ok(vec![runtime])
+    }
+}