anytomd 1.2.2

Pure Rust library that converts various document formats into Markdown
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! WebAssembly bindings for anytomd via `wasm-bindgen`.
//!
//! Provides `convertBytes` and `convertBytesWithOptions` for use from JavaScript.
//! When the `async-gemini` feature is also enabled, `convertBytesWithGemini` is
//! available for async conversion with Gemini-powered image descriptions.
//!
//! All functions return a JS object with `markdown`, `plainText`, `title`, and
//! `warnings` fields.

use wasm_bindgen::prelude::*;

use crate::convert_bytes;
use crate::converter::{ConversionOptions, ConversionResult};

/// Convert raw document bytes to Markdown from JavaScript.
///
/// # Arguments
///
/// * `data` - Raw file bytes as a `Uint8Array`
/// * `extension` - File format extension (e.g., `"docx"`, `"csv"`, `"html"`)
///
/// # Returns
///
/// A JS object with fields: `markdown` (string), `plainText` (string),
/// `title` (string or null), `warnings` (array of strings).
#[wasm_bindgen(js_name = "convertBytes")]
pub fn convert_bytes_wasm(data: &[u8], extension: &str) -> Result<JsValue, JsError> {
    let options = ConversionOptions::default();
    let result =
        convert_bytes(data, extension, &options).map_err(|e| JsError::new(&e.to_string()))?;
    convert_result_to_js(&result)
}

/// Convert raw document bytes to Markdown with options from JavaScript.
///
/// # Arguments
///
/// * `data` - Raw file bytes as a `Uint8Array`
/// * `extension` - File format extension (e.g., `"docx"`, `"csv"`, `"html"`)
/// * `strict` - If `true`, treat recoverable parse errors as hard errors
///
/// # Returns
///
/// A JS object with fields: `markdown` (string), `plainText` (string),
/// `title` (string or null), `warnings` (array of strings).
#[wasm_bindgen(js_name = "convertBytesWithOptions")]
pub fn convert_bytes_with_options_wasm(
    data: &[u8],
    extension: &str,
    strict: bool,
) -> Result<JsValue, JsError> {
    let options = ConversionOptions {
        strict,
        ..Default::default()
    };
    let result =
        convert_bytes(data, extension, &options).map_err(|e| JsError::new(&e.to_string()))?;
    convert_result_to_js(&result)
}

/// Convert raw document bytes to Markdown with Gemini-powered image descriptions.
///
/// This is an async function that creates an `AsyncGeminiDescriber` with the
/// given API key and uses `convert_bytes_async` to resolve image descriptions
/// concurrently via the Gemini API.
///
/// # Arguments
///
/// * `data` - Raw file bytes as a `Uint8Array`
/// * `extension` - File format extension (e.g., `"docx"`, `"pptx"`, `"xlsx"`)
/// * `api_key` - Google Gemini API key
/// * `model` - Optional Gemini model name (defaults to `gemini-3-flash-preview`)
///
/// # Returns
///
/// A Promise that resolves to a JS object with fields: `markdown` (string),
/// `plainText` (string), `title` (string or null), `warnings` (array of strings).
#[cfg(feature = "async-gemini")]
#[wasm_bindgen(js_name = "convertBytesWithGemini")]
pub async fn convert_bytes_with_gemini_wasm(
    data: &[u8],
    extension: &str,
    api_key: &str,
    model: Option<String>,
) -> Result<JsValue, JsError> {
    use std::sync::Arc;

    use crate::convert_bytes_async;
    use crate::converter::AsyncConversionOptions;
    use crate::gemini::AsyncGeminiDescriber;

    let describer = match model {
        Some(m) => AsyncGeminiDescriber::new(api_key.to_string()).with_model(m),
        None => AsyncGeminiDescriber::new(api_key.to_string()),
    };

    let options = AsyncConversionOptions {
        async_image_describer: Some(Arc::new(describer)),
        ..Default::default()
    };

    let result = convert_bytes_async(data, extension, &options)
        .await
        .map_err(|e| JsError::new(&e.to_string()))?;
    convert_result_to_js(&result)
}

/// Convert a `ConversionResult` into a JS object.
fn convert_result_to_js(result: &ConversionResult) -> Result<JsValue, JsError> {
    let obj = js_sys::Object::new();

    js_sys::Reflect::set(&obj, &"markdown".into(), &result.markdown.as_str().into())
        .map_err(|_| JsError::new("failed to set markdown property"))?;
    js_sys::Reflect::set(
        &obj,
        &"plainText".into(),
        &result.plain_text.as_str().into(),
    )
    .map_err(|_| JsError::new("failed to set plainText property"))?;
    js_sys::Reflect::set(
        &obj,
        &"title".into(),
        &match result.title {
            Some(ref t) => JsValue::from_str(t),
            None => JsValue::NULL,
        },
    )
    .map_err(|_| JsError::new("failed to set title property"))?;

    let warnings_arr = js_sys::Array::new();
    for w in &result.warnings {
        let msg = match &w.location {
            Some(loc) => format!("[{:?}] {} ({})", w.code, w.message, loc),
            None => format!("[{:?}] {}", w.code, w.message),
        };
        warnings_arr.push(&msg.into());
    }
    js_sys::Reflect::set(&obj, &"warnings".into(), &warnings_arr.into())
        .map_err(|_| JsError::new("failed to set warnings property"))?;

    Ok(obj.into())
}