// 1. Build an ODT document from scratch
import { OdtDocument } from "odf-kit";

const doc = new OdtDocument();
doc.addHeading("Quarterly Report", 1);
doc.addParagraph("Revenue exceeded expectations.");
doc.addTable([
  ["Division", "Q4 Revenue", "Growth"],
  ["North", "$2.1M", "+12%"],
  ["South", "$1.8M", "+8%"],
]);
const bytes = await doc.save();

// 2. Convert HTML to ODT
import { htmlToOdt } from "odf-kit";

const html = `
  <h1>Meeting Notes</h1>
  <p>Attendees: <strong>Alice</strong>, Bob, Carol</p>
  <ul>
    <li>Project status</li>
    <li>Budget review</li>
  </ul>
`;
const bytes = await htmlToOdt(html, { pageFormat: "A4" });

// 3. Convert Markdown to ODT
import { markdownToOdt } from "odf-kit";

const markdown = `
# Meeting Notes

Attendees: **Alice**, Bob, Carol

## Action Items

- Send report by Friday
- Review budget on Monday
`;
const bytes = await markdownToOdt(markdown, { pageFormat: "A4" });

// 4. Convert TipTap/ProseMirror JSON to ODT
import { tiptapToOdt } from "odf-kit";

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

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

// With custom node handler for app-specific extensions
const bytes3 = await tiptapToOdt(editor.getJSON(), {
  unknownNodeHandler: (node, doc) => {
    if (node.type === "callout") doc.addParagraph(`⚠️ ${extractText(node)}`);
  },
});

// 5. Build an ODS spreadsheet from scratch
import { OdsDocument } from "odf-kit";

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.setColumnWidth(1, "4cm");
const bytes = await doc.save();

// 6. Fill an existing .odt template with data
import { fillTemplate } from "odf-kit";

const template = readFileSync("invoice-template.odt");
const result = fillTemplate(template, {
  customer: "Acme Corp",
  date: "2026-03-19",
  items: [
    { product: "Widget", qty: 5, price: "$125" },
    { product: "Gadget", qty: 3, price: "$120" },
  ],
  showNotes: true,
  notes: "Net 30",
});
writeFileSync("invoice.odt", result);

// 7. Read an existing .odt file
import { readOdt, odtToHtml } from "odf-kit/reader";

const bytes = readFileSync("report.odt");
const model = readOdt(bytes);              // structured document model
const html  = odtToHtml(bytes);            // styled HTML string

// 8. Read an existing .ods spreadsheet
import { readOds, odsToHtml } from "odf-kit/ods-reader";

const bytes = readFileSync("data.ods");
const model = readOds(bytes);              // structured model — typed values
const html  = odsToHtml(bytes);            // HTML table string

// 9. Convert .xlsx to .ods — no external dependencies
import { xlsxToOds } from "odf-kit/xlsx"

const bytes = await xlsxToOds(readFileSync("report.xlsx"))
writeFileSync("report.ods", bytes)

// 10. Convert .odt to Typst for PDF generation
import { odtToTypst } from "odf-kit/typst";
import { execSync } from "child_process";

const typst = odtToTypst(readFileSync("letter.odt"));
writeFileSync("letter.typ", typst);
execSync("typst compile letter.typ letter.pdf");

// 11. Convert .docx to .odt — pure ESM, zero new dependencies, browser-safe
import { docxToOdt } from "odf-kit/docx";

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

// With options
const { bytes: bytes2 } = await docxToOdt(readFileSync("report.docx"), {
  pageFormat: "letter",
  styleMap: { "Section Title": 1 }, // map custom Word style → heading level
});

// 12. Convert .odt to Markdown
import { odtToMarkdown } from "odf-kit/markdown";

const md = odtToMarkdown(readFileSync("document.odt"));
writeFileSync("document.md", md);

// CommonMark flavor (no pipe tables)
const mdCompat = odtToMarkdown(readFileSync("document.odt"), { flavor: "commonmark" });
// Embed images as base64 data URLs (fully self-contained output)
const mdEmbedded = odtToMarkdown(readFileSync("document.odt"), { embedImages: true });

