@rowsncolumns/spreadsheet 10.2.68

package/dist/cjs/hooks/use-header-actions.d.ts

@@ -0,0 +1,70 @@
+import type { CellInterface, CellPosition, PosXYRequired, ScrollCoords, ViewPortProps } from "@rowsncolumns/grid";
+import React from "react";
+import type { CanvasGridProps } from "../components/canvas-grid/typings";
+import type { AXIS } from "../types";
+import type { useSelection } from "./use-selection";
+type UseHeaderActions = {
+    backgroundColor?: string;
+    activeCell?: CellInterface | null;
+    getScrollPosition: () => ScrollCoords | undefined;
+    getCellOffsetFromCoords: (cell: CellInterface) => CellPosition | undefined;
+    getRelativePositionFromOffset: (x: number, y: number) => PosXYRequired | null | undefined;
+    /**
+     * Callback when user resizes a column or row
+     */
+    onResize?: CanvasGridProps["onResize"];
+    /**
+     * Focus current sheet
+     */
+    focusSheet?(): void;
+    /**
+     * Called when user double clicks on a column or row
+     */
+    onAutoFit?: (index: number, axis: AXIS) => void;
+    isRowHeader(columnIndex: number): boolean;
+    isColumnHeader(rowIndex: number): boolean;
+    /**
+     * Show context menu for a cell
+     * @param cell
+     * @param x
+     * @param y
+     */
+    showContextMenu(cell: CellInterface, x: number, y: number): void;
+    selectColumn(columnIndex: number): void;
+    /**
+     * Set active cell
+     * @param coords
+     * @param shouldScroll
+     */
+    setActiveCell: ReturnType<typeof useSelection>["setActiveCell"];
+    getViewPort(): ViewPortProps;
+    isHiddenColumn: (columnIndex: number) => boolean;
+    showHeaderMenuButton?: boolean;
+    frozenRows: number;
+    frozenColumns: number;
+    headerMenuWidth?: number;
+    selectionTopBound: number;
+    resizerDimension?: number;
+    headerBorderWidth?: number;
+    containerWidth: number;
+    containerHeight: number;
+    minDimension?: number;
+    scale?: number;
+    sheetId: number;
+    selectedRowHeadersIds: number[];
+    selectedColumnHeadersIds: number[];
+    enableResizerOverflow?: boolean;
+};
+/**
+ * User header actions hook
+ * @param param0
+ * @returns
+ */
+export declare const useHeaderActions: ({ activeCell, getScrollPosition, getCellOffsetFromCoords, getRelativePositionFromOffset, onResize, onAutoFit, isRowHeader, isColumnHeader, showContextMenu, selectColumn, setActiveCell, getViewPort, isHiddenColumn, focusSheet, frozenRows, frozenColumns, showHeaderMenuButton, selectionTopBound, resizerDimension, headerBorderWidth, minDimension, containerHeight, containerWidth, backgroundColor, scale, headerMenuWidth, sheetId, selectedRowHeadersIds, selectedColumnHeadersIds, enableResizerOverflow, }: UseHeaderActions) => {
+    headerMenuComponent: React.JSX.Element | null;
+    isHeaderMenuInFrozenColumn: boolean;
+    headerResizer: React.JSX.Element | null;
+    isDragging: boolean;
+};
+export {};
+//# sourceMappingURL=use-header-actions.d.ts.map

package/dist/cjs/hooks/use-header-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-header-actions.d.ts","sourceRoot":"","sources":["../../../hooks/use-header-actions.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAiD,MAAM,OAAO,CAAC;AAGtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,KAAK,gBAAgB,GAAG;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAClC,iBAAiB,EAAE,MAAM,YAAY,GAAG,SAAS,CAAC;IAClD,uBAAuB,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,YAAY,GAAG,SAAS,CAAC;IAC3E,6BAA6B,EAAE,CAC7B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,KACN,aAAa,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC;;OAEG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;IACvC;;OAEG;IACH,UAAU,CAAC,IAAI,IAAI,CAAC;IACpB;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAChD,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1C,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC;;;;OAIG;IACH,aAAa,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,eAAe,CAAC,CAAC;IAChE,WAAW,IAAI,aAAa,CAAC;IAC7B,cAAc,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,ufA+B9B,gBAAgB;;;;;CA8VlB,CAAC"}

