前端打包工具Mako架构解析｜得物技术

• 生产级

• 快如闪电

• 热模块替换

• 代码拆分

• Module Concatenation

• Rust实现Mako编译的核心逻辑并进行导出。
  

使用napi进行编译的胶水层代码

pub trait Plugin: Any + Send + Sync {    fn name(&self) -> &str;
    fn modify_config(&self, _config: &mut Config, _root: &Path, _args: &Args) -> Result<()> {        Ok(())    }
    fn load(&self, _param: &PluginLoadParam, _context: &Arc<Context>) -> Result<Option<Content>> {        Ok(None)    }
    fn next_build(&self, _next_build_param: &NextBuildParam) -> bool {        true    }
    fn parse(        &self,        _param: &PluginParseParam,        _context: &Arc<Context>,    ) -> Result<Option<ModuleAst>> {        Ok(None)    }
    fn transform_js(        &self,        _param: &PluginTransformJsParam,        _ast: &mut Module,        _context: &Arc<Context>,    ) -> Result<()> {        Ok(())    }
    fn after_generate_transform_js(        &self,        _param: &PluginTransformJsParam,        _ast: &mut Module,        _context: &Arc<Context>,    ) -> Result<()> {        Ok(())    }
    fn before_resolve(&self, _deps: &mut Vec<Dependency>, _context: &Arc<Context>) -> Result<()> {        Ok(())    }
    fn after_build(&self, _context: &Arc<Context>, _compiler: &Compiler) -> Result<()> {        Ok(())    }
    fn generate(&self, _context: &Arc<Context>) -> Result<Option<()>> {        Ok(None)    }
    fn after_generate_chunk_files(        &self,        _chunk_files: &[ChunkFile],        _context: &Arc<Context>,    ) -> Result<()> {        Ok(())    }
    fn build_success(&self, _stats: &StatsJsonMap, _context: &Arc<Context>) -> Result<Option<()>> {        Ok(None)    }
    fn build_start(&self, _context: &Arc<Context>) -> Result<Option<()>> {        Ok(None)    }
    fn generate_beg(&self, _context: &Arc<Context>) -> Result<()> {        Ok(())    }
    fn generate_end(        &self,        _params: &PluginGenerateEndParams,        _context: &Arc<Context>,    ) -> Result<Option<()>> {        Ok(None)    }
    fn runtime_plugins(&self, _context: &Arc<Context>) -> Result<Vec<String>> {        Ok(Vec::new())    }
    fn optimize_module_graph(        &self,        _module_graph: &mut ModuleGraph,        _context: &Arc<Context>,    ) -> Result<()> {        Ok(())    }
    fn before_optimize_chunk(&self, _context: &Arc<Context>) -> Result<()> {        Ok(())    }
    fn optimize_chunk(        &self,        _chunk_graph: &mut ChunkGraph,        _module_graph: &mut ModuleGraph,        _context: &Arc<Context>,    ) -> Result<()> {        Ok(())    }
    fn before_write_fs(&self, _path: &Path, _content: &[u8]) -> Result<()> {        Ok(())    }}

• 内置的分为两类的插件11种；
• 外部js编写的插件（Less的编译就是使用这种）；
• 其他条件型插件。

使用各种插件

impl Load {    pub fn load(file: &File, context: Arc<Context>) -> Result<Content> {        crate::mako_profile_function!(file.path.to_string_lossy());        debug!("load: {:?}", file);
        // plugin first        let content: Option<Content> = context            .plugin_driver            .load(&PluginLoadParam { file }, &context)?;
        if let Some(content) = content {            return Ok(content);        }
        // virtual:inline_css:runtime        if file.path.to_str().unwrap() == "virtual:inline_css:runtime" {            return Ok(Content::Js(JsContent {                content: r#"export function moduleToDom(css) {    var styleElement = document.createElement("style");    styleElement.type = "text/css";    styleElement.appendChild(document.createTextNode(css))    document.head.appendChild(styleElement);}                                "#                .to_string(),                ..Default::default()            }));        }
        // file exists check must after virtual modules handling        if !file.pathname.exists() || !file.pathname.is_file() {            return Err(anyhow!(LoadError::FileNotFound {                path: file.path.to_string_lossy().to_string(),            }));        }
        // unsupported        if UNSUPPORTED_EXTENSIONS.contains(&file.extname.as_str()) {            return Err(anyhow!(LoadError::UnsupportedExtName {                ext_name: file.extname.clone(),                path: file.path.to_string_lossy().to_string(),            }));        }
        // ?raw        if file.has_param("raw") {            let content = FileSystem::read_file(&file.pathname)?;            let content = serde_json::to_string(&content)?;            return Ok(Content::Js(JsContent {                content: format!("module.exports = {}", content),                ..Default::default()            }));        }
        // js        if JS_EXTENSIONS.contains(&file.extname.as_str()) {            // entry with ?hmr            let is_jsx = file.extname.as_str() == "jsx" || file.extname.as_str() == "tsx";            if file.is_entry && file.has_param("hmr") {                let content = format!(                    "{}\nmodule.exports = require(\"{}\");\n",                    include_str!("../runtime/runtime_hmr_entry.js"),                    file.pathname.to_string_lossy(),                );                return Ok(Content::Js(JsContent { content, is_jsx }));            }            let content = FileSystem::read_file(&file.pathname)?;            return Ok(Content::Js(JsContent { content, is_jsx }));        }
        // css        if CSS_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            return Ok(Content::Css(content));        }
        // md & mdx        if MD_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            let options = MdxOptions {                development: matches!(context.config.mode, Mode::Development),                ..Default::default()            };            let content = match compile(&content, &options) {                Ok(js_string) => js_string,                Err(reason) => {                    return Err(anyhow!(LoadError::CompileMdError {                        path: file.path.to_string_lossy().to_string(),                        reason,                    }));                }            };            let is_jsx = file.extname.as_str() == "mdx";            return Ok(Content::Js(JsContent { content, is_jsx }));        }
        // svg        // TODO: Not all svg files need to be converted to React Component, unnecessary performance consumption here        if SVG_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            let svgr_transformed = svgr_rs::transform(                content,                svgr_rs::Config {                    named_export: SVGR_NAMED_EXPORT.to_string(),                    export_type: Some(svgr_rs::ExportType::Named),                    ..Default::default()                },                svgr_rs::State {                    ..Default::default()                },            )            .map_err(|err| LoadError::ToSvgrError {                path: file.path.to_string_lossy().to_string(),                reason: err.to_string(),            })?;            let asset_path = Self::handle_asset(file, true, true, context.clone())?;            return Ok(Content::Js(JsContent {                content: format!("{}\nexport default {};", svgr_transformed, asset_path),                is_jsx: true,            }));        }
        // toml        if TOML_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            let content = from_toml_str::<TomlValue>(&content)?;            let content = serde_json::to_string(&content)?;            return Ok(Content::Js(JsContent {                content: format!("module.exports = {}", content),                ..Default::default()            }));        }
        // wasm        if WASM_EXTENSIONS.contains(&file.extname.as_str()) {            let final_file_name = format!(                "{}.{}.{}",                file.get_file_stem(),                file.get_content_hash()?,                file.extname            );            context.emit_assets(                file.pathname.to_string_lossy().to_string(),                final_file_name.clone(),            );            return Ok(Content::Js(JsContent {                content: format!(                    "module.exports = require._interopreRequireWasm(exports, \"{}\")",                    final_file_name                ),                ..Default::default()            }));        }
        // xml        if XML_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            let content = from_xml_str::<serde_json::Value>(&content)?;            let content = serde_json::to_string(&content)?;            return Ok(Content::Js(JsContent {                content: format!("module.exports = {}", content),                ..Default::default()            }));        }
        // yaml        if YAML_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            let content = from_yaml_str::<YamlValue>(&content)?;            let content = serde_json::to_string(&content)?;            return Ok(Content::Js(JsContent {                content: format!("module.exports = {}", content),                ..Default::default()            }));        }
        // json        if JSON_EXTENSIONS.contains(&file.extname.as_str()) {            let content = FileSystem::read_file(&file.pathname)?;            return Ok(Content::Js(JsContent {                content: format!("module.exports = {}", content),                ..Default::default()            }));        }
        // assets        let asset_path = Self::handle_asset(file, true, true, context.clone())?;        Ok(Content::Js(JsContent {            content: format!("module.exports = {};", asset_path),            ..Default::default()        }))    }}

比如想支持鸿蒙的ets，编写插件的话就需要在这个阶段进行ast解析

impl Parse {    pub fn parse(file: &File, context: Arc<Context>) -> Result<ModuleAst> {        // plugin first        let ast = context            .plugin_driver            .parse(&PluginParseParam { file }, &context)?;        if let Some(ast) = ast {            return Ok(ast);        }
        // js        if let Some(Content::Js(_)) = &file.content {            debug!("parse js: {:?}", file.path);            let ast = JsAst::new(file, context.clone())?;            if let Some(ast) = Rsc::parse_js(file, &ast, context.clone())? {                return Ok(ast);            }            return Ok(ModuleAst::Script(ast));        }
        // css        if let Some(Content::Css(_)) = &file.content {            // xxx        }
    }}

impl Transform {    pub fn transform(ast: &mut ModuleAst, file: &File, context: Arc<Context>) -> Result<()> {        crate::mako_profile_function!();        match ast {            ModuleAst::Script(ast) => {                GLOBALS.set(&context.meta.script.globals, || {                    let unresolved_mark = ast.unresolved_mark;                    let top_level_mark = ast.top_level_mark;                    let cm: Arc<swc_core::common::SourceMap> = context.meta.script.cm.clone();                    let origin_comments = context.meta.script.origin_comments.read().unwrap();                    let is_ts = file.extname == "ts";                    let is_tsx = file.extname == "tsx";                    let is_jsx = file.is_content_jsx()                        || file.extname == "jsx"                        || file.extname == "js"                        || file.extname == "ts"                        || file.extname == "tsx";
                    // visitors                    let mut visitors: Vec<Box<dyn VisitMut>> = vec![                        Box::new(resolver(unresolved_mark, top_level_mark, is_ts || is_tsx)),                        Box::new(FixHelperInjectPosition::new()),                        Box::new(FixSymbolConflict::new(top_level_mark)),                        Box::new(NewUrlAssets {                            context: context.clone(),                            path: file.path.clone(),                            unresolved_mark,                        }),                        Box::new(WorkerModule::new(unresolved_mark)),                    ];                    if is_tsx {                        visitors.push(Box::new(tsx_strip(                            cm.clone(),                            context.clone(),                            top_level_mark,                        )))                    }                    if is_ts {                        visitors.push(Box::new(ts_strip(top_level_mark)))                    }                    // named default export                    if context.args.watch && !file.is_under_node_modules && is_jsx {                        visitors.push(Box::new(DefaultExportNamer::new()));                    }                    // react & react-refresh                    let is_dev = matches!(context.config.mode, Mode::Development);                    let is_browser =                        matches!(context.config.platform, crate::config::Platform::Browser);                    let use_refresh = is_dev                        && context.args.watch                        && context.config.hmr.is_some()                        && !file.is_under_node_modules                        && is_browser;                    if is_jsx {                        visitors.push(react(                            cm,                            context.clone(),                            use_refresh,                            &top_level_mark,                            &unresolved_mark,                        ));                    }
                    {                        let mut define = context.config.define.clone();                        let mode = context.config.mode.to_string();                        define                            .entry("NODE_ENV".to_string())                            .or_insert_with(|| format!("\"{}\"", mode).into());                        let env_map = build_env_map(define, &context)?;                        visitors.push(Box::new(EnvReplacer::new(                            Lrc::new(env_map),                            unresolved_mark,                        )));                    }                    visitors.push(Box::new(TryResolve {                        path: file.path.to_string_lossy().to_string(),                        context: context.clone(),                        unresolved_mark,                    }));                    visitors.push(Box::new(Provide::new(                        context.config.providers.clone(),                        unresolved_mark,                        top_level_mark,                    )));                    visitors.push(Box::new(VirtualCSSModules {                        auto_css_modules: context.config.auto_css_modules,                    }));                    visitors.push(Box::new(ContextModuleVisitor { unresolved_mark }));                    if context.config.dynamic_import_to_require {                        visitors.push(Box::new(DynamicImportToRequire { unresolved_mark }));                    }                    if matches!(context.config.platform, crate::config::Platform::Node) {                        visitors.push(Box::new(features::node::MockFilenameAndDirname {                            unresolved_mark,                            current_path: file.path.clone(),                            context: context.clone(),                        }));                    }
                    // folders                    let mut folders: Vec<Box<dyn Fold>> = vec![];                    folders.push(Box::new(decorators(decorators::Config {                        legacy: true,                        emit_metadata: false,                        ..Default::default()                    })));                    let comments = origin_comments.get_swc_comments().clone();                    let assumptions = context.assumptions_for(file);
                    folders.push(Box::new(swc_preset_env::preset_env(                        unresolved_mark,                        Some(comments),                        swc_preset_env::Config {                            mode: Some(swc_preset_env::Mode::Entry),                            targets: Some(swc_preset_env_targets_from_map(                                context.config.targets.clone(),                            )),                            ..Default::default()                        },                        assumptions,                        &mut FeatureFlag::default(),                    )));                    folders.push(Box::new(reserved_words::reserved_words()));                    folders.push(Box::new(paren_remover(Default::default())));                    folders.push(Box::new(simplifier(                        unresolved_mark,                        SimpilifyConfig {                            dce: dce::Config {                                top_level: false,                                ..Default::default()                            },                            ..Default::default()                        },                    )));
                    ast.transform(&mut visitors, &mut folders, file, true, context.clone())?;
                    Ok(())                })            }            ModuleAst::Css(ast) => {                // replace @import url() to @import before CSSUrlReplacer                import_url_to_href(&mut ast.ast);                let mut visitors: Vec<Box<dyn swc_css_visit::VisitMut>> = vec![];                visitors.push(Box::new(Compiler::new(compiler::Config {                    process: swc_css_compat::feature::Features::NESTING,                })));                let path = file.path.to_string_lossy().to_string();                visitors.push(Box::new(CSSAssets {                    path,                    context: context.clone(),                }));                // same ability as postcss-flexbugs-fixes                if context.config.flex_bugs {                    visitors.push(Box::new(CSSFlexbugs {}));                }                if context.config.px2rem.is_some() {                    let context = context.clone();                    visitors.push(Box::new(Px2Rem::new(                        context.config.px2rem.as_ref().unwrap().clone(),                    )));                }                // prefixer                visitors.push(Box::new(prefixer::prefixer(prefixer::options::Options {                    env: Some(targets::swc_preset_env_targets_from_map(                        context.config.targets.clone(),                    )),                })));                ast.transform(&mut visitors)?;
                // css modules                let is_modules = file.has_param("modules");                if is_modules {                    CssAst::compile_css_modules(file.pathname.to_str().unwrap(), &mut ast.ast);                }
                Ok(())            }            ModuleAst::None => Ok(()),        }    }}

依赖分析阶段

create Module阶段

🎉 至此，核心编译流程已经完成。

生成阶段

Mako 不是为了与 Webpack 的社区加载器和插件兼容而设计的。如果你的项目严重依赖于 Webpack 的社区加载器和插件，你不应该使用 Mako，Rspack 是更好的选择。

往期回顾

1. 基于Rspack实现大仓应用构建提效实践｜得物技术
2. 星愿森林的互动玩法揭秘｜得物技术
3. StarRocks跨集群迁移最佳实践｜得物技术
4. Apache Flink类型及序列化研读&生产应用｜得物技术
5. 可视化流量录制规则探索和实践｜得物技术

文 / asarua

关注得物技术，每周一、三、五更新技术干货

要是觉得文章对你有帮助的话，欢迎评论转发点赞～

未经得物技术许可严禁转载，否则依法追究法律责任。

线下活动推荐

快快点击下方图片报名吧！