chore: merge

crates/mako/src/build/transform.rs

@@ -3,10 +3,11 @@ use std::sync::Arc;
 use anyhow::Result;
 use swc_core::base::try_with_handler;
 use swc_core::common::errors::HANDLER;
-use swc_core::common::GLOBALS;
+use swc_core::common::{Mark, GLOBALS};
 use swc_core::css::ast::{AtRule, AtRulePrelude, ImportHref, Rule, Str, Stylesheet, UrlValue};
 use swc_core::css::compat::compiler::{self, Compiler};
 use swc_core::css::{compat as swc_css_compat, prefixer, visit as swc_css_visit};
+use swc_core::ecma::ast::Module;
 use swc_core::ecma::preset_env::{self as swc_preset_env};
 use swc_core::ecma::transforms::base::feature::FeatureFlag;
 use swc_core::ecma::transforms::base::fixer::paren_remover;
@@ -16,7 +17,7 @@ use swc_core::ecma::transforms::compat::reserved_words;
 use swc_core::ecma::transforms::optimization::simplifier;
 use swc_core::ecma::transforms::optimization::simplify::{dce, Config as SimplifyConfig};
 use swc_core::ecma::transforms::proposal::decorators;
-use swc_core::ecma::visit::{Fold, VisitMut};
+use swc_core::ecma::visit::{Fold, VisitMut, VisitMutWith};
 
 use crate::ast::css_ast::CssAst;
 use crate::ast::file::File;
@@ -29,6 +30,7 @@ use crate::module::ModuleAst;
 use crate::plugin::PluginTransformJsParam;
 use crate::plugins::context_module::ContextModuleVisitor;
 use crate::visitors::amd_define_overrides::amd_define_overrides;
+use crate::visitors::clean_ctxt::clean_syntax_context;
 use crate::visitors::css_assets::CSSAssets;
 use crate::visitors::css_flexbugs::CSSFlexbugs;
 use crate::visitors::css_px2rem::Px2Rem;
@@ -75,6 +77,22 @@ impl Transform {
                                     || file.extname == "ts"
                                     || file.extname == "tsx";
 
+                                if is_tsx || is_ts {
+                                    if is_tsx {
+                                        strip_unresolved_tsx(
+                                            &mut ast.ast,
+                                            context.clone(),
+                                            cm.clone(),
+                                        )
+                                    }
+                                    // strip should be ts only
+                                    // since when use this in js, it will remove all unused imports
+                                    // which is not expected as what webpack does
+                                    if is_ts {
+                                        strip_unresolved_ts(&mut ast.ast);
+                                    }
+                                }
+
                                 // visitors
                                 let mut visitors: Vec<Box<dyn VisitMut>> = vec![
                                     Box::new(resolver(
@@ -94,21 +112,7 @@ impl Transform {
                                     }),
                                     Box::new(WorkerModule::new(unresolved_mark)),
                                 ];
-                                if is_tsx {
-                                    visitors.push(Box::new(tsx_strip(
-                                        cm.clone(),
-                                        context.clone(),
-                                        top_level_mark,
-                                        unresolved_mark,
-                                    )))
-                                }
-                                // strip should be ts only
-                                // since when use this in js, it will remove all unused imports
-                                // which is not expected as what webpack does
-                                if is_ts {
-                                    visitors
-                                        .push(Box::new(ts_strip(unresolved_mark, top_level_mark)));
-                                }
+
                                 // named default export
                                 if context.args.watch && !file.is_under_node_modules && is_jsx {
                                     visitors.push(Box::new(DefaultExportNamer::new()));
@@ -347,3 +351,27 @@ fn import_url_to_href(ast: &mut Stylesheet) {
         }
     });
 }