package/dist/cjs/hooks/use-header-actions.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHeaderActions = void 0;
+var tslib_1 = require("tslib");
+var react_1 = tslib_1.__importStar(require("react"));
+var scheduler_1 = require("../api/scheduler");
+var header_menu_1 = require("../components/header-menu");
+var header_resizer_1 = require("../components/header-resizer");
+var use_isomorphic_layout_effect_1 = require("./use-isomorphic-layout-effect");
+/**
+ * User header actions hook
+ * @param param0
+ * @returns
+ */
+var useHeaderActions = function (_a) {
+    var activeCell = _a.activeCell, getScrollPosition = _a.getScrollPosition, getCellOffsetFromCoords = _a.getCellOffsetFromCoords, getRelativePositionFromOffset = _a.getRelativePositionFromOffset, onResize = _a.onResize, onAutoFit = _a.onAutoFit, isRowHeader = _a.isRowHeader, isColumnHeader = _a.isColumnHeader, showContextMenu = _a.showContextMenu, selectColumn = _a.selectColumn, setActiveCell = _a.setActiveCell, getViewPort = _a.getViewPort, isHiddenColumn = _a.isHiddenColumn, focusSheet = _a.focusSheet, frozenRows = _a.frozenRows, frozenColumns = _a.frozenColumns, showHeaderMenuButton = _a.showHeaderMenuButton, selectionTopBound = _a.selectionTopBound, _b = _a.resizerDimension, resizerDimension = _b === void 0 ? 5 : _b, _c = _a.headerBorderWidth, headerBorderWidth = _c === void 0 ? 1 : _c, _d = _a.minDimension, minDimension = _d === void 0 ? 5 : _d, containerHeight = _a.containerHeight, containerWidth = _a.containerWidth, backgroundColor = _a.backgroundColor, _e = _a.scale, scale = _e === void 0 ? 1 : _e, _f = _a.headerMenuWidth, headerMenuWidth = _f === void 0 ? 16 * scale : _f, sheetId = _a.sheetId, selectedRowHeadersIds = _a.selectedRowHeadersIds, selectedColumnHeadersIds = _a.selectedColumnHeadersIds, _g = _a.enableResizerOverflow, enableResizerOverflow = _g === void 0 ? false : _g;
+    var _h = tslib_1.__read((0, react_1.useState)(0), 2), dimension = _h[0], setDimension = _h[1];
+    var _j = tslib_1.__read((0, react_1.useState)(false), 2), isDragging = _j[0], setIsDragging = _j[1];
+    var dragStartPos = (0, react_1.useRef)(0);
+    var activeCellRef = (0, react_1.useRef)(undefined);
+    var axisRef = (0, react_1.useRef)(undefined);
+    var dimensionRef = (0, react_1.useRef)(0);
+    var initialDimensionRef = (0, react_1.useRef)(0);
+    var hiddenMarkerDim = 15;
+    var selectedIndexesRef = (0, react_1.useRef)(undefined);
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        dimensionRef.current = dimension;
+    }, [dimension]);
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        selectedIndexesRef.current =
+            axisRef.current === "x"
+                ? selectedRowHeadersIds
+                : selectedColumnHeadersIds;
+    }, [isDragging, selectedColumnHeadersIds, selectedRowHeadersIds]);
+    // Check if header is selected
+    var isHeaderSelected = (0, react_1.useCallback)(function (index) {
+        var _a;
+        return (_a = selectedIndexesRef.current) === null || _a === void 0 ? void 0 : _a.includes(index);
+    }, []);
+    // Show header menu
+    var showHeaderMenu = (0, react_1.useCallback)(function (activeCell, x, y) {
+        var actualFrozenRows = frozenRows - 1;
+        var visibleRowStartIndex = getViewPort().visibleRowStartIndex;
+        // Set the first visible cell
+        setActiveCell(sheetId, tslib_1.__assign(tslib_1.__assign({}, activeCell), { rowIndex: actualFrozenRows >= selectionTopBound
+                ? selectionTopBound
+                : visibleRowStartIndex }), false);
+        // Select entire column
+        selectColumn(activeCell.columnIndex);
+        // Show context menu
+        showContextMenu(activeCell, x, y);
+    }, [
+        sheetId,
+        frozenRows,
+        getViewPort,
+        selectionTopBound,
+        selectColumn,
+        showContextMenu,
+        setActiveCell,
+    ]);
+    /**
+     * Frozen column headers do not translate with horizontal scroll,
+     * so the menu overlay must skip the scroll offset for them
+     */
+    var isHeaderMenuInFrozenColumn = !!activeCell && activeCell.columnIndex < frozenColumns;
+    /**
+     * Header actions component
+     */
+    var headerMenuComponent = (0, react_1.useMemo)(function () {
+        var _a;
+        if (!showHeaderMenuButton ||
+            isDragging ||
+            !activeCell ||
+            !isColumnHeader(activeCell.rowIndex) ||
+            (isColumnHeader(activeCell.rowIndex) &&
+                isRowHeader(activeCell.columnIndex))) {
+            return null;
+        }
+        // Only visible for column headers
+        var _b = (_a = getCellOffsetFromCoords(activeCell)) !== null && _a !== void 0 ? _a : {}, _c = _b.x, x = _c === void 0 ? 0 : _c, _d = _b.y, y = _d === void 0 ? 0 : _d, _e = _b.width, width = _e === void 0 ? 0 : _e, _f = _b.height, height = _f === void 0 ? 0 : _f;
+        var isSelected = isHeaderSelected(axisRef.current === "x" ? activeCell.rowIndex : activeCell.columnIndex);
+        var isNextColumnHidden = isHiddenColumn(activeCell.columnIndex + 1);
+        var spacing = (height - headerMenuWidth) / 2;
+        var left = x +
+            // scrollLeft +
+            width -
+            headerMenuWidth -
+            spacing +
+            (isNextColumnHidden ? -hiddenMarkerDim + spacing : 0);
+        var top = y + (height - headerMenuWidth) / 2;
+        return (react_1.default.createElement(header_menu_1.Headermenu, { left: left, top: top, dimension: headerMenuWidth, onClick: function (e) {
+                showHeaderMenu(activeCell, e.nativeEvent.clientX, e.nativeEvent.clientY);
+            }, 
+            /**
+             * We are listening to mousedown events in
+             * <BaseGrid />
+             * This div appears above it and events dont get
+             * propagated to the BaseGrid
+             */
+            onContextMenu: function (e) {
+                showHeaderMenu(activeCell, e.nativeEvent.clientX, e.nativeEvent.clientY);
+            }, isSelected: isSelected, scale: scale }));
+    }, [
+        activeCell,
+        headerMenuWidth,
+        showHeaderMenuButton,
+        hiddenMarkerDim,
+        isDragging,
+        isHiddenColumn,
+        showHeaderMenu,
+        getCellOffsetFromCoords,
+        isColumnHeader,
+        isRowHeader,
+        isHeaderSelected,
+        scale,
+    ]);
+    /**
+     * Called when user drags header resize component
+     */
+    var handleMouseMove = (0, react_1.useCallback)(function (e) {
+        var relativePosition = getRelativePositionFromOffset(e.clientX, e.clientY);
+        if (!relativePosition) {
+            return;
+        }
+        var pos = axisRef.current === "x" ? relativePosition.y : relativePosition.x;
+        var finalDimension = pos - dragStartPos.current;
+        if (initialDimensionRef.current + finalDimension < minDimension) {
+            finalDimension = minDimension - initialDimensionRef.current;
+        }
+        setDimension(finalDimension);
+    }, [minDimension, getRelativePositionFromOffset]);
+    /**
+     * Called when user finishes dragging the component
+     */
+    var handleMouseUp = (0, react_1.useCallback)(function () {
+        var _a, _b, _c;
+        document.removeEventListener("mousemove", handleMouseMove);
+        document.removeEventListener("mouseup", handleMouseUp);
+        // Header resizer does not update otherwise.. @Vinay TODO Fix this later
+        (0, scheduler_1.scheduleLowPriorityCallback)(function () {
+            setDimension(0);
+            setIsDragging(false);
+        });
+        if (!activeCellRef.current || !axisRef.current || !dimensionRef.current) {
+            return;
+        }
+        var activeCellIndex = axisRef.current === "x"
+            ? (_a = activeCellRef.current) === null || _a === void 0 ? void 0 : _a.rowIndex
+            : (_b = activeCellRef.current) === null || _b === void 0 ? void 0 : _b.columnIndex;
+        var indexes = ((_c = selectedIndexesRef.current) === null || _c === void 0 ? void 0 : _c.length) &&
+            selectedIndexesRef.current.includes(activeCellIndex)
+            ? selectedIndexesRef.current
+            : [activeCellIndex];
+        var finalDimension = Math.max(0, initialDimensionRef.current + dimensionRef.current);
+        onResize === null || onResize === void 0 ? void 0 : onResize(sheetId, indexes, finalDimension / scale, axisRef.current);
+        // Keep the focus back
+        focusSheet === null || focusSheet === void 0 ? void 0 : focusSheet();
+        activeCellRef.current = null;
+    }, [handleMouseMove, onResize, focusSheet, scale, sheetId]);
+    /**
+     * When user activates resize component
+     * @param e
+     * @returns
+     */
+    var handleMouseDown = (0, react_1.useCallback)(function (e) {
+        var _a;
+        if (!activeCell || e.button !== 0) {
+            return;
+        }
+        setIsDragging(true);
+        var relativePosition = getRelativePositionFromOffset(e.nativeEvent.clientX, e.nativeEvent.clientY);
+        if (!relativePosition) {
+            return;
+        }
+        var _b = (_a = getCellOffsetFromCoords(activeCell)) !== null && _a !== void 0 ? _a : {}, _c = _b.width, width = _c === void 0 ? 0 : _c, _d = _b.height, height = _d === void 0 ? 0 : _d;
+        activeCellRef.current = activeCell;
+        axisRef.current = (activeCell === null || activeCell === void 0 ? void 0 : activeCell.rowIndex) === 0 ? "y" : "x";
+        dragStartPos.current =
+            axisRef.current === "x" ? relativePosition.y : relativePosition.x;
+        initialDimensionRef.current = axisRef.current === "x" ? height : width;
+        document.addEventListener("mousemove", handleMouseMove);
+        document.addEventListener("mouseup", handleMouseUp);
+    }, [
+        activeCell,
+        handleMouseMove,
+        handleMouseUp,
+        getCellOffsetFromCoords,
+        getRelativePositionFromOffset,
+    ]);
+    /**
+     * Header resize component
+     */
+    var headerResizer = (0, react_1.useMemo)(function () {
+        var _a, _b;
+        var currentCell = isDragging ? activeCellRef.current : activeCell;
+        if (!currentCell) {
+            return null;
+        }
+        var rowIndex = currentCell.rowIndex, columnIndex = currentCell.columnIndex;
+        if ((!isRowHeader(columnIndex) && !isColumnHeader(rowIndex)) ||
+            (isRowHeader(columnIndex) && isColumnHeader(rowIndex))) {
+            return null;
+        }
+        var _c = (_a = getCellOffsetFromCoords(currentCell)) !== null && _a !== void 0 ? _a : {}, _d = _c.x, x = _d === void 0 ? 0 : _d, _e = _c.y, y = _e === void 0 ? 0 : _e, _f = _c.width, width = _f === void 0 ? 0 : _f, _g = _c.height, height = _g === void 0 ? 0 : _g;
+        var _h = (_b = getScrollPosition()) !== null && _b !== void 0 ? _b : {}, _j = _h.scrollLeft, scrollX = _j === void 0 ? 0 : _j, _k = _h.scrollTop, scrollY = _k === void 0 ? 0 : _k;
+        var axis = isColumnHeader(rowIndex) ? "y" : "x";
+        // Frozen rows/columns are not affected by scroll
+        var scrollLeft = columnIndex < frozenColumns ? 0 : scrollX;
+        var scrollTop = rowIndex < frozenRows ? 0 : scrollY;
+        var left = axis === "y"
+            ? Math.min(x -
+                scrollLeft +
+                width -
+                resizerDimension +
+                dimension +
+                headerBorderWidth, enableResizerOverflow ? Number.MAX_SAFE_INTEGER : containerWidth)
+            : headerBorderWidth;
+        var top = axis === "x"
+            ? Math.min(y -
+                scrollTop +
+                height -
+                resizerDimension +
+                dimension +
+                headerBorderWidth, enableResizerOverflow ? Number.MAX_SAFE_INTEGER : containerHeight)
+            : headerBorderWidth;
+        var resizerWidth = axis === "y" ? resizerDimension : width - headerBorderWidth;
+        var resizerHeight = axis === "y" ? height - headerBorderWidth : resizerDimension;
+        var index = axis === "y" ? columnIndex : rowIndex;
+        return (react_1.default.createElement(header_resizer_1.HeaderResizer, { left: left, top: top, width: resizerWidth, height: resizerHeight, axis: axis, onMouseDown: handleMouseDown, onMouseMove: function (e) { return e.stopPropagation(); }, isDragging: isDragging, dimension: resizerDimension, onAutoFit: onAutoFit, index: index, containerHeight: containerHeight, containerWidth: containerWidth, backgroundColor: backgroundColor }));
+    }, [
+        activeCell,
+        dimension,
+        isDragging,
+        resizerDimension,
+        headerBorderWidth,
+        frozenRows,
+        frozenColumns,
+        onAutoFit,
+        containerWidth,
+        containerHeight,
+        backgroundColor,
+        getCellOffsetFromCoords,
+        getScrollPosition,
+        handleMouseDown,
+        isRowHeader,
+        isColumnHeader,
+        enableResizerOverflow,
+    ]);
+    return {
+        headerMenuComponent: headerMenuComponent,
+        isHeaderMenuInFrozenColumn: isHeaderMenuInFrozenColumn,
+        headerResizer: headerResizer,
+        isDragging: isDragging,
+    };
+};
+exports.useHeaderActions = useHeaderActions;

