kreuzberg 4.0.0.pre.rc.6 → 4.0.0.pre.rc.7

data/vendor/kreuzberg/src/pdf/metadata.rs

@@ -1,46 +1,91 @@
 use super::error::{PdfError, Result};
+use crate::types::{PageBoundary, PageInfo, PageStructure, PageUnitType};
 use pdfium_render::prelude::*;
 use serde::{Deserialize, Serialize};
 
+/// PDF-specific metadata.
+///
+/// Contains metadata fields specific to PDF documents that are not in the common
+/// `Metadata` structure. Common fields like title, authors, keywords, and dates
+/// are now at the `Metadata` level.
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct PdfMetadata {
+    /// PDF version (e.g., "1.7", "2.0")
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pdf_version: Option<String>,
+
+    /// PDF producer (application that created the PDF)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub producer: Option<String>,
+
+    /// Whether the PDF is encrypted/password-protected
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub is_encrypted: Option<bool>,
+
+    /// First page width in points (1/72 inch)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub width: Option<i64>,
+
+    /// First page height in points (1/72 inch)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub height: Option<i64>,
+}
+
+/// Complete PDF extraction metadata including common and PDF-specific fields.
+///
+/// This struct combines common document fields (title, authors, dates) with
+/// PDF-specific metadata and optional page structure information. It is returned
+/// by `extract_metadata_from_document()` when page boundaries are provided.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PdfExtractionMetadata {
+    /// Document title
     #[serde(skip_serializing_if = "Option::is_none")]
     pub title: Option<String>,
+
+    /// Document subject or description
     #[serde(skip_serializing_if = "Option::is_none")]
     pub subject: Option<String>,
+
+    /// Document authors (parsed from PDF Author field)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub authors: Option<Vec<String>>,
+
+    /// Document keywords (parsed from PDF Keywords field)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub keywords: Option<Vec<String>>,
+
+    /// Creation timestamp (ISO 8601 format)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub created_at: Option<String>,
+
+    /// Last modification timestamp (ISO 8601 format)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub modified_at: Option<String>,
+
+    /// Application or user that created the document
     #[serde(skip_serializing_if = "Option::is_none")]
     pub created_by: Option<String>,
+
+    /// PDF-specific metadata
+    pub pdf_specific: PdfMetadata,
+
+    /// Page structure with boundaries and optional per-page metadata
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub producer: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub page_count: Option<usize>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pdf_version: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_encrypted: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub width: Option<i64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub height: Option<i64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub summary: Option<String>,
+    pub page_structure: Option<PageStructure>,
 }
 
+/// Extract PDF-specific metadata from raw bytes.
+///
+/// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
 pub fn extract_metadata(pdf_bytes: &[u8]) -> Result<PdfMetadata> {
     extract_metadata_with_password(pdf_bytes, None)
 }
 
+/// Extract PDF-specific metadata from raw bytes with optional password.
+///
+/// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
 pub fn extract_metadata_with_password(pdf_bytes: &[u8], password: Option<&str>) -> Result<PdfMetadata> {
-    let bindings = Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./"))
-        .or_else(|_| Pdfium::bind_to_system_library())
+    let bindings = Pdfium::bind_to_system_library()
         .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to initialize Pdfium: {}", e)))?;
 
     let pdfium = Pdfium::new(bindings);
@@ -56,7 +101,7 @@ pub fn extract_metadata_with_password(pdf_bytes: &[u8], password: Option<&str>)
         }
     })?;
 
-    extract_metadata_from_document(&document)
+    extract_pdf_specific_metadata(&document)
 }
 
 pub fn extract_metadata_with_passwords(pdf_bytes: &[u8], passwords: &[&str]) -> Result<PdfMetadata> {
@@ -79,70 +124,197 @@ pub fn extract_metadata_with_passwords(pdf_bytes: &[u8], passwords: &[&str]) ->
     extract_metadata(pdf_bytes)
 }
 
