Skip to content
Office Oxide

Dokumente aus IR erzeugen

create_from_ir schreibt eine brandneue DOCX, XLSX oder PPTX aus einer DocumentIR — also dem gleichen strukturierten Schema, das du aus to_ir() bekommst. Eine IR, drei Zielformate. Die IR ist die natürliche Senke für LLM-generierten Content: die Modell liefert strukturiertes JSON, du materialisiertest bei Bedarf das passende Office-Format.

Bauen und schreiben

Rust

use office_oxide::{DocumentFormat};
use office_oxide::create::create_from_ir;
use office_oxide::ir::{DocumentIR, Section, Element, Run};

let ir = DocumentIR {
    sections: vec![Section {
        title: Some("Quartalsbericht".into()),
        elements: vec![
            Element::Heading { level: 1, text: "Highlights".into() },
            Element::Paragraph { runs: vec![Run::plain("Umsatz wuchs um 18 %.")] },
            Element::Table {
                rows: vec![
                    vec!["Region".into(), "Umsatz".into()],
                    vec!["NA".into(),     "$1.2M".into()],
                    vec!["EU".into(),     "$820K".into()],
                ],
            },
        ],
    }],
};

create_from_ir(&ir, DocumentFormat::Docx, "report.docx")?;

Mit Wechsel des Zielformats kommen aus derselben IR XLSX oder PPTX:

create_from_ir(&ir, DocumentFormat::Xlsx, "report.xlsx")?;
create_from_ir(&ir, DocumentFormat::Pptx, "report.pptx")?;

Python

from office_oxide import create_from_ir

ir = {
    "sections": [{
        "title": "Quartalsbericht",
        "elements": [
            {"kind": "Heading", "level": 1, "text": "Highlights"},
            {"kind": "Paragraph", "runs": [{"text": "Umsatz wuchs um 18 %."}]},
            {"kind": "Table", "rows": [
                ["Region", "Umsatz"],
                ["NA",     "$1.2M"],
                ["EU",     "$820K"],
            ]},
        ],
    }],
}

create_from_ir(ir, "docx", "report.docx")
create_from_ir(ir, "xlsx", "report.xlsx")
create_from_ir(ir, "pptx", "report.pptx")

JavaScript

import { createFromIr } from 'office-oxide';

const ir = {
  sections: [{
    title: 'Quarterly Report',
    elements: [
      { kind: 'Heading', level: 1, text: 'Highlights' },
      { kind: 'Paragraph', runs: [{ text: 'Revenue grew 18%.' }] },
      { kind: 'Table', rows: [
        ['Region', 'Revenue'],
        ['NA',     '$1.2M'],
        ['EU',     '$820K'],
      ]},
    ],
  }],
};

createFromIr(ir, 'docx', 'report.docx');
createFromIr(ir, 'xlsx', 'report.xlsx');
createFromIr(ir, 'pptx', 'report.pptx');

Go

Go nimmt die IR als JSON-Payload entgegen:

import (
    "encoding/json"
    officeoxide "github.com/yfedoseev/office_oxide/go"
)

ir := map[string]any{
    "sections": []any{
        map[string]any{
            "title": "Quarterly Report",
            "elements": []any{
                map[string]any{"kind": "Heading", "level": 1, "text": "Highlights"},
                map[string]any{"kind": "Paragraph", "runs": []any{map[string]any{"text": "Revenue grew 18%."}}},
                map[string]any{"kind": "Table", "rows": [][]string{
                    {"Region", "Revenue"},
                    {"NA", "$1.2M"},
                    {"EU", "$820K"},
                }},
            },
        },
    },
}
payload, _ := json.Marshal(ir)

officeoxide.CreateFromIR(string(payload), "docx", "report.docx")
officeoxide.CreateFromIR(string(payload), "xlsx", "report.xlsx")
officeoxide.CreateFromIR(string(payload), "pptx", "report.pptx")

C#

using OfficeOxide;
using System.Text.Json;

