html-to-markdown 2.30.0 → 3.0.1

data/vendor/html-to-markdown-rs/src/visitor/async_traits.rs

@@ -1,249 +0,0 @@
-//! Asynchronous visitor trait for HTML to Markdown conversion.
-//!
-//! This module contains the `AsyncHtmlVisitor` trait for async/await based visitation.
-
-#[cfg(feature = "async-visitor")]
-use async_trait::async_trait;
-
-use super::types::{NodeContext, VisitResult};
-
-/// Async visitor trait for HTML→Markdown conversion.
-///
-/// This trait is identical to `HtmlVisitor` but all methods are async. Use this for languages
-/// with native async/await support:
-/// - Python (with `async def` and `asyncio`)
-/// - TypeScript/JavaScript (with `Promise`-based callbacks)
-/// - Elixir (with message-passing processes)
-///
-/// For synchronous languages (Ruby, PHP, Go, Java, C#), use the sync `HtmlVisitor` trait.
-///
-/// # Example (Python-like)
-///
-/// ```ignore
-/// use html_to_markdown_rs::visitor::{AsyncHtmlVisitor, NodeContext, VisitResult};
-///
-/// struct CustomAsyncVisitor;
-///
-/// #[async_trait::async_trait]
-/// impl AsyncHtmlVisitor for CustomAsyncVisitor {
-///     async fn visit_link(
-///         &mut self,
-///         ctx: &NodeContext,
-///         href: &str,
-///         text: &str,
-///         title: Option<&str>,
-///     ) -> VisitResult {
-///         // Can await async operations here
-///         VisitResult::Custom(format!("{} ({})", text, href))
-///     }
-/// }
-/// ```
-#[cfg(feature = "async-visitor")]
-#[async_trait]
-pub trait AsyncHtmlVisitor: std::fmt::Debug + Send + Sync {
-    /// Called before entering any element (async version).
-    async fn visit_element_start(&mut self, _ctx: &NodeContext) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called after exiting any element (async version).
-    async fn visit_element_end(&mut self, _ctx: &NodeContext, _output: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit text nodes (async version - most frequent callback - ~100+ per document).
-    async fn visit_text(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit anchor links `<a href="...">` (async version).
-    async fn visit_link(&mut self, _ctx: &NodeContext, _href: &str, _text: &str, _title: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit images `<img src="...">` (async version).
-    async fn visit_image(&mut self, _ctx: &NodeContext, _src: &str, _alt: &str, _title: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit heading elements `<h1>` through `<h6>` (async version).
-    async fn visit_heading(&mut self, _ctx: &NodeContext, _level: u32, _text: &str, _id: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit code blocks `<pre><code>` (async version).
-    async fn visit_code_block(&mut self, _ctx: &NodeContext, _lang: Option<&str>, _code: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit inline code `<code>` (async version).
-    async fn visit_code_inline(&mut self, _ctx: &NodeContext, _code: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit list items `<li>` (async version).
-    async fn visit_list_item(&mut self, _ctx: &NodeContext, _ordered: bool, _marker: &str, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called before processing a list `<ul>` or `<ol>` (async version).
-    async fn visit_list_start(&mut self, _ctx: &NodeContext, _ordered: bool) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called after processing a list `</ul>` or `</ol>` (async version).
-    async fn visit_list_end(&mut self, _ctx: &NodeContext, _ordered: bool, _output: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called before processing a table `<table>` (async version).
-    async fn visit_table_start(&mut self, _ctx: &NodeContext) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit table rows `<tr>` (async version).
-    async fn visit_table_row(&mut self, _ctx: &NodeContext, _cells: &[String], _is_header: bool) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called after processing a table `</table>` (async version).
-    async fn visit_table_end(&mut self, _ctx: &NodeContext, _output: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit blockquote elements `<blockquote>` (async version).
-    async fn visit_blockquote(&mut self, _ctx: &NodeContext, _content: &str, _depth: usize) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit strong/bold elements `<strong>`, `<b>` (async version).
-    async fn visit_strong(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit emphasis/italic elements `<em>`, `<i>` (async version).
-    async fn visit_emphasis(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit strikethrough elements `<s>`, `<del>`, `<strike>` (async version).
-    async fn visit_strikethrough(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit underline elements `<u>`, `<ins>` (async version).
-    async fn visit_underline(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit subscript elements `<sub>` (async version).
-    async fn visit_subscript(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit superscript elements `<sup>` (async version).
-    async fn visit_superscript(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit mark/highlight elements `<mark>` (async version).
-    async fn visit_mark(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit line break elements `<br>` (async version).
-    async fn visit_line_break(&mut self, _ctx: &NodeContext) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit horizontal rule elements `<hr>` (async version).
-    async fn visit_horizontal_rule(&mut self, _ctx: &NodeContext) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit custom elements (web components) or unknown tags (async version).
-    async fn visit_custom_element(&mut self, _ctx: &NodeContext, _tag_name: &str, _html: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit definition list `<dl>` (async version).
-    async fn visit_definition_list_start(&mut self, _ctx: &NodeContext) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit definition term `<dt>` (async version).
-    async fn visit_definition_term(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit definition description `<dd>` (async version).
-    async fn visit_definition_description(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called after processing a definition list `</dl>` (async version).
-    async fn visit_definition_list_end(&mut self, _ctx: &NodeContext, _output: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit form elements `<form>` (async version).
-    async fn visit_form(&mut self, _ctx: &NodeContext, _action: Option<&str>, _method: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit input elements `<input>` (async version).
-    async fn visit_input(
-        &mut self,
-        _ctx: &NodeContext,
-        _input_type: &str,
-        _name: Option<&str>,
-        _value: Option<&str>,
-    ) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit button elements `<button>` (async version).
-    async fn visit_button(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit audio elements `<audio>` (async version).
-    async fn visit_audio(&mut self, _ctx: &NodeContext, _src: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit video elements `<video>` (async version).
-    async fn visit_video(&mut self, _ctx: &NodeContext, _src: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit iframe elements `<iframe>` (async version).
-    async fn visit_iframe(&mut self, _ctx: &NodeContext, _src: Option<&str>) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit details elements `<details>` (async version).
-    async fn visit_details(&mut self, _ctx: &NodeContext, _open: bool) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit summary elements `<summary>` (async version).
-    async fn visit_summary(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit figure elements `<figure>` (async version).
-    async fn visit_figure_start(&mut self, _ctx: &NodeContext) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Visit figcaption elements `<figcaption>` (async version).
-    async fn visit_figcaption(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-
-    /// Called after processing a figure `</figure>` (async version).
-    async fn visit_figure_end(&mut self, _ctx: &NodeContext, _output: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-}

data/vendor/html-to-markdown-rs/src/visitor_helpers/helpers/callbacks/bridge.rs

@@ -1,189 +0,0 @@
-//! Async-to-sync visitor bridge for integrating async visitors with synchronous converters.
-//!
-//! This module provides the `AsyncToSyncVisitorBridge` struct that wraps an async visitor
-//! and implements the sync `HtmlVisitor` trait using channel-based communication.
-
-#[cfg(feature = "async-visitor")]
-use super::AsyncVisitorHandle;
-
-/// Request types for visitor method calls over the channel.
-#[cfg(feature = "async-visitor")]
-pub(super) enum VisitorRequest {
-    ElementStart(crate::visitor::NodeContext),
-    ElementEnd(crate::visitor::NodeContext, String),
-    Text(crate::visitor::NodeContext, String),
-    Link(crate::visitor::NodeContext, String, String, Option<String>),
-    Image(crate::visitor::NodeContext, String, String, Option<String>),
-    Heading(crate::visitor::NodeContext, u32, String, Option<String>),
-    CodeBlock(crate::visitor::NodeContext, Option<String>, String),
-    CodeInline(crate::visitor::NodeContext, String),
-    ListItem(crate::visitor::NodeContext, bool, String, String),
-    ListStart(crate::visitor::NodeContext, bool),
-    ListEnd(crate::visitor::NodeContext, bool, String),
-    TableStart(crate::visitor::NodeContext),
-    TableRow(crate::visitor::NodeContext, Vec<String>, bool),
-    TableEnd(crate::visitor::NodeContext, String),
-    Blockquote(crate::visitor::NodeContext, String, usize),
-    Strong(crate::visitor::NodeContext, String),
-    Emphasis(crate::visitor::NodeContext, String),
-    Strikethrough(crate::visitor::NodeContext, String),
-    Underline(crate::visitor::NodeContext, String),
-    Subscript(crate::visitor::NodeContext, String),
-    Superscript(crate::visitor::NodeContext, String),
-    Mark(crate::visitor::NodeContext, String),
-    LineBreak(crate::visitor::NodeContext),
-    HorizontalRule(crate::visitor::NodeContext),
-    CustomElement(crate::visitor::NodeContext, String, String),
-}
-
-/// Bridge that wraps an async visitor and implements the sync `HtmlVisitor` trait.
-///
-/// This bridge uses a channel-based approach to avoid blocking:
-/// 1. Sync converter sends visitor call request through channel
-/// 2. Async runtime receives request and awaits JS callback
-/// 3. Result sent back through response channel
-/// 4. Sync converter receives result and continues
-///
-/// This approach avoids deadlock by never blocking on async operations.
-#[cfg(feature = "async-visitor")]
-pub struct AsyncToSyncVisitorBridge {
-    #[allow(dead_code)]
-    pub(super) async_visitor: AsyncVisitorHandle,
-    pub(super) request_tx: tokio::sync::mpsc::UnboundedSender<VisitorRequest>,
-    pub(super) response_rx: std::sync::mpsc::Receiver<crate::visitor::VisitResult>,
-}
-
-#[cfg(feature = "async-visitor")]
-impl std::fmt::Debug for AsyncToSyncVisitorBridge {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AsyncToSyncVisitorBridge")
-            .field("async_visitor", &self.async_visitor)
-            .finish_non_exhaustive()
-    }
-}
-
-#[cfg(feature = "async-visitor")]
-impl AsyncToSyncVisitorBridge {
-    /// Create a new async-to-sync visitor bridge with channel-based communication.
-    pub fn new(async_visitor: AsyncVisitorHandle) -> Self {
-        // Use tokio::sync::mpsc for async channels (not std::sync::mpsc which blocks)
-        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (response_tx, response_rx) = std::sync::mpsc::channel();
-
-        // Spawn async task to handle visitor requests
-        let visitor_clone = async_visitor.clone();
-        tokio::spawn(async move {
-            while let Some(request) = request_rx.recv().await {
-                let result = match request {
-                    VisitorRequest::ElementStart(ctx) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_element_start(&ctx).await
-                    }
-                    VisitorRequest::ElementEnd(ctx, output) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_element_end(&ctx, &output).await
-                    }
-                    VisitorRequest::Text(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_text(&ctx, &text).await
-                    }
-                    VisitorRequest::Link(ctx, href, text, title) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_link(&ctx, &href, &text, title.as_deref()).await
-                    }
-                    VisitorRequest::Image(ctx, src, alt, title) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_image(&ctx, &src, &alt, title.as_deref()).await
-                    }
-                    VisitorRequest::Heading(ctx, level, text, id) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_heading(&ctx, level, &text, id.as_deref()).await
-                    }
-                    VisitorRequest::CodeBlock(ctx, lang, code) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_code_block(&ctx, lang.as_deref(), &code).await
-                    }
-                    VisitorRequest::CodeInline(ctx, code) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_code_inline(&ctx, &code).await
-                    }
-                    VisitorRequest::ListItem(ctx, ordered, marker, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_list_item(&ctx, ordered, &marker, &text).await
-                    }
-                    VisitorRequest::ListStart(ctx, ordered) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_list_start(&ctx, ordered).await
-                    }
-                    VisitorRequest::ListEnd(ctx, ordered, output) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_list_end(&ctx, ordered, &output).await
-                    }
-                    VisitorRequest::TableStart(ctx) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_table_start(&ctx).await
-                    }
-                    VisitorRequest::TableRow(ctx, cells, is_header) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_table_row(&ctx, &cells, is_header).await
-                    }
-                    VisitorRequest::TableEnd(ctx, output) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_table_end(&ctx, &output).await
-                    }
-                    VisitorRequest::Blockquote(ctx, content, depth) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_blockquote(&ctx, &content, depth).await
-                    }
-                    VisitorRequest::Strong(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_strong(&ctx, &text).await
-                    }
-                    VisitorRequest::Emphasis(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_emphasis(&ctx, &text).await
-                    }
-                    VisitorRequest::Strikethrough(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_strikethrough(&ctx, &text).await
-                    }
-                    VisitorRequest::Underline(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_underline(&ctx, &text).await
-                    }
-                    VisitorRequest::Subscript(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_subscript(&ctx, &text).await
-                    }
-                    VisitorRequest::Superscript(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_superscript(&ctx, &text).await
-                    }
-                    VisitorRequest::Mark(ctx, text) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_mark(&ctx, &text).await
-                    }
-                    VisitorRequest::LineBreak(ctx) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_line_break(&ctx).await
-                    }
-                    VisitorRequest::HorizontalRule(ctx) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_horizontal_rule(&ctx).await
-                    }
-                    VisitorRequest::CustomElement(ctx, tag_name, html) => {
-                        let mut visitor = visitor_clone.lock().await;
-                        visitor.visit_custom_element(&ctx, &tag_name, &html).await
-                    }
-                };
-                let _ = response_tx.send(result);
-            }
-        });
-
-        Self {
-            async_visitor,
-            request_tx,
-            response_rx,
-        }
-    }
-}