@deckflow/deckuse 1.2.1 → 1.3.1

package/dist/pptx/table.js

@@ -0,0 +1,638 @@
+import { err, ok } from '../core/index.js';
+import { applyShapeProperties, shapePropertyKeys, } from './properties.js';
+import { readSlideSize } from './slide-size.js';
+import { estimateTableHeightEmu, estimateTableRowHeightEmu, measureTableLayout, } from './table-measure.js';
+import { NS, attr, children, descendants, first, setNodeText } from './xml.js';
+const DEFAULT_ROW_H = '370840';
+const DEFAULT_COL_W = '914400';
+const EMU_PER_PT = 12700;
+const DEFAULT_STROKE_PT = 1;
+const MAX_LINE_WIDTH_EMU = 20116800; // ST_LineWidth maxInclusive
+const MAX_LINE_WIDTH_PT = MAX_LINE_WIDTH_EMU / EMU_PER_PT;
+/** DrawingML 2014 table unique ids (PowerPoint writes these on modern tables). */
+const NS_A16 = 'http://schemas.microsoft.com/office/drawing/2014/main';
+const COL_ID_URI = '{9D8B030D-6E8A-4147-A177-3AD203B41FA5}';
+const ROW_ID_URI = '{0D108BD9-81ED-4DB2-BD59-A6C34878D82A}';
+/** Convert line.width to EMU. Values above max pt are treated as already-EMU. */
+const lineWidthToEmu = (width) => {
+    const emu = width > MAX_LINE_WIDTH_PT ? Math.round(width) : Math.round(width * EMU_PER_PT);
+    return Math.min(MAX_LINE_WIDTH_EMU, Math.max(1, emu));
+};
+const STROKE_ALIASES = ['stroke', 'border', 'outline', 'line'];
+const TABLE_CELL_BORDER_SIDES = ['lnL', 'lnR', 'lnT', 'lnB'];
+const TABLE_CELL_BORDER_LOCAL = new Set([
+    ...TABLE_CELL_BORDER_SIDES,
+    'lnTlToBr',
+    'lnBlToTr',
+    'cell3D',
+]);
+const TABLE_CELL_FILL_LOCAL = new Set([
+    'noFill',
+    'solidFill',
+    'gradFill',
+    'blipFill',
+    'pattFill',
+    'grpFill',
+]);
+const SHAPE_KEY_SET = new Set(shapePropertyKeys);
+/** Insert fill after border sides (OOXML CT_TableCellProperties order). */
+const insertTcPrFill = (tcPr, fill) => {
+    const kids = children(tcPr);
+    let lastBorder;
+    for (const child of kids)
+        if (child.localName && TABLE_CELL_BORDER_LOCAL.has(child.localName))
+            lastBorder = child;
+    if (lastBorder?.nextSibling)
+        tcPr.insertBefore(fill, lastBorder.nextSibling);
+    else if (lastBorder)
+        tcPr.appendChild(fill);
+    else if (tcPr.firstChild)
+        tcPr.insertBefore(fill, tcPr.firstChild);
+    else
+        tcPr.appendChild(fill);
+};
+/** Insert a border side before fill / margins (OOXML CT_TableCellProperties order). */
+const insertTcPrBorder = (tcPr, ln) => {
+    const kids = children(tcPr);
+    const fillOrLater = kids.find((child) => child.localName && !TABLE_CELL_BORDER_LOCAL.has(child.localName));
+    if (fillOrLater)
+        tcPr.insertBefore(ln, fillOrLater);
+    else
+        tcPr.appendChild(ln);
+};
+const directChildren = (node, localName) => children(node).filter((c) => c.localName === localName);
+const normalizeColor = (value) => {
+    const hex = value.trim().replace(/^#/, '').toUpperCase();
+    if (!/^[0-9A-F]{6}$/.test(hex))
+        throw new Error(`Invalid color: ${value}`);
+    return hex;
+};
+const isNone = (value) => {
+    if (value === null || value === false || value === 'none')
+        return true;
+    return (typeof value === 'object' &&
+        value !== null &&
+        'type' in value &&
+        value.type === 'none');
+};
+const tblOf = (node) => {
+    const tbl = first(node, 'tbl');
+    if (!tbl)
+        throw new Error('Table element has no a:tbl');
+    return tbl;
+};
+const makeCell = (doc, text = '') => {
+    const tc = doc.createElementNS(NS.a, 'a:tc');
+    const txBody = doc.createElementNS(NS.a, 'a:txBody');
+    txBody.appendChild(doc.createElementNS(NS.a, 'a:bodyPr'));
+    txBody.appendChild(doc.createElementNS(NS.a, 'a:lstStyle'));
+    const p = doc.createElementNS(NS.a, 'a:p');
+    const r = doc.createElementNS(NS.a, 'a:r');
+    const t = doc.createElementNS(NS.a, 'a:t');
+    t.appendChild(doc.createTextNode(text));
+    r.appendChild(t);
+    p.appendChild(r);
+    txBody.appendChild(p);
+    tc.appendChild(doc.createElementNS(NS.a, 'a:tcPr'));
+    return tc;
+};
+/** Clone a cell's formatting (tcPr, bodyPr, lstStyle, pPr, rPr) and set plain text. */
+const cloneCellWithText = (template, text) => {
+    const doc = template.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    const tc = template.cloneNode(true);
+    // Drop a16 / extLst unique ids that must not be duplicated on the new cell.
+    for (const extLst of [...descendants(tc, 'extLst')])
+        extLst.parentNode?.removeChild(extLst);
+    setNodeText(tc, text);
+    return tc;
+};
+const growFrame = (graphicFrame, deltaCx, deltaCy) => {
+    const xfrm = first(graphicFrame, 'xfrm');
+    const ext = xfrm ? first(xfrm, 'ext') : undefined;
+    if (!ext)
+        return;
+    if (deltaCx !== 0) {
+        const cx = Number(attr(ext, 'cx') ?? 0);
+        ext.setAttribute('cx', String(Math.max(1, Math.round(cx + deltaCx))));
+    }
+    if (deltaCy !== 0) {
+        const cy = Number(attr(ext, 'cy') ?? 0);
+        ext.setAttribute('cy', String(Math.max(1, Math.round(cy + deltaCy))));
+    }
+};
+const frameBoxOf = (node) => {
+    const xfrm = first(node, 'xfrm');
+    const off = xfrm ? first(xfrm, 'off') : undefined;
+    const ext = xfrm ? first(xfrm, 'ext') : undefined;
+    if (!off || !ext)
+        return undefined;
+    const x = Number(attr(off, 'x') ?? 0);
+    const y = Number(attr(off, 'y') ?? 0);
+    const cx = Number(attr(ext, 'cx') ?? 0);
+    const cy = Number(attr(ext, 'cy') ?? 0);
+    if (![x, y, cx, cy].every(Number.isFinite))
+        return undefined;
+    return { x, y, cx, cy };
+};
+const boxesIntersect = (a, b) => a.x < b.x + b.cx && a.x + a.cx > b.x && a.y < b.y + b.cy && a.y + a.cy > b.y;
+const SHAPE_FRAME_LOCAL = new Set(['sp', 'pic', 'graphicFrame', 'cxnSp', 'grpSp']);
+/** Warn when a grown table overlaps peers or extends past the slide bottom. */
+export const tableLayoutWarnings = (graphicFrame, context) => {
+    const box = frameBoxOf(graphicFrame);
+    if (!box)
+        return [];
+    const diagnostics = [];
+    if (context?.archive) {
+        const { heightEmu } = readSlideSize(context.archive);
+        if (box.y + box.cy > heightEmu) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'TABLE_EXTENDS_PAST_SLIDE',
+                message: `Table bottom (${String(box.y + box.cy)} EMU) extends past slide height (${String(heightEmu)} EMU)`,
+                details: { bottomEmu: box.y + box.cy, slideHeightEmu: heightEmu },
+            });
+        }
+    }
+    const doc = graphicFrame.ownerDocument;
+    if (!doc)
+        return diagnostics;
+    for (const peer of descendants(doc)) {
+        if (peer === graphicFrame)
+            continue;
+        if (!peer.localName || !SHAPE_FRAME_LOCAL.has(peer.localName))
+            continue;
+        const other = frameBoxOf(peer);
+        if (!other || other.cx <= 0 || other.cy <= 0)
+            continue;
+        if (boxesIntersect(box, other)) {
+            const name = attr(first(peer, 'cNvPr'), 'name') ?? peer.localName;
+            diagnostics.push({
+                severity: 'warning',
+                code: 'TABLE_OVERLAPS_SHAPE',
+                message: `Table frame overlaps shape "${name}" after structural edit; consider setTableLayout to reflow`,
+                details: { peer: name },
+            });
+            break;
+        }
+    }
+    return diagnostics;
+};
+/** True when any gridCol already carries a16:colId (PowerPoint modern table). */
+const tableUsesColIds = (tbl) => descendants(tbl, 'colId').some((el) => el.namespaceURI === NS_A16 || el.prefix === 'a16' || el.localName === 'colId');
+/** True when any row already carries a16:rowId. */
+const tableUsesRowIds = (tbl) => descendants(tbl, 'rowId').some((el) => el.namespaceURI === NS_A16 || el.prefix === 'a16' || el.localName === 'rowId');
+const nextTableUniqueId = (tbl, localName) => {
+    let max = 0;
+    for (const el of descendants(tbl, localName)) {
+        const n = Number(attr(el, 'val') ?? 0);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    // PowerPoint typically uses 10000+ for rows and 20000+ for cols; stay above either.
+    return String(Math.max(max + 1, localName === 'colId' ? 20000 : 10000));
+};
+const attachA16Id = (parent, kind, id) => {
+    const doc = parent.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    const uri = kind === 'colId' ? COL_ID_URI : ROW_ID_URI;
+    const extLst = doc.createElementNS(NS.a, 'a:extLst');
+    const ext = doc.createElementNS(NS.a, 'a:ext');
+    ext.setAttribute('uri', uri);
+    const idEl = doc.createElementNS(NS_A16, `a16:${kind}`);
+    idEl.setAttribute('val', id);
+    ext.appendChild(idEl);
+    extLst.appendChild(ext);
+    parent.appendChild(extLst);
+};
+const parseIndex = (value, name) => {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0)
+        return value;
+    if (typeof value === 'object' && value !== null && 'index' in value) {
+        const index = value.index;
+        if (typeof index === 'number' && Number.isInteger(index) && index >= 0)
+            return index;
+    }
+    throw new Error(`${name} requires a non-negative integer index`);
+};
+const cellsFromSpec = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const cells = value.cells;
+    if (cells === undefined)
+        return undefined;
+    if (!Array.isArray(cells) || !cells.every((c) => typeof c === 'string'))
+        throw new Error('cells must be an array of strings');
+    return cells;
+};
+export function insertTableRow(node, spec) {
+    const tbl = tblOf(node);
+    const doc = node.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    const index = parseIndex(spec, 'insertRow');
+    const rows = directChildren(tbl, 'tr');
+    const grid = first(tbl, 'tblGrid');
+    const colCount = grid
+        ? directChildren(grid, 'gridCol').length
+        : rows[0]
+            ? directChildren(rows[0], 'tc').length
+            : 1;
+    const texts = cellsFromSpec(spec) ?? Array.from({ length: colCount }, () => '');
+    // Inherit from the row at the insert point, or the last row when appending.
+    const templateRow = rows[index] ?? rows[rows.length - 1];
+    const templateCells = templateRow ? directChildren(templateRow, 'tc') : [];
+    const rowH = templateRow ? (attr(templateRow, 'h') ?? DEFAULT_ROW_H) : DEFAULT_ROW_H;
+    const tr = doc.createElementNS(NS.a, 'a:tr');
+    tr.setAttribute('h', rowH);
+    for (let i = 0; i < colCount; i++) {
+        const text = texts[i] ?? '';
+        const template = templateCells[i];
+        tr.appendChild(template ? cloneCellWithText(template, text) : makeCell(doc, text));
+    }
+    // Keep a16:rowId complete when the source table already uses them — partial
+    // coverage makes PowerPoint prompt to repair the package.
+    if (tableUsesRowIds(tbl))
+        attachA16Id(tr, 'rowId', nextTableUniqueId(tbl, 'rowId'));
+    const anchor = rows[index];
+    if (anchor)
+        tbl.insertBefore(tr, anchor);
+    else
+        tbl.appendChild(tr);
+    growFrame(node, 0, Number(rowH) || Number(DEFAULT_ROW_H));
+}
+export function deleteTableRow(node, spec) {
+    const tbl = tblOf(node);
+    const index = parseIndex(spec, 'deleteRow');
+    const rows = directChildren(tbl, 'tr');
+    if (rows.length <= 1)
+        throw new Error('Cannot delete the last table row');
+    const row = rows[index];
+    if (!row)
+        throw new Error(`deleteRow index ${String(index)} out of range`);
+    tbl.removeChild(row);
+}
+export function insertTableColumn(node, spec) {
+    const tbl = tblOf(node);
+    const doc = node.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    const index = parseIndex(spec, 'insertColumn');
+    let grid = first(tbl, 'tblGrid');
+    if (!grid) {
+        grid = doc.createElementNS(NS.a, 'a:tblGrid');
+        const firstRow = directChildren(tbl, 'tr')[0];
+        if (firstRow)
+            tbl.insertBefore(grid, firstRow);
+        else
+            tbl.appendChild(grid);
+    }
+    const cols = directChildren(grid, 'gridCol');
+    const templateCol = cols[index] ?? cols[cols.length - 1];
+    const colW = templateCol ? (attr(templateCol, 'w') ?? DEFAULT_COL_W) : DEFAULT_COL_W;
+    const gridCol = doc.createElementNS(NS.a, 'a:gridCol');
+    gridCol.setAttribute('w', colW);
+    if (tableUsesColIds(tbl))
+        attachA16Id(gridCol, 'colId', nextTableUniqueId(tbl, 'colId'));
+    const colAnchor = cols[index];
+    if (colAnchor)
+        grid.insertBefore(gridCol, colAnchor);
+    else
+        grid.appendChild(gridCol);
+    for (const row of directChildren(tbl, 'tr')) {
+        const cells = directChildren(row, 'tc');
+        const template = cells[index] ?? cells[cells.length - 1];
+        const cell = template ? cloneCellWithText(template, '') : makeCell(doc, '');
+        const cellAnchor = cells[index];
+        if (cellAnchor)
+            row.insertBefore(cell, cellAnchor);
+        else
+            row.appendChild(cell);
+    }
+    growFrame(node, Number(colW) || Number(DEFAULT_COL_W), 0);
+}
+export function deleteTableColumn(node, spec) {
+    const tbl = tblOf(node);
+    const index = parseIndex(spec, 'deleteColumn');
+    const grid = first(tbl, 'tblGrid');
+    const cols = grid ? directChildren(grid, 'gridCol') : [];
+    const rowCells = directChildren(tbl, 'tr').map((r) => directChildren(r, 'tc').length);
+    if ((cols.length || Math.max(0, ...rowCells)) <= 1)
+        throw new Error('Cannot delete the last table column');
+    if (grid) {
+        const col = cols[index];
+        if (!col)
+            throw new Error(`deleteColumn index ${String(index)} out of range`);
+        grid.removeChild(col);
+    }
+    for (const row of directChildren(tbl, 'tr')) {
+        const cells = directChildren(row, 'tc');
+        const cell = cells[index];
+        if (!cell)
+            throw new Error(`deleteColumn index ${String(index)} out of range`);
+        row.removeChild(cell);
+    }
+}
+export function setTableCellFill(cell, value) {
+    const doc = cell.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    let tcPr = directChildren(cell, 'tcPr')[0] ?? first(cell, 'tcPr');
+    if (!tcPr) {
+        tcPr = doc.createElementNS(NS.a, 'a:tcPr');
+        cell.appendChild(tcPr);
+    }
+    for (const child of [...children(tcPr)])
+        if (child.localName && TABLE_CELL_FILL_LOCAL.has(child.localName))
+            tcPr.removeChild(child);
+    if (isNone(value)) {
+        insertTcPrFill(tcPr, doc.createElementNS(NS.a, 'a:noFill'));
+        return;
+    }
+    let color;
+    if (typeof value === 'string')
+        color = normalizeColor(value);
+    else if (typeof value === 'object' && value !== null) {
+        const record = value;
+        if (typeof record['color'] !== 'string')
+            throw new Error('fill.color must be a hex string');
+        color = normalizeColor(record['color']);
+    }
+    else
+        throw new Error('Unsupported fill value');
+    const solidFill = doc.createElementNS(NS.a, 'a:solidFill');
+    const srgb = doc.createElementNS(NS.a, 'a:srgbClr');
+    srgb.setAttribute('val', color);
+    solidFill.appendChild(srgb);
+    insertTcPrFill(tcPr, solidFill);
+}
+const ensureTcPr = (cell) => {
+    const doc = cell.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    let tcPr = directChildren(cell, 'tcPr')[0] ?? first(cell, 'tcPr');
+    if (!tcPr) {
+        tcPr = doc.createElementNS(NS.a, 'a:tcPr');
+        cell.appendChild(tcPr);
+    }
+    return tcPr;
+};
+const tableCells = (node) => directChildren(tblOf(node), 'tr').flatMap((tr) => directChildren(tr, 'tc'));
+const setTableCellBorders = (cell, value) => {
+    const doc = cell.ownerDocument;
+    if (!doc)
+        throw new Error('Element has no document');
+    const tcPr = ensureTcPr(cell);
+    for (const child of [...children(tcPr)])
+        if (child.localName && TABLE_CELL_BORDER_SIDES.includes(child.localName))
+            tcPr.removeChild(child);
+    if (isNone(value)) {
+        for (const side of TABLE_CELL_BORDER_SIDES) {
+            const ln = doc.createElementNS(NS.a, `a:${side}`);
+            ln.appendChild(doc.createElementNS(NS.a, 'a:noFill'));
+            insertTcPrBorder(tcPr, ln);
+        }
+        return;
+    }
+    let color = '0000FF';
+    let widthPt = DEFAULT_STROKE_PT;
+    let dash;
+    if (typeof value === 'string')
+        color = normalizeColor(value);
+    else if (typeof value === 'object' && value !== null) {
+        const record = value;
+        if (typeof record['color'] === 'string')
+            color = normalizeColor(record['color']);
+        else if (record['color'] !== undefined)
+            throw new Error('stroke.color must be a hex string');
+        const width = record['width'] ?? record['widthPt'];
+        if (typeof width === 'number' && Number.isFinite(width) && width > 0)
+            widthPt = width;
+        else if (width !== undefined)
+            throw new Error('stroke.width must be a positive number (pt)');
+        if (typeof record['dash'] === 'string')
+            dash = record['dash'];
+        else if (record['dash'] !== undefined)
+            throw new Error('stroke.dash must be a string');
+    }
+    else
+        throw new Error('Unsupported stroke value');
+    const widthEmu = String(lineWidthToEmu(widthPt));
+    for (const side of TABLE_CELL_BORDER_SIDES) {
+        const ln = doc.createElementNS(NS.a, `a:${side}`);
+        ln.setAttribute('w', widthEmu);
+        const solidFill = doc.createElementNS(NS.a, 'a:solidFill');
+        const srgb = doc.createElementNS(NS.a, 'a:srgbClr');
+        srgb.setAttribute('val', color);
+        solidFill.appendChild(srgb);
+        ln.appendChild(solidFill);
+        if (dash) {
+            const prstDash = doc.createElementNS(NS.a, 'a:prstDash');
+            prstDash.setAttribute('val', dash);
+            ln.appendChild(prstDash);
+        }
+        insertTcPrBorder(tcPr, ln);
+    }
+};
+const TABLE_STRUCTURAL_KEYS = new Set([
+    'insertRow',
+    'deleteRow',
+    'insertColumn',
+    'deleteColumn',
+    'text',
+    'name',
+]);
+const TABLE_CELL_KEYS = new Set(['text', 'fill', 'paragraph.align']);
+export function applyTableProperties(node, properties, context) {
+    const structural = {};
+    const visual = {};
+    const unexpected = [];
+    for (const [key, value] of Object.entries(properties)) {
+        if (TABLE_STRUCTURAL_KEYS.has(key))
+            structural[key] = value;
+        else if (SHAPE_KEY_SET.has(key))
+            visual[key] = value;
+        else
+            unexpected.push(key);
+    }
+    if (unexpected.length)
+        return err('INVALID_COMMAND', `Unsupported table setProperties keys: ${unexpected.join(', ')}`);
+    const applied = [];
+    const diagnostics = [];
+    let structureGrew = false;
+    try {
+        if ('insertRow' in structural) {
+            insertTableRow(node, structural['insertRow']);
+            applied.push('insertRow');
+            structureGrew = true;
+        }
+        if ('deleteRow' in structural) {
+            deleteTableRow(node, structural['deleteRow']);
+            applied.push('deleteRow');
+        }
+        if ('insertColumn' in structural) {
+            insertTableColumn(node, structural['insertColumn']);
+            applied.push('insertColumn');
+            structureGrew = true;
+        }
+        if ('deleteColumn' in structural) {
+            deleteTableColumn(node, structural['deleteColumn']);
+            applied.push('deleteColumn');
+        }
+        if (typeof structural['text'] === 'string') {
+            setNodeText(node, structural['text']);
+            applied.push('text');
+        }
+        else if (structural['text'] !== undefined)
+            throw new Error('text must be a string');
+        if (typeof structural['name'] === 'string') {
+            const pr = first(node, 'cNvPr');
+            if (!pr)
+                throw new Error('Element has no cNvPr to set name');
+            pr.setAttribute('name', structural['name']);
+            applied.push('name');
+        }
+        else if (structural['name'] !== undefined)
+            throw new Error('name must be a string');
+        // Table fill/line map onto cells — graphicFrame has no spPr.
+        if ('fill' in visual) {
+            const cells = tableCells(node);
+            if (cells.length === 0)
+                throw new Error('Table has no cells to fill');
+            for (const cell of cells)
+                setTableCellFill(cell, visual['fill']);
+            applied.push('fill');
+            delete visual['fill'];
+        }
+        const strokeKeys = STROKE_ALIASES.filter((key) => key in visual);
+        if (strokeKeys.length > 1)
+            throw new Error(`Use only one stroke alias; found: ${strokeKeys.join(', ')}`);
+        if (strokeKeys[0]) {
+            const key = strokeKeys[0];
+            const cells = tableCells(node);
+            if (cells.length === 0)
+                throw new Error('Table has no cells for stroke');
+            for (const cell of cells)
+                setTableCellBorders(cell, visual[key]);
+            applied.push(key);
+            delete visual[key];
+        }
+        if (Object.keys(visual).length > 0) {
+            const styled = applyShapeProperties(node, visual, context);
+            if (!styled.ok)
+                return styled;
+            applied.push(...styled.value.applied);
+        }
+        if (structureGrew)
+            diagnostics.push(...tableLayoutWarnings(node, context));
+    }
+    catch (cause) {
+        return err('INVALID_COMMAND', cause instanceof Error ? cause.message : 'Invalid table properties');
+    }
+    return ok({ applied, diagnostics });
+}
+export function applyTableCellProperties(node, properties) {
+    const unexpected = Object.keys(properties).filter((k) => !TABLE_CELL_KEYS.has(k));
+    if (unexpected.length)
+        return err('INVALID_COMMAND', `Unsupported tableCell setProperties keys: ${unexpected.join(', ')}`);
+    const applied = [];
+    try {
+        if (typeof properties['text'] === 'string') {
+            setNodeText(node, properties['text']);
+            applied.push('text');
+        }
+        else if (properties['text'] !== undefined)
+            throw new Error('text must be a string');
+        if ('fill' in properties) {
+            setTableCellFill(node, properties['fill']);
+            applied.push('fill');
+        }
+        if ('paragraph.align' in properties) {
+            const styled = applyShapeProperties(node, {
+                'paragraph.align': properties['paragraph.align'],
+            });
+            if (!styled.ok)
+                return styled;
+            applied.push(...styled.value.applied);
+        }
+    }
+    catch (cause) {
+        return err('INVALID_COMMAND', cause instanceof Error ? cause.message : 'Invalid tableCell properties');
+    }
+    return ok({ applied });
+}
+const cellPlainText = (tc) => descendants(tc, 't')
+    .map((t) => t.textContent ?? '')
+    .join('');
+/** Read table grid width (sum of gridCol) or fall back to graphicFrame cx. */
+const tableWidthEmu = (graphicFrame) => {
+    const gridCols = descendants(graphicFrame, 'gridCol');
+    if (gridCols.length > 0) {
+        const sum = gridCols.reduce((acc, col) => acc + Number(attr(col, 'w') ?? 0), 0);
+        if (sum > 0)
+            return sum;
+    }
+    const xfrm = first(graphicFrame, 'xfrm');
+    const ext = xfrm ? first(xfrm, 'ext') : undefined;
+    return Number(attr(ext, 'cx') ?? 914400);
+};
+export function applyTableLayout(graphicFrame, options) {
+    if (graphicFrame.localName !== 'graphicFrame')
+        return err('INVALID_COMMAND', 'setTableLayout target must be a table graphicFrame');
+    const tbl = first(graphicFrame, 'tbl');
+    if (!tbl)
+        return err('INVALID_COMMAND', 'Target is not a DrawingML table');
+    const rows = directChildren(tbl, 'tr');
+    if (rows.length === 0)
+        return err('INVALID_COMMAND', 'Table has no rows');
+    const widthEmu = tableWidthEmu(graphicFrame);
+    const textRows = rows.map((tr) => directChildren(tr, 'tc').map((tc) => cellPlainText(tc)));
+    const redistribute = options.redistribute ??
+        (options.height === 'auto' || options.height === undefined ? 'content' : 'equal');
+    const xfrm = first(graphicFrame, 'xfrm');
+    const ext = xfrm ? first(xfrm, 'ext') : undefined;
+    if (!ext)
+        return err('INVALID_COMMAND', 'Table graphicFrame has no xfrm/ext');
+    const applied = [];
+    let totalHeightEmu;
+    let estimatedEmu;
+    if (redistribute === 'content' || options.height === 'auto') {
+        const layout = measureTableLayout({ rows: textRows, widthEmu, fontPt: 11 });
+        estimatedEmu = layout.totalHeightEmu;
+        for (let i = 0; i < rows.length; i++) {
+            const h = layout.rowHeightsEmu[i] ?? estimateTableRowHeightEmu(11);
+            rows[i].setAttribute('h', String(h));
+        }
+        if (typeof options.height === 'number') {
+            totalHeightEmu = options.height;
+        }
+        else {
+            totalHeightEmu = layout.totalHeightEmu;
+        }
+        applied.push('redistribute:content');
+    }
+    else {
+        totalHeightEmu =
+            typeof options.height === 'number'
+                ? options.height
+                : Number(attr(ext, 'cy') ?? estimateTableHeightEmu(rows.length));
+        const rowH = Math.max(1, Math.floor(totalHeightEmu / rows.length));
+        let assigned = 0;
+        for (let i = 0; i < rows.length; i++) {
+            const h = i === rows.length - 1 ? Math.max(1, totalHeightEmu - assigned) : rowH;
+            rows[i].setAttribute('h', String(h));
+            assigned += h;
+        }
+        applied.push('redistribute:equal');
+    }
+    ext.setAttribute('cy', String(Math.round(totalHeightEmu)));
+    applied.push('height');
+    return ok({
+        applied,
+        totalHeightEmu,
+        ...(estimatedEmu !== undefined ? { estimatedEmu } : {}),
+    });
+}
+//# sourceMappingURL=table.js.map