新增 callback

.vscode/settings.json

@@ -1,6 +1,7 @@
 {
     "cSpell.words": [
         "napi",
+        "Threadsafe",
         "vistor"
     ]
 }

__test__/fixtures/demo2.ts

@@ -0,0 +1,7 @@
+export CompositionReport from './CompositionReport'
+export SupplierColorCodeInput from './SupplierColorCodeInput'
+export MarketFlowerSelect from './MarketFlowerSelect'
+
+export FlowerCodeSelect from './FlowerCodeSelect'
+
+export NewNBarcodes from './new-barcodes';

__test__/index.spec.mjs

@@ -11,8 +11,13 @@ const __dirname = dirname(__filename);
 
 test('should to be array of len is 4', (t) => {
   const start = performance.now()
-  const res = inspectPackageUsage("shineout",path.join(__dirname,"fixtures"));
+  // let errorCount = 0;
+  const res = inspectPackageUsage("shineout",path.join(__dirname,"fixtures"),(v) => {
+    console.log("--->",v);
+    // errorCount++;
+  });
   const end = performance.now()
   console.log(`inspectPackageUsage cost ${end - start} ms`);
   t.is(res.length, 4);
+  // t.is(errorCount, 1);
 })

index.d.ts

@@ -3,4 +3,4 @@
 
 /* auto-generated by NAPI-RS */
 
-export function inspectPackageUsage(packageName: string, workspace: string): NapiResult
+export function inspectPackageUsage(packageName: string, workspace: string, callback: (...args: any[]) => any): NapiResult

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shined/package-exported-usage",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {

src/lib.rs

@@ -1,7 +1,10 @@
 #![deny(clippy::all)]
 
 use crate::vistor::ImportVisitor;
-use napi::Result as NapiResult;
+use napi::threadsafe_function::{
+  ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+};
+use napi::{JsFunction, Result as NapiResult};
 use rayon::prelude::*;
 use serde_json::json;
 use std::{
@@ -32,75 +35,87 @@ static PATTERN: &str = "**/*.{js,ts,jsx,tsx}";
 pub fn inspect_package_usage(
   package_name: String,
   workspace: String,
+  callback: JsFunction,
 ) -> NapiResult<serde_json::Value> {
-  let glob = Glob::new(PATTERN).unwrap();
+  let fns: ThreadsafeFunction<String, ErrorStrategy::Fatal> = callback
+    .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<String>| {
+      ctx.env.create_string(&ctx.value).map(|v| vec![v])
+    })?;
 
-  // let map = Arc::new(Mutex::new(HashMap::<String, usize>::new()));
+  let glob = Glob::new(PATTERN).unwrap();
 
   let vec = Arc::new(Mutex::new(Vec::<PackageExportedUsage>::new()));
 
-  let entries = glob
-    .walk(workspace)
+  if let Ok(entries) = glob
+    .walk(&workspace)
     .not(["**/node_modules/**", "**/*.d.ts"])
-    .unwrap();
-
-  entries.par_bridge().for_each(|entry| {
-    let e = entry.unwrap();
-    let path = e.path();
-
-    let cm = Arc::<SourceMap>::default();
-
-    let content = read_to_string(path).unwrap();
-
-    let fm = cm.new_source_file(FileName::Anon, content);
-
-    let lexer = Lexer::new(
-      Syntax::Typescript(TsConfig {
-        tsx: true,
-        decorators: true,
-        dts: false,
-        no_early_errors: false,
-        ..Default::default()
-      }),
-      EsVersion::EsNext,
-      StringInput::from(&*fm),
-      None,
-    );
+  {
+    entries.par_bridge().for_each(|entry| {
+      let e = entry.unwrap();
+      let path = e.path();
+
+      let cm = Arc::<SourceMap>::default();
+
+      if let Ok(content) = read_to_string(path) {
+        let fm = cm.new_source_file(FileName::Anon, content);
+
+        let lexer = Lexer::new(
+          Syntax::Typescript(TsConfig {
+            tsx: true,
+            decorators: true,
+            dts: false,
+            no_early_errors: false,
+            ..Default::default()
+          }),
+          EsVersion::EsNext,
+          StringInput::from(&*fm),
+          None,
+        );
+
+        let mut parser = Parser::new_from(lexer);
+
+        let list_error = parser.take_errors();
+        if list_error.iter().len() > 0 {
+          let err_msg = list_error
+            .iter()
+            .map(|err| err.kind().msg())
+            .collect::<Vec<_>>()
+            .join("");
+          println!("Error: {:?}", err_msg);
+        }
 
-    let mut parser = Parser::new_from(lexer);
-
-    let list_error = parser.take_errors();
-    if list_error.iter().len() > 0 {
-      let err_msg = list_error
-        .iter()
-        .map(|err| err.kind().msg())
-        .collect::<Vec<_>>()
-        .join("");
-      println!("Error: {:?}", err_msg);
-    }
-
-    match parser.parse_program() {
-      Ok(module_result) => {
-        let mut import_controller = ImportVisitor {
-          package_name: package_name.clone(),
-          imports: vec![],
-        };
-        module_result.visit_with(&mut import_controller);
-        // let mut map = map.lock().unwrap();
-        let mut vec = vec.lock().unwrap();
-        for import in import_controller.imports {
-          vec.push(PackageExportedUsage {
-            file_path: path.display().to_string(),
-            exported_name: import,
-          })
-          // *map.entry(import).or_insert(0) += 1;
+        if let Ok(module_result) = parser.parse_program() {
+          let mut import_controller = ImportVisitor {
+            package_name: package_name.clone(),
+            imports: vec![],
+          };
+          module_result.visit_with(&mut import_controller);
+          let mut vec = vec.lock().unwrap();
+          for import in import_controller.imports {
+            vec.push(PackageExportedUsage {
+              file_path: path.display().to_string(),
+              exported_name: import,
+            })
+          }
+        } else {
+          fns.call(
+            format!("parse file {} fail", path.display()),
+            ThreadsafeFunctionCallMode::Blocking,
+          );
         }
+      } else {
+        fns.call(
+          format!("read file {} fail", path.display()),
+          ThreadsafeFunctionCallMode::Blocking,
+        );
       }
-      Err(error) => {
-        println!("Error: {:?} {:?}", error, path);
-      }
-    }
-  });
+    });
+  } else {
+    fns.call(
+      format!("glob workspace {} fail", &workspace),
+      ThreadsafeFunctionCallMode::Blocking,
+    );
+  }
 
   let vec = vec.lock().unwrap().clone();