docgen-utils 1.0.21 → 1.0.22

package/dist/packages/docs/parse.js

@@ -6,6 +6,62 @@ import { parseHeadingLevel, getTextAlignment, getTextContent, BLOCK_LEVEL_TAGS,
 import { isInlineOnlyContainer, extractInlineRuns, hasInlineFormatting } from "./parse-inline";
 import { isGridOrFlexContainer, isHorizontalFlexContainer, isDecorativeSvg, isTwoColumnGridLayout, findTwoColumnChildren, detectFlexEqualColumns, detectGridEqualColumns } from "./parse-layout";
 import { detectSkillItem, detectLanguageItem, detectProgressBar, detectTimeline } from "./parse-special";
+/**
+ * Get direct child rows of a table element (not nested table rows).
+ * Handles tbody, thead, tfoot containers.
+ */
+function getDirectRows(tableEl) {
+    const result = [];
+    for (const child of tableEl.children) {
+        const childTag = child.tagName.toLowerCase();
+        if (childTag === "tr") {
+            result.push(child);
+        }
+        else if (childTag === "thead" || childTag === "tbody" || childTag === "tfoot") {
+            for (const grandchild of child.children) {
+                if (grandchild.tagName.toLowerCase() === "tr") {
+                    result.push(grandchild);
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Get direct child cells of a row element (not nested cells).
+ */
+function getDirectCells(rowEl) {
+    const result = [];
+    for (const child of rowEl.children) {
+        const childTag = child.tagName.toLowerCase();
+        if (childTag === "td" || childTag === "th") {
+            result.push(child);
+        }
+    }
+    return result;
+}
+/**
+ * Check if a table cell contains nested tables (complex content).
+ */
+function cellHasNestedTable(cellEl) {
+    return cellEl.querySelector("table") !== null;
+}
+/**
+ * Check if table has border:none style (layout table).
+ */
+function isLayoutTable(tableEl, cssContext) {
+    const styles = getElementStyles(tableEl, cssContext);
+    // Check inline style
+    const inlineStyle = tableEl.getAttribute("style") || "";
+    if (inlineStyle.includes("border: none") || inlineStyle.includes("border:none")) {
+        return true;
+    }
+    // Check CSS class-based border:none
+    if (styles.border && styles.border.includes("none")) {
+        return true;
+    }
+    return false;
+}
 function createParsedImageElement(imageEl, imageKey) {
     const src = imageEl.getAttribute("src")?.trim();
     if (!src) {
@@ -131,20 +187,60 @@ function parseContainerContent(element, cssContext, nextImageKey, inheritedColor
         // Handle tables
         if (tagName === "table") {
             const rows = [];
-            for (const tr of el.querySelectorAll("tr")) {
+            const directRows = getDirectRows(el);
+            for (const tr of directRows) {
                 const cells = [];
-                for (const cell of tr.querySelectorAll("td, th")) {
+                const directCells = getDirectCells(tr);
+                for (const cell of directCells) {
+                    // Extract cell-level background color (same logic as main table parsing)
+                    let cellBackgroundColor;
+                    // Method 1: Check cell's direct class-based styles
+                    const cellStyles = getElementStyles(cell, cssContext, tr);
+                    if (cellStyles.backgroundColor) {
+                        const hexBg = extractHexColor(cellStyles.backgroundColor);
+                        if (hexBg)
+                            cellBackgroundColor = hexBg;
+                    }
+                    // Method 2: Check inline style on the cell
+                    if (!cellBackgroundColor) {
+                        const inlineStyle = cell.getAttribute("style") || "";
+                        if (inlineStyle) {
+                            const bgMatch = inlineStyle.match(/background(?:-color)?\s*:\s*([^;]+)/i);
+                            if (bgMatch) {
+                                const hexBg = extractHexColor(bgMatch[1]);
+                                if (hexBg)
+                                    cellBackgroundColor = hexBg;
+                            }
+                        }
+                    }
                     const runs = extractInlineRuns(cell, cssContext);
-                    if (runs.length > 0) {
-                        if (hasInlineFormatting(runs)) {
-                            cells.push(runs);
+                    // If cell has background color, wrap in StyledTableCell
+                    if (cellBackgroundColor) {
+                        if (runs.length > 0) {
+                            if (hasInlineFormatting(runs)) {
+                                cells.push({ content: runs, backgroundColor: cellBackgroundColor });
+                            }
+                            else {
+                                cells.push({ content: runs.map((r) => r.text).join(""), backgroundColor: cellBackgroundColor });
+                            }
                         }
                         else {
-                            cells.push(runs.map((r) => r.text).join(""));
+                            cells.push({ content: "", backgroundColor: cellBackgroundColor });
                         }
                     }
                     else {
-                        cells.push("");
+                        // No cell background - use simple format
+                        if (runs.length > 0) {
+                            if (hasInlineFormatting(runs)) {
+                                cells.push(runs);
+                            }
+                            else {
+                                cells.push(runs.map((r) => r.text).join(""));
+                            }
+                        }
+                        else {
+                            cells.push("");
+                        }
                     }
                 }
                 if (cells.length > 0) {
@@ -1126,23 +1222,91 @@ export function parseHtmlContent(html) {
         }
         if (tagName === "table") {
             const rows = [];
-            for (const tr of element.querySelectorAll("tr")) {
+            // Use direct children traversal to avoid flattening nested tables
+            const directRows = getDirectRows(element);
+            for (const tr of directRows) {
                 const cells = [];
-                for (const cell of tr.querySelectorAll("td, th")) {
-                    // Extract inline runs to preserve bold/italic formatting in cells
-                    const runs = extractInlineRuns(cell, cssContext);
-                    if (runs.length > 0) {
-                        if (hasInlineFormatting(runs)) {
-                            // Has formatting - store as runs
-                            cells.push(runs);
+                const directCells = getDirectCells(tr);
+                for (const cell of directCells) {
+                    // Check if cell contains nested table (complex content)
+                    if (cellHasNestedTable(cell)) {
+                        // Parse cell content recursively for nested tables
+                        const nestedContent = parseContainerContent(cell, cssContext, nextImageKey);
+                        if (nestedContent.length > 0) {
+                            cells.push({ content: nestedContent });
                         }
                         else {
-                            // Plain text - store as string
-                            cells.push(runs.map((r) => r.text).join(""));
+                            cells.push("");
                         }
                     }
                     else {
-                        cells.push("");
+                        // Extract cell-level background color from CSS
+                        // This handles nested selectors like .charges-table th or .charges-table tr.row-even td
+                        let cellBackgroundColor;
+                        // Method 1: Check cell's direct styles with row as parent
+                        // This handles .row-class td { ... } patterns
+                        const cellStylesWithRowParent = getElementStyles(cell, cssContext, tr);
+                        if (cellStylesWithRowParent.backgroundColor) {
+                            const hexBg = extractHexColor(cellStylesWithRowParent.backgroundColor);
+                            if (hexBg)
+                                cellBackgroundColor = hexBg;
+                        }
+                        // Method 2: Check cell's styles with TABLE as parent
+                        // This handles .table-class th { ... } and .table-class td { ... } patterns
+                        if (!cellBackgroundColor) {
+                            const cellStylesWithTableParent = getElementStyles(cell, cssContext, element);
+                            if (cellStylesWithTableParent.backgroundColor) {
+                                const hexBg = extractHexColor(cellStylesWithTableParent.backgroundColor);
+                                if (hexBg)
+                                    cellBackgroundColor = hexBg;
+                            }
+                        }
+                        // Method 3: Check inline style on the cell
+                        const inlineStyle = cell.getAttribute("style") || "";
+                        if (inlineStyle && !cellBackgroundColor) {
+                            const bgMatch = inlineStyle.match(/background(?:-color)?\s*:\s*([^;]+)/i);
+                            if (bgMatch) {
+                                const hexBg = extractHexColor(bgMatch[1]);
+                                if (hexBg)
+                                    cellBackgroundColor = hexBg;
+                            }
+                        }
+                        // NOTE: Multi-level nested selectors like ".charges-table tr.row-even td { ... }" are now
+                        // handled by the general ancestor walk in getElementStyles(). The nestedSelectorPattern
+                        // extracts the row class (row-even) as the parent for td styles, and getElementStyles()
+                        // finds tr.row-even as an ancestor of td when walking up the DOM tree.
+                        // Extract inline runs to preserve bold/italic formatting in cells
+                        const runs = extractInlineRuns(cell, cssContext);
+                        // If cell has background color, wrap in StyledTableCell
+                        if (cellBackgroundColor) {
+                            if (runs.length > 0) {
+                                if (hasInlineFormatting(runs)) {
+                                    cells.push({ content: runs, backgroundColor: cellBackgroundColor });
+                                }
+                                else {
+                                    cells.push({ content: runs.map((r) => r.text).join(""), backgroundColor: cellBackgroundColor });
+                                }
+                            }
+                            else {
+                                cells.push({ content: "", backgroundColor: cellBackgroundColor });
+                            }
+                        }
+                        else {
+                            // No cell background - use simple format
+                            if (runs.length > 0) {
+                                if (hasInlineFormatting(runs)) {
+                                    // Has formatting - store as runs
+                                    cells.push(runs);
+                                }
+                                else {
+                                    // Plain text - store as string
+                                    cells.push(runs.map((r) => r.text).join(""));
+                                }
+                            }
+                            else {
+                                cells.push("");
+                            }
+                        }
                     }
                 }
                 if (cells.length > 0) {
@@ -1314,7 +1478,9 @@ export function parseHtmlContent(html) {
                         }
                     }
                 }
-                elements.push({ type: "table", rows, cellPadding, headerBackgroundColor, headerTextColor, evenRowBackgroundColor, hasHeader: hasExplicitHeader ? true : undefined, horizontalBordersOnly: horizontalBordersOnly || undefined, columnWidths: calculateColumnWidths(rows, element) });
+                // Detect noBorders layout tables (tables with border:none for pure layout)
+                const noBorders = isLayoutTable(element, cssContext);
+                elements.push({ type: "table", rows, cellPadding, headerBackgroundColor, headerTextColor, evenRowBackgroundColor, hasHeader: hasExplicitHeader ? true : undefined, horizontalBordersOnly: horizontalBordersOnly || undefined, noBorders: noBorders || undefined, columnWidths: calculateColumnWidths(rows, element) });
             }
             return;
         }