package/dist/cjs/hooks/use-hidden-dimension-markers.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import type { CanvasGridProps } from "../components/canvas-grid/typings";
+import type { Sheet } from "../types";
+type InputProps = {
+    sheetId: number;
+    columnMetadata: Sheet["columnMetadata"];
+    rowMetadata: Sheet["rowMetadata"];
+    onShowColumn: CanvasGridProps["onShowColumn"];
+    onShowRow: CanvasGridProps["onShowRow"];
+    isFrozenColumn(columnIndex: number): boolean;
+    isFrozenRow(rowIndex: number): boolean;
+    focusSheet(): void;
+    rowCount: number;
+    columnCount: number;
+    HiddenRowMarkers?: CanvasGridProps["HiddenRowMarkers"];
+    HiddenColumnMarkers?: CanvasGridProps["HiddenColumnMarkers"];
+};
+export declare const useHiddenDimensionMarkers: ({ sheetId, columnMetadata, rowMetadata, onShowColumn, onShowRow, isFrozenColumn, isFrozenRow, focusSheet, rowCount, columnCount, HiddenRowMarkers, HiddenColumnMarkers, }: InputProps) => readonly [React.JSX.Element, React.JSX.Element, React.JSX.Element, React.JSX.Element];
+export {};
+//# sourceMappingURL=use-hidden-dimension-markers.d.ts.map

package/dist/cjs/hooks/use-hidden-dimension-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hidden-dimension-markers.d.ts","sourceRoot":"","sources":["../../../hooks/use-hidden-dimension-markers.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+B,MAAM,OAAO,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAKzE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IACxC,WAAW,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAClC,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;IAC9C,SAAS,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;IACxC,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7C,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,UAAU,IAAI,IAAI,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,eAAe,CAAC,kBAAkB,CAAC,CAAC;IACvD,mBAAmB,CAAC,EAAE,eAAe,CAAC,qBAAqB,CAAC,CAAC;CAC9D,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,2KAavC,UAAU,0FAsJZ,CAAC"}

package/dist/cjs/hooks/use-hidden-dimension-markers.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHiddenDimensionMarkers = void 0;
+var tslib_1 = require("tslib");
+var react_1 = tslib_1.__importStar(require("react"));
+var hidden_markers_1 = require("../components/hidden-markers");
+var useHiddenDimensionMarkers = function (_a) {
+    var sheetId = _a.sheetId, columnMetadata = _a.columnMetadata, rowMetadata = _a.rowMetadata, onShowColumn = _a.onShowColumn, onShowRow = _a.onShowRow, isFrozenColumn = _a.isFrozenColumn, isFrozenRow = _a.isFrozenRow, focusSheet = _a.focusSheet, rowCount = _a.rowCount, columnCount = _a.columnCount, _b = _a.HiddenRowMarkers, HiddenRowMarkers = _b === void 0 ? hidden_markers_1.HiddenRowMarkers : _b, _c = _a.HiddenColumnMarkers, HiddenColumnMarkers = _c === void 0 ? hidden_markers_1.HiddenColumnMarkers : _c;
+    var handleShowRow = (0, react_1.useCallback)(function (rowIndexes) {
+        focusSheet();
+        onShowRow === null || onShowRow === void 0 ? void 0 : onShowRow(sheetId, rowIndexes);
+    }, [sheetId, focusSheet, onShowRow]);
+    var handleShowColumn = (0, react_1.useCallback)(function (columnIndexes) {
+        focusSheet();
+        onShowColumn === null || onShowColumn === void 0 ? void 0 : onShowColumn(sheetId, columnIndexes);
+    }, [sheetId, focusSheet, onShowColumn]);
+    // Columns
+    var _d = tslib_1.__read((0, react_1.useMemo)(function () {
+        var _a;
+        var frozen = [];
+        var dims = [];
+        if (!columnMetadata) {
+            return [dims, [], frozen, []];
+        }
+        var seen = {};
+        for (var i = 0; i < columnMetadata.length; i++) {
+            if ((_a = columnMetadata === null || columnMetadata === void 0 ? void 0 : columnMetadata[i]) === null || _a === void 0 ? void 0 : _a.hiddenByUser) {
+                seen[i] = true;
+                if (isFrozenColumn(i)) {
+                    frozen.push(i);
+                }
+                else {
+                    if (seen[i - 1]) {
+                        continue;
+                    }
+                    dims.push(i);
+                }
+            }
+        }
+        return [
+            dims,
+            exandDimensions(dims, seen, columnCount),
+            frozen,
+            exandDimensions(frozen, seen, columnCount),
+        ];
+    }, [columnMetadata, isFrozenColumn, columnCount]), 4), hiddenColumns = _d[0], expandedHiddenColumns = _d[1], frozenHiddenColumns = _d[2], expandedFrozenHiddenColumns = _d[3];
+    // Rows
+    var _e = tslib_1.__read((0, react_1.useMemo)(function () {
+        var _a;
+        var frozen = [];
+        var dims = [];
+        if (!rowMetadata) {
+            return [dims, [], frozen, []];
+        }
+        var seen = {};
+        for (var i = 0; i < rowMetadata.length; i++) {
+            if ((_a = rowMetadata === null || rowMetadata === void 0 ? void 0 : rowMetadata[i]) === null || _a === void 0 ? void 0 : _a.hiddenByUser) {
+                seen[i] = true;
+                if (isFrozenRow(i)) {
+                    frozen.push(i);
+                }
+                else {
+                    if (seen[i - 1]) {
+                        continue;
+                    }
+                    dims.push(i);
+                }
+            }
+        }
+        return [
+            dims,
+            exandDimensions(dims, seen, rowCount),
+            frozen,
+            exandDimensions(frozen, seen, rowCount),
+        ];
+    }, [rowMetadata, isFrozenRow, rowCount]), 4), hiddenRows = _e[0], expandedHiddenRows = _e[1], frozenHiddenRows = _e[2], expandedFrozenHiddenRows = _e[3];
+    // Frozen column
+    var frozenColumnMarkers = (0, react_1.useMemo)(function () {
+        return (react_1.default.createElement(HiddenColumnMarkers, { hiddenDimensions: frozenHiddenColumns, expandedDimensions: expandedFrozenHiddenColumns, onShowColumn: handleShowColumn }));
+    }, [
+        frozenHiddenColumns,
+        expandedFrozenHiddenColumns,
+        handleShowColumn,
+        HiddenColumnMarkers,
+    ]);
+    // All other column
+    var columnMarkers = (0, react_1.useMemo)(function () {
+        return (react_1.default.createElement(HiddenColumnMarkers, { hiddenDimensions: hiddenColumns, expandedDimensions: expandedHiddenColumns, onShowColumn: handleShowColumn }));
+    }, [
+        hiddenColumns,
+        expandedHiddenColumns,
+        handleShowColumn,
+        HiddenColumnMarkers,
+    ]);
+    // Frozen column
+    var frozenRowMarkers = (0, react_1.useMemo)(function () {
+        return (react_1.default.createElement(HiddenRowMarkers, { hiddenDimensions: frozenHiddenRows, expandedDimensions: expandedFrozenHiddenRows, onShowRow: handleShowRow }));
+    }, [
+        frozenHiddenRows,
+        expandedFrozenHiddenRows,
+        handleShowRow,
+        HiddenRowMarkers,
+    ]);
+    // All other column
+    var rowMarkers = (0, react_1.useMemo)(function () {
+        return (react_1.default.createElement(HiddenRowMarkers, { hiddenDimensions: hiddenRows, expandedDimensions: expandedHiddenRows, onShowRow: handleShowRow }));
+    }, [hiddenRows, expandedHiddenRows, handleShowRow, HiddenRowMarkers]);
+    return [
+        columnMarkers,
+        frozenColumnMarkers,
+        rowMarkers,
+        frozenRowMarkers,
+    ];
+};
+exports.useHiddenDimensionMarkers = useHiddenDimensionMarkers;
+/**
+ * Expand hidden rows and columns
+ * @param dims
+ * @param seen
+ * @param maxCount
+ * @returns
+ */
+var exandDimensions = function (dims, seen, maxCount) {
+    return dims.map(function (dim) {
+        var start = dim;
+        var value = [];
+        while (start <= maxCount) {
+            if (start in seen) {
+                value.push(start);
+                start++;
+            }
+            else {
+                break;
+            }
+        }
+        return value;
+    });
+};

