perf: use simd json for json parse (#117)

Author: stormslowly

Cargo.lock

@@ -81,6 +81,9 @@ serde = { version = "1.0.203", features = ["derive"] } # derive for Deserialize
 serde_json = { version = "1.0.117", features = [
   "preserve_order",
 ] } # preserve_order: package_json.exports requires order such as `["require", "import", "default"]`
+
+simd-json = {  version = "0.17.0", features = ["serde_impl", "runtime-detection"], default-features = false }
+
 rustc-hash = { version = "2.0.0", default-features = false, features = ["std"] }
 dunce = "1.0.4" # Normalize Windows paths to the most compatible format, avoiding UNC where possible
 thiserror = "1.0.61"

Cargo.toml

@@ -93,7 +93,8 @@ allow = [
     "Apache-2.0",
     "Unicode-DFS-2016",
     "BSD-2-Clause",
-    "Unicode-3.0"
+    "Unicode-3.0", 
+    "Zlib"
     #"Apache-2.0 WITH LLVM-exception",
 ]
 # The confidence threshold for detecting a license from license text.

deny.toml

@@ -30,8 +30,7 @@ async fn resolve(resolver: &Resolver, path: &Path, request: &str) -> ResolveResu
       error: None,
       module_type: resolution
         .package_json()
-        .and_then(|p| p.r#type.as_ref())
-        .and_then(|t| t.as_str())
+        .and_then(|p| p.r#type)
         .map(|t| t.to_string()),
     },
     Err(err) => ResolveResult {

napi/src/lib.rs

@@ -15,8 +15,10 @@ use rustc_hash::FxHasher;
 use tokio::sync::OnceCell as OnceLock;
 
 use crate::{
-  context::ResolveContext as Ctx, package_json::PackageJson, path::PathUtil, FileMetadata,
-  FileSystem, ResolveError, ResolveOptions, TsConfig,
+  context::ResolveContext as Ctx,
+  package_json::{off_to_location, PackageJson},
+  path::PathUtil,
+  FileMetadata, FileSystem, JSONError, ResolveError, ResolveOptions, TsConfig,
 };
 
 #[derive(Default)]
@@ -311,27 +313,40 @@ impl CachedPathImpl {
       .package_json
       .get_or_try_init(|| async {
         let package_json_path = self.path.join("package.json");
-        let Ok(package_json_string) = fs.read_to_string(&package_json_path).await else {
+        let Ok(package_json_string) = fs.read(&package_json_path).await else {
           return Ok(None);
         };
         let real_path = if options.symlinks {
           self.realpath(fs).await?.join("package.json")
         } else {
           package_json_path.clone()
         };
-        PackageJson::parse(package_json_path.clone(), real_path, &package_json_string)
-          .map(Arc::new)
-          .map(Some)
-          .map_err(|error| {
-            ResolveError::from_serde_json_error(
-              package_json_path,
-              &error,
-              Some(package_json_string),
-            )
-          })
+        match PackageJson::parse(package_json_path.clone(), real_path, package_json_string) {
+          Ok(v) => Ok(Some(Arc::new(v))),
+          Err(parse_err) => {
+            let package_json_path = self.path.join("package.json");
+            let package_json_string = match fs.read_to_string(&package_json_path).await {
+              Ok(c) => c,
+              Err(io_err) => {
+                return Err(ResolveError::from(io_err));
+              }
+            };
+
+            let (line, column) = off_to_location(&package_json_string, parse_err.index());
+
+            Err(ResolveError::JSON(JSONError {
+              path: package_json_path,
+              message: format!("Parsing error: {:?}", parse_err.error()),
+              line,
+              column,
+              content: Some(package_json_string),
+            }))
+          }
+        }
       })
       .await
       .cloned();
+
     // https://github.com/webpack/enhanced-resolve/blob/58464fc7cb56673c9aa849e68e6300239601e615/lib/DescriptionFileUtils.js#L68-L82
     match &result {
       Ok(Some(package_json)) => {