+
+fn strip_unresolved_ts(ast: &mut Module) {
+    let unresolved_mark = Mark::new();
+    let top_level_mark = Mark::new();
+
+    ast.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, true));
+    ast.visit_mut_with(&mut ts_strip(unresolved_mark, top_level_mark));
+
+    ast.visit_mut_with(&mut clean_syntax_context());
+}
+
+fn strip_unresolved_tsx(
+    ast: &mut Module,
+    context: Arc<Context>,
+    cm: Arc<swc_core::common::SourceMap>,
+) {
+    let unresolved_mark = Mark::new();
+    let top_level_mark = Mark::new();
+
+    ast.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, true));
+    ast.visit_mut_with(&mut tsx_strip(cm, context, top_level_mark, unresolved_mark));
+
+    ast.visit_mut_with(&mut clean_syntax_context());
+}

crates/mako/src/compiler.rs

@@ -311,6 +311,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/config/experimental.rs

@@ -13,10 +13,13 @@ pub struct RustPlugin {
 pub struct ExperimentalConfig {
     pub webpack_syntax_validate: Vec<String>,
     pub require_context: bool,
+    // this feature is conflicting with require_context
+    pub ignore_non_literal_require: bool,
     pub magic_comment: bool,
     #[serde(deserialize_with = "deserialize_detect_loop")]
     pub detect_circular_dependence: Option<DetectCircularDependence>,
     pub rust_plugins: Vec<RustPlugin>,
+    pub central_ensure: bool,
 }
 
 #[derive(Deserialize, Serialize, Debug)]

crates/mako/src/config/mako.config.default.json

@@ -68,11 +68,13 @@
     "webpackSyntaxValidate": [],
     "rustPlugins": [],
     "requireContext": true,
+    "ignoreNonLiteralRequire": false,
     "magicComment": true,
     "detectCircularDependence": {
       "ignores": ["node_modules"],
       "graphviz": false
-    }
+    },
+    "centralEnsure": true
   },
   "useDefineForClassFields": true,
   "emitDecoratorMetadata": false,

crates/mako/src/dev/update.rs

@@ -7,11 +7,13 @@ use anyhow::{anyhow, Ok, Result};
 use rayon::prelude::*;
 use tracing::debug;
 
+use crate::ast::file::File;
 use crate::build::BuildError;
 use crate::compiler::Compiler;
 use crate::generate::transform::transform_modules;
 use crate::module::{Dependency, Module, ModuleId, ResolveType};
 use crate::module_graph::ModuleGraph;
+use crate::plugin::NextBuildParam;
 use crate::resolve::{self, clear_resolver_cache};
 
 #[derive(Debug, Clone)]
@@ -253,6 +255,9 @@ impl Compiler {
         update_result.added.extend(added_module_ids);
 
         debug!("update_result: {:?}", &update_result);
+
+        self.context.plugin_driver.after_update(self)?;
+
         Result::Ok(update_result)
     }
 
@@ -326,14 +331,20 @@ impl Compiler {
                 resolved_deps.iter().for_each(|dep| {
                     let resolved_path = dep.resolver_resource.get_resolved_path();
                     let is_external = dep.resolver_resource.get_external().is_some();
-                    let module_id = ModuleId::new(resolved_path.clone());
-                    let module = if is_external {
+                    let dep_module_id = ModuleId::new(resolved_path.clone());
+                    let dep_module = if is_external {
                         Self::create_external_module(&dep.resolver_resource, self.context.clone())
                     } else {
-                        Self::create_empty_module(&module_id)
+                        Self::create_empty_module(&dep_module_id)
                     };
-                    target_dependencies.push((module_id.clone(), dep.dependency.clone()));
-                    dependence_modules.insert(module_id, module);
+                    target_dependencies.push((dep_module_id.clone(), dep.dependency.clone()));
+                    dependence_modules.insert(dep_module_id, dep_module);
+
+                    self.context.plugin_driver.next_build(&NextBuildParam {
+                        current_module: &module.id,
+                        next_file: &File::new(resolved_path.clone(), self.context.clone()),
+                        resource: &dep.resolver_resource,
+                    });
                 });
 
                 let modules_diff = diff(&current_dependencies, &target_dependencies);

crates/mako/src/dev/watch.rs

@@ -150,10 +150,11 @@ impl<'a> Watcher<'a> {
     }
 
     fn watch_file_or_dir(&mut self, path: PathBuf, ignore_list: &[PathBuf]) -> anyhow::Result<()> {
-        if Self::should_ignore_watch(&path, ignore_list) {
+        if Self::should_ignore_watch(&path, ignore_list)
+            || path.to_string_lossy().contains("node_modules")
+        {
             return Ok(());
         }
-
         if path.is_file() && !self.watched_files.contains(&path) {
             self.watcher
                 .watch(path.as_path(), notify::RecursiveMode::NonRecursive)?;

crates/mako/src/features/node.rs

@@ -21,7 +21,7 @@ impl Node {
             config.targets = HashMap::from([("node".into(), *target)]);
             // ignore all built-in node modules
             config.ignores.push(format!(
-                "^(node:)?({})(/|$)",
+                "^(node:)?({})(/.+|$)",
                 Self::get_all_node_modules().join("|")
             ));
             // polifyll __dirname & __filename is supported with MockFilenameAndDirname Visitor

crates/mako/src/generate/chunk_graph.rs

@@ -63,6 +63,12 @@ impl ChunkGraph {
         self.graph.node_weights().find(|c| c.has_module(module_id))
     }
 
+    pub fn get_async_chunk_for_module(&self, module_id: &ModuleId) -> Option<&Chunk> {
+        self.graph
+            .node_weights()
+            .find(|c| c.has_module(module_id) && matches!(c.chunk_type, ChunkType::Async))
+    }
+
     // pub fn get_chunk_by_id(&self, id: &String) -> Option<&Chunk> {
     //     self.graph.node_weights().find(|c| c.id.id.eq(id))
     // }

crates/mako/src/generate/hmr.rs

@@ -22,10 +22,18 @@ impl Compiler {
         let module_graph = &self.context.module_graph.read().unwrap();
         let (js_stmts, _) = modules_to_js_stmts(module_ids, module_graph, &self.context).unwrap();
         let content = include_str!("../runtime/runtime_hmr.js").to_string();
-        let content = content.replace("__CHUNK_ID__", &chunk.id.id).replace(
-            "__runtime_code__",
-            &format!("runtime._h='{}';", current_hash),
-        );
+
+        let runtime_code_snippets = [
+            format!("runtime._h='{}';", current_hash),
+            self.context
+                .plugin_driver
+                .hmr_runtime_update_code(&self.context)?,
+        ];
+
+        let content = content
+            .replace("__CHUNK_ID__", &chunk.id.id)
+            .replace("__runtime_code__", &runtime_code_snippets.join("\n"));
+
         let mut js_ast = JsAst::build(filename, content.as_str(), self.context.clone())
             /* safe */
             .unwrap();

crates/mako/src/generate/transform.rs

@@ -27,7 +27,7 @@ use crate::utils::thread_pool;
 use crate::visitors::async_module::{mark_async, AsyncModule};
 use crate::visitors::common_js::common_js;
 use crate::visitors::css_imports::CSSImports;
-use crate::visitors::dep_replacer::{DepReplacer, DependenciesToReplace};
+use crate::visitors::dep_replacer::{DepReplacer, DependenciesToReplace, ResolvedReplaceInfo};
 use crate::visitors::dynamic_import::DynamicImport;
 use crate::visitors::mako_require::MakoRequire;
 use crate::visitors::meta_url_replacer::MetaUrlReplacer;
@@ -84,38 +84,53 @@ pub fn transform_modules_in_thread(
         thread_pool::spawn(move || {
             let module_graph = context.module_graph.read().unwrap();
             let deps = module_graph.get_dependencies(&module_id);
-            let mut resolved_deps: HashMap<String, (String, String)> = deps
-                .into_iter()
-                .map(|(id, dep)| {
-                    (
-                        dep.source.clone(),
-                        (
-                            match &dep.resolve_type {
-                                ResolveType::Worker(import_options) => {
-                                    let chunk_id = match import_options.get_chunk_name() {
-                                        Some(chunk_name) => {
-                                            generate_module_id(chunk_name, &context)
-                                        }
-                                        None => id.generate(&context),
-                                    };
-                                    let chunk_graph = context.chunk_graph.read().unwrap();
-                                    chunk_graph.chunk(&chunk_id.into()).unwrap().filename()
-                                }
-                                ResolveType::DynamicImport(import_options) => {
-                                    match import_options.get_chunk_name() {
-                                        Some(chunk_name) => {
-                                            generate_module_id(chunk_name, &context)
-                                        }
-                                        None => id.generate(&context),
-                                    }
-                                }
-                                _ => id.generate(&context),
-                            },
-                            id.id.clone(),
-                        ),
-                    )
-                })
-                .collect();
+            let mut resolved_deps: HashMap<String, ResolvedReplaceInfo> = Default::default();
+
+            deps.into_iter().for_each(|(id, dep)| {
+                let replace_info = match &dep.resolve_type {
+                    ResolveType::Worker(import_options) => {
+                        let chunk_id = match import_options.get_chunk_name() {
+                            Some(chunk_name) => generate_module_id(chunk_name, &context),
+                            None => id.generate(&context),
+                        };
+                        let chunk_graph = context.chunk_graph.read().unwrap();
+                        let chunk_name = chunk_graph.chunk(&chunk_id.into()).unwrap().filename();
+
+                        ResolvedReplaceInfo {
+                            chunk_id: None,
+                            to_replace_source: chunk_name,
+                            resolved_module_id: id.clone(),
+                        }
+                    }
+                    ResolveType::DynamicImport(import_options) => {
+                        let chunk_id = Some(match import_options.get_chunk_name() {
+                            Some(chunk_name) => generate_module_id(chunk_name, &context),
+                            None => id.generate(&context),
+                        });
+
+                        ResolvedReplaceInfo {
+                            chunk_id,
+                            to_replace_source: id.generate(&context),
+                            resolved_module_id: id.clone(),
+                        }
+                    }
+                    _ => ResolvedReplaceInfo {
+                        chunk_id: None,
+                        to_replace_source: id.generate(&context),
+                        resolved_module_id: id.clone(),
+                    },
+                };
+
+                resolved_deps
+                    .entry(dep.source.clone())
+                    .and_modify(|info: &mut ResolvedReplaceInfo| {
+                        match (&replace_info.chunk_id, &info.chunk_id) {
+                            (None, _) => {}
+                            (Some(id), _) => info.chunk_id = Some(id.clone()),
+                        }
+                    })
+                    .or_insert(replace_info);
+            });
             insert_swc_helper_replace(&mut resolved_deps, &context);
             let module = module_graph.get_module(&module_id).unwrap();
             let info = module.info.as_ref().unwrap();
@@ -162,10 +177,20 @@ pub fn transform_modules_in_thread(
     Ok(())
 }
 
-fn insert_swc_helper_replace(map: &mut HashMap<String, (String, String)>, context: &Arc<Context>) {
+fn insert_swc_helper_replace(
+    map: &mut HashMap<String, ResolvedReplaceInfo>,
+    context: &Arc<Context>,
+) {
     SWC_HELPERS.into_iter().for_each(|h| {
         let m_id: ModuleId = h.to_string().into();
-        map.insert(m_id.id.clone(), (m_id.generate(context), h.to_string()));
+        map.insert(
+            m_id.id.clone(),
+            ResolvedReplaceInfo {
+                chunk_id: None,
+                to_replace_source: m_id.generate(context),
+                resolved_module_id: m_id,
+            },
+        );
     });
 }
 
@@ -247,6 +272,7 @@ pub fn transform_js_generate(transform_js_param: TransformJsParam) -> Result<()>
                         let mut mako_require = MakoRequire {
                             ignores,
                             unresolved_mark,
+                            context: context.clone(),
                         };
                         ast.ast.visit_mut_with(&mut mako_require);