@scrider/formatter 1.8.1 → 1.8.3

package/dist/index.cjs

@@ -492,6 +492,13 @@ function isTextNode(node) {
 }
 
 // src/schema/blocks/table.ts
+var VALID_CELL_HORIZONTAL_ALIGNS = [
+  "left",
+  "center",
+  "right",
+  "justify"
+];
+var VALID_CELL_VERTICAL_ALIGNS = ["top", "middle", "bottom"];
 var CELL_KEY_RE = /^(\d+):(\d+)$/;
 function parseCellKey(key) {
   const match = CELL_KEY_RE.exec(key);
@@ -512,7 +519,22 @@ function getGridDimensions(cells) {
   return [maxRow + 1, maxCol + 1];
 }
 function isValidCellData(cell) {
-  return typeof cell === "object" && cell !== null && Array.isArray(cell.ops) && cell.ops.length > 0 && (cell.colspan === void 0 || Number.isInteger(cell.colspan) && cell.colspan >= 1) && (cell.rowspan === void 0 || Number.isInteger(cell.rowspan) && cell.rowspan >= 1);
+  if (typeof cell !== "object" || cell === null || !Array.isArray(cell.ops) || cell.ops.length === 0) {
+    return false;
+  }
+  if (cell.colspan !== void 0 && (!Number.isInteger(cell.colspan) || cell.colspan < 1)) {
+    return false;
+  }
+  if (cell.rowspan !== void 0 && (!Number.isInteger(cell.rowspan) || cell.rowspan < 1)) {
+    return false;
+  }
+  if (cell.align !== void 0 && !VALID_CELL_HORIZONTAL_ALIGNS.includes(cell.align)) {
+    return false;
+  }
+  if (cell.vAlign !== void 0 && !VALID_CELL_VERTICAL_ALIGNS.includes(cell.vAlign)) {
+    return false;
+  }
+  return true;
 }
 function validateMergedCells(cells, rows, cols) {
   const covered = /* @__PURE__ */ new Set();
@@ -542,10 +564,44 @@ function validateMergedCells(cells, rows, cols) {
   }
   return true;
 }
+function parseHorizontalAlign(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "left" || normalized === "center" || normalized === "right") {
+    return normalized;
+  }
+  if (normalized === "justify") return "justify";
+  return null;
+}
+function resolveCellHorizontalAlign(cell, col, colAligns) {
+  if (cell.align !== void 0) return cell.align;
+  const colAlign = colAligns?.[col];
+  if (colAlign) return colAlign;
+  return "left";
+}
+function promoteAlignFromCellOps(cell) {
+  if (cell.align !== void 0) return cell;
+  for (let i = cell.ops.length - 1; i >= 0; i--) {
+    const op = cell.ops[i];
+    if (!op || !(0, import_delta2.isInsert)(op) || !(0, import_delta2.isTextInsert)(op) || !op.insert.includes("\n")) continue;
+    const align = op.attributes?.align;
+    const parsed = typeof align === "string" ? parseHorizontalAlign(align) : null;
+    if (!parsed) continue;
+    const ops = cell.ops.map((item, idx) => {
+      if (idx !== i || !(0, import_delta2.isInsert)(item) || item.attributes == null) return item;
+      const rest = { ...item.attributes };
+      delete rest.align;
+      return Object.keys(rest).length > 0 ? { insert: item.insert, attributes: rest } : { insert: item.insert };
+    });
+    return { ...cell, ops, align: parsed };
+  }
+  return cell;
+}
 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];
@@ -559,11 +615,16 @@ function renderExtendedRow(data, row, cols, defaultCellTag, context, pretty) {
     if (cell.rowspan && cell.rowspan > 1) {
       attrs.push(`rowspan="${cell.rowspan}"`);
     }
-    if (data.colAligns) {
-      const align = data.colAligns[c];
-      if (align && align !== "left") {
-        attrs.push(`style="text-align: ${align}"`);
-      }
+    const colDefault = data.colAligns?.[c] ?? "left";
+    const effectiveAlign = resolveCellHorizontalAlign(cell, c, data.colAligns);
+    let alignStyle = null;
+    if (effectiveAlign !== "left") {
+      alignStyle = `text-align: ${effectiveAlign}`;
+    } else if (cell.align === "left" && colDefault !== "left") {
+      alignStyle = "text-align: left";
+    }
+    if (alignStyle) {
+      attrs.push(`style="${alignStyle}"`);
     }
     const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
     let content = "";
@@ -579,6 +640,12 @@ 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) return false;
     if (cell.colspan && cell.colspan > 1) return false;
@@ -688,15 +755,62 @@ 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 textAlign = cell.style?.textAlign || cell.style?.getPropertyValue?.("text-align");
-  if (textAlign === "left" || textAlign === "center" || textAlign === "right") {
-    return textAlign;
+  const direct = extractInlineHorizontalAlign(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 align = extractInlineHorizontalAlign(child);
+      if (align) return align;
+    }
   }
-  const style = cell.getAttribute("style") || "";
-  const match = style.match(/text-align:\s*(left|center|right)/);
+  return null;
+}
+function extractInlineHorizontalAlign(element) {
+  const textAlign = element.style?.textAlign || element.style?.getPropertyValue?.("text-align");
+  const fromStyle = parseHorizontalAlign(textAlign);
+  if (fromStyle) return fromStyle;
+  const style = element.getAttribute("style") || "";
+  const match = style.match(/text-align:\s*(left|center|right|justify)/i);
   if (match?.[1]) {
-    return match[1];
+    return parseHorizontalAlign(match[1]);
   }
   return null;
 }
@@ -705,6 +819,7 @@ function parseTableElement(table, context) {
   if (rows.length === 0) return null;
   const cells = {};
   const colAligns = [];
+  const rawAligns = {};
   let maxCol = 0;
   let firstRowProcessed = false;
   const occupied = /* @__PURE__ */ new Set();
@@ -733,10 +848,20 @@ function parseTableElement(table, context) {
       } else {
         ops = [{ insert: "\n" }];
       }
-      const cellData = { ops };
+      let cellData = { ops };
       if (colspan > 1) cellData.colspan = colspan;
       if (rowspan > 1) cellData.rowspan = rowspan;
-      cells[`${rowIdx}:${colIdx}`] = cellData;
+      cellData = promoteAlignFromCellOps(cellData);
+      const htmlAlign = extractCellAlign(cell);
+      const effectiveAlign = htmlAlign ?? cellData.align ?? "left";
+      if (cellData.align !== void 0) {
+        const withoutAlign = { ...cellData };
+        delete withoutAlign.align;
+        cellData = withoutAlign;
+      }
+      const cellKey = `${rowIdx}:${colIdx}`;
+      cells[cellKey] = cellData;
+      rawAligns[cellKey] = effectiveAlign;
       for (let dr = 0; dr < rowspan; dr++) {
         for (let dc = 0; dc < colspan; dc++) {
           if (dr === 0 && dc === 0) continue;
@@ -750,8 +875,9 @@ function parseTableElement(table, context) {
       }
       if (!firstRowProcessed) {
         const align = extractCellAlign(cell);
+        const colAlign = align === "center" || align === "right" ? align : null;
         for (let dc = 0; dc < colspan; dc++) {
-          colAligns.push(align);
+          colAligns.push(colAlign);
         }
       }
       const cellEndCol = colIdx + colspan - 1;
@@ -787,11 +913,31 @@ 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;
     result.colAligns = colAligns;
   }
+  for (let r = 0; r < totalRows; r++) {
+    for (let c = 0; c < totalCols; c++) {
+      const key = `${r}:${c}`;
+      const cell = result.cells[key];
+      if (cell == null) continue;
+      const colDefault = result.colAligns?.[c] ?? "left";
+      const effective = rawAligns[key] ?? "left";
+      if (effective !== colDefault) {
+        result.cells[key] = { ...cell, align: effective };
+      }
+    }
+  }
   return result;
 }
 var tableBlockHandler = {
@@ -834,6 +980,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;
@@ -903,8 +1057,11 @@ var tableBlockHandler = {
     for (const [key, cell] of Object.entries(data.cells)) {
       if (cell !== null) {
         const normalized = normalizeDelta(new import_delta2.Delta(cell.ops), registry);
-        if (normalized.ops !== cell.ops) {
-          newCells[key] = { ...cell, ops: normalized.ops };
+        const promoted = promoteAlignFromCellOps(
+          normalized.ops !== cell.ops ? { ...cell, ops: normalized.ops } : cell
+        );
+        if (promoted.ops !== cell.ops || promoted.align !== cell.align) {
+          newCells[key] = promoted;
           changed = true;
         } else {
           newCells[key] = cell;