package/dist/cjs/hooks/use-hidden-dimensions.d.ts

@@ -0,0 +1,7 @@
+import type { OptionalCellInterface } from "@rowsncolumns/grid";
+import type { Sheet } from "../types";
+export declare const useHiddenDimensions: (columnMetadata: Sheet["columnMetadata"], rowMetadata: Sheet["rowMetadata"], sheetId: number, scale: number, resetLastMeasuredIndices: (cell: OptionalCellInterface) => void, hostHiddenRowRanges?: [number, number][], visibleRowRanges?: {
+    start: number;
+    end: number;
+}[]) => void;
+//# sourceMappingURL=use-hidden-dimensions.d.ts.map

package/dist/cjs/hooks/use-hidden-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hidden-dimensions.d.ts","sourceRoot":"","sources":["../../../hooks/use-hidden-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,eAAO,MAAM,mBAAmB,GAC9B,gBAAgB,KAAK,CAAC,gBAAgB,CAAC,EACvC,aAAa,KAAK,CAAC,aAAa,CAAC,EACjC,SAAS,MAAM,EACf,OAAO,MAAM,EACb,0BAA0B,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,EAM/D,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAWxC,mBAAmB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,SA+CpD,CAAC"}

package/dist/cjs/hooks/use-hidden-dimensions.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHiddenDimensions = void 0;
+var use_previous_1 = require("./use-previous");
+var useHiddenDimensions = function (columnMetadata, rowMetadata, sheetId, scale, resetLastMeasuredIndices, 
+// Host-driven filter visibility (basic OR table filter) rides this, NOT `rowMetadata`. Reset the
+// inner grid's measured-row cache from index 0 when the hidden set changes — done DURING render
+// (like the rowMetadata reset above), so the same render that flips `visibleRowRanges` also remaps
+// row offsets. A post-render effect is too late: the first paint uses the stale layout (blank
+// viewport / rows that don't hide until the next reflow).
+hostHiddenRowRanges, 
+// The visible row ranges CanvasGrid feeds BaseGrid (the complement of the hidden rows over the
+// published extent). BaseGrid's `getItemMetadata` caches ANY row it measures while the row sits
+// outside every range with `size: 0` (that is how hidden rows collapse) — including the row one
+// past the published edge, which the bottom-edge gridline pass measures via
+// `getRowOffset(rowStopIndex + 1)`. When the published extent then grows (scroll auto-grow,
+// data-extent growth, "add rows"), that row falls inside the new ranges but the stale zero-height
+// cache entry survives: the row renders invisible and the header numbers skip it. Watch the
+// ranges here and reset the measured-row cache from the first index whose visibility could have
+// changed — the smaller tail boundary — so growth re-measures the tail without re-walking the
+// body of a million-row sheet.
+visibleRowRanges) {
+    var previousColumnMetadata = (0, use_previous_1.usePrevious)(columnMetadata);
+    var previousRowMetadata = (0, use_previous_1.usePrevious)(rowMetadata);
+    var previousSheetId = (0, use_previous_1.usePrevious)(sheetId);
+    var previousScale = (0, use_previous_1.usePrevious)(scale);
+    var previousHiddenRowRanges = (0, use_previous_1.usePrevious)(hostHiddenRowRanges);
+    var previousVisibleRowRanges = (0, use_previous_1.usePrevious)(visibleRowRanges);
+    var scaleChanged = previousScale !== undefined && previousScale !== scale;
+    var columnMetaChanged = previousColumnMetadata !== undefined &&
+        previousColumnMetadata !== columnMetadata;
+    var rowMetaChanged = previousRowMetadata !== undefined && previousRowMetadata !== rowMetadata;
+    var hiddenRowsChanged = previousHiddenRowRanges !== undefined &&
+        previousHiddenRowRanges !== hostHiddenRowRanges;
+    var visibleRowRangesChanged = previousVisibleRowRanges !== undefined &&
+        previousVisibleRowRanges !== visibleRowRanges;
+    var rowResetIndex = rowMetaChanged || scaleChanged || hiddenRowsChanged ? 0 : undefined;
+    if (rowResetIndex === undefined && visibleRowRangesChanged) {
+        var previousTailEnd = previousVisibleRowRanges && previousVisibleRowRanges.length > 0
+            ? previousVisibleRowRanges[previousVisibleRowRanges.length - 1].end
+            : -1;
+        var nextTailEnd = visibleRowRanges && visibleRowRanges.length > 0
+            ? visibleRowRanges[visibleRowRanges.length - 1].end
+            : -1;
+        rowResetIndex = Math.max(0, Math.min(previousTailEnd, nextTailEnd) + 1);
+    }
+    if ((previousSheetId !== undefined && sheetId !== previousSheetId) ||
+        columnMetaChanged ||
+        rowMetaChanged ||
+        scaleChanged ||
+        hiddenRowsChanged ||
+        rowResetIndex !== undefined) {
+        // Compute the min column and row from which the grid has to recalc
+        resetLastMeasuredIndices({
+            rowIndex: rowResetIndex,
+            columnIndex: columnMetaChanged || scaleChanged ? 0 : undefined,
+        });
+    }
+};
+exports.useHiddenDimensions = useHiddenDimensions;

