microsoft-graph 2.6.0 → 2.7.0

package/dist/esm/operations/workbookWorksheet/updateWorkbookWorksheet.js

@@ -0,0 +1,32 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/**
+ * Update the name, position, and/or visibility of a worksheet.
+ *
+ * @param worksheetRef - A reference to the worksheet to be updated, optionally including session information.
+ * @param updates - An object containing the properties to update:
+ *   - `name` (optional): The new name for the worksheet.
+ *   - `position` (optional): The new position of the worksheet in the workbook.
+ *   - `visibility` (optional): The visibility state of the worksheet. Can be "Visible", "Hidden", or "VeryHidden".
+ * @returns The updated worksheet, including its reference information.
+ * @see https://learn.microsoft.com/en-us/graph/api/worksheet-update
+ */
+export default function updateWorkbookWorksheet(worksheetRef, updates) {
+    return operation({
+        contextId: worksheetRef.contextId,
+        method: "PATCH",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}", worksheetRef),
+        headers: {
+            "workbook-session-id": worksheetRef.sessionId,
+            "content-type": "application/json",
+        },
+        body: updates,
+        responseTransform: (response) => {
+            const worksheet = response;
+            return {
+                ...worksheet,
+                ...worksheetRef,
+            };
+        },
+    });
+}

package/dist/esm/operations/workbookWorksheet/updateWorkbookWorksheet.test.d.ts

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

package/dist/esm/operations/workbookWorksheet/updateWorkbookWorksheet.test.d.ts.map

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

package/dist/esm/operations/workbookWorksheet/updateWorkbookWorksheet.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import { createDefaultWorkbookWorksheetRef } from "../../services/workbookWorksheet.js";
+import getWorkbookWorksheetByName from "../../tasks/getWorkbookWorksheetByName.js";
+import tryDeleteDriveItem from "../../tasks/tryDeleteDriveItem.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import createWorkbookWorksheet from "./createWorkbookWorksheet.js";
+import updateWorkbookWorksheet from "./updateWorkbookWorksheet.js";
+describe("updateWorkbookWorksheet", () => {
+    it("can update the name of an existing worksheet", async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(getDefaultDriveRef(), workbookPath);
+        try {
+            const worksheetRef = createDefaultWorkbookWorksheetRef(workbook);
+            const newName = "UpdatedSheet";
+            await updateWorkbookWorksheet(worksheetRef, { name: newName });
+            await calculateWorkbook(workbook);
+            const updatedWorksheet = await getWorkbookWorksheetByName(workbook, newName);
+            expect(updatedWorksheet.name).toBe(newName);
+        }
+        finally {
+            await tryDeleteDriveItem(workbook);
+        }
+    });
+    it("can update the visibility of an existing worksheet", async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(getDefaultDriveRef(), workbookPath);
+        try {
+            const worksheetName = "Sheet2";
+            const worksheet = await createWorkbookWorksheet(workbook); // Can't hide the single worksheet
+            await updateWorkbookWorksheet(worksheet, { visibility: "Hidden" });
+            const updatedWorksheet = await getWorkbookWorksheetByName(worksheet, worksheetName);
+            expect(updatedWorksheet.visibility).toBe("Hidden");
+        }
+        finally {
+            await tryDeleteDriveItem(workbook);
+        }
+    });
+});

package/dist/esm/services/accessToken.d.ts

@@ -0,0 +1,16 @@
+import type { AccessToken } from "../models/AccessToken.ts";
+import type { ClientId } from "../models/ClientId.ts";
+import type { ClientSecret } from "../models/ClientSecret.ts";
+import type { Scope } from "../models/Scope.ts";
+import type { TenantId } from "../models/TenantId.ts";
+/**
+ * Retrieves the current access token for a given client and scope.
+ * If a valid token is cached, it will be returned; otherwise, a new token will be requested.
+ * @param tenantId - The tenant ID.
+ * @param clientId - The client ID.
+ * @param clientSecret - The client secret.
+ * @param scope - The scope for which the token is requested.
+ * @returns A promise that resolves to the access token.
+ */
+export declare function getCurrentAccessToken(tenantId: TenantId, clientId: ClientId, clientSecret: ClientSecret, scope: Scope): Promise<AccessToken>;
+//# sourceMappingURL=accessToken.d.ts.map

package/dist/esm/services/accessToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessToken.d.ts","sourceRoot":"","sources":["../../../src/services/accessToken.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItD;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,CAWlJ"}

package/dist/esm/services/accessToken.js

@@ -0,0 +1,23 @@
+import { ClientSecretCredential } from "@azure/identity";
+const innerTokenCache = {};
+/**
+ * Retrieves the current access token for a given client and scope.
+ * If a valid token is cached, it will be returned; otherwise, a new token will be requested.
+ * @param tenantId - The tenant ID.
+ * @param clientId - The client ID.
+ * @param clientSecret - The client secret.
+ * @param scope - The scope for which the token is requested.
+ * @returns A promise that resolves to the access token.
+ */
+export async function getCurrentAccessToken(tenantId, clientId, clientSecret, scope) {
+    const cacheKey = createCacheKey(tenantId, clientId, scope);
+    let innerToken = innerTokenCache[cacheKey];
+    if (!innerToken || innerToken.expiresOnTimestamp < Date.now()) {
+        const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
+        innerTokenCache[cacheKey] = innerToken = await credential.getToken(scope);
+    }
+    return innerToken.token;
+}
+function createCacheKey(tenantId, clientId, scope) {
+    return `${tenantId}/${clientId}/${scope}`;
+}

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

@@ -0,0 +1,123 @@
+import type { Address, CellAddress, ColumnAddress, RowAddress } from "../models/Address.ts";
+export type AddressComponents = {
+    startColumn: ColumnAddress;
+    endColumn: ColumnAddress;
+    startRow: RowAddress;
+    endRow: RowAddress;
+};
+/**
+ * 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 declare function decomposeAddress(address: Address): AddressComponents;
+/**
+ * Composes an address from its components.
+ * @param components - The address components.
+ * @returns The composed address.
+ * @throws InvalidArgumentError if the components are invalid.
+ */
+export declare function composeAddress(components: AddressComponents): Address;
+/**
+ * Gets the first cell address from a given address.
+ * @param address - The address to analyze.
+ * @returns The first cell address.
+ */
+export declare function getFirstCellAddress(address: Address): CellAddress;
+/**
+ * Gets the last cell address from a given address.
+ * @param address - The address to analyze.
+ * @returns The last cell address.
+ */
+export declare function getLastCellAddress(address: Address): CellAddress;
+/**
+ * Gets the first row address from a given address.
+ * @param address - The address to analyze.
+ * @returns The first row address.
+ */
+export declare function getFirstRowAddress(address: Address): Address;
+/**
+ * Gets the last row address from a given address.
+ * @param address - The address to analyze.
+ * @returns The last row address.
+ */
+export declare function getLastRowAddress(address: Address): Address;
+/**
+ * Gets the first column address from a given address.
+ * @param address - The address to analyze.
+ * @returns The first column address.
+ */
+export declare function getFirstColumnAddress(address: Address): Address;
+/**
+ * Gets the last column address from a given address.
+ * @param address - The address to analyze.
+ * @returns The last column address.
+ */
+export declare function getLastColumnAddress(address: Address): Address;
+/**
+ * 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 declare function offsetAddress(address: Address, columnOffset: number, rowOffset: number): Address;
+/**
+ * Increments the row address by one.
+ * @param address - The address to increment.
+ * @returns The incremented address.
+ */
+export declare function incrementRowAddress(address: Address): Address;
+/**
+ * Decrements the row address by one.
+ * @param address - The address to decrement.
+ * @returns The decremented address.
+ */
+export declare function decrementRowAddress(address: Address): Address;
+/**
+ * Checks if two addresses overlap.
+ * @param address1 - The first address.
+ * @param address2 - The second address.
+ * @returns True if the addresses overlap, otherwise false.
+ */
+export declare function isAddressOverlapping(address1: Address, address2: Address): boolean;
+/**
+ * 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 declare function isSingleRowAddress(address: Address): boolean;
+/**
+ * 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 declare function isSingleColumnAddress(address: Address): boolean;
+/**
+ * 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 declare function isAllColumnsAddress(address: Address): boolean;
+/**
+ * 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 declare function isAllRowsAddress(address: Address): boolean;
+/**
+ * Counts the number of rows in a given address.
+ * @param address - The address to analyze.
+ * @returns The number of rows in the address.
+ */
+export declare function countAddressRows(address: Address): number;
+/**
+ * Counts the number of columns in a given address.
+ * @param address - The address to analyze.
+ * @returns The number of columns in the address.
+ */
+export declare function countAddressColumns(address: Address): number;
+//# sourceMappingURL=addressManipulation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addressManipulation.d.ts","sourceRoot":"","sources":["../../../src/services/addressManipulation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAoB,aAAa,EAAsB,UAAU,EAAmB,MAAM,sBAAsB,CAAC;AAmBnJ,MAAM,MAAM,iBAAiB,GAAG;IAC/B,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,QAAQ,EAAE,UAAU,CAAC;IACrB,MAAM,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAcpE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CA6BrE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAGhE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS5D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS3D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS/D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAqChG;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAKlF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG5D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG/D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG7D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG1D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAGzD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAG5D"}

package/dist/esm/services/addressManipulation.js

@@ -0,0 +1,280 @@
+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/esm/services/addressManipulation.test.d.ts

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

package/dist/esm/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":""}