fix: element reference

Author: Groupguanfang

index.d.ts

@@ -9,7 +9,7 @@ export declare class ElementDirectory {
 export declare class ElementJsonFile {
   static findAll(elementDirectory: ElementDirectory): Array<ElementJsonFile>
   getUri(): Uri
-  getResourceDirectory(): ElementDirectory
+  getElementDirectory(): ElementDirectory
   getContent(): string
   parse(): any
   getReference(): Array<ElementJsonFileReference>
@@ -21,7 +21,9 @@ export declare class ElementJsonFileReference {
   getValueStart(): number
   getValueEnd(): number
   getNameText(): string
+  getNameFullText(): string
   getValueText(): string
+  getValueFullText(): string
 }
 
 export declare class Module {
@@ -130,6 +132,7 @@ export declare class Resource {
 export declare class ResourceDirectory {
   static findAll(resource: Resource): Array<ResourceDirectory>
   getUri(): Uri
+  getResource(): Resource
   getQualifiers(): Array<Qualifier> | 'base' | 'rawfile' | 'resfile'
 }
 

index.js

@@ -76,6 +76,7 @@
     "eslint": "^9.37.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.6",
+    "magic-string": "^0.30.19",
     "npm-run-all2": "^8.0.4",
     "tinybench": "^5.0.1",
     "typescript": "^5.9.2",

package.json

@@ -16,7 +16,7 @@ pub struct ElementJsonFile {
   source_code: String,
   uri: Uri,
   #[cfg(not(test))]
-  resource_directory: Reference<ElementDirectory>,
+  element_directory: Reference<ElementDirectory>,
 }
 
 #[napi]
@@ -34,15 +34,15 @@ impl ElementJsonFile {
   }
 
   #[cfg(not(test))]
-  pub fn new(resource_directory: Reference<ElementDirectory>, uri: &Uri, source_code: String) -> Self {
+  pub fn new(element_directory: Reference<ElementDirectory>, uri: &Uri, source_code: String) -> Self {
     let mut parser = Parser::new();
     parser.set_language(&tree_sitter_json::LANGUAGE.into()).unwrap();
 
     Self {
       parser,
       source_code,
       uri: uri.clone(),
-      resource_directory,
+      element_directory,
     }
   }
 
@@ -74,15 +74,19 @@ impl ElementJsonFile {
 
   #[napi]
   #[cfg(not(test))]
-  pub fn get_resource_directory(&self, env: Env) -> Reference<ElementDirectory> {
-    self.resource_directory.clone(env).unwrap()
+  pub fn get_element_directory(&self, env: Env) -> Reference<ElementDirectory> {
+    self.element_directory.clone(env).unwrap()
   }
 
   #[napi]
   pub fn get_content(&self) -> String {
     self.source_code.clone()
   }
 
+  fn byte_to_char_index(&self, byte_offset: usize) -> usize {
+    self.source_code[..byte_offset].chars().count()
+  }
+
   #[napi]
   pub fn parse(&mut self) -> serde_json::Value {
     serde_json5::from_str(&self.source_code).unwrap()
@@ -139,16 +143,16 @@ impl ElementJsonFile {
                 Ok(text) => text,
                 Err(_) => continue,
               };
-              if key_text.contains("\"name\"") {
-                name_start = Some(filtered_nodes[1].start_byte());
-                name_end = Some(filtered_nodes[1].end_byte());
+              if key_text =="\"name\"" {
+                name_start = Some(self.byte_to_char_index(filtered_nodes[1].start_byte()));
+                name_end = Some(self.byte_to_char_index(filtered_nodes[1].end_byte()));
                 name_text = Some(match filtered_nodes[1].utf8_text(self.source_code.as_bytes()) {
                   Ok(text) => text.to_string(),
                   Err(_) => continue,
                 });
-              } else if key_text.contains("\"value\"") {
-                value_start = Some(filtered_nodes[1].start_byte());
-                value_end = Some(filtered_nodes[1].end_byte());
+              } else if key_text == "\"value\"" {
+                value_start = Some(self.byte_to_char_index(filtered_nodes[1].start_byte()));
+                value_end = Some(self.byte_to_char_index(filtered_nodes[1].end_byte()));
                 value_text = Some(match filtered_nodes[1].utf8_text(self.source_code.as_bytes()) {
                   Ok(text) => text.to_string(),
                   Err(_) => continue,
@@ -161,14 +165,16 @@ impl ElementJsonFile {
             if let (Some(name_start), Some(name_end), Some(name_text), Some(value_start), Some(value_end), Some(value_text)) =
               (name_start, name_end, name_text, value_start, value_end, value_text)
             {
-              reference.push(ElementJsonFileReference::new(
-                name_start as u32,
-                name_end as u32,
-                name_text,
-                value_start as u32,
-                value_end as u32,
-                value_text,
-              ))
+              reference.push(
+                ElementJsonFileReference::new(
+                  name_start as u32,
+                  name_end as u32,
+                  name_text,
+                  value_start as u32,
+                  value_end as u32,
+                  value_text,
+                )
+              )
             }
           }
         }
@@ -183,17 +189,39 @@ impl ElementJsonFile {
 mod tests {
   use super::*;
 
+  fn slice(s: &str, start: usize, end_exclusive: usize) -> String {
+    let mut byte_start = 0usize;
+    let mut byte_end = s.len();
+    for (i, (bpos, _)) in s.char_indices().enumerate() {
+      if i == start { byte_start = bpos; }
+      if i == end_exclusive { byte_end = bpos; break; }
+    }
+    s[byte_start..byte_end].to_string()
+  }
+
   #[test]
   fn test_get_reference() {
     let mock_str = String::from("{ \"string\": [{ \"name\": \"test1\", \"value\": \"test1-value\" }] }");
     let mut element_json_file = ElementJsonFile::new(&Uri::file("test.json".to_string()), mock_str.clone());
     let references = element_json_file.get_reference();
     assert_eq!(references.len(), 1);
-    assert_eq!(references[0].get_name_text(), "\"test1\"");
-    assert_eq!(references[0].get_value_text(), "\"test1-value\"");
-    assert_eq!(references[0].get_name_start(), 23);
-    assert_eq!(references[0].get_name_end(), 30);
-    assert_eq!(references[0].get_value_start(), 41);
-    assert_eq!(references[0].get_value_end(), 54);
+    assert_eq!(references[0].get_name_full_text(), "\"test1\"");
+    assert_eq!(references[0].get_value_full_text(), "\"test1-value\"");
+    assert_eq!(
+      slice(
+        &mock_str,
+        references[0].get_name_start() as usize,
+        references[0].get_name_end() as usize
+      ),
+      references[0].get_name_full_text()
+    );
+    assert_eq!(
+      slice(
+        &mock_str,
+        references[0].get_value_start() as usize,
+        references[0].get_value_end() as usize
+      ),
+      references[0].get_value_full_text()
+    );
   }
 }

pnpm-lock.yaml

@@ -45,11 +45,27 @@ impl ElementJsonFileReference {
 
   #[napi]
   pub fn get_name_text(&self) -> String {
+    let s = self.name_text.as_str();
+    let s = if s.starts_with('"') { &s[1..] } else { s };
+    let s = if s.ends_with('"') { &s[..s.len() - 1] } else { s };
+    s.to_string()
+  }
+
+  #[napi]
+  pub fn get_name_full_text(&self) -> String {
     self.name_text.clone()
   }
 
   #[napi]
   pub fn get_value_text(&self) -> String {
+    let s = self.value_text.as_str();
+    let s = if s.starts_with('"') { &s[1..] } else { s };
+    let s = if s.ends_with('"') { &s[..s.len() - 1] } else { s };
+    s.to_string()
+  }
+
+  #[napi]
+  pub fn get_value_full_text(&self) -> String {
     self.value_text.clone()
   }
 }

src/files/element_json_file.rs

@@ -3,25 +3,31 @@ use crate::utils::qualifier::utils_impl::QualifierUtils;
 use crate::utils::uri::Uri;
 use core::str;
 use napi::bindgen_prelude::Reference;
+use napi::Env;
 use napi_derive::napi;
 use serde_json::Value;
 use std::path::Path;
 
 #[napi]
-#[derive(Clone)]
 pub struct ResourceDirectory {
   uri: Uri,
+  resource: Reference<Resource>,
 }
 
 #[napi]
 impl ResourceDirectory {
   #[napi]
-  pub fn find_all(resource: Reference<Resource>) -> Vec<ResourceDirectory> {
+  pub fn find_all(resource: Reference<Resource>, env: Env) -> Vec<ResourceDirectory> {
     let mut resource_directories = Vec::new();
     let qualified_directories = resource.get_qualified_directories();
 
     for qualified_directory in qualified_directories {
-      resource_directories.push(ResourceDirectory { uri: qualified_directory })
+      resource_directories.push(
+        ResourceDirectory { 
+          uri: qualified_directory,
+          resource: resource.clone(env).unwrap()
+        }
+      )
     }
 
     resource_directories
@@ -32,6 +38,11 @@ impl ResourceDirectory {
     self.uri.clone()
   }
 
+  #[napi]
+  pub fn get_resource(&self, env: Env) -> Reference<Resource> {
+    self.resource.clone(env).unwrap()
+  }
+
   #[napi(ts_return_type = "Array<Qualifier> | 'base' | 'rawfile' | 'resfile'")]
   pub fn get_qualifiers(&self) -> Value {
     let directory_name = Path::new(&self.uri.fs_path()).file_name().unwrap_or_default().to_string_lossy().to_string();

src/references/element_json_file_reference.rs

@@ -1,4 +1,5 @@
 import path from 'node:path'
+import MagicString from 'magic-string'
 import { describe, expect } from 'vitest'
 import { ElementDirectory, ElementJsonFile, Module, Product, Project, ProjectDetector, Resource, ResourceDirectory, Uri } from '../index.js'
 
@@ -74,11 +75,25 @@ describe.sequential('projectDetector', (it) => {
     expect(harmonyProject1MainBaseResource).toBeDefined()
   })
 
+  let stringJsonFile: ElementJsonFile
+
   it.sequential('elementDirectory & elementJsonFile.findAll', () => {
     const elementDirectory = ElementDirectory.from(harmonyProject1MainBaseResource)
     const elementJsonFiles = ElementJsonFile.findAll(elementDirectory)
     expect(elementJsonFiles.length).toBeGreaterThanOrEqual(1)
-    const stringJsonFile = elementJsonFiles.find(elementJsonFile => elementJsonFile.getUri().toString().includes('string.json'))!
+    stringJsonFile = elementJsonFiles.find(elementJsonFile => elementJsonFile.getUri().toString().includes('string.json'))!
     expect(stringJsonFile).toBeDefined()
   })
+
+  it.sequential('elementJsonFile.getReference', () => {
+    const references = stringJsonFile.getReference()
+    expect(references.length).toBeGreaterThanOrEqual(1)
+    const ms = new MagicString(stringJsonFile.getContent())
+    for (const reference of references) {
+      expect(ms.slice(reference.getNameStart(), reference.getNameEnd())).toBe(reference.getNameFullText())
+      expect(ms.slice(reference.getValueStart(), reference.getValueEnd())).toBe(reference.getValueFullText())
+      expect(reference.getNameFullText()).toBe(`"${reference.getNameText()}"`)
+      expect(reference.getValueFullText()).toBe(`"${reference.getValueText()}"`)
+    }
+  })
 })