// 13. Convert Lexical editor state to ODT
import { lexicalToOdt } from "odf-kit/lexical";
// editor.getEditorState().toJSON() returns SerializedEditorState
const bytes = await lexicalToOdt(editor.getEditorState().toJSON(), { pageFormat: "A4" });
// With image resolution (e.g. for Proton Docs integration)
const bytes2 = await lexicalToOdt(editor.getEditorState().toJSON(), {
  pageFormat: "A4",
  fetchImage: async (src) => {
    const response = await fetch(src);
    return new Uint8Array(await response.arrayBuffer());
  },
});

import { OdtDocument, OdsDocument, htmlToOdt, markdownToOdt, tiptapToOdt, fillTemplate } from "odf-kit";
import { readOdt, odtToHtml } from "odf-kit/odt-reader";
import { readOds, odsToHtml } from "odf-kit/ods-reader";
import { odtToTypst, modelToTypst }          from "odf-kit/typst";
import { docxToOdt }                         from "odf-kit/docx";
import { odtToMarkdown, modelToMarkdown }    from "odf-kit/markdown";
import { lexicalToOdt }                      from "odf-kit/lexical";
import { odfKitNormalizer }                  from "odf-kit/html-normalizer";

doc.addHeading("Chapter 1", 1);

doc.addParagraph((p) => {
  p.addText("This is ");
  p.addText("bold",   { bold: true });
  p.addText(", ");
  p.addText("italic", { italic: true });
  p.addText(", and ");
  p.addText("red",    { color: "red", fontSize: 16 });
  p.addText(".");
});

// Scientific notation
doc.addParagraph((p) => {
  p.addText("H");
  p.addText("2", { subscript: true });
  p.addText("O is ");
  p.addText("essential", { underline: true, highlightColor: "yellow" });
});

// Simple
doc.addTable([
  ["Name",  "Age", "City"],
  ["Alice", "30",  "Portland"],
  ["Bob",   "25",  "Seattle"],
]);

// With column widths and borders
doc.addTable([
  ["Product", "Price"],
  ["Widget",  "$9.99"],
], { columnWidths: ["8cm", "4cm"], border: "0.5pt solid #000000" });

// Full control — builder callback
doc.addTable((t) => {
  t.addRow((r) => {
    r.addCell("Name",   { bold: true, backgroundColor: "#DDDDDD" });
    r.addCell("Status", { bold: true, backgroundColor: "#DDDDDD" });
  });
  t.addRow((r) => {
    r.addCell((c) => { c.addText("Project Alpha", { bold: true }); });
    r.addCell("Complete", { color: "green" });
  });
}, { columnWidths: ["8cm", "4cm"] });

doc.setPageLayout({
  orientation: "landscape",
  marginTop: "1.5cm",
  marginBottom: "1.5cm",
});

doc.setHeader((h) => {
  h.addText("Confidential", { bold: true, color: "gray" });
  h.addText(" — Page ");
  h.addPageNumber();
});

doc.setFooter("© 2026 Acme Corp — Page ###");  // ### = page number

doc.addPageBreak();

doc.addList(["Apples", "Bananas", "Cherries"]);
doc.addList(["First", "Second", "Third"], { type: "numbered" });

// Nested with formatting
doc.addList((l) => {
  l.addItem((p) => {
    p.addText("Important: ", { bold: true });
    p.addText("read the docs");
  });
  l.addItem("Main topic");
  l.addNested((sub) => {
    sub.addItem("Subtopic A");
    sub.addItem("Subtopic B");
  });
});

import { readFile } from "fs/promises";

const logo = await readFile("logo.png");

doc.addImage(logo, { width: "10cm", height: "6cm", mimeType: "image/png" });

// Inline image inside a paragraph
doc.addParagraph((p) => {
  p.addText("Logo: ");
  p.addImage(logo, { width: "2cm", height: "1cm", mimeType: "image/png" });
});

