microsoft-graph 1.0.0

package/dist/operations/site/getSiteByName.js

@@ -0,0 +1,20 @@
+import { operation } from "../../graphApi.js";
+import { siteRef } from "../../services/site.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Get site by name. @see https://learn.microsoft.com/en-us/graph/api/site-getbypath */
+export default function getSiteByName(hostName, siteName) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{host-name}:/sites/{site-name}", { hostName, siteName }),
+        headers: {},
+        body: null,
+        responseTransform: (response) => {
+            const site = response;
+            const ref = siteRef(site.id);
+            return {
+                ...site,
+                ...ref
+            };
+        }
+    });
+}

package/dist/operations/site/getSiteByName.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultSiteRef } from "../../services/site.js";
+import getSite from "./getSite.js";
+import getSiteByName from "./getSiteByName.js";
+describe("getSiteByName", () => {
+    it("can retrieve an existing site by name", async () => {
+        const defaultSiteRef = getDefaultSiteRef();
+        const defaultSite = await getSite(defaultSiteRef);
+        const hostName = new URL(defaultSite.webUrl ?? "").hostname; // Yeah, a little hacky, but in the context of this test it's fine
+        const siteName = defaultSite.name;
+        const site = await getSiteByName(hostName, siteName);
+        expect(site.id).toBe(defaultSite.id);
+        expect(site.name).toBe(siteName);
+    });
+    it("throws an error when trying to retrieve a non-existent site by name", async () => {
+        const nonExistentHostName = "non-existent-host-name";
+        const nonExistentSiteName = "non-existent-site-name";
+        await expect(getSiteByName(nonExistentHostName, nonExistentSiteName)).rejects.toThrow();
+    });
+});

package/dist/operations/site/listSites.js

@@ -0,0 +1,23 @@
+import { operation } from "../../graphApi.js";
+import { siteRef } from "../../services/site.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** List sites that are available. @see https://learn.microsoft.com/en-us/graph/api/site-list */
+export default function listSites() {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites", {}),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const list = response;
+            const sites = list.value.map(site => {
+                const ref = siteRef(site.id);
+                return {
+                    ...site,
+                    ...ref,
+                };
+            });
+            return sites;
+        }
+    });
+}

package/dist/operations/site/listSites.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import listSites from "./listSites.js";
+describe("listSites", () => {
+    it("can list all sites", async () => {
+        const sites = await listSites();
+        console.debug("Sites:", sites.map(site => [site.id, site.name]));
+        expect(sites).toBeInstanceOf(Array);
+        expect(sites.length).toBeGreaterThan(0);
+    });
+});

package/dist/operations/site/searchSites.js

@@ -0,0 +1,23 @@
+import { operation } from "../../graphApi.js";
+import { siteRef } from "../../services/site.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Find accessible sites that match keywords provided. @see https://learn.microsoft.com/en-us/graph/api/site-search */
+export default function searchSites(search) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites?search={search}", { search }),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const list = response;
+            const sites = list.value.map(site => {
+                const ref = siteRef(site.id);
+                return {
+                    ...site,
+                    ...ref,
+                };
+            });
+            return sites;
+        }
+    });
+}

