text-document-frontend 1.9.0

// Generated by Qleany v1.4.8 from frontend_feature_commands.tera

//! DocumentIo feature commands

use crate::app_context::AppContext;
use anyhow::{Context, Result};
use document_io::{
    ExportDjotDto, ExportDocxDto, ExportDocxResultDto, ExportEpubDto, ExportEpubResultDto,
    ExportHtmlDto, ExportLatexDto, ExportLatexResultDto, ExportMarkdownDto, ExportPdfDto,
    ExportPdfResultDto, ExportPlainTextDto, ImportDjotDto, ImportDjotResultDto, ImportHtmlDto,
    ImportHtmlResultDto, ImportMarkdownDto, ImportMarkdownResultDto, ImportPlainTextDto,
    document_io_controller,
};

use common::long_operation::OperationProgress;
use common::parser_tools::{DjotExportOptions, MarkdownExportOptions, PlainTextExportOptions};

pub fn import_plain_text(ctx: &AppContext, dto: &ImportPlainTextDto) -> Result<()> {
    document_io_controller::import_plain_text(&ctx.db_context, &ctx.event_hub, dto)
        .context("import_plain_text")
}

pub fn export_plain_text(ctx: &AppContext) -> Result<ExportPlainTextDto> {
    document_io_controller::export_plain_text(&ctx.db_context, &ctx.event_hub)
        .context("export_plain_text")
}

/// [`export_plain_text`] with blockquotes indented — for writing a `.txt` file, not for
/// anything that computes offsets against the result.
pub fn export_plain_text_indented(ctx: &AppContext) -> Result<ExportPlainTextDto> {
    export_plain_text_with(
        ctx,
        PlainTextExportOptions {
            quote_indent: true,
            ..PlainTextExportOptions::addressable()
        },
    )
}

/// [`export_plain_text`] with every presentation option under the caller's control.
pub fn export_plain_text_with(
    ctx: &AppContext,
    options: PlainTextExportOptions,
) -> Result<ExportPlainTextDto> {
    document_io_controller::export_plain_text_with(&ctx.db_context, &ctx.event_hub, options)
        .context("export_plain_text_with")
}

/// import_markdown (long operation)
pub fn import_markdown(ctx: &AppContext, dto: &ImportMarkdownDto) -> Result<String> {
    document_io_controller::import_markdown(
        &ctx.db_context,
        &ctx.event_hub,
        &mut ctx.long_operation_manager.lock(),
        dto,
    )
    .context("import_markdown")
}

