@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/export/table-properties-xml.ts

@@ -0,0 +1,318 @@
+interface TableWidthLike {
+  value: number;
+  type: string;
+}
+
+interface BorderSpecLike {
+  value?: string;
+  size?: number;
+  space?: number;
+  color?: string;
+}
+
+interface TableBordersLike {
+  top?: BorderSpecLike;
+  left?: BorderSpecLike;
+  bottom?: BorderSpecLike;
+  right?: BorderSpecLike;
+  insideH?: BorderSpecLike;
+  insideV?: BorderSpecLike;
+}
+
+interface TableCellMarginsLike {
+  top?: number;
+  left?: number;
+  bottom?: number;
+  right?: number;
+}
+
+interface TableLookLike {
+  val?: string;
+  firstRow?: boolean;
+  lastRow?: boolean;
+  firstColumn?: boolean;
+  lastColumn?: boolean;
+  noHBand?: boolean;
+  noVBand?: boolean;
+}
+
+interface CellShadingLike {
+  val?: string;
+  color?: string;
+  fill?: string;
+}
+
+interface TablePropertiesLike {
+  propertiesXml?: string;
+  styleId?: string;
+  width?: TableWidthLike;
+  alignment?: string;
+  borders?: TableBordersLike;
+  cellMargins?: TableCellMarginsLike;
+  tblLook?: TableLookLike;
+}
+
+interface TableRowPropertiesLike {
+  propertiesXml?: string;
+  gridBefore?: number;
+  widthBefore?: TableWidthLike;
+  gridAfter?: number;
+  widthAfter?: TableWidthLike;
+  height?: number;
+  heightRule?: string;
+  isHeader?: boolean;
+}
+
+interface TableCellPropertiesLike {
+  propertiesXml?: string;
+  width?: TableWidthLike;
+  gridSpan?: number;
+  verticalMerge?: "restart" | "continue";
+  borders?: TableBordersLike;
+  shading?: CellShadingLike;
+  verticalAlign?: string;
+}
+
+interface PropertyStripSpec {
+  pairedTags?: string[];
+  selfClosingTags?: string[];
+}
+
+const TABLE_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
+  pairedTags: ["w:tblBorders", "w:tblCellMar"],
+  selfClosingTags: ["w:tblStyle", "w:tblW", "w:jc", "w:tblLook"],
+};
+
+const ROW_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
+  selfClosingTags: ["w:gridBefore", "w:wBefore", "w:gridAfter", "w:wAfter", "w:trHeight", "w:tblHeader"],
+};
+
+const CELL_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
+  pairedTags: ["w:tcBorders"],
+  selfClosingTags: ["w:tcW", "w:gridSpan", "w:vMerge", "w:shd", "w:vAlign"],
+};
+
+export function serializeTablePropertiesXml(table: TablePropertiesLike): string {
+  return mergePropertiesXml(
+    "w:tblPr",
+    table.propertiesXml,
+    buildTablePropertiesInnerXml(table),
+    TABLE_PROPERTY_STRIP_SPEC,
+  );
+}
+
+export function serializeTableRowPropertiesXml(row: TableRowPropertiesLike): string {
+  return mergePropertiesXml(
+    "w:trPr",
+    row.propertiesXml,
+    buildTableRowPropertiesInnerXml(row),
+    ROW_PROPERTY_STRIP_SPEC,
+  );
+}
+
+export function serializeTableCellPropertiesXml(cell: TableCellPropertiesLike): string {
+  return mergePropertiesXml(
+    "w:tcPr",
+    cell.propertiesXml,
+    buildTableCellPropertiesInnerXml(cell),
+    CELL_PROPERTY_STRIP_SPEC,
+  );
+}
+
+function mergePropertiesXml(
+  tagName: "w:tblPr" | "w:trPr" | "w:tcPr",
+  existingXml: string | undefined,
+  supportedInnerXml: string,
+  stripSpec: PropertyStripSpec,
+): string {
+  const preservedInnerXml = stripKnownProperties(
+    extractWrappedChildren(tagName, existingXml),
+    stripSpec,
+  );
+  const mergedInnerXml = [supportedInnerXml, preservedInnerXml]
+    .filter((part) => part.length > 0)
+    .join("");
+  return mergedInnerXml.length > 0 ? `<${tagName}>${mergedInnerXml}</${tagName}>` : "";
+}
+
+function extractWrappedChildren(
+  tagName: "w:tblPr" | "w:trPr" | "w:tcPr",
+  xml: string | undefined,
+): string {
+  if (!xml) {
+    return "";
+  }
+  const trimmed = xml.trim();
+  const wrapped = new RegExp(`^<${tagName}\\b[^>]*>([\\s\\S]*)</${tagName}>$`, "u").exec(trimmed);
+  return wrapped?.[1] ?? trimmed;
+}
+
+function stripKnownProperties(xml: string, stripSpec: PropertyStripSpec): string {
+  let nextXml = xml;
+  for (const tagName of stripSpec.pairedTags ?? []) {
+    nextXml = nextXml.replace(
+      new RegExp(`<${tagName}\\b[^>]*>[\\s\\S]*?</${tagName}>`, "gu"),
+      "",
+    );
+  }
+  for (const tagName of stripSpec.selfClosingTags ?? []) {
+    nextXml = nextXml.replace(new RegExp(`<${tagName}\\b[^>]*/>`, "gu"), "");
+  }
+  return nextXml.trim();
+}
+
+function buildTablePropertiesInnerXml(table: TablePropertiesLike): string {
+  const children: string[] = [];
+  if (table.styleId) {
+    children.push(`<w:tblStyle w:val="${escapeAttribute(table.styleId)}"/>`);
+  }
+  if (table.width) {
+    children.push(serializeWidth("tblW", table.width));
+  }
+  if (table.alignment) {
+    children.push(`<w:jc w:val="${escapeAttribute(table.alignment)}"/>`);
+  }
+  if (table.borders) {
+    const bordersXml = serializeBorders(table.borders);
+    if (bordersXml) {
+      children.push(`<w:tblBorders>${bordersXml}</w:tblBorders>`);
+    }
+  }
+  if (table.cellMargins) {
+    const marginsXml = serializeTableCellMargins(table.cellMargins);
+    if (marginsXml) {
+      children.push(`<w:tblCellMar>${marginsXml}</w:tblCellMar>`);
+    }
+  }
+  if (table.tblLook) {
+    const tblLookXml = serializeTableLook(table.tblLook);
+    if (tblLookXml) {
+      children.push(tblLookXml);
+    }
+  }
+  return children.join("");
+}
+
+function buildTableRowPropertiesInnerXml(row: TableRowPropertiesLike): string {
+  const children: string[] = [];
+  if (row.gridBefore !== undefined) {
+    children.push(`<w:gridBefore w:val="${row.gridBefore}"/>`);
+  }
+  if (row.widthBefore) {
+    children.push(`<w:wBefore w:w="${row.widthBefore.value}" w:type="${row.widthBefore.type}"/>`);
+  }
+  if (row.gridAfter !== undefined) {
+    children.push(`<w:gridAfter w:val="${row.gridAfter}"/>`);
+  }
+  if (row.widthAfter) {
+    children.push(`<w:wAfter w:w="${row.widthAfter.value}" w:type="${row.widthAfter.type}"/>`);
+  }
+  if (row.height !== undefined) {
+    const hRuleAttr = row.heightRule ? ` w:hRule="${escapeAttribute(row.heightRule)}"` : "";
+    children.push(`<w:trHeight w:val="${row.height}"${hRuleAttr}/>`);
+  }
+  if (row.isHeader !== undefined) {
+    children.push(row.isHeader ? `<w:tblHeader/>` : `<w:tblHeader w:val="0"/>`);
+  }
+  return children.join("");
+}
+
+function buildTableCellPropertiesInnerXml(cell: TableCellPropertiesLike): string {
+  const children: string[] = [];
+  if (cell.width) {
+    children.push(serializeWidth("tcW", cell.width));
+  }
+  if (cell.gridSpan && cell.gridSpan > 1) {
+    children.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+  }
+  if (cell.verticalMerge) {
+    children.push(
+      cell.verticalMerge === "restart"
+        ? `<w:vMerge w:val="restart"/>`
+        : `<w:vMerge/>`,
+    );
+  }
+  if (cell.borders) {
+    const bordersXml = serializeBorders(cell.borders);
+    if (bordersXml) {
+      children.push(`<w:tcBorders>${bordersXml}</w:tcBorders>`);
+    }
+  }
+  if (cell.shading) {
+    const shadingXml = serializeCellShading(cell.shading);
+    if (shadingXml) {
+      children.push(shadingXml);
+    }
+  }
+  if (cell.verticalAlign) {
+    children.push(`<w:vAlign w:val="${escapeAttribute(cell.verticalAlign)}"/>`);
+  }
+  return children.join("");
+}
+
+function serializeWidth(elementName: "tblW" | "tcW", width: TableWidthLike): string {
+  return `<w:${elementName} w:w="${width.value}" w:type="${escapeAttribute(width.type)}"/>`;
+}
+
+function serializeBorders(borders: TableBordersLike): string {
+  const sides = ["top", "left", "bottom", "right", "insideH", "insideV"] as const;
+  return sides
+    .filter((side) => borders[side] !== undefined)
+    .map((side) => serializeBorderSpec(side, borders[side]!))
+    .join("");
+}
+
+function serializeBorderSpec(elementName: string, border: BorderSpecLike): string {
+  const attrs: string[] = [];
+  if (border.value) attrs.push(`w:val="${escapeAttribute(border.value)}"`);
+  if (border.size !== undefined) attrs.push(`w:sz="${border.size}"`);
+  if (border.space !== undefined) attrs.push(`w:space="${border.space}"`);
+  if (border.color) attrs.push(`w:color="${escapeAttribute(border.color)}"`);
+  return attrs.length > 0 ? `<w:${elementName} ${attrs.join(" ")}/>` : "";
+}
+
+function serializeTableCellMargins(margins: TableCellMarginsLike): string {
+  const parts: string[] = [];
+  if (margins.top !== undefined) parts.push(`<w:top w:w="${margins.top}" w:type="dxa"/>`);
+  if (margins.left !== undefined) parts.push(`<w:left w:w="${margins.left}" w:type="dxa"/>`);
+  if (margins.bottom !== undefined) parts.push(`<w:bottom w:w="${margins.bottom}" w:type="dxa"/>`);
+  if (margins.right !== undefined) parts.push(`<w:right w:w="${margins.right}" w:type="dxa"/>`);
+  return parts.join("");
+}
+
+function serializeTableLook(tblLook: TableLookLike): string {
+  const attrs: string[] = [];
+  if (tblLook.val) {
+    attrs.push(`w:val="${escapeAttribute(tblLook.val)}"`);
+  }
+  for (const [key, attr] of [
+    ["firstRow", "w:firstRow"],
+    ["lastRow", "w:lastRow"],
+    ["firstColumn", "w:firstColumn"],
+    ["lastColumn", "w:lastColumn"],
+    ["noHBand", "w:noHBand"],
+    ["noVBand", "w:noVBand"],
+  ] as const) {
+    const value = tblLook[key];
+    if (value !== undefined) {
+      attrs.push(`${attr}="${value ? "1" : "0"}"`);
+    }
+  }
+  return attrs.length > 0 ? `<w:tblLook ${attrs.join(" ")}/>` : "";
+}
+
+function serializeCellShading(shading: CellShadingLike): string {
+  const attrs: string[] = [];
+  if (shading.val) attrs.push(`w:val="${escapeAttribute(shading.val)}"`);
+  if (shading.color) attrs.push(`w:color="${escapeAttribute(shading.color)}"`);
+  if (shading.fill) attrs.push(`w:fill="${escapeAttribute(shading.fill)}"`);
+  return attrs.length > 0 ? `<w:shd ${attrs.join(" ")}/>` : "";
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/gu, "&amp;")
+    .replace(/"/gu, "&quot;")
+    .replace(/</gu, "&lt;")
+    .replace(/>/gu, "&gt;");
+}

package/src/io/normalize/README.md

@@ -0,0 +1,3 @@
+# IO Normalize
+
+Normalization from OOXML structures into canonical state belongs here.