microsoft-graph 2.7.2 → 2.7.4

package/dist/services/addressManipulation.js

@@ -1,280 +0,0 @@
-import InvalidArgumentError from "../errors/InvalidArgumentError.js";
-import UnsupportedAddressTypeError from "../errors/UnsupportedAddressTypeError.js";
-import { columnAddressToOffset, offsetToColumnAddress, offsetToRowAddress, rowAddressToOffset } from "./addressOffset.js";
-const firstColumn = "A";
-const lastColumn = "XFD";
-const firstRow = "1";
-const lastRow = "1048576";
-const addressPattern = /^(?<sheet>[A-Za-z0-9_]+!)?(?:(?<startColumn>[A-Z]+)?(?<startRow>\d+)?(?::(?<endColumn>[A-Z]+)?(?<endRow>\d+)?)?)$/;
-/**
- * Decomposes an address into its components (start and end columns/rows).
- * @param address - The address to decompose.
- * @returns The decomposed address components.
- * @throws InvalidArgumentError if the address format is invalid.
- */
-export function decomposeAddress(address) {
-    const match = address.match(addressPattern);
-    if (!match?.groups) {
-        throw new InvalidArgumentError(`Invalid address format. Must match pattern '${addressPattern}'`);
-    }
-    const groups = match.groups;
-    return {
-        startColumn: groups.startColumn ?? firstColumn,
-        startRow: groups.startRow ?? firstRow,
-        endColumn: groups.endColumn ?? groups.startColumn ?? lastColumn,
-        endRow: groups.endRow ?? groups.startRow ?? lastRow,
-    };
-}
-/**
- * Composes an address from its components.
- * @param components - The address components.
- * @returns The composed address.
- * @throws InvalidArgumentError if the components are invalid.
- */
-export function composeAddress(components) {
-    if (isSingleColumn(components) && isAllRows(components)) {
-        return composeColumnAddress(components.startColumn);
-    }
-    if (isSingleRow(components) && isAllColumns(components)) {
-        return composeRowAddress(components.startRow);
-    }
-    if (isAllRows(components)) {
-        return composeColumnRangeAddress(components.startColumn, components.endColumn);
-    }
-    if (isAllColumns(components)) {
-        return composeRowRangeAddress(components.startRow, components.endRow);
-    }
-    if (isSingleColumn(components) && isSingleRow(components)) {
-        return composeCellAddress(components.startColumn, components.startRow);
-    }
-    if (components.startColumn > components.endColumn) {
-        throw new InvalidArgumentError("Invalid address. End column is before start column.");
-    }
-    if (components.startRow > components.endRow) {
-        throw new InvalidArgumentError("Invalid address. End row is before start row.");
-    }
-    return composeCellRangeAddress(components.startColumn, components.startRow, components.endColumn, components.endRow);
-}
-/**
- * Gets the first cell address from a given address.
- * @param address - The address to analyze.
- * @returns The first cell address.
- */
-export function getFirstCellAddress(address) {
-    const components = decomposeAddress(address);
-    return composeCellAddress(components.startColumn, components.startRow);
-}
-/**
- * Gets the last cell address from a given address.
- * @param address - The address to analyze.
- * @returns The last cell address.
- */
-export function getLastCellAddress(address) {
-    const components = decomposeAddress(address);
-    return composeCellAddress(components.endColumn, components.endRow);
-}
-/**
- * Gets the first row address from a given address.
- * @param address - The address to analyze.
- * @returns The first row address.
- */
-export function getFirstRowAddress(address) {
-    const components = decomposeAddress(address);
-    return composeAddress({
-        startColumn: components.startColumn,
-        startRow: components.startRow,
-        endColumn: components.endColumn,
-        endRow: components.startRow,
-    });
-}
-/**
- * Gets the last row address from a given address.
- * @param address - The address to analyze.
- * @returns The last row address.
- */
-export function getLastRowAddress(address) {
-    const components = decomposeAddress(address);
-    return composeAddress({
-        startColumn: components.startColumn,
-        startRow: components.endRow,
-        endColumn: components.endColumn,
-        endRow: components.endRow,
-    });
-}
-/**
- * Gets the first column address from a given address.
- * @param address - The address to analyze.
- * @returns The first column address.
- */
-export function getFirstColumnAddress(address) {
-    const components = decomposeAddress(address);
-    return composeAddress({
-        startColumn: components.startColumn,
-        startRow: components.startRow,
-        endColumn: components.startColumn,
-        endRow: components.endRow,
-    });
-}
-/**
- * Gets the last column address from a given address.
- * @param address - The address to analyze.
- * @returns The last column address.
- */
-export function getLastColumnAddress(address) {
-    const components = decomposeAddress(address);
-    return composeAddress({
-        startColumn: components.endColumn,
-        startRow: components.startRow,
-        endColumn: components.endColumn,
-        endRow: components.endRow,
-    });
-}
-/**
- * Offsets an address by the specified column and row offsets.
- * @param address - The address to offset.
- * @param columnOffset - The column offset.
- * @param rowOffset - The row offset.
- * @returns The offset address.
- * @throws UnsupportedAddressTypeError if the address cannot be offset.
- * @throws InvalidArgumentError if the offset is out of bounds.
- */
-export function offsetAddress(address, columnOffset, rowOffset) {
-    const components = decomposeAddress(address);
-    if (isAllRows(components) && rowOffset !== 0) {
-        throw new UnsupportedAddressTypeError("All rows are selected. Cannot offset rows.");
-    }
-    if (isAllColumns(components) && columnOffset !== 0) {
-        throw new UnsupportedAddressTypeError("All columns are selected. Cannot offset columns.");
-    }
-    const newStartRowIndex = rowAddressToOffset(components.startRow) + rowOffset;
-    const newEndRowIndex = rowAddressToOffset(components.endRow) + rowOffset;
-    if (newStartRowIndex < rowAddressToOffset(firstRow) || newEndRowIndex > rowAddressToOffset(lastRow)) {
-        throw new InvalidArgumentError(`Row offset out of bounds: ${newStartRowIndex + 1} to ${newEndRowIndex + 1}`);
-    }
-    const newStartRow = offsetToRowAddress(newStartRowIndex);
-    const newEndRow = offsetToRowAddress(newEndRowIndex);
-    const newStartColumnIndex = columnAddressToOffset(components.startColumn) + columnOffset;
-    const newEndColumnIndex = columnAddressToOffset(components.endColumn) + columnOffset;
-    if (newStartColumnIndex < columnAddressToOffset(firstColumn) || newEndColumnIndex > columnAddressToOffset(lastColumn)) {
-        throw new InvalidArgumentError(`Column offset out of bounds: ${newStartColumnIndex + 1} to ${newEndColumnIndex + 1}`);
-    }
-    const newStartColumn = offsetToColumnAddress(newStartColumnIndex);
-    const newEndColumn = offsetToColumnAddress(newEndColumnIndex);
-    return composeAddress({
-        startColumn: newStartColumn,
-        endColumn: newEndColumn,
-        startRow: newStartRow,
-        endRow: newEndRow,
-    });
-}
-/**
- * Increments the row address by one.
- * @param address - The address to increment.
- * @returns The incremented address.
- */
-export function incrementRowAddress(address) {
-    return offsetAddress(address, 0, +1);
-}
-/**
- * Decrements the row address by one.
- * @param address - The address to decrement.
- * @returns The decremented address.
- */
-export function decrementRowAddress(address) {
-    return offsetAddress(address, 0, -1);
-}
-/**
- * Checks if two addresses overlap.
- * @param address1 - The first address.
- * @param address2 - The second address.
- * @returns True if the addresses overlap, otherwise false.
- */
-export function isAddressOverlapping(address1, address2) {
-    const components1 = decomposeAddress(address1);
-    const components2 = decomposeAddress(address2);
-    return components1.startColumn <= components2.endColumn && components1.endColumn >= components2.startColumn && rowAddressToOffset(components1.startRow) <= rowAddressToOffset(components2.endRow) && rowAddressToOffset(components1.endRow) >= rowAddressToOffset(components2.startRow);
-}
-/**
- * Checks if the address components represent a single row.
- * @param address - The address to check.
- * @returns True if the components represent a single riw, otherwise false.
- */
-export function isSingleRowAddress(address) {
-    const components = decomposeAddress(address);
-    return isSingleRow(components);
-}
-/**
- * Checks if the address components represent a single column.
- * @param address - The address to check.
- * @returns True if the components represent single columns, otherwise false.
- */
-export function isSingleColumnAddress(address) {
-    const components = decomposeAddress(address);
-    return isSingleColumn(components);
-}
-/**
- * Checks if the address components represent all columns.
- * @param address - The address to check.
- * @returns True if the components represent all columns, otherwise false.
- */
-export function isAllColumnsAddress(address) {
-    const components = decomposeAddress(address);
-    return isAllColumns(components);
-}
-/**
- * Checks if the address components represent all rows.
- * @param address - The address to check.
- * @returns True if the components represent all rows, otherwise false.
- */
-export function isAllRowsAddress(address) {
-    const components = decomposeAddress(address);
-    return isAllRows(components);
-}
-/**
- * Counts the number of rows in a given address.
- * @param address - The address to analyze.
- * @returns The number of rows in the address.
- */
-export function countAddressRows(address) {
-    const components = decomposeAddress(address);
-    return rowAddressToOffset(components.endRow) - rowAddressToOffset(components.startRow) + 1;
-}
-/**
- * Counts the number of columns in a given address.
- * @param address - The address to analyze.
- * @returns The number of columns in the address.
- */
-export function countAddressColumns(address) {
-    const components = decomposeAddress(address);
-    return columnAddressToOffset(components.endColumn) - columnAddressToOffset(components.startColumn) + 1;
-}
-function isSingleRow(components) {
-    return components.startRow === components.endRow;
-}
-function isSingleColumn(components) {
-    return components.startColumn === components.endColumn;
-}
-function isAllColumns(components) {
-    return components.startColumn === firstColumn && components.endColumn === lastColumn;
-}
-function isAllRows(components) {
-    return components.startRow === firstRow && components.endRow === lastRow;
-}
-function composeCellRangeAddress(startColumn, startRow, endColumn, endRow) {
-    return `${startColumn}${startRow}:${endColumn}${endRow}`;
-}
-function composeCellAddress(startColumn, startRow) {
-    return `${startColumn}${startRow}`;
-}
-function composeRowRangeAddress(startRow, endRow) {
-    return `${startRow}:${endRow}`;
-}
-function composeColumnRangeAddress(startColumn, endColumn) {
-    return `${startColumn}:${endColumn}`;
-}
-function composeRowAddress(startRow) {
-    return startRow;
-}
-function composeColumnAddress(startColumn) {
-    return startColumn;
-}

package/dist/services/addressManipulation.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=addressManipulation.test.d.ts.map

package/dist/services/addressManipulation.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addressManipulation.test.d.ts","sourceRoot":"","sources":["../../src/services/addressManipulation.test.ts"],"names":[],"mappings":""}

package/dist/services/addressManipulation.test.js

@@ -1,384 +0,0 @@
-import { describe, expect, it } from "vitest";
-import InvalidArgumentError from "../errors/InvalidArgumentError.js";
-import { composeAddress, countAddressColumns, countAddressRows, decomposeAddress, decrementRowAddress, getFirstCellAddress, getFirstColumnAddress, getFirstRowAddress, getLastCellAddress, getLastColumnAddress, getLastRowAddress, incrementRowAddress, isAddressOverlapping, isAllColumnsAddress, isAllRowsAddress, isSingleColumnAddress, isSingleRowAddress, offsetAddress, } from "./addressManipulation.js";
-describe("getFirstCellAddress", () => {
-    it("should return the start cell of a range address", () => {
-        expect(getFirstCellAddress("C3:D4")).toBe("C3");
-        expect(getFirstCellAddress("Sheet!A1:B2")).toBe("A1");
-        expect(getFirstCellAddress("E5")).toBe("E5"); // Single cell address
-        expect(getFirstCellAddress("Sheet!E5")).toBe("E5"); // Single cell address
-        expect(getFirstCellAddress("C")).toBe("C1"); // ColumnAddress
-        expect(getFirstCellAddress("Sheet!C")).toBe("C1"); // ColumnAddress
-        expect(getFirstCellAddress("3")).toBe("A3"); // RowAddress
-        expect(getFirstCellAddress("Sheet!3")).toBe("A3"); // RowAddress
-        expect(getFirstCellAddress("A:Z")).toBe("A1"); // ColumnRangeAddress
-        expect(getFirstCellAddress("Sheet!A:Z")).toBe("A1"); // ColumnRangeAddress
-        expect(getFirstCellAddress("1:10")).toBe("A1"); // RowRangeAddress
-        expect(getFirstCellAddress("Sheet!1:10")).toBe("A1"); // RowRangeAddress
-    });
-});
-describe("getLastCellAddress", () => {
-    it("should return the end cell of a range address", () => {
-        expect(getLastCellAddress("C3:D4")).toBe("D4");
-        expect(getLastCellAddress("Sheet!A1:B2")).toBe("B2");
-        expect(getLastCellAddress("E5")).toBe("E5"); // Single cell address
-        expect(getLastCellAddress("Sheet!E5")).toBe("E5"); // Single cell address
-        expect(getLastCellAddress("C")).toBe("C1048576"); // ColumnAddress
-        expect(getLastCellAddress("Sheet!C")).toBe("C1048576"); // ColumnAddress
-        expect(getLastCellAddress("3")).toBe("XFD3"); // RowAddress
-        expect(getLastCellAddress("Sheet!3")).toBe("XFD3"); // RowAddress
-        expect(getLastCellAddress("A:Z")).toBe("Z1048576"); // ColumnRangeAddress
-        expect(getLastCellAddress("Sheet!A:Z")).toBe("Z1048576"); // ColumnRangeAddress
-        expect(getLastCellAddress("1:10")).toBe("XFD10"); // RowRangeAddress
-        expect(getLastCellAddress("Sheet!1:10")).toBe("XFD10"); // RowRangeAddress
-    });
-});
-describe("getFirstRowAddress", () => {
-    it("should return the first row of a row range", () => {
-        expect(getFirstRowAddress("1:5")).toBe("1");
-        expect(getFirstRowAddress("Sheet!1:10")).toBe("1");
-    });
-    it("should return the first row of a column range", () => {
-        expect(getFirstRowAddress("A")).toBe("A1");
-        expect(getFirstRowAddress("A:C")).toBe("A1:C1");
-    });
-    it("should handle cell ranges", () => {
-        expect(getFirstRowAddress("A1:C5")).toBe("A1:C1");
-    });
-    it("should return the first row of a single cell address", () => {
-        expect(getFirstRowAddress("A1")).toBe("A1");
-        expect(getFirstRowAddress("Sheet!B2")).toBe("B2");
-    });
-    it("should handle cell ranges", () => {
-        expect(getFirstRowAddress("A1:C5")).toBe("A1:C1");
-    });
-    it("should return the same cell address for a single cell", () => {
-        expect(getFirstRowAddress("C1")).toBe("C1");
-    });
-});
-describe("getLastRowAddress", () => {
-    it("should return the last row of a row range", () => {
-        expect(getLastRowAddress("1:5")).toBe("5");
-        expect(getLastRowAddress("Sheet!1:10")).toBe("10");
-    });
-    it("should return the last row of a column range", () => {
-        expect(getLastRowAddress("A")).toBe("A1048576");
-        expect(getLastRowAddress("A:C")).toBe("A1048576:C1048576");
-    });
-    it("should handle cell ranges", () => {
-        expect(getLastRowAddress("A1:C5")).toBe("A5:C5");
-    });
-    it("should return the last row of a single cell address", () => {
-        expect(getLastRowAddress("A1")).toBe("A1");
-        expect(getLastRowAddress("Sheet!B2")).toBe("B2");
-    });
-    it("should handle cell ranges", () => {
-        expect(getLastRowAddress("A1:C5")).toBe("A5:C5");
-    });
-    it("should return the same cell address for a single cell", () => {
-        expect(getLastRowAddress("C1")).toBe("C1");
-    });
-});
-describe("getFirstColumnAddress", () => {
-    it("should return the first column of a column range", () => {
-        expect(getFirstColumnAddress("A:C")).toBe("A");
-        expect(getFirstColumnAddress("Sheet!A:Z")).toBe("A");
-    });
-    it("should return the first column of a row range", () => {
-        expect(getFirstColumnAddress("1")).toBe("A1");
-        expect(getFirstColumnAddress("1:5")).toBe("A1:A5");
-    });
-    it("should handle cell ranges", () => {
-        expect(getFirstColumnAddress("A1:C5")).toBe("A1:A5");
-    });
-    it("should return the first column of a single cell address", () => {
-        expect(getFirstColumnAddress("A1")).toBe("A1");
-        expect(getFirstColumnAddress("Sheet!B2")).toBe("B2");
-    });
-    it("should handle cell ranges", () => {
-        expect(getFirstColumnAddress("A1:C5")).toBe("A1:A5");
-    });
-    it("should return the same cell address for a single cell", () => {
-        expect(getFirstColumnAddress("C1")).toBe("C1");
-    });
-});
-describe("getLastColumnAddress", () => {
-    it("should return the last column of a column range", () => {
-        expect(getLastColumnAddress("A:C")).toBe("C");
-        expect(getLastColumnAddress("Sheet!A:Z")).toBe("Z");
-    });
-    it("should return the last column of a row range", () => {
-        expect(getLastColumnAddress("1")).toBe("XFD1");
-        expect(getLastColumnAddress("1:5")).toBe("XFD1:XFD5");
-    });
-    it("should handle cell ranges", () => {
-        expect(getLastColumnAddress("A1:C5")).toBe("C1:C5");
-    });
-    it("should return the last column of a single cell address", () => {
-        expect(getLastColumnAddress("A1")).toBe("A1");
-        expect(getLastColumnAddress("Sheet!B2")).toBe("B2");
-    });
-    it("should handle cell ranges", () => {
-        expect(getLastColumnAddress("A1:C5")).toBe("C1:C5");
-    });
-    it("should return the same cell address for a single cell", () => {
-        expect(getLastColumnAddress("C1")).toBe("C1");
-    });
-});
-describe("offsetAddress", () => {
-    it("should offset rows and columns in a cell range", () => {
-        expect(offsetAddress("A1:C5", 2, 2)).toBe("C3:E7");
-        expect(offsetAddress("Sheet!B2:C5", 2, 2)).toBe("D4:E7");
-    });
-    it("should offset rows only", () => {
-        expect(offsetAddress("A1:C5", 0, 2)).toBe("A3:C7");
-        expect(offsetAddress("Sheet!B1:C5", 0, 2)).toBe("B3:C7");
-    });
-    it("should offset columns only", () => {
-        expect(offsetAddress("A1:C5", 2, 0)).toBe("C1:E5");
-        expect(offsetAddress("Sheet!A2:C5", 2, 0)).toBe("C2:E5");
-    });
-    it("should throw if offset exceeds valid range", () => {
-        expect(() => offsetAddress("A1:C5", 0, 1048577)).toThrow(InvalidArgumentError);
-        expect(() => offsetAddress("A1:C5", 16385, 0)).toThrow(InvalidArgumentError);
-    });
-    it("should offset rows and columns in a single cell address", () => {
-        expect(offsetAddress("A1", 2, 2)).toBe("C3");
-        expect(offsetAddress("Sheet!B2", 2, 2)).toBe("D4");
-    });
-});
-describe("incrementRowAddress", () => {
-    it("should increment the row of a row range", () => {
-        expect(incrementRowAddress("1:5")).toBe("2:6");
-    });
-    it("should increment the row of a cell range", () => {
-        expect(incrementRowAddress("A1:C5")).toBe("A2:C6");
-    });
-});
-describe("decrementRowAddress", () => {
-    it("should decrement the row of a row range", () => {
-        expect(decrementRowAddress("2:6")).toBe("1:5");
-    });
-    it("should decrement the row of a cell range", () => {
-        expect(decrementRowAddress("A2:C6")).toBe("A1:C5");
-    });
-});
-describe("decomposeAddress", () => {
-    it("should parse a column address", () => {
-        expect(decomposeAddress("A")).toEqual({
-            startColumn: "A",
-            endColumn: "A",
-            startRow: "1",
-            endRow: "1048576",
-        });
-    });
-    it("should parse a row address", () => {
-        expect(decomposeAddress("5")).toEqual({
-            startColumn: "A",
-            endColumn: "XFD",
-            startRow: "5",
-            endRow: "5",
-        });
-    });
-    it("should parse a cell address", () => {
-        expect(decomposeAddress("B3")).toEqual({
-            startColumn: "B",
-            endColumn: "B",
-            startRow: "3",
-            endRow: "3",
-        });
-    });
-    it("should parse a column range address", () => {
-        expect(decomposeAddress("A:C")).toEqual({
-            startColumn: "A",
-            endColumn: "C",
-            startRow: "1",
-            endRow: "1048576",
-        });
-    });
-    it("should parse a row range address", () => {
-        expect(decomposeAddress("1:10")).toEqual({
-            startColumn: "A",
-            endColumn: "XFD",
-            startRow: "1",
-            endRow: "10",
-        });
-    });
-    it("should parse a cell range address", () => {
-        expect(decomposeAddress("A1:C5")).toEqual({
-            startColumn: "A",
-            endColumn: "C",
-            startRow: "1",
-            endRow: "5",
-        });
-    });
-    it("should throw an error for invalid addresses", () => {
-        expect(() => decomposeAddress("InvalidAddress")).toThrow(InvalidArgumentError);
-    });
-});
-describe("composeAddress", () => {
-    it("should create a column address", () => {
-        expect(composeAddress({
-            startColumn: "A",
-            endColumn: "A",
-            startRow: "1",
-            endRow: "1048576",
-        })).toBe("A");
-    });
-    it("should create a row address", () => {
-        expect(composeAddress({
-            startColumn: "A",
-            endColumn: "XFD",
-            startRow: "5",
-            endRow: "5",
-        })).toBe("5");
-    });
-    it("should create a cell address", () => {
-        expect(composeAddress({
-            startColumn: "B",
-            endColumn: "B",
-            startRow: "3",
-            endRow: "3",
-        })).toBe("B3");
-    });
-    it("should create a column range address", () => {
-        expect(composeAddress({
-            startColumn: "A",
-            endColumn: "C",
-            startRow: "1",
-            endRow: "1048576",
-        })).toBe("A:C");
-    });
-    it("should create a row range address", () => {
-        expect(composeAddress({
-            startColumn: "A",
-            endColumn: "XFD",
-            startRow: "1",
-            endRow: "10",
-        })).toBe("1:10");
-    });
-    it("should create a cell range address", () => {
-        expect(composeAddress({
-            startColumn: "A",
-            endColumn: "C",
-            startRow: "1",
-            endRow: "5",
-        })).toBe("A1:C5");
-    });
-    it("should throw an error for invalid address components", () => {
-        expect(() => composeAddress({
-            startColumn: "C",
-            endColumn: "A",
-            startRow: "5",
-            endRow: "1",
-        })).toThrow(InvalidArgumentError);
-    });
-});
-describe("isAddressOverlapping", () => {
-    it("should return true for overlapping cell ranges", () => {
-        expect(isAddressOverlapping("A1:C3", "B2:D4")).toBe(true);
-        expect(isAddressOverlapping("A1:B2", "A1:B2")).toBe(true); // Exact overlap
-        expect(isAddressOverlapping("A1:D4", "B2:C3")).toBe(true); // Nested overlap
-    });
-    it("should return false for non-overlapping cell ranges", () => {
-        expect(isAddressOverlapping("A1:B2", "C3:D4")).toBe(false);
-        expect(isAddressOverlapping("A1:A1", "B1:B1")).toBe(false);
-        expect(isAddressOverlapping("A1:A10", "B11:B20")).toBe(false);
-    });
-    it("should return true for overlapping row ranges", () => {
-        expect(isAddressOverlapping("1:5", "3:7")).toBe(true);
-        expect(isAddressOverlapping("1:10", "5:15")).toBe(true);
-    });
-    it("should return false for non-overlapping row ranges", () => {
-        expect(isAddressOverlapping("1:5", "6:10")).toBe(false);
-        expect(isAddressOverlapping("1:1", "2:2")).toBe(false);
-    });
-    it("should return true for overlapping column ranges", () => {
-        expect(isAddressOverlapping("A:C", "B:D")).toBe(true);
-        expect(isAddressOverlapping("A:Z", "M:N")).toBe(true);
-    });
-    it("should return false for non-overlapping column ranges", () => {
-        expect(isAddressOverlapping("A:C", "D:F")).toBe(false);
-        expect(isAddressOverlapping("A:A", "B:B")).toBe(false);
-    });
-    it("should handle single cell addresses", () => {
-        expect(isAddressOverlapping("A1", "A1")).toBe(true); // Exact match
-        expect(isAddressOverlapping("A1", "B2")).toBe(false); // No overlap
-        expect(isAddressOverlapping("A1", "A2")).toBe(false); // Different rows
-        expect(isAddressOverlapping("A1", "B1")).toBe(false); // Different columns
-    });
-});
-describe("isSingleRowAddress", () => {
-    it("should return true for single row addresses", () => {
-        expect(isSingleRowAddress("1")).toBe(true);
-        expect(isSingleRowAddress("A1:A1")).toBe(true);
-    });
-    it("should return false for multi-row addresses", () => {
-        expect(isSingleRowAddress("1:2")).toBe(false);
-        expect(isSingleRowAddress("A1:A2")).toBe(false);
-    });
-});
-describe("isSingleColumnAddress", () => {
-    it("should return true for single column addresses", () => {
-        expect(isSingleColumnAddress("A")).toBe(true);
-        expect(isSingleColumnAddress("A1:A1")).toBe(true);
-    });
-    it("should return false for multi-column addresses", () => {
-        expect(isSingleColumnAddress("A:B")).toBe(false);
-        expect(isSingleColumnAddress("A1:B1")).toBe(false);
-    });
-});
-describe("isAllColumnsAddress", () => {
-    it("should return true for addresses spanning all columns", () => {
-        expect(isAllColumnsAddress("1")).toBe(true);
-        expect(isAllColumnsAddress("1:10")).toBe(true);
-    });
-    it("should return false for addresses not spanning all columns", () => {
-        expect(isAllColumnsAddress("A")).toBe(false);
-        expect(isAllColumnsAddress("A1:B1")).toBe(false);
-    });
-});
-describe("isAllRowsAddress", () => {
-    it("should return true for addresses spanning all rows", () => {
-        expect(isAllRowsAddress("A")).toBe(true);
-        expect(isAllRowsAddress("A:C")).toBe(true);
-    });
-    it("should return false for addresses not spanning all rows", () => {
-        expect(isAllRowsAddress("1")).toBe(false);
-        expect(isAllRowsAddress("A1:A10")).toBe(false);
-    });
-});
-describe("countAddressRows", () => {
-    it("should return the correct number of rows for a cell range", () => {
-        expect(countAddressRows("A1:C5")).toBe(5);
-    });
-    it("should return the correct number of rows for a row range", () => {
-        expect(countAddressRows("1:5")).toBe(5);
-    });
-    it("should return 1 for a single cell address", () => {
-        expect(countAddressRows("A1")).toBe(1);
-    });
-    it("should return the correct number of rows for a column address", () => {
-        expect(countAddressRows("A")).toBe(1048576);
-    });
-    it("should return the correct number of rows for a column range address", () => {
-        expect(countAddressRows("A:C")).toBe(1048576);
-    });
-});
-describe("countAddressColumns", () => {
-    it("should return the correct number of columns for a cell range", () => {
-        expect(countAddressColumns("A1:C5")).toBe(3);
-    });
-    it("should return the correct number of columns for a column range", () => {
-        expect(countAddressColumns("A:C")).toBe(3);
-    });
-    it("should return 1 for a single cell address", () => {
-        expect(countAddressColumns("A1")).toBe(1);
-    });
-    it("should return the correct number of columns for a row address", () => {
-        expect(countAddressColumns("1")).toBe(16384);
-    });
-    it("should return the correct number of columns for a row range address", () => {
-        expect(countAddressColumns("1:5")).toBe(16384);
-    });
-});