package/dist/cjs/hooks/use-hovered-selection-ids.d.ts

@@ -0,0 +1,9 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes } from "../components/canvas-grid/typings";
+export type UseHoveredSelectionIdsProps = {
+    selections: SelectionArea<SelectionAttributes>[];
+    activeCell: CellInterface;
+    hoveredCell?: CellInterface | null;
+};
+export declare const useHoveredSelectionIds: ({ hoveredCell, selections, activeCell, }: UseHoveredSelectionIdsProps) => Set<string | number>;
+//# sourceMappingURL=use-hovered-selection-ids.d.ts.map

package/dist/cjs/hooks/use-hovered-selection-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hovered-selection-ids.d.ts","sourceRoot":"","sources":["../../../hooks/use-hovered-selection-ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAQ/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAG7E,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,CAAC;IACjD,UAAU,EAAE,aAAa,CAAC;IAC1B,WAAW,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CACpC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,0CAIpC,2BAA2B,yBAuB7B,CAAC"}

package/dist/cjs/hooks/use-hovered-selection-ids.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHoveredSelectionIds = void 0;
+var grid_1 = require("@rowsncolumns/grid");
+var react_1 = require("react");
+var use_memo_compare_1 = require("./use-memo-compare");
+var useHoveredSelectionIds = function (_a) {
+    var hoveredCell = _a.hoveredCell, selections = _a.selections, activeCell = _a.activeCell;
+    /**
+     * Calculate all area ids that is active
+     * This is used so that we dont re-calc
+     * borderStyles
+     */
+    var visibleIds = (0, react_1.useMemo)(function () {
+        var ids = new Set();
+        for (var i = 0; i < selections.length; i++) {
+            var sel = selections[i];
+            if (hoveredCell && (0, grid_1.isCellWithinBounds)(hoveredCell, sel.range)) {
+                ids.add(i);
+            }
+        }
+        if ((0, grid_1.isEqualCells)(hoveredCell, activeCell)) {
+            ids.add((0, grid_1.cellIdentifier)(activeCell.rowIndex, activeCell.columnIndex));
+        }
+        return ids;
+    }, [selections, activeCell, hoveredCell]);
+    // Cache visible ranges ids
+    return (0, use_memo_compare_1.useMemoCompare)(visibleIds);
+};
+exports.useHoveredSelectionIds = useHoveredSelectionIds;

package/dist/cjs/hooks/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,6 @@
+import { useEffect } from "react";
+/**
+ * Prevent warning on SSR by falling back to useEffect when DOM isn't available
+ */
+export declare const useIsomorphicLayoutEffect: typeof useEffect;
+//# sourceMappingURL=use-isomorphic-layout-effect.d.ts.map

package/dist/cjs/hooks/use-isomorphic-layout-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-isomorphic-layout-effect.d.ts","sourceRoot":"","sources":["../../../hooks/use-isomorphic-layout-effect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAmB,MAAM,OAAO,CAAC;AAEnD;;GAEG;AAEH,eAAO,MAAM,yBAAyB,kBAEzB,CAAC"}

package/dist/cjs/hooks/use-isomorphic-layout-effect.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsomorphicLayoutEffect = void 0;
+var utils_1 = require("@rowsncolumns/utils");
+var react_1 = require("react");
+/**
+ * Prevent warning on SSR by falling back to useEffect when DOM isn't available
+ */
+exports.useIsomorphicLayoutEffect = utils_1.canUseDOM
+    ? react_1.useLayoutEffect
+    : react_1.useEffect;