@jackgreen2018/pdf-engine 1.0.43 → 1.0.45

package/src/lib.rs

@@ -1,294 +0,0 @@
-use wasm_bindgen::prelude::*;
-use js_sys::{Array, Uint8Array};
-use lopdf::{Document, Object, ObjectId};
-use std::collections::BTreeMap;
-
-#[wasm_bindgen]
-pub fn init() -> Result<(), JsValue> {
-    Ok(())
-}
-
-#[wasm_bindgen]
-pub fn get_page_count(buffer: &[u8]) -> Result<u32, JsValue> {
-    let doc = Document::load_mem(buffer)
-        .map_err(|e| JsValue::from_str(&format!("PDF error: {}", e)))?;
-    Ok(doc.get_pages().len().max(1) as u32)
-}
-
-/// Decode PDF hex strings (<HHHH...>) in content stream operators.
-fn decode_hex_strings(content: &str) -> String {
-    let mut result = String::new();
-    let bytes = content.as_bytes();
-    let mut i = 0;
-    while i < bytes.len() {
-        if bytes[i] == b'<' {
-            let mut j = i + 1;
-            while j < bytes.len() && bytes[j] != b'>' {
-                j += 1;
-            }
-            if j > i + 1 && j < bytes.len() {
-                let hex = &content[i+1..j];
-                if hex.len() % 2 == 0 && hex.chars().all(|c| c.is_ascii_hexdigit()) {
-                    let mut buf = Vec::with_capacity(hex.len() / 2);
-                    for k in (0..hex.len()).step_by(2) {
-                        if let Ok(byte) = u8::from_str_radix(&hex[k..k+2], 16) {
-                            buf.push(byte);
-                        }
-                    }
-                    if let Ok(s) = String::from_utf8(buf) {
-                        result.push_str(&s);
-                    }
-                }
-            }
-            i = j + 1;
-        } else {
-            i += 1;
-        }
-    }
-    result
-}
-
-/// Extract text from all content streams by decoding hex strings.
-///
-/// Scans every decompressed stream for <HEX> patterns and decodes them,
-/// bypassing the BT/ET block requirement.
-fn collect_page_text(doc: &Document) -> String {
-    let mut text = String::new();
-
-    for (_id, obj) in doc.objects.iter() {
-        let Object::Stream(ref stream) = obj else { continue };
-        let mut s = stream.clone();
-        let _ = s.decompress();
-        let content = String::from_utf8_lossy(&s.content);
-        if content.is_empty() {
-            continue;
-        }
-
-        let decoded = decode_hex_strings(&content);
-        if !decoded.is_empty() {
-            if !text.is_empty() {
-                text.push('\n');
-            }
-            text.push_str(&decoded);
-        }
-    }
-
-    text
-}
-
-#[wasm_bindgen]
-pub fn extract_text(buffer: &[u8]) -> Result<String, JsValue> {
-    let doc = Document::load_mem(buffer)
-        .map_err(|e| JsValue::from_str(&format!("PDF error: {}", e)))?;
-
-    let text = collect_page_text(&doc);
-
-    if text.is_empty() {
-        Ok("No text extracted.".to_string())
-    } else {
-        Ok(text)
-    }
-}
-
-/// Remap all ObjectId references in `obj` using `id_map`.
-fn remap_refs(obj: &mut Object, id_map: &BTreeMap<ObjectId, ObjectId>) {
-    match obj {
-        Object::Reference(r) => {
-            if let Some(&new_id) = id_map.get(r) {
-                *r = new_id;
-            }
-        }
-        Object::Array(arr) => {
-            for item in arr {
-                remap_refs(item, id_map);
-            }
-        }
-        Object::Dictionary(dict) => {
-            for (_, v) in dict.iter_mut() {
-                remap_refs(v, id_map);
-            }
-        }
-        Object::Stream(stream) => {
-            for (_, v) in stream.dict.iter_mut() {
-                remap_refs(v, id_map);
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Collect all object IDs reachable from `start` in `doc` (including start itself).
-fn collect_reachable(start: ObjectId, doc: &Document, visited: &mut BTreeMap<ObjectId, Object>) {
-    if visited.contains_key(&start) {
-        return;
-    }
-    if let Ok(obj) = doc.get_object(start) {
-        visited.insert(start, obj.clone());
-        walk_refs(&obj, doc, visited);
-    }
-}
-
-/// Walk all references in `obj` and collect reachable objects.
-fn walk_refs(obj: &Object, doc: &Document, visited: &mut BTreeMap<ObjectId, Object>) {
-    match obj {
-        Object::Reference(r) => collect_reachable(*r, doc, visited),
-        Object::Array(arr) => {
-            for item in arr {
-                walk_refs(item, doc, visited);
-            }
-        }
-        Object::Dictionary(dict) => {
-            for (_, v) in dict.iter() {
-                walk_refs(v, doc, visited);
-            }
-        }
-        Object::Stream(stream) => {
-            for (_, v) in stream.dict.iter() {
-                walk_refs(v, doc, visited);
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Copy page at `page_obj_id` from `src` into `dst`, updating all internal references.
-fn copy_page_into(src: &Document, dst: &mut Document, page_obj_id: ObjectId) -> ObjectId {
-    let mut to_copy: BTreeMap<ObjectId, Object> = BTreeMap::new();
-    collect_reachable(page_obj_id, src, &mut to_copy);
-
-    let mut id_map: BTreeMap<ObjectId, ObjectId> = BTreeMap::new();
-    let mut next_id = dst.max_id + 1;
-
-    let mut ids_sorted: Vec<ObjectId> = to_copy.keys().cloned().collect();
-    ids_sorted.sort_by_key(|(x, _)| *x);
-
-    for old_id in ids_sorted {
-        let new_id = loop {
-            let candidate = (next_id, 0);
-            if !dst.objects.contains_key(&candidate) {
-                break candidate;
-            }
-            next_id += 1;
-        };
-        id_map.insert(old_id, new_id);
-        let mut obj = to_copy[&old_id].clone();
-        remap_refs(&mut obj, &id_map);
-        dst.objects.insert(new_id, obj);
-        dst.max_id = next_id.max(dst.max_id);
-    }
-
-    *id_map.get(&page_obj_id).unwrap_or(&(0, 0))
-}
-
-#[wasm_bindgen]
-pub fn merge(pdf_buffers: Array) -> Result<Uint8Array, JsValue> {
-    let len = pdf_buffers.length();
-    if len == 0 {
-        return Ok(Uint8Array::new_from_slice(&[]));
-    }
-
-    let first_buf = pdf_buffers.get(0).dyn_into::<Uint8Array>()
-        .map_err(|_| JsValue::from_str("merge: first item not Uint8Array"))?;
-    let mut doc = Document::load_mem(&first_buf.to_vec())
-        .map_err(|e| JsValue::from_str(&format!("PDF load error: {}", e)))?;
-
-    for i in 1..len {
-        let buf = pdf_buffers.get(i).dyn_into::<Uint8Array>()
-            .map_err(|_| JsValue::from_str("merge: item not Uint8Array"))?;
-        let other = Document::load_mem(&buf.to_vec())
-            .map_err(|e| JsValue::from_str(&format!("PDF load error: {}", e)))?;
-
-        let page_count = doc.get_pages().len() as i64;
-
-        for &page_obj_id in other.get_pages().values() {
-            let new_page_id = copy_page_into(&other, &mut doc, page_obj_id);
-            if let Ok(root_ref) = doc.trailer.get(b"Root").and_then(|r| r.as_reference()) {
-                if let Some(Object::Dictionary(ref mut root_dict)) = doc.objects.get_mut(&root_ref) {
-                    if let Ok(pages_ref) = root_dict.get(b"Pages").and_then(|p| p.as_reference()) {
-                        if let Some(Object::Dictionary(ref mut pages_dict)) = doc.objects.get_mut(&pages_ref) {
-                            if let Ok(kids) = pages_dict.get_mut(b"Kids") {
-                                if let Object::Array(ref mut kids_arr) = kids {
-                                    kids_arr.push(Object::Reference(new_page_id));
-                                }
-                            }
-                            if let Ok(count) = pages_dict.get_mut(b"Count") {
-                                *count = Object::Integer(page_count + 1);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let mut buf = Vec::new();
-    doc.save_to(&mut buf).map_err(|e| JsValue::from_str(&format!("PDF save error: {}", e)))?;
-    Ok(Uint8Array::new_from_slice(&buf))
-}
-
-#[wasm_bindgen]
-pub fn split(buffer: &[u8], pages: Array) -> Result<Array, JsValue> {
-    let doc = Document::load_mem(buffer)
-        .map_err(|e| JsValue::from_str(&format!("PDF error: {}", e)))?;
-    let page_len = pages.length();
-
-    let page_map: BTreeMap<u32, ObjectId> = doc.get_pages();
-    let results = Array::new();
-
-    for i in 0..page_len {
-        let page_num = pages.get(i).as_f64().unwrap_or(0.0) as u32;
-        // PDF page numbers are 1-based internally
-        let Some(&page_obj_id) = page_map.get(&(page_num + 1)) else { continue };
-
-        let mut new_doc = Document::with_version("1.5");
-        let new_page_id = copy_page_into(&doc, &mut new_doc, page_obj_id);
-
-        // Build the page tree: Pages -> [page], Catalog -> Pages
-        let pages_id = (new_doc.max_id + 1, 0);
-        let catalog_id = (new_doc.max_id + 2, 0);
-
-        let pages_dict = lopdf::dictionary! {
-            "Type" => "Pages",
-            "Kids" => vec![Object::Reference(new_page_id)],
-            "Count" => 1
-        };
-        new_doc.objects.insert(pages_id, Object::Dictionary(pages_dict));
-        new_doc.max_id = pages_id.0.max(new_doc.max_id);
-
-        let catalog_dict = lopdf::dictionary! {
-            "Type" => "Catalog",
-            "Pages" => Object::Reference(pages_id)
-        };
-        new_doc.objects.insert(catalog_id, Object::Dictionary(catalog_dict));
-        new_doc.max_id = catalog_id.0.max(new_doc.max_id);
-        new_doc.trailer.set("Root", Object::Reference(catalog_id));
-
-        let mut pdf_bytes = Vec::new();
-        let _ = new_doc.save_to(&mut pdf_bytes);
-        results.push(&Uint8Array::new_from_slice(&pdf_bytes).into());
-    }
-
-    if results.length() == 0 {
-        results.push(&Uint8Array::new_from_slice(&[]).into());
-    }
-
-    Ok(results)
-}
-
-#[wasm_bindgen]
-pub fn get_pdf_info(buffer: &[u8]) -> Result<String, JsValue> {
-    let count = get_page_count(buffer)?;
-    Ok(format!("PDF with {} pages", count))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn page_count_of_empty_doc_is_one() {
-        // ponytail: lopdf get_pages() returns empty map for docs with no pages
-        let doc = Document::with_version("1.5");
-        assert_eq!(doc.get_pages().len().max(1), 1);
-    }
-}