feat(graph): support CSS files

crates/biome_css_syntax/src/import_ext.rs

@@ -0,0 +1,27 @@
+use crate::{AnyCssImportUrl, AnyCssUrlValue};
+use biome_rowan::TokenText;
+
+impl AnyCssImportUrl {
+    /// Returns the inner text of specifier:
+    ///
+    /// ## Examples
+    ///
+    /// ```
+    /// use biome_css_factory::make;
+    /// use biome_css_syntax::AnyCssImportUrl;
+    /// ```
+    pub fn inner_string_text(&self) -> Option<TokenText> {
+        match self {
+            Self::CssString(css) => css.inner_string_text().ok(),
+            Self::CssUrlFunction(url_function) => {
+                url_function.value().and_then(|value| match value {
+                    AnyCssUrlValue::CssString(css) => css.inner_string_text().ok(),
+                    AnyCssUrlValue::CssUrlValueRaw(raw) => raw
+                        .value_token()
+                        .ok()
+                        .map(|token| token.token_text_trimmed()),
+                })
+            }
+        }
+    }
+}

crates/biome_css_syntax/src/lib.rs

@@ -3,6 +3,7 @@
 #[macro_use]
 mod file_source;
 mod generated;
+mod import_ext;
 pub mod selector_ext;
 pub mod stmt_ext;
 mod string_ext;

crates/biome_js_analyze/src/lib.rs

@@ -159,7 +159,7 @@ where
         .map(|(path, manifest)| (path, Arc::new(manifest)));
 
     let type_resolver = module_graph
-        .module_info_for_path(file_path.as_ref())
+        .js_module_info_for_path(file_path.as_ref())
         .map(|module_info| ModuleResolver::for_module(module_info, module_graph.clone()))
         .map(Arc::new);
 

crates/biome_js_analyze/src/lint/nursery/no_deprecated_imports.rs

@@ -125,7 +125,7 @@ fn get_deprecated_imports_from_module_source(
     target_path: &Utf8Path,
     module_graph: &ModuleGraph,
 ) -> Vec<NoDeprecatedImportsState> {
-    let Some(module_info) = module_graph.module_info_for_path(target_path) else {
+    let Some(module_info) = module_graph.js_module_info_for_path(target_path) else {
         return Vec::new();
     };
 

crates/biome_js_analyze/src/lint/nursery/no_unresolved_imports.rs

@@ -260,6 +260,6 @@ fn get_unresolved_imports_from_module_source(
 fn has_exported_symbol(import_name: &Text, options: &GetUnresolvedImportsOptions) -> bool {
     options
         .target_info
-        .find_exported_symbol(options.module_graph, import_name.text())
+        .find_js_exported_symbol(options.module_graph, import_name.text())
         .is_some()
 }

crates/biome_js_analyze/src/services/module_graph.rs

@@ -17,7 +17,7 @@ impl ModuleGraphService {
     }
 
     pub fn module_info_for_path(&self, path: &Utf8Path) -> Option<JsModuleInfo> {
-        self.0.module_info_for_path(path)
+        self.0.js_module_info_for_path(path)
     }
 
     pub fn project_layout(&self) -> &ProjectLayout {

crates/biome_lsp/src/server.tests.rs

@@ -3838,7 +3838,11 @@ async fn should_open_and_update_nested_files() -> Result<()> {
         result
             .data
             .get(fs.working_directory.join("src").join("a.js").as_str())
-            .map(|module_info| module_info.static_import_paths.clone()),
+            .map(|module_info| module_info
+                .as_js_module_info()
+                .unwrap()
+                .static_import_paths
+                .clone()),
         Some(BTreeMap::from([("foo".to_string(), "foo".to_string())]))
     );
 
@@ -3865,7 +3869,11 @@ async fn should_open_and_update_nested_files() -> Result<()> {
         result
             .data
             .get(fs.working_directory.join("src").join("a.js").as_str())
-            .map(|module_info| module_info.static_import_paths.clone()),
+            .map(|module_info| module_info
+                .as_js_module_info()
+                .unwrap()
+                .static_import_paths
+                .clone()),
         Some(BTreeMap::from([("bar".to_string(), "bar".to_string())]))
     );
 

crates/biome_module_graph/Cargo.toml

@@ -16,6 +16,8 @@ workspace = true
 
 [dependencies]
 biome_console        = { workspace = true }
+biome_css_semantic   = { workspace = true }
+biome_css_syntax     = { workspace = true }
 biome_diagnostics    = { workspace = true }
 biome_formatter      = { workspace = true }
 biome_fs             = { workspace = true }

crates/biome_module_graph/benches/module_graph.rs

@@ -73,7 +73,6 @@ fn bench_index_d_ts(bencher: Bencher, name: &str) {
                 &fs,
                 &ProjectLayout::default(),
                 &[(&path, root)],
-                &[],
             );
             divan::black_box(&module_graph);
         });

crates/biome_module_graph/src/css_module_info.rs

@@ -0,0 +1,102 @@
+mod visitor;
+
+use biome_resolver::ResolvedPath;
+use biome_rowan::Text;
+use indexmap::IndexMap;
+use std::collections::BTreeSet;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+pub(crate) use visitor::CssModuleVisitor;
+
+/// Information restricted to a single module in the [ModuleGraph].
+#[derive(Clone, Debug)]
+pub struct CssModuleInfo(pub(super) Arc<CssModuleInfoInner>);
+
+impl Deref for CssModuleInfo {
+    type Target = CssModuleInfoInner;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref()
+    }
+}
+
+impl CssModuleInfo {
+    pub(crate) fn new(imports: CssImports) -> Self {
+        let info = CssModuleInfoInner { imports };
+        Self(Arc::new(info))
+    }
+
+    pub(crate) fn dump(&self) -> SerializedCssModuleInfo {
+        SerializedCssModuleInfo {
+            imports: self
+                .0
+                .imports
+                .iter()
+                .map(|(_, static_import)| static_import.specifier.to_string())
+                .collect(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CssModuleInfoInner {
+    /// Map of all static imports found in the module.
+    ///
+    /// Maps from the local imported name to a [JsImport] with the absolute path
+    /// it resolves to. The resolved path may be looked up as key in the
+    /// [ModuleGraph::data] map, although it is not required to exist
+    /// (for instance, if the path is outside the project's scope).
+    ///
+    /// Note that re-exports may introduce additional dependencies, because they
+    /// import another module and immediately re-export from that module.
+    /// Re-exports are tracked as part of [Self::exports] and
+    /// [Self::blanket_reexports].
+    pub imports: CssImports,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct CssImports(pub(crate) IndexMap<Text, CssImport>);
+
+impl Deref for CssImports {
+    type Target = IndexMap<Text, CssImport>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for CssImports {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// Represents an import to one or more symbols from an external path.
+///
+/// It could point to any kind of resource, such as JavaScript files, CSS files,
+/// images, and so on.
+#[derive(Clone, Debug, PartialEq, Hash, Eq)]
+pub struct CssImport {
+    /// The specifier for the imported as it appeared in the source text.
+    pub specifier: Text,
+
+    /// Absolute path of the resource being imported, if it can be resolved.
+    ///
+    /// If the import statement referred to a package dependency, the path will
+    /// point towards the resolved entry point of the package.
+    ///
+    /// If `None`, import resolution failed.
+    pub resolved_path: ResolvedPath,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub struct SerializedCssModuleInfo {
+    /// Map of all static imports found in the module.
+    ///
+    /// Maps from the local imported name to the absolute path it resolves to.
+    pub imports: BTreeSet<String>,
+}

crates/biome_module_graph/src/css_module_info/visitor.rs

@@ -0,0 +1,76 @@
+use crate::css_module_info::{CssImport, CssImports, CssModuleInfo};
+use crate::module_graph::ModuleGraphFsProxy;
+use biome_css_syntax::{AnyCssImportUrl, CssRoot};
+use biome_resolver::{ResolveOptions, ResolvedPath, resolve};
+use biome_rowan::{AstNode, Text, WalkEvent};
+use camino::Utf8Path;
+use std::ops::DerefMut;
+
+pub const SUPPORTED_EXTENSIONS: &[&str] = &["css"];
+
+pub(crate) struct CssModuleVisitor<'a> {
+    root: CssRoot,
+    directory: &'a Utf8Path,
+    fs_proxy: &'a ModuleGraphFsProxy<'a>,
+}
+
+impl<'a> CssModuleVisitor<'a> {
+    pub(crate) fn new(
+        root: CssRoot,
+        directory: &'a Utf8Path,
+        fs_proxy: &'a ModuleGraphFsProxy,
+    ) -> Self {
+        Self {
+            root,
+            directory,
+            fs_proxy,
+        }
+    }
+
+    pub(crate) fn visit(self) -> CssModuleInfo {
+        let mut imports = CssImports::default();
+        let iter = self.root.syntax().preorder();
+        for event in iter {
+            match event {
+                WalkEvent::Enter(node) => {
+                    if let Some(node) = AnyCssImportUrl::cast(node) {
+                        self.visit_any_css_import_url(node, &mut imports);
+                    }
+                }
+                WalkEvent::Leave(_) => {}
+            }
+        }
+
+        CssModuleInfo::new(imports)
+    }
+
+    fn visit_any_css_import_url(&self, node: AnyCssImportUrl, imports: &mut CssImports) {
+        let Some(specifier) = node.inner_string_text() else {
+            return;
+        };
+
+        let resolved_path = self.resolved_path_from_specifier(&specifier);
+
+        let text: Text = specifier.into();
+        imports.deref_mut().insert(
+            text.clone(),
+            CssImport {
+                specifier: text,
+                resolved_path,
+            },
+        );
+    }
+
+    fn resolved_path_from_specifier(&self, specifier: &str) -> ResolvedPath {
+        let options = ResolveOptions {
+            assume_relative: true,
+            condition_names: &[],
+            default_files: &[],
+            extensions: SUPPORTED_EXTENSIONS,
+            extension_aliases: &[],
+            ..Default::default()
+        };
+        let resolved_path = resolve(specifier, self.directory, self.fs_proxy, &options);
+        ResolvedPath::new(resolved_path)
+    }
+}

crates/biome_module_graph/src/js_module_info.rs

@@ -57,7 +57,7 @@ impl JsModuleInfo {
     /// Finds an exported symbol by `name`, using the `module_graph` to
     /// lookup re-exports if necessary.
     #[inline]
-    pub fn find_exported_symbol(
+    pub fn find_js_exported_symbol(
         &self,
         module_graph: &ModuleGraph,
         name: &str,

crates/biome_module_graph/src/js_module_info/module_resolver.rs

@@ -169,7 +169,7 @@ impl ModuleResolver {
             Entry::Occupied(entry) => Some(*entry.get()),
             Entry::Vacant(entry) => {
                 let path = entry.key().as_path()?;
-                let module_info = self.module_graph.module_info_for_path(path)?;
+                let module_info = self.module_graph.js_module_info_for_path(path)?;
                 let module_id = ModuleId::new(self.modules.len());
                 self.modules.push(module_info);
                 self.types

crates/biome_module_graph/src/lib.rs

@@ -1,5 +1,6 @@
 #![deny(clippy::use_self)]
 
+mod css_module_info;
 mod diagnostics;
 mod format_module_graph;
 mod js_module_info;
@@ -8,9 +9,12 @@ mod module_graph;
 pub use biome_js_type_info::ImportSymbol;
 pub use biome_resolver::ResolvedPath;
 
+pub use css_module_info::{CssImport, CssImports, CssModuleInfo};
 pub use diagnostics::ModuleDiagnostic;
 pub use js_module_info::{
     JsExport, JsImport, JsImportPath, JsImportPhase, JsModuleInfo, JsModuleInfoDiagnostic,
     JsOwnExport, JsReexport, ModuleResolver, SerializedJsModuleInfo,
 };
-pub use module_graph::{ModuleDependencies, ModuleGraph, SUPPORTED_EXTENSIONS};
+pub use module_graph::{
+    ModuleDependencies, ModuleGraph, ModuleInfo, SUPPORTED_EXTENSIONS, SerializedModuleInfo,
+};