@extend-ai/react-xlsx 0.13.2 → 0.13.3

package/dist/index.cjs

@@ -8101,8 +8101,9 @@ function useXlsxViewerController(options) {
   const readOnly = requestedReadOnly || forcedReadOnly;
   const canResizeReadOnly = requestedReadOnly && allowResizeInReadOnly && !forcedReadOnly;
   const workerSupported = useWorker && typeof Worker !== "undefined" && canUseConfiguredWasmSourceInWorker();
-  const shouldUseWorker = workerSupported && forcedReadOnly;
+  const canUseWorkerForRequestedReadOnly = requestedReadOnly;
   const shouldForceReadOnlyForBuffer = React.useCallback((bufferByteLength) => !requestedReadOnly && readOnlyAboveBytes > 0 && bufferByteLength > readOnlyAboveBytes, [readOnlyAboveBytes, requestedReadOnly]);
+  const shouldUseWorkerForReadOnlyLoad = React.useCallback((willForceReadOnly) => workerSupported && (willForceReadOnly || canUseWorkerForRequestedReadOnly), [canUseWorkerForRequestedReadOnly, workerSupported]);
   const disposeWorkerClient = React.useCallback(() => {
     workerClientRef.current?.dispose();
     workerClientRef.current = null;
@@ -8153,9 +8154,6 @@ function useXlsxViewerController(options) {
   const hasIncompleteWorkerChartSnapshot = React.useCallback((snapshot) => {
     for (const sheetCharts of snapshot.chartsByWorkbookSheetIndex) {
       for (const chart of sheetCharts) {
-        if (!chart.chartPath) {
-          return true;
-        }
         if (chart.chartType !== "Bubble") {
           continue;
         }
@@ -8402,7 +8400,7 @@ function useXlsxViewerController(options) {
       }
       const shouldForceReadOnly = shouldForceReadOnlyForBuffer(buffer.byteLength);
       setForcedReadOnly(shouldForceReadOnly);
-      const shouldUseWorkerForLoad = workerSupported && shouldForceReadOnly;
+      const shouldUseWorkerForLoad = shouldUseWorkerForReadOnlyLoad(shouldForceReadOnly);
       const effectiveSkipXmlParsing = shouldSkipXmlParsingForWorkbook(new Uint8Array(buffer), skipXmlParsing);
       if (shouldDeferLoading && buffer.byteLength > deferLoadingAboveBytes) {
         deferredBufferRef.current = buffer;
@@ -8499,13 +8497,12 @@ function useXlsxViewerController(options) {
     hasIncompleteWorkerChartSnapshot,
     loadWorkbookOnMainThread,
     maxFileSizeBytes,
-    requestedReadOnly,
     setImageAssets,
     startChartDisplayHydration,
     shouldFallbackFromWorkerError,
     shouldDeferLoading,
     shouldForceReadOnlyForBuffer,
-    workerSupported,
+    shouldUseWorkerForReadOnlyLoad,
     src,
     showHiddenSheets
   ]);
@@ -8634,7 +8631,7 @@ function useXlsxViewerController(options) {
     }
     const shouldForceReadOnly = shouldForceReadOnlyForBuffer(deferredBuffer.byteLength);
     setForcedReadOnly(shouldForceReadOnly);
-    const shouldUseWorkerForLoad = workerSupported && shouldForceReadOnly;
+    const shouldUseWorkerForLoad = shouldUseWorkerForReadOnlyLoad(shouldForceReadOnly);
     const effectiveSkipXmlParsing = shouldSkipXmlParsingForWorkbook(new Uint8Array(deferredBuffer), skipXmlParsing);
     if (shouldUseWorkerForLoad) {
       void getWorkerClient().loadWorkbook(deferredBuffer, effectiveSkipXmlParsing, showHiddenSheets).then((snapshot) => {
@@ -8747,14 +8744,13 @@ function useXlsxViewerController(options) {
     disposeWorkerClient,
     getWorkerClient,
     loadWorkbookOnMainThread,
-    requestedReadOnly,
     setImageAssets,
     startChartDisplayHydration,
     hasIncompleteWorkerChartSnapshot,
     maxFileSizeBytes,
     shouldFallbackFromWorkerError,
     shouldForceReadOnlyForBuffer,
-    workerSupported
+    shouldUseWorkerForReadOnlyLoad
   ]);
   const maybeRecalculateWorkbook = React.useCallback((targetWorkbook) => {
     if (!shouldAutoCalculate) {
@@ -9468,8 +9464,58 @@ function useXlsxViewerController(options) {
     }
     setShouldAutoCalculate(false);
   }, [refreshWorkbookState, workbook]);
+  const applyReadOnlyResizeOverride = React.useCallback((axis, actualIndex, sizePx) => {
+    if (!activeSheet) {
+      return;
+    }
+    const contentSizePx = resolveContentSheetAxisPixels(sizePx, activeSheet.showGridLines);
+    const targetWorkbookSheetIndex = activeSheet.workbookSheetIndex;
+    setSheets((currentSheets) => currentSheets.map((sheet) => {
+      if (sheet.workbookSheetIndex !== targetWorkbookSheetIndex) {
+        return sheet;
+      }
+      if (axis === "column") {
+        const nextColWidthOverridesPx = {
+          ...sheet.colWidthOverridesPx,
+          [actualIndex]: contentSizePx
+        };
+        const nextColWidths = [...sheet.colWidths];
+        const visibleColIndex = sheet.visibleCols.indexOf(actualIndex);
+        if (visibleColIndex >= 0) {
+          nextColWidths[visibleColIndex] = contentSizePx;
+        }
+        return {
+          ...sheet,
+          colWidthOverridesPx: nextColWidthOverridesPx,
+          colWidths: nextColWidths
+        };
+      }
+      const nextRowHeightOverridesPx = {
+        ...sheet.rowHeightOverridesPx,
+        [actualIndex]: contentSizePx
+      };
+      const nextRowHeights = [...sheet.rowHeights];
+      const visibleRowIndex = sheet.visibleRows.indexOf(actualIndex);
+      if (visibleRowIndex >= 0) {
+        nextRowHeights[visibleRowIndex] = contentSizePx;
+      }
+      return {
+        ...sheet,
+        rowHeightOverridesPx: nextRowHeightOverridesPx,
+        rowHeights: nextRowHeights
+      };
+    }));
+    setRevision((current) => current + 1);
+  }, [activeSheet]);
   const resizeColumn = React.useCallback((col, widthPx) => {
-    if (readOnly && !canResizeReadOnly || !workbook || !activeSheet) {
+    if (readOnly && !canResizeReadOnly || !activeSheet) {
+      return;
+    }
+    if (isWorkerBacked) {
+      applyReadOnlyResizeOverride("column", col, widthPx);
+      return;
+    }
+    if (!workbook) {
       return;
     }
     recordHistoryBeforeMutation();
@@ -9479,9 +9525,25 @@ function useXlsxViewerController(options) {
       pxToSheetColumnWidth(resolveContentSheetAxisPixels(widthPx, activeSheet.showGridLines))
     );
     refreshWorkbookState(workbook);
-  }, [activeSheet, canResizeReadOnly, readOnly, recordHistoryBeforeMutation, refreshWorkbookState, workbook]);
+  }, [
+    activeSheet,
+    applyReadOnlyResizeOverride,
+    canResizeReadOnly,
+    isWorkerBacked,
+    readOnly,
+    recordHistoryBeforeMutation,
+    refreshWorkbookState,
+    workbook
+  ]);
   const resizeRow = React.useCallback((row, heightPx) => {
-    if (readOnly && !canResizeReadOnly || !workbook || !activeSheet) {
+    if (readOnly && !canResizeReadOnly || !activeSheet) {
+      return;
+    }
+    if (isWorkerBacked) {
+      applyReadOnlyResizeOverride("row", row, heightPx);
+      return;
+    }
+    if (!workbook) {
       return;
     }
     recordHistoryBeforeMutation();
@@ -9491,7 +9553,16 @@ function useXlsxViewerController(options) {
       pxToSheetRowHeight(resolveContentSheetAxisPixels(heightPx, activeSheet.showGridLines))
     );
     refreshWorkbookState(workbook);
-  }, [activeSheet, canResizeReadOnly, readOnly, recordHistoryBeforeMutation, refreshWorkbookState, workbook]);
+  }, [
+    activeSheet,
+    applyReadOnlyResizeOverride,
+    canResizeReadOnly,
+    isWorkerBacked,
+    readOnly,
+    recordHistoryBeforeMutation,
+    refreshWorkbookState,
+    workbook
+  ]);
   const resolveAnchoredObjectRect = React.useCallback((anchor, worksheet) => {
     const resolveAxisSum = (index, getSize) => {
       let total = 0;
@@ -23059,12 +23130,16 @@ function XlsxGrid({
           continue;
         }
         widths[col] = Math.max(
-          resolveRenderedSheetAxisPixels(precomputedWidths[index] ?? activeSheet?.defaultColWidthPx ?? DEFAULT_COL_WIDTH2, showGridLines),
+          resolveRenderedSheetAxisPixels(
+            activeSheet?.colWidthOverridesPx[col] ?? precomputedWidths[index] ?? activeSheet?.defaultColWidthPx ?? DEFAULT_COL_WIDTH2,
+            showGridLines
+          ),
           DEFAULT_COL_WIDTH2 / 2
         );
       }
       for (let col = Math.max(0, (activeSheet?.maxUsedCol ?? -1) + 1); col < displayColLimit; col += 1) {
-        widths[col] = fallbackWidth;
+        const overrideWidth = activeSheet?.colWidthOverridesPx[col];
+        widths[col] = overrideWidth === void 0 ? fallbackWidth : Math.max(resolveRenderedSheetAxisPixels(overrideWidth, showGridLines), DEFAULT_COL_WIDTH2 / 2);
       }
       return widths;
     },
@@ -23156,12 +23231,16 @@ function XlsxGrid({
           continue;
         }
         heights[row] = Math.max(
-          resolveRenderedSheetAxisPixels(precomputedHeights[index] ?? activeSheet?.defaultRowHeightPx ?? DEFAULT_ROW_HEIGHT2, showGridLines),
+          resolveRenderedSheetAxisPixels(
+            activeSheet?.rowHeightOverridesPx[row] ?? precomputedHeights[index] ?? activeSheet?.defaultRowHeightPx ?? DEFAULT_ROW_HEIGHT2,
+            showGridLines
+          ),
           DEFAULT_ROW_HEIGHT2 / 1.5
         );
       }
       for (let row = Math.max(0, (activeSheet?.maxUsedRow ?? -1) + 1); row < displayRowLimit; row += 1) {
-        heights[row] = fallbackHeight;
+        const overrideHeight = activeSheet?.rowHeightOverridesPx[row];
+        heights[row] = overrideHeight === void 0 ? fallbackHeight : Math.max(resolveRenderedSheetAxisPixels(overrideHeight, showGridLines), DEFAULT_ROW_HEIGHT2 / 1.5);
       }
       return heights;
     },
@@ -24315,8 +24394,25 @@ function XlsxGrid({
   const [, startSelectionTransition] = React4.useTransition();
   const [asyncViewportRowBatch, setAsyncViewportRowBatch] = React4.useState(null);
   const viewportRequest = React4.useMemo(() => {
-    const firstVirtualRowIndex = domExpandedWindow.rowIndices[0];
-    const lastVirtualRowIndex = domExpandedWindow.rowIndices[domExpandedWindow.rowIndices.length - 1];
+    const rowIndices = experimentalCanvas ? (() => {
+      if (visibleRows.length === 0 || drawingViewport.height <= 0) {
+        return [];
+      }
+      const indices = new Set(frozenRowVirtualIndices);
+      const viewportStart = Math.max(0, drawingViewport.top - displayHeaderHeight - CANVAS_VIEWPORT_OVERSCAN_PX);
+      const viewportEnd = Math.max(
+        viewportStart,
+        drawingViewport.top + drawingViewport.height - displayHeaderHeight + CANVAS_VIEWPORT_OVERSCAN_PX
+      );
+      const startIndex = findIndexForOffsetPrefix(rowPrefixSums, viewportStart);
+      const endIndex = findIndexForOffsetPrefix(rowPrefixSums, viewportEnd);
+      for (let index = Math.max(0, startIndex); index <= Math.max(startIndex, endIndex); index += 1) {
+        indices.add(index);
+      }
+      return Array.from(indices).sort((left, right) => left - right);
+    })() : domExpandedWindow.rowIndices;
+    const firstVirtualRowIndex = rowIndices[0];
+    const lastVirtualRowIndex = rowIndices[rowIndices.length - 1];
     const firstVisibleRow2 = firstVirtualRowIndex === void 0 ? void 0 : visibleRows[firstVirtualRowIndex];
     const lastVisibleRow2 = lastVirtualRowIndex === void 0 ? void 0 : visibleRows[lastVirtualRowIndex];
     if (firstVisibleRow2 === void 0 || lastVisibleRow2 === void 0 || lastVisibleRow2 < firstVisibleRow2) {
@@ -24329,7 +24425,16 @@ function XlsxGrid({
       endRow,
       startRow
     };
-  }, [domExpandedWindow.rowIndices, visibleRows]);
+  }, [
+    displayHeaderHeight,
+    domExpandedWindow.rowIndices,
+    drawingViewport.height,
+    drawingViewport.top,
+    experimentalCanvas,
+    frozenRowVirtualIndices,
+    rowPrefixSums,
+    visibleRows
+  ]);
   const syncViewportRowBatch = React4.useMemo(() => {
     if (!shouldVirtualizeRows || !worksheet || getRowsBatchAsync || !viewportRequest) {
       return null;