@lotics/xlsx 0.1.0

package/src/move_logic.ts

@@ -0,0 +1,63 @@
+// =============================================================================
+// Move Logic
+// =============================================================================
+//
+// Pure spreadsheet move-cells computation. Given a source range and a delta,
+// builds commands to write source cells to the target and delete the originals.
+//
+// No DOM or React dependencies.
+// =============================================================================
+
+import type { Command } from "./command_history";
+import type { WorkbookModel } from "./workbook_model";
+import type { FormulaEngine } from "./formula_engine";
+import { rowColToRef } from "./excel_utils";
+import { setCellValueCommand, deleteCellCommand, batchCommand } from "./spreadsheet_commands";
+
+/**
+ * Compute commands to move a range of cells by a row/col delta.
+ * Returns a batch command, or null if nothing to move.
+ */
+export function computeMoveCommand(
+  workbook: WorkbookModel,
+  engine: FormulaEngine | undefined,
+  sheetIndex: number,
+  sourceRange: { start: { row: number; col: number }; end: { row: number; col: number } },
+  deltaRow: number,
+  deltaCol: number,
+): Command | null {
+  if (deltaRow === 0 && deltaCol === 0) return null;
+
+  const { start, end } = sourceRange;
+  const sheet = workbook.sheets[sheetIndex];
+  const commands: Command[] = [];
+
+  // Write source cells to target
+  for (let r = start.row; r <= end.row; r++) {
+    for (let c = start.col; c <= end.col; c++) {
+      const srcRef = rowColToRef(r, c);
+      const srcCell = sheet.getCell(srcRef);
+      const targetR = r + deltaRow;
+      const targetC = c + deltaCol;
+      const value = srcCell?.formula ? `=${srcCell.formula}` : srcCell?.displayValue ?? "";
+      if (value !== "") {
+        commands.push(setCellValueCommand(workbook, engine, sheetIndex, targetR, targetC, value));
+      }
+    }
+  }
+
+  // Delete source cells (only those not overlapping with target)
+  for (let r = start.row; r <= end.row; r++) {
+    for (let c = start.col; c <= end.col; c++) {
+      const targetR = r + deltaRow;
+      const targetC = c + deltaCol;
+      const isInTarget = targetR >= start.row && targetR <= end.row && targetC >= start.col && targetC <= end.col;
+      if (!isInTarget) {
+        commands.push(deleteCellCommand(workbook, engine, sheetIndex, r, c));
+      }
+    }
+  }
+
+  if (commands.length === 0) return null;
+  return batchCommand("Move cells", commands);
+}

package/src/numfmt_type.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from "vitest";
+import { classifyNumFmt, coerceByNumFmt, parseLocalizedNumber, parseToExcelSerial } from "./numfmt_type";
+
+describe("classifyNumFmt", () => {
+  it("treats empty and General as general", () => {
+    expect(classifyNumFmt(undefined)).toBe("general");
+    expect(classifyNumFmt(null)).toBe("general");
+    expect(classifyNumFmt("")).toBe("general");
+    expect(classifyNumFmt("General")).toBe("general");
+  });
+
+  it("identifies numeric formats", () => {
+    expect(classifyNumFmt("0")).toBe("numeric");
+    expect(classifyNumFmt("#,##0")).toBe("numeric");
+    expect(classifyNumFmt("#,##0.00")).toBe("numeric");
+    expect(classifyNumFmt('#,##0;(#,##0);"-"')).toBe("numeric");
+    expect(classifyNumFmt("0.000")).toBe("numeric");
+  });
+
+  it("identifies percent formats", () => {
+    expect(classifyNumFmt("0%")).toBe("percent");
+    expect(classifyNumFmt("0.0%")).toBe("percent");
+    expect(classifyNumFmt("#,##0.00%;(#,##0.00%)")).toBe("percent");
+  });
+
+  it("identifies currency formats", () => {
+    expect(classifyNumFmt('"$"#,##0.00')).toBe("currency");
+    expect(classifyNumFmt("[$VND-42A]#,##0")).toBe("currency");
+    expect(classifyNumFmt("[$-409]$#,##0.00")).toBe("currency");
+  });
+
+  it("identifies date/time formats", () => {
+    expect(classifyNumFmt("yyyy-mm-dd")).toBe("date");
+    expect(classifyNumFmt("dd/mm/yyyy")).toBe("date");
+    expect(classifyNumFmt("d-mmm-yyyy")).toBe("date");
+    expect(classifyNumFmt("hh:mm:ss")).toBe("date");
+    expect(classifyNumFmt("yyyy-mm-dd hh:mm")).toBe("date");
+    expect(classifyNumFmt('"Date: "yyyy-mm-dd')).toBe("date");
+  });
+
+  it("identifies text format", () => {
+    expect(classifyNumFmt("@")).toBe("text");
+  });
+
+  it("does not misread bare literals as date tokens", () => {
+    // Quoted literals must not trigger date/number heuristics.
+    expect(classifyNumFmt('"Total: "0')).toBe("numeric");
+    expect(classifyNumFmt('"-"')).toBe("general");
+  });
+});
+
+describe("parseLocalizedNumber", () => {
+  it("parses bare numbers", () => {
+    expect(parseLocalizedNumber("0")).toBe(0);
+    expect(parseLocalizedNumber("1234")).toBe(1234);
+    expect(parseLocalizedNumber("1234.56")).toBe(1234.56);
+    expect(parseLocalizedNumber("-1234.56")).toBe(-1234.56);
+  });
+
+  it("parses EU thousand-dot grouping (the VN demo case)", () => {
+    expect(parseLocalizedNumber("308.500.000")).toBe(308500000);
+    expect(parseLocalizedNumber("1.234.567,89")).toBe(1234567.89);
+    expect(parseLocalizedNumber("-1.234,50")).toBe(-1234.5);
+  });
+
+  it("parses US thousand-comma grouping", () => {
+    expect(parseLocalizedNumber("308,500,000")).toBe(308500000);
+    expect(parseLocalizedNumber("1,234,567.89")).toBe(1234567.89);
+  });
+
+  it("parses accountants' parens as negative", () => {
+    expect(parseLocalizedNumber("(1,234)")).toBe(-1234);
+    expect(parseLocalizedNumber("(1.234,56)")).toBe(-1234.56);
+  });
+
+  it("strips leading/trailing currency noise", () => {
+    expect(parseLocalizedNumber("$1,234.56")).toBe(1234.56);
+    expect(parseLocalizedNumber("308.500.000 ₫")).toBe(308500000);
+    expect(parseLocalizedNumber("VND 308.500.000")).toBe(308500000);
+  });
+
+  it("returns null on unambiguous garbage", () => {
+    expect(parseLocalizedNumber("")).toBeNull();
+    expect(parseLocalizedNumber("N/A")).toBeNull();
+    expect(parseLocalizedNumber("abc")).toBeNull();
+    // Ambiguous separator pattern — conservative refusal beats misparsing.
+    expect(parseLocalizedNumber("1.234.56")).toBeNull();
+  });
+});
+
+describe("parseToExcelSerial", () => {
+  it("converts ISO dates to the 1900 serial system", () => {
+    // 2024-01-01 → 45292 (well-known value for the 1900 system).
+    expect(parseToExcelSerial("2024-01-01")).toBe(45292);
+    expect(parseToExcelSerial("2026-04-19")).toBe(46131);
+  });
+
+  it("supports ISO datetime", () => {
+    expect(parseToExcelSerial("2024-01-01T12:00:00")).toBe(45292.5);
+    expect(parseToExcelSerial("2024-01-01 06:00")).toBe(45292.25);
+  });
+
+  it("returns null on non-date strings", () => {
+    expect(parseToExcelSerial("not a date")).toBeNull();
+    expect(parseToExcelSerial("19/04/2026")).toBeNull(); // not ISO
+  });
+});
+
+describe("coerceByNumFmt", () => {
+  it("preserves typed number/boolean regardless of numFmt", () => {
+    expect(coerceByNumFmt(42, "#,##0")).toBe(42);
+    expect(coerceByNumFmt(true, "General")).toBe(true);
+    expect(coerceByNumFmt(0, "#,##0")).toBe(0);
+  });
+
+  it("nulls out null/undefined", () => {
+    expect(coerceByNumFmt(null, "#,##0")).toBeNull();
+    expect(coerceByNumFmt(undefined, "General")).toBeNull();
+  });
+
+  it("coerces locale-formatted strings into numbers for numeric cells", () => {
+    expect(coerceByNumFmt("308.500.000", "#,##0")).toBe(308500000);
+    expect(coerceByNumFmt("308,500,000", "#,##0")).toBe(308500000);
+    expect(coerceByNumFmt("15.425.000", '#,##0;(#,##0);"-"')).toBe(15425000);
+  });
+
+  it("interprets percent strings for percent cells", () => {
+    expect(coerceByNumFmt("5%", "0.0%")).toBeCloseTo(0.05, 10);
+    expect(coerceByNumFmt("0.05", "0.0%")).toBeCloseTo(0.05, 10);
+  });
+
+  it("coerces ISO dates for date cells", () => {
+    expect(coerceByNumFmt("2024-01-01", "yyyy-mm-dd")).toBe(45292);
+  });
+
+  it("falls through to string for non-parseable input", () => {
+    // Non-numeric text in a numeric cell: keep as text rather than inserting
+    // a silent 0 — the author will see it and fix the data.
+    expect(coerceByNumFmt("N/A", "#,##0")).toBe("N/A");
+    expect(coerceByNumFmt("TBD", "0.00%")).toBe("TBD");
+  });
+
+  it("keeps strings for text-format cells", () => {
+    expect(coerceByNumFmt("308500000", "@")).toBe("308500000");
+    expect(coerceByNumFmt("true", "@")).toBe("true");
+  });
+
+  it("coerces in general-format cells as a fallback (boolean then number)", () => {
+    expect(coerceByNumFmt("true", "General")).toBe(true);
+    expect(coerceByNumFmt("FALSE", "General")).toBe(false);
+    expect(coerceByNumFmt("1234", "General")).toBe(1234);
+    expect(coerceByNumFmt("not a value", "General")).toBe("not a value");
+  });
+
+  it("returns empty string for whitespace-only input", () => {
+    expect(coerceByNumFmt("   ", "#,##0")).toBe("");
+  });
+});

