@scrider/formatter 1.8.2 → 1.8.4

package/dist/index.cjs

@@ -596,10 +596,52 @@ function promoteAlignFromCellOps(cell) {
   }
   return cell;
 }
+function parseVerticalAlign(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === "top" || normalized === "baseline" || normalized === "text-top") return "top";
+  if (normalized === "middle" || normalized === "center") return "middle";
+  if (normalized === "bottom" || normalized === "text-bottom") return "bottom";
+  return null;
+}
+function extractInlineVerticalAlign(element) {
+  const verticalAlign = element.style?.getPropertyValue?.("vertical-align");
+  const fromStyle = parseVerticalAlign(verticalAlign);
+  if (fromStyle) return fromStyle;
+  const style = element.getAttribute("style") || "";
+  const match = style.match(/vertical-align:\s*(top|middle|bottom|center|baseline|text-top|text-bottom)/i);
+  if (match?.[1]) {
+    const parsed = parseVerticalAlign(match[1]);
+    if (parsed) return parsed;
+  }
+  const msoMatch = style.match(/mso-vertical-align:\s*(top|middle|bottom|center)/i);
+  if (msoMatch?.[1]) {
+    const parsed = parseVerticalAlign(msoMatch[1]);
+    if (parsed) return parsed;
+  }
+  return null;
+}
+function extractCellVAlign(cell) {
+  const direct = extractInlineVerticalAlign(cell);
+  if (direct) return direct;
+  const children = cell.childNodes;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!child || !isElement(child)) continue;
+    const tag = child.tagName.toLowerCase();
+    if (tag === "p" || tag === "div") {
+      const vAlign = extractInlineVerticalAlign(child);
+      if (vAlign) return vAlign;
+    }
+  }
+  return null;
+}
 function renderExtendedRow(data, row, cols, defaultCellTag, context, pretty) {
   const nl = pretty ? "\n" : "";
   const ind = (level) => pretty ? "  ".repeat(level) : "";
-  let html = `${ind(2)}<tr>${nl}`;
+  const rowHeight = data.rowHeights?.[row];
+  const trStyle = rowHeight !== void 0 && rowHeight > 0 ? ` style="height: ${rowHeight}px"` : "";
+  let html = `${ind(2)}<tr${trStyle}>${nl}`;
   for (let c = 0; c < cols; c++) {
     const key = `${row}:${c}`;
     const cell = data.cells[key];
@@ -615,14 +657,17 @@ function renderExtendedRow(data, row, cols, defaultCellTag, context, pretty) {
     }
     const colDefault = data.colAligns?.[c] ?? "left";
     const effectiveAlign = resolveCellHorizontalAlign(cell, c, data.colAligns);
-    let alignStyle = null;
+    const styleParts = [];
     if (effectiveAlign !== "left") {
-      alignStyle = `text-align: ${effectiveAlign}`;
+      styleParts.push(`text-align: ${effectiveAlign}`);
     } else if (cell.align === "left" && colDefault !== "left") {
-      alignStyle = "text-align: left";
+      styleParts.push("text-align: left");
+    }
+    if (cell.vAlign !== void 0 && cell.vAlign !== "top") {
+      styleParts.push(`vertical-align: ${cell.vAlign}`);
     }
-    if (alignStyle) {
-      attrs.push(`style="${alignStyle}"`);
+    if (styleParts.length > 0) {
+      attrs.push(`style="${styleParts.join("; ")}"`);
     }
     const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
     let content = "";
@@ -638,9 +683,15 @@ function isGfmCompatible(data) {
   if (data.colWidths && data.colWidths.some((w) => w > 0)) {
     return false;
   }
+  if (data.rowHeights && data.rowHeights.some((h) => h > 0)) {
+    return false;
+  }
   for (const cell of Object.values(data.cells)) {
     if (cell !== null && cell.align !== void 0) return false;
   }
+  for (const cell of Object.values(data.cells)) {
+    if (cell !== null && cell.vAlign !== void 0) return false;
+  }
   for (const cell of Object.values(data.cells)) {
     if (cell === null) return false;
     if (cell.colspan && cell.colspan > 1) return false;
@@ -750,6 +801,39 @@ function extractColWidths(table) {
   }
   return void 0;
 }
+function extractRowHeightPx(row) {
+  const style = row.getAttribute("style") || "";
+  const heightMatch = style.match(/(?:^|;)\s*height:\s*([\d.]+)px/i);
+  if (heightMatch?.[1]) {
+    const n = parseFloat(heightMatch[1]);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const minHeightMatch = style.match(/(?:^|;)\s*min-height:\s*([\d.]+)px/i);
+  if (minHeightMatch?.[1]) {
+    const n = parseFloat(minHeightMatch[1]);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const heightAttr = row.getAttribute("height");
+  if (heightAttr) {
+    const n = parseFloat(heightAttr);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return null;
+}
+function extractRowHeights(rows) {
+  const heights = [];
+  let any = false;
+  for (const row of rows) {
+    const h = extractRowHeightPx(row);
+    if (h != null) {
+      heights.push(h);
+      any = true;
+    } else {
+      heights.push(0);
+    }
+  }
+  return any ? heights : void 0;
+}
 function extractCellAlign(cell) {
   const direct = extractInlineHorizontalAlign(cell);
   if (direct) return direct;
@@ -821,6 +905,10 @@ function parseTableElement(table, context) {
         delete withoutAlign.align;
         cellData = withoutAlign;
       }
+      const htmlVAlign = extractCellVAlign(cell);
+      if (htmlVAlign && htmlVAlign !== "top") {
+        cellData = { ...cellData, vAlign: htmlVAlign };
+      }
       const cellKey = `${rowIdx}:${colIdx}`;
       cells[cellKey] = cellData;
       rawAligns[cellKey] = effectiveAlign;
@@ -875,6 +963,14 @@ function parseTableElement(table, context) {
     if (colWidths.length > totalCols) colWidths.length = totalCols;
     result.colWidths = colWidths;
   }
+  const rowHeights = extractRowHeights(rows);
+  if (rowHeights) {
+    while (rowHeights.length < totalRows) rowHeights.push(0);
+    if (rowHeights.length > totalRows) rowHeights.length = totalRows;
+    if (rowHeights.some((h) => h > 0)) {
+      result.rowHeights = rowHeights;
+    }
+  }
   if (colAligns.length > 0 && colAligns.some((a) => a !== null)) {
     while (colAligns.length < totalCols) colAligns.push(null);
     if (colAligns.length > totalCols) colAligns.length = totalCols;
@@ -934,6 +1030,14 @@ var tableBlockHandler = {
         if (typeof w !== "number" || w < 0) return false;
       }
     }
+    if (data.rowHeights !== void 0) {
+      if (!Array.isArray(data.rowHeights) || data.rowHeights.length !== rows) {
+        return false;
+      }
+      for (const h of data.rowHeights) {
+        if (typeof h !== "number" || h < 0) return false;
+      }
+    }
     if (data.colAligns !== void 0) {
       if (!Array.isArray(data.colAligns) || data.colAligns.length !== cols) {
         return false;