/// Get the progress of a import_markdown operation
pub fn get_import_markdown_progress(
    ctx: &AppContext,
    operation_id: &str,
) -> Option<OperationProgress> {
    document_io_controller::get_import_markdown_progress(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
}

/// Get the result of a import_markdown operation
pub fn get_import_markdown_result(
    ctx: &AppContext,
    operation_id: &str,
) -> Result<Option<ImportMarkdownResultDto>> {
    document_io_controller::get_import_markdown_result(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
    .context("getting import_markdown result")
}

pub fn export_markdown(ctx: &AppContext) -> Result<ExportMarkdownDto> {
    document_io_controller::export_markdown(&ctx.db_context, &ctx.event_hub)
        .context("export_markdown")
}

/// [`export_markdown`] with the presentation opt-ins.
pub fn export_markdown_with(
    ctx: &AppContext,
    options: MarkdownExportOptions,
) -> Result<ExportMarkdownDto> {
    document_io_controller::export_markdown_with(&ctx.db_context, &ctx.event_hub, options)
        .context("export_markdown_with")
}

/// import_djot (long operation)
pub fn import_djot(ctx: &AppContext, dto: &ImportDjotDto) -> Result<String> {
    document_io_controller::import_djot(
        &ctx.db_context,
        &ctx.event_hub,
        &mut ctx.long_operation_manager.lock(),
        dto,
    )
    .context("import_djot")
}

/// import_djot, **synchronously**, on the calling thread.
///
/// [`import_djot`] starts a long operation, which spawns a thread. That is right for a
/// UI import (it must not block the frame loop) and wrong for a batch caller, which
/// would spawn one thread per document to do work it wants to do inline. See
/// `text_document::BatchDocument`, the intended consumer.
pub fn import_djot_sync(ctx: &AppContext, dto: &ImportDjotDto) -> Result<ImportDjotResultDto> {
    document_io_controller::import_djot_sync(&ctx.db_context, &ctx.event_hub, dto)
        .context("import_djot_sync")
}

/// Get the progress of a import_djot operation
pub fn get_import_djot_progress(ctx: &AppContext, operation_id: &str) -> Option<OperationProgress> {
    document_io_controller::get_import_djot_progress(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
}

/// Get the result of a import_djot operation
pub fn get_import_djot_result(
    ctx: &AppContext,
    operation_id: &str,
) -> Result<Option<ImportDjotResultDto>> {
    document_io_controller::get_import_djot_result(&ctx.long_operation_manager.lock(), operation_id)
        .context("getting import_djot result")
}

pub fn export_djot(ctx: &AppContext, options: &DjotExportOptions) -> Result<ExportDjotDto> {
    document_io_controller::export_djot(&ctx.db_context, &ctx.event_hub, options)
        .context("export_djot")
}

/// import_html (long operation)
pub fn import_html(ctx: &AppContext, dto: &ImportHtmlDto) -> Result<String> {
    document_io_controller::import_html(
        &ctx.db_context,
        &ctx.event_hub,
        &mut ctx.long_operation_manager.lock(),
        dto,
    )
    .context("import_html")
}

/// Get the progress of a import_html operation
pub fn get_import_html_progress(ctx: &AppContext, operation_id: &str) -> Option<OperationProgress> {
    document_io_controller::get_import_html_progress(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
}

/// Get the result of a import_html operation
pub fn get_import_html_result(
    ctx: &AppContext,
    operation_id: &str,
) -> Result<Option<ImportHtmlResultDto>> {
    document_io_controller::get_import_html_result(&ctx.long_operation_manager.lock(), operation_id)
        .context("getting import_html result")
}

pub fn export_html(ctx: &AppContext) -> Result<ExportHtmlDto> {
    document_io_controller::export_html(&ctx.db_context, &ctx.event_hub).context("export_html")
}
/// HTML export with an explicit image policy.
pub fn export_html_with_options(
    ctx: &AppContext,
    options: common::parser_tools::HtmlExportOptions,
) -> Result<ExportHtmlDto> {
    document_io::document_io_controller::export_html_with_options(
        &ctx.db_context,
        &ctx.event_hub,
        options,
    )
}

pub fn export_latex(ctx: &AppContext, dto: &ExportLatexDto) -> Result<ExportLatexResultDto> {
    document_io_controller::export_latex(&ctx.db_context, &ctx.event_hub, dto)
        .context("export_latex")
}

/// export_docx (long operation)
pub fn export_docx(ctx: &AppContext, dto: &ExportDocxDto) -> Result<String> {
    document_io_controller::export_docx(
        &ctx.db_context,
        &ctx.event_hub,
        &mut ctx.long_operation_manager.lock(),
        dto,
    )
    .context("export_docx")
}

/// Get the progress of a export_docx operation
pub fn get_export_docx_progress(ctx: &AppContext, operation_id: &str) -> Option<OperationProgress> {
    document_io_controller::get_export_docx_progress(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
}

/// Get the result of a export_docx operation
pub fn get_export_docx_result(
    ctx: &AppContext,
    operation_id: &str,
) -> Result<Option<ExportDocxResultDto>> {
    document_io_controller::get_export_docx_result(&ctx.long_operation_manager.lock(), operation_id)
        .context("getting export_docx result")
}

/// export_epub (long operation)
pub fn export_epub(ctx: &AppContext, dto: &ExportEpubDto) -> Result<String> {
    document_io_controller::export_epub(
        &ctx.db_context,
        &ctx.event_hub,
        &mut ctx.long_operation_manager.lock(),
        dto,
    )
    .context("export_epub")
}

/// Get the progress of a export_epub operation
pub fn get_export_epub_progress(ctx: &AppContext, operation_id: &str) -> Option<OperationProgress> {
    document_io_controller::get_export_epub_progress(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
}

/// Get the result of a export_epub operation
pub fn get_export_epub_result(
    ctx: &AppContext,
    operation_id: &str,
) -> Result<Option<ExportEpubResultDto>> {
    document_io_controller::get_export_epub_result(&ctx.long_operation_manager.lock(), operation_id)
        .context("getting export_epub result")
}

/// export_pdf (long operation).
///
/// Thin, **unconditional** wrapper — no `#[cfg(feature = "pdf")]` here. `document_io_controller`'s
/// `export_pdf`/`get_export_pdf_progress`/`get_export_pdf_result` exist with the same signature
/// whether or not `document_io`'s own `pdf` cargo feature is enabled (a real export, or an
/// immediate "unsupported" error), so this wrapper — and every caller of it — never needs to know
/// which.
pub fn export_pdf(ctx: &AppContext, dto: &ExportPdfDto) -> Result<String> {
    document_io_controller::export_pdf(
        &ctx.db_context,
        &ctx.event_hub,
        &mut ctx.long_operation_manager.lock(),
        dto,
    )
    .context("export_pdf")
}

/// Get the progress of a export_pdf operation
pub fn get_export_pdf_progress(ctx: &AppContext, operation_id: &str) -> Option<OperationProgress> {
    document_io_controller::get_export_pdf_progress(
        &ctx.long_operation_manager.lock(),
        operation_id,
    )
}

/// Get the result of a export_pdf operation
pub fn get_export_pdf_result(
    ctx: &AppContext,
    operation_id: &str,
) -> Result<Option<ExportPdfResultDto>> {
    document_io_controller::get_export_pdf_result(&ctx.long_operation_manager.lock(), operation_id)
        .context("getting export_pdf result")
}