doc.addParagraph((p) => {
  p.addBookmark("introduction");
  p.addText("Welcome to the guide.");
});

doc.addParagraph((p) => {
  p.addLink("our website", "https://example.com", { bold: true });
  p.addText(" or go back to the ");
  p.addLink("introduction", "#introduction");
});

doc.addParagraph((p) => {
  p.addText("Item");  p.addTab();
  p.addText("Qty");   p.addTab();
  p.addText("$100.00");
}, {
  tabStops: [
    { position: "6cm" },
    { position: "12cm", type: "right" },
  ],
});

const bytes = await new OdtDocument()
  .setMetadata({ title: "Report" })
  .setPageLayout({ orientation: "landscape" })
  .setHeader("Confidential")
  .setFooter("Page ###")
  .addHeading("Summary", 1)
  .addParagraph("All systems operational.")
  .addTable([["System", "Status"], ["API", "OK"], ["DB", "OK"]])
  .save();

import { OdsDocument } from "odf-kit";

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

sheet.addRow([
  "Text",             // string
  42,                 // float
  new Date("2026-01-15"),  // date
  true,               // boolean
  null,               // empty cell
  { value: "=SUM(B1:B10)", type: "formula" },  // formula — explicit required
]);

// Bold header row with background
sheet.addRow(["Month", "Revenue", "Notes"], {
  bold: true,
  backgroundColor: "#DDDDDD",
  align: "center",
});

// Mixed: row default + per-cell override
sheet.addRow([
  "January",
  { value: 12500, type: "float", color: "#006600" },
  "On track",
], { italic: true });

doc.setDateFormat("DD/MM/YYYY");  // "YYYY-MM-DD" | "DD/MM/YYYY" | "MM/DD/YYYY"
sheet.addRow([{ value: new Date("2026-12-25"), type: "date", dateFormat: "MM/DD/YYYY" }]);

sheet.setColumnWidth(0, "4cm");
sheet.setColumnWidth(1, "8cm");
sheet.setRowHeight(0, "1.5cm");

const doc = new OdsDocument();
const q1 = doc.addSheet("Q1").setTabColor("#4CAF50");
const q2 = doc.addSheet("Q2").setTabColor("#2196F3");
q1.addRow(["Month", "Revenue"], { bold: true });
q1.addRow(["January", 12500]);

const q2sheet = doc.addSheet("Summary");
q2sheet.addRow(["Total", 27700]);

const bytes = await doc.save();

sheet.addRow([{ value: 9999, type: "float", numberFormat: "integer" }]);           // 9,999
sheet.addRow([{ value: 1234.567, type: "float", numberFormat: "decimal:2" }]);     // 1,234.57
sheet.addRow([{ value: 0.1234, type: "percentage", numberFormat: "percentage" }]); // 12.34%
sheet.addRow([{ value: 0.075, type: "percentage", numberFormat: "percentage:1" }]);// 7.5%
sheet.addRow([{ value: 1234.56, type: "currency", numberFormat: "currency:EUR" }]);       // €1,234.56
sheet.addRow([{ value: 99.99, type: "currency", numberFormat: "currency:USD:0" }]);       // $100
sheet.addRow([{ value: 1234.56, type: "currency", numberFormat: "currency:EUR:right" }]); // 1,234.56 €
sheet.addRow([{ value: 1234.5, type: "currency", numberFormat: "currency:EUR:2:right" }]);// 1,234.50 €

// `:right` places the symbol after the value with a non-breaking space —
// matches European typographic convention (France, Germany, Spain, Italy, etc.)

// Row-level number format — applies to all cells in the row
sheet.addRow([1000, 2000, 3000], { numberFormat: "integer" });

// Span across 3 columns
sheet.addRow([{ value: "Q1 Sales Report", type: "string", colSpan: 3, bold: true }]);
sheet.addRow(["Region", "Units", "Revenue"]);