package/src/numfmt_type.ts

@@ -0,0 +1,231 @@
+/**
+ * NumFmt classification + value coercion for template substitution.
+ *
+ * Excel cells encode their intended data type via `numFmt` (number format
+ * code). When a template engine substitutes `{{foo}}` into a cell, the
+ * input's JS type (string/number/boolean) must be reconciled with the
+ * cell's intended type. Without coercion, a numeric-looking string like
+ * `"308.500.000"` lands in a number-formatted cell as `t="s"` — SUM
+ * ignores it, cached value is 0, and the zero-section of the numFmt (e.g.
+ * `"-"`) renders in every Excel-compatible reader. That's how the VN demo
+ * báo giá ended up showing dashes in totals despite the agent passing the
+ * "right" (display-formatted) numbers.
+ *
+ * The engine's contract: agents pass semantic values (raw number for
+ * money, ISO string for date). The cell's numFmt handles display. If the
+ * agent does pass a formatted string anyway, we try to parse it so the
+ * file still works.
+ */
+
+export type NumFmtKind = "numeric" | "percent" | "currency" | "date" | "text" | "general";
+
+/**
+ * Classify a cell's numFmt code by the data type it expects.
+ *
+ * Heuristic — OOXML doesn't tag formats with a type, so we inspect tokens:
+ * - `@` → text
+ * - date tokens (`y`/`yyyy`, `d`/`dd`, `h`/`hh`, `s`/`ss`, or adjacent `m`
+ *   within a date sequence like `yyyy-mm-dd`) → date
+ * - `%` → percent
+ * - currency symbols (`$`, `¥`, `€`, `£`, `₫`) or `[$...]` locale tag → currency
+ * - digit placeholders (`#`, `0`, `?`) → numeric
+ * - otherwise (empty, `"General"`, unrecognized) → general
+ *
+ * Format codes can have up to 4 sections (pos;neg;zero;text) separated by
+ * `;`; classification uses the first section since that's the "active"
+ * format for the value being written.
+ */
+export function classifyNumFmt(code: string | undefined | null): NumFmtKind {
+  if (!code || code === "General") return "general";
+
+  const first = code.split(";")[0] ?? code;
+
+  // Currency check runs against the original form: `"$"` and `[$VND-42A]`
+  // are canonical currency markers that sit inside quoted/bracketed
+  // literals and would be erased by the literal-stripping pass below.
+  const currency = hasCurrencyTokens(first);
+
+  const stripped = stripQuotedLiterals(first);
+
+  if (stripped.trim() === "@") return "text";
+
+  if (hasDateTokens(stripped)) return "date";
+  if (stripped.includes("%")) return "percent";
+  if (currency) return "currency";
+  if (/[#0?]/.test(stripped)) return "numeric";
+
+  return "general";
+}
+
+/**
+ * Coerce a substitution value to the type expected by the target cell.
+ *
+ * - Already-typed inputs (number/boolean) are preserved regardless of
+ *   numFmt — trust the caller's explicit type.
+ * - String inputs are parsed according to numFmt kind; on parse failure
+ *   the original string is returned (so "N/A" in a number cell stays as
+ *   text rather than silently becoming 0).
+ * - `null`/`undefined` map to `null` (empty cell).
+ */
+export function coerceByNumFmt(value: unknown, numFmtCode: string | undefined | null): string | number | boolean | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "boolean") return value;
+  if (typeof value !== "string") return String(value);
+
+  const kind = classifyNumFmt(numFmtCode);
+  const trimmed = value.trim();
+  if (trimmed === "") return "";
+
+  // Integer numFmt (no decimal places): `98.680` in a VN context must mean
+  // 98680, not 98.68, since the format can't represent fractions. Pass the
+  // hint down so the parser treats single-dot-3-digits as thousand
+  // grouping instead of a decimal fraction.
+  const isInteger = !hasDecimalPart(numFmtCode ?? "");
+
+  if (kind === "numeric" || kind === "currency") {
+    const n = parseLocalizedNumber(trimmed, { integerOnly: isInteger });
+    if (n !== null) return n;
+  } else if (kind === "percent") {
+    // Accept bare "0.05" or "5%" — convert the latter to 0.05.
+    const hasPct = trimmed.endsWith("%");
+    const n = parseLocalizedNumber(hasPct ? trimmed.slice(0, -1) : trimmed, { integerOnly: false });
+    if (n !== null) return hasPct ? n / 100 : n;
+  } else if (kind === "date") {
+    const serial = parseToExcelSerial(trimmed);
+    if (serial !== null) return serial;
+  } else if (kind === "general") {
+    // Bare-cell, no format hint — try boolean, then numeric, else keep as
+    // string. Common case: a declared "boolean" variable pushed as JS
+    // boolean flows through the typed path above; this branch rescues the
+    // stringified form.
+    if (/^(true|false)$/i.test(trimmed)) return trimmed.toLowerCase() === "true";
+    const n = parseLocalizedNumber(trimmed);
+    if (n !== null) return n;
+  }
+
+  return value;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+// Excel format codes use `"..."` and `\<c>` for literal characters. Strip
+// them before pattern-matching so `"-"` (literal dash in zero-section)
+// doesn't confuse `#` / `0` detection.
+function stripQuotedLiterals(code: string): string {
+  return code
+    .replace(/"[^"]*"/g, "")
+    .replace(/\\./g, "");
+}
+
+function hasDateTokens(code: string): boolean {
+  // Whole-word date tokens: y/yy/yyyy, d/dd/ddd/dddd, h/hh, s/ss, am/pm, a/p.
+  if (/\b(y{1,4}|d{1,4}|h{1,2}|s{1,2}|am\/pm|a\/p)\b/i.test(code)) return true;
+  // `m` is ambiguous (month vs minutes vs literal). Count it as a date
+  // token only when it sits next to another date token — `yyyy-mm-dd`,
+  // `mm/yyyy`, `dd-mmm-yyyy` — to avoid misclassifying `"#,##0.00m"` or
+  // similar numeric suffixes.
+  if (/[ymdhs]\s*[-\/.:\s]\s*m/i.test(code)) return true;
+  if (/m\s*[-\/.:\s]\s*[ymdhs]/i.test(code)) return true;
+  return false;
+}
+
+function hasCurrencyTokens(code: string): boolean {
+  if (/[$¥€£₫¢]/.test(code)) return true;
+  if (/\[\$/.test(code)) return true; // locale-tagged: [$-409], [$VND-42A]
+  return false;
+}
+
+export interface ParseNumberOptions {
+  /**
+   * Resolve the `N.NNN` ambiguity when the target cell's numFmt has no
+   * decimal places (e.g. `#,##0`): treat a single-dot + exactly-three-
+   * digits string as thousand grouping (`98.680` → 98680) rather than a
+   * decimal fraction (→ 98.68). Defaults to `false` — decimal
+   * interpretation is more broadly safe.
+   */
+  integerOnly?: boolean;
+}
+
+/**
+ * Parse a number that may carry locale-specific grouping separators or a
+ * currency prefix/suffix. Supports:
+ * - bare: `1234`, `1234.56`, `-1234.56`
+ * - EU thousand-separator: `1.234.567,89`, `308.500.000`
+ * - US thousand-separator: `1,234,567.89`, `308,500,000`
+ * - accountants' parens for negatives: `(1,234)` → -1234
+ * - currency prefix/suffix: `$1,234.56`, `1.234,56 ₫`, `VND 308.500.000`
+ *
+ * Returns null on ambiguity or unparseable input (so the caller can fall
+ * back to the literal string).
+ */
+export function parseLocalizedNumber(input: string, opts: ParseNumberOptions = {}): number | null {
+  let s = input.trim();
+  if (s === "") return null;
+
+  // Accountants' negative parens: `(1,234)` → `-1,234`.
+  let negParens = false;
+  if (s.startsWith("(") && s.endsWith(")")) {
+    negParens = true;
+    s = s.slice(1, -1).trim();
+  }
+
+  // Strip currency markers only — whitespace, currency symbols, and
+  // common ISO codes at string ends. Letters/digits inside the string
+  // must not be re-interpreted (e.g. `"Thép D16"` must NOT parse as 16).
+  const currencyTrimRe = /^[\s$¥€£₫¢]*(?:VND|VNĐ|USD|EUR|GBP|JPY)?\s*|\s*(?:VND|VNĐ|USD|EUR|GBP|JPY)?[\s$¥€£₫¢%]*$/gi;
+  s = s.replace(currencyTrimRe, "");
+  if (s === "") return null;
+  // Any remaining non-number character disqualifies the string.
+  if (!/^[\d+\-().,\s]+$/.test(s)) return null;
+  s = s.replace(/\s+/g, "");
+
+  let n: number | null = null;
+
+  // Single-dot three-trailing-digits is ambiguous (`1.234` → 1.234 vs
+  // 1234). When the caller hints that the target format has no decimal
+  // places, interpret the dot as thousand grouping.
+  if (opts.integerOnly && /^-?\d+\.\d{3}$/.test(s)) {
+    n = Number(s.replace(".", ""));
+  } else if (/^-?\d+(\.\d+)?$/.test(s)) {
+    n = Number(s);
+  } else if (/^-?\d{1,3}(\.\d{3})+(,\d+)?$/.test(s)) {
+    n = Number(s.replace(/\./g, "").replace(",", "."));
+  } else if (/^-?\d{1,3}(,\d{3})+(\.\d+)?$/.test(s)) {
+    n = Number(s.replace(/,/g, ""));
+  } else if (/^-?\d+,\d+$/.test(s)) {
+    n = Number(s.replace(",", "."));
+  }
+
+  if (n === null || !Number.isFinite(n)) return null;
+  return negParens ? -n : n;
+}
+
+/**
+ * True when the numFmt code contains a decimal part (`0.00`, `#,##0.0#`,
+ * `0.00%`). Used to resolve the single-dot-three-digits ambiguity in
+ * integer-formatted cells.
+ */
+function hasDecimalPart(code: string): boolean {
+  const stripped = stripQuotedLiterals(code.split(";")[0] ?? "");
+  return /\.[0#?]/.test(stripped);
+}
+
+/**
+ * Convert an ISO-ish date string to an Excel 1900-system serial number.
+ *
+ * Supports `YYYY-MM-DD` and `YYYY-MM-DDTHH:mm[:ss]`. Anchor is 1899-12-30
+ * because Excel erroneously treats 1900 as a leap year (dating back to
+ * Lotus 1-2-3 compatibility); the shifted anchor makes dates from
+ * 1900-03-01 onward correct. Dates before that rarely appear in business
+ * templates and aren't worth handling specially.
+ */
+export function parseToExcelSerial(input: string): number | null {
+  const m = input.trim().match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[T\s](\d{1,2}):(\d{2})(?::(\d{2}))?)?$/);
+  if (!m) return null;
+  const [, y, mo, d, hh, mm, ss] = m;
+  const dt = Date.UTC(+y, +mo - 1, +d, Number(hh) || 0, Number(mm) || 0, Number(ss) || 0);
+  if (!Number.isFinite(dt)) return null;
+  const epoch = Date.UTC(1899, 11, 30);
+  return (dt - epoch) / 86400000;
+}

package/src/ooxml_cell_format.ts

@@ -0,0 +1,70 @@
+import type { CellContent, RichTextPart } from "./types";
+import type { SharedStringEntry } from "./ooxml_workbook";
+import { formatNumFmt } from "./excel_numfmt";
+
+// =============================================================================
+// Cell value formatting
+// =============================================================================
+
+/**
+ * Format a raw cell value from XML into a display string.
+ * Delegates all number/date formatting to the excel_numfmt engine.
+ */
+export function formatCellValue(
+  rawValue: string | undefined,
+  type: string,
+  numFmt: string,
+  sharedString?: SharedStringEntry,
+  date1904?: boolean,
+): string {
+  if (rawValue === undefined || rawValue === "") {
+    if (type === "s" && sharedString) return sharedString.text;
+    return "";
+  }
+
+  switch (type) {
+    case "s":
+      return sharedString?.text ?? "";
+    case "b":
+      return rawValue === "1" ? "TRUE" : "FALSE";
+    case "e":
+      return rawValue;
+    case "str":
+    case "inlineStr":
+      return rawValue;
+    default: {
+      const num = parseFloat(rawValue);
+      if (isNaN(num)) return rawValue;
+      return formatNumFmt(num, numFmt, date1904 ?? false).text;
+    }
+  }
+}
+
+/**
+ * Format a number using an Excel number format string.
+ * Thin wrapper around formatNumFmt for backward compatibility.
+ */
+export function formatNumber(value: number, numFmt: string): string {
+  return formatNumFmt(value, numFmt).text;
+}
+
+// =============================================================================
+// Cell content building
+// =============================================================================
+
+export function buildCellContent(
+  displayValue: string,
+  sharedString?: SharedStringEntry,
+  hyperlink?: string,
+): CellContent {
+  if (hyperlink) {
+    return { type: "hyperlink", text: displayValue || hyperlink, url: hyperlink };
+  }
+
+  if (sharedString?.richText) {
+    const parts: RichTextPart[] = sharedString.richText;
+    return { type: "rich_text", parts };
+  }
+
+  return { type: "plain", text: displayValue };
+}

package/src/ooxml_chart.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+import { XMLParser } from "fast-xml-parser";
+import { parseChartXml } from "./ooxml_chart";
+
+const parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  isArray: () => false,
+});
+const parseXml = (xml: string) => parser.parse(xml) as Record<string, unknown>;
+
+const BAR_CHART_XML = `<?xml version="1.0"?>
+<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
+  <c:chart>
+    <c:title><c:tx><c:rich><a:p><a:r><a:t>Sales</a:t></a:r></a:p></c:rich></c:tx></c:title>
+    <c:legend><c:legendPos val="b"/></c:legend>
+    <c:plotArea>
+      <c:barChart>
+        <c:barDir val="bar"/>
+        <c:ser>
+          <c:tx><c:strRef><c:strCache><c:pt idx="0"><c:v>Series1</c:v></c:pt></c:strCache></c:strRef></c:tx>
+          <c:val><c:numRef><c:numCache><c:pt idx="0"><c:v>10</c:v></c:pt><c:pt idx="1"><c:v>20</c:v></c:pt></c:numCache></c:numRef></c:val>
+        </c:ser>
+      </c:barChart>
+      <c:catAx><c:scaling/></c:catAx>
+      <c:valAx><c:scaling/></c:valAx>
+    </c:plotArea>
+  </c:chart>
+</c:chartSpace>`;
+
+const LINE_CHART_XML = `<?xml version="1.0"?>
+<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">
+  <c:chart>
+    <c:plotArea>
+      <c:lineChart>
+        <c:ser>
+          <c:val><c:numRef><c:numCache><c:pt idx="0"><c:v>5</c:v></c:pt></c:numCache></c:numRef></c:val>
+        </c:ser>
+      </c:lineChart>
+    </c:plotArea>
+  </c:chart>
+</c:chartSpace>`;
+
+const EMPTY_CHART_XML = `<?xml version="1.0"?>
+<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">
+  <c:chart>
+    <c:plotArea/>
+  </c:chart>
+</c:chartSpace>`;
+
+describe("parseChartXml", () => {
+  it("parses bar chart with correct type, series, and title", () => {
+    const result = parseChartXml(BAR_CHART_XML, parseXml);
+    expect(result.chartType).toBe("bar");
+    expect(result.title).toBe("Sales");
+    expect(result.series).toHaveLength(1);
+    expect(result.series[0].name).toBe("Series1");
+    expect(result.series[0].values).toEqual([10, 20]);
+  });
+
+  it("parses line chart type", () => {
+    const result = parseChartXml(LINE_CHART_XML, parseXml);
+    expect(result.chartType).toBe("line");
+    expect(result.series).toHaveLength(1);
+    expect(result.series[0].values).toEqual([5]);
+  });
+
+  it("handles empty chart as unknown type with no series", () => {
+    const result = parseChartXml(EMPTY_CHART_XML, parseXml);
+    expect(result.chartType).toBe("unknown");
+    expect(result.series).toEqual([]);
+  });
+
+  it("extracts legend position", () => {
+    const result = parseChartXml(BAR_CHART_XML, parseXml);
+    expect(result.legendPosition).toBe("bottom");
+  });
+
+  it("extracts axes", () => {
+    const result = parseChartXml(BAR_CHART_XML, parseXml);
+    expect(result.axes).toHaveLength(2);
+    expect(result.axes![0].type).toBe("category");
+    expect(result.axes![1].type).toBe("value");
+  });
+});