Skip to content
Office Oxide

Criar documentos a partir do IR

create_from_ir escreve um DOCX, XLSX ou PPTX novinho a partir de um DocumentIR — o mesmo schema estruturado que você obtém com to_ir(). Um IR, três formatos-alvo. O IR é o destino natural de conteúdo gerado por LLM: faça o modelo produzir JSON estruturado e materialize o formato Office certo sob demanda.

Construir e gravar

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("Relatório Trimestral".into()),
        elements: vec![
            Element::Heading { level: 1, text: "Destaques".into() },
            Element::Paragraph { runs: vec![Run::plain("Receita cresceu 18%.")] },
            Element::Table {
                rows: vec![
                    vec!["Região".into(), "Receita".into()],
                    vec!["NA".into(),     "$1.2M".into()],
                    vec!["EU".into(),     "$820K".into()],
                ],
            },
        ],
    }],
};

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

Trocando o formato-alvo, a partir do mesmo IR você pega XLSX ou 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": "Relatório Trimestral",
        "elements": [
            {"kind": "Heading", "level": 1, "text": "Destaques"},
            {"kind": "Paragraph", "runs": [{"text": "Receita cresceu 18%."}]},
            {"kind": "Table", "rows": [
                ["Região", "Receita"],
                ["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: 'Relatório Trimestral',
    elements: [
      { kind: 'Heading', level: 1, text: 'Destaques' },
      { kind: 'Paragraph', runs: [{ text: 'Receita cresceu 18%.' }] },
      { kind: 'Table', rows: [
        ['Região', 'Receita'],
        ['NA',     '$1.2M'],
        ['EU',     '$820K'],
      ]},
    ],
  }],
};

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

Go

Go recebe o IR como payload JSON:

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

ir := map[string]any{
    "sections": []any{
        map[string]any{
            "title": "Relatório Trimestral",
            "elements": []any{
                map[string]any{"kind": "Heading", "level": 1, "text": "Destaques"},
                map[string]any{"kind": "Paragraph", "runs": []any{map[string]any{"text": "Receita cresceu 18%."}}},
                map[string]any{"kind": "Table", "rows": [][]string{
                    {"Região", "Receita"},
                    {"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 = "Relatório Trimestral",
            elements = new object[] {
                new { kind = "Heading", level = 1, text = "Destaques" },
                new { kind = "Paragraph", runs = new[] { new { text = "Receita cresceu 18%." } } },
                new { kind = "Table", rows = new[] {
                    new[] { "Região", "Receita" },
                    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");

Como cada formato-alvo renderiza o IR

Elemento IR DOCX XLSX PPTX
Section Quebra de seção Word Planilha (uma section → uma planilha) Slide
Heading { level } Parágrafo com estilo Heading{level} Célula em negrito no topo da linha Placeholder de título do slide
Paragraph Parágrafo no corpo Células em linhas sucessivas Placeholder de corpo de texto
List { ordered, items } Lista numerada ou com marcadores Células na coluna A Marcadores no corpo
Table { rows } Tabela Word Células começando na próxima linha livre Tabela PowerPoint
Image { filename, data } Imagem inline (ignorado — XLSX precisa de coordenadas de âncora) Imagem do slide

O mapeamento é conservador: todo elemento IR produz uma saída determinística, mas cada formato tem features que o IR não modela (mesclagens em XLSX, animações em PPTX, threads de comentários em DOCX). Para saídas mais ricas use os builders específicos do formato.

Round-trip — ler, modificar, gravar

Combine to_ir() com create_from_ir para fazer edições estruturais que sobrevivem entre formatos:

from office_oxide import Document, create_from_ir

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

# Anexa uma nova section
ir["sections"].append({
    "title": "Apêndice",
    "elements": [
        {"kind": "Heading", "level": 2, "text": "Termos atualizados"},
        {"kind": "Paragraph", "runs": [{"text": "Vigente a partir de 2026-04-19."}]},
    ],
})

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

Esse também é o jeito mais limpo de fazer conversão legado → OOXML (DOC → DOCX, XLS → XLSX, PPT → PPTX). Veja Conversão: legado → OOXML.

Por que usar o IR para criação

  • Templates independentes de formato. Gere o mesmo conteúdo como DOCX (para gente do Word), XLSX (para analistas) ou PPTX (para apresentações) sem reescrever nada.
  • Nativo para LLM. Faça o modelo produzir JSON no schema IR; depois materialize o arquivo. Bem mais confiável do que pedir XML do Office direto.
  • Versionável (diff). O IR é JSON; commit. O arquivo Office vira um artefato de build.

Limitações

  • As imagens em Element::Image são gravadas quando o formato-alvo suporta imagens inline (DOCX, PPTX). XLSX precisa de coordenadas de âncora, que o IR simples não carrega — pule ou use o builder específico do formato.
  • Formatação de célula (formato numérico, moeda, negrito) não faz parte do IR. Adicione via editor específico após a criação.
  • Gráficos, SmartArt e objetos embutidos não fazem parte do IR.

Para tudo além do que o IR consegue expressar, vá nos builders específicos de formato (docx::create::DocxBuilder, xlsx::create::XlsxBuilder, pptx::create::PptxBuilder). Eles dão acesso completo às features OOXML ao custo de serem específicos por formato.

Veja também