microsoft-graph 2.2.5 → 2.3.1

package/dist/services/addressManipulation.js

@@ -0,0 +1,226 @@
+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) && isMaxRows(components)) {
+        return composeColumnAddress(components.startColumn);
+    }
+    if (isSingleRow(components) && isMaxColumns(components)) {
+        return composeRowAddress(components.startRow);
+    }
+    if (isMaxRows(components)) {
+        return composeColumnRangeAddress(components.startColumn, components.endColumn);
+    }
+    if (isMaxColumns(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 (isMaxRows(components) && rowOffset !== 0) {
+        throw new UnsupportedAddressTypeError("All rows are selected. Cannot offset rows.");
+    }
+    if (isMaxColumns(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);
+}
+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;
+}
+function isSingleRow(components) {
+    return components.startRow === components.endRow;
+}
+function isSingleColumn(components) {
+    return components.startColumn === components.endColumn;
+}
+function isMaxColumns(components) {
+    return components.startColumn === firstColumn && components.endColumn === lastColumn;
+}
+function isMaxRows(components) {
+    return components.startRow === firstRow && components.endRow === lastRow;
+}

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

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

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

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

package/dist/services/addressManipulation.test.js

@@ -0,0 +1,310 @@
+import { describe, expect, it } from "vitest";
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+import { composeAddress, decomposeAddress, decrementRowAddress, getFirstCellAddress, getFirstColumnAddress, getFirstRowAddress, getLastCellAddress, getLastColumnAddress, getLastRowAddress, incrementRowAddress, isAddressOverlapping, 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
+    });
+});

package/dist/services/addressOffset.d.ts

@@ -0,0 +1,28 @@
+import type { ColumnAddress, RowAddress } from "../models/Address.ts";
+import type { ColumnOffset } from "../models/ColumnOffset.ts";
+import type { RowOffset } from "../models/RowOffset.ts";
+/**
+ * Converts a column address (e.g., "A") to a zero-based column offset.
+ * @param column - The column address.
+ * @returns The zero-based column offset.
+ */
+export declare function columnAddressToOffset(column: ColumnAddress): ColumnOffset;
+/**
+ * Converts a zero-based column offset to a column address (e.g., "A").
+ * @param offset - The zero-based column offset.
+ * @returns The column address.
+ */
+export declare function offsetToColumnAddress(offset: ColumnOffset): ColumnAddress;
+/**
+ * Converts a row address (e.g., "1") to a zero-based row offset.
+ * @param row - The row address.
+ * @returns The zero-based row offset.
+ */
+export declare function rowAddressToOffset(row: RowAddress): RowOffset;
+/**
+ * Converts a zero-based row offset to a row address (e.g., "1").
+ * @param offset - The zero-based row offset.
+ * @returns The row address.
+ */
+export declare function offsetToRowAddress(offset: RowOffset): RowAddress;
+//# sourceMappingURL=addressOffset.d.ts.map

package/dist/services/addressOffset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressOffset.d.ts","sourceRoot":"","sources":["../../src/services/addressOffset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY,CAMzE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,CASzE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAEhE"}

package/dist/services/addressOffset.js

@@ -0,0 +1,43 @@
+/**
+ * Converts a column address (e.g., "A") to a zero-based column offset.
+ * @param column - The column address.
+ * @returns The zero-based column offset.
+ */
+export function columnAddressToOffset(column) {
+    let offset = 0;
+    for (let i = 0; i < column.length; i++) {
+        offset = offset * 26 + (column.charCodeAt(i) - 65 + 1);
+    }
+    return (offset - 1);
+}
+/**
+ * Converts a zero-based column offset to a column address (e.g., "A").
+ * @param offset - The zero-based column offset.
+ * @returns The column address.
+ */
+export function offsetToColumnAddress(offset) {
+    let result = "";
+    let currentOffset = offset + 1;
+    while (currentOffset > 0) {
+        currentOffset -= 1;
+        result = String.fromCharCode((currentOffset % 26) + 65) + result;
+        currentOffset = Math.floor(currentOffset / 26);
+    }
+    return result;
+}
+/**
+ * Converts a row address (e.g., "1") to a zero-based row offset.
+ * @param row - The row address.
+ * @returns The zero-based row offset.
+ */
+export function rowAddressToOffset(row) {
+    return (Number.parseInt(row, 10) - 1);
+}
+/**
+ * Converts a zero-based row offset to a row address (e.g., "1").
+ * @param offset - The zero-based row offset.
+ * @returns The row address.
+ */
+export function offsetToRowAddress(offset) {
+    return (offset + 1).toString();
+}

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

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

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

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

package/dist/services/addressOffset.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { columnAddressToOffset, offsetToColumnAddress, offsetToRowAddress, rowAddressToOffset } from "./addressOffset.js";
+describe("columnAddressToOffset", () => {
+    it("should convert column address to offset", () => {
+        expect(columnAddressToOffset("A")).toBe(0);
+        expect(columnAddressToOffset("B")).toBe(1);
+        expect(columnAddressToOffset("Z")).toBe(25);
+        expect(columnAddressToOffset("AA")).toBe(26);
+        expect(columnAddressToOffset("AB")).toBe(27);
+        expect(columnAddressToOffset("AZ")).toBe(51);
+        expect(columnAddressToOffset("BA")).toBe(52);
+    });
+});
+describe("offsetToColumnAddress", () => {
+    it("should convert offset to column address", () => {
+        expect(offsetToColumnAddress(0)).toBe("A");
+        expect(offsetToColumnAddress(1)).toBe("B");
+        expect(offsetToColumnAddress(25)).toBe("Z");
+        expect(offsetToColumnAddress(26)).toBe("AA");
+        expect(offsetToColumnAddress(27)).toBe("AB");
+        expect(offsetToColumnAddress(51)).toBe("AZ");
+        expect(offsetToColumnAddress(52)).toBe("BA");
+    });
+});
+describe("rowAddressToOffset", () => {
+    it("should convert row address to offset", () => {
+        expect(rowAddressToOffset("1")).toBe(0);
+        expect(rowAddressToOffset("2")).toBe(1);
+        expect(rowAddressToOffset("10")).toBe(9);
+    });
+});
+describe("offsetToRowAddress", () => {
+    it("should convert offset to row address", () => {
+        expect(offsetToRowAddress(0)).toBe("1");
+        expect(offsetToRowAddress(1)).toBe("2");
+        expect(offsetToRowAddress(9)).toBe("10");
+    });
+});