The OpenDoc SDK

./packages/opendoc/build.sh                      # wasm-pack; needs Rust and wasm-pack
cd packages/opendoc && npm test && npm pack

python -m venv .venv && . .venv/bin/activate
pip install maturin pytest
cd bindings/python
maturin develop --release        # or: maturin build --release (wheel in target/wheels)
pytest tests

./bindings/java/build.sh     # cargo build -p opendoc-ffi --release, javac, jar, conformance test

// Open any DOCX/ODT/RTF, read it, change it, and save it four ways, with the
// loss report the save returns.
//
//   node examples/read-modify-convert.mjs input.docx out-dir
import { mkdir } from "node:fs/promises";
import { join } from "node:path";

import { openFile, saveFile } from "@casualoffice/opendoc/node";

const [input, out = "out"] = process.argv.slice(2);
if (!input) throw new Error("usage: node read-modify-convert.mjs input.docx [out-dir]");
await mkdir(out, { recursive: true });

const doc = await openFile(input);
console.log(`${doc.sourceFormat}: ${doc.paragraphs.length} paragraphs, ${doc.tables.length} tables, ${doc.pageCount} pages`);
console.log("not carried at open:", doc.importReport.findings.filter((f) => f.loss).map((f) => f.feature));
for (const p of doc.paragraphs.filter((p) => p.headingLevel !== undefined)) {
  console.log(`${"  ".repeat(Math.max(0, p.headingLevel - 1))}${p.text}`);
}

const replaced = doc.replaceAll("Draft", "Final");
const note = doc.addParagraph("Reviewed by the OpenDoc SDK.", { style: "Quote" });
doc.addComment(note, 0, 8, "Automated review");
console.log(`replaced ${replaced}; ${doc.comments.length} comment(s)`);

for (const ext of ["docx", "odt", "pdf", "md"]) {
  const report = await saveFile(doc, join(out, `output.${ext}`));
  console.log(`output.${ext}: ${report.losses.length ? report.losses.map((l) => l.feature).join(", ") : "nothing lost"}`);
}

// A docx-js program, unchanged apart from its import, that also renders.
//
//   node examples/build-report.mjs out-dir
import { mkdir, writeFile } from "node:fs/promises";
import { join } from "node:path";

import {
  AlignmentType,
  Document,
  Footer,
  HeadingLevel,
  Packer,
  PageNumber,
  Paragraph,
  Table,
  TableCell,
  TableOfContents,
  TableRow,
  TextRun,
  WidthType,
} from "@casualoffice/opendoc/docx";

const out = process.argv[2] ?? "out";
await mkdir(out, { recursive: true });

const rows = [
  ["Region", "Q1", "Q2"],
  ["North", "1,200", "1,350"],
  ["South", "980", "1,105"],
];

const doc = new Document({
  creator: "Finance",
  title: "Quarterly report",
  features: { updateFields: true },
  sections: [
    {
      footers: {
        default: new Footer({
          children: [
            new Paragraph({
              alignment: AlignmentType.CENTER,
              children: [new TextRun({ children: ["Page ", PageNumber.CURRENT, " of ", PageNumber.TOTAL_PAGES] })],
            }),
          ],
        }),
      },
      children: [
        new Paragraph({ text: "Quarterly report", heading: HeadingLevel.TITLE }),
        new TableOfContents("Contents", { hyperlink: true, headingStyleRange: "1-2" }),
        new Paragraph({ text: "Summary", heading: HeadingLevel.HEADING_1 }),
        new Paragraph({
          children: [
            new TextRun("Revenue grew "),
            new TextRun({ text: "12%", bold: true, color: "2E7D32" }),
            new TextRun(" quarter on quarter."),
          ],
        }),
        new Paragraph({ text: "By region", heading: HeadingLevel.HEADING_1 }),
        new Table({
          width: { size: 100, type: WidthType.PERCENTAGE },
          rows: rows.map(
            (cells, index) =>
              new TableRow({
                tableHeader: index === 0,
                children: cells.map(
                  (text) =>
                    new TableCell({ children: [new Paragraph({ children: [new TextRun({ text, bold: index === 0 })] })] }),
                ),
              }),
          ),
        }),
      ],
    },
  ],
});

await writeFile(join(out, "report.docx"), await Packer.toBuffer(doc));
// What docx-js cannot do: the same document, laid out.
await writeFile(join(out, "report.pdf"), await Packer.toPdf(doc));
await writeFile(join(out, "report-page-1.png"), await Packer.toPng(doc, { page: 0, dpi: 96 }));
console.log(`wrote report.docx, report.pdf and report-page-1.png to ${out}`);

# SPDX-License-Identifier: Apache-2.0
"""python-docx code, then what python-docx cannot do: a PDF and a page image.

    python examples/quickstart.py out-dir

tests/test_opendoc.py runs this file, so it cannot rot.
"""
import pathlib
import sys

from opendoc import Document, Pt

out = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else "out")
out.mkdir(parents=True, exist_ok=True)

document = Document()
document.add_heading("Quarterly report", 0)
p = document.add_paragraph("Revenue grew ")
p.add_run("12%").bold = True
p.add_run(" quarter on quarter.")
p.runs[1].font.size = Pt(14)
table = document.add_table(rows=1, cols=2)
table.rows[0].cells[0].text = "Region"
table.rows[0].cells[1].text = "Q2"
table.add_row().cells[0].text = "North"

report = document.save(out / "report.docx")
print("report.docx:", "nothing lost" if report.is_lossless else report.losses)
document.save(out / "report.pdf")
(out / "page-1.png").write_bytes(document.render_page_png(0, dpi=96))
print(f"{document.page_count} page(s) laid out by the engine")

// SPDX-License-Identifier: Apache-2.0
package org.casualoffice.opendoc.examples;

import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;

import org.casualoffice.opendoc.OpenDocument;
import org.casualoffice.opendoc.OpenParagraph;
import org.casualoffice.opendoc.OpenRun;
import org.casualoffice.opendoc.OpenTable;
import org.casualoffice.opendoc.ParagraphAlignment;

/** POI XWPF calls, then what POI cannot do: a PDF and a page image. build.sh runs it. */
public final class Quickstart {
    private Quickstart() {}

    public static void main(String[] args) throws Exception {
        Path out = Files.createDirectories(Path.of(args.length > 0 ? args[0] : "out"));
        try (OpenDocument doc = new OpenDocument()) {
            OpenParagraph title = doc.createParagraph();
            title.setAlignment(ParagraphAlignment.CENTER);
            OpenRun run = title.createRun();
            run.setBold(true);
            run.setText("Quarterly report");
            OpenTable table = doc.createTable(2, 2);
            table.getRow(0).getCell(0).setText("Region");
            table.getRow(1).getCell(0).setText("North");
            try (OutputStream stream = Files.newOutputStream(out.resolve("report.docx"))) {
                doc.write(stream);
            }
            doc.save(out.resolve("report.pdf"));
            Files.write(out.resolve("page-1.png"), doc.renderPagePng(0, 96f));
            System.out.println(doc.getPageCount() + " page(s); lost on save: "
                + doc.getLastSaveReport().get("losses"));
        }
    }
}

// SPDX-License-Identifier: Apache-2.0

//! Build a document, edit it in one all-or-nothing batch, then save it as DOCX
//! with a loss report, as PDF and as a page image, all from one layout.
//!
//! `cargo run -p opendoc --example quickstart -- out-dir`. `tests/sdk.rs` runs
//! the same `run` function, so this file cannot rot.

use std::path::Path;

use opendoc::{Document, Error, ErrorCode, Format, Position, RunFormat, SaveMode};

/// Writes `report.docx`, `report.pdf` and `page-1.png` into `out`; returns
/// the page count and the features the DOCX save lost (none here).
pub fn run(out: &Path) -> opendoc::Result<(usize, Vec<String>)> {
    let mut doc = Document::create()?;
    doc.edit(|e| {
        e.append_heading("Quarterly report", 1)?;
        let p = e.append_paragraph("Revenue grew ", None)?;
        e.append_run(&p, "12%", &RunFormat::bold())?;
        e.insert_table(&Position::End, 2, 2, &[vec!["Region".into(), "Q2".into()]])?;
        Ok(())
    })?;

    let (docx, report) = doc.save(Format::Docx, SaveMode::PreserveWhenSafe)?;
    let write = |name: &str, bytes: &[u8]| {
        std::fs::create_dir_all(out)
            .and_then(|()| std::fs::write(out.join(name), bytes))
            .map_err(|e| Error::new(ErrorCode::InvalidArgument, e.to_string()))
    };
    write("report.docx", &docx)?;
    write("report.pdf", &doc.to_pdf()?)?;
    write("page-1.png", &doc.render_page_png(0, 96.0)?)?;
    let lost = report.losses.iter().map(|l| l.feature.clone()).collect();
    Ok((doc.page_count(), lost))
}

#[allow(dead_code)]
fn main() -> opendoc::Result<()> {
    let out = std::env::args().nth(1).unwrap_or_else(|| "out".to_owned());
    run(Path::new(&out)).map(|_| ())
}

usage:
  opendoc convert  IN OUT [--to FMT] [--mode exact|preserve|semantic] [--report FILE] [--strict-loss]
  opendoc render   IN [--out DIR] [--format png|svg|pdf] [--dpi N] [--pages 1-3,5]
  opendoc info     IN [--json]
  opendoc diff     OLD NEW [--json]
  opendoc template TEMPLATE DATA.json OUT [--delimiters "[[,]]"] [--strict] [--null TEXT]
  opendoc build    SPEC.json OUT [--media FILE]...
  opendoc formats
common: --system-fonts  --font FILE  --author NAME
formats: docx dotx odt rtf txt json html md pdf