@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/tables/tc-pr.js

@@ -0,0 +1,553 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+/**
+* Typed parse/serialize helpers for `w:tcPr`.
+*
+* Citations: Transitional `wml.xsd` `CT_TcPrBase`, `CT_TblWidth`, `CT_TcBorders`,
+* `CT_TcMar`, `ST_TextDirection`, `ST_VerticalJc`, `ST_Merge`.
+*/
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wValAttribute, wmlAttr, wmlElement, } from '../document/wml';
+import { emptyPropsToUndefined, normalizeCnfStyle, normalizedCnfStyleHasTrue, parseCellMargins, parseCnfStyle, parseShd, parseTblWidth, parseTcBorders, serializeCellMargins, serializeCnfStyle, serializeShd, serializeTblWidth, serializeTcBorders, twipsToPoint, upsertPropChild } from './tbl-pr';
+/** Explicit zero cell margins used when leaving table padding inheritance. */
+var ZERO_CELL_MARGINS = {
+    top: twipsToPoint(0),
+    left: twipsToPoint(0),
+    bottom: twipsToPoint(0),
+    right: twipsToPoint(0),
+};
+/**
+ * Cell vertical alignment (`w:vAlign` / `ST_VerticalJc` public subset; omit `both`).
+ *
+ * - {@link TableCellVerticalAlignment.Top}: top of the cell (default).
+ * - {@link TableCellVerticalAlignment.Center}: middle of the cell.
+ * - {@link TableCellVerticalAlignment.Bottom}: bottom of the cell.
+ *
+ * @public
+ */
+export var TableCellVerticalAlignment = {
+    Top: 'top',
+    Center: 'center',
+    Bottom: 'bottom',
+};
+function findWmlChild(parent, localName) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(elementChildren(parent)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, localName)) {
+                return child;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+function readDecimalChild(tcPr, localName) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(elementChildren(tcPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, localName)) {
+                continue;
+            }
+            var raw = wValAttribute(child);
+            if (raw !== undefined && /^\d+$/.test(raw)) {
+                return parseInt(raw, 10);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+function readVerticalMergeChild(tcPr) {
+    var e_3, _a;
+    try {
+        for (var _b = __values(elementChildren(tcPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, 'vMerge')) {
+                continue;
+            }
+            var val = wValAttribute(child);
+            if (val === 'restart') {
+                return 'restart';
+            }
+            if (val === 'continue' || val === undefined) {
+                return 'continue';
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return undefined;
+}
+function upsertTcPrChild(tcPr, localName, replacement) {
+    return upsertPropChild(tcPr, 'tcPr', localName, replacement);
+}
+function ensureTcPr(tcPr) {
+    return tcPr != null ? tcPr : wmlElement('tcPr');
+}
+function writeTcChild(tcPr, localName, replacement) {
+    var next = upsertTcPrChild(ensureTcPr(tcPr), localName, replacement);
+    return emptyPropsToUndefined(next);
+}
+/**
+ * @private
+ */
+export function readGridSpan(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    return readDecimalChild(tcPr, 'gridSpan');
+}
+/**
+ * @private
+ */
+export function readVerticalMerge(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    return readVerticalMergeChild(tcPr);
+}
+/**
+ * @private
+ */
+export function writeGridSpan(tcPr, span) {
+    // Absent and span===1 both mean one column — omit the element (ECMA / Word UI).
+    if (span === undefined || span === 1) {
+        if (tcPr === undefined) {
+            return undefined;
+        }
+        return writeTcChild(tcPr, 'gridSpan', undefined);
+    }
+    if (span < 1) {
+        throw new RangeError('gridSpan must be at least 1');
+    }
+    var element = wmlElement('gridSpan', { attributes: [wmlAttr('val', String(span))] });
+    return writeTcChild(tcPr, 'gridSpan', element);
+}
+/**
+ * @private
+ */
+export function writeVerticalMerge(tcPr, merge) {
+    if (merge === undefined) {
+        if (tcPr === undefined) {
+            return undefined;
+        }
+        return writeTcChild(tcPr, 'vMerge', undefined);
+    }
+    var element = merge === 'restart'
+        ? wmlElement('vMerge', { attributes: [wmlAttr('val', 'restart')] })
+        : wmlElement('vMerge', { attributes: [wmlAttr('val', 'continue')] });
+    return writeTcChild(tcPr, 'vMerge', element);
+}
+function readHorizontalMergeChild(tcPr) {
+    var e_4, _a;
+    try {
+        for (var _b = __values(elementChildren(tcPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, 'hMerge')) {
+                continue;
+            }
+            var val = wValAttribute(child);
+            if (val === 'restart') {
+                return 'restart';
+            }
+            if (val === 'continue' || val === undefined) {
+                return 'continue';
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return undefined;
+}
+/**
+ * Horizontal merge setting on `w:tcPr/w:hMerge` (`ST_Merge`).
+ *
+ * @private
+ */
+export function readHorizontalMerge(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    return readHorizontalMergeChild(tcPr);
+}
+/**
+ * @private
+ */
+export function writeHorizontalMerge(tcPr, merge) {
+    if (merge === undefined) {
+        if (tcPr === undefined) {
+            return undefined;
+        }
+        return writeTcChild(tcPr, 'hMerge', undefined);
+    }
+    var element = merge === 'restart'
+        ? wmlElement('hMerge', { attributes: [wmlAttr('val', 'restart')] })
+        : wmlElement('hMerge', { attributes: [wmlAttr('val', 'continue')] });
+    return writeTcChild(tcPr, 'hMerge', element);
+}
+/**
+ * @private
+ */
+export function readCellPreferredWidth(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'tcW');
+    return el !== undefined ? parseTblWidth(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeCellPreferredWidth(tcPr, width) {
+    return writeTcChild(tcPr, 'tcW', width !== undefined ? serializeTblWidth('tcW', width) : undefined);
+}
+/**
+ * @private
+ */
+export function readCellBorders(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'tcBorders');
+    if (el === undefined) {
+        return undefined;
+    }
+    var borders = parseTcBorders(el);
+    if (borders.top === undefined &&
+        borders.left === undefined &&
+        borders.bottom === undefined &&
+        borders.right === undefined &&
+        borders.insideH === undefined &&
+        borders.insideV === undefined &&
+        borders.tl2br === undefined &&
+        borders.tr2bl === undefined) {
+        return undefined;
+    }
+    return borders;
+}
+/**
+ * @private
+ */
+export function writeCellBorders(tcPr, borders) {
+    var existing = tcPr !== undefined ? findWmlChild(tcPr, 'tcBorders') : undefined;
+    return writeTcChild(tcPr, 'tcBorders', borders !== undefined ? serializeTcBorders(borders, existing) : undefined);
+}
+/**
+ * @private
+ */
+export function readCellShading(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'shd');
+    if (el === undefined) {
+        return undefined;
+    }
+    var shd = parseShd(el);
+    if (shd.fill === undefined && shd.color === undefined && shd.pattern === undefined) {
+        return undefined;
+    }
+    return shd;
+}
+/**
+ * Whether cell shading carries explicit direct formatting worth serializing.
+ * Bare `{ pattern: 'clear' }` with no fill/color is treated as uninitialized and omitted
+ * so table-style shading can inherit. Explicit clear+fill/color, non-clear patterns, or
+ * fill alone still emit. Parsed genuine bare clear is preserved only when callers pass a
+ * shaded object that was read from the wire with additional markers — bare clear alone
+ * must not be introduced on authoring paths.
+ *
+ * @private
+ */
+function isExplicitCellShading(shading) {
+    if (shading.fill !== undefined && shading.fill.length > 0) {
+        return true;
+    }
+    if (shading.color !== undefined && shading.color.length > 0 && shading.color !== 'auto') {
+        return true;
+    }
+    if (shading.pattern !== undefined && shading.pattern.length > 0 && shading.pattern !== 'clear') {
+        return true;
+    }
+    // Explicit clear with a color (including auto) is genuine direct formatting.
+    if (shading.pattern === 'clear' &&
+        shading.color !== undefined &&
+        shading.color.length > 0) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Write cell shading only when it is explicit direct formatting.
+ * Omits bare uninitialized `w:shd w:val="clear"` so style shading inherits in Word.
+ *
+ * @private
+ */
+export function writeCellShading(tcPr, shading) {
+    if (shading === undefined || !isExplicitCellShading(shading)) {
+        return writeTcChild(tcPr, 'shd', undefined);
+    }
+    return writeTcChild(tcPr, 'shd', serializeShd(shading));
+}
+/**
+ * @private
+ */
+export function readCellMargins(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'tcMar');
+    if (el === undefined) {
+        return undefined;
+    }
+    var m = parseCellMargins(el);
+    if (m.top === undefined &&
+        m.right === undefined &&
+        m.bottom === undefined &&
+        m.left === undefined) {
+        return undefined;
+    }
+    return m;
+}
+/**
+ * Whether the cell inherits table default cell margins (absence of `w:tcMar`).
+ *
+ * @private
+ */
+export function readIsSamePaddingsAsTable(tcPr) {
+    if (tcPr === undefined) {
+        return true;
+    }
+    return findWmlChild(tcPr, 'tcMar') === undefined;
+}
+/**
+ * @private
+ */
+export function writeCellMargins(tcPr, margins) {
+    var existing = tcPr !== undefined ? findWmlChild(tcPr, 'tcMar') : undefined;
+    return writeTcChild(tcPr, 'tcMar', margins !== undefined ? serializeCellMargins('tcMar', margins, existing) : undefined);
+}
+/**
+ * Write inheritance mode for cell padding.
+ *
+ * - `true` removes `w:tcMar` (inherit table `tblCellMar`).
+ * - `false` ensures an explicit `w:tcMar` is present. Existing non-empty side
+ *   values are retained. When `w:tcMar` is missing or empty, all four sides
+ *   are written as 0 twips so Word treats the cell as a real override
+ *   (Cell Options → “Same as the whole table” unchecked). An empty
+ *   `<w:tcMar/>` alone is ignored by Word’s checkbox UI.
+ *
+ * @private
+ */
+export function writeIsSamePaddingsAsTable(tcPr, sameAsTable) {
+    if (sameAsTable) {
+        return writeCellMargins(tcPr, undefined);
+    }
+    var existing = tcPr !== undefined ? findWmlChild(tcPr, 'tcMar') : undefined;
+    if (existing !== undefined) {
+        var m = parseCellMargins(existing);
+        if (m.top !== undefined ||
+            m.right !== undefined ||
+            m.bottom !== undefined ||
+            m.left !== undefined) {
+            return tcPr;
+        }
+    }
+    // Word requires concrete side elements to uncheck "Same as the whole table".
+    return writeCellMargins(tcPr, ZERO_CELL_MARGINS);
+}
+var TEXT_DIRECTIONS = new Set(['lr', 'rl', 'tb', 'btLr', 'lrV', 'rlV']);
+/** Map full ST_TextDirection tokens onto the public cell subset when possible. */
+function mapTextDirection(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (TEXT_DIRECTIONS.has(raw)) {
+        return raw;
+    }
+    if (raw === 'lrTb') {
+        return 'lr';
+    }
+    if (raw === 'tbRl') {
+        return 'tb';
+    }
+    if (raw === 'btLr') {
+        return 'btLr';
+    }
+    if (raw === 'lrTbV') {
+        return 'lrV';
+    }
+    if (raw === 'tbRlV') {
+        return 'rlV';
+    }
+    if (raw === 'tbLrV') {
+        return 'tb';
+    }
+    return undefined;
+}
+/**
+ * @private
+ */
+export function readCellTextDirection(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'textDirection');
+    if (el === undefined) {
+        return undefined;
+    }
+    return mapTextDirection(wValAttribute(el));
+}
+/**
+ * @private
+ */
+export function writeCellTextDirection(tcPr, direction) {
+    return writeTcChild(tcPr, 'textDirection', direction !== undefined
+        ? wmlElement('textDirection', { attributes: [wmlAttr('val', direction)] })
+        : undefined);
+}
+/**
+ * @private
+ */
+export function readCellVerticalAlignment(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'vAlign');
+    if (el === undefined) {
+        return undefined;
+    }
+    var raw = wValAttribute(el);
+    if (raw === 'top' || raw === 'center' || raw === 'bottom') {
+        return raw;
+    }
+    return undefined;
+}
+/**
+ * @private
+ */
+export function writeCellVerticalAlignment(tcPr, alignment) {
+    return writeTcChild(tcPr, 'vAlign', alignment !== undefined
+        ? wmlElement('vAlign', { attributes: [wmlAttr('val', alignment)] })
+        : undefined);
+}
+/**
+ * @private
+ */
+export function readCellNoWrap(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'noWrap');
+    return el !== undefined ? parseOnOff(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeCellNoWrap(tcPr, noWrap) {
+    return writeTcChild(tcPr, 'noWrap', noWrap !== undefined ? serializeOnOff('noWrap', noWrap) : undefined);
+}
+/**
+ * Fit text (`w:tcFitText` — not `w:fitText`).
+ *
+ * @private
+ */
+export function readCellFitText(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'tcFitText');
+    return el !== undefined ? parseOnOff(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeCellFitText(tcPr, fitText) {
+    return writeTcChild(tcPr, 'tcFitText', fitText !== undefined ? serializeOnOff('tcFitText', fitText) : undefined);
+}
+/**
+ * @private
+ */
+export function readCellHideMark(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'hideMark');
+    return el !== undefined ? parseOnOff(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeCellHideMark(tcPr, hideMark) {
+    return writeTcChild(tcPr, 'hideMark', hideMark !== undefined ? serializeOnOff('hideMark', hideMark) : undefined);
+}
+/**
+ * Cell conditional formatting membership (`w:tcPr/w:cnfStyle` / `CT_Cnf`).
+ * Preserve-only: does not recompute from table layout.
+ *
+ * Citations: ECMA-376-1 §17.4.8; Part 4 §14.3.1.1 / §14.11.9; Transitional `CT_Cnf`.
+ *
+ * @private
+ */
+export function readCellCnfStyle(tcPr) {
+    if (tcPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(tcPr, 'cnfStyle');
+    if (el === undefined) {
+        return undefined;
+    }
+    var state = parseCnfStyle(el);
+    var normalized = normalizeCnfStyle(state);
+    return normalizedCnfStyleHasTrue(normalized) ? state : undefined;
+}
+/**
+ * Write or clear cell `w:cnfStyle`. Passing `undefined` removes the element.
+ * A supplied {@link NormalizedCnfStyle} is always written (including all-false).
+ *
+ * @private
+ */
+export function writeCellCnfStyle(tcPr, state) {
+    if (state === undefined) {
+        if (tcPr === undefined) {
+            return undefined;
+        }
+        return writeTcChild(tcPr, 'cnfStyle', undefined);
+    }
+    var existing = tcPr !== undefined ? findWmlChild(tcPr, 'cnfStyle') : undefined;
+    var normalized = normalizeCnfStyle(state);
+    return writeTcChild(tcPr, 'cnfStyle', serializeCnfStyle(normalized, existing));
+}

package/src/features/tables/tr-pr.d.ts

@@ -0,0 +1,60 @@
+import { OpenXmlElement } from '../../core/xml/index';
+import { CnfStyle, NormalizedCnfStyle, TableAlignment, TableRowHeight, TableShading } from './tbl-pr';
+/**
+ * @private
+ */
+export declare function readRowHeight(trPr: OpenXmlElement | undefined): TableRowHeight | undefined;
+/**
+ * @private
+ */
+export declare function writeRowHeight(trPr: OpenXmlElement | undefined, height: TableRowHeight | undefined): OpenXmlElement | undefined;
+/**
+ * @private
+ */
+export declare function readRowCantSplit(trPr: OpenXmlElement | undefined): boolean | undefined;
+/**
+ * @private
+ */
+export declare function writeRowCantSplit(trPr: OpenXmlElement | undefined, cantSplit: boolean | undefined): OpenXmlElement | undefined;
+/**
+ * @private
+ */
+export declare function readRowIsHeader(trPr: OpenXmlElement | undefined): boolean | undefined;
+/**
+ * @private
+ */
+export declare function writeRowIsHeader(trPr: OpenXmlElement | undefined, isHeader: boolean | undefined): OpenXmlElement | undefined;
+/**
+ * @private
+ */
+export declare function readRowAlignment(trPr: OpenXmlElement | undefined): TableAlignment | undefined;
+/**
+ * @private
+ */
+export declare function writeRowAlignment(trPr: OpenXmlElement | undefined, alignment: TableAlignment | undefined): OpenXmlElement | undefined;
+/**
+ * Row shading (`w:trPr/w:shd`).
+ *
+ * @private
+ */
+export declare function readRowShading(trPr: OpenXmlElement | undefined): TableShading | undefined;
+/**
+ * @private
+ */
+export declare function writeRowShading(trPr: OpenXmlElement | undefined, shading: TableShading | undefined): OpenXmlElement | undefined;
+/**
+ * Row conditional formatting membership (`w:trPr/w:cnfStyle` / `CT_Cnf`).
+ * Preserve-only: does not recompute from table layout.
+ *
+ * Citations: ECMA-376-1 §17.4.7; Part 4 §14.3.1.1 / §14.11.9; Transitional `CT_Cnf`.
+ *
+ * @private
+ */
+export declare function readRowCnfStyle(trPr: OpenXmlElement | undefined): CnfStyle | undefined;
+/**
+ * Write or clear row `w:cnfStyle`. Passing `undefined` removes the element.
+ * A supplied {@link NormalizedCnfStyle} is always written (including all-false).
+ *
+ * @private
+ */
+export declare function writeRowCnfStyle(trPr: OpenXmlElement | undefined, state: NormalizedCnfStyle | CnfStyle | undefined): OpenXmlElement | undefined;