@rowsncolumns/grid 9.0.3 → 13.2.32

package/dist/cjs/helpers.js

@@ -0,0 +1,1409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDevicePixelRatio = exports.useCallbackRef = exports.useIsomorphicLayoutEffect = exports.getScrollIncrement = exports.isArrowKey = exports.castToString = exports.findNextCellInDataRegion = exports.findLastContentfulCell = exports.findNextContentfulCell = exports.clampIndex = exports.isCellWithinBounds = exports.isEqualCells = exports.isNull = exports.autoSizerCanvas = exports.AutoSizerCanvas = exports.toCssFontFamily = exports.canUseDOM = exports.cellToArea = exports.cellRangeToBounds = exports.extendAreaToMergedCells = exports.isAreasEqual = exports.areaInsideArea = exports.areaIntersects = exports.findNextCellWithinBounds = exports.prepareClipboardData = exports.numberToAlphabet = exports.clampCellCoords = exports.newSelectionFromDrag = exports.selectionSpansCells = exports.selectionFromActiveCell = exports.getOffsetForRowAndAlignment = exports.getOffsetForColumnAndAlignment = exports.getOffsetForIndexAndAlignment = exports.scheduleIdlePriorityCallback = exports.cellIdentifier = exports.getEstimatedTotalWidth = exports.getEstimatedTotalHeight = exports.getItemMetadata = exports.getColumnWidth = exports.getRowHeight = exports.getColumnOffset = exports.getRowOffset = exports.itemKey = exports.getBoundedCells = exports.getColumnStopIndexForStartIndex = exports.getColumnStartIndexForOffset = exports.getRowStopIndexForStartIndex = exports.getRowStartIndexForOffset = exports.ItemType = exports.Align = void 0;
+exports.getPreviousCellInDirection = void 0;
+exports.throttle = throttle;
+exports.debounce = debounce;
+exports.rafThrottle = rafThrottle;
+exports.ricThrottle = ricThrottle;
+exports.cancelTimeout = cancelTimeout;
+exports.requestTimeout = requestTimeout;
+var tslib_1 = require("tslib");
+// Utilities extracted from https://github.com/bvaughn/react-window
+var react_1 = require("react");
+var scheduler_1 = require("scheduler");
+var types_1 = require("./types");
+var Align;
+(function (Align) {
+    Align["start"] = "start";
+    Align["end"] = "end";
+    Align["center"] = "center";
+    Align["auto"] = "auto";
+    Align["smart"] = "smart";
+})(Align || (exports.Align = Align = {}));
+var ItemType;
+(function (ItemType) {
+    ItemType["row"] = "row";
+    ItemType["column"] = "column";
+})(ItemType || (exports.ItemType = ItemType = {}));
+var getRowStartIndexForOffset = function (_a) {
+    var rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, rowCount = _a.rowCount, columnCount = _a.columnCount, instanceProps = _a.instanceProps, offset = _a.offset, scale = _a.scale;
+    return findNearestItem({
+        itemType: ItemType.row,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        rowCount: rowCount,
+        columnCount: columnCount,
+        instanceProps: instanceProps,
+        offset: offset,
+        scale: scale,
+    });
+};
+exports.getRowStartIndexForOffset = getRowStartIndexForOffset;
+var getRowStopIndexForStartIndex = function (_a) {
+    var startIndex = _a.startIndex, rowCount = _a.rowCount, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, scrollTop = _a.scrollTop, containerHeight = _a.containerHeight, instanceProps = _a.instanceProps, scale = _a.scale, visibleRowRanges = _a.visibleRowRanges;
+    var itemMetadata = (0, exports.getItemMetadata)({
+        itemType: ItemType.row,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        index: startIndex,
+        instanceProps: instanceProps,
+        scale: scale,
+    });
+    var maxOffset = scrollTop + containerHeight;
+    var offset = itemMetadata.offset + itemMetadata.size;
+    var stopIndex = startIndex;
+    // If visibleRowRanges provided, use it to skip hidden rows efficiently
+    if (visibleRowRanges && visibleRowRanges.length > 0) {
+        // Find which range we're currently in
+        var currentRangeIdx = 0;
+        for (var i = 0; i < visibleRowRanges.length; i++) {
+            if (visibleRowRanges[i].end >= stopIndex) {
+                currentRangeIdx = i;
+                break;
+            }
+        }
+        while (stopIndex < rowCount - 1 && offset < maxOffset) {
+            var currentRange = visibleRowRanges[currentRangeIdx];
+            if (currentRange && stopIndex < currentRange.end) {
+                // Still within current visible range, move to next row
+                stopIndex++;
+                offset += (0, exports.getItemMetadata)({
+                    itemType: ItemType.row,
+                    rowHeight: rowHeight,
+                    columnWidth: columnWidth,
+                    index: stopIndex,
+                    instanceProps: instanceProps,
+                    scale: scale,
+                    visibleRowRanges: visibleRowRanges,
+                }).size;
+            }
+            else {
+                // At end of current range, jump to next visible range
+                currentRangeIdx++;
+                if (currentRangeIdx >= visibleRowRanges.length) {
+                    // No more visible ranges
+                    break;
+                }
+                var nextRange = visibleRowRanges[currentRangeIdx];
+                stopIndex = nextRange.start;
+                offset = (0, exports.getItemMetadata)({
+                    itemType: ItemType.row,
+                    rowHeight: rowHeight,
+                    columnWidth: columnWidth,
+                    index: stopIndex,
+                    instanceProps: instanceProps,
+                    scale: scale,
+                    visibleRowRanges: visibleRowRanges,
+                }).offset;
+            }
+        }
+    }
+    else {
+        // Fallback to original behavior
+        while (stopIndex < rowCount - 1 && offset < maxOffset) {
+            stopIndex++;
+            offset += (0, exports.getItemMetadata)({
+                itemType: ItemType.row,
+                rowHeight: rowHeight,
+                columnWidth: columnWidth,
+                index: stopIndex,
+                instanceProps: instanceProps,
+                scale: scale,
+            }).size;
+        }
+    }
+    return stopIndex;
+};
+exports.getRowStopIndexForStartIndex = getRowStopIndexForStartIndex;
+var getColumnStartIndexForOffset = function (_a) {
+    var rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, rowCount = _a.rowCount, columnCount = _a.columnCount, instanceProps = _a.instanceProps, offset = _a.offset, scale = _a.scale;
+    return findNearestItem({
+        itemType: ItemType.column,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        rowCount: rowCount,
+        columnCount: columnCount,
+        instanceProps: instanceProps,
+        offset: offset,
+        scale: scale,
+    });
+};
+exports.getColumnStartIndexForOffset = getColumnStartIndexForOffset;
+var getColumnStopIndexForStartIndex = function (_a) {
+    var startIndex = _a.startIndex, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, instanceProps = _a.instanceProps, containerWidth = _a.containerWidth, scrollLeft = _a.scrollLeft, columnCount = _a.columnCount, scale = _a.scale;
+    var itemMetadata = (0, exports.getItemMetadata)({
+        itemType: ItemType.column,
+        index: startIndex,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        instanceProps: instanceProps,
+        scale: scale,
+    });
+    var maxOffset = scrollLeft + containerWidth;
+    var offset = itemMetadata.offset + itemMetadata.size;
+    var stopIndex = startIndex;
+    while (stopIndex < columnCount - 1 && offset < maxOffset) {
+        stopIndex++;
+        offset += (0, exports.getItemMetadata)({
+            itemType: ItemType.column,
+            rowHeight: rowHeight,
+            columnWidth: columnWidth,
+            index: stopIndex,
+            instanceProps: instanceProps,
+            scale: scale,
+        }).size;
+    }
+    return stopIndex;
+};
+exports.getColumnStopIndexForStartIndex = getColumnStopIndexForStartIndex;
+var getBoundedCells = function (area) {
+    var cells = new Set();
+    if (!area)
+        return cells;
+    var top = area.startRowIndex, left = area.startColumnIndex, right = area.endColumnIndex, bottom = area.endRowIndex;
+    for (var i = top; i <= bottom; i++) {
+        for (var j = left; j <= right; j++) {
+            cells.add((0, exports.cellIdentifier)(i, j));
+        }
+    }
+    return cells;
+};
+exports.getBoundedCells = getBoundedCells;
+var itemKey = function (_a) {
+    var rowIndex = _a.rowIndex, columnIndex = _a.columnIndex;
+    return "".concat(rowIndex, ":").concat(columnIndex);
+};
+exports.itemKey = itemKey;
+var getRowOffset = function (_a) {
+    var index = _a.index, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, instanceProps = _a.instanceProps, scale = _a.scale, readonly = _a.readonly, visibleRowRanges = _a.visibleRowRanges;
+    return (0, exports.getItemMetadata)({
+        itemType: ItemType.row,
+        index: index,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        instanceProps: instanceProps,
+        scale: scale,
+        readonly: readonly,
+        visibleRowRanges: visibleRowRanges,
+    }).offset;
+};
+exports.getRowOffset = getRowOffset;
+var getColumnOffset = function (_a) {
+    var index = _a.index, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, instanceProps = _a.instanceProps, scale = _a.scale, readonly = _a.readonly;
+    return (0, exports.getItemMetadata)({
+        itemType: ItemType.column,
+        index: index,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        instanceProps: instanceProps,
+        scale: scale,
+        readonly: readonly,
+    }).offset;
+};
+exports.getColumnOffset = getColumnOffset;
+var getRowHeight = function (index, instanceProps) {
+    var _a, _b;
+    return (_b = (_a = instanceProps.rowMetadataMap.get(index)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
+};
+exports.getRowHeight = getRowHeight;
+var getColumnWidth = function (index, instanceProps) {
+    var _a, _b;
+    return (_b = (_a = instanceProps.columnMetadataMap.get(index)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
+};
+exports.getColumnWidth = getColumnWidth;
+var getItemMetadata = function (_a) {
+    var itemType = _a.itemType, index = _a.index, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, instanceProps = _a.instanceProps, _b = _a.scale, scale = _b === void 0 ? 1 : _b, readonly = _a.readonly, visibleRowRanges = _a.visibleRowRanges;
+    var itemMetadataMap, itemSize, lastMeasuredIndex, recalcIndices;
+    if (itemType === "column") {
+        itemMetadataMap = instanceProps.columnMetadataMap;
+        itemSize = columnWidth;
+        lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;
+    }
+    else {
+        itemMetadataMap = instanceProps.rowMetadataMap;
+        itemSize = rowHeight;
+        lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;
+    }
+    if (index > lastMeasuredIndex) {
+        var offset = 0;
+        if (lastMeasuredIndex >= 0) {
+            var itemMetadata = itemMetadataMap.get(lastMeasuredIndex);
+            if (itemMetadata) {
+                offset = itemMetadata.offset + itemMetadata.size;
+            }
+        }
+        // If visibleRowRanges provided for rows, skip expensive itemSize() calls for hidden rows
+        // We still store metadata for all rows (required by binary search), but hidden rows get size=0
+        if (itemType === "row" && visibleRowRanges && visibleRowRanges.length > 0) {
+            // Build a quick lookup for which ranges we're in
+            var rangeIdx = 0;
+            for (var i = lastMeasuredIndex + 1; i <= index; i++) {
+                // Advance to the appropriate range
+                while (rangeIdx < visibleRowRanges.length && visibleRowRanges[rangeIdx].end < i) {
+                    rangeIdx++;
+                }
+                // Check if i is in the current range (visible) or in a gap (hidden)
+                var currentRange = visibleRowRanges[rangeIdx];
+                var isVisible = currentRange && i >= currentRange.start && i <= currentRange.end;
+                // Only call itemSize for visible rows - hidden rows have size 0
+                var size = isVisible ? itemSize(i) * scale : 0;
+                itemMetadataMap.set(i, { offset: offset, size: size });
+                offset += size;
+            }
+        }
+        else {
+            // Original behavior for columns or when no visibleRowRanges
+            for (var i = lastMeasuredIndex + 1; i <= index; i++) {
+                var size = itemSize(i) * scale;
+                itemMetadataMap.set(i, {
+                    offset: offset,
+                    size: size,
+                });
+                offset += size;
+            }
+        }
+        if (!readonly) {
+            if (itemType === "column") {
+                instanceProps.lastMeasuredColumnIndex = index;
+            }
+            else {
+                instanceProps.lastMeasuredRowIndex = index;
+            }
+        }
+    }
+    return itemMetadataMap.get(index);
+};
+exports.getItemMetadata = getItemMetadata;
+var findNearestItem = function (_a) {
+    var _b, _c;
+    var itemType = _a.itemType, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, rowCount = _a.rowCount, columnCount = _a.columnCount, instanceProps = _a.instanceProps, offset = _a.offset, scale = _a.scale;
+    var itemMetadataMap, lastMeasuredIndex;
+    if (itemType === "column") {
+        itemMetadataMap = instanceProps.columnMetadataMap;
+        lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;
+    }
+    else {
+        itemMetadataMap = instanceProps.rowMetadataMap;
+        lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;
+    }
+    var lastMeasuredItemOffset = lastMeasuredIndex > 0
+        ? (_c = (_b = itemMetadataMap.get(lastMeasuredIndex)) === null || _b === void 0 ? void 0 : _b.offset) !== null && _c !== void 0 ? _c : 0
+        : 0;
+    if (lastMeasuredItemOffset >= offset) {
+        // If we've already measured items within this range just use a binary search as it's faster.
+        return findNearestItemBinarySearch({
+            itemType: itemType,
+            rowHeight: rowHeight,
+            columnWidth: columnWidth,
+            instanceProps: instanceProps,
+            high: lastMeasuredIndex,
+            low: 0,
+            offset: offset,
+            scale: scale,
+        });
+    }
+    else {
+        // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.
+        // The exponential search avoids pre-computing sizes for the full set of items as a binary search would.
+        // The overall complexity for this approach is O(log n).
+        return findNearestItemExponentialSearch({
+            itemType: itemType,
+            rowHeight: rowHeight,
+            rowCount: rowCount,
+            columnCount: columnCount,
+            columnWidth: columnWidth,
+            instanceProps: instanceProps,
+            index: Math.max(0, lastMeasuredIndex),
+            offset: offset,
+            scale: scale,
+        });
+    }
+};
+var findNearestItemBinarySearch = function (_a) {
+    var itemType = _a.itemType, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, instanceProps = _a.instanceProps, high = _a.high, low = _a.low, offset = _a.offset, scale = _a.scale;
+    while (low <= high) {
+        var middle = low + Math.floor((high - low) / 2);
+        var currentOffset = (0, exports.getItemMetadata)({
+            itemType: itemType,
+            rowHeight: rowHeight,
+            columnWidth: columnWidth,
+            index: middle,
+            instanceProps: instanceProps,
+            scale: scale,
+        }).offset;
+        if (currentOffset === offset) {
+            return middle;
+        }
+        else if (currentOffset < offset) {
+            low = middle + 1;
+        }
+        else if (currentOffset > offset) {
+            high = middle - 1;
+        }
+    }
+    if (low > 0) {
+        return low - 1;
+    }
+    else {
+        return 0;
+    }
+};
+var findNearestItemExponentialSearch = function (_a) {
+    var itemType = _a.itemType, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, rowCount = _a.rowCount, columnCount = _a.columnCount, instanceProps = _a.instanceProps, index = _a.index, offset = _a.offset, scale = _a.scale;
+    var itemCount = itemType === "column" ? columnCount : rowCount;
+    var interval = 1;
+    while (index < itemCount &&
+        (0, exports.getItemMetadata)({
+            itemType: itemType,
+            rowHeight: rowHeight,
+            columnWidth: columnWidth,
+            index: index,
+            instanceProps: instanceProps,
+            scale: scale,
+        }).offset < offset) {
+        index += interval;
+        interval *= 2;
+    }
+    return findNearestItemBinarySearch({
+        itemType: itemType,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        instanceProps: instanceProps,
+        high: Math.min(index, itemCount - 1),
+        low: Math.floor(index / 2),
+        offset: offset,
+        scale: scale,
+    });
+};
+var getEstimatedTotalHeight = function (rowCount, instanceProps) {
+    var estimatedRowHeight = instanceProps.estimatedRowHeight;
+    var totalSizeOfMeasuredRows = 0;
+    var lastMeasuredRowIndex = instanceProps.lastMeasuredRowIndex;
+    var rowMetadataMap = instanceProps.rowMetadataMap;
+    // Edge case check for when the number of items decreases while a scroll is in progress.
+    // https://github.com/bvaughn/react-window/pull/138
+    if (lastMeasuredRowIndex >= rowCount) {
+        lastMeasuredRowIndex = rowCount - 1;
+    }
+    if (lastMeasuredRowIndex >= 0) {
+        var itemMetadata = rowMetadataMap.get(lastMeasuredRowIndex);
+        if (itemMetadata) {
+            totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;
+        }
+    }
+    var numUnmeasuredItems = rowCount - lastMeasuredRowIndex - 1;
+    var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedRowHeight;
+    return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;
+};
+exports.getEstimatedTotalHeight = getEstimatedTotalHeight;
+var getEstimatedTotalWidth = function (columnCount, instanceProps) {
+    var estimatedColumnWidth = instanceProps.estimatedColumnWidth;
+    var totalSizeOfMeasuredRows = 0;
+    var lastMeasuredColumnIndex = instanceProps.lastMeasuredColumnIndex;
+    var columnMetadataMap = instanceProps.columnMetadataMap;
+    // Edge case check for when the number of items decreases while a scroll is in progress.
+    // https://github.com/bvaughn/react-window/pull/138
+    if (lastMeasuredColumnIndex >= columnCount) {
+        lastMeasuredColumnIndex = columnCount - 1;
+    }
+    if (lastMeasuredColumnIndex >= 0) {
+        var itemMetadata = columnMetadataMap.get(lastMeasuredColumnIndex);
+        if (itemMetadata) {
+            totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;
+        }
+    }
+    var numUnmeasuredItems = columnCount - lastMeasuredColumnIndex - 1;
+    var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedColumnWidth;
+    return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;
+};
+exports.getEstimatedTotalWidth = getEstimatedTotalWidth;
+/* Create a stringified cell identifier */
+var cellIdentifier = function (rowIndex, columnIndex) {
+    return "".concat(rowIndex, ",").concat(columnIndex);
+};
+exports.cellIdentifier = cellIdentifier;
+/**
+ * @desc Throttle fn
+ * @param func function
+ * @param limit Delay in milliseconds
+ */
+function throttle(func, limit) {
+    var lastEventTimestamp = null;
+    var callable = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var now = Date.now();
+        if (!lastEventTimestamp || now - lastEventTimestamp >= limit) {
+            lastEventTimestamp = now;
+            func.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(args), false));
+        }
+    };
+    return callable;
+}
+function debounce(cb, wait) {
+    if (wait === void 0) { wait = 300; }
+    var h = 0;
+    var callable = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        clearTimeout(h);
+        h = window.setTimeout(function () { return cb.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(args), false)); }, wait);
+    };
+    return callable;
+}
+function rafThrottle(callback) {
+    var active = false; // a simple flag
+    var evt; // to keep track of the last event
+    var handler = function () {
+        // fired only when screen has refreshed
+        active = false; // release our flag
+        callback(evt);
+    };
+    return function handleEvent(e) {
+        // the actual event handler
+        evt = e; // save our event at each call
+        evt && evt.persist && evt.persist();
+        if (!active) {
+            // only if we weren't already doing it
+            active = true; // raise the flag
+            requestAnimationFrame(handler); // wait for next screen refresh
+        }
+    };
+}
+var scheduleIdlePriorityCallback = function (callback) {
+    return (0, scheduler_1.unstable_scheduleCallback)(scheduler_1.unstable_IdlePriority, callback);
+};
+exports.scheduleIdlePriorityCallback = scheduleIdlePriorityCallback;
+function ricThrottle(callback) {
+    var active = false; // a simple flag
+    var evt; // to keep track of the last event
+    var handler = function () {
+        // fired only when screen has refreshed
+        active = false; // release our flag
+        callback(evt);
+    };
+    return function handleEvent(e) {
+        // the actual event handler
+        evt = e; // save our event at each call
+        evt && evt.persist && evt.persist();
+        if (!active) {
+            // only if we weren't already doing it
+            active = true; // raise the flag
+            (0, exports.scheduleIdlePriorityCallback)(handler); // wait for next screen refresh
+        }
+    };
+}
+var getOffsetForIndexAndAlignment = function (_a) {
+    var itemType = _a.itemType, containerHeight = _a.containerHeight, containerWidth = _a.containerWidth, rowHeight = _a.rowHeight, columnWidth = _a.columnWidth, columnCount = _a.columnCount, rowCount = _a.rowCount, index = _a.index, _b = _a.align, align = _b === void 0 ? Align.smart : _b, scrollOffset = _a.scrollOffset, instanceProps = _a.instanceProps, scrollbarSize = _a.scrollbarSize, _c = _a.frozenOffset, frozenOffset = _c === void 0 ? 0 : _c, scale = _a.scale, estimatedTotalHeight = _a.estimatedTotalHeight, estimatedTotalWidth = _a.estimatedTotalWidth;
+    var size = itemType === "column" ? containerWidth : containerHeight;
+    var itemMetadata = (0, exports.getItemMetadata)({
+        itemType: itemType,
+        rowHeight: rowHeight,
+        columnWidth: columnWidth,
+        index: index,
+        instanceProps: instanceProps,
+        scale: scale,
+    });
+    // Get estimated total size after ItemMetadata is computed,
+    // To ensure it reflects actual measurements instead of just estimates.
+    var estimatedTotalSize = itemType === "column" ? estimatedTotalWidth : estimatedTotalHeight;
+    var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size + scrollbarSize, itemMetadata.offset - frozenOffset));
+    var minOffset = Math.max(0, itemMetadata.offset - size + scrollbarSize + itemMetadata.size);
+    if (align === Align.smart) {
+        if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
+            align = Align.auto;
+        }
+        else {
+            align = Align.center;
+        }
+    }
+    switch (align) {
+        case Align.start:
+            return maxOffset;
+        case Align.end:
+            return minOffset;
+        case Align.center:
+            return Math.round(minOffset + (maxOffset - minOffset) / 2);
+        case Align.auto:
+        default:
+            if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
+                return scrollOffset;
+            }
+            else if (minOffset > maxOffset) {
+                // Because we only take into account the scrollbar size when calculating minOffset
+                // this value can be larger than maxOffset when at the end of the list
+                return minOffset;
+            }
+            else if (scrollOffset < minOffset) {
+                return minOffset;
+            }
+            else {
+                return maxOffset;
+            }
+    }
+};
+exports.getOffsetForIndexAndAlignment = getOffsetForIndexAndAlignment;
+var getOffsetForColumnAndAlignment = function (props) {
+    return (0, exports.getOffsetForIndexAndAlignment)(tslib_1.__assign({ itemType: ItemType.column }, props));
+};
+exports.getOffsetForColumnAndAlignment = getOffsetForColumnAndAlignment;
+var getOffsetForRowAndAlignment = function (props) {
+    return (0, exports.getOffsetForIndexAndAlignment)(tslib_1.__assign({ itemType: ItemType.row }, props));
+};
+exports.getOffsetForRowAndAlignment = getOffsetForRowAndAlignment;
+// Animation frame based implementation of setTimeout.
+// Inspired by Joe Lambert, https://gist.github.com/joelambert/1002116#file-requesttimeout-js
+var hasNativePerformanceNow = typeof performance === "object" && typeof performance.now === "function";
+var now = hasNativePerformanceNow
+    ? function () { return performance.now(); }
+    : function () { return Date.now(); };
+function cancelTimeout(timeoutID) {
+    cancelAnimationFrame(timeoutID.id);
+}
+/**
+ * Create a throttler based on RAF
+ * @param callback
+ * @param delay
+ */
+function requestTimeout(callback, delay) {
+    var start = now();
+    function tick() {
+        if (now() - start >= delay) {
+            callback.call(null);
+        }
+        else {
+            timeoutID.id = requestAnimationFrame(tick);
+        }
+    }
+    var timeoutID = {
+        id: requestAnimationFrame(tick),
+    };
+    return timeoutID;
+}
+var selectionFromActiveCell = function (activeCell) {
+    if (!activeCell)
+        return [];
+    return [
+        {
+            range: {
+                startRowIndex: activeCell.rowIndex,
+                startColumnIndex: activeCell.columnIndex,
+                endRowIndex: activeCell.rowIndex,
+                endColumnIndex: activeCell.columnIndex,
+            },
+        },
+    ];
+};
+exports.selectionFromActiveCell = selectionFromActiveCell;
+/**
+ * Check if a selection are spans multiple cells
+ * @param sel
+ */
+var selectionSpansCells = function (sel) {
+    if (!sel)
+        return false;
+    return (sel.endRowIndex !== sel.startRowIndex ||
+        sel.startColumnIndex !== sel.endColumnIndex);
+};
+exports.selectionSpansCells = selectionSpansCells;
+/**
+ * When user tries to drag a selection
+ * @param initialSelection
+ * @param from
+ * @param to
+ */
+var newSelectionFromDrag = function (initialSelection, from, to, topBound, leftBound, rowCount, columnCount) {
+    if (topBound === void 0) { topBound = 0; }
+    if (leftBound === void 0) { leftBound = 0; }
+    var currentBounds = initialSelection.range;
+    var startRowIndex = Math.max(topBound, Math.min(rowCount, to.rowIndex + currentBounds.startRowIndex - from.rowIndex));
+    var startColumnIndex = Math.max(leftBound, Math.min(columnCount, to.columnIndex + currentBounds.startColumnIndex - from.columnIndex));
+    return {
+        range: {
+            startRowIndex: startRowIndex,
+            startColumnIndex: startColumnIndex,
+            endRowIndex: startRowIndex +
+                (currentBounds.endRowIndex - currentBounds.startRowIndex),
+            endColumnIndex: startColumnIndex +
+                (currentBounds.endColumnIndex - currentBounds.startColumnIndex),
+        },
+    };
+};
+exports.newSelectionFromDrag = newSelectionFromDrag;
+/**
+ * Clamp cell coordinates to be inside activeCell and selection
+ * @param coords
+ * @param activeCell
+ * @param selection
+ */
+var clampCellCoords = function (coords, activeCell, selection) {
+    if (activeCell) {
+        coords.rowIndex = Math.max(activeCell.rowIndex, coords.rowIndex);
+        coords.columnIndex = Math.min(activeCell.columnIndex, coords.columnIndex);
+    }
+    if (selection) {
+        coords.rowIndex = Math.min(selection.range.endRowIndex, Math.max(selection.range.startRowIndex, coords.rowIndex));
+        coords.columnIndex = Math.min(selection.range.endColumnIndex, Math.max(selection.range.startColumnIndex, coords.columnIndex));
+    }
+    return coords;
+};
+exports.clampCellCoords = clampCellCoords;
+/**
+ * Converts a number to alphabet
+ * @param i
+ */
+var numberToAlphabet = function (i) {
+    return ((i >= 26 ? (0, exports.numberToAlphabet)(((i / 26) >> 0) - 1) : "") +
+        "abcdefghijklmnopqrstuvwxyz"[i % 26 >> 0]).toUpperCase();
+};
+exports.numberToAlphabet = numberToAlphabet;
+/**
+ * Convert selections to html and csv data
+ * @param rows
+ */
+var prepareClipboardData = function (rows) {
+    var html = ["<table>"];
+    var csv = [];
+    var sanitizeCell = function (value) {
+        if ((0, exports.isNull)(value))
+            return "";
+        return value;
+    };
+    rows.forEach(function (row) {
+        html.push("<tr>");
+        var csvRow = [];
+        row.forEach(function (cell) {
+            var _a;
+            html.push("<td>".concat(sanitizeCell(cell), "</td>"));
+            csvRow.push("".concat((_a = (0, exports.castToString)(cell)) === null || _a === void 0 ? void 0 : _a.replace(/"/g, '""')));
+        });
+        csv.push(csvRow.join(","));
+        html.push("</tr>");
+    });
+    html.push("</table>");
+    return [html.join(""), csv.join("\n")];
+};
+exports.prepareClipboardData = prepareClipboardData;
+/**
+ * Cycles active cell within selecton bounds
+ * @param activeCellBounds
+ * @param selectionBounds
+ * @param direction
+ */
+var findNextCellWithinBounds = function (activeCellBounds, selectionBounds, direction) {
+    if (direction === void 0) { direction = types_1.Direction.Right; }
+    var intersects = (0, exports.areaIntersects)(activeCellBounds, selectionBounds);
+    if (!intersects)
+        return null;
+    var rowIndex, columnIndex;
+    var nextActiveCell = null;
+    if (direction === types_1.Direction.Right) {
+        rowIndex = activeCellBounds.startRowIndex;
+        columnIndex = activeCellBounds.startColumnIndex + 1;
+        if (columnIndex > selectionBounds.endColumnIndex) {
+            rowIndex = rowIndex + 1;
+            columnIndex = selectionBounds.startColumnIndex;
+            if (rowIndex > selectionBounds.endRowIndex) {
+                rowIndex = selectionBounds.startRowIndex;
+            }
+        }
+        nextActiveCell = { rowIndex: rowIndex, columnIndex: columnIndex };
+    }
+    if (direction === types_1.Direction.Left) {
+        rowIndex = activeCellBounds.endRowIndex;
+        columnIndex = activeCellBounds.startColumnIndex - 1;
+        if (columnIndex < selectionBounds.startColumnIndex) {
+            rowIndex = rowIndex - 1;
+            columnIndex = selectionBounds.endColumnIndex;
+            if (rowIndex < selectionBounds.startRowIndex) {
+                rowIndex = selectionBounds.endRowIndex;
+            }
+        }
+        nextActiveCell = { rowIndex: rowIndex, columnIndex: columnIndex };
+    }
+    if (direction === types_1.Direction.Down) {
+        rowIndex = activeCellBounds.endRowIndex + 1;
+        columnIndex = activeCellBounds.startColumnIndex;
+        if (rowIndex > selectionBounds.endRowIndex) {
+            columnIndex = activeCellBounds.startColumnIndex + 1;
+            rowIndex = selectionBounds.startRowIndex;
+            if (columnIndex > selectionBounds.endColumnIndex) {
+                columnIndex = selectionBounds.startColumnIndex;
+            }
+        }
+        nextActiveCell = { rowIndex: rowIndex, columnIndex: columnIndex };
+    }
+    if (direction === types_1.Direction.Up) {
+        rowIndex = activeCellBounds.startRowIndex - 1;
+        columnIndex = activeCellBounds.startColumnIndex;
+        if (rowIndex < selectionBounds.startRowIndex) {
+            columnIndex = activeCellBounds.startColumnIndex - 1;
+            rowIndex = selectionBounds.endRowIndex;
+            if (columnIndex < selectionBounds.startColumnIndex) {
+                columnIndex = selectionBounds.endColumnIndex;
+            }
+        }
+        nextActiveCell = { rowIndex: rowIndex, columnIndex: columnIndex };
+    }
+    return nextActiveCell;
+};
+exports.findNextCellWithinBounds = findNextCellWithinBounds;
+/**
+ * Check if 2 areas overlap
+ * @param area1
+ * @param area2
+ */
+var areaIntersects = function (area1, area2) {
+    if (!area2) {
+        return false;
+    }
+    if (area1.startColumnIndex > area2.endColumnIndex ||
+        area2.startColumnIndex > area1.endColumnIndex) {
+        return false;
+    }
+    if (area1.startRowIndex > area2.endRowIndex ||
+        area2.startRowIndex > area1.endRowIndex) {
+        return false;
+    }
+    return true;
+};
+exports.areaIntersects = areaIntersects;
+/**
+ * Check if area is inside another area
+ * @param needle
+ * @param haystack
+ */
+var areaInsideArea = function (needle, haystack) {
+    return (needle.startRowIndex >= haystack.startRowIndex &&
+        needle.endRowIndex <= haystack.endRowIndex &&
+        needle.startColumnIndex >= haystack.startColumnIndex &&
+        needle.endColumnIndex <= haystack.endColumnIndex);
+};
+exports.areaInsideArea = areaInsideArea;
+/**
+ * Check if two areas are equal
+ * @param area1
+ * @param area2
+ */
+var isAreasEqual = function (area1, area2) {
+    if (area1 === void 0 || area2 === void 0) {
+        return false;
+    }
+    return (area1.endRowIndex === area2.endRowIndex &&
+        area1.startRowIndex === area2.startRowIndex &&
+        area1.startColumnIndex === area2.startColumnIndex &&
+        area1.endColumnIndex === area2.endColumnIndex);
+};
+exports.isAreasEqual = isAreasEqual;
+/**
+ * Get maximum bound of an area, caters to merged cells
+ * @param area
+ * @param boundGetter
+ */
+var extendAreaToMergedCells = function (_area, mergedCells) {
+    var e_1, _a;
+    var area = tslib_1.__assign({}, _area);
+    try {
+        for (var mergedCells_1 = tslib_1.__values(mergedCells), mergedCells_1_1 = mergedCells_1.next(); !mergedCells_1_1.done; mergedCells_1_1 = mergedCells_1.next()) {
+            var bounds = mergedCells_1_1.value;
+            if ((0, exports.areaIntersects)(area, bounds)) {
+                area.startRowIndex = Math.min(area.startRowIndex, bounds.startRowIndex);
+                area.endRowIndex = Math.max(area.endRowIndex, bounds.endRowIndex);
+                area.endColumnIndex = Math.max(area.endColumnIndex, bounds.endColumnIndex);
+                area.startColumnIndex = Math.min(area.startColumnIndex, bounds.startColumnIndex);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (mergedCells_1_1 && !mergedCells_1_1.done && (_a = mergedCells_1.return)) _a.call(mergedCells_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return area;
+};
+exports.extendAreaToMergedCells = extendAreaToMergedCells;
+/**
+ * Convert 2 cells to bounds
+ * @param start
+ * @param end
+ * @returns
+ *
+ * 2 loops O(n)
+ */
+var cellRangeToBounds = function (start, end, spanMerges, getCellBounds, selectionLeftbound, selectionTopBound) {
+    if (spanMerges === void 0) { spanMerges = true; }
+    if (selectionLeftbound === void 0) { selectionLeftbound = 1; }
+    if (selectionTopBound === void 0) { selectionTopBound = 1; }
+    var top = Math.min(Math.max(selectionTopBound, start.rowIndex), Math.max(selectionTopBound, end.rowIndex));
+    var bottom = Math.max(start.rowIndex, end.rowIndex);
+    var left = Math.min(Math.max(selectionLeftbound, start.columnIndex), Math.max(selectionLeftbound, end.columnIndex));
+    var right = Math.max(start.columnIndex, end.columnIndex);
+    /**
+     * The idea is that
+     * We do 2 loops >
+     * Left to Right and then top to bottom
+     *  => Find top cell and bottom cell and check
+     * if there are any merged cells at the edge
+     * Then keep extending our top and bottom bounds accordingly
+     *
+     * Same goes for Top to bottom
+     *  => Find left most and right most cells
+     */
+    if (spanMerges) {
+        for (var columnIndex = left; columnIndex <= right; columnIndex++) {
+            var topCell = getCellBounds({ rowIndex: top, columnIndex: columnIndex });
+            var bottomCell = getCellBounds({ rowIndex: bottom, columnIndex: columnIndex });
+            bottom = Math.max(topCell.endRowIndex, bottomCell.endRowIndex, bottom);
+            top = Math.min(topCell.startRowIndex, bottomCell.startRowIndex, top);
+        }
+        for (var rowIndex = top; rowIndex <= bottom; rowIndex++) {
+            var topCell = getCellBounds({ rowIndex: rowIndex, columnIndex: left });
+            var bottomCell = getCellBounds({ rowIndex: rowIndex, columnIndex: right });
+            right = Math.max(topCell.endColumnIndex, bottomCell.endColumnIndex, right);
+            left = Math.min(topCell.startColumnIndex, bottomCell.startColumnIndex, left);
+        }
+    }
+    return {
+        startRowIndex: top,
+        startColumnIndex: left,
+        endColumnIndex: right,
+        endRowIndex: bottom,
+    };
+};
+exports.cellRangeToBounds = cellRangeToBounds;
+/**
+ * Create a range out of a cell
+ * @param param0
+ * @returns
+ */
+var cellToArea = function (_a) {
+    var rowIndex = _a.rowIndex, columnIndex = _a.columnIndex;
+    return {
+        startRowIndex: rowIndex,
+        startColumnIndex: columnIndex,
+        endColumnIndex: columnIndex,
+        endRowIndex: rowIndex,
+    };
+};
+exports.cellToArea = cellToArea;
+/**
+ * Check if its being rendered in Browser or SSR
+ */
+exports.canUseDOM = typeof window !== "undefined" &&
+    typeof document !== "undefined" &&
+    typeof window.document !== "undefined";
+/**
+ * Make a font-family value safe for CSS font shorthand (canvas
+ * `ctx.font`). Family names that aren't a single safe identifier
+ * (leading digit, spaces with odd characters, slashes, …) must be
+ * quoted or the shorthand is invalid; generic families (sans-serif,
+ * serif, monospace, …) must stay unquoted to keep their generic
+ * meaning. Accepts a single family or a comma-separated stack.
+ */
+var toCssFontFamily = function (family) {
+    return family
+        .split(",")
+        .map(function (part) {
+        var trimmed = part.trim().replace(/^["']|["']$/g, "");
+        if (!trimmed)
+            return "";
+        return /^[a-zA-Z][a-zA-Z0-9-]*$/.test(trimmed)
+            ? trimmed
+            : "\"".concat(trimmed.replace(/"/g, ""), "\"");
+    })
+        .filter(Boolean)
+        .join(", ");
+};
+exports.toCssFontFamily = toCssFontFamily;
+var AutoSizerCanvas = function (defaults) {
+    if (defaults === void 0) { defaults = {}; }
+    var _a = defaults.fontFamily, fontFamily = _a === void 0 ? "Arial" : _a, _b = defaults.fontSize, fontSize = _b === void 0 ? 12 : _b, _c = defaults.fontWeight, fontWeight = _c === void 0 ? "" : _c, _d = defaults.fontStyle, fontStyle = _d === void 0 ? "" : _d, _e = defaults.lineHeight, lineHeight = _e === void 0 ? 16 : _e, _f = defaults.scale, scale = _f === void 0 ? 1 : _f;
+    var o = {
+        fontFamily: fontFamily,
+        fontSize: fontSize,
+        fontWeight: fontWeight,
+        fontStyle: fontStyle,
+        lineHeight: lineHeight,
+        scale: scale,
+    };
+    var canvas = exports.canUseDOM && document.createElement("canvas");
+    var context = canvas ? canvas.getContext("2d") : null;
+    var SegmenterCtor = typeof Intl !== "undefined" && "Segmenter" in Intl
+        ? Intl.Segmenter
+        : undefined;
+    var wordSegmenter = SegmenterCtor
+        ? new SegmenterCtor(undefined, { granularity: "word" })
+        : undefined;
+    var graphemeSegmenter = SegmenterCtor
+        ? new SegmenterCtor(undefined, { granularity: "grapheme" })
+        : undefined;
+    var setFont = function (options) {
+        var _a;
+        if (options === void 0) { options = {}; }
+        for (var key in options) {
+            o[key] = (_a = options[key]) !== null && _a !== void 0 ? _a : o[key];
+        }
+        if (context) {
+            // Canvas `ctx.font` takes CSS font shorthand — an unquoted family
+            // that needs quoting (leading digit, slash, …) makes the whole
+            // assignment silently no-op, so the sizer keeps measuring with the
+            // PREVIOUS font. Quote non-identifier families (generic families
+            // must stay unquoted) and always end on a sans-serif fallback so
+            // painter and sizer agree on unknown fonts.
+            var family = o.fontFamily
+                ? "".concat((0, exports.toCssFontFamily)(String(o.fontFamily)), ", sans-serif")
+                : "sans-serif";
+            context.font = "".concat(o.fontStyle, " ").concat(o.fontWeight, " ").concat(o.fontSize * o.scale, "px ").concat(family);
+        }
+    };
+    var getWidthOfLongestText = function (text, shouldWrap, width) {
+        if (text == null) {
+            return { width: 0, height: 0 };
+        }
+        return getMultilineTextDimensions(text, shouldWrap, width);
+    };
+    // Get width and height of multi-line text
+    var getMultilineTextDimensions = function (text, shouldWrap, width) {
+        var e_2, _a;
+        var lines = text.split("\n");
+        var textWidth = 0;
+        // Keep this in-sync with the default line-height used by <Cell /> (1.15)
+        var lineHeightRatio = 1.2;
+        var lineHeightPx = o.fontSize * lineHeightRatio * o.scale;
+        var currentHeightPx = 0;
+        var maxWidth = width !== null && width !== void 0 ? width : 0;
+        var wrapAtWord = shouldWrap;
+        var SPACE = " ";
+        var DASH = "-";
+        var measureWidth = function (value) { var _a; return (_a = context === null || context === void 0 ? void 0 : context.measureText(value).width) !== null && _a !== void 0 ? _a : 0; };
+        var pushLine = function (content, clampToWidth) {
+            var normalized = content.replace(/\s+$/g, "");
+            var measured = normalized.length ? measureWidth(normalized) : 0;
+            var finalWidth = clampToWidth && maxWidth > 0 ? Math.min(measured, maxWidth) : measured;
+            textWidth = Math.max(textWidth, finalWidth);
+            currentHeightPx += lineHeightPx;
+        };
+        var getWordSegments = function (value) {
+            var _a;
+            if (wordSegmenter) {
+                return Array.from(wordSegmenter.segment(value), function (segment) { return segment.segment; });
+            }
+            return (_a = value.match(/\S+|\s+/g)) !== null && _a !== void 0 ? _a : [value];
+        };
+        var getGraphemeSegments = function (value) {
+            if (graphemeSegmenter) {
+                return Array.from(graphemeSegmenter.segment(value), function (segment) { return segment.segment; });
+            }
+            return Array.from(value);
+        };
+        var splitSegment = function (segment) {
+            var e_3, _a;
+            if (maxWidth <= 0) {
+                return [segment];
+            }
+            var graphemes = getGraphemeSegments(segment);
+            var pieces = [];
+            var buffer = "";
+            try {
+                for (var graphemes_1 = tslib_1.__values(graphemes), graphemes_1_1 = graphemes_1.next(); !graphemes_1_1.done; graphemes_1_1 = graphemes_1.next()) {
+                    var grapheme = graphemes_1_1.value;
+                    var tentative = buffer + grapheme;
+                    var tentativeWidth = measureWidth(tentative);
+                    if (tentativeWidth <= maxWidth || !buffer) {
+                        buffer = tentative;
+                    }
+                    else {
+                        pieces.push(buffer);
+                        buffer = grapheme;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (graphemes_1_1 && !graphemes_1_1.done && (_a = graphemes_1.return)) _a.call(graphemes_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            if (buffer) {
+                pieces.push(buffer);
+            }
+            return pieces;
+        };
+        var wrapLine = function (line) {
+            var e_4, _a;
+            var _b;
+            if (!shouldWrap || maxWidth <= 0) {
+                pushLine(line, false);
+                return;
+            }
+            var segments = getWordSegments(line);
+            var currentLine = "";
+            try {
+                for (var segments_1 = tslib_1.__values(segments), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+                    var segment = segments_1_1.value;
+                    var tentative = currentLine + segment;
+                    var tentativeWidth = measureWidth(tentative);
+                    if (tentativeWidth <= maxWidth || tentative.trim().length === 0) {
+                        currentLine = tentative;
+                        continue;
+                    }
+                    if (currentLine.trim().length) {
+                        pushLine(currentLine, true);
+                        currentLine = segment.trimStart();
+                        if (!currentLine.length) {
+                            continue;
+                        }
+                        if (measureWidth(currentLine) > maxWidth) {
+                            var pieces_1 = splitSegment(currentLine);
+                            for (var i = 0; i < pieces_1.length - 1; i++) {
+                                pushLine(pieces_1[i], true);
+                            }
+                            currentLine = (_b = pieces_1[pieces_1.length - 1]) !== null && _b !== void 0 ? _b : "";
+                        }
+                        continue;
+                    }
+                    var trimmedSegment = segment.trim();
+                    var pieces = splitSegment(trimmedSegment);
+                    for (var i = 0; i < pieces.length; i++) {
+                        var piece = pieces[i];
+                        if (i === pieces.length - 1) {
+                            currentLine = piece;
+                        }
+                        else {
+                            pushLine(piece, true);
+                        }
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            var trimmedLine = currentLine.trim();
+            if (trimmedLine.length) {
+                pushLine(trimmedLine, true);
+            }
+            else if (currentLine.length) {
+                currentHeightPx += lineHeightPx;
+            }
+        };
+        try {
+            for (var lines_1 = tslib_1.__values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+                var line = lines_1_1.value;
+                wrapLine(line);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return {
+            width: textWidth,
+            height: currentHeightPx,
+        };
+    };
+    var measureText = function (text, shouldWrap, boundedWidth) { return getWidthOfLongestText((0, exports.castToString)(text), shouldWrap, boundedWidth); };
+    var reset = function () { return setFont(defaults); };
+    /* Set font in constructor */
+    setFont(o);
+    return {
+        context: context,
+        measureText: measureText,
+        setFont: setFont,
+        reset: reset,
+    };
+};
+exports.AutoSizerCanvas = AutoSizerCanvas;
+/* Export a singleton */
+exports.autoSizerCanvas = (0, exports.AutoSizerCanvas)();
+/* Check if a value is null */
+var isNull = function (value) {
+    return value === void 0 || value === null || value === "";
+};
+exports.isNull = isNull;
+var isEqualCells = function (a, b) {
+    if ((0, exports.isNull)(a) ||
+        (0, exports.isNull)(b) ||
+        a === null ||
+        b === null ||
+        a === void 0 ||
+        b === void 0)
+        return false;
+    return a.rowIndex === b.rowIndex && a.columnIndex === b.columnIndex;
+};
+exports.isEqualCells = isEqualCells;
+/**
+ * Simple utility function to check if cell is within bounds
+ * @param cell
+ * @param bounds
+ */
+var isCellWithinBounds = function (cell, bounds) {
+    if (!bounds) {
+        return false;
+    }
+    if (cell.rowIndex < bounds.startRowIndex ||
+        cell.rowIndex > bounds.endRowIndex) {
+        return false;
+    }
+    if (cell.columnIndex < bounds.startColumnIndex ||
+        cell.columnIndex > bounds.endColumnIndex) {
+        return false;
+    }
+    return true;
+};
+exports.isCellWithinBounds = isCellWithinBounds;
+var clampIndex = function (index, isHidden, direction) {
+    switch (direction) {
+        case types_1.Direction.Right:
+        case types_1.Direction.Down: {
+            var hidden = isHidden === null || isHidden === void 0 ? void 0 : isHidden(index);
+            while (hidden === true) {
+                hidden = isHidden === null || isHidden === void 0 ? void 0 : isHidden(++index);
+            }
+            break;
+        }
+        case types_1.Direction.Left:
+        case types_1.Direction.Up: {
+            var hidden = isHidden === null || isHidden === void 0 ? void 0 : isHidden(index);
+            while (hidden === true) {
+                hidden = isHidden === null || isHidden === void 0 ? void 0 : isHidden(--index);
+            }
+            break;
+        }
+    }
+    return Math.max(0, index);
+};
+exports.clampIndex = clampIndex;
+/**
+ * Find a cell with content if the current cell is out of the current dataregion
+ * [
+ *  1, 2, 3,
+ *  x, x, x
+ *  7, 8, 9
+ * ]
+ * activeCel = 2
+ * direction = Down
+ * New Cell = 8
+ *
+ * @param activeCell
+ * @param getValue
+ * @param isHidden
+ * @param direction
+ * @param limit
+ */
+var findNextContentfulCell = function (sheetId, activeCell, getValue, isHidden, direction, limit) {
+    var rowIndex = activeCell.rowIndex, columnIndex = activeCell.columnIndex;
+    switch (direction) {
+        case types_1.Direction.Down: {
+            rowIndex = (0, exports.clampIndex)(Math.min(rowIndex + 1, limit), isHidden, direction);
+            while ((0, exports.isNull)(getValue(sheetId, rowIndex, columnIndex)) &&
+                rowIndex < limit) {
+                rowIndex = (0, exports.clampIndex)(Math.min(rowIndex + 1, limit), isHidden, direction);
+            }
+            return { rowIndex: rowIndex, columnIndex: columnIndex };
+        }
+        case types_1.Direction.Up: {
+            rowIndex = (0, exports.clampIndex)(Math.max(rowIndex - 1, limit), isHidden, direction);
+            while ((0, exports.isNull)(getValue(sheetId, rowIndex, columnIndex)) &&
+                rowIndex > limit) {
+                rowIndex = (0, exports.clampIndex)(Math.max(rowIndex - 1, limit), isHidden, direction);
+            }
+            return { rowIndex: rowIndex, columnIndex: columnIndex };
+        }
+        case types_1.Direction.Right: {
+            columnIndex = (0, exports.clampIndex)(Math.min(columnIndex + 1, limit), isHidden, direction);
+            while ((0, exports.isNull)(getValue(sheetId, rowIndex, columnIndex)) &&
+                columnIndex < limit) {
+                columnIndex = (0, exports.clampIndex)(Math.min(columnIndex + 1, limit), isHidden, direction);
+            }
+            return { rowIndex: rowIndex, columnIndex: columnIndex };
+        }
+        case types_1.Direction.Left: {
+            columnIndex = (0, exports.clampIndex)(Math.max(columnIndex - 1, limit), isHidden, direction);
+            while ((0, exports.isNull)(getValue(sheetId, rowIndex, columnIndex)) &&
+                columnIndex > limit) {
+                columnIndex = (0, exports.clampIndex)(Math.max(columnIndex - 1, limit), isHidden, direction);
+            }
+            return { rowIndex: rowIndex, columnIndex: columnIndex };
+        }
+        default:
+            return activeCell;
+    }
+};
+exports.findNextContentfulCell = findNextContentfulCell;
+/**
+ * Find the next cell
+ * @param activeCell
+ * @param getValue
+ * @param isHidden
+ * @param direction
+ * @param limit
+ */
+var findLastContentfulCell = function (sheetId, activeCell, getValue, isHidden, direction, limit) {
+    var rowIndex = activeCell.rowIndex, columnIndex = activeCell.columnIndex;
+    switch (direction) {
+        case types_1.Direction.Down: {
+            while (!(0, exports.isNull)(getValue(sheetId, (0, exports.clampIndex)(Math.min(rowIndex + 1, limit), isHidden, direction), columnIndex)) &&
+                rowIndex < limit) {
+                (0, exports.clampIndex)(Math.min(++rowIndex, limit), isHidden, direction);
+            }
+            return {
+                columnIndex: columnIndex,
+                rowIndex: rowIndex,
+            };
+        }
+        case types_1.Direction.Up: {
+            while (!(0, exports.isNull)(getValue(sheetId, (0, exports.clampIndex)(Math.max(rowIndex - 1, limit), isHidden, direction), columnIndex)) &&
+                rowIndex > limit) {
+                rowIndex = (0, exports.clampIndex)(Math.max(--rowIndex, limit), isHidden, direction);
+            }
+            return {
+                columnIndex: columnIndex,
+                rowIndex: rowIndex,
+            };
+        }
+        case types_1.Direction.Right: {
+            while (!(0, exports.isNull)(getValue(sheetId, rowIndex, (0, exports.clampIndex)(Math.min(columnIndex + 1, limit), isHidden, direction))) &&
+                columnIndex < limit) {
+                columnIndex = (0, exports.clampIndex)(Math.min(++columnIndex, limit), isHidden, direction);
+            }
+            return {
+                rowIndex: rowIndex,
+                columnIndex: columnIndex,
+            };
+        }
+        case types_1.Direction.Left: {
+            while (!(0, exports.isNull)(getValue(sheetId, rowIndex, (0, exports.clampIndex)(Math.max(columnIndex - 1, limit), isHidden, direction))) &&
+                columnIndex > limit) {
+                columnIndex = (0, exports.clampIndex)(Math.max(--columnIndex, limit), isHidden, direction);
+            }
+            return {
+                rowIndex: rowIndex,
+                columnIndex: columnIndex,
+            };
+        }
+        default:
+            return activeCell;
+    }
+};
+exports.findLastContentfulCell = findLastContentfulCell;
+/**
+ * Ex
+ */
+var findNextCellInDataRegion = function (sheetId, activeCell, getValue, isHidden, direction, limit) {
+    var rowIndex = activeCell.rowIndex, columnIndex = activeCell.columnIndex;
+    var isCurrentCellEmpty = (0, exports.isNull)(getValue(sheetId, rowIndex, columnIndex));
+    var didWeReachTheEdge = function (cur, next) {
+        return (cur && next) || (cur && !next) || (!cur && next);
+    };
+    switch (direction) {
+        case types_1.Direction.Down: {
+            var nextIndex = (0, exports.clampIndex)(Math.min(rowIndex + 1, limit), isHidden, direction);
+            var nextCellValue = getValue(sheetId, nextIndex, columnIndex);
+            var isNextCellEmpty = (0, exports.isNull)(nextCellValue);
+            var isEdge = didWeReachTheEdge(isCurrentCellEmpty, isNextCellEmpty);
+            var nextCell = isEdge
+                ? (0, exports.findNextContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit)
+                : (0, exports.findLastContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit);
+            return nextCell === null || nextCell === void 0 ? void 0 : nextCell.rowIndex;
+        }
+        case types_1.Direction.Up: {
+            var nextIndex = (0, exports.clampIndex)(Math.max(rowIndex - 1, limit), isHidden, direction);
+            var nextCellValue = getValue(sheetId, nextIndex, columnIndex);
+            var isNextCellEmpty = (0, exports.isNull)(nextCellValue);
+            var isEdge = didWeReachTheEdge(isCurrentCellEmpty, isNextCellEmpty);
+            var nextCell = isEdge
+                ? (0, exports.findNextContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit)
+                : (0, exports.findLastContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit);
+            return nextCell === null || nextCell === void 0 ? void 0 : nextCell.rowIndex;
+        }
+        case types_1.Direction.Right: {
+            var nextIndex = (0, exports.clampIndex)(Math.min(columnIndex + 1, limit), isHidden, direction);
+            var nextCellValue = getValue(sheetId, rowIndex, nextIndex);
+            var isNextCellEmpty = (0, exports.isNull)(nextCellValue);
+            var isEdge = didWeReachTheEdge(isCurrentCellEmpty, isNextCellEmpty);
+            var nextCell = isEdge
+                ? (0, exports.findNextContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit)
+                : (0, exports.findLastContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit);
+            return nextCell === null || nextCell === void 0 ? void 0 : nextCell.columnIndex;
+        }
+        case types_1.Direction.Left: {
+            var nextIndex = (0, exports.clampIndex)(Math.max(columnIndex - 1, limit), isHidden, direction);
+            var nextCellValue = getValue(sheetId, rowIndex, nextIndex);
+            var isNextCellEmpty = (0, exports.isNull)(nextCellValue);
+            var isEdge = didWeReachTheEdge(isCurrentCellEmpty, isNextCellEmpty);
+            var nextCell = isEdge
+                ? (0, exports.findNextContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit)
+                : (0, exports.findLastContentfulCell)(sheetId, activeCell, getValue, isHidden, direction, limit);
+            return nextCell === null || nextCell === void 0 ? void 0 : nextCell.columnIndex;
+        }
+    }
+};
+exports.findNextCellInDataRegion = findNextCellInDataRegion;
+/**
+ * Converts a value to string
+ * @param value
+ */
+var castToString = function (value) {
+    if (value === null || value === void 0)
+        return void 0;
+    return typeof value !== "string" ? "" + value : value;
+};
+exports.castToString = castToString;
+var isArrowKey = function (key) {
+    return (["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].indexOf(key) !== -1);
+};
+exports.isArrowKey = isArrowKey;
+var getScrollIncrement = function (delta, minDim) {
+    if (minDim === void 0) { minDim = 8; }
+    return Math.max(1, Math.round(Math.abs(delta) / minDim));
+};
+exports.getScrollIncrement = getScrollIncrement;
+exports.useIsomorphicLayoutEffect = exports.canUseDOM
+    ? react_1.useLayoutEffect
+    : react_1.useEffect;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var useCallbackRef = function (callback) {
+    var callbackRef = (0, react_1.useRef)(callback);
+    (0, exports.useIsomorphicLayoutEffect)(function () {
+        callbackRef.current = callback;
+    });
+    // https://github.com/facebook/react/issues/19240
+    return (0, react_1.useMemo)(function () { return (function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return (_a = callbackRef.current) === null || _a === void 0 ? void 0 : _a.call.apply(_a, tslib_1.__spreadArray([callbackRef], tslib_1.__read(args), false));
+    }); }, []);
+};
+exports.useCallbackRef = useCallbackRef;
+var getDevicePixelRatio = function () {
+    return exports.canUseDOM && typeof window !== "undefined" ? window.devicePixelRatio : 1;
+};
+exports.getDevicePixelRatio = getDevicePixelRatio;
+var getPreviousCellInDirection = function (cell, direction) {
+    if (direction === void 0) { direction = types_1.Direction.Down; }
+    if (direction === types_1.Direction.Down) {
+        return tslib_1.__assign(tslib_1.__assign({}, cell), { rowIndex: cell.rowIndex - 1 });
+    }
+    if (direction === types_1.Direction.Right) {
+        return tslib_1.__assign(tslib_1.__assign({}, cell), { columnIndex: cell.columnIndex - 1 });
+    }
+};
+exports.getPreviousCellInDirection = getPreviousCellInDirection;