@mcp-z/mcp-sheets 1.0.0

package/dist/cjs/spreadsheet/range-operations.js

@@ -0,0 +1,672 @@
+/**
+ * Range Operations Utilities for Google Sheets
+ *
+ * This module provides comprehensive utilities for working with A1 notation,
+ * range parsing, batch operations, and range validation in Google Sheets.
+ *
+ * Key features:
+ * - A1 notation validation and parsing
+ * - Range manipulation and calculation utilities
+ * - Batch operation builders for Google Sheets API
+ * - Cell count and dimension calculations
+ * - Range conflict detection for batch operations
+ * - Google Sheets limits validation and enforcement
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get GOOGLE_SHEETS_LIMITS () {
+        return GOOGLE_SHEETS_LIMITS;
+    },
+    get buildValuesBatchUpdateRequest () {
+        return buildValuesBatchUpdateRequest;
+    },
+    get calculateRangeDimensions () {
+        return calculateRangeDimensions;
+    },
+    get calculateTotalCells () {
+        return calculateTotalCells;
+    },
+    get columnIndexToString () {
+        return columnIndexToString;
+    },
+    get columnStringToIndex () {
+        return columnStringToIndex;
+    },
+    get detectRangeConflicts () {
+        return detectRangeConflicts;
+    },
+    get expandRange () {
+        return expandRange;
+    },
+    get getRangeIntersection () {
+        return getRangeIntersection;
+    },
+    get isValidA1Notation () {
+        return isValidA1Notation;
+    },
+    get parseA1Notation () {
+        return parseA1Notation;
+    },
+    get parseCellReference () {
+        return parseCellReference;
+    },
+    get rangeReferenceToGridRange () {
+        return rangeReferenceToGridRange;
+    },
+    get rangeToA1Notation () {
+        return rangeToA1Notation;
+    },
+    get rangesOverlap () {
+        return rangesOverlap;
+    },
+    get splitRangeIntoChunks () {
+        return splitRangeIntoChunks;
+    },
+    get validateA1Notation () {
+        return validateA1Notation;
+    },
+    get validateBatchRanges () {
+        return validateBatchRanges;
+    }
+});
+var _columnutilities = require("./column-utilities.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var GOOGLE_SHEETS_LIMITS = {
+    MAX_ROWS: 10000000,
+    MAX_COLUMNS: 18278,
+    MAX_CELLS: 10000000,
+    MAX_BATCH_REQUESTS: 1000,
+    MAX_DIMENSION_BATCH_REQUESTS: 100
+};
+function isValidA1Notation(notation) {
+    if (!notation || typeof notation !== 'string') {
+        return false;
+    }
+    // Use the same regex pattern as in the schema
+    var a1Pattern = /^(?:[A-Z]{1,3}(?:[1-9]\d{0,6}|10000000)(?::[A-Z]{1,3}(?:[1-9]\d{0,6}|10000000))?|[A-Z]{1,3}:[A-Z]{1,3}|(?:[1-9]\d{0,6}|10000000):(?:[1-9]\d{0,6}|10000000))$/;
+    if (!a1Pattern.test(notation)) {
+        return false;
+    }
+    // Additional validation for Google Sheets limits
+    var parts = notation.split(':');
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = parts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var part = _step.value;
+            // Check cell reference
+            var cellMatch = part.match(/^([A-Z]{1,3})([1-9]\d{0,6}|10000000)$/);
+            if (cellMatch && cellMatch[1] && cellMatch[2]) {
+                var _cellMatch = _sliced_to_array(cellMatch, 3), colStr = _cellMatch[1], rowStr = _cellMatch[2];
+                // Validate column
+                var colNum = columnStringToIndex(colStr);
+                if (colNum > GOOGLE_SHEETS_LIMITS.MAX_COLUMNS) {
+                    return false;
+                }
+                // Validate row
+                var rowNum = parseInt(rowStr, 10);
+                if (rowNum > GOOGLE_SHEETS_LIMITS.MAX_ROWS) {
+                    return false;
+                }
+            }
+            // Check column reference
+            var colMatch = part.match(/^([A-Z]{1,3})$/);
+            if (colMatch && colMatch[1]) {
+                var colNum1 = columnStringToIndex(colMatch[1]);
+                if (colNum1 > GOOGLE_SHEETS_LIMITS.MAX_COLUMNS) {
+                    return false;
+                }
+            }
+            // Check row reference
+            var rowMatch = part.match(/^([1-9]\d{0,6}|10000000)$/);
+            if (rowMatch && rowMatch[1]) {
+                var rowNum1 = parseInt(rowMatch[1], 10);
+                if (rowNum1 > GOOGLE_SHEETS_LIMITS.MAX_ROWS) {
+                    return false;
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return true;
+}
+function validateA1Notation(notation) {
+    if (!isValidA1Notation(notation)) {
+        throw new Error('Invalid A1 notation: "'.concat(notation, '". Valid formats: A1, A1:B2, A:B, 1:2'));
+    }
+}
+function columnStringToIndex(colStr) {
+    var colNum = 0;
+    for(var i = 0; i < colStr.length; i++){
+        colNum = colNum * 26 + (colStr.charCodeAt(i) - 64);
+    }
+    return colNum;
+}
+function columnIndexToString(colIndex) {
+    return (0, _columnutilities.a1Col)(colIndex);
+}
+function parseCellReference(cellRef) {
+    var match = cellRef.match(/^([A-Z]{1,3})([1-9]\d{0,6}|10000000)$/);
+    if (!match || !match[1] || !match[2]) {
+        throw new Error("Invalid cell reference: ".concat(cellRef));
+    }
+    var _match = _sliced_to_array(match, 3), column = _match[1], rowStr = _match[2];
+    var row = parseInt(rowStr, 10);
+    var columnIndex = columnStringToIndex(column);
+    return {
+        column: column,
+        columnIndex: columnIndex,
+        row: row
+    };
+}
+function parseA1Notation(notation) {
+    validateA1Notation(notation);
+    var parts = notation.split(':');
+    if (parts.length === 1) {
+        var part = parts[0];
+        if (!part) {
+            throw new Error('Invalid A1 notation: empty part after split');
+        }
+        // Single cell reference (e.g., A1)
+        var cellMatch = part.match(/^([A-Z]{1,3})([1-9]\d{0,6}|10000000)$/);
+        if (cellMatch && cellMatch[1] && cellMatch[2]) {
+            var startCell = parseCellReference(part);
+            return {
+                type: 'cell',
+                startCell: startCell,
+                endCell: startCell
+            };
+        }
+        // Single column reference (e.g., A)
+        var colMatch = part.match(/^([A-Z]{1,3})$/);
+        if (colMatch && colMatch[1]) {
+            var column = colMatch[1];
+            var columnIndex = columnStringToIndex(column);
+            return {
+                type: 'column',
+                startColumn: column,
+                endColumn: column,
+                startColumnIndex: columnIndex,
+                endColumnIndex: columnIndex
+            };
+        }
+        // Single row reference (e.g., 1)
+        var rowMatch = part.match(/^([1-9]\d{0,6}|10000000)$/);
+        if (rowMatch && rowMatch[1]) {
+            var row = parseInt(rowMatch[1], 10);
+            return {
+                type: 'row',
+                startRow: row,
+                endRow: row
+            };
+        }
+    }
+    if (parts.length === 2 && parts[0] && parts[1]) {
+        var _parts = _sliced_to_array(parts, 2), start = _parts[0], end = _parts[1];
+        // Cell range (e.g., A1:B5)
+        var startCellMatch = start.match(/^([A-Z]{1,3})([1-9]\d{0,6}|10000000)$/);
+        var endCellMatch = end.match(/^([A-Z]{1,3})([1-9]\d{0,6}|10000000)$/);
+        if (startCellMatch && endCellMatch && startCellMatch[1] && startCellMatch[2] && endCellMatch[1] && endCellMatch[2]) {
+            var startCell1 = parseCellReference(start);
+            var endCell = parseCellReference(end);
+            return {
+                type: 'range',
+                startCell: startCell1,
+                endCell: endCell
+            };
+        }
+        // Column range (e.g., A:B)
+        var startColMatch = start.match(/^([A-Z]{1,3})$/);
+        var endColMatch = end.match(/^([A-Z]{1,3})$/);
+        if (startColMatch && endColMatch && startColMatch[1] && endColMatch[1]) {
+            var startColumn = startColMatch[1];
+            var endColumn = endColMatch[1];
+            var startColumnIndex = columnStringToIndex(startColumn);
+            var endColumnIndex = columnStringToIndex(endColumn);
+            return {
+                type: 'column',
+                startColumn: startColumn,
+                endColumn: endColumn,
+                startColumnIndex: startColumnIndex,
+                endColumnIndex: endColumnIndex
+            };
+        }
+        // Row range (e.g., 1:5)
+        var startRowMatch = start.match(/^([1-9]\d{0,6}|10000000)$/);
+        var endRowMatch = end.match(/^([1-9]\d{0,6}|10000000)$/);
+        if (startRowMatch && endRowMatch && startRowMatch[1] && endRowMatch[1]) {
+            var startRow = parseInt(startRowMatch[1], 10);
+            var endRow = parseInt(endRowMatch[1], 10);
+            return {
+                type: 'row',
+                startRow: startRow,
+                endRow: endRow
+            };
+        }
+    }
+    throw new Error("Unable to parse A1 notation: ".concat(notation));
+}
+function rangeToA1Notation(range) {
+    switch(range.type){
+        case 'cell':
+            if (!range.startCell) throw new Error('Invalid cell range: missing startCell');
+            return "".concat(range.startCell.column).concat(range.startCell.row);
+        case 'range':
+            if (!range.startCell || !range.endCell) throw new Error('Invalid range: missing start or end cell');
+            return "".concat(range.startCell.column).concat(range.startCell.row, ":").concat(range.endCell.column).concat(range.endCell.row);
+        case 'column':
+            if (!range.startColumn || !range.endColumn) throw new Error('Invalid column range: missing start or end column');
+            if (range.startColumn === range.endColumn) {
+                return range.startColumn;
+            }
+            return "".concat(range.startColumn, ":").concat(range.endColumn);
+        case 'row':
+            if (range.startRow === undefined || range.endRow === undefined) throw new Error('Invalid row range: missing start or end row');
+            if (range.startRow === range.endRow) {
+                return range.startRow.toString();
+            }
+            return "".concat(range.startRow, ":").concat(range.endRow);
+        default:
+            throw new Error("Unknown range type: ".concat(range.type));
+    }
+}
+function calculateRangeDimensions(notation) {
+    var range = parseA1Notation(notation);
+    switch(range.type){
+        case 'cell':
+            return {
+                rows: 1,
+                columns: 1,
+                cells: 1
+            };
+        case 'range':
+            {
+                if (!range.startCell || !range.endCell) throw new Error('Invalid range: missing cells');
+                var rows = range.endCell.row - range.startCell.row + 1;
+                var columns = range.endCell.columnIndex - range.startCell.columnIndex + 1;
+                return {
+                    rows: rows,
+                    columns: columns,
+                    cells: rows * columns
+                };
+            }
+        case 'column':
+            {
+                if (range.startColumnIndex === undefined || range.endColumnIndex === undefined) {
+                    throw new Error('Invalid column range: missing column indices');
+                }
+                var columnCount = range.endColumnIndex - range.startColumnIndex + 1;
+                return {
+                    rows: GOOGLE_SHEETS_LIMITS.MAX_ROWS,
+                    columns: columnCount,
+                    cells: GOOGLE_SHEETS_LIMITS.MAX_ROWS * columnCount
+                };
+            }
+        case 'row':
+            {
+                if (range.startRow === undefined || range.endRow === undefined) {
+                    throw new Error('Invalid row range: missing row numbers');
+                }
+                var rowCount = range.endRow - range.startRow + 1;
+                return {
+                    rows: rowCount,
+                    columns: GOOGLE_SHEETS_LIMITS.MAX_COLUMNS,
+                    cells: rowCount * GOOGLE_SHEETS_LIMITS.MAX_COLUMNS
+                };
+            }
+        default:
+            throw new Error("Unknown range type: ".concat(range.type));
+    }
+}
+function calculateTotalCells(ranges) {
+    return ranges.reduce(function(total, range) {
+        var dimensions = calculateRangeDimensions(range);
+        return total + dimensions.cells;
+    }, 0);
+}
+function buildValuesBatchUpdateRequest(requests, sheetTitle) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    // Validate all ranges first
+    requests.forEach(function(req, index) {
+        try {
+            validateA1Notation(req.range);
+        } catch (error) {
+            throw new Error("Invalid range in request ".concat(index, ": ").concat(error));
+        }
+    });
+    // Calculate total cells for validation
+    var totalCells = calculateTotalCells(requests.map(function(r) {
+        return r.range;
+    }));
+    if (totalCells > GOOGLE_SHEETS_LIMITS.MAX_CELLS) {
+        throw new Error("Batch update exceeds maximum cells limit: ".concat(totalCells, " > ").concat(GOOGLE_SHEETS_LIMITS.MAX_CELLS));
+    }
+    // Build the request
+    var data = requests.map(function(req) {
+        return {
+            range: "".concat(sheetTitle, "!").concat(req.range),
+            values: req.values,
+            majorDimension: req.majorDimension || 'ROWS'
+        };
+    });
+    return {
+        valueInputOption: options.valueInputOption || 'USER_ENTERED',
+        data: data,
+        includeValuesInResponse: options.includeValuesInResponse || false,
+        responseDateTimeRenderOption: options.responseDateTimeRenderOption || 'FORMATTED_STRING',
+        responseValueRenderOption: options.responseValueRenderOption || 'FORMATTED_VALUE'
+    };
+}
+function rangesOverlap(range1, range2) {
+    try {
+        var parsed1 = parseA1Notation(range1);
+        var parsed2 = parseA1Notation(range2);
+        // Different types might still overlap, so we need to normalize to cell ranges
+        var normalized1 = normalizeRangeToBounds(parsed1);
+        var normalized2 = normalizeRangeToBounds(parsed2);
+        // Check for overlap
+        return !(normalized1.endRow < normalized2.startRow || normalized2.endRow < normalized1.startRow || normalized1.endCol < normalized2.startCol || normalized2.endCol < normalized1.startCol);
+    } catch (unused) {
+        // If we can't parse the ranges, assume no overlap
+        return false;
+    }
+}
+/**
+ * Normalizes a range to bounds for overlap checking
+ */ function normalizeRangeToBounds(range) {
+    switch(range.type){
+        case 'cell':
+            if (!range.startCell) throw new Error('Invalid cell range');
+            return {
+                startRow: range.startCell.row,
+                endRow: range.startCell.row,
+                startCol: range.startCell.columnIndex,
+                endCol: range.startCell.columnIndex
+            };
+        case 'range':
+            if (!range.startCell || !range.endCell) throw new Error('Invalid range');
+            return {
+                startRow: range.startCell.row,
+                endRow: range.endCell.row,
+                startCol: range.startCell.columnIndex,
+                endCol: range.endCell.columnIndex
+            };
+        case 'column':
+            if (range.startColumnIndex === undefined || range.endColumnIndex === undefined) {
+                throw new Error('Invalid column range');
+            }
+            return {
+                startRow: 1,
+                endRow: GOOGLE_SHEETS_LIMITS.MAX_ROWS,
+                startCol: range.startColumnIndex,
+                endCol: range.endColumnIndex
+            };
+        case 'row':
+            if (range.startRow === undefined || range.endRow === undefined) {
+                throw new Error('Invalid row range');
+            }
+            return {
+                startRow: range.startRow,
+                endRow: range.endRow,
+                startCol: 1,
+                endCol: GOOGLE_SHEETS_LIMITS.MAX_COLUMNS
+            };
+        default:
+            throw new Error("Unknown range type: ".concat(range.type));
+    }
+}
+function detectRangeConflicts(ranges) {
+    var conflicts = [];
+    for(var i = 0; i < ranges.length; i++){
+        for(var j = i + 1; j < ranges.length; j++){
+            var range1 = ranges[i];
+            var range2 = ranges[j];
+            if (!range1 || !range2) continue;
+            if (rangesOverlap(range1, range2)) {
+                conflicts.push({
+                    range1: range1,
+                    range2: range2,
+                    conflictType: 'overlap',
+                    description: "Ranges ".concat(range1, " and ").concat(range2, " overlap")
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+function validateBatchRanges(ranges) {
+    var errors = [];
+    var warnings = [];
+    var totalCells = 0;
+    // Validate each range
+    ranges.forEach(function(range, index) {
+        try {
+            validateA1Notation(range);
+            var dimensions = calculateRangeDimensions(range);
+            totalCells += dimensions.cells;
+            // Check for very large ranges that might cause performance issues
+            if (dimensions.cells > 1000000) {
+                warnings.push("Range ".concat(index + 1, " (").concat(range, ") affects ").concat(dimensions.cells.toLocaleString(), " cells, which may impact performance"));
+            }
+        } catch (error) {
+            errors.push("Range ".concat(index + 1, " (").concat(range, "): ").concat(error));
+        }
+    });
+    // Check batch size limits
+    if (ranges.length > GOOGLE_SHEETS_LIMITS.MAX_BATCH_REQUESTS) {
+        errors.push("Too many ranges: ".concat(ranges.length, " > ").concat(GOOGLE_SHEETS_LIMITS.MAX_BATCH_REQUESTS));
+    }
+    // Check total cells limit
+    if (totalCells > GOOGLE_SHEETS_LIMITS.MAX_CELLS) {
+        errors.push("Total cells exceed limit: ".concat(totalCells.toLocaleString(), " > ").concat(GOOGLE_SHEETS_LIMITS.MAX_CELLS.toLocaleString()));
+    }
+    // Check for conflicts
+    var conflicts = detectRangeConflicts(ranges);
+    conflicts.forEach(function(conflict) {
+        warnings.push(conflict.description);
+    });
+    return {
+        valid: errors.length === 0,
+        errors: errors,
+        warnings: warnings,
+        totalCells: totalCells
+    };
+}
+function expandRange(notation, expandRows, expandCols) {
+    var range = parseA1Notation(notation);
+    if (range.type === 'cell' && range.startCell) {
+        var newEndRow = Math.min(range.startCell.row + expandRows, GOOGLE_SHEETS_LIMITS.MAX_ROWS);
+        var newEndCol = Math.min(range.startCell.columnIndex + expandCols, GOOGLE_SHEETS_LIMITS.MAX_COLUMNS);
+        var newEndColStr = columnIndexToString(newEndCol);
+        if (expandRows === 0 && expandCols === 0) {
+            return notation;
+        }
+        return "".concat(range.startCell.column).concat(range.startCell.row, ":").concat(newEndColStr).concat(newEndRow);
+    }
+    if (range.type === 'range' && range.startCell && range.endCell) {
+        var newEndRow1 = Math.min(range.endCell.row + expandRows, GOOGLE_SHEETS_LIMITS.MAX_ROWS);
+        var newEndCol1 = Math.min(range.endCell.columnIndex + expandCols, GOOGLE_SHEETS_LIMITS.MAX_COLUMNS);
+        var newEndColStr1 = columnIndexToString(newEndCol1);
+        return "".concat(range.startCell.column).concat(range.startCell.row, ":").concat(newEndColStr1).concat(newEndRow1);
+    }
+    // For row and column ranges, expansion doesn't make sense in the same way
+    return notation;
+}
+function getRangeIntersection(range1, range2) {
+    try {
+        var parsed1 = parseA1Notation(range1);
+        var parsed2 = parseA1Notation(range2);
+        var bounds1 = normalizeRangeToBounds(parsed1);
+        var bounds2 = normalizeRangeToBounds(parsed2);
+        // Check if they overlap
+        if (!rangesOverlap(range1, range2)) {
+            return null;
+        }
+        // Calculate intersection bounds
+        var startRow = Math.max(bounds1.startRow, bounds2.startRow);
+        var endRow = Math.min(bounds1.endRow, bounds2.endRow);
+        var startCol = Math.max(bounds1.startCol, bounds2.startCol);
+        var endCol = Math.min(bounds1.endCol, bounds2.endCol);
+        var startColStr = columnIndexToString(startCol);
+        var endColStr = columnIndexToString(endCol);
+        if (startRow === endRow && startCol === endCol) {
+            return "".concat(startColStr).concat(startRow);
+        }
+        return "".concat(startColStr).concat(startRow, ":").concat(endColStr).concat(endRow);
+    } catch (unused) {
+        return null;
+    }
+}
+function splitRangeIntoChunks(notation) {
+    var maxCellsPerChunk = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100000;
+    var range = parseA1Notation(notation);
+    var dimensions = calculateRangeDimensions(notation);
+    if (dimensions.cells <= maxCellsPerChunk) {
+        return [
+            notation
+        ];
+    }
+    var chunks = [];
+    if (range.type === 'range' && range.startCell && range.endCell) {
+        var totalRows = range.endCell.row - range.startCell.row + 1;
+        var totalCols = range.endCell.columnIndex - range.startCell.columnIndex + 1;
+        // Calculate chunk size based on max cells
+        var cellsPerRow = totalCols;
+        var maxRowsPerChunk = Math.floor(maxCellsPerChunk / cellsPerRow);
+        if (maxRowsPerChunk >= 1) {
+            // Split by rows
+            for(var currentRow = range.startCell.row; currentRow <= range.endCell.row; currentRow += maxRowsPerChunk){
+                var chunkEndRow = Math.min(currentRow + maxRowsPerChunk - 1, range.endCell.row);
+                var chunkRange = "".concat(range.startCell.column).concat(currentRow, ":").concat(range.endCell.column).concat(chunkEndRow);
+                chunks.push(chunkRange);
+            }
+        } else {
+            // If even one row is too big, split by columns
+            var maxColsPerChunk = Math.floor(maxCellsPerChunk / totalRows);
+            for(var currentCol = range.startCell.columnIndex; currentCol <= range.endCell.columnIndex; currentCol += maxColsPerChunk){
+                var chunkEndCol = Math.min(currentCol + maxColsPerChunk - 1, range.endCell.columnIndex);
+                var startColStr = columnIndexToString(currentCol);
+                var endColStr = columnIndexToString(chunkEndCol);
+                var chunkRange1 = "".concat(startColStr).concat(range.startCell.row, ":").concat(endColStr).concat(range.endCell.row);
+                chunks.push(chunkRange1);
+            }
+        }
+    } else {
+        // For other range types, just return the original range
+        // (column and row ranges are already at their limits)
+        chunks.push(notation);
+    }
+    return chunks;
+}
+function rangeReferenceToGridRange(rangeRef, sheetId) {
+    if (rangeRef.type === 'cell' || rangeRef.type === 'range') {
+        // For cell and range types, extract from startCell/endCell
+        if (!rangeRef.startCell || !rangeRef.endCell) {
+            throw new Error("Invalid ".concat(rangeRef.type, " range: missing start or end cell"));
+        }
+        return {
+            sheetId: sheetId,
+            // Convert 1-based row to 0-based startRowIndex
+            startRowIndex: rangeRef.startCell.row - 1,
+            // endRowIndex is exclusive (so row 5 becomes endRowIndex 5)
+            endRowIndex: rangeRef.endCell.row,
+            // Convert 1-based column index to 0-based startColumnIndex
+            startColumnIndex: rangeRef.startCell.columnIndex - 1,
+            // endColumnIndex is exclusive
+            endColumnIndex: rangeRef.endCell.columnIndex
+        };
+    }
+    if (rangeRef.type === 'row') {
+        // For row types, use startRow/endRow and omit column indices for full row width
+        if (rangeRef.startRow === undefined || rangeRef.endRow === undefined) {
+            throw new Error('Invalid row range: missing start or end row');
+        }
+        return {
+            sheetId: sheetId,
+            // Convert 1-based row to 0-based startRowIndex
+            startRowIndex: rangeRef.startRow - 1,
+            // endRowIndex is exclusive
+            endRowIndex: rangeRef.endRow
+        };
+    }
+    if (rangeRef.type === 'column') {
+        // For column types, use startColumnIndex/endColumnIndex and omit row indices for full column height
+        if (rangeRef.startColumnIndex === undefined || rangeRef.endColumnIndex === undefined) {
+            throw new Error('Invalid column range: missing start or end column index');
+        }
+        return {
+            sheetId: sheetId,
+            // Omit startRowIndex and endRowIndex to apply to all rows
+            // Convert 1-based column index to 0-based startColumnIndex
+            startColumnIndex: rangeRef.startColumnIndex - 1,
+            // endColumnIndex is exclusive
+            endColumnIndex: rangeRef.endColumnIndex
+        };
+    }
+    throw new Error("Unknown range type: ".concat(rangeRef.type));
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }