refact: build

biome.json

@@ -12,7 +12,8 @@
       "./crates/mako/test/**/*",
       "./test/**/dist/*",
       "./test/build/tmp/**/*",
-      "./e2e/**/*"
+      "./e2e/**",
+      "./tmp/**"
     ]
   },
   "formatter": {

crates/core/Cargo.toml

@@ -83,7 +83,7 @@ serde_json            = { workspace = true }
 serde_yaml            = "0.9.22"
 svgr-rs               = "0.1.3"
 thiserror             = "1.0.43"
-tokio                 = { version = "1", features = ["full"] }
+tokio                 = { version = "1", features = ["rt", "sync"] }
 tokio-tungstenite     = "0.19.0"
 toml                  = "0.7.6"
 tracing               = "0.1.37"

crates/mako/src/analyze_deps.rs

@@ -1,40 +1,122 @@
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use mako_core::anyhow::{anyhow, Result};
+use mako_core::thiserror::Error;
 
+use crate::ast_2::error;
+use crate::ast_2::file::File;
 use crate::compiler::Context;
 use crate::module::{Dependency, ModuleAst};
-use crate::plugin::PluginDepAnalyzeParam;
-
-pub fn analyze_deps(
-    ast: &ModuleAst,
-    file_path: &String,
-    context: &Arc<Context>,
-) -> Result<Vec<Dependency>> {
-    mako_core::mako_profile_function!();
-
-    let mut analyze_deps_param = PluginDepAnalyzeParam { ast };
-
-    let mut deps = context
-        .plugin_driver
-        .analyze_deps(&mut analyze_deps_param, context)?;
-
-    context.plugin_driver.before_resolve(&mut deps, context)?;
-
-    // check loader syntax
-    // e.g. file-loader!./file.txt
-    // e.g. file-loader?esModule=false!./src-noconflict/theme-kr_theme.js
-    for dep in &deps {
-        if dep.source.contains("-loader!")
-            || (dep.source.contains("-loader?") && dep.source.contains('!'))
-        {
-            return Err(anyhow!(
-                "webpack loader syntax is not supported, since found dep {:?} in {:?}",
-                dep.source,
-                file_path
-            ));
+use crate::resolve::{resolve, ResolverResource};
+
+#[derive(Debug, Error)]
+pub enum AnalyzeDepsError {
+    #[error("{message:}")]
+    ModuleNotFound { message: String },
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct AnalyzeDepsResult {
+    pub resolved_deps: Vec<ResolvedDep>,
+    // why use hash map?
+    // since we need source as key to replace in generate step
+    pub missing_deps: HashMap<String, Dependency>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ResolvedDep {
+    pub resolver_resource: ResolverResource,
+    pub dependency: Dependency,
+}
+
+pub struct AnalyzeDeps {}
+
+impl AnalyzeDeps {
+    pub fn analyze_deps(
+        ast: &ModuleAst,
+        file: &File,
+        context: Arc<Context>,
+    ) -> Result<AnalyzeDepsResult> {
+        mako_core::mako_profile_function!();
+        let mut deps = match ast {
+            ModuleAst::Script(ast) => ast.analyze_deps(context.clone()),
+            ModuleAst::Css(ast) => ast.analyze_deps(),
+            _ => vec![],
+        };
+        context.plugin_driver.before_resolve(&mut deps, &context)?;
+        Self::check_deps(&deps, file)?;
+
+        let mut resolved_deps = vec![];
+        let mut missing_deps = HashMap::new();
+        let path = file.path.to_str().unwrap();
+        for dep in deps {
+            let result = resolve(
+                // .
+                path,
+                &dep,
+                &context.resolvers,
+                &context,
+            );
+            match result {
+                Ok(resolver_resource) => {
+                    resolved_deps.push(ResolvedDep {
+                        resolver_resource,
+                        dependency: dep,
+                    });
+                }
+                Err(_err) => {
+                    missing_deps.insert(dep.source.clone(), dep);
+                }
+            }
         }
+
+        if !missing_deps.is_empty() {
+            let messages = missing_deps
+                .values()
+                .map(|dep| Self::get_resolved_error(dep, context.clone()))
+                .collect::<Vec<String>>()
+                .join("\n");
+            // TODO:
+            // should we just throw an error here and decide whether to print or exit at the upper level?
+            if context.args.watch {
+                eprint!("{}", messages);
+            } else {
+                return Err(anyhow!(AnalyzeDepsError::ModuleNotFound {
+                    message: messages
+                }));
+            }
+        }
+
+        Ok(AnalyzeDepsResult {
+            resolved_deps,
+            missing_deps,
+        })
+    }
+
+    fn check_deps(deps: &Vec<Dependency>, file: &File) -> Result<()> {
+        for dep in deps {
+            // webpack loader syntax is not supported
+            if dep.source.contains("-loader!")
+                || (dep.source.contains("-loader?") && dep.source.contains('!'))
+            {
+                return Err(anyhow!(
+                    "webpack loader syntax is not supported, since found dep {:?} in {:?}",
+                    dep.source,
+                    file.path.to_str().unwrap()
+                ));
+            }
+        }
+        Ok(())
     }
 
-    Ok(deps)
+    pub fn get_resolved_error(dep: &Dependency, context: Arc<Context>) -> String {
+        let message = format!("Module not found: Can't resolve '{}'", dep.source);
+        if dep.span.is_some() {
+            // TODO: support css resolved error
+            error::code_frame(error::ErrorSpan::Js(dep.span.unwrap()), &message, context)
+        } else {
+            message
+        }
+    }
 }

crates/mako/src/ast.rs

@@ -116,6 +116,7 @@ pub fn build_js_ast(path: &str, content: &str, context: &Arc<Context>) -> Result
     })
 }
 
+#[allow(dead_code)]
 pub fn build_css_ast(
     path: &str,
     content: &str,
@@ -310,16 +311,14 @@ mod tests {
     use std::path::PathBuf;
     use std::sync::Arc;
 
-    use mako_core::tokio;
-
     use super::build_js_ast;
     use crate::assert_debug_snapshot;
     use crate::ast::js_ast_to_code;
     use crate::compiler::Context;
     use crate::test_helper::create_mock_module;
 
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_chinese_ascii() {
+    #[test]
+    fn test_chinese_ascii() {
         let module = create_mock_module(
             PathBuf::from("/path/to/test"),
             r#"

crates/mako/src/ast_2/comments.rs

@@ -0,0 +1 @@
+// TODO