Generate, fill, read, and convert
OpenDocument files with odf-kit

import { fillTemplate } from "odf-kit";
import { readFileSync, writeFileSync } from "fs";

// Load a .odt template created in LibreOffice
const template = readFileSync("invoice-template.odt");

const result = fillTemplate(template, {
  customer: "Acme Corp",
  date: "2026-04-12",
  items: [
    { product: "Widget", qty: 5, price: "$125" },
    { product: "Gadget", qty: 3, price: "$120" },
  ],
  showNotes: true, notes: "Net 30",
  company: { name: "Acme Corp", address: "123 Main St" },
});

writeFileSync("invoice.odt", result);
// {placeholders}, {#loops}, conditionals, dot.notation

import { htmlToOdt } from "odf-kit";
import { writeFileSync } from "fs";

const html = `
  <h1>Meeting Notes</h1>
  <p>Attendees: <strong>Alice</strong>, Bob, Carol</p>
  <ul>
    <li>Project status — on track</li>
    <li>Budget review — approved</li>
  </ul>
  <table>
    <tr><th>Action</th><th>Owner</th></tr>
    <tr><td>Send report</td><td>Alice</td></tr>
  </table>
`;

const bytes = await htmlToOdt(html, { pageFormat: "A4" });
writeFileSync("notes.odt", bytes);
// → Headings, bold, lists, tables, inline CSS all preserved

import { markdownToOdt } from "odf-kit";
import { writeFileSync } from "fs";

const markdown = `
# Quarterly Report

Revenue **exceeded expectations** across all regions.

## Action Items

- Send report by Friday
- Review budget on Monday

| Region | Revenue |
|--------|---------|
| North  | $2.1M   |
| South  | $1.8M   |
`;

const bytes = await markdownToOdt(markdown, { pageFormat: "A4" });
writeFileSync("report.odt", bytes);
// → Full CommonMark — headings, bold, lists, tables

import { tiptapToOdt } from "odf-kit";

// editor.getJSON() returns TipTap/ProseMirror JSONContent
const bytes = await tiptapToOdt(editor.getJSON(), { pageFormat: "A4" });

// With pre-fetched images (IPFS, S3, etc.)
const images = { [imageUrl]: await fetchImageBytes(imageUrl) };
const bytes2 = await tiptapToOdt(editor.getJSON(), { images });

// Custom handler for app-specific TipTap extensions
const bytes3 = await tiptapToOdt(editor.getJSON(), {
  unknownNodeHandler: (node, doc) => {
    if (node.type === "callout") doc.addParagraph(`⚠️ ${node.text}`);
  },
});
// → No @tiptap/core dependency — walks JSON directly

import { OdsDocument } from "odf-kit";
import { writeFileSync } from "fs";

const doc = new OdsDocument();
const sheet = doc.addSheet("Sales");

sheet.addRow(
  ["Month", "Revenue", "Growth"],
  { bold: true, backgroundColor: "#DDDDDD" }
);
sheet.addRow(["January",  12500, 0.08]);
sheet.addRow(["February", 14200, 0.136]);
sheet.addRow(["Total", { value: "=SUM(B2:B3)", type: "formula" }]);
sheet.setColumnWidth(0, "4cm");
sheet.freezeRows(1);

const bytes = await doc.save();
writeFileSync("sales.ods", bytes);
// → Valid .ods — opens in LibreOffice Calc

import { readOdt, odtToHtml } from "odf-kit/reader";
import { readFileSync } from "node:fs";

const bytes = new Uint8Array(readFileSync("document.odt"));

// Convert to HTML in one call
const html = odtToHtml(bytes, { fragment: true });

// Or parse to a structured document model
const doc = readOdt(bytes);
console.log(doc.metadata.title);

for (const node of doc.body) {
  if (node.kind === "heading")
    console.log(`h${node.level}:`, node.spans[0].text);
}
// → Paragraphs, headings, tables, lists, formatting

import { readOds, odsToHtml } from "odf-kit/ods-reader";
import { readFileSync } from "node:fs";

const bytes = readFileSync("data.ods");

// Parse to a structured model — typed JavaScript values
const model = readOds(bytes);
for (const row of model.sheets[0].rows) {
  for (const cell of row.cells) {
    console.log(cell.type, cell.value);
    // string | float | boolean | date — never display strings
  }
}

// Or convert directly to an HTML table
const html = odsToHtml(bytes);
// → <table> with merged cells, inline styles

import { xlsxToOds } from "odf-kit/xlsx";
import { readFileSync, writeFileSync } from "fs";

// Convert .xlsx to .ods — zero new dependencies
const xlsx = readFileSync("report.xlsx");
const ods = await xlsxToOds(xlsx);
writeFileSync("report.ods", ods);

// Preserves strings, numbers, booleans, dates,
// formulas, merged cells, freeze panes, multi-sheet
// No SheetJS — own parser built on fflate

// Also works in the browser
const ods2 = await xlsxToOds(await file.arrayBuffer());

import { docxToOdt } from "odf-kit/docx";
import { readFileSync, writeFileSync } from "fs";

// Simple conversion
const { bytes, warnings } = await docxToOdt(readFileSync("report.docx"));
writeFileSync("report.odt", bytes);
if (warnings.length) console.warn(warnings);

// With options — page format, custom style mapping
const { bytes: bytes2 } = await docxToOdt(readFileSync("report.docx"), {
  pageFormat: "letter",
  styleMap: { "Section Title": 1 },
});

// Also works in the browser — pure ESM, zero new dependencies
const { bytes: odt } = await docxToOdt(await file.arrayBuffer());

import { odtToMarkdown } from "odf-kit/markdown";
import { readFileSync, writeFileSync } from "fs";

// GFM (default) — pipe tables, ~~strikethrough~~
const md = odtToMarkdown(readFileSync("document.odt"));
writeFileSync("document.md", md);

// CommonMark flavor
const md2 = odtToMarkdown(readFileSync("document.odt"), {
  flavor: "commonmark",
});

// Also works in the browser — pure ESM, zero dependencies
const md3 = odtToMarkdown(new Uint8Array(await file.arrayBuffer()));

import { odtToTypst, modelToTypst } from "odf-kit/typst";
import { readOdt } from "odf-kit/reader";
import { readFileSync, writeFileSync } from "node:fs";
import { execSync } from "node:child_process";

const bytes = new Uint8Array(readFileSync("document.odt"));

const typ = odtToTypst(bytes);
writeFileSync("document.typ", typ);
execSync("typst compile document.typ document.pdf");

// Parse once, emit to multiple formats
const model = readOdt(bytes);
const typst = modelToTypst(model);
// odf-kit/typst is zero-dependency and browser-safe

import { lexicalToOdt } from "odf-kit/lexical";

// editor.getEditorState().toJSON() returns SerializedEditorState
const bytes = await lexicalToOdt(editor.getEditorState().toJSON(), {
  pageFormat: "A4",
});

// With image resolution for remote URLs
const bytes2 = await lexicalToOdt(editor.getEditorState().toJSON(), {
  pageFormat: "A4",
  fetchImage: async (src) => {
    const res = await fetch(src);
    return new Uint8Array(await res.arrayBuffer());
  },
});
// → No Lexical dependency — walks SerializedEditorState directly