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
02
Primeiros passos
- Obtenha o repositório e consulte o README para requisitos de ambiente e fontes.
- 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.
Fontesgit 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-output01 / 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
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.
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.
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.
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.