var ir = new {
    sections = new[] {
        new {
            title = "Quarterly Report",
            elements = new object[] {
                new { kind = "Heading", level = 1, text = "Highlights" },
                new { kind = "Paragraph", runs = new[] { new { text = "Revenue grew 18%." } } },
                new { kind = "Table", rows = new[] {
                    new[] { "Region", "Revenue" },
                    new[] { "NA",     "$1.2M" },
                    new[] { "EU",     "$820K" },
                }},
            },
        },
    },
};

var payload = JsonSerializer.Serialize(ir);
OfficeOxide.CreateFromIr(payload, "docx", "report.docx");
OfficeOxide.CreateFromIr(payload, "xlsx", "report.xlsx");
OfficeOxide.CreateFromIr(payload, "pptx", "report.pptx");

Wie jedes Zielformat die IR rendert

IR-Element DOCX XLSX PPTX
Section Word-Abschnittsumbruch Worksheet (eine Section → ein Sheet) Folie
Heading { level } Absatz mit Stil Heading{level} Fette Zelle am Zeilenanfang Folientitel-Placeholder
Paragraph Body-Absatz Zellen in aufeinanderfolgenden Zeilen Body-Text-Placeholder
List { ordered, items } Nummerierte oder Aufzählungsliste Zellen in Spalte A Body-Aufzählung
Table { rows } Word-Tabelle Zellen ab nächster freier Zeile PowerPoint-Tabelle
Image { filename, data } Inline-Bild (übersprungen — XLSX braucht Anker-Koordinaten) Folienbild

Das Mapping ist konservativ: jedes IR-Element ergibt einen deterministischen Output, aber jedes Format hat Features, die die IR nicht abbildet (Merges in XLSX, Animationen in PPTX, Comment-Threads in DOCX). Für reichere Outputs nimm formatspezifische Builder.

Round-Trip — lesen, ändern, schreiben

Kombiniere to_ir() mit create_from_ir, um strukturelle Änderungen zu machen, die formatübergreifend überleben:

from office_oxide import Document, create_from_ir

with Document.open("legacy.doc") as doc:
    ir = doc.to_ir()

# Neue Section anhängen
ir["sections"].append({
    "title": "Anhang",
    "elements": [
        {"kind": "Heading", "level": 2, "text": "Aktualisierte Bedingungen"},
        {"kind": "Paragraph", "runs": [{"text": "Gültig ab 2026-04-19."}]},
    ],
})

create_from_ir(ir, "docx", "modernized.docx")

Das ist gleichzeitig der sauberste Weg für Legacy → OOXML-Konvertierung (DOC → DOCX, XLS → XLSX, PPT → PPTX). Siehe Konvertierung: Legacy → OOXML.

Warum die IR zum Erzeugen nutzen

  • Formatunabhängige Templates. Erzeuge denselben Content als DOCX (für Word-Nutzer), XLSX (für Analysten) oder PPTX (für Präsentationen), ohne etwas neu zu schreiben.
  • LLM-nativ. Lass das Modell JSON gemäß dem IR-Schema produzieren; materialisiere die Datei. Viel verlässlicher, als dem Modell direkt Office-XML aufzubürden.
  • Diffbar. Die IR ist JSON; commit es. Die Office-Datei wird zum Build-Artefakt.

Grenzen

  • Bilder in Element::Image werden geschrieben, wenn das Zielformat Inline-Bilder unterstützt (DOCX, PPTX). XLSX braucht Anker-Koordinaten, die die einfache IR nicht trägt — überspringen oder formatspezifischen Builder nehmen.
  • Zellformatierung (Zahlenformat, Währung, Fett) gehört nicht zur IR. Nach dem Erzeugen über den formatspezifischen Editor ergänzen.
  • Diagramme, SmartArt und embedded Objects gehören nicht zur IR.

Für alles, was über den Ausdrucksumfang der IR hinausgeht, fall in die formatspezifischen Builder ab (docx::create::DocxBuilder, xlsx::create::XlsxBuilder, pptx::create::PptxBuilder). Du bekommst vollen Zugriff auf OOXML-Features im Tausch dafür, an ein Format gebunden zu sein.

Siehe auch