Implement package.json's imports field

crates/turbo-tasks-memory/tests/debug.rs

@@ -3,7 +3,7 @@
 use std::sync::Mutex;
 
 use anyhow::Result;
-use turbo_tasks::{debug::ValueDebug, TaskInput};
+use turbo_tasks::debug::ValueDebug;
 use turbo_tasks_testing::{register, run};
 
 register!();

crates/turbopack-core/src/issue/mod.rs

@@ -1,6 +1,5 @@
 pub mod analyze;
 pub mod code_gen;
-pub mod package_json;
 pub mod resolve;
 pub mod unsupported_module;
 

crates/turbopack-core/src/lib.rs

@@ -16,6 +16,7 @@ pub mod error;
 pub mod ident;
 pub mod introspect;
 pub mod issue;
+pub mod package_json;
 pub mod plugin;
 pub mod proxied_asset;
 pub mod reference;

crates/turbopack-core/src/package_json.rs

@@ -0,0 +1,79 @@
+use std::{fmt::Write, ops::Deref};
+
+use anyhow::Result;
+use serde_json::Value as JsonValue;
+use turbo_tasks::{debug::ValueDebugFormat, primitives::StringVc, trace::TraceRawVcs};
+use turbo_tasks_fs::{FileContent, FileJsonContent, FileJsonContentReadRef, FileSystemPathVc};
+
+use super::issue::{Issue, IssueVc};
+
+#[derive(PartialEq, Eq, ValueDebugFormat, TraceRawVcs)]
+pub struct PackageJson(FileJsonContentReadRef);
+
+impl Deref for PackageJson {
+ type Target = JsonValue;
+ fn deref(&self) -> &Self::Target {
+ match &*self.0 {
+ FileJsonContent::Content(json) => json,
+ _ => unreachable!("PackageJson is guaranteed to hold Content"),
+ }
+ }
+}
+
+#[turbo_tasks::value(transparent, serialization = "none")]
+pub struct OptionPackageJson(Option<PackageJson>);
+
+#[turbo_tasks::function]
+pub async fn read_package_json(path: FileSystemPathVc) -> Result<OptionPackageJsonVc> {
+ let read = path.read_json().await?;
+ match &*read {
+ FileJsonContent::Content(_) => Ok(OptionPackageJson(Some(PackageJson(read))).cell()),
+ FileJsonContent::NotFound => Ok(OptionPackageJson(None).cell()),
+ FileJsonContent::Unparseable(e) => {
+ let mut message = "package.json is not parseable: invalid JSON: ".to_string();
+ if let FileContent::Content(content) = &*path.read().await? {
+ let text = content.content().to_str()?;
+ e.write_with_content(&mut message, &text)?;
+ } else {
+ write!(message, "{}", e)?;
+ }
+ PackageJsonIssue {
+ error_message: message,
+ path,
+ }
+ .cell()
+ .as_issue()
+ .emit();
+ Ok(OptionPackageJson(None).cell())
+ }
+ }
+}
+
+#[turbo_tasks::value(shared)]
+pub struct PackageJsonIssue {
+ pub path: FileSystemPathVc,
+ pub error_message: String,
+}
+
+#[turbo_tasks::value_impl]
+impl Issue for PackageJsonIssue {
+ #[turbo_tasks::function]
+ fn title(&self) -> StringVc {
+ StringVc::cell("Error parsing package.json file".to_string())
+ }
+
+ #[turbo_tasks::function]
+ fn category(&self) -> StringVc {
+ StringVc::cell("parse".to_string())
+ }
+
+ #[turbo_tasks::function]
+ fn context(&self) -> FileSystemPathVc {
+ self.path
+ }
+
+ #[turbo_tasks::function]
+ fn description(&self) -> StringVc {
+ StringVc::cell(self.error_message.clone())
+ }
+}