-pub(crate) fn extract_metadata_from_document(document: &PdfDocument<'_>) -> Result<PdfMetadata> {
+/// Extract complete PDF metadata from a document.
+///
+/// Extracts common fields (title, subject, authors, keywords, dates, creator),
+/// PDF-specific metadata, and optionally builds a PageStructure with boundaries.
+///
+/// # Arguments
+///
+/// * `document` - The PDF document to extract metadata from
+/// * `page_boundaries` - Optional vector of PageBoundary entries for building PageStructure.
+///   If provided, a PageStructure will be built with these boundaries.
+///
+/// # Returns
+///
+/// Returns a `PdfExtractionMetadata` struct containing all extracted metadata,
+/// including page structure if boundaries were provided.
+pub fn extract_metadata_from_document(
+    document: &PdfDocument<'_>,
+    page_boundaries: Option<&[PageBoundary]>,
+) -> Result<PdfExtractionMetadata> {
+    let pdf_specific = extract_pdf_specific_metadata(document)?;
+
+    let common = extract_common_metadata_from_document(document)?;
+
+    let page_structure = if let Some(boundaries) = page_boundaries {
+        Some(build_page_structure(document, boundaries)?)
+    } else {
+        None
+    };
+
+    Ok(PdfExtractionMetadata {
+        title: common.title,
+        subject: common.subject,
+        authors: common.authors,
+        keywords: common.keywords,
+        created_at: common.created_at,
+        modified_at: common.modified_at,
+        created_by: common.created_by,
+        pdf_specific,
+        page_structure,
+    })
+}
+
+/// Extract PDF-specific metadata from a document.
+///
+/// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
+fn extract_pdf_specific_metadata(document: &PdfDocument<'_>) -> Result<PdfMetadata> {
     let pdf_metadata = document.metadata();
 
     let mut metadata = PdfMetadata {
         pdf_version: format_pdf_version(document.version()),
         ..Default::default()
     };
-    metadata.page_count = Some(document.pages().len() as usize);
+
     metadata.is_encrypted = document
         .permissions()
         .security_handler_revision()
         .ok()
         .map(|revision| revision != PdfSecurityHandlerRevision::Unprotected);
 
-    metadata.title = pdf_metadata
-        .get(PdfDocumentMetadataTagType::Title)
-        .map(|tag| tag.value().to_string());
-
-    metadata.subject = pdf_metadata
-        .get(PdfDocumentMetadataTagType::Subject)
+    metadata.producer = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Producer)
         .map(|tag| tag.value().to_string());
 
-    if let Some(author_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::Author) {
-        let authors = parse_authors(author_tag.value());
-        if !authors.is_empty() {
-            metadata.authors = Some(authors);
-        }
+    if !document.pages().is_empty()
+        && let Ok(page_rect) = document.pages().page_size(0)
+    {
+        metadata.width = Some(page_rect.width().value.round() as i64);
+        metadata.height = Some(page_rect.height().value.round() as i64);
     }
 
-    if let Some(keywords_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::Keywords) {
-        let keywords = parse_keywords(keywords_tag.value());
-        if !keywords.is_empty() {
-            metadata.keywords = Some(keywords);
-        }
+    Ok(metadata)
+}
+
+/// Build a PageStructure from a document and page boundaries.
+///
+/// Constructs a complete PageStructure including:
+/// - Total page count
+/// - Unit type (Page)
+/// - Character offset boundaries for each page
+/// - Optional per-page metadata with dimensions
+///
+/// # Validation
+///
+/// - Boundaries must not be empty
+/// - Boundary count must match the document's page count
+fn build_page_structure(document: &PdfDocument<'_>, boundaries: &[PageBoundary]) -> Result<PageStructure> {
+    let total_count = document.pages().len() as usize;
+
+    if boundaries.is_empty() {
+        return Err(PdfError::MetadataExtractionFailed(
+            "No page boundaries provided for PageStructure".to_string(),
+        ));
     }
 
-    if let Some(created_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::CreationDate) {
-        metadata.created_at = Some(parse_pdf_date(created_tag.value()));
+    if boundaries.len() != total_count {
+        return Err(PdfError::MetadataExtractionFailed(format!(
+            "Boundary count {} doesn't match page count {}",
+            boundaries.len(),
+            total_count
+        )));
     }
 
-    if let Some(modified_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::ModificationDate) {
-        metadata.modified_at = Some(parse_pdf_date(modified_tag.value()));
+    let mut pages = Vec::new();
+    for (index, boundary) in boundaries.iter().enumerate() {
+        let page_number = boundary.page_number;
+
+        let dimensions = if let Ok(page_rect) = document.pages().page_size(index as u16) {
+            Some((page_rect.width().value as f64, page_rect.height().value as f64))
+        } else {
+            None
+        };
+
+        pages.push(PageInfo {
+            number: page_number,
+            title: None,
+            dimensions,
+            image_count: None,
+            table_count: None,
+            hidden: None,
+        });
     }
 
-    metadata.created_by = pdf_metadata
-        .get(PdfDocumentMetadataTagType::Creator)
+    Ok(PageStructure {
+        total_count,
+        unit_type: PageUnitType::Page,
+        boundaries: Some(boundaries.to_vec()),
+        pages: if pages.is_empty() { None } else { Some(pages) },
+    })
+}
+
+/// Extract common metadata from a PDF document.
+///
+/// Returns common fields (title, authors, keywords, dates) that are now stored
+/// in the base `Metadata` struct instead of format-specific metadata.
+pub fn extract_common_metadata_from_document(document: &PdfDocument<'_>) -> Result<CommonPdfMetadata> {
+    let pdf_metadata = document.metadata();
+
+    let title = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Title)
         .map(|tag| tag.value().to_string());
 
-    metadata.producer = pdf_metadata
-        .get(PdfDocumentMetadataTagType::Producer)
+    let subject = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Subject)
         .map(|tag| tag.value().to_string());
 
-    if !document.pages().is_empty()
-        && let Ok(page_rect) = document.pages().page_size(0)
-    {
-        metadata.width = Some(page_rect.width().value.round() as i64);
-        metadata.height = Some(page_rect.height().value.round() as i64);
-    }
+    let authors = if let Some(author_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::Author) {
+        let parsed = parse_authors(author_tag.value());
+        if !parsed.is_empty() { Some(parsed) } else { None }
+    } else {
+        None
+    };
 
-    if metadata.summary.is_none() {
-        metadata.summary = Some(generate_summary(&metadata));
-    }
+    let keywords = if let Some(keywords_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::Keywords) {
+        let parsed = parse_keywords(keywords_tag.value());
+        if !parsed.is_empty() { Some(parsed) } else { None }
+    } else {
+        None
+    };
 
-    Ok(metadata)
+    let created_at = pdf_metadata
+        .get(PdfDocumentMetadataTagType::CreationDate)
+        .map(|tag| parse_pdf_date(tag.value()));
+
+    let modified_at = pdf_metadata
+        .get(PdfDocumentMetadataTagType::ModificationDate)
+        .map(|tag| parse_pdf_date(tag.value()));
+
+    let created_by = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Creator)
+        .map(|tag| tag.value().to_string());
+
+    Ok(CommonPdfMetadata {
+        title,
+        subject,
+        authors,
+        keywords,
+        created_at,
+        modified_at,
+        created_by,
+    })
+}
+
+/// Common metadata fields extracted from a PDF.
+pub struct CommonPdfMetadata {
+    pub title: Option<String>,
+    pub subject: Option<String>,
+    pub authors: Option<Vec<String>>,
+    pub keywords: Option<Vec<String>>,
+    pub created_at: Option<String>,
+    pub modified_at: Option<String>,
+    pub created_by: Option<String>,
 }
 
 fn parse_authors(author_str: &str) -> Vec<String> {
@@ -206,25 +378,6 @@ fn parse_pdf_date(date_str: &str) -> String {
     }
 }
 
-fn generate_summary(metadata: &PdfMetadata) -> String {
-    let mut parts = Vec::new();
-
-    if let Some(page_count) = metadata.page_count {
-        let plural = if page_count != 1 { "s" } else { "" };
-        parts.push(format!("PDF document with {} page{}.", page_count, plural));
-    }
-
-    if let Some(ref version) = metadata.pdf_version {
-        parts.push(format!("PDF version {}.", version));
-    }
-
-    if metadata.is_encrypted == Some(true) {
-        parts.push("Document is encrypted.".to_string());
-    }
-
-    parts.join(" ")
-}
-
 fn format_pdf_version(version: PdfDocumentVersion) -> Option<String> {
     match version {
         PdfDocumentVersion::Unset => None,
@@ -312,35 +465,25 @@ mod tests {
     }
 
     #[test]
-    fn test_generate_summary() {
-        let metadata = PdfMetadata {
-            page_count: Some(10),
-            pdf_version: Some("1.7".to_string()),
-            is_encrypted: Some(false),
-            ..Default::default()
-        };
-
-        let summary = generate_summary(&metadata);
-        assert!(summary.contains("10 pages"));
-        assert!(summary.contains("1.7"));
-        assert!(!summary.contains("encrypted"));
+    fn test_extract_metadata_invalid_pdf() {
+        let result = extract_metadata(b"not a pdf");
+        assert!(result.is_err());
     }
 
     #[test]
-    fn test_generate_summary_single_page() {
-        let metadata = PdfMetadata {
-            page_count: Some(1),
-            ..Default::default()
-        };
-
-        let summary = generate_summary(&metadata);
-        assert!(summary.contains("1 page."));
-        assert!(!summary.contains("pages"));
+    fn test_build_page_structure_empty_boundaries() {
+        let result_msg = "No page boundaries provided for PageStructure".to_string();
+        assert!(!result_msg.is_empty());
     }
 
     #[test]
-    fn test_extract_metadata_invalid_pdf() {
-        let result = extract_metadata(b"not a pdf");
-        assert!(result.is_err());
+    fn test_build_page_structure_boundary_mismatch_message() {
+        let boundaries_count = 3;
+        let page_count = 5;
+        let error_msg = format!(
+            "Boundary count {} doesn't match page count {}",
+            boundaries_count, page_count
+        );
+        assert_eq!(error_msg, "Boundary count 3 doesn't match page count 5");
     }
 }

data/vendor/kreuzberg/src/pdf/mod.rs

@@ -26,25 +26,37 @@
 //!
 //! // Extract metadata
 //! let metadata = extract_metadata(&pdf_bytes)?;
-//! println!("Page count: {:?}", metadata.page_count);
+//! println!("PDF version: {:?}", metadata.pdf_version);
 //! # Ok(())
 //! # }
 //! ```
 //!
 //! # Note
 //!
-//! This module is always available. The `ocr` feature enables additional
+//! This module requires the `pdf` feature. The `ocr` feature enables additional
 //! functionality in the PDF extractor for rendering pages to images.
+#[cfg(feature = "pdf")]
 pub mod error;
+#[cfg(feature = "pdf")]
 pub mod images;
+#[cfg(feature = "pdf")]
 pub mod metadata;
+#[cfg(feature = "pdf")]
 pub mod rendering;
+#[cfg(feature = "pdf")]
 pub mod table;
+#[cfg(feature = "pdf")]
 pub mod text;
 
+#[cfg(feature = "pdf")]
 pub use error::PdfError;
+#[cfg(feature = "pdf")]
 pub use images::{PdfImage, PdfImageExtractor, extract_images_from_pdf};
+#[cfg(feature = "pdf")]
 pub use metadata::extract_metadata;
+#[cfg(feature = "pdf")]
 pub use rendering::{PageRenderOptions, render_page_to_image};
+#[cfg(feature = "pdf")]
 pub use table::extract_words_from_page;
+#[cfg(feature = "pdf")]
 pub use text::extract_text_from_pdf;

data/vendor/kreuzberg/src/pdf/rendering.rs

@@ -32,8 +32,7 @@ pub struct PdfRenderer {
 
 impl PdfRenderer {
     pub fn new() -> Result<Self> {
-        let binding = Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./"))
-            .or_else(|_| Pdfium::bind_to_system_library())
+        let binding = Pdfium::bind_to_system_library()
             .map_err(|e| PdfError::RenderingFailed(format!("Failed to initialize Pdfium: {}", e)))?;
 
         let pdfium = Pdfium::new(binding);

data/vendor/kreuzberg/src/pdf/table.rs

@@ -2,9 +2,12 @@
 //!
 //! This module converts pdfium character data to HocrWord format,
 //! allowing us to reuse the existing table reconstruction logic.
+//!
+//! Note: Table extraction requires the "ocr" feature and is not available in WASM builds.
 
 use super::error::{PdfError, Result};
-use html_to_markdown_rs::hocr::HocrWord;
+#[cfg(feature = "ocr")]
+use crate::ocr::table::HocrWord;
 use pdfium_render::prelude::*;
 
 /// Spacing threshold for word boundary detection (in PDF units).
@@ -29,9 +32,14 @@ const MIN_WORD_LENGTH: usize = 1;
 ///
 /// Vector of HocrWord objects with text and bounding box information.
 ///
+/// # Note
+/// This function requires the "ocr" feature to be enabled. Without it, returns an error.
+///
 /// # Example
 ///
 /// ```rust,no_run
+/// # #[cfg(feature = "ocr")]
+/// # {
 /// use kreuzberg::pdf::table::extract_words_from_page;
 /// use pdfium_render::prelude::*;
 ///
@@ -42,7 +50,9 @@ const MIN_WORD_LENGTH: usize = 1;
 /// let words = extract_words_from_page(&page, 90.0)?;
 /// # Ok(())
 /// # }
+/// # }
 /// ```
+#[cfg(feature = "ocr")]
 pub fn extract_words_from_page(page: &PdfPage, min_confidence: f64) -> Result<Vec<HocrWord>> {
     let page_width = page.width().value as i32;
     let page_height = page.height().value as i32;
@@ -58,6 +68,17 @@ pub fn extract_words_from_page(page: &PdfPage, min_confidence: f64) -> Result<Ve
     Ok(words)
 }
 
+/// Fallback implementation when OCR feature is disabled.
+///
+/// # Errors
+/// Always returns an error indicating that the OCR feature is required.
+#[cfg(not(feature = "ocr"))]
+pub fn extract_words_from_page(_page: &PdfPage, _min_confidence: f64) -> Result<Vec<()>> {
+    Err(PdfError::TextExtractionFailed(
+        "PDF table extraction requires the 'ocr' feature to be enabled".to_string(),
+    ))
+}
+
 /// Character with position information extracted from PDF.
 #[derive(Debug, Clone)]
 struct CharInfo {
@@ -80,6 +101,7 @@ struct CharInfo {
 /// * `page_width` - Page width in PDF units
 /// * `page_height` - Page height in PDF units
 /// * `min_confidence` - Minimum confidence threshold (PDF text uses 95.0)
+#[cfg(feature = "ocr")]
 fn group_chars_into_words(
     chars: PdfPageTextChars,
     _page_width: i32,
@@ -139,6 +161,7 @@ fn group_chars_into_words(
 ///
 /// Returns true if the character is far from the previous character
 /// (indicating a word boundary) or on a different line.
+#[cfg(feature = "ocr")]
 fn should_start_new_word(current_word_chars: &[CharInfo], new_char: &CharInfo) -> bool {
     if current_word_chars.is_empty() {
         return false;
@@ -159,6 +182,7 @@ fn should_start_new_word(current_word_chars: &[CharInfo], new_char: &CharInfo) -
 ///
 /// Calculates bounding box and confidence for the word.
 /// Returns None if the word doesn't meet minimum criteria.
+#[cfg(feature = "ocr")]
 fn finalize_word(chars: &[CharInfo], page_height: i32, min_confidence: f64) -> Option<HocrWord> {
     if chars.is_empty() {
         return None;
@@ -212,7 +236,7 @@ fn finalize_word(chars: &[CharInfo], page_height: i32, min_confidence: f64) -> O
     })
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "ocr"))]
 mod tests {
     use super::*;