microsoft-graph 2.7.0 → 2.7.2

package/dist/cjs/services/templatedPaths.js

@@ -1,5 +1,11 @@
-import BadTemplateError from "../errors/BadTemplateError.js";
-import { kebabToCamelCase } from "./stringCaseConversion.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePath = generatePath;
+const BadTemplateError_ts_1 = __importDefault(require("../errors/BadTemplateError.js"));
+const stringCaseConversion_ts_1 = require("./stringCaseConversion.js");
 const argumentPattern = /\{([a-z-]+)\}/g;
 /**
  * Generates a HTTP path based on a template and arguments. Arguments are automatically escaped.
@@ -8,18 +14,18 @@ const argumentPattern = /\{([a-z-]+)\}/g;
  * @returns The generated Graph API path.
  * @throws BadTemplateError if the template is invalid or required arguments are missing.
  */
-export function generatePath(template, args) {
+function generatePath(template, args) {
     if (!template.startsWith("/")) {
-        throw new BadTemplateError(`Path template '${template}' must start with a slash.`);
+        throw new BadTemplateError_ts_1.default(`Path template '${template}' must start with a slash.`);
     }
     if (template.includes("\n")) {
-        throw new BadTemplateError("Path template must not contain newlines.");
+        throw new BadTemplateError_ts_1.default("Path template must not contain newlines.");
     }
     return template.replace(argumentPattern, (_, match) => {
-        const camelCaseKey = kebabToCamelCase(match);
+        const camelCaseKey = (0, stringCaseConversion_ts_1.kebabToCamelCase)(match);
         const value = args[camelCaseKey];
         if (value === undefined) {
-            throw new BadTemplateError(`Path template references argument '${camelCaseKey}' however no such argument provided.`);
+            throw new BadTemplateError_ts_1.default(`Path template references argument '${camelCaseKey}' however no such argument provided.`);
         }
         return encodeURIComponent(value);
     });

package/dist/cjs/services/templatedPaths.test.js

@@ -1,49 +1,54 @@
-import { describe, expect, it } from "vitest";
-import BadTemplateError from "../errors/BadTemplateError.js";
-import { generatePath } from "./templatedPaths.js";
-describe("generatePath", () => {
-    it("should generate a valid path with correct arguments", () => {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const BadTemplateError_ts_1 = __importDefault(require("../errors/BadTemplateError.js"));
+const templatedPaths_ts_1 = require("./templatedPaths.js");
+(0, vitest_1.describe)("generatePath", () => {
+    (0, vitest_1.it)("should generate a valid path with correct arguments", () => {
         const template = "/me/drive/items/{item-id}/children";
         const args = { itemId: "123" };
-        const result = generatePath(template, args);
-        expect(result).toBe("/me/drive/items/123/children");
+        const result = (0, templatedPaths_ts_1.generatePath)(template, args);
+        (0, vitest_1.expect)(result).toBe("/me/drive/items/123/children");
     });
-    it("should throw BadTemplateError if template does not start with a slash", () => {
+    (0, vitest_1.it)("should throw BadTemplateError if template does not start with a slash", () => {
         const template = "me/drive/items/{item-id}/children";
         const args = { itemId: "123" };
-        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+        (0, vitest_1.expect)(() => (0, templatedPaths_ts_1.generatePath)(template, args)).toThrow(BadTemplateError_ts_1.default);
     });
-    it("should throw BadTemplateError if template contains newlines", () => {
+    (0, vitest_1.it)("should throw BadTemplateError if template contains newlines", () => {
         const template = "/me/drive/items/{item-id}/children\n";
         const args = { itemId: "123" };
-        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+        (0, vitest_1.expect)(() => (0, templatedPaths_ts_1.generatePath)(template, args)).toThrow(BadTemplateError_ts_1.default);
     });
-    it("should throw BadTemplateError if argument is missing", () => {
+    (0, vitest_1.it)("should throw BadTemplateError if argument is missing", () => {
         const template = "/me/drive/items/{item-id}/children";
         const args = {};
-        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+        (0, vitest_1.expect)(() => (0, templatedPaths_ts_1.generatePath)(template, args)).toThrow(BadTemplateError_ts_1.default);
     });
-    it("should encode URI components", () => {
+    (0, vitest_1.it)("should encode URI components", () => {
         const template = "/me/drive/items/{item-id}/children";
         const args = { itemId: "item name with spaces" };
-        const result = generatePath(template, args);
-        expect(result).toBe("/me/drive/items/item%20name%20with%20spaces/children");
+        const result = (0, templatedPaths_ts_1.generatePath)(template, args);
+        (0, vitest_1.expect)(result).toBe("/me/drive/items/item%20name%20with%20spaces/children");
     });
-    it("should generate a valid path when the same argument is used twice", () => {
+    (0, vitest_1.it)("should generate a valid path when the same argument is used twice", () => {
         const template = "/me/drive/items/{item-id}/children/{item-id}";
         const args = { itemId: "123" };
-        const result = generatePath(template, args);
-        expect(result).toBe("/me/drive/items/123/children/123");
+        const result = (0, templatedPaths_ts_1.generatePath)(template, args);
+        (0, vitest_1.expect)(result).toBe("/me/drive/items/123/children/123");
     });
-    it("should throw BadTemplateError if template has an argument that is not matched", () => {
+    (0, vitest_1.it)("should throw BadTemplateError if template has an argument that is not matched", () => {
         const template = "/me/drive/items/{item-id}/children/{child-id}";
         const args = { itemId: "123" };
-        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+        (0, vitest_1.expect)(() => (0, templatedPaths_ts_1.generatePath)(template, args)).toThrow(BadTemplateError_ts_1.default);
     });
-    it("should generate a valid path with multiple arguments", () => {
+    (0, vitest_1.it)("should generate a valid path with multiple arguments", () => {
         const template = "/users/{user-id}/messages/{message-id}/attachments/{attachment-id}";
         const args = { userId: "user123", messageId: "msg456", attachmentId: "att789" };
-        const result = generatePath(template, args);
-        expect(result).toBe("/users/user123/messages/msg456/attachments/att789");
+        const result = (0, templatedPaths_ts_1.generatePath)(template, args);
+        (0, vitest_1.expect)(result).toBe("/users/user123/messages/msg456/attachments/att789");
     });
 });

package/dist/cjs/services/temporaryFiles.js

@@ -1,10 +1,13 @@
-import { generateRandomString } from "./random.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTempFileName = generateTempFileName;
+const random_ts_1 = require("./random.js");
 /**
  * Generates a temporary file name with the specified extension.
  * @param extension - The file extension. Defaults to "tmp".
  * @returns A temporary file name.
  */
-export function generateTempFileName(extension = "tmp") {
-    const body = generateRandomString(16);
+function generateTempFileName(extension = "tmp") {
+    const body = (0, random_ts_1.generateRandomString)(16);
     return `~${body}.${extension}`;
 }

package/dist/cjs/services/workbookRange.js

@@ -1,10 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkbookRangeRef = createWorkbookRangeRef;
 /**
  * Creates a reference to a workbook range.
  * @param worksheetRef - The reference to the worksheet containing the range.
  * @param address - The address of the range.
  * @returns A reference to the workbook range.
  */
-export function createWorkbookRangeRef(worksheetRef, address) {
+function createWorkbookRangeRef(worksheetRef, address) {
     return {
         contextId: worksheetRef.contextId,
         siteId: worksheetRef.siteId,

package/dist/cjs/services/workbookTable.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkbookTableRef = createWorkbookTableRef;
 /**
  * Creates a reference to a workbook table.
  * @param worksheetRef - The reference to the worksheet containing the table.
@@ -5,7 +8,7 @@
  * @returns A reference to the workbook table.
  * @throws Error if the table ID is missing.
  */
-export function createWorkbookTableRef(worksheetRef, tableId) {
+function createWorkbookTableRef(worksheetRef, tableId) {
     if (!tableId) {
         throw new Error("TableId is missing");
     }

package/dist/cjs/services/workbookTableColumn.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkbookTableColumnRef = createWorkbookTableColumnRef;
 /**
  * Creates a reference to a workbook table column.
  * @param tableRef - The reference to the worksheet containing the table.
@@ -5,7 +8,7 @@
  * @returns A reference to the workbook table.
  * @throws Error if the table ID is missing.
  */
-export function createWorkbookTableColumnRef(tableRef, column) {
+function createWorkbookTableColumnRef(tableRef, column) {
     if (!column) {
         throw new Error("TableId is missing");
     }

package/dist/cjs/services/workbookWorksheet.js

@@ -1,4 +1,9 @@
-export const defaultWorkbookWorksheetId = "{00000000-0001-0000-0000-000000000000}"; // Program Manager in Microsoft Office Extensibility team says this ID is used for the first sheet of all workbooks by design, but not documented. https://github.com/OfficeDev/office-js/issues/552#issuecomment-800841930
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultWorkbookWorksheetId = void 0;
+exports.createWorkbookWorksheetRef = createWorkbookWorksheetRef;
+exports.createDefaultWorkbookWorksheetRef = createDefaultWorkbookWorksheetRef;
+exports.defaultWorkbookWorksheetId = "{00000000-0001-0000-0000-000000000000}"; // Program Manager in Microsoft Office Extensibility team says this ID is used for the first sheet of all workbooks by design, but not documented. https://github.com/OfficeDev/office-js/issues/552#issuecomment-800841930
 /**
  * Creates a reference to a workbook worksheet.
  * @param workbookRef - The reference to the workbook.
@@ -6,7 +11,7 @@ export const defaultWorkbookWorksheetId = "{00000000-0001-0000-0000-000000000000
  * @returns A reference to the workbook worksheet.
  * @throws Error if the worksheet ID is missing.
  */
-export function createWorkbookWorksheetRef(workbookRef, worksheetId) {
+function createWorkbookWorksheetRef(workbookRef, worksheetId) {
     if (!worksheetId) {
         throw new Error("WorksheetID is missing");
     }
@@ -24,6 +29,6 @@ export function createWorkbookWorksheetRef(workbookRef, worksheetId) {
  * @param workbookRef - The reference to the workbook.
  * @returns A reference to the default workbook worksheet.
  */
-export function createDefaultWorkbookWorksheetRef(workbookRef) {
-    return createWorkbookWorksheetRef(workbookRef, defaultWorkbookWorksheetId);
+function createDefaultWorkbookWorksheetRef(workbookRef) {
+    return createWorkbookWorksheetRef(workbookRef, exports.defaultWorkbookWorksheetId);
 }

package/dist/cjs/tasks/createWorkbookAndStartSession.js

@@ -1,5 +1,11 @@
-import createWorkbook from "../operations/workbook/createWorkbook.js";
-import createWorkbookSession from "../operations/workbookSession/createWorkbookSession.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createWorkbookAndStartSession;
+const createWorkbook_ts_1 = __importDefault(require("../operations/workbook/createWorkbook.js"));
+const createWorkbookSession_ts_1 = __importDefault(require("../operations/workbookSession/createWorkbookSession.js"));
 /**
  * Create a new workbook and open a session for that workbook in a single operation.
  *
@@ -7,9 +13,9 @@ import createWorkbookSession from "../operations/workbookSession/createWorkbookS
  * @param itemPath - The path of the new workbook within the drive.
  * @returns The created workbook and session details.
  */
-export default async function createWorkbookAndStartSession(driveRef, itemPath) {
-    const workbook = await createWorkbook(driveRef, itemPath);
-    const workbookRef = await createWorkbookSession(workbook);
+async function createWorkbookAndStartSession(driveRef, itemPath) {
+    const workbook = await (0, createWorkbook_ts_1.default)(driveRef, itemPath);
+    const workbookRef = await (0, createWorkbookSession_ts_1.default)(workbook);
     return {
         ...workbook,
         ...workbookRef,

package/dist/cjs/tasks/deleteDriveItemWithRetry.js

@@ -1,21 +1,27 @@
-import deleteDriveItem from "../operations/driveItem/deleteDriveItem.js";
-import { sleep } from "../services/sleep.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = deleteDriveItemWithRetry;
+const deleteDriveItem_ts_1 = __importDefault(require("../operations/driveItem/deleteDriveItem.js"));
+const sleep_ts_1 = require("../services/sleep.js");
 /**
  * Delete a DriveItem, avoiding locking issues through automatic retries.
  *
  * @param driveItemRef - A reference to the DriveItem to delete.
  * @returns Void when the DriveItem is successfully deleted.
  */
-export default async function deleteDriveItemWithRetry(driveItemRef) {
+async function deleteDriveItemWithRetry(driveItemRef) {
     const retryDelays = [1000, 2000, 4000];
     for (const delay of retryDelays) {
         try {
-            await deleteDriveItem(driveItemRef);
+            await (0, deleteDriveItem_ts_1.default)(driveItemRef);
             return;
         }
         catch (_) {
-            await sleep(delay);
+            await (0, sleep_ts_1.sleep)(delay);
         }
     }
-    await deleteDriveItem(driveItemRef);
+    await (0, deleteDriveItem_ts_1.default)(driveItemRef);
 }

package/dist/cjs/tasks/downloadDriveItemContent.js

@@ -1,5 +1,11 @@
-import { writeFile } from "node:fs/promises";
-import getDriveItemContent from "../operations/driveItem/getDriveItemContent.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = downloadDriveItemContent;
+const promises_1 = require("node:fs/promises");
+const getDriveItemContent_ts_1 = __importDefault(require("../operations/driveItem/getDriveItemContent.js"));
 /**
  * Download a DriveItem and save it as a local file.
  *
@@ -7,8 +13,8 @@ import getDriveItemContent from "../operations/driveItem/getDriveItemContent.js"
  * @param localFilePath - The local file path where the content should be saved.
  * @returns Void when the content is successfully downloaded and saved.
  */
-export default async function downloadDriveItemContent(itemRef, localFilePath) {
-    const arrayBuffer = await getDriveItemContent(itemRef);
+async function downloadDriveItemContent(itemRef, localFilePath) {
+    const arrayBuffer = await (0, getDriveItemContent_ts_1.default)(itemRef);
     const buffer = Buffer.from(arrayBuffer);
-    await writeFile(localFilePath, buffer);
+    await (0, promises_1.writeFile)(localFilePath, buffer);
 }

package/dist/cjs/tasks/getRangeLastUsedCell.js

@@ -1,6 +1,12 @@
-import ProtocolError from "../errors/ProtocolError.js";
-import getWorkbookWorksheetRange from "../operations/workbookRange/getWorkbookWorksheetRange.js";
-import { getFirstCellAddress, offsetAddress } from "../services/addressManipulation.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getRangeLastUsedCell;
+const ProtocolError_ts_1 = __importDefault(require("../errors/ProtocolError.js"));
+const getWorkbookWorksheetRange_ts_1 = __importDefault(require("../operations/workbookRange/getWorkbookWorksheetRange.js"));
+const addressManipulation_ts_1 = require("../services/addressManipulation.js");
 /**
  * Get the last used cell (i.e., the most lower-right cell) in a given range.
  *
@@ -8,31 +14,31 @@ import { getFirstCellAddress, offsetAddress } from "../services/addressManipulat
  * @throws {ProtocolError} If the range's row or column counts, or values, are missing.
  * @returns The last used cell's value and address, or `null` if no cells are used.
  */
-export default async function getRangeLastUsedCell(rangeRef) {
+async function getRangeLastUsedCell(rangeRef) {
     // TODO: Consider adding chunking if the range is too large
     // TODO: Reduce cells returned by using "used range"?
-    const range = await getWorkbookWorksheetRange(rangeRef);
+    const range = await (0, getWorkbookWorksheetRange_ts_1.default)(rangeRef);
     const { rowCount, columnCount } = range;
     if (rowCount === undefined || columnCount === undefined) {
-        throw new ProtocolError("Counts missing");
+        throw new ProtocolError_ts_1.default("Counts missing");
     }
     const values = range.values;
     if (values === undefined) {
-        throw new ProtocolError("Range values missing");
+        throw new ProtocolError_ts_1.default("Range values missing");
     }
     for (let rowIndex = (rowCount - 1); rowIndex >= 0; rowIndex--) {
         const row = values[rowIndex];
         if (row === undefined) {
-            throw new ProtocolError("Row missing");
+            throw new ProtocolError_ts_1.default("Row missing");
         }
         for (let columnIndex = (columnCount - 1); columnIndex >= 0; columnIndex--) {
             const cell = row[columnIndex];
             if (cell === undefined) {
-                throw new ProtocolError("Cell missing");
+                throw new ProtocolError_ts_1.default("Cell missing");
             }
             if (cell !== null && cell !== "") {
-                const firstCellAddress = getFirstCellAddress(rangeRef.address);
-                const lastUsedCellAddress = offsetAddress(firstCellAddress, columnIndex, rowIndex);
+                const firstCellAddress = (0, addressManipulation_ts_1.getFirstCellAddress)(rangeRef.address);
+                const lastUsedCellAddress = (0, addressManipulation_ts_1.offsetAddress)(firstCellAddress, columnIndex, rowIndex);
                 return {
                     value: cell,
                     address: lastUsedCellAddress,

package/dist/cjs/tasks/getRangeLastUsedCell.test.js

@@ -1,85 +1,90 @@
-import { describe, expect, it } from "vitest";
-import { sequential } from "../graphApi.js";
-import calculateWorkbook from "../operations/workbook/calculateWorkbook.js";
-import createWorkbook from "../operations/workbook/createWorkbook.js";
-import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
-import { getDefaultDriveRef } from "../services/drive.js";
-import { driveItemPath } from "../services/driveItem.js";
-import { generateTempFileName } from "../services/temporaryFiles.js";
-import { createWorkbookRangeRef } from "../services/workbookRange.js";
-import { createWorkbookWorksheetRef, defaultWorkbookWorksheetId } from "../services/workbookWorksheet.js";
-import getRangeLastUsedCell from "./getRangeLastUsedCell.js";
-import tryDeleteDriveItem from "./tryDeleteDriveItem.js";
-describe("getRangeLastUsedCell", () => {
-    it("should return the last used cell value", async () => {
-        const workbookName = generateTempFileName("xlsx");
-        const workbookPath = driveItemPath(workbookName);
-        const driveRef = getDefaultDriveRef();
-        const workbook = await createWorkbook(driveRef, workbookPath);
-        const worksheetRef = createWorkbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
-        const rangeRef = createWorkbookRangeRef(worksheetRef, "A1:B2");
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const graphApi_ts_1 = require("../graphApi.js");
+const calculateWorkbook_ts_1 = __importDefault(require("../operations/workbook/calculateWorkbook.js"));
+const createWorkbook_ts_1 = __importDefault(require("../operations/workbook/createWorkbook.js"));
+const updateWorkbookRange_ts_1 = __importDefault(require("../operations/workbookRange/updateWorkbookRange.js"));
+const drive_ts_1 = require("../services/drive.js");
+const driveItem_ts_1 = require("../services/driveItem.js");
+const temporaryFiles_ts_1 = require("../services/temporaryFiles.js");
+const workbookRange_ts_1 = require("../services/workbookRange.js");
+const workbookWorksheet_ts_1 = require("../services/workbookWorksheet.js");
+const getRangeLastUsedCell_ts_1 = __importDefault(require("./getRangeLastUsedCell.js"));
+const tryDeleteDriveItem_ts_1 = __importDefault(require("./tryDeleteDriveItem.js"));
+(0, vitest_1.describe)("getRangeLastUsedCell", () => {
+    (0, vitest_1.it)("should return the last used cell value", async () => {
+        const workbookName = (0, temporaryFiles_ts_1.generateTempFileName)("xlsx");
+        const workbookPath = (0, driveItem_ts_1.driveItemPath)(workbookName);
+        const driveRef = (0, drive_ts_1.getDefaultDriveRef)();
+        const workbook = await (0, createWorkbook_ts_1.default)(driveRef, workbookPath);
+        const worksheetRef = (0, workbookWorksheet_ts_1.createWorkbookWorksheetRef)(workbook, workbookWorksheet_ts_1.defaultWorkbookWorksheetId);
+        const rangeRef = (0, workbookRange_ts_1.createWorkbookRangeRef)(worksheetRef, "A1:B2");
         try {
-            await sequential(updateWorkbookRange(rangeRef, {
+            await (0, graphApi_ts_1.sequential)((0, updateWorkbookRange_ts_1.default)(rangeRef, {
                 values: [
                     [1, 2],
                     [3, 4],
                 ],
-            }), calculateWorkbook(workbook));
-            const result = await getRangeLastUsedCell(rangeRef);
+            }), (0, calculateWorkbook_ts_1.default)(workbook));
+            const result = await (0, getRangeLastUsedCell_ts_1.default)(rangeRef);
             if (result === null) {
                 throw new Error("Expected a result");
             }
-            expect(result.value).toBe(4);
-            expect(result.address).toBe("B2");
+            (0, vitest_1.expect)(result.value).toBe(4);
+            (0, vitest_1.expect)(result.address).toBe("B2");
         }
         finally {
-            await tryDeleteDriveItem(workbook);
+            await (0, tryDeleteDriveItem_ts_1.default)(workbook);
         }
     });
-    it("should return the last non-empty cell value when the last cell is empty", async () => {
-        const workbookName = generateTempFileName("xlsx");
-        const workbookPath = driveItemPath(workbookName);
-        const driveRef = getDefaultDriveRef();
-        const workbook = await createWorkbook(driveRef, workbookPath);
-        const worksheetRef = createWorkbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
-        const rangeRef = createWorkbookRangeRef(worksheetRef, "A1:B2");
+    (0, vitest_1.it)("should return the last non-empty cell value when the last cell is empty", async () => {
+        const workbookName = (0, temporaryFiles_ts_1.generateTempFileName)("xlsx");
+        const workbookPath = (0, driveItem_ts_1.driveItemPath)(workbookName);
+        const driveRef = (0, drive_ts_1.getDefaultDriveRef)();
+        const workbook = await (0, createWorkbook_ts_1.default)(driveRef, workbookPath);
+        const worksheetRef = (0, workbookWorksheet_ts_1.createWorkbookWorksheetRef)(workbook, workbookWorksheet_ts_1.defaultWorkbookWorksheetId);
+        const rangeRef = (0, workbookRange_ts_1.createWorkbookRangeRef)(worksheetRef, "A1:B2");
         try {
-            await sequential(updateWorkbookRange(rangeRef, {
+            await (0, graphApi_ts_1.sequential)((0, updateWorkbookRange_ts_1.default)(rangeRef, {
                 values: [
                     [1, 2],
                     [3, null],
                 ],
-            }), calculateWorkbook(workbook));
-            const result = await getRangeLastUsedCell(rangeRef);
+            }), (0, calculateWorkbook_ts_1.default)(workbook));
+            const result = await (0, getRangeLastUsedCell_ts_1.default)(rangeRef);
             if (result === null) {
                 throw new Error("Expected a result");
             }
-            expect(result.value).toBe(3);
-            expect(result.address).toBe("A2");
+            (0, vitest_1.expect)(result.value).toBe(3);
+            (0, vitest_1.expect)(result.address).toBe("A2");
         }
         finally {
-            await tryDeleteDriveItem(workbook);
+            await (0, tryDeleteDriveItem_ts_1.default)(workbook);
         }
     });
-    it("should return null when no cells are used", async () => {
-        const workbookName = generateTempFileName("xlsx");
-        const workbookPath = driveItemPath(workbookName);
-        const driveRef = getDefaultDriveRef();
-        const workbook = await createWorkbook(driveRef, workbookPath);
-        const worksheetRef = createWorkbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
-        const rangeRef = createWorkbookRangeRef(worksheetRef, "A1:B2");
+    (0, vitest_1.it)("should return null when no cells are used", async () => {
+        const workbookName = (0, temporaryFiles_ts_1.generateTempFileName)("xlsx");
+        const workbookPath = (0, driveItem_ts_1.driveItemPath)(workbookName);
+        const driveRef = (0, drive_ts_1.getDefaultDriveRef)();
+        const workbook = await (0, createWorkbook_ts_1.default)(driveRef, workbookPath);
+        const worksheetRef = (0, workbookWorksheet_ts_1.createWorkbookWorksheetRef)(workbook, workbookWorksheet_ts_1.defaultWorkbookWorksheetId);
+        const rangeRef = (0, workbookRange_ts_1.createWorkbookRangeRef)(worksheetRef, "A1:B2");
         try {
-            await sequential(updateWorkbookRange(rangeRef, {
+            await (0, graphApi_ts_1.sequential)((0, updateWorkbookRange_ts_1.default)(rangeRef, {
                 values: [
                     [null, null],
                     [null, null],
                 ],
-            }), calculateWorkbook(workbook));
-            const result = await getRangeLastUsedCell(rangeRef);
-            expect(result).toBeNull();
+            }), (0, calculateWorkbook_ts_1.default)(workbook));
+            const result = await (0, getRangeLastUsedCell_ts_1.default)(rangeRef);
+            (0, vitest_1.expect)(result).toBeNull();
         }
         finally {
-            await tryDeleteDriveItem(workbook);
+            await (0, tryDeleteDriveItem_ts_1.default)(workbook);
         }
     });
 });

package/dist/cjs/tasks/getWorkbookTableVisibleBody.js

@@ -1,8 +1,14 @@
-import getWorkbookVisibleRange from "../operations/workbookRange/getWorkbookVisibleRange.js";
-import getWorkbookTableBodyRange from "../operations/workbookTable/getWorkbookTableBodyRange.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkbookTableVisibleBody = getWorkbookTableVisibleBody;
+const getWorkbookVisibleRange_ts_1 = __importDefault(require("../operations/workbookRange/getWorkbookVisibleRange.js"));
+const getWorkbookTableBodyRange_ts_1 = __importDefault(require("../operations/workbookTable/getWorkbookTableBodyRange.js"));
 /** @deprecated Use `getWorkbookTableBodyVisibleRange` instead. */
-export async function getWorkbookTableVisibleBody(tableRef) {
-    const range = await getWorkbookTableBodyRange(tableRef);
-    const visibleRange = await getWorkbookVisibleRange(range);
+async function getWorkbookTableVisibleBody(tableRef) {
+    const range = await (0, getWorkbookTableBodyRange_ts_1.default)(tableRef);
+    const visibleRange = await (0, getWorkbookVisibleRange_ts_1.default)(range);
     return visibleRange;
 }

package/dist/cjs/tasks/getWorkbookWorksheetByName.js

@@ -1,5 +1,11 @@
-import NotFoundError from "../errors/NotFoundError.js";
-import listWorkbookWorksheets from "../operations/workbookWorksheet/listWorkbookWorksheets.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getWorkbookWorksheetByName;
+const NotFoundError_ts_1 = __importDefault(require("../errors/NotFoundError.js"));
+const listWorkbookWorksheets_ts_1 = __importDefault(require("../operations/workbookWorksheet/listWorkbookWorksheets.js"));
 /**
  * Get a worksheet by its name. Throws an error if not found.
  *
@@ -8,12 +14,12 @@ import listWorkbookWorksheets from "../operations/workbookWorksheet/listWorkbook
  * @throws {NotFoundError} If the worksheet with the specified name is not found.
  * @returns The worksheet details.
  */
-export default async function getWorkbookWorksheetByName(workbookRef, name) {
+async function getWorkbookWorksheetByName(workbookRef, name) {
     // TODO: More performant to get it by a direct call without listing all workbooks?
-    const worksheets = await listWorkbookWorksheets(workbookRef);
+    const worksheets = await (0, listWorkbookWorksheets_ts_1.default)(workbookRef);
     const worksheet = worksheets.find((worksheetRef) => worksheetRef.name === name);
     if (!worksheet) {
-        throw new NotFoundError(`Worksheet '${name}' not found.`);
+        throw new NotFoundError_ts_1.default(`Worksheet '${name}' not found.`);
     }
     return worksheet;
 }

package/dist/cjs/tasks/iterateWorkbookRangeValues.js

@@ -1,8 +1,14 @@
-import InvalidArgumentError from "../errors/InvalidArgumentError.js";
-import getWorkbookWorksheetRange from "../operations/workbookRange/getWorkbookWorksheetRange.js";
-import { composeAddress, decomposeAddress } from "../services/addressManipulation.js";
-import { columnAddressToOffset, offsetToRowAddress, rowAddressToOffset } from "../services/addressOffset.js";
-import { createWorkbookRangeRef } from "../services/workbookRange.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = iterateWorkbookRangeValues;
+const InvalidArgumentError_ts_1 = __importDefault(require("../errors/InvalidArgumentError.js"));
+const getWorkbookWorksheetRange_ts_1 = __importDefault(require("../operations/workbookRange/getWorkbookWorksheetRange.js"));
+const addressManipulation_ts_1 = require("../services/addressManipulation.js");
+const addressOffset_ts_1 = require("../services/addressOffset.js");
+const workbookRange_ts_1 = require("../services/workbookRange.js");
 /**
  * Maximum number of cells that can be retrieved in a single request, unless overwritten.
  * @remarks The Microsoft Graph API documentation does not specify a fixed maximum number of cells that can be retrieved in a single request.
@@ -17,29 +23,29 @@ const maxCellsPerRequest = 10_000;
  * @param overwriteRowsPerRequest - Optional. The number of rows to fetch per request. If omitted, it is automatically calculated.
  * @returns An async iterable that yields rows of range values.
  */
-export default async function* iterateWorkbookRangeValues(rangeRef, overwriteRowsPerRequest = null) {
+async function* iterateWorkbookRangeValues(rangeRef, overwriteRowsPerRequest = null) {
     const address = rangeRef.address;
-    const components = decomposeAddress(address);
-    const columnsPerRow = columnAddressToOffset(components.endColumn) - columnAddressToOffset(components.startColumn) + 1;
+    const components = (0, addressManipulation_ts_1.decomposeAddress)(address);
+    const columnsPerRow = (0, addressOffset_ts_1.columnAddressToOffset)(components.endColumn) - (0, addressOffset_ts_1.columnAddressToOffset)(components.startColumn) + 1;
     if (overwriteRowsPerRequest !== null && overwriteRowsPerRequest < 1) {
-        throw new InvalidArgumentError("overwriteRowsPerRequest must be greater than 0");
+        throw new InvalidArgumentError_ts_1.default("overwriteRowsPerRequest must be greater than 0");
     }
     const rowsPerRequest = overwriteRowsPerRequest ?? Math.floor(maxCellsPerRequest / columnsPerRow);
-    const rangeStartRowOffset = rowAddressToOffset(components.startRow);
-    const rangeEndRowOffset = rowAddressToOffset(components.endRow);
+    const rangeStartRowOffset = (0, addressOffset_ts_1.rowAddressToOffset)(components.startRow);
+    const rangeEndRowOffset = (0, addressOffset_ts_1.rowAddressToOffset)(components.endRow);
     for (let chunkRowOffset = rangeStartRowOffset; chunkRowOffset <= rangeEndRowOffset; chunkRowOffset = (chunkRowOffset + rowsPerRequest)) {
         const requestStartRowOffset = chunkRowOffset;
         const requestEndRowOffset = Math.min(chunkRowOffset + rowsPerRequest - 1, rangeEndRowOffset);
-        const chunkStartRow = offsetToRowAddress(requestStartRowOffset);
-        const chunkEndRow = offsetToRowAddress(requestEndRowOffset);
-        const requestAddress = composeAddress({
+        const chunkStartRow = (0, addressOffset_ts_1.offsetToRowAddress)(requestStartRowOffset);
+        const chunkEndRow = (0, addressOffset_ts_1.offsetToRowAddress)(requestEndRowOffset);
+        const requestAddress = (0, addressManipulation_ts_1.composeAddress)({
             startRow: chunkStartRow,
             endRow: chunkEndRow,
             startColumn: components.startColumn,
             endColumn: components.endColumn,
         });
-        const requestRef = createWorkbookRangeRef(rangeRef, requestAddress);
-        const range = await getWorkbookWorksheetRange(requestRef);
+        const requestRef = (0, workbookRange_ts_1.createWorkbookRangeRef)(rangeRef, requestAddress);
+        const range = await (0, getWorkbookWorksheetRange_ts_1.default)(requestRef);
         for (const row of range.values) {
             yield row;
         }