Biblioteca

KatanA Document Viewer

Biblioteca Rust para integrar pré-visualização documental e exportação para HTML, PDF e imagens em um aplicativo. Trabalha com dados documentais independentes de framework de UI.

Desenvolvedores Rust que integram visualizadores documentais ou exportação HTML, PDF e de imagens

01

Funções implementadas

API para snapshots documentais, dados de saída e diagnósticos

Fontes

Ligação entre a estrutura Markdown e a renderização de diagramas por KRR

Fontes

Exportação para HTML, PDF, PNG e JPEG

Fontes

02

Primeiros passos

  1. Obtenha o repositório e consulte o README para requisitos de ambiente e fontes.
  2. Use o exemplo export_debug com um arquivo Markdown e um diretório de saída e confira os documentos gerados.

Prepare Rust e as ferramentas de desenvolvimento necessárias e consulte o README indicado para os requisitos antes da integração. Os exemplos são pontos de entrada e não garantem funcionamento em todos os ambientes.

Fontes
sh
git clone https://github.com/HiroyukiFuruno/katana-document-viewer.git
cd katana-document-viewer
cargo run -p katana-document-viewer --example export_debug -- README.md ./export-output

01 / KDV

Casos de uso

Base comum para visualizar e exportar documentos

É adequado quando você quer tratar Markdown como frame, estado e diagnósticos de documento no KDV, sem ligá-lo diretamente à UI da aplicação, e gerar HTML, PDF, PNG e JPEG pelo mesmo render pipeline. A visualização no viewer e a exportação compartilham a mesma fronteira de processamento.

Preparar a exportação de documentos com diagramas

O KDV faz o build de Markdown com diagramas e fórmulas, delega o render dos diagramas ao KRR e preserva significados não suportados como diagnósticos e raw source. Assim, entradas que a camada de exibição não entende não são descartadas silenciosamente e permanecem disponíveis para as etapas seguintes.

02 / KDV

Fluxo da entrada à saída

  1. Normalizar a entrada

    Leia o arquivo de entrada, normalize CRLF/CR para LF e normalize os Markdown fences com MarkdownFenceNormalizer. Configure URI, source kind, revision e o corpo no source de entrada.

  2. Criar o snapshot e o build graph

    Estruture o Markdown com KatanaMarkdownModel::parse e crie o snapshot usando DocumentSnapshotFactory::from_kmm. Passe o markdown export profile e o theme a BuildRequest e gere, com ForgePipeline::build, um BuildGraph que inclua os diagnósticos.

  3. Salvar artifacts e diagnósticos

    Passe o build graph a ForgePipeline::export para criar o artifact de cada formato e grave-o junto com build graph, coverage e summary TOML. Se o artifact estiver vazio, o export do exemplo falha, evitando que o usuário receba um resultado incompleto.

03 / KDV

APIs e CLI principais

DocumentSnapshotFactory — Snapshot do documento
Combina o documento KMM com DocumentSource para criar o DocumentSnapshot usado por viewer/forge. URI e revision são tão necessários quanto o corpo de entrada para formar o snapshot.
ForgePipeline::build — Construção do grafo
Processa o snapshot, BuildProfile e theme de BuildRequest e devolve um BuildGraph com snapshot documental, profile, diagnostics e rendered diagrams.
ForgePipeline::export — Exportação de documentos
Recebe build graph, formato e theme de ExportRequest e devolve ExportOutput. Os formatos são HTML, PDF, PNG e JPEG; artifact e forge diagnostics podem ser encaminhados juntos para a etapa seguinte.
KRR diagram backend — Ligação dos diagramas
Ao passar DiagramRenderingBackend e KrrDiagramRenderEngine ao pipeline, o render de diagramas é conectado à fronteira do KRR. O próprio KDV não possui uma API que seja dona da UI da aplicação ou de outra implementação de diagramas.

04 / KDV

Entenda com um exemplo

Fazer o build do README e conferir a quantidade de nós

Este código lê README.md, normaliza, faz o parse e cria o snapshot; depois cria um BuildGraph com markdown export profile e exibe a quantidade de nós. É apenas a parte de build do exemplo público export_debug e não salva arquivos nem executa a exportação nos quatro formatos.

rust
use katana_document_viewer::{
    BuildProfile, BuildRequest, DiagramRenderingBackend, DocumentSnapshotFactory,
    DocumentSource, ForgePipeline, KrrDiagramRenderEngine, MarkdownFenceNormalizer,
    SourceKind, SourceRevision, SourceUri,
};
use katana_markdown_model::{KatanaMarkdownModel, MarkdownInput};
use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "README.md";
    let content = MarkdownFenceNormalizer::normalize(&fs::read_to_string(path)?);
    let source = DocumentSource {
        uri: SourceUri(format!("file://{path}")),
        kind: SourceKind::Markdown,
        revision: SourceRevision("local".to_string()),
        content: content.clone(),
    };
    let document = KatanaMarkdownModel::parse(MarkdownInput::from_content(path, content))?;
    let snapshot = DocumentSnapshotFactory::from_kmm(source, document);
    let request = BuildRequest {
        snapshot,
        profile: BuildProfile::markdown_export(),
        theme: Default::default(),
    };
    let pipeline = ForgePipeline::new(DiagramRenderingBackend::new(KrrDiagramRenderEngine));
    let graph = pipeline.build(&request)?;
    println!("nodes={}", graph.snapshot.document.nodes.len());
    Ok(())
}

05 / KDV

Integração e limites

Não trazer um UI backend

O KDV não depende de UI backend como egui/eframe e também não expõe tipos de KUC na API pública. Aplicações de nível superior, como KatanA, coordenam a sincronização entre viewer e editor; o KDV concentra-se na fronteira document/viewer/export.

Adotar como scaffolding

O README público descreve o estado como scaffolding: v0.1.0 é uma foundation de artifact/forge/export sem dependência de UI. Não preencha parser gaps do KMM com reparse nem trate significados ainda não suportados pelo KRR como recursos concluídos.

Fontes

Apresentação baseada nos repositórios públicos disponíveis no momento da pesquisa. A implementação e os passos podem ser conferidos no commit fixado do link.

RepositórioLeia-me99371a97dbc5
Fontes · KDV
Todos os produtos