dumpfs_ts/
lib.rs

1mod bindings;
2
3use bindings::*;
4use dumpfs::Subject;
5use napi::bindgen_prelude::{AsyncTask, Result, Task};
6use napi::{Env, Error, Status};
7use std::sync::Arc;
8
9#[macro_use]
10extern crate napi_derive;
11
12#[napi]
13pub struct DumpfsScanData {
14    output: Arc<dumpfs::fs::FsScanOutput>,
15}
16
17#[napi(ts_return_type = "Promise<DumpfsScanData>")]
18pub fn scan(input: String, opts: Option<ScanOpts>) -> AsyncTask<ScanTask> {
19    AsyncTask::new(ScanTask {
20        input,
21        opts: opts.map(Into::into).unwrap_or_default(),
22    })
23}
24
25#[napi]
26impl DumpfsScanData {
27    #[napi(ts_return_type = "Promise<string>")]
28    pub fn llm_text(&self, opts: Option<LlmTextOpts>) -> AsyncTask<LlmTextTask> {
29        AsyncTask::new(LlmTextTask {
30            output: self.output.clone(),
31            opts: opts.map(Into::into).unwrap_or_default(),
32        })
33    }
34}
35
36// --------------------------------------------
37// Tasks
38// --------------------------------------------
39
40pub struct ScanTask {
41    input: String,
42    opts: dumpfs::fs::FsScannerOpts,
43}
44
45#[napi]
46impl Task for ScanTask {
47    type Output = Arc<dumpfs::fs::FsScanOutput>;
48    type JsValue = DumpfsScanData;
49
50    fn compute(&mut self) -> Result<Self::Output> {
51        Subject::new(dumpfs::SubjectOpts {
52            input: self.input.clone(),
53            reporter: None,
54        })
55        .and_then(|v| v.scan(self.opts.clone()))
56        .map(Arc::new)
57        .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))
58    }
59
60    fn resolve(&mut self, _env: Env, output: Self::Output) -> Result<Self::JsValue> {
61        Ok(DumpfsScanData { output })
62    }
63
64    fn reject(&mut self, _env: Env, err: Error) -> Result<Self::JsValue> {
65        Err(err)
66    }
67}
68
69pub struct LlmTextTask {
70    output: Arc<dumpfs::fs::FsScanOutput>,
71    opts: dumpfs::fs::FsFmtOpts,
72}
73
74#[napi]
75impl Task for LlmTextTask {
76    type Output = String;
77    type JsValue = napi::JsString;
78
79    fn compute(&mut self) -> Result<Self::Output> {
80        let mut buf = String::new();
81        self.output
82            .llmtext_to(&mut buf, self.opts.clone())
83            .map_err(|err| Error::new(Status::GenericFailure, err.to_string()))?;
84        Ok(buf)
85    }
86
87    fn resolve(&mut self, mut env: Env, output: Self::Output) -> Result<Self::JsValue> {
88        env.adjust_external_memory(output.len() as i64)?;
89        env.create_string_from_std(output)
90    }
91
92    fn reject(&mut self, _env: Env, err: Error) -> Result<Self::JsValue> {
93        Err(err)
94    }
95}