// Span across 2 rows
sheet.addRow([{ value: "North", type: "string", rowSpan: 2 }, "Jan", 12500]);
sheet.addRow(["Feb", 14200]); // "North" continues from above

// Combined colSpan + rowSpan
sheet.addRow([{ value: "Big Cell", type: "string", colSpan: 2, rowSpan: 2 }, "C"]);

// Freeze the header row
sheet.addRow(["Name", "Amount", "Date"], { bold: true });
sheet.freezeRows(1);

// Freeze first column
sheet.freezeColumns(1);

// Both
sheet.freezeRows(1).freezeColumns(1);

sheet.addRow([{
  value: "odf-kit on GitHub",
  type: "string",
  href: "https://github.com/GitHubNewbie0/odf-kit",
}]);

doc.addSheet("Q1").setTabColor("#4CAF50");  // green
doc.addSheet("Q2").setTabColor("#2196F3");  // blue
doc.addSheet("Q3").setTabColor("#F44336");  // red

import { htmlToOdt } from "odf-kit";

const bytes = await htmlToOdt(html);                          // A4 default
const bytes = await htmlToOdt(html, { pageFormat: "letter" }); // US letter

  // Base64 data URL — embedded automatically
  const bytes = await htmlToOdt('<img src="data:image/png;base64,..."/>');

  // Pre-fetched image map (e.g. from WebDAV in odf-kit-service)
  const bytes = await htmlToOdt(html, {
    images: {
      "https://example.com/logo.png": pngBytes,
    },
  });

  // Async fetch callback (Node.js or browser)
  const bytes = await htmlToOdt(html, {
    fetchImage: async (src) => {
      const res = await fetch(src);
      return new Uint8Array(await res.arrayBuffer());
    },
  });

const bytes = await htmlToOdt(html, { normalizer: false });

import { htmlToOdt } from "odf-kit";

// Use parse5 for full HTML5 spec compliance — write a small adapter
// (see ADAPTERS.md for conventions)
htmlToOdt(html, { parser: fromParse5(parse5.parse) });

// Skip normalization (input is already polyglot)
htmlToOdt(html, { normalizer: false });

// Substitute both
htmlToOdt(html, { normalizer: myNormalizer, parser: myParser });

import { markdownToOdt } from "odf-kit";

const bytes = await markdownToOdt(markdownString, { pageFormat: "A4" });
const bytes = await markdownToOdt(markdownString, {
  pageFormat: "letter",
  metadata: { title: "My Document", creator: "Alice" },
});

import { tiptapToOdt } from "odf-kit";

// Basic usage
const bytes = await tiptapToOdt(editor.getJSON(), { pageFormat: "A4" });

// With pre-fetched images
const images = {
  "https://example.com/photo.jpg": jpegBytes,
  "ipfs://Qm...": ipfsImageBytes,
};
const bytes = await tiptapToOdt(editor.getJSON(), { images });

// With custom node handler for app-specific extensions
const bytes = await tiptapToOdt(editor.getJSON(), {
  unknownNodeHandler: (node, doc) => {
    if (node.type === "callout") {
      doc.addParagraph(`⚠️ ${node.content?.[0]?.content?.[0]?.text ?? ""}`)
    }
  },
});

import { readOdt, odtToHtml } from "odf-kit/odt-reader";

const bytes = readFileSync("report.odt");
const model = readOdt(bytes);
const html  = odtToHtml(bytes);

// Tracked changes
const final    = odtToHtml(bytes, {}, { trackedChanges: "final" });
const original = odtToHtml(bytes, {}, { trackedChanges: "original" });
const marked   = odtToHtml(bytes, {}, { trackedChanges: "changes" });

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

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

// Structured model — typed JavaScript values
const model = readOds(bytes);
for (const sheet of model.sheets) {
  console.log(sheet.name);
  for (const row of sheet.rows) {
    for (const cell of row.cells) {
      console.log(cell.colIndex, cell.type, cell.value);
      // e.g. 0 "float" 1234.56
      // e.g. 1 "string" "Hello"
      // e.g. 2 "date" Date { 2026-01-15 }
      // e.g. 3 "formula" 100  (cell.formula = "=SUM(A1:A10)")
      // e.g. 4 "covered" null (part of a merged cell)
    }
  }
}