package/dist/operations/site/searchSites.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import searchSites from "./searchSites.js";
+describe("searchSites", () => {
+    it("can find sites matching the search keyword", async () => {
+        const searchKeyword = "a";
+        const result = await searchSites(searchKeyword);
+        expect(result).toBeInstanceOf(Array);
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it("returns an empty array when no sites match the search keyword", async () => {
+        const searchKeyword = "non-existent-keyword";
+        const result = await searchSites(searchKeyword);
+        expect(result).toBeInstanceOf(Array);
+        expect(result.length).toBe(0);
+    });
+    it("handles search with '/' character", async () => {
+        const searchKeyword = "/";
+        const result = await searchSites(searchKeyword);
+        expect(result).toBeInstanceOf(Array);
+    });
+});

package/dist/operations/workbook/calculateWorkbook.js

@@ -0,0 +1,20 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Recalculate a workbook. @see https://learn.microsoft.com/en-us/graph/api/workbookapplication-calculate */
+export default function calculateWorkbook(workbookRef, calculationType = "Recalculate") {
+    return operation({
+        method: "POST",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/application/calculate", workbookRef),
+        headers: {
+            "content-type": "application/json",
+        },
+        body: {
+            calculationType
+        },
+        responseTransform: () => undefined
+    });
+}
+/** @deprecated Use calculateWorkbook instead. */
+export function recalculateWorkbook(workbookRef) {
+    return calculateWorkbook(workbookRef, "Recalculate");
+}

package/dist/operations/workbook/calculateWorkbook.test.js

@@ -0,0 +1,46 @@
+import { describe, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "./calculateWorkbook.js";
+import createWorkbook from "./createWorkbook.js";
+describe("calculateWorkbook", () => {
+    // All we're really doing is check that there's no errors
+    it(`can calculate workbook with calculation type: 'Recalculate'`, { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            await calculateWorkbook(workbook, "Recalculate");
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it(`can calculate workbook with calculation type: 'Full'`, async () => {
+        const driveRef = getDefaultDriveRef();
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            await calculateWorkbook(workbook, "Full");
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it(`can calculate workbook with calculation type: 'FullRebuild'`, { timeout: 10000 }, async () => {
+        const driveRef = getDefaultDriveRef();
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            await calculateWorkbook(workbook, "FullRebuild");
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbook/createWorkbook.js

@@ -0,0 +1,26 @@
+import InvalidArgumentError from "../../errors/InvalidArgumentError.js";
+import { operation } from "../../graphApi.js";
+import { driveItemRef, workbookFileExtension } from "../../services/driveItem.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Create a new blank workbook. */
+export default function createWorkbook(driveRef, itemPath) {
+    if (!itemPath.endsWith(`.${workbookFileExtension}`)) {
+        throw new InvalidArgumentError(`Item path must end with '.${workbookFileExtension}'`);
+    }
+    return operation({
+        method: "PUT",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/root:${itemPath}:/content`, driveRef),
+        headers: {
+            "content-type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        },
+        body: null, // This is correct, Sharepoint interprets a 0-byte files as a new workbook.
+        responseTransform: response => {
+            const driveItem = response;
+            const itemRef = driveItemRef(driveRef, driveItem.id);
+            return {
+                ...driveItem,
+                ...itemRef
+            };
+        }
+    });
+}

package/dist/operations/workbook/createWorkbook.test.js

@@ -0,0 +1,15 @@
+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 deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import createWorkbook from "./createWorkbook.js";
+describe("createWorkbook", () => {
+    it("can create a new workbook", async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(getDefaultDriveRef(), workbookPath);
+        expect(workbook.name).toBe(workbookName);
+        await deleteDriveItemWithRetry(workbook);
+    });
+});

package/dist/operations/workbook/deleteWorkbook.js

@@ -0,0 +1,5 @@
+import deleteDriveItem from "../driveItem/deleteDriveItem.js";
+/** Delete a workbook. @see https://learn.microsoft.com/en-us/graph/api/driveitem-delete */
+export default function deleteWorkbook(workbookRef) {
+    return deleteDriveItem(workbookRef);
+}

package/dist/operations/workbookRange/clearWorkbookRange.js

@@ -0,0 +1,17 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Clear a range - content, formatting or both. @see https://learn.microsoft.com/en-us/graph/api/range-delete */
+export default function clearWorkbookRange(rangeRef, applyTo = "All") {
+    return operation({
+        method: "POST",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}/range(address='{address}')/clear", rangeRef),
+        headers: {
+            "workbook-session-id": rangeRef.sessionId,
+            "content-type": "application/json",
+        },
+        body: {
+            applyTo
+        },
+        responseTransform: () => undefined
+    });
+}

package/dist/operations/workbookRange/clearWorkbookRange.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { sequential } from "../../graphApi.js";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import { workbookRangeRef } from "../../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import getWorkbookWorksheetRange from "../workbookWorksheet/getWorkbookWorksheetRange.js";
+import clearWorkbookRange from "./clearWorkbookRange.js";
+import updateWorkbookRange from "./updateWorkbookRange.js";
+describe("clearWorkbookRange", () => {
+    it("can clear a range in an existing workbook", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            await updateWorkbookRange(rangeRef, {
+                values: values
+            });
+            await clearWorkbookRange(rangeRef);
+            await calculateWorkbook(workbook);
+            const clearedRange = await getWorkbookWorksheetRange(rangeRef);
+            expect(clearedRange.values).toEqual([["", ""], ["", ""]]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can clear a range in an existing workbook sequential", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            const [_, __, ___, clearedRange] = await sequential(updateWorkbookRange(rangeRef, {
+                values: values
+            }), clearWorkbookRange(rangeRef), calculateWorkbook(workbook), getWorkbookWorksheetRange(rangeRef));
+            expect(clearedRange.values).toEqual([["", ""], ["", ""]]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookRange/deleteWorkbookRange.js

@@ -0,0 +1,17 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Delete a range. @see https://learn.microsoft.com/en-us/graph/api/range-clear */
+export default function deleteWorkbookRange(rangeRef, shift) {
+    return operation({
+        method: "POST",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}/range(address='{address}')/delete", rangeRef),
+        headers: {
+            "workbook-session-id": rangeRef.sessionId,
+            "content-type": "application/json",
+        },
+        body: {
+            shift
+        },
+        responseTransform: () => undefined
+    });
+}

package/dist/operations/workbookRange/deleteWorkbookRange.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { sequential } from "../../graphApi.js";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import { workbookRangeRef } from "../../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import getWorkbookWorksheetRange from "../workbookWorksheet/getWorkbookWorksheetRange.js";
+import deleteWorkbookRange from "./deleteWorkbookRange.js";
+import updateWorkbookRange from "./updateWorkbookRange.js";
+describe("deleteWorkbookRange", () => {
+    it("can delete a range in an existing workbook", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            await updateWorkbookRange(rangeRef, {
+                values: values
+            });
+            await deleteWorkbookRange(rangeRef, "Up");
+            await calculateWorkbook(workbook);
+            const deletedRange = await getWorkbookWorksheetRange(rangeRef);
+            expect(deletedRange.values).toEqual([["", ""], ["", ""]]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can delete a range in an existing workbook sequential", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            const [_, __, ___, deletedRange] = await sequential(updateWorkbookRange(rangeRef, {
+                values: values
+            }), deleteWorkbookRange(rangeRef, "Up"), calculateWorkbook(workbook), getWorkbookWorksheetRange(rangeRef));
+            expect(deletedRange.values).toEqual([["", ""], ["", ""]]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookRange/getWorkbookNamedRange.js

@@ -0,0 +1,20 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Retrieve range that has been defined using the "named range" functionality. @see https://learn.microsoft.com/en-us/graph/api/range-get */
+export default function getWorkbookNamedRange(rangeRef) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/names/{range-name}/range", rangeRef),
+        headers: {
+            "workbook-session-id": rangeRef.sessionId,
+        },
+        body: null,
+        responseTransform: response => {
+            const range = response;
+            return {
+                ...range,
+                ...rangeRef
+            };
+        }
+    });
+}

package/dist/operations/workbookRange/getWorkbookUsedRange.js

@@ -0,0 +1,22 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+import { workbookRangeRef } from "../../services/workbookRange.js";
+/** Retrieve the used range in a worksheet, ignoring trailing rows and columns that are blank. @see https://learn.microsoft.com/en-us/graph/api/range-usedrange */
+export default function getWorkbookUsedRange(worksheetRef) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}/range/usedRange", worksheetRef),
+        headers: {
+            "workbook-session-id": worksheetRef.sessionId,
+        },
+        body: null,
+        responseTransform: response => {
+            const range = response;
+            const rangeRef = workbookRangeRef(worksheetRef, range.address);
+            return {
+                ...range,
+                ...rangeRef
+            };
+        }
+    });
+}

package/dist/operations/workbookRange/getWorkbookUsedRange.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { sequential } from "../../graphApi.js";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import { workbookRangeRef } from "../../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import getWorkbookUsedRange from "./getWorkbookUsedRange.js";
+import updateWorkbookRange from "./updateWorkbookRange.js";
+describe("getWorkbookUsedRange", { timeout: 10000 }, () => {
+    it("can retrieve the used range from an existing workbook", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            await updateWorkbookRange(rangeRef, {
+                values: values
+            });
+            await calculateWorkbook(workbook);
+            const usedRange = await getWorkbookUsedRange(worksheetRef);
+            expect(usedRange.values).toEqual(values);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can retrieve the used range from an existing workbook sequential", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            const [_, __, usedRange] = await sequential(updateWorkbookRange(rangeRef, {
+                values: values
+            }), calculateWorkbook(workbook), getWorkbookUsedRange(worksheetRef));
+            expect(usedRange.values).toEqual(values);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookRange/getWorkbookVisibleRange.js

@@ -0,0 +1,20 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Retrieve the visible view of a range. @see https://learn.microsoft.com/en-us/graph/api/workbookrange-visibleview */
+export default function getWorkbookVisibleRange(rangeRef) {
+    return operation({
+        method: "GET",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}/range(address='${rangeRef.address}')/visibleView`, rangeRef),
+        headers: {
+            "workbook-session-id": rangeRef.sessionId,
+        },
+        body: null,
+        responseTransform: response => {
+            const range = response;
+            return {
+                ...range,
+                ...rangeRef
+            };
+        }
+    });
+}

package/dist/operations/workbookRange/getWorkbookVisibleRange.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+import { sequential } from "../../graphApi.js";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import { workbookRangeRef } from "../../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import getWorkbookVisibleRange from "./getWorkbookVisibleRange.js";
+import updateWorkbookRange from "./updateWorkbookRange.js";
+describe("getWorkbookRangeVisible", () => {
+    it("can retrieve the visible view of a range in an existing workbook", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            await updateWorkbookRange(rangeRef, { values: values });
+            await calculateWorkbook(workbook);
+            const visibleView = await getWorkbookVisibleRange(rangeRef);
+            expect(visibleView).toBeDefined();
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can retrieve the visible view of a range in an existing workbook sequential", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, address);
+        try {
+            const [_, __, visibleView] = await sequential(updateWorkbookRange(rangeRef, { values: values }), calculateWorkbook(workbook), getWorkbookVisibleRange(rangeRef));
+            expect(visibleView).toBeDefined();
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("omits hidden row from the visible view of a range", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        try {
+            const rangeRef = workbookRangeRef(worksheetRef, "A1:C3");
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    [1, 2, 3],
+                    [4, 5, 6],
+                    [7, 8, 9]
+                ]
+            });
+            const hiddenRange = workbookRangeRef(worksheetRef, "B:B");
+            await updateWorkbookRange(hiddenRange, {
+                columnHidden: true
+            });
+            await calculateWorkbook(workbook);
+            const visibleView = await getWorkbookVisibleRange(rangeRef);
+            expect(visibleView.values).toEqual([
+                [1, 3],
+                [4, 6],
+                [7, 9]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("omits hidden column from the visible view of a range", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        try {
+            const rangeRef = workbookRangeRef(worksheetRef, "A1:C3");
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    [1, 2, 3],
+                    [4, 5, 6],
+                    [7, 8, 9]
+                ]
+            });
+            const hiddenRange = workbookRangeRef(worksheetRef, "2:2");
+            const [_, __, visibleView] = await sequential(updateWorkbookRange(hiddenRange, {
+                rowHidden: true
+            }), calculateWorkbook(workbook), getWorkbookVisibleRange(rangeRef));
+            expect(visibleView.values).toEqual([
+                [1, 2, 3],
+                [7, 8, 9]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookRange/insertWorkbookCells.js

@@ -0,0 +1,25 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+import { workbookRangeRef } from "../../services/workbookRange.js";
+/** Insert a new blank range at a specified address, shifting existing cells. Use `updateRange` after to set content. @see https://learn.microsoft.com/en-us/graph/api/range-insert */
+export default function insertWorkbookCells(worksheetRef, address, shift) {
+    return operation({
+        method: "POST",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}/range(address='${address}')/insert`, worksheetRef),
+        headers: {
+            "workbook-session-id": worksheetRef.sessionId,
+            "content-type": "application/json",
+        },
+        body: {
+            shift
+        },
+        responseTransform: response => {
+            const workbook = response;
+            const rangeRef = workbookRangeRef(worksheetRef, workbook.address);
+            return {
+                ...workbook,
+                ...rangeRef
+            };
+        }
+    });
+}