Skip to content
Office Oxide

Crear documentos desde IR

create_from_ir escribe un DOCX, XLSX o PPTX nuevo desde un DocumentIR — el mismo esquema estructurado que obtienes con to_ir(). Un IR, tres formatos destino. El IR es el destino natural del contenido generado por LLM: haz que el modelo produzca JSON estructurado y materializa el formato Office adecuado a demanda.

Construir y escribir

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("Informe Trimestral".into()),
        elements: vec![
            Element::Heading { level: 1, text: "Destacados".into() },
            Element::Paragraph { runs: vec![Run::plain("Los ingresos crecieron 18%.")] },
            Element::Table {
                rows: vec![
                    vec!["Región".into(), "Ingresos".into()],
                    vec!["NA".into(),     "$1.2M".into()],
                    vec!["EU".into(),     "$820K".into()],
                ],
            },
        ],
    }],
};

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

Cambiando el formato destino sacas XLSX o PPTX desde el mismo IR:

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": "Informe Trimestral",
        "elements": [
            {"kind": "Heading", "level": 1, "text": "Destacados"},
            {"kind": "Paragraph", "runs": [{"text": "Los ingresos crecieron 18%."}]},
            {"kind": "Table", "rows": [
                ["Región", "Ingresos"],
                ["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: 'Informe Trimestral',
    elements: [
      { kind: 'Heading', level: 1, text: 'Destacados' },
      { kind: 'Paragraph', runs: [{ text: 'Los ingresos crecieron 18%.' }] },
      { kind: 'Table', rows: [
        ['Región', 'Ingresos'],
        ['NA',     '$1.2M'],
        ['EU',     '$820K'],
      ]},
    ],
  }],
};

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

Go

Go acepta el IR como payload JSON:

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

ir := map[string]any{
    "sections": []any{
        map[string]any{
            "title": "Informe Trimestral",
            "elements": []any{
                map[string]any{"kind": "Heading", "level": 1, "text": "Destacados"},
                map[string]any{"kind": "Paragraph", "runs": []any{map[string]any{"text": "Los ingresos crecieron 18%."}}},
                map[string]any{"kind": "Table", "rows": [][]string{
                    {"Región", "Ingresos"},
                    {"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 = "Informe Trimestral",
            elements = new object[] {
                new { kind = "Heading", level = 1, text = "Destacados" },
                new { kind = "Paragraph", runs = new[] { new { text = "Los ingresos crecieron 18%." } } },
                new { kind = "Table", rows = new[] {
                    new[] { "Región", "Ingresos" },
                    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");

Cómo cada formato destino renderiza el IR

Elemento IR DOCX XLSX PPTX
Section Salto de sección Word Hoja de cálculo (una section → una hoja) Diapositiva
Heading { level } Párrafo con estilo Heading{level} Celda en negrita al inicio de la fila Placeholder de título de diapositiva
Paragraph Párrafo en cuerpo Celdas en filas sucesivas Placeholder de cuerpo de texto
List { ordered, items } Lista numerada o con viñetas Celdas en columna A Viñetas en cuerpo
Table { rows } Tabla Word Celdas comenzando en la siguiente fila libre Tabla PowerPoint
Image { filename, data } Imagen inline (omitido — XLSX necesita coordenadas de anclaje) Imagen de la diapositiva

El mapeo es conservador: cada elemento IR produce salida determinista, pero cada formato tiene features que el IR no modela (combinaciones en XLSX, animaciones en PPTX, hilos de comentarios en DOCX). Para salidas más ricas usa los builders específicos por formato.

Round-trip — leer, modificar, escribir

Combina to_ir() con create_from_ir para hacer ediciones estructurales que sobreviven entre formatos:

from office_oxide import Document, create_from_ir

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

# Añade una nueva section
ir["sections"].append({
    "title": "Apéndice",
    "elements": [
        {"kind": "Heading", "level": 2, "text": "Términos actualizados"},
        {"kind": "Paragraph", "runs": [{"text": "Vigentes desde 2026-04-19."}]},
    ],
})

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

Esta es también la forma más limpia de hacer conversión heredado → OOXML (DOC → DOCX, XLS → XLSX, PPT → PPTX). Ver Conversión: heredado → OOXML.

Por qué usar el IR para crear

  • Plantillas independientes del formato. Genera el mismo contenido como DOCX (para usuarios de Word), XLSX (para analistas) o PPTX (para presentaciones) sin reescribir nada.
  • Nativo para LLM. Haz que el modelo produzca JSON acorde al esquema IR; luego materializa el archivo. Mucho más fiable que pedirle Office XML directamente.
  • Diffable. El IR es JSON; commitéalo. El archivo Office se vuelve un artefacto de build.

Limitaciones

  • Las imágenes de Element::Image se escriben cuando el formato destino soporta imágenes inline (DOCX, PPTX). XLSX necesita coordenadas de anclaje que el IR simple no lleva — sáltalo o usa el builder específico del formato.
  • El formato de celda (formato numérico, moneda, negrita) no es parte del IR. Añádelo vía el editor específico tras la creación.
  • Gráficos, SmartArt y objetos embebidos no son parte del IR.

Para todo lo que excede la expresividad del IR, baja a los builders específicos por formato (docx::create::DocxBuilder, xlsx::create::XlsxBuilder, pptx::create::PptxBuilder). Te dan acceso completo a las features OOXML a cambio de ser específicos por formato.

Véase también