// HTML table
const html = odsToHtml(bytes);

// Fast mode — values only, no formatting
const model2 = readOds(bytes, { includeFormatting: false });

// A1:C1 merged — reading row 0:
// cell 0: { type: "string", value: "Header", colSpan: 3 }
// cell 1: { type: "covered", value: null, colIndex: 1 }
// cell 2: { type: "covered", value: null, colIndex: 2 }
// cell 3: { type: "string", value: "D1", colIndex: 3 }  ← always correct

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

// Simple conversion
const bytes = await xlsxToOds(readFileSync("report.xlsx"))
writeFileSync("report.ods", bytes)

// With options
const bytes2 = await xlsxToOds(readFileSync("report.xlsx"), {
  dateFormat: "DD/MM/YYYY",
  metadata: { title: "Q4 Report", creator: "Alice" },
})

// Works with ArrayBuffer too (browser-friendly)
const bytes3 = await xlsxToOds(arrayBuffer)

import { odtToTypst, modelToTypst } from "odf-kit/typst";

const typst = odtToTypst(readFileSync("letter.odt"));
writeFileSync("letter.typ", typst);
execSync("typst compile letter.typ letter.pdf");

import { docxToOdt } from "odf-kit/docx"

const { bytes, warnings } = await docxToOdt(input, options?)

interface DocxToOdtOptions {
  pageFormat?:         "A4" | "letter" | "legal" | "A3" | "A5";
  orientation?:        "portrait" | "landscape";
  preservePageLayout?: boolean;              // default: true — read layout from DOCX
  styleMap?:           Record<string, number>; // custom style name → heading level
  metadata?:           { title?: string; creator?: string; description?: string };
}

interface DocxToOdtResult {
  bytes:    Uint8Array;   // the .odt file
  warnings: string[];     // content that could not be fully converted
}

function htmlToOdt(html: string, options?: HtmlToOdtOptions): Promise<Uint8Array>
function markdownToOdt(markdown: string, options?: HtmlToOdtOptions): Promise<Uint8Array>

interface HtmlToOdtOptions {
  pageFormat?: "A4" | "letter" | "legal" | "A3" | "A5"; // default: "A4"
  orientation?: "portrait" | "landscape";
  marginTop?: string;
  marginBottom?: string;
  marginLeft?: string;
  marginRight?: string;
  metadata?: { title?: string; creator?: string; description?: string };
  images?: Record<string, Uint8Array>;
  fetchImage?: (src: string) => Promise<Uint8Array | undefined>;
  normalizer?: Normalizer | false;  // omit for default (Tier 1 normalization);
                                     // false to skip; or supply a custom function
  parser?: Parser;                   // omit for default (odfKitParser);
                                     // or supply a custom function
}

function tiptapToOdt(json: TiptapNode, options?: TiptapToOdtOptions): Promise<Uint8Array>

interface TiptapNode {
  type: string;
  text?: string;
  attrs?: Record<string, unknown>;
  content?: TiptapNode[];
  marks?: TiptapMark[];
}

interface TiptapMark {
  type: string;
  attrs?: Record<string, unknown>;
}

interface TiptapToOdtOptions extends HtmlToOdtOptions {
  images?: Record<string, Uint8Array>;
  unknownNodeHandler?: (node: TiptapNode, doc: OdtDocument) => void;
}

function fillTemplate(templateBytes: Uint8Array, data: TemplateData): Uint8Array

{
  bold?: boolean,
  italic?: boolean,
  fontSize?: number | string,
  fontFamily?: string,
  color?: string,
  underline?: boolean,
  strikethrough?: boolean,
  superscript?: boolean,
  subscript?: boolean,
  highlightColor?: string,
}