fix(es/module): support resolving exports from package.json

crates/swc_ecma_loader/src/resolvers/exports.rs

@@ -0,0 +1,273 @@
+use std::collections::{BTreeMap, HashSet};
+use std::fmt;
+use std::path::PathBuf;
+
+use serde::de::{self, Deserialize, Deserializer, MapAccess, Visitor};
+
+/// The parsed representation of the "exports" field in a package.json file.
+/// See https://nodejs.org/api/packages.html#package-entry-points for syntax.
+#[derive(Debug)]
+pub(super) struct Exports {
+    subpaths: BTreeMap<String, Subpath>
+}
+
+impl Exports {
+    /// Resolves a relative path to a target file path.
+    pub fn resolve_import_path(&self, rel_path: &str, conditions: &HashSet<&str>) -> Option<PathBuf> {
+        let mut wildcard_match = None;
+        for (candidate, subpath) in self.subpaths.iter() {
+            match candidate_matches(candidate, rel_path) {
+                None => continue,
+                Some(Match::Exact) => {
+                    return subpath.matches(&conditions).and_then(|m| {
+                        match m {
+                            SubpathMatch::Target(path) => Some(path.into()),
+                            SubpathMatch::Exclude => None,
+                        }
+                    });
+                }
+                Some(Match::Wildcard { replacement }) => {
+                    match subpath.matches(&conditions) {
+                        None => continue,
+
+                        // If we have a target, save it as a candidate.
+                        // We have to keep looking as there may be an exclude directive later.
+                        Some(SubpathMatch::Target(path)) => {
+                            if wildcard_match.is_none() {
+                                wildcard_match = Some((path, replacement));
+                            }
+                        }
+
+                        // If we have an exclude, stop looking and immediately return none.
+                        Some(SubpathMatch::Exclude) => return None,
+                    }
+                }
+            }
+        }
+
+        match wildcard_match {
+            None => None,
+            Some((path, replacement)) => {
+                Some(path.replace("*", replacement).into())
+            }
+        }
+    }
+}
+
+
+enum Match<'a> {
+    Exact,
+    Wildcard { replacement: &'a str },
+}
+
+fn candidate_matches<'a>(candidate: &str, rel_path: &'a str) -> Option<Match<'a>> {
+    let candidate = match (candidate, rel_path) {
+        (".", "") => return Some(Match::Exact),
+        (".", _) => return None,
+        (_, _) => {
+            // Strip "./" prefix.
+            let candidate = candidate.strip_prefix("./").unwrap_or(candidate);
+            if candidate == rel_path {
+                return Some(Match::Exact);
+            }
+            candidate
+        }
+    };
+
+    if let Some(idx) = candidate.find('*') {
+        let (prefix, suffix) = candidate.split_at(idx);
+        if rel_path.starts_with(prefix) && rel_path.ends_with(suffix) {
+            // Get the middle part of the path, to be injected into the result.
+            let replacement = &rel_path[prefix.len()..(rel_path.len() - suffix.len())];
+            return Some(Match::Wildcard { replacement })
+        }
+    }
+
+    None
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum Subpath {
+    Target(String),
+    Conditions(BTreeMap<String, Subpath>),
+    Exclude,
+}
+
+enum SubpathMatch<'a> {
+    Target(&'a str),
+    Exclude,
+}
+
+impl Subpath {
+    fn matches(&self, active_conditions: &HashSet<&str>) -> Option<SubpathMatch> {
+        match self {
+            Subpath::Target(path) => Some(SubpathMatch::Target(&path)),
+            Subpath::Exclude => Some(SubpathMatch::Exclude),
+            Subpath::Conditions(conds) => {
+                for (cond, subpath) in conds.iter() {
+                    if active_conditions.contains(cond.as_str()) {
+                        return subpath.matches(&active_conditions);
+                    }
+                }
+                None
+            }
+        }
+    }
+}
+
+// The "exports" value can be defined in lots of ways.
+//
+// - A single subpath, e.g. "exports": "./index.js".
+//   Syntactic sugar for {".": "./index.js"}
+//
+// - A condition spec: {"node": "./index.node.js"}
+//   Conditions can be nested: {"node": {"import": "./index.node.js", "default": "./index.js"}}
+//
+// - An ordered map of subpaths key-value pairs: {".": "./index.js", "./foo/*": "./foo/*.js"}
+// - Each subpath value can be one of:
+//   - A single target path, e.g. "./index.js" (possibly with wildcards, "./foo/*.js")
+//   - A condition spec.
+//   - Null, indicating the subpath is not exported (overriding other exports that may match).
+
+impl<'de> Deserialize<'de> for Exports {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        struct StringOrMap;
+        impl<'de> Visitor<'de> for StringOrMap {
+            type Value = Exports;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("string or map")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                where
+                    E: de::Error,
+            {
+                let mut subpaths =  BTreeMap::<String, Subpath>::new();
+                subpaths.insert(".".into(), Subpath::Target(value.to_string()));
+                Ok(Exports { subpaths })
+            }
+
+            fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+                where
+                    M: MapAccess<'de>,
+            {
+
+                let mut subpaths = BTreeMap::new();
+
+                // Peek at the first entry to decide whether it's a map of subpaths or conditions.
+                let Some((key, value)) = access.next_entry::<String, Subpath>()? else {
+                    // Empty map.
+                    return Ok(Exports { subpaths });
+                };
+
+                if !key.starts_with(".") {
+                    let mut conditions: BTreeMap<String, Subpath> = Deserialize::deserialize(de::value::MapAccessDeserializer::new(access))?;
+                    conditions.insert(key, value);
+                    subpaths.insert(".".to_string(), Subpath::Conditions(conditions));
+                    return Ok(Exports { subpaths });
+                }
+
+                subpaths.insert(key, value);
+                while let Some((key, value)) = access.next_entry::<String, Subpath>()? {
+                    subpaths.insert(key, value);
+                }
+
+                Ok(Exports { subpaths })
+            }
+        }
+
+        deserializer.deserialize_any(StringOrMap)
+    }
+}
+
+struct SubpathVisitor;
+
+impl<'de> Visitor<'de> for SubpathVisitor {
+    type Value = Subpath;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("string or map")
+    }
+
+    fn visit_unit<E>(self) -> Result<Self::Value, E> where E: de::Error {
+        Ok(Subpath::Exclude)
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+    {
+        Ok(Subpath::Target(value.to_string()))
+    }
+
+    fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>
+        where
+            M: MapAccess<'de>,
+    {
+        let conditions: BTreeMap<String, Subpath> = Deserialize::deserialize(de::value::MapAccessDeserializer::new(map))?;
+        Ok(Subpath::Conditions(conditions))
+    }
+}
+
+impl<'de> Deserialize<'de> for Subpath {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        deserializer.deserialize_any(SubpathVisitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_subpaths() {
+        let exports: Exports = serde_json::from_str(r#"{
+            ".": "./index.js",
+            "./foo/*": "./foo/*.js",
+            "./bar": {"node": "./bar.node.js", "default": "./bar.js"},
+            "./baz": {"node": "./baz.node.js", "default": null},
+            "./qux": null
+        }"#).unwrap();
+        assert_eq!(exports.subpaths.len(), 5);
+        assert_eq!(exports.subpaths.get(".").unwrap(), &Subpath::Target("./index.js".into()));
+        assert_eq!(exports.subpaths.get("./foo/*").unwrap(), &Subpath::Target("./foo/*.js".into()));
+        assert_eq!(exports.subpaths.get("./bar").unwrap(), &Subpath::Conditions({
+            let mut map = BTreeMap::new();
+            map.insert("node".to_owned(), Subpath::Target("./bar.node.js".into()));
+            map.insert("default".to_owned(), Subpath::Target("./bar.js".into()));
+            map
+        }));
+        assert_eq!(exports.subpaths.get("./baz").unwrap(), &Subpath::Conditions({
+            let mut map = BTreeMap::new();
+            map.insert("node".to_owned(), Subpath::Target("./baz.node.js".into()));
+            map.insert("default".to_owned(), Subpath::Exclude);
+            map
+        }));
+        assert_eq!(exports.subpaths.get("./qux").unwrap(), &Subpath::Exclude);
+    }
+
+    #[test]
+    fn parse_toplevel_conditions() {
+        let exports: Exports = serde_json::from_str(r#"{
+            "node": {"import": "./bar.node.js", "default": "./bar.js"},
+            "default": "./index.js"
+        }"#).unwrap();
+        assert_eq!(exports.subpaths.len(), 1);
+        assert_eq!(exports.subpaths.get(".").unwrap(), &Subpath::Conditions({
+            let mut map = BTreeMap::new();
+            map.insert("node".to_owned(), Subpath::Conditions({
+                let mut map = BTreeMap::new();
+                map.insert("import".to_owned(), Subpath::Target("./bar.node.js".into()));
+                map.insert("default".to_owned(), Subpath::Target("./bar.js".into()));
+                map
+            }));
+            map.insert("default".to_owned(), Subpath::Target("./index.js".into()));
+            map
+        }));
+    }
+}

crates/swc_ecma_loader/src/resolvers/mod.rs

@@ -7,3 +7,6 @@ pub mod node;
 #[cfg(feature = "tsc")]
 #[cfg_attr(docsrs, doc(cfg(feature = "tsc")))]
 pub mod tsc;
+#[cfg(feature = "node")]
+#[cfg_attr(docsrs, doc(cfg(feature = "node")))]
+mod exports;