diff --git a/src/lib/import/CLAUDE.md b/src/lib/import/CLAUDE.md
index bdf8091..4022c58 100644
--- a/src/lib/import/CLAUDE.md
+++ b/src/lib/import/CLAUDE.md
@@ -12,7 +12,7 @@ The **Open .odt** button (`App.svelte`) parses an uploaded file with `importOdt(
- **Default suppression** keeps round trips (editor → LibreOffice → editor) from accreting explicit attrs: values matching the editor's defaults (12pt body, `HEADING_STYLE_OVERRIDES` sizes/margins, **0 paragraph spacing**, list margin 0, Times New Roman/Liberation Serif, `#000000` text) are imported as `null`/no mark, with small tolerances for producer unit rounding (pt↔cm↔twips). This is why the editor's defaults must equal Word's/LibreOffice's (below) — an editor-only default is indistinguishable from a failed style resolution and silently lands in every imported document.
- **Mapping:** `text:h` → heading (level clamped to `MAX_HEADING_LEVEL`), per-depth `text:list-level-style-*` defs decide bullet vs ordered and `listStyleType` (reverse lookup `orderedTypeFromFormat`), tables handle covered cells / `number-columns-repeated` / header rows / colspans / cell shading (`StyleResolver.cellBackgroundColor` → `backgroundColor`) / cell borders (`StyleResolver.cellBorders` + `borderAttrFromOdf` → the per-side border attrs) / table margins (`tableMargins` reads the table style's `fo:margin-*`, `style:width`/`style:rel-width` and `table:align` against `Ctx.contentWidthCm` — so a table narrower than the text width stays narrow instead of being stretched; DOCX does the same from `w:tblInd` + the `w:tblGrid`/`w:tblW` width), `text:s`/`text:tab`/`text:line-break` become spaces/`\t`/`hardBreak`, `draw:frame`/`draw:image` → an `image` node (`convertFrame`: bytes read from the zip's `Pictures/` entry into a data-URI, `svg:width`/`-height` cm → px, `svg:title` → `alt`, `draw:transform` rotate → `rotation`; a non-`as-char` anchor or a graphic style's `style:wrap` → floating `wrap` mode via `StyleResolver.graphicProps` — an **explicit `as-char` anchor is always inline**: LibreOffice's named Graphics style carries a `style:wrap` that would otherwise float every inherited frame), text fields keep their stored value. **Text boxes / shapes** (`convertDrawElement`): `draw:frame`+`draw:text-box` → a `textBox` node (`convertTextBoxFrame`: height = `fo:min-height` else `svg:height`; fill/stroke read straight from `graphicProps`' `draw:fill(-color)`/`draw:stroke`/`svg:stroke-*`, values equal to the editor defaults suppressed, none → explicit `null`); `draw:rect`/`draw:ellipse`/`draw:custom-shape` with a rect/round-rectangle/ellipse preset → a `textBox` with the matching `shapeKind` (`convertShape`; other presets → "Unsupported shapes were removed"). A box is a block node but its frame sits inside a `text:p`, so converted boxes ride `Ctx.pendingBlocks` and `convertBlocks` flushes them after the anchor paragraph (dropping our own export's empty anchor); in cells/other boxes their blocks are unwrapped in place with a warning. The DOCX importer mirrors all of this (`convertWpsShape` for DrawingML `wps:wsp` — probed before the image `a:blip` path, `convertPict` for legacy VML; Word's `mc:AlternateContent` uses only the `mc:Choice` branch so the VML fallback can't double-import).
- **Image formats (`import/imageFormats.ts`, shared by both importers):** `
` only renders a fixed set of formats, so `imageDataUrl(bytes, path)` resolves the mime by extension **then** magic-number (mislabelled/extensionless entries still work) and returns `null` for anything unrenderable — the importer then skips it with a specific "format the browser can't display" warning instead of a broken `
`. A frame's multiple `` alternatives (ODF) and a Word `a:blip`'s `svgBlip` alternative are probed for the first *displayable* one, and ``-wrapped frames are unwrapped (the hyperlink dropped). **Non-web formats we can decode client-side** (currently **TIFF**) are converted to PNG up front by `convertUnsupportedImages(bytes)` — an async pass `applyImport` runs before the synchronous import, passing a `path → PNG data-URI` map (`ConvertedImages`) into `importOdt`/`importDocx` (default empty, so tests stay sync). The decoder (`utif2`) is a **dynamic `import()`** → its own lazy chunk, loaded only when a convertible image is actually present, so ordinary docs pay nothing. **SVM/WMF/EMF** have no JS decoder (SVM is StarOffice-proprietary) → skipped with the format warning; LibreOffice/WASM conversion was ruled out (no backend; WASM LO is ~300MB).
-- **Charts (`import/chart.ts`, DOCX)**: `word/charts/chartN.xml` is parsed and **drawn as an SVG picture** of the frame's own size — series values from the `numCache` the producer left, colours from the named theme accent (`themeAccents`), title/axis titles/gridlines, and the value axis' own `c:scaling` bounds where the file fixes them. Bar (incl. stacked and `barDir="bar"`), line, area, scatter and pie; anything else keeps the placeholder. Read-only — the editor has no chart object, so a re-export carries the picture, not the chart.
+- **Charts (`import/chart.ts`, DOCX)**: `word/charts/chartN.xml` is parsed and **drawn as an SVG picture** of the frame's own size — series values from the `numCache` the producer left, colours from the named theme accent (`themeAccents`), title/axis titles/gridlines, and the value axis' own `c:scaling` bounds where the file fixes them. Bar (incl. stacked and `barDir="bar"`), line, area, scatter and pie; anything else keeps the placeholder. Read-only — the editor has no chart object, so a re-export carries the picture, not the chart. **ODF** charts go through the same drawing (`odfChartDataUrl`, `convertChartFrame`): `` in the `draw:object`'s sub-document, series values read out of its own `local-table` by cell range, colours from the series' `draw:fill-color`, bounds from the y-axis style's `chart:maximum`/`-minimum`.
- **Content controls** (`inlineChildren`, DOCX): a `w:sdt` inside a paragraph — Word wraps every citation and bibliography entry in one — is walked through to its `w:sdtContent`, or the runs inside it never reach the paragraph (the thesis fixture lost every `[7]`-style reference and broke its lines one page short).
- **Formulas** (`convertFormulaFrame`): a `` whose `` resolves to a sub-document with a `math:math` root (or holds one inline) → a `formula` node. Our own `` is preferred; LibreOffice strips it, so the MathML is parsed back to LaTeX instead. **`display` comes from the paragraph** (`aloneInParagraph`), not the object — LibreOffice writes `display="block"` on every formula it re-saves. DOCX: `m:oMath`/`m:oMathPara` sit beside the `w:r` runs in their own namespace, so `convertInline` probes them ahead of its `namespaceURI !== W` guard (that guard silently dropped every Word formula). See `docs/architecture/formulas.md`.
- **Graceful degradation** (collected as `warnings`, surfaced once): footnotes/comments dropped, hyperlinks flattened to text, nested tables flattened to paragraphs, non-`Pictures` drawings dropped, unreadable pictures skipped (each with a warning). Page size is normalized to A4. Floating/wrapped images are imported as left/right/top-bottom wrap (free x/y positions collapse to the nearest side; see `image.ts`).
diff --git a/src/lib/import/chart.ts b/src/lib/import/chart.ts
index 04e143d..a75bd89 100644
--- a/src/lib/import/chart.ts
+++ b/src/lib/import/chart.ts
@@ -277,6 +277,124 @@ export function chartDataUrl(xml: string, widthPx: number, heightPx: number, acc
} catch { return null; }
if (doc.getElementsByTagName('parsererror').length) return null;
const chart = parseChart(doc, accents.length ? accents : DEFAULT_ACCENTS);
- if (!chart) return null;
- return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(chartSvg(chart, w, h))}`;
+ return chart ? svgUrl(chart, w, h) : null;
+}
+
+const svgUrl = (chart: Chart, widthPx: number, heightPx: number) =>
+ `data:image/svg+xml;charset=utf-8,${encodeURIComponent(
+ chartSvg(chart, Math.max(80, Math.round(widthPx)), Math.max(60, Math.round(heightPx))))}`;
+
+// ---- ODF charts ------------------------------------------------------------
+// An embedded ODF chart document (LibreOffice's "Object N/content.xml"): the same
+// picture, read from and the local table that holds its numbers.
+
+const NS_CHART = 'urn:oasis:names:tc:opendocument:xmlns:chart:1.0';
+const NS_TABLE = 'urn:oasis:names:tc:opendocument:xmlns:table:1.0';
+const NS_OFFICE = 'urn:oasis:names:tc:opendocument:xmlns:office:1.0';
+const NS_STYLE = 'urn:oasis:names:tc:opendocument:xmlns:style:1.0';
+const NS_DRAW = 'urn:oasis:names:tc:opendocument:xmlns:drawing:1.0';
+
+const ODF_PLOTS: Record = {
+ bar: 'bar', line: 'line', circle: 'pie', ring: 'pie', area: 'area', scatter: 'scatter',
+};
+
+// "local-table.$B$2:.$B$24" → the column index and the row span it covers (1-based,
+// as the sheet counts them). Only single-column ranges occur in a chart's own table.
+function cellRange(addr: string | null): { col: number; from: number; to: number } | null {
+ const m = /\.?\$?([A-Z]+)\$?(\d+)(?::\.?\$?[A-Z]+\$?(\d+))?/.exec(addr ?? '');
+ if (!m) return null;
+ const col = [...m[1]].reduce((a, ch) => a * 26 + (ch.charCodeAt(0) - 64), 0);
+ return { col, from: +m[2], to: +(m[3] ?? m[2]) };
+}
+
+// The chart's own as rows of cells, repeats expanded. A cell's number is
+// office:value; its label is the text, which is what a category axis shows.
+function localTable(chart: Element): { num: (number | null)[]; text: string[] }[] {
+ const table = chart.getElementsByTagNameNS(NS_TABLE, 'table')[0];
+ const rows: { num: (number | null)[]; text: string[] }[] = [];
+ for (const tr of Array.from(table?.getElementsByTagNameNS(NS_TABLE, 'table-row') ?? [])) {
+ const num: (number | null)[] = [];
+ const text: string[] = [];
+ for (const td of Array.from(tr.children)) {
+ if (td.namespaceURI !== NS_TABLE || !td.localName.startsWith('table-cell')) continue;
+ const repeat = Math.min(64, parseInt(td.getAttributeNS(NS_TABLE, 'number-columns-repeated') ?? '1', 10) || 1);
+ const raw = td.getAttributeNS(NS_OFFICE, 'value');
+ const v = raw != null ? parseFloat(raw) : NaN;
+ for (let i = 0; i < repeat; i++) {
+ num.push(Number.isFinite(v) ? v : null);
+ text.push((td.textContent ?? '').trim());
+ }
+ }
+ rows.push({ num, text });
+ }
+ return rows;
+}
+
+const odfStyleProp = (styles: Map, name: string | null, ns: string, family: string, attr: string) => {
+ const props = styles.get(name ?? '')?.getElementsByTagNameNS(NS_STYLE, family)[0];
+ return props?.getAttributeNS(ns, attr) ?? null;
+};
+
+function parseOdfChart(doc: Document): Chart | null {
+ const chart = doc.getElementsByTagNameNS(NS_CHART, 'chart')[0];
+ const kind = ODF_PLOTS[(chart?.getAttributeNS(NS_CHART, 'class') ?? '').replace(/^chart:/, '')];
+ if (!chart || !kind) return null;
+ const styles = new Map();
+ for (const st of Array.from(doc.getElementsByTagNameNS(NS_STYLE, 'style'))) {
+ const n = st.getAttributeNS(NS_STYLE, 'name');
+ if (n) styles.set(n, st);
+ }
+ const plotArea = chart.getElementsByTagNameNS(NS_CHART, 'plot-area')[0] ?? null;
+ const rows = localTable(chart);
+ const column = (addr: string | null, pick: 'num' | 'text') => {
+ const range = cellRange(addr);
+ if (!range) return [];
+ return rows.slice(range.from - 1, range.to).map((row) => (row?.[pick][range.col - 1] ?? null));
+ };
+
+ const axis = (dim: string) => Array.from(plotArea?.getElementsByTagNameNS(NS_CHART, 'axis') ?? [])
+ .find((a) => a.getAttributeNS(NS_CHART, 'dimension') === dim) ?? null;
+ const titleOf = (el: Element | null) =>
+ (el?.getElementsByTagNameNS(NS_CHART, 'title')[0]?.textContent ?? '').trim();
+ const yStyle = axis('y')?.getAttributeNS(NS_CHART, 'style-name') ?? null;
+ const bound = (attr: string) => {
+ const v = parseFloat(odfStyleProp(styles, yStyle, NS_CHART, 'chart-properties', attr) ?? '');
+ return Number.isFinite(v) ? v : null;
+ };
+
+ const series: Series[] = Array.from(plotArea?.getElementsByTagNameNS(NS_CHART, 'series') ?? []).map((ser, i) => {
+ const fill = odfStyleProp(styles, ser.getAttributeNS(NS_CHART, 'style-name'), NS_DRAW, 'graphic-properties', 'fill-color');
+ const label = column(ser.getAttributeNS(NS_CHART, 'label-cell-address'), 'text')[0];
+ return {
+ name: (typeof label === 'string' && label) || `Series ${i + 1}`,
+ color: fill ?? DEFAULT_ACCENTS[i % DEFAULT_ACCENTS.length],
+ values: column(ser.getAttributeNS(NS_CHART, 'values-cell-range-address'), 'num') as (number | null)[],
+ };
+ });
+ if (!series.length) return null;
+
+ const catAddr = plotArea?.getElementsByTagNameNS(NS_CHART, 'categories')[0]
+ ?.getAttributeNS(NS_TABLE, 'cell-range-address') ?? null;
+ return {
+ kind: kind === 'bar' && odfStyleProp(styles, plotArea?.getAttributeNS(NS_CHART, 'style-name') ?? null,
+ NS_CHART, 'chart-properties', 'vertical') === 'true' ? 'hbar' : kind,
+ stacked: odfStyleProp(styles, plotArea?.getAttributeNS(NS_CHART, 'style-name') ?? null,
+ NS_CHART, 'chart-properties', 'stacked') === 'true',
+ title: titleOf(chart),
+ cats: column(catAddr, 'text').map((v) => (typeof v === 'string' ? v : '')),
+ series,
+ legend: !!chart.getElementsByTagNameNS(NS_CHART, 'legend').length,
+ grid: !!axis('y')?.getElementsByTagNameNS(NS_CHART, 'grid').length,
+ catTitle: titleOf(axis('x')),
+ valTitle: titleOf(axis('y')),
+ axMin: bound('minimum'),
+ axMax: bound('maximum'),
+ };
+}
+
+// An embedded ODF chart document as an SVG data-URI, or null when it holds no plot
+// this can draw — the caller then keeps its placeholder.
+export function odfChartDataUrl(doc: Document, widthPx: number, heightPx: number): string | null {
+ const chart = parseOdfChart(doc);
+ return chart ? svgUrl(chart, widthPx, heightPx) : null;
}
diff --git a/src/lib/import/odt.ts b/src/lib/import/odt.ts
index e2dc637..d695a07 100644
--- a/src/lib/import/odt.ts
+++ b/src/lib/import/odt.ts
@@ -4,6 +4,7 @@ import { HEADING_STYLE_OVERRIDES, MAX_HEADING_LEVEL, ODF_LOOK_ATTRS, normalizeCo
import { builtinStyleSheet, DEFAULT_STYLE, type ParaProps, type Style, type StyleSheet, type TextProps } from '../styles/styleSheet';
import { HEADER_SHADE } from '../editor/extensions/tableHeaderRow';
import { fitInlineImage } from '../editor/extensions/image';
+import { odfChartDataUrl } from './chart';
import { formatTabStops } from '../editor/extensions/tabStops';
import type { CapsMode, LineStyle } from '../editor/extensions/textEffects';
import { TABLE_REGIONS, tableLookAttr, type TableLook, type TableRegion } from '../styles/tableStyles';
@@ -313,6 +314,25 @@ function convertFormulaFrame(frame: Element, ctx: Ctx): Node | null {
return { type: 'formula', attrs: { latex, display: aloneInParagraph(frame) } };
}
+// A holding a chart object → an image node drawing it, at the frame's own
+// size. Read-only, like the DOCX leg: the editor has no chart object, so a re-export
+// carries the picture (see import/chart.ts).
+function convertChartFrame(frame: Element, ctx: Ctx): Node | null {
+ const obj = Array.from(frame.children).find(
+ c => c.namespaceURI === NS.draw && (c.localName === 'object' || c.localName === 'object-ole'),
+ );
+ const wCm = lengthToCm(frame.getAttributeNS(NS.svg, 'width'));
+ const hCm = lengthToCm(frame.getAttributeNS(NS.svg, 'height'));
+ if (!obj || wCm == null || hCm == null) return null;
+ const doc = loadObjectDoc(obj.getAttributeNS(NS.xlink, 'href'), ctx);
+ const src = doc && odfChartDataUrl(doc, cmToPx(wCm), cmToPx(hCm));
+ if (!src) return null;
+ const attrs: Record = { src, width: Math.round(cmToPx(wCm)), height: Math.round(cmToPx(hCm)), alt: 'Chart' };
+ applyFrameRotationAndWrap(frame, attrs, ctx.resolver.graphicProps(frame.getAttributeNS(NS.draw, 'style-name')));
+ if (!attrs.wrap || attrs.wrap === 'inline') fitInlineImage(attrs, Math.floor(cmToPx(ctx.contentWidthCm)));
+ return { type: 'image', attrs };
+}
+
// A display formula is one that owns its line — ODF has no flag for it (LibreOffice
// writes display="block" on every formula object it re-saves), so it is read off the
// paragraph: nothing but this frame in it.
@@ -326,16 +346,22 @@ function aloneInParagraph(frame: Element): boolean {
// The embedded object's content.xml — an ODF formula document's root is the MathML
// itself. A non-formula object (chart, spreadsheet) has no math root and falls through.
function loadFormulaObject(href: string | null, ctx: Ctx): Element | null {
+ const doc = loadObjectDoc(href, ctx);
+ const root = doc?.documentElement;
+ if (!root) return null;
+ return root.namespaceURI === NS.math && root.localName === 'math'
+ ? root
+ : doc!.getElementsByTagNameNS(NS.math, 'math')[0] ?? null;
+}
+
+// The sub-document a draw:object points at ("./Object 1" → "Object 1/content.xml").
+function loadObjectDoc(href: string | null, ctx: Ctx): Document | null {
const dir = (href ?? '').replace(/^\.\//, '').replace(/\/$/, '');
if (!dir) return null;
const bytes = ctx.files[`${dir}/content.xml`] ?? ctx.files[dir];
if (!bytes) return null;
const doc = new DOMParser().parseFromString(strFromU8(bytes), 'text/xml');
- const root = doc.documentElement;
- if (!root || doc.getElementsByTagName('parsererror').length) return null;
- return root.namespaceURI === NS.math && root.localName === 'math'
- ? root
- : doc.getElementsByTagNameNS(NS.math, 'math')[0] ?? null;
+ return doc.documentElement && !doc.getElementsByTagName('parsererror').length ? doc : null;
}
// draw:rect / draw:ellipse / draw:custom-shape (rect/round-rect/ellipse preset) → a
@@ -378,6 +404,8 @@ function convertDrawElement(e: Element, ctx: Ctx): { inline?: Node; block?: Node
if (textBoxEl) return { block: convertTextBoxFrame(e, textBoxEl, ctx) };
const formula = convertFormulaFrame(e, ctx);
if (formula) return { inline: formula };
+ const chart = convertChartFrame(e, ctx);
+ if (chart) return { inline: chart };
const hasImage = !!e.getElementsByTagNameNS(NS.draw, 'image')[0];
const img = convertFrame(e, ctx);
if (img) return { inline: img };
diff --git a/tests/unit/chart.test.ts b/tests/unit/chart.test.ts
index 86126ce..0dc0fe8 100644
--- a/tests/unit/chart.test.ts
+++ b/tests/unit/chart.test.ts
@@ -1,7 +1,7 @@
// A DrawingML chart part drawn as an SVG picture (import/chart.ts): series values,
// the file's own axis bounds, and the 1..n categories a chart without any gets.
import { describe, it, expect } from 'vitest';
-import { chartDataUrl } from '../../src/lib/import/chart';
+import { chartDataUrl, odfChartDataUrl } from '../../src/lib/import/chart';
const C = 'xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"';
const A = 'xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"';
@@ -57,3 +57,58 @@ describe('a chart part', () => {
});
});
+
+// ---- ODF charts: plus the local table that holds its numbers ----
+
+const NSDECL = 'xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0"'
+ + ' xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"'
+ + ' xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"'
+ + ' xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"'
+ + ' xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"'
+ + ' xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"';
+
+const row = (cells: string[]) => `${cells.map((c) => c).join('')}`;
+const strCell = (s: string) => `${s}`;
+const numCell = (v: number) => `${v}`;
+
+const odfChart = (cls: string) =>
+ `` +
+ `` +
+ `` +
+ `` +
+ `Phase Std` +
+ `` +
+ `interferogram` +
+ `` +
+ `` +
+ `` +
+ `` +
+ `` +
+ row([strCell(''), strCell('Series1')]) +
+ row([strCell('Mo'), numCell(1)]) + row([strCell('Di'), numCell(2)]) + row([strCell('Mi'), numCell(3)]) +
+ ``;
+
+const odfSvg = (cls: string) => {
+ const doc = new DOMParser().parseFromString(odfChart(cls), 'application/xml');
+ const url = odfChartDataUrl(doc, 400, 300);
+ expect(url?.startsWith('data:image/svg+xml')).toBe(true);
+ return decodeURIComponent(url!.replace(/^data:image\/svg\+xml;charset=utf-8,/, ''));
+};
+
+describe('an ODF chart object', () => {
+ it('draws its series from the local table, in the file’s own colour', () => {
+ const svg = odfSvg('chart:bar');
+ expect(svg).toContain('Phase Std');
+ expect(svg).toContain('interferogram');
+ expect(svg).toContain('#22AA33');
+ expect(svg).toContain('>Di<');
+ expect((svg.match(/ {
+ expect(odfSvg('chart:bar')).toContain('>4<');
+ const doc = new DOMParser().parseFromString(odfChart('chart:surface'), 'application/xml');
+ expect(odfChartDataUrl(doc, 400, 300)).toBeNull();
+ });
+});