microsoft-graph 2.6.0 → 2.7.0

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

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

package/dist/cjs/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/cjs/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/cjs/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/cjs/services/addressOffset.test.d.ts

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

package/dist/cjs/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/cjs/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");
+    });
+});

package/dist/cjs/services/context.d.ts

@@ -0,0 +1,30 @@
+import type { ClientId } from "../models/ClientId.ts";
+import type { ClientSecret } from "../models/ClientSecret.ts";
+import type { Context } from "../models/Context.ts";
+import type { ContextId } from "../models/ContextId.ts";
+import type { ContextRef } from "../models/ContextRef.ts";
+import type { HttpProxy } from "../models/HttpProxy.ts";
+import type { TenantId } from "../models/TenantId.ts";
+/**
+ * Registers a tenant+client so that its secret can be used later.
+ * @param tenantId - The tenant ID.
+ * @param clientId - The client ID.
+ * @param clientSecret - The client secret.
+ * @param httpProxy - Optional HTTP proxy configuration.
+ * @returns A reference to the registered context.
+ */
+export declare function register(tenantId: TenantId, clientId: ClientId, clientSecret: ClientSecret, httpProxy?: HttpProxy | undefined): ContextRef;
+/**
+ * Retrieves the context for a given context ID.
+ * @param contextId - The ID of the context.
+ * @returns The context associated with the given ID.
+ * @throws ContextNotRegisteredError if the context ID is not registered.
+ */
+export declare function getContext(contextId: ContextId): Context;
+/**
+ * Retrieves the opinionated default context reference. NOT RECOMMENDED FOR PRODUCTION USE.
+ * @returns A reference to the default context.
+ * @remarks This method is opinionated and not recommended for production use.
+ */
+export declare function getDefaultContextRef(): ContextRef;
+//# sourceMappingURL=context.d.ts.map

package/dist/cjs/services/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/services/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMtD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,CAe1I;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAMxD;AAYD;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,CASjD"}

package/dist/cjs/services/context.js

@@ -0,0 +1,58 @@
+import ContextNotRegisteredError from "../errors/ContextNotRegisteredError.js";
+import { getEnvironmentVariable } from "./environmentVariable.js";
+import { generateRandomString } from "./random.js";
+const contexts = {};
+/**
+ * Registers a tenant+client so that its secret can be used later.
+ * @param tenantId - The tenant ID.
+ * @param clientId - The client ID.
+ * @param clientSecret - The client secret.
+ * @param httpProxy - Optional HTTP proxy configuration.
+ * @returns A reference to the registered context.
+ */
+export function register(tenantId, clientId, clientSecret, httpProxy) {
+    const contextId = generateContextId();
+    const context = {
+        tenantId,
+        clientId,
+        clientSecret,
+        httpProxy,
+    };
+    contexts[contextId] = context;
+    const contextRef = createContextRef(contextId);
+    return contextRef;
+}
+/**
+ * Retrieves the context for a given context ID.
+ * @param contextId - The ID of the context.
+ * @returns The context associated with the given ID.
+ * @throws ContextNotRegisteredError if the context ID is not registered.
+ */
+export function getContext(contextId) {
+    const context = contexts[contextId];
+    if (!context) {
+        throw new ContextNotRegisteredError(`Context with ID ${contextId} is not registered`);
+    }
+    return context;
+}
+function generateContextId() {
+    return generateRandomString(16);
+}
+function createContextRef(contextId) {
+    return {
+        contextId,
+    };
+}
+/**
+ * Retrieves the opinionated default context reference. NOT RECOMMENDED FOR PRODUCTION USE.
+ * @returns A reference to the default context.
+ * @remarks This method is opinionated and not recommended for production use.
+ */
+export function getDefaultContextRef() {
+    const tenantId = getEnvironmentVariable("AZURE_TENANT_ID");
+    const clientId = getEnvironmentVariable("AZURE_CLIENT_ID");
+    const clientSecret = getEnvironmentVariable("AZURE_CLIENT_SECRET");
+    const httpProxy = (getEnvironmentVariable("HTTP_PROXY", "") || undefined);
+    const contextRef = register(tenantId, clientId, clientSecret, httpProxy);
+    return contextRef;
+}

package/dist/cjs/services/drive.d.ts

@@ -0,0 +1,18 @@
+import type { DriveId } from "../models/DriveId.ts";
+import type { DriveRef } from "../models/DriveRef.ts";
+import type { SiteRef } from "../models/SiteRef.ts";
+/**
+ * Creates a reference to a drive.
+ * @param siteRef - The reference to the site.
+ * @param driveId - The ID of the drive.
+ * @returns A reference to the drive.
+ * @throws ProtocolError if the drive ID is missing.
+ */
+export declare function createDriveRef(siteRef: SiteRef, driveId: DriveId | undefined): DriveRef;
+/**
+ * Retrieves the opinionated default drive reference. NOT RECOMMENDED FOR PRODUCTION USE.
+ * @returns A reference to the default drive.
+ * @remarks This method is opinionated and not recommended for production use.
+ */
+export declare function getDefaultDriveRef(): DriveRef;
+//# sourceMappingURL=drive.d.ts.map

package/dist/cjs/services/drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/services/drive.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAMpD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,CAUvF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,QAAQ,CAa7C"}

package/dist/cjs/services/drive.js

@@ -0,0 +1,38 @@
+import ProtocolError from "../errors/ProtocolError.js";
+import { register } from "./context.js";
+import { getEnvironmentVariable } from "./environmentVariable.js";
+import { createSiteRef } from "./site.js";
+/**
+ * Creates a reference to a drive.
+ * @param siteRef - The reference to the site.
+ * @param driveId - The ID of the drive.
+ * @returns A reference to the drive.
+ * @throws ProtocolError if the drive ID is missing.
+ */
+export function createDriveRef(siteRef, driveId) {
+    if (!driveId) {
+        throw new ProtocolError("DriveID is missing");
+    }
+    return {
+        contextId: siteRef.contextId,
+        siteId: siteRef.siteId,
+        driveId,
+    };
+}
+/**
+ * Retrieves the opinionated default drive reference. NOT RECOMMENDED FOR PRODUCTION USE.
+ * @returns A reference to the default drive.
+ * @remarks This method is opinionated and not recommended for production use.
+ */
+export function getDefaultDriveRef() {
+    const tenantId = getEnvironmentVariable("AZURE_TENANT_ID");
+    const clientId = getEnvironmentVariable("AZURE_CLIENT_ID");
+    const clientSecret = getEnvironmentVariable("AZURE_CLIENT_SECRET");
+    const siteId = getEnvironmentVariable("SHAREPOINT_DEFAULT_SITE_ID");
+    const driveId = getEnvironmentVariable("SHAREPOINT_DEFAULT_DRIVE_ID");
+    const httpProxy = (getEnvironmentVariable("HTTP_PROXY", "") || undefined);
+    const contextRef = register(tenantId, clientId, clientSecret, httpProxy);
+    const siteRef = createSiteRef(contextRef, siteId);
+    const driveRef = createDriveRef(siteRef, driveId);
+    return driveRef;
+}