@extend-ai/react-xlsx 0.17.0 → 0.17.2

package/dist/index.cjs

@@ -3632,7 +3632,7 @@ function resolveWorkbookColor(color, themePalette) {
   if (directHex) {
     return normalizeHexColor2(directHex);
   }
-  const themeValue = color.theme;
+  const themeValue = color.theme ?? color.themeIndex;
   const numericTheme = typeof themeValue === "number" ? themeValue : typeof themeValue === "string" && themeValue.trim().length > 0 ? Number(themeValue) : Number.NaN;
   const themeColor = Number.isFinite(numericTheme) ? themePalette?.colorsByIndex[numericTheme] ?? null : null;
   if (!themeColor) {
@@ -4260,6 +4260,12 @@ function parseSpreadsheetFont(node) {
     return void 0;
   }
   const font = {};
+  for (const [tag, property] of [["b", "bold"], ["i", "italic"], ["strike", "strikethrough"]]) {
+    const flag = getFirstChild(node, tag);
+    if (flag) {
+      font[property] = hasEnabledSpreadsheetFlag(flag);
+    }
+  }
   const size = getFirstChild(node, "sz")?.getAttribute("val");
   const name = getFirstChild(node, "name")?.getAttribute("val");
   const family = getFirstChild(node, "family")?.getAttribute("val");
@@ -4267,15 +4273,6 @@ function parseSpreadsheetFont(node) {
   const charset = getFirstChild(node, "charset")?.getAttribute("val");
   const verticalAlign = getFirstChild(node, "vertAlign")?.getAttribute("val");
   const color = parseSpreadsheetColor(getFirstChild(node, "color"));
-  if (hasEnabledSpreadsheetFlag(getFirstChild(node, "b"))) {
-    font.bold = true;
-  }
-  if (hasEnabledSpreadsheetFlag(getFirstChild(node, "i"))) {
-    font.italic = true;
-  }
-  if (hasEnabledSpreadsheetFlag(getFirstChild(node, "strike"))) {
-    font.strikethrough = true;
-  }
   if (getFirstChild(node, "u")) {
     font.underline = getFirstChild(node, "u")?.getAttribute("val") ?? "single";
   }
@@ -4524,7 +4521,14 @@ function parseWorkbookStyles(archive) {
   const styleById = {};
   const tableStyleByName = {};
   getChildElements(cellXfsNode, "xf").forEach((xfNode, index) => {
-    styleById[index] = parseResolvedXfStyle(xfNode, fonts, fills, borders, checkboxComplementIndices);
+    const style = parseResolvedXfStyle(xfNode, fonts, fills, borders, checkboxComplementIndices);
+    const overrides = {};
+    for (const component of ["font", "fill", "border"]) {
+      if (Number(xfNode.getAttribute(`${component}Id`) ?? 0) > 0 && xfNode.getAttribute(`apply${component[0].toUpperCase()}${component.slice(1)}`) !== "0") {
+        Object.assign(overrides, { [component]: style[component] });
+      }
+    }
+    styleById[index] = { ...style, tableStyleOverrides: overrides };
   });
   getChildElements(cellStylesNode ?? document2.documentElement, "cellStyle").forEach((cellStyleNode) => {
     const name = cellStyleNode.getAttribute("name");
@@ -4868,6 +4872,7 @@ function parseSheetState(archive, path, options) {
   const rowHeightOverridesPx = {};
   const colWidthOverridesPx = {};
   const rowStyleIds = {};
+  const cellStyleIds = {};
   const colStyleIds = {};
   let minContentCol = Number.POSITIVE_INFINITY;
   let minContentRow = Number.POSITIVE_INFINITY;
@@ -4917,6 +4922,10 @@ function parseSheetState(archive, path, options) {
     }
     getChildElements(rowNode, "c").forEach((cellNode) => {
       const cellRef = cellNode.getAttribute("r");
+      const cellStyleId = Number(cellNode.getAttribute("s") ?? Number.NaN);
+      if (cellRef && Number.isFinite(cellStyleId)) {
+        cellStyleIds[cellRef] = cellStyleId;
+      }
       if (isMeaningfulCellNode(cellNode)) {
         trackContentCell(cellRef);
       }
@@ -4955,6 +4964,7 @@ function parseSheetState(archive, path, options) {
   return {
     autoFilterRanges,
     cachedFormulaValues,
+    cellStyleIds,
     columnWidthCharacterWidthPx,
     colWidthOverridesPx,
     colStyleIds,
@@ -6697,13 +6707,52 @@ function hasUnresolvedSheetReferences(workbook) {
   }
   return false;
 }
+function collectFormulaCellsWithSavedValues(workbook) {
+  const positions = [];
+  for (let sheetIdx = 0; sheetIdx < workbook.sheetCount; sheetIdx += 1) {
+    let sheet;
+    try {
+      sheet = workbook.getSheet(sheetIdx);
+    } catch {
+      continue;
+    }
+    const cells = sheet.formulaCells;
+    if (!Array.isArray(cells)) {
+      continue;
+    }
+    for (const cell of cells) {
+      if (typeof cell?.row !== "number" || typeof cell?.col !== "number") {
+        continue;
+      }
+      let saved;
+      try {
+        saved = sheet.getCalculatedValueAt(cell.row, cell.col);
+      } catch {
+        continue;
+      }
+      if (!saved.is_empty && !saved.is_error) {
+        positions.push({ sheetIdx, row: cell.row, col: cell.col });
+      }
+    }
+  }
+  return positions;
+}
+function anyBecameError(workbook, positions) {
+  return positions.some(({ sheetIdx, row, col }) => {
+    try {
+      return workbook.getSheet(sheetIdx).getCalculatedValueAt(row, col).is_error;
+    } catch {
+      return false;
+    }
+  });
+}
 function safeCalculate(workbook, options = {}) {
   if (hasUnresolvedSheetReferences(workbook)) {
     return { workbook, calculated: false, skipReason: "unresolved-sheet-refs" };
   }
+  const withSavedValues = options.reparse ? collectFormulaCellsWithSavedValues(workbook) : [];
   try {
     workbook.calculate();
-    return { workbook, calculated: true, skipReason: null };
   } catch (err) {
     console.warn("[react-xlsx] workbook.calculate() trapped; falling back to cached formula values", err);
     if (options.reparse) {
@@ -6715,6 +6764,14 @@ function safeCalculate(workbook, options = {}) {
     }
     return { workbook, calculated: false, skipReason: "calculate-trapped" };
   }
+  if (options.reparse && anyBecameError(workbook, withSavedValues)) {
+    try {
+      return { workbook: options.reparse(), calculated: false, skipReason: "calculate-regressed" };
+    } catch (reparseErr) {
+      console.warn("[react-xlsx] workbook reparse after calculate regression failed", reparseErr);
+    }
+  }
+  return { workbook, calculated: true, skipReason: null };
 }
 function tryRecalculate(workbook) {
   try {
@@ -7458,6 +7515,7 @@ function buildSheetList(workbook, sheetStatesByWorkbookSheetIndex, themePalette,
         colCount: 0,
         rowHeightOverridesPx: sheetState?.rowHeightOverridesPx ?? {},
         rowStyleIds: sheetState?.rowStyleIds ?? {},
+        cellStyleIds: sheetState?.cellStyleIds ?? {},
         styleById: styleById ?? {},
         sparklines: sheetState?.sparklines ?? [],
         tableStyleByName: tableStyleByName ?? {},
@@ -7544,6 +7602,7 @@ function buildSheetList(workbook, sheetStatesByWorkbookSheetIndex, themePalette,
       namedCellStyleByName: namedCellStyleByName ?? {},
       rowHeightOverridesPx: sheetState?.rowHeightOverridesPx ?? {},
       rowStyleIds: sheetState?.rowStyleIds ?? {},
+      cellStyleIds: sheetState?.cellStyleIds ?? {},
       showGridLines: sheetState?.showGridLines ?? true,
       styleById: styleById ?? {},
       sparklines: sheetState?.sparklines ?? [],
@@ -10007,7 +10066,7 @@ function useXlsxViewerController(options) {
       return;
     }
     const dataStartRow = targetTable.start.row + Math.max(targetTable.headerRowCount, 1);
-    const totalsRowOffset = targetTable.totalsRowShown ? Math.max(targetTable.totalsRowCount, 1) : 0;
+    const totalsRowOffset = targetTable.totalsRowCount;
     const dataEndRow = targetTable.end.row - totalsRowOffset;
     const startCol = targetTable.start.col;
     const endCol = targetTable.end.col;
@@ -19171,7 +19230,8 @@ function applyCanvasBorderDash(context, style, width) {
   context.setLineDash([]);
 }
 function strokeCanvasBorderSide(context, side, rect, border) {
-  const halfWidth = border.width / 2;
+  const strokeWidth = border.style === "double" ? border.width / 3 : border.width;
+  const halfWidth = strokeWidth / 2;
   const left = rect.left;
   const right = rect.left + rect.width;
   const top = rect.top;
@@ -19197,8 +19257,8 @@ function strokeCanvasBorderSide(context, side, rect, border) {
     context.stroke();
   };
   if (border.style === "double") {
-    const inset = Math.max(1, border.width);
-    context.lineWidth = Math.max(1, border.width / 3);
+    const inset = border.width - strokeWidth;
+    context.lineWidth = strokeWidth;
     context.setLineDash([]);
     strokeLine(0);
     strokeLine(inset);
@@ -22111,6 +22171,43 @@ function mergeResolvedCellStyle(base, overlay, options) {
   }
   return nextStyle;
 }
+function resolveCellTableOverrides(rawStyle, sheet, row, col) {
+  const styleId = sheet?.cellStyleIds?.[cellAddressToA12({ row, col })] ?? sheet?.rowStyleIds[row] ?? sheet?.colStyleIds[col];
+  const declared = styleId === void 0 ? void 0 : sheet?.styleById[styleId]?.tableStyleOverrides;
+  const overrides = {};
+  const font = asRecord(rawStyle?.font);
+  if (font) {
+    const explicitFont = {};
+    const fontDefaults = {
+      name: "Calibri",
+      size: 11,
+      bold: false,
+      italic: false,
+      underline: "none",
+      strikethrough: false,
+      verticalAlign: "baseline"
+    };
+    for (const [key, value] of Object.entries(font)) {
+      const isExplicit = declared ? Object.hasOwn(declared.font ?? {}, key) : key === "color" ? asRecord(value)?.colorType !== "auto" : value !== fontDefaults[key];
+      if (isExplicit) {
+        explicitFont[key] = value;
+      }
+    }
+    overrides.font = explicitFont;
+  }
+  const fill = asRecord(rawStyle?.fill);
+  if (fill && fill.fillType !== "none") {
+    overrides.fill = fill;
+  }
+  const border = asRecord(rawStyle?.border);
+  if (border) {
+    overrides.border = Object.fromEntries(Object.entries(border).filter(([, edge]) => {
+      const style = asRecord(edge)?.style;
+      return typeof style === "string" && style !== "none";
+    }));
+  }
+  return overrides;
+}
 function resolveBorderEdgePriority(edge) {
   const style = typeof edge?.style === "string" ? edge.style : "none";
   const stylePriority = {
@@ -22239,7 +22336,7 @@ function resolveTableCellStyle(table, row, col, activeSheet) {
     return null;
   }
   const headerRowCount = Math.max(table.headerRowCount, 1);
-  const totalsRowCount = table.totalsRowShown ? Math.max(table.totalsRowCount, 1) : 0;
+  const totalsRowCount = table.totalsRowCount;
   const headerEndRow = table.start.row + headerRowCount - 1;
   const totalsStartRow = table.end.row - totalsRowCount + 1;
   const bodyStartRow = headerEndRow + 1;
@@ -26563,7 +26660,10 @@ function XlsxGrid({
       });
       const targetTable = getTableAtCell(effectiveTables, targetRow, targetCol);
       const targetTableStyle = resolveTableCellStyle(targetTable, targetRow, targetCol, activeSheet);
-      const resolvedStyle = mergeResolvedCellStyle(targetRawStyle, targetTableStyle);
+      const resolvedStyle = targetTableStyle ? mergeResolvedCellStyle(
+        mergeResolvedCellStyle(targetRawStyle, targetTableStyle),
+        resolveCellTableOverrides(targetRawStyle, activeSheet, targetRow, targetCol)
+      ) : targetRawStyle;
       cellBaseRawStyleCacheRef.current.set(targetCacheKey, resolvedStyle);
       return resolvedStyle;
     };
@@ -28934,6 +29034,14 @@ function XlsxGrid({
           hasPendingGridlinePath = false;
         };
         const drawnMergedAnchorKeys = /* @__PURE__ */ new Set();
+        const deferredDoubleBorders = [];
+        const drawCellBorder = (side, rect, border) => {
+          if (border.style === "double") {
+            deferredDoubleBorders.push({ side, rect, border });
+          } else {
+            strokeCanvasBorderSide(paneContext, side, rect, border);
+          }
+        };
         for (const rowItem of paneAxisItems.rows) {
           for (const colItem of paneAxisItems.cols) {
             const cell = { row: rowItem.actualRow, col: colItem.actualCol };
@@ -29080,16 +29188,24 @@ function XlsxGrid({
               flushPendingGridlines();
             }
             if (topBorder && drawRowIndex === 0) {
-              strokeCanvasBorderSide(paneContext, "top", localRect, topBorder);
+              drawCellBorder("top", localRect, topBorder);
             }
             if (resolvedRightBorder) {
-              strokeCanvasBorderSide(paneContext, "right", localRect, resolvedRightBorder);
+              if (resolvedRightBorder.style === "double" && resolvedRightBorder === rightNeighborLeftBorder) {
+                drawCellBorder("left", { ...localRect, left: localRect.left + localRect.width }, resolvedRightBorder);
+              } else {
+                drawCellBorder("right", localRect, resolvedRightBorder);
+              }
             }
             if (resolvedBottomBorder) {
-              strokeCanvasBorderSide(paneContext, "bottom", localRect, resolvedBottomBorder);
+              if (resolvedBottomBorder.style === "double" && resolvedBottomBorder === bottomNeighborTopBorder) {
+                drawCellBorder("top", { ...localRect, top: localRect.top + localRect.height }, resolvedBottomBorder);
+              } else {
+                drawCellBorder("bottom", localRect, resolvedBottomBorder);
+              }
             }
             if (leftBorder && drawColIndex === 0) {
-              strokeCanvasBorderSide(paneContext, "left", localRect, leftBorder);
+              drawCellBorder("left", localRect, leftBorder);
             }
             if (cellData.chartHighlight) {
               const highlightBorder = {
@@ -29362,6 +29478,9 @@ function XlsxGrid({
           }
         }
         flushPendingGridlines();
+        for (const { side, rect, border } of deferredDoubleBorders) {
+          strokeCanvasBorderSide(paneContext, side, rect, border);
+        }
       }
       for (const pane of cellPaneOrder) {
         const paneContext = bodyContexts[pane];