feat: improve error message for empty package.json files (#793)

## Summary

Improves error messages for empty package.json files by returning a clear "File is empty" message instead of the cryptic "EOF while parsing a value at line 1 column 0".

## Changes

- Add empty file check in `PackageJson::parse()` for both simd and serde implementations
- Return `JSONError` with "File is empty" message before attempting JSON parsing
- Update tests to expect new error message
- Add comprehensive test suite for various corrupted package.json scenarios

## Error Message Improvement

**Before:**
```
EOF while parsing a value at line 1 column 0
```

**After:**
```
File is empty
```

## Test Plan

- ✅ All existing tests pass (150/150)
- ✅ Added new test `test_corrupted_package_json` covering multiple scenarios:
  - Empty file
  - Null bytes
  - Trailing commas
  - Unclosed braces
  - Invalid escapes
- ✅ Updated `incorrect_description_file_2` test for new error message
- ✅ Clippy passes with no warnings

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: Boshen

src/package_json/mod.rs

@@ -14,7 +14,18 @@ pub use serde::*;
 #[cfg(target_endian = "little")]
 pub use simd::*;
 
-use std::fmt;
+use std::{fmt, path::PathBuf};
+
+use crate::JSONError;
+
+/// Check if JSON content is empty or contains only whitespace
+fn check_if_empty(json_bytes: &[u8], path: PathBuf) -> Result<(), JSONError> {
+    // Check if content is empty or whitespace-only
+    if json_bytes.iter().all(|&b| b.is_ascii_whitespace()) {
+        return Err(JSONError { path, message: "File is empty".to_string(), line: 0, column: 0 });
+    }
+    Ok(())
+}
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum PackageType {

src/package_json/serde.rs

@@ -228,6 +228,9 @@ impl PackageJson {
             json.as_str()
         };
 
+        // Check if empty after BOM stripping
+        super::check_if_empty(json_string.as_bytes(), path.clone())?;
+
         // Parse JSON
         let value = serde_json::from_str::<Value>(json_string).map_err(|error| JSONError {
             path: path.clone(),

src/package_json/simd.rs

@@ -262,6 +262,9 @@ impl PackageJson {
             json_bytes[2] = b' ';
         }
 
+        // Check if empty after BOM stripping
+        super::check_if_empty(&json_bytes, path.clone())?;
+
         // Create the self-cell with the JSON bytes and parsed BorrowedValue
         let cell = PackageJsonCell::try_new(json_bytes.clone(), |bytes| {
             // We need a mutable slice from our owned data

src/tests/incorrect_description_file.rs

@@ -31,8 +31,8 @@ fn incorrect_description_file_2() {
     let resolution = Resolver::default().resolve(f.join("pack2"), ".");
     let error = ResolveError::Json(JSONError {
         path: f.join("pack2/package.json"),
-        message: String::from("EOF while parsing a value at line 1 column 0"),
-        line: 1,
+        message: String::from("File is empty"),
+        line: 0,
         column: 0,
     });
     assert_eq!(resolution, Err(error));

src/tests/package_json.rs

@@ -1,6 +1,6 @@
 //! Tests for `Resolution::package_json`.
 
-use crate::Resolver;
+use crate::{ResolveError, Resolver};
 
 #[test]
 fn test() {
@@ -62,3 +62,64 @@ fn package_json_with_symlinks_true() {
     let package_json_path = package_json.as_ref().map(|p| &p.path);
     assert_eq!(package_json_path, Some(&resolved_package_json_path));
 }
+
+#[test]
+#[cfg(not(target_os = "windows"))] // MemoryFS's path separator is always `/` so the test will not pass in windows.
+fn test_corrupted_package_json() {
+    use std::path::Path;
+
+    use super::memory_fs::MemoryFS;
+    use crate::{ResolveOptions, ResolverGeneric};
+
+    // Test scenarios for various corrupted package.json files
+    let scenarios = [
+        ("empty_file", "", "File is empty"),
+        ("null_byte_at_start", "\0", "expected value"),
+        ("json_with_embedded_null", "{\"name\":\0\"test\"}", "expected value"),
+        ("trailing_comma", "{\"name\":\"test\",}", "trailing comma"),
+        ("unclosed_brace", "{\"name\":\"test\"", "EOF while parsing"),
+        ("invalid_escape", "{\"name\":\"test\\x\"}", "escape"),
+    ];
+
+    for (name, content, expected_message_contains) in scenarios {
+        let mut fs = MemoryFS::default();
+
+        // Write corrupted package.json
+        fs.add_file(Path::new("/test/package.json"), content);
+
+        // Create a simple index.js so resolution can proceed
+        fs.add_file(Path::new("/test/index.js"), "export default 42;");
+
+        // Create resolver with VFS
+        let resolver = ResolverGeneric::new_with_file_system(fs, ResolveOptions::default());
+
+        // Attempt to resolve - should fail with JSONError
+        let result = resolver.resolve(Path::new("/test"), "./index.js");
+
+        match result {
+            Err(ResolveError::Json(json_error)) => {
+                assert!(
+                    json_error
+                        .message
+                        .to_lowercase()
+                        .contains(&expected_message_contains.to_lowercase()),
+                    "Test case '{name}': Expected error message to contain '{expected_message_contains}', but got: {}",
+                    json_error.message
+                );
+                assert!(
+                    json_error.path.ends_with("package.json"),
+                    "Test case '{name}': Expected path to end with 'package.json', but got: {:?}",
+                    json_error.path
+                );
+            }
+            Err(other_error) => {
+                panic!("Test case '{name}': Expected JSONError but got: {other_error:?}");
+            }
+            Ok(resolution) => {
+                panic!(
+                    "Test case '{name}': Expected error but resolution succeeded: {resolution:?}"
+                );
+            }
+        }
+    }
+}