Libreria

KatanA Document Viewer

Libreria Rust per integrare in un'app anteprima documenti ed esportazione in HTML, PDF e immagini. Gestisce dati documentali indipendenti dal framework UI.

Sviluppatori Rust che integrano visualizzatori documentali o esportazione HTML, PDF e immagini

01

Funzioni implementate

API per snapshot documentali, dati di output e informazioni diagnostiche

Fonti

Collegamento tra struttura Markdown e rendering dei diagrammi tramite KRR

Fonti

Esportazione in HTML, PDF, PNG e JPEG

Fonti

02

Per iniziare

  1. Ottieni il repository e consulta il README per ambiente e requisiti dei font.
  2. Usa l'esempio export_debug indicando un file Markdown e una directory di output, poi verifica i documenti generati.

Prepara Rust e gli strumenti di sviluppo necessari e consulta il README collegato per i requisiti prima dell'integrazione. Gli esempi sono punti di partenza e non garantiscono il funzionamento in ogni ambiente.

Fonti
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

Casi d'uso

Base comune per visualizzare ed esportare documenti

È adatto quando vuoi trattare Markdown come frame, stato e diagnostica documentale di KDV senza legarlo direttamente alla UI dell’app, generando HTML, PDF, PNG e JPEG dalla stessa render pipeline. Il confine tra visualizzazione nel viewer ed export può essere condiviso.

Preparare l’export di documenti con diagrammi

Puoi fare build in KDV di Markdown con diagrammi e formule, delegare il rendering dei diagrammi a KRR e conservare i significati non supportati come diagnostica e raw source. È una base per non scartare in silenzio gli input che la vista non sa interpretare, lasciandoli disponibili alle fasi successive.

02 / KDV

Flusso da input a output

  1. Normalizzare l’input

    Leggi il file di input, uniforma CRLF/CR a LF e normalizza i Markdown fence con MarkdownFenceNormalizer. Configura in input source URI, source kind, revision e contenuto.

  2. Creare snapshot e build graph

    Struttura il Markdown con KatanaMarkdownModel::parse e crea lo snapshot con DocumentSnapshotFactory::from_kmm. Passa a BuildRequest il markdown export profile e il theme, quindi genera con ForgePipeline::build un BuildGraph che include la diagnostica.

  3. Salvare artifact e diagnostica

    Passa il build graph a ForgePipeline::export per creare l’artifact del formato richiesto e salvalo insieme a build graph, coverage e summary TOML. Se l’artifact è vuoto, l’export dell’esempio restituisce un errore, evitando di consegnare un risultato incompleto.

03 / KDV

API e CLI principali

DocumentSnapshotFactory — Snapshot del documento
Combina il documento KMM con DocumentSource per creare il DocumentSnapshot usato da viewer/forge. Oltre al contenuto, URI e revision sono parte dei presupposti dello snapshot.
ForgePipeline::build — Costruzione del grafo
Elabora snapshot, BuildProfile e theme di BuildRequest e restituisce un BuildGraph con document snapshot, profile, diagnostics e rendered diagrams.
ForgePipeline::export — Esportazione dei documenti
Restituisce ExportOutput a partire da build graph, formato e theme di ExportRequest. I formati sono HTML, PDF, PNG e JPEG; artifact e forge diagnostics possono essere passati insieme alle fasi successive.
KRR diagram backend — Collegamento dei diagrammi
Passando DiagramRenderingBackend e KrrDiagramRenderEngine alla pipeline colleghi il rendering dei diagrammi al confine KRR. KDV non possiede direttamente la UI dell’app né un’altra implementazione di diagrammi.

04 / KDV

Capire con un esempio

Esempio: eseguire la build di README e verificare il numero di nodi

Questo codice legge README.md, esegue normalizzazione, parse e creazione dello snapshot, quindi costruisce un BuildGraph con markdown export profile e visualizza il numero di nodes. È estratta la sola parte build dell’esempio pubblico export_debug: non salva file e non esegue l’export nei quattro formati.

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

Integrazione e limiti

Non introdurre un UI backend

KDV non dipende da backend UI come egui/eframe e non espone tipi KUC nella propria API pubblica. L’applicazione superiore, come KatanA, coordina la sincronizzazione tra viewer ed editor; KDV resta concentrato sul confine document/viewer/export.

Adottarlo come scaffolding

Il README pubblico indica uno scaffolding: v0.1.0 è una foundation di artifact/forge/export indipendente dalla UI. Non colmare i parser gaps di KMM con un reparse e non trattare come funzionalità completa i significati non supportati da KRR.

Fonti

Presentazione basata sui repository pubblici disponibili al momento della ricerca. Implementazione e procedure sono verificabili nel commit fissato del link.

Archivio del codiceLeggimi99371a97dbc5
Fonti · KDV
Tutti i prodotti