@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/utils/pagination-utils.test.js

@@ -1,461 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { paginate, paginateMaxItems } from "./pagination-utils";
-// Test data set - simulating a large dataset with cursor-based pagination
-export const ALL_ITEMS = Array.from({ length: 25 }, (_, i) => ({
-    id: i + 1,
-    name: `Item ${i + 1}`,
-}));
-// Test page function that implements cursor-based pagination logic
-export async function listTestItems(options) {
-    const { pageSize = 5, cursor, filter, maxItems } = options;
-    // Cap pageSize at 10 to simulate real API limits
-    let actualPageSize = Math.min(pageSize, 10);
-    // If maxItems hint is provided, further limit the page size for optimization
-    if (maxItems !== undefined && maxItems > 0) {
-        actualPageSize = Math.min(actualPageSize, maxItems);
-    }
-    // Filter items if filter is provided
-    let items = ALL_ITEMS;
-    if (filter) {
-        items = items.filter((item) => item.name.toLowerCase().includes(filter.toLowerCase()));
-    }
-    // Find starting position based on cursor
-    let startIndex = 0;
-    if (cursor) {
-        // Cursor format: "cursor-{itemId}"
-        const cursorId = parseInt(cursor.replace("cursor-", ""));
-        startIndex = items.findIndex((item) => item.id > cursorId);
-        if (startIndex === -1) {
-            // No more items after cursor
-            return { data: [], nextCursor: undefined };
-        }
-    }
-    // Get page of items
-    const pageItems = items.slice(startIndex, startIndex + actualPageSize);
-    // Determine next cursor
-    let nextCursor;
-    if (startIndex + actualPageSize < items.length && pageItems.length > 0) {
-        const lastItem = pageItems[pageItems.length - 1];
-        nextCursor = `cursor-${lastItem.id}`;
-    }
-    return {
-        data: pageItems,
-        nextCursor,
-    };
-}
-describe("paginate", () => {
-    it("should paginate through multiple pages", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 3 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        // With 25 items and pageSize 3, should have 9 pages (8 full + 1 partial)
-        expect(pages).toHaveLength(9);
-        // Check first page
-        expect(pages[0]).toEqual({
-            data: ALL_ITEMS.slice(0, 3),
-            nextCursor: "cursor-3",
-        });
-        // Check second page (cursor should be passed correctly)
-        expect(pages[1]).toEqual({
-            data: ALL_ITEMS.slice(3, 6),
-            nextCursor: "cursor-6",
-        });
-        // Check last page (should have no nextCursor)
-        expect(pages[8]).toEqual({
-            data: ALL_ITEMS.slice(24, 25),
-            nextCursor: undefined,
-        });
-        // Verify we got all 25 items across all pages
-        const allItems = pages.flatMap((page) => page.data);
-        expect(allItems).toHaveLength(25);
-    });
-    it("should cap pageSize at 10 when unbuffered", async () => {
-        // Use a page size larger than 10, should get capped
-        const pageIterator = paginateMaxItems(listTestItems, { pageSize: 50 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        // Should get 3 pages: 10+10+5=25 (pageSize capped at 10)
-        expect(pages).toHaveLength(3);
-        expect(pages[0].data).toHaveLength(10); // First page capped at 10
-        expect(pages[1].data).toHaveLength(10); // Second page capped at 10
-        expect(pages[2].data).toHaveLength(5); // Last page has remaining 5
-        expect(pages[2].nextCursor).toBeUndefined(); // Last page has no nextCursor
-    });
-    it("should not cap pageSize when buffered", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 50 });
-        for await (const page of pageIterator) {
-            expect(page.data).toHaveLength(25);
-            break;
-        }
-    });
-    it("should not cap pageSize when buffered", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 15 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        expect(pages).toHaveLength(2);
-        expect(pages[0].data).toHaveLength(15);
-        expect(pages[1].data).toHaveLength(10);
-    });
-    it("should continue from pseudo cursor", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 15 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-            break;
-        }
-        const nextPageIterator = paginate(listTestItems, {
-            pageSize: 15,
-            cursor: pages[0].nextCursor,
-        });
-        for await (const page of nextPageIterator) {
-            pages.push(page);
-        }
-        expect(pages).toHaveLength(2);
-        expect(pages[0].data).toHaveLength(15);
-        expect(pages[1].data).toHaveLength(10);
-    });
-    it("should handle filtered results", async () => {
-        // Filter for items containing "1" (should match Item 1, Item 10-19, Item 21)
-        const pageIterator = paginate(listTestItems, {
-            pageSize: 4,
-            filter: "1",
-        });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        // Should have multiple pages due to pageSize: 4
-        expect(pages.length).toBeGreaterThan(1);
-        // All items should contain "1"
-        const allItems = pages.flatMap((page) => page.data);
-        expect(allItems.every((item) => item.name.includes("1"))).toBe(true);
-        // Should include items like Item 1, Item 10, Item 11, etc.
-        expect(allItems).toContainEqual(ALL_ITEMS[0]); // Item 1
-        expect(allItems).toContainEqual(ALL_ITEMS[9]); // Item 10
-        expect(allItems).toContainEqual(ALL_ITEMS[20]); // Item 21
-    });
-    it("should handle empty results", async () => {
-        // Filter that matches no items
-        const pageIterator = paginate(listTestItems, {
-            pageSize: 10,
-            filter: "nonexistent",
-        });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        expect(pages).toHaveLength(1);
-        expect(pages[0]).toEqual({
-            data: [],
-            nextCursor: undefined,
-        });
-    });
-    it("should pass through errors from the page function", async () => {
-        // Create a page function that throws an error
-        const errorPageFunction = async () => {
-            throw new Error("Page function failed");
-        };
-        const pageIterator = paginate(errorPageFunction, {});
-        let reachedUnreachableCode = undefined;
-        await expect(async () => {
-            for await (const page of pageIterator) {
-                // Should never reach here due to error
-                reachedUnreachableCode = page;
-            }
-        }).rejects.toThrow("Page function failed");
-        // Verify we never reached the unreachable code
-        expect(reachedUnreachableCode).toBeUndefined();
-    });
-    it("should start pagination from provided cursor", async () => {
-        // Test that pagination can start from a specific cursor position
-        const pageIterator = paginate(listTestItems, {
-            pageSize: 3,
-            cursor: "cursor-5", // Start after item 5
-        });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-            if (pages.length >= 2)
-                break; // Just test first 2 pages
-        }
-        expect(pages).toHaveLength(2);
-        // First page should start after cursor-5 (from item 6)
-        expect(pages[0].data[0]).toEqual(ALL_ITEMS[5]); // Item 6
-        // Second page should continue properly
-        expect(pages[1].data[0]).toEqual(ALL_ITEMS[8]); // Item 9
-    });
-    it("should allow breaking out of pagination early", async () => {
-        // Test that users can break out of the iterator manually
-        const pageIterator = paginate(listTestItems, { pageSize: 3 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-            // Break after getting 3 pages
-            if (pages.length >= 3) {
-                break;
-            }
-        }
-        // Should have stopped at exactly 3 pages with 9 items (3+3+3=9)
-        const allItems = pages.flatMap((page) => page.data);
-        expect(allItems).toHaveLength(9);
-        expect(pages).toHaveLength(3);
-        // Should be first 9 items
-        expect(allItems).toEqual(ALL_ITEMS.slice(0, 9));
-    });
-    describe("conditional types for optional options", () => {
-        it("should work with function that takes no options", async () => {
-            async function fetchWithNoOptions(_options) {
-                return { data: [1, 2, 3] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchWithNoOptions)) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual([1, 2, 3]);
-        });
-        it("should work with function that takes optional options", async () => {
-            async function fetchWithOptionalOptions(options) {
-                return { data: [`page-${options?.cursor || "1"}`] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchWithOptionalOptions, {
-                limit: 5,
-            })) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual(["page-1"]);
-        });
-        it("should work with function that takes only cursor", async () => {
-            async function fetchWithOnlyCursor(_options) {
-                return { data: [true] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchWithOnlyCursor, {
-                cursor: "start",
-            })) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual([true]);
-        });
-        it("should work when baseOptions is omitted entirely", async () => {
-            async function fetchSimple(_options) {
-                return { data: ["simple"] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchSimple)) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual(["simple"]);
-        });
-    });
-    describe("maxItems functionality", () => {
-        it("should limit total items across pages", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(7);
-            expect(items).toEqual(ALL_ITEMS.slice(0, 7));
-        });
-        it("should truncate the final page when maxItems is exceeded", async () => {
-            // Create a function that ignores maxItems hint to force truncation
-            async function fetchIgnoringMaxItems(options) {
-                return listTestItems({
-                    pageSize: options.pageSize,
-                    cursor: options.cursor,
-                });
-            }
-            const pageData = [];
-            for await (const page of paginate(fetchIgnoringMaxItems, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                pageData.push(page);
-            }
-            // Should have 3 pages: [3 items], [3 items], [1 item (truncated)]
-            expect(pageData).toHaveLength(3);
-            expect(pageData[0].data).toHaveLength(3);
-            expect(pageData[1].data).toHaveLength(3);
-            expect(pageData[2].data).toHaveLength(1); // Truncated page
-            expect(pageData[2].nextCursor).toBeUndefined(); // Should clear cursor
-        });
-        it("should stop early when maxItems is exactly a page boundary", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 6,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(6);
-            expect(items).toEqual(ALL_ITEMS.slice(0, 6));
-        });
-        it("should handle maxItems of 0", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 0,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(0);
-        });
-        it("should work normally when maxItems is larger than total items", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 100,
-            })) {
-                items.push(...page.data);
-            }
-            // Should get all items since limit is higher than total
-            expect(items).toEqual(ALL_ITEMS);
-        });
-        it("should work with maxItems and other options combined", async () => {
-            async function fetchWithLimit(options) {
-                const start = parseInt(options.cursor || "0");
-                let limit = options.limit;
-                // Apply maxItems hint for optimization
-                if (options.maxItems !== undefined && options.maxItems > 0) {
-                    limit = Math.min(limit, options.maxItems);
-                }
-                const items = ALL_ITEMS.slice(start, start + limit);
-                const nextCursor = start + limit < ALL_ITEMS.length
-                    ? (start + limit).toString()
-                    : undefined;
-                return { data: items, nextCursor };
-            }
-            const items = [];
-            for await (const page of paginate(fetchWithLimit, {
-                limit: 2,
-                maxItems: 5,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(5);
-            expect(items).toEqual(ALL_ITEMS.slice(0, 5));
-        });
-        it("should preserve original page structure except for truncation", async () => {
-            // Create a function that ignores maxItems hint to force truncation
-            async function fetchIgnoringMaxItems(options) {
-                const pageSize = options.pageSize || 3;
-                const start = options.cursor
-                    ? parseInt(options.cursor.replace("cursor-", "")) + 1
-                    : 0;
-                const items = ALL_ITEMS.slice(start, start + pageSize);
-                const nextCursor = start + pageSize <= ALL_ITEMS.length
-                    ? `cursor-${ALL_ITEMS[start + pageSize - 1].id}`
-                    : undefined;
-                return { data: items, nextCursor };
-            }
-            let pageCount = 0;
-            for await (const page of paginate(fetchIgnoringMaxItems, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                pageCount++;
-                // All pages should have the expected structure
-                expect(page).toHaveProperty("data");
-                expect(Array.isArray(page.data)).toBe(true);
-                if (pageCount === 3) {
-                    // Final truncated page
-                    expect(page.data).toHaveLength(1);
-                    expect(page.nextCursor).toBeUndefined();
-                }
-                else {
-                    // Regular pages
-                    expect(page.data).toHaveLength(3);
-                    expect(typeof page.nextCursor).toBe("string");
-                }
-            }
-            expect(pageCount).toBe(3);
-        });
-        it("should handle API that ignores pageSize and returns more items on first page", async () => {
-            // Simulate an API that ignores pageSize and always returns 10 items per page
-            async function apiIgnoresPageSize(options) {
-                return listTestItems({
-                    cursor: options.cursor,
-                    pageSize: 10,
-                });
-            }
-            const pages = [];
-            // User requests pageSize: 3, but API returns 10 per page
-            for await (const page of paginate(apiIgnoresPageSize, {
-                pageSize: 3,
-            })) {
-                pages.push(page);
-                // Only get first page to test the behavior
-                break;
-            }
-            // Should get 1 page with only 3 items (paginate enforces pageSize limit)
-            expect(pages).toHaveLength(1);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[0].data).toEqual(ALL_ITEMS.slice(0, 3));
-            // Cursor should still be present since there are more items available
-            expect(pages[0].nextCursor).toBeDefined();
-        });
-        it("should truncate oversized API response to pageSize", async () => {
-            // API always returns 10 items, but user wants pageSize: 3
-            async function apiReturns10Items(options) {
-                return listTestItems({
-                    cursor: options.cursor,
-                    pageSize: 10,
-                });
-            }
-            const pages = [];
-            for await (const page of paginate(apiReturns10Items, {
-                pageSize: 3,
-            })) {
-                pages.push(page);
-            }
-            // Should truncate each 10-item API response to 3 items per page
-            expect(pages).toHaveLength(9);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[1].data).toHaveLength(3);
-            expect(pages[8].data).toHaveLength(1);
-            // Verify items are from different API calls
-            expect(pages[0].data).toEqual(ALL_ITEMS.slice(0, 3)); // Items 1-3 from first API call
-            expect(pages[1].data).toEqual(ALL_ITEMS.slice(3, 6)); // Items 11-13 from second API call
-            expect(pages[8].data).toEqual(ALL_ITEMS.slice(24, 25)); // Items 21-23 from third API call
-            // All pages should have nextCursor since API has more data
-            expect(pages[0].nextCursor).toBe('["$$offset$$",3,null]');
-            expect(pages[8].nextCursor).toBeUndefined();
-        });
-        it("should handle pageSize enforcement with maxItems limit", async () => {
-            // API returns 10 items, user wants pageSize: 3, maxItems: 7
-            async function apiReturns10Items(options) {
-                return listTestItems({
-                    cursor: options.cursor,
-                    pageSize: 10,
-                });
-            }
-            const pages = [];
-            for await (const page of paginate(apiReturns10Items, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                pages.push(page);
-            }
-            // Should get: [3, 3, 1] items (total 7, respecting maxItems)
-            expect(pages).toHaveLength(3);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[1].data).toHaveLength(3);
-            expect(pages[2].data).toHaveLength(1); // Truncated to respect maxItems
-            // Last page should have no nextCursor (maxItems reached)
-            expect(pages[2].nextCursor).toBeUndefined();
-            // Verify total items
-            const allItems = pages.flatMap((p) => p.data);
-            expect(allItems).toHaveLength(7);
-            expect(allItems).toEqual(ALL_ITEMS.slice(0, 7));
-        });
-    });
-});

package/dist/utils/retry-utils.test.d.ts

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

package/dist/utils/retry-utils.test.d.ts.map

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

package/dist/utils/retry-utils.test.js

@@ -1,90 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { calculateErrorBackoffMs, MAX_CONSECUTIVE_ERRORS, BASE_ERROR_BACKOFF_MS, JITTER_FACTOR, } from "./retry-utils";
-describe("retry-utils", () => {
-    describe("calculateErrorBackoffMs", () => {
-        beforeEach(() => {
-            // Seed random for consistent testing
-            vi.spyOn(Math, "random");
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-        });
-        it("should return base interval with jitter when no errors", () => {
-            vi.spyOn(Math, "random").mockReturnValue(0.5); // Middle of jitter range
-            const baseInterval = 1000;
-            const waitTime = calculateErrorBackoffMs(baseInterval, 0);
-            // With 0.5 random and JITTER_FACTOR 0.5:
-            // jitter = 0.5 * 0.5 * 1000 = 250ms
-            // errorBackoff = 0 (no errors)
-            // total = 1000 + 250 + 0 = 1250ms
-            expect(waitTime).toBe(1250);
-        });
-        it("should add error backoff for consecutive errors", () => {
-            vi.spyOn(Math, "random").mockReturnValue(0); // No jitter for simpler math
-            const baseInterval = 1000;
-            const errorCount = 2;
-            const waitTime = calculateErrorBackoffMs(baseInterval, errorCount);
-            // jitter = 0 (random is 0)
-            // errorBackoff = BASE_ERROR_BACKOFF_MS * (errorCount / 2) = 1000 * (2/2) = 1000ms
-            // total = 1000 + 0 + 1000 = 2000ms
-            expect(waitTime).toBe(2000);
-        });
-        it("should cap error backoff at 2x base interval", () => {
-            vi.spyOn(Math, "random").mockReturnValue(0); // No jitter
-            const baseInterval = 1000;
-            const errorCount = 10; // Large error count
-            const waitTime = calculateErrorBackoffMs(baseInterval, errorCount);
-            // errorBackoff would be 1000 * (10/2) = 5000ms
-            // but it's capped at 2x base = 2000ms
-            // total = 1000 + 0 + 2000 = 3000ms
-            expect(waitTime).toBe(3000);
-        });
-        it("should add random jitter to prevent thundering herd", () => {
-            const baseInterval = 1000;
-            const results = new Set();
-            // Run multiple times with real random to ensure jitter varies
-            vi.spyOn(Math, "random").mockRestore(); // Use real random
-            for (let i = 0; i < 10; i++) {
-                const waitTime = calculateErrorBackoffMs(baseInterval, 0);
-                results.add(waitTime);
-            }
-            // Should have multiple different values due to jitter
-            expect(results.size).toBeGreaterThan(1);
-            // All values should be in expected range
-            // baseInterval (1000) + jitter (0 to JITTER_FACTOR * baseInterval)
-            // = 1000 to 1500ms
-            for (const result of results) {
-                expect(result).toBeGreaterThanOrEqual(1000);
-                expect(result).toBeLessThanOrEqual(1500);
-            }
-        });
-        it("should combine jitter and error backoff", () => {
-            vi.spyOn(Math, "random").mockReturnValue(0.5);
-            const baseInterval = 1000;
-            const errorCount = 2;
-            const waitTime = calculateErrorBackoffMs(baseInterval, errorCount);
-            // jitter = 0.5 * 0.5 * 1000 = 250ms
-            // errorBackoff = 1000 * (2/2) = 1000ms
-            // total = 1000 + 250 + 1000 = 2250ms
-            expect(waitTime).toBe(2250);
-        });
-        it("should return integer wait time", () => {
-            vi.spyOn(Math, "random").mockReturnValue(0.333);
-            const baseInterval = 1000;
-            const waitTime = calculateErrorBackoffMs(baseInterval, 1);
-            // Result should be floored integer
-            expect(Number.isInteger(waitTime)).toBe(true);
-        });
-    });
-    describe("constants", () => {
-        it("should export MAX_CONSECUTIVE_ERRORS", () => {
-            expect(MAX_CONSECUTIVE_ERRORS).toBe(3);
-        });
-        it("should export BASE_ERROR_BACKOFF_MS", () => {
-            expect(BASE_ERROR_BACKOFF_MS).toBe(1000);
-        });
-        it("should export JITTER_FACTOR", () => {
-            expect(JITTER_FACTOR).toBe(0.5);
-        });
-    });
-});

package/dist/utils/string-utils.test.d.ts

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

package/dist/utils/string-utils.test.d.ts.map

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

package/dist/utils/string-utils.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toTitleCase, stripPageSuffix } from "./string-utils";
-describe("toTitleCase", () => {
-    it("converts snake_case to title case", () => {
-        expect(toTitleCase("first_name")).toBe("First Name");
-        expect(toTitleCase("sender_settings")).toBe("Sender Settings");
-        expect(toTitleCase("api_key_config")).toBe("Api Key Config");
-    });
-    it("converts camelCase to title case", () => {
-        expect(toTitleCase("firstName")).toBe("First Name");
-        expect(toTitleCase("senderSettings")).toBe("Sender Settings");
-        expect(toTitleCase("apiKeyConfig")).toBe("Api Key Config");
-    });
-    it("converts kebab-case to title case", () => {
-        expect(toTitleCase("first-name")).toBe("First Name");
-        expect(toTitleCase("sender-settings")).toBe("Sender Settings");
-        expect(toTitleCase("api-key-config")).toBe("Api Key Config");
-    });
-    it("handles mixed formats", () => {
-        expect(toTitleCase("first_name-value")).toBe("First Name Value");
-        expect(toTitleCase("sender_settings-config")).toBe("Sender Settings Config");
-    });
-    it("handles single words", () => {
-        expect(toTitleCase("name")).toBe("Name");
-        expect(toTitleCase("settings")).toBe("Settings");
-    });
-    it("handles multiple spaces and trims", () => {
-        expect(toTitleCase("  first   name  ")).toBe("First Name");
-        expect(toTitleCase("sender__settings")).toBe("Sender Settings");
-    });
-    it("handles empty and edge cases", () => {
-        expect(toTitleCase("")).toBe("");
-        expect(toTitleCase("a")).toBe("A");
-        expect(toTitleCase("_")).toBe("");
-    });
-});
-describe("stripPageSuffix", () => {
-    it("strips Page suffix from function names", () => {
-        expect(stripPageSuffix("listAppsPage")).toBe("listApps");
-        expect(stripPageSuffix("listActionsPage")).toBe("listActions");
-        expect(stripPageSuffix("runActionPage")).toBe("runAction");
-        expect(stripPageSuffix("listAuthenticationsPage")).toBe("listAuthentications");
-    });
-    it("leaves names without Page suffix unchanged", () => {
-        expect(stripPageSuffix("listApps")).toBe("listApps");
-        expect(stripPageSuffix("getProfile")).toBe("getProfile");
-        expect(stripPageSuffix("request")).toBe("request");
-    });
-    it("only strips Page from the end", () => {
-        expect(stripPageSuffix("myPageFunction")).toBe("myPageFunction");
-        expect(stripPageSuffix("PageList")).toBe("PageList");
-        expect(stripPageSuffix("getPageData")).toBe("getPageData");
-    });
-    it("handles edge cases", () => {
-        expect(stripPageSuffix("Page")).toBe("");
-        expect(stripPageSuffix("")).toBe("");
-        expect(stripPageSuffix("p")).toBe("p");
-    });
-});

package/dist/utils/telemetry-context.test.d.ts

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

package/dist/utils/telemetry-context.test.d.ts.map

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