feat: add resolve_id plugin hook

crates/binding/src/js_hook.rs

@@ -58,12 +58,15 @@ pub struct JsHooks {
     pub _on_generate_file: Option<JsFunction>,
     #[napi(ts_type = "() => Promise<void>;")]
     pub build_start: Option<JsFunction>,
+    #[napi(ts_type = "(source: string, importer: string) => Promise<{ id: string }>;")]
+    pub resolve_id: Option<JsFunction>,
 }
 
 pub struct TsFnHooks {
     pub build_start: Option<ThreadsafeFunction<(), ()>>,
     pub generate_end: Option<ThreadsafeFunction<Value, ()>>,
     pub load: Option<ThreadsafeFunction<String, Option<LoadResult>>>,
+    pub resolve_id: Option<ThreadsafeFunction<(String, String), Option<ResolveIdResult>>>,
     pub _on_generate_file: Option<ThreadsafeFunction<WriteFile, ()>>,
 }
 
@@ -79,6 +82,9 @@ impl TsFnHooks {
             load: hooks.load.as_ref().map(|hook| unsafe {
                 ThreadsafeFunction::from_napi_value(env.raw(), hook.raw()).unwrap()
             }),
+            resolve_id: hooks.resolve_id.as_ref().map(|hook| unsafe {
+                ThreadsafeFunction::from_napi_value(env.raw(), hook.raw()).unwrap()
+            }),
             _on_generate_file: hooks._on_generate_file.as_ref().map(|hook| unsafe {
                 ThreadsafeFunction::from_napi_value(env.raw(), hook.raw()).unwrap()
             }),
@@ -99,3 +105,8 @@ pub struct LoadResult {
     #[napi(js_name = "type")]
     pub content_type: String,
 }
+
+#[napi(object, use_nullable = true)]
+pub struct ResolveIdResult {
+    pub id: String,
+}

crates/binding/src/js_plugin.rs

@@ -1,6 +1,7 @@
+use std::path::PathBuf;
 use std::sync::Arc;
 
-use crate::js_hook::{LoadResult, TsFnHooks, WriteFile};
+use crate::js_hook::{LoadResult, ResolveIdResult, TsFnHooks, WriteFile};
 
 pub struct JsPlugin {
     pub hooks: TsFnHooks,
@@ -9,6 +10,7 @@ use anyhow::{anyhow, Result};
 use mako::ast::file::{Content, JsContent};
 use mako::compiler::Context;
 use mako::plugin::{Plugin, PluginGenerateEndParams, PluginLoadParam};
+use mako::resolve::{Resolution, ResolvedResource, ResolverResource};
 
 impl Plugin for JsPlugin {
     fn name(&self) -> &str {
@@ -47,6 +49,29 @@ impl Plugin for JsPlugin {
         Ok(None)
     }
 
+    fn resolve_id(
+        &self,
+        source: &str,
+        importer: &str,
+        _context: &Arc<Context>,
+    ) -> Result<Option<ResolverResource>> {
+        if let Some(hook) = &self.hooks.resolve_id {
+            let x: Option<ResolveIdResult> =
+                hook.call((source.to_string(), importer.to_string()))?;
+            if let Some(x) = x {
+                return Ok(Some(ResolverResource::Resolved(ResolvedResource(
+                    Resolution {
+                        path: PathBuf::from(x.id),
+                        query: None,
+                        fragment: None,
+                        package_json: None,
+                    },
+                ))));
+            }
+        }
+        Ok(None)
+    }
+
     fn generate_end(&self, param: &PluginGenerateEndParams, _context: &Arc<Context>) -> Result<()> {
         if let Some(hook) = &self.hooks.generate_end {
             hook.call(serde_json::to_value(param)?)?

crates/mako/src/lib.rs

@@ -15,7 +15,7 @@ mod module;
 mod module_graph;
 pub mod plugin;
 mod plugins;
-mod resolve;
+pub mod resolve;
 pub mod share;
 pub mod stats;
 pub mod utils;

crates/mako/src/plugin.rs

@@ -53,6 +53,15 @@
         Ok(None)
     }
 
+    fn resolve_id(
+        &self,
+        _source: &str,
+        _importer: &str,
+        _context: &Arc<Context>,
+    ) -> Result<Option<ResolverResource>> {
+        Ok(None)
+    }
+
     fn next_build(&self, _next_build_param: &NextBuildParam) -> bool {
         true
     }
@@ -208,7 +217,6 @@
         Ok(None)
     }
 
-    #[allow(dead_code)]
     pub fn transform_js(
         &self,
         param: &PluginTransformJsParam,
@@ -233,7 +241,6 @@
         Ok(())
     }
 
-    #[allow(dead_code)]
     pub fn before_resolve(
         &self,
         param: &mut Vec<Dependency>,
@@ -245,6 +252,21 @@
         Ok(())
     }
 
+    pub fn resolve_id(
+        &self,
+        source: &str,
+        importer: &str,
+        context: &Arc<Context>,
+    ) -> Result<Option<ResolverResource>> {
+        for plugin in &self.plugins {
+            let ret = plugin.resolve_id(source, importer, context)?;
+            if ret.is_some() {
+                return Ok(ret);
+            }
+        }
+        Ok(None)
+    }
+
     pub fn before_generate(&self, context: &Arc<Context>) -> Result<()> {
         for plugin in &self.plugins {
             plugin.generate_begin(context)?;

crates/mako/src/resolve.rs

@@ -10,8 +10,10 @@
 use thiserror::Error;
 use tracing::debug;
 
+mod resolution;
 mod resource;
-pub(crate) use resource::{ExternalResource, ResolvedResource, ResolverResource};
+pub use resolution::Resolution;
+pub use resource::{ExternalResource, ResolvedResource, ResolverResource};
 
 use crate::ast::file::parse_path;
 use crate::compiler::Context;
@@ -49,6 +51,14 @@
     crate::mako_profile_function!();
     crate::mako_profile_scope!("resolve", &dep.source);
 
+    // plugin first
+    if let Some(resolved) = context
+        .plugin_driver
+        .resolve_id(&dep.source, path, context)?
+    {
+        return Ok(resolved);
+    }
+
     if dep.source.starts_with("virtual:") {
         return Ok(ResolverResource::Virtual(PathBuf::from(&dep.source)));
     }
@@ -244,7 +254,12 @@
                 // TODO: 临时方案，需要改成删除文件时删 resolve cache 里的内容
                 // 比如把 util.ts 改名为 util.tsx，目前应该是还有问题的
                 if resolution.path().exists() {
-                    Ok(ResolverResource::Resolved(ResolvedResource(resolution)))
+                    Ok(ResolverResource::Resolved(ResolvedResource(Resolution {
+                        package_json: resolution.package_json().cloned(),
+                        path: resolution.clone().into_path_buf(),
+                        query: resolution.query().map(|q| q.to_string()),
+                        fragment: resolution.fragment().map(|f| f.to_string()),
+                    })))
                 } else {
                     Err(anyhow!(ResolveError {
                         path: source.to_string(),

crates/mako/src/resolve/resolution.rs

@@ -0,0 +1,63 @@
+use std::fmt;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use oxc_resolver::PackageJson;
+
+#[derive(Clone)]
+pub struct Resolution {
+    pub path: PathBuf,
+    pub query: Option<String>,
+    pub fragment: Option<String>,
+    pub package_json: Option<Arc<PackageJson>>,
+}
+
+impl Resolution {
+    /// Returns the path without query and fragment
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+
+    /// Returns the path without query and fragment
+    pub fn into_path_buf(self) -> PathBuf {
+        self.path
+    }
+
+    /// Returns the path query `?query`, contains the leading `?`
+    pub fn query(&self) -> Option<&str> {
+        self.query.as_deref()
+    }
+
+    /// Returns the path fragment `#fragment`, contains the leading `#`
+    pub fn fragment(&self) -> Option<&str> {
+        self.fragment.as_deref()
+    }
+
+    /// Returns serialized package_json
+    pub fn package_json(&self) -> Option<&Arc<PackageJson>> {
+        self.package_json.as_ref()
+    }
+
+    /// Returns the full path with query and fragment
+    pub fn full_path(&self) -> PathBuf {
+        let mut path = self.path.clone().into_os_string();
+        if let Some(query) = &self.query {
+            path.push(query);
+        }
+        if let Some(fragment) = &self.fragment {
+            path.push(fragment);
+        }
+        PathBuf::from(path)
+    }
+}
+
+impl fmt::Debug for Resolution {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Resolution")
+            .field("path", &self.path)
+            .field("query", &self.query)
+            .field("fragment", &self.fragment)
+            .field("package_json", &self.package_json.as_ref().map(|p| &p.path))
+            .finish()
+    }
+}

crates/mako/src/resolve/resource.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use oxc_resolver::Resolution;
+use crate::resolve::Resolution;
 
 #[derive(Debug, Clone)]
 pub struct ExternalResource {

e2e/fixtures/plugins/expect.js

@@ -8,3 +8,6 @@ assert(content.includes(`children: "foo.bar"`), `jsx in foo.bar works`);
 assert(content.includes(`children: ".bar"`), `jsx in hoo.bar works`);
 assert(content.includes(`children: ".haha"`), `plugin in node_modules works`);
 assert(content.includes(`children: ".hoo"`), `relative plugin works`);
+
+// resolve_id hook
+assert(content.includes(`resolve_id mocked`), `resolve_id hook works`);

e2e/fixtures/plugins/plugins.config.js

@@ -19,5 +19,14 @@ module.exports = [
         };
       }
     }
-  }
+  },
+  {
+    async resolveId(source, importer) {
+      if (source === 'resolve_id') {
+        console.log('resolveId', source, importer);
+        return { id: require('path').join(__dirname, 'resolve_id_mock.js') };
+      }
+      return null;
+    }
+  },
 ];

e2e/fixtures/plugins/resolve_id_mock.js

@@ -0,0 +1 @@
+console.log('resolve_id mocked');

e2e/fixtures/plugins/src/index.tsx

@@ -2,3 +2,4 @@ console.log(require('./foo.bar'));
 console.log(require('./hoo.bar'));
 console.log(require('./foo.haha'));
 console.log(require('./foo.hoo'));
+console.log(require('resolve_id'));

packages/mako/binding.d.ts

@@ -51,6 +51,7 @@ export interface JsHooks {
   }) => void;
   onGenerateFile?: (path: string, content: Buffer) => Promise<void>;
   buildStart?: () => Promise<void>;
+  resolveId?: (source: string, importer: string) => Promise<{ id: string }>;
 }
 export interface WriteFile {
   path: string;
@@ -60,6 +61,9 @@ export interface LoadResult {
   content: string;
   type: string;
 }
+export interface ResolveIdResult {
+  id: string;
+}
 export interface BuildParams {
   root: string;
   config: {