@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/types/domain.test.d.ts

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

package/dist/types/domain.test.d.ts.map

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

package/dist/types/domain.test.js

@@ -1,39 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { splitVersionedKey } from "../utils/domain-utils";
-describe("splitVersionedKey", () => {
-    it("should split versioned key with version", () => {
-        const [baseKey, version] = splitVersionedKey("SlackCLIAPI@1.21.1");
-        expect(baseKey).toBe("SlackCLIAPI");
-        expect(version).toBe("1.21.1");
-    });
-    it("should split versioned key with complex version", () => {
-        const [baseKey, version] = splitVersionedKey("GoogleSheetsAPI@2.5.0-beta.1");
-        expect(baseKey).toBe("GoogleSheetsAPI");
-        expect(version).toBe("2.5.0-beta.1");
-    });
-    it("should handle versioned key without version", () => {
-        const [baseKey, version] = splitVersionedKey("SomeAPI");
-        expect(baseKey).toBe("SomeAPI");
-        expect(version).toBeUndefined();
-    });
-    it("should handle versioned key with multiple @ symbols", () => {
-        const [baseKey, version] = splitVersionedKey("ComplexAPI@1.0.0@beta");
-        expect(baseKey).toBe("ComplexAPI");
-        expect(version).toBe("1.0.0@beta");
-    });
-    it("should handle edge case with many @ symbols", () => {
-        const [baseKey, version] = splitVersionedKey("API@with@multiple@at@symbols@1.2.3");
-        expect(baseKey).toBe("API");
-        expect(version).toBe("with@multiple@at@symbols@1.2.3");
-    });
-    it("should handle empty string", () => {
-        const [baseKey, version] = splitVersionedKey("");
-        expect(baseKey).toBe("");
-        expect(version).toBeUndefined();
-    });
-    it("should handle string that starts with @", () => {
-        const [baseKey, version] = splitVersionedKey("@version");
-        expect(baseKey).toBe("");
-        expect(version).toBe("version");
-    });
-});

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

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

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

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

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

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toArrayFromAsync } from "./array-utils";
-describe("array-utils", () => {
-    describe("fromAsync", () => {
-        it("should convert async generator to array", async () => {
-            async function* generateNumbers() {
-                yield 1;
-                yield 2;
-                yield 3;
-            }
-            const result = await toArrayFromAsync(generateNumbers());
-            expect(result).toEqual([1, 2, 3]);
-        });
-        it("should handle empty async generator", async () => {
-            async function* generateNothing() {
-                // yield nothing
-            }
-            const result = await toArrayFromAsync(generateNothing());
-            expect(result).toEqual([]);
-        });
-        it("should handle async generator with async operations", async () => {
-            async function* generateWithDelay() {
-                for (let i = 1; i <= 3; i++) {
-                    await new Promise((resolve) => setTimeout(resolve, 1)); // Small delay
-                    yield i * 10;
-                }
-            }
-            const result = await toArrayFromAsync(generateWithDelay());
-            expect(result).toEqual([10, 20, 30]);
-        });
-        it("should handle async generator that yields different types", async () => {
-            async function* generateMixed() {
-                yield "hello";
-                yield 42;
-                yield { name: "test" };
-                yield [1, 2, 3];
-            }
-            const result = await toArrayFromAsync(generateMixed());
-            expect(result).toEqual(["hello", 42, { name: "test" }, [1, 2, 3]]);
-        });
-        it("should handle async generator with error", async () => {
-            async function* generateWithError() {
-                yield 1;
-                yield 2;
-                throw new Error("Test error");
-            }
-            await expect(toArrayFromAsync(generateWithError())).rejects.toThrow("Test error");
-        });
-        it("should handle async iterable from array with Symbol.asyncIterator", async () => {
-            const asyncIterable = {
-                async *[Symbol.asyncIterator]() {
-                    for (const item of ["a", "b", "c"]) {
-                        yield item;
-                    }
-                },
-            };
-            const result = await toArrayFromAsync(asyncIterable);
-            expect(result).toEqual(["a", "b", "c"]);
-        });
-        it("should handle large async generator efficiently", async () => {
-            async function* generateLargeSequence() {
-                for (let i = 0; i < 1000; i++) {
-                    yield i;
-                }
-            }
-            const result = await toArrayFromAsync(generateLargeSequence());
-            expect(result).toHaveLength(1000);
-            expect(result[0]).toBe(0);
-            expect(result[999]).toBe(999);
-        });
-        it("should handle async generator that yields promises (promises are auto-awaited)", async () => {
-            async function* generatePromises() {
-                yield Promise.resolve("first");
-                yield Promise.resolve("second");
-            }
-            const result = await toArrayFromAsync(generatePromises());
-            // for await automatically awaits promises, so we get resolved values
-            expect(result).toEqual(["first", "second"]);
-        });
-        it("should handle async generator that yields already resolved values", async () => {
-            async function* generateResolvedValues() {
-                yield await Promise.resolve("first");
-                yield await Promise.resolve("second");
-            }
-            const result = await toArrayFromAsync(generateResolvedValues());
-            // The resolved values are yielded directly
-            expect(result).toEqual(["first", "second"]);
-        });
-        it("should maintain order of async generator items", async () => {
-            async function* generateInOrder() {
-                for (let i = 1; i <= 5; i++) {
-                    // Simulate varying delays
-                    await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
-                    yield `item-${i}`;
-                }
-            }
-            const result = await toArrayFromAsync(generateInOrder());
-            expect(result).toEqual([
-                "item-1",
-                "item-2",
-                "item-3",
-                "item-4",
-                "item-5",
-            ]);
-        });
-    });
-});

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

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

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

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

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

@@ -1,476 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { batch } from "./batch-utils";
-// Mock the timers/promises module
-vi.mock("timers/promises", () => ({
-    setTimeout: vi.fn(() => Promise.resolve()),
-}));
-// Mock retry-utils to control backoff behavior in tests
-vi.mock("./retry-utils", () => ({
-    calculateErrorBackoffMs: vi.fn(() => 0), // No delay in tests
-    MAX_CONSECUTIVE_ERRORS: 3,
-}));
-describe("batch", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("basic functionality", () => {
-        it("should execute all tasks and return settled results", async () => {
-            const tasks = [
-                () => Promise.resolve("result1"),
-                () => Promise.resolve("result2"),
-                () => Promise.resolve("result3"),
-            ];
-            const results = await batch(tasks);
-            expect(results).toEqual([
-                { status: "fulfilled", value: "result1" },
-                { status: "fulfilled", value: "result2" },
-                { status: "fulfilled", value: "result3" },
-            ]);
-        });
-        it("should handle empty task array", async () => {
-            const results = await batch([]);
-            expect(results).toEqual([]);
-        });
-        it("should handle single task", async () => {
-            const tasks = [() => Promise.resolve("single")];
-            const results = await batch(tasks);
-            expect(results).toEqual([{ status: "fulfilled", value: "single" }]);
-        });
-        it("should maintain result order matching input order", async () => {
-            // Create tasks that resolve in reverse order but should maintain input order
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("first"), 30)),
-                () => new Promise((resolve) => setTimeout(() => resolve("second"), 20)),
-                () => new Promise((resolve) => setTimeout(() => resolve("third"), 10)),
-            ];
-            const results = await batch(tasks);
-            expect(results[0]).toEqual({ status: "fulfilled", value: "first" });
-            expect(results[1]).toEqual({ status: "fulfilled", value: "second" });
-            expect(results[2]).toEqual({ status: "fulfilled", value: "third" });
-        });
-    });
-    describe("concurrency limiting", () => {
-        it("should limit concurrent execution", async () => {
-            let concurrentCount = 0;
-            let maxConcurrent = 0;
-            const createTask = () => () => {
-                concurrentCount++;
-                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
-                return new Promise((resolve) => {
-                    setTimeout(() => {
-                        concurrentCount--;
-                        resolve("done");
-                    }, 10);
-                });
-            };
-            const tasks = Array.from({ length: 20 }, createTask);
-            await batch(tasks, { concurrency: 5 });
-            // Max concurrent should not exceed limit
-            expect(maxConcurrent).toBeLessThanOrEqual(5);
-        });
-        it("should respect custom concurrency limit", async () => {
-            let concurrentCount = 0;
-            let maxConcurrent = 0;
-            const createTask = () => () => {
-                concurrentCount++;
-                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
-                return new Promise((resolve) => {
-                    setTimeout(() => {
-                        concurrentCount--;
-                        resolve("done");
-                    }, 10);
-                });
-            };
-            const tasks = Array.from({ length: 20 }, createTask);
-            await batch(tasks, { concurrency: 3 });
-            expect(maxConcurrent).toBeLessThanOrEqual(3);
-        });
-        it("should handle concurrency limit greater than task count", async () => {
-            const tasks = [() => Promise.resolve(1), () => Promise.resolve(2)];
-            const results = await batch(tasks, { concurrency: 10 });
-            expect(results).toHaveLength(2);
-        });
-    });
-    describe("error handling", () => {
-        it("should handle failing tasks without stopping batch", async () => {
-            const tasks = [
-                () => Promise.resolve("success1"),
-                () => Promise.reject(new Error("failed")),
-                () => Promise.resolve("success2"),
-            ];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0]).toEqual({ status: "fulfilled", value: "success1" });
-            expect(results[1]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(results[2]).toEqual({ status: "fulfilled", value: "success2" });
-        });
-        it("should retry failed tasks when retry is enabled", async () => {
-            let attemptCount = 0;
-            const failTwiceThenSucceed = () => {
-                attemptCount++;
-                if (attemptCount <= 2) {
-                    return Promise.reject(new Error("temporary failure"));
-                }
-                return Promise.resolve("success");
-            };
-            const tasks = [failTwiceThenSucceed];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({ status: "fulfilled", value: "success" });
-            expect(attemptCount).toBe(3); // Initial + 2 retries
-        });
-        it("should give up after MAX_CONSECUTIVE_ERRORS retries", async () => {
-            let attemptCount = 0;
-            const alwaysFail = () => {
-                attemptCount++;
-                return Promise.reject(new Error("always fails"));
-            };
-            const tasks = [alwaysFail];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(attemptCount).toBe(3); // MAX_CONSECUTIVE_ERRORS
-        });
-        it("should not retry when retry is disabled", async () => {
-            let attemptCount = 0;
-            const failTask = () => {
-                attemptCount++;
-                return Promise.reject(new Error("failed"));
-            };
-            const tasks = [failTask];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(attemptCount).toBe(1); // No retries
-        });
-    });
-    describe("options validation", () => {
-        it("should throw error for invalid concurrency", async () => {
-            const tasks = [() => Promise.resolve("test")];
-            await expect(batch(tasks, { concurrency: 0 })).rejects.toThrow("Concurrency must be greater than 0");
-            await expect(batch(tasks, { concurrency: -1 })).rejects.toThrow("Concurrency must be greater than 0");
-        });
-        it("should use default options when not provided", async () => {
-            const tasks = [() => Promise.resolve("test")];
-            const results = await batch(tasks);
-            expect(results).toEqual([{ status: "fulfilled", value: "test" }]);
-        });
-    });
-    describe("mixed success and failure scenarios", () => {
-        it("should handle alternating success and failure", async () => {
-            const tasks = [
-                () => Promise.resolve("success1"),
-                () => Promise.reject(new Error("error1")),
-                () => Promise.resolve("success2"),
-                () => Promise.reject(new Error("error2")),
-                () => Promise.resolve("success3"),
-            ];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            expect(results[2].status).toBe("fulfilled");
-            expect(results[3].status).toBe("rejected");
-            expect(results[4].status).toBe("fulfilled");
-        });
-        it("should handle some tasks succeeding after retry", async () => {
-            let task1Attempts = 0;
-            let task2Attempts = 0;
-            const task1 = () => {
-                task1Attempts++;
-                if (task1Attempts === 1) {
-                    return Promise.reject(new Error("task1 first attempt"));
-                }
-                return Promise.resolve("task1 success");
-            };
-            const task2 = () => {
-                task2Attempts++;
-                return Promise.resolve("task2 success");
-            };
-            const tasks = [task1, task2];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({
-                status: "fulfilled",
-                value: "task1 success",
-            });
-            expect(results[1]).toEqual({
-                status: "fulfilled",
-                value: "task2 success",
-            });
-            expect(task1Attempts).toBe(2); // Initial + 1 retry
-            expect(task2Attempts).toBe(1); // No retry needed
-        });
-    });
-    describe("performance characteristics", () => {
-        it("should complete faster with higher concurrency", async () => {
-            const delay = 50; // ms
-            const taskCount = 10;
-            const tasks = Array.from({ length: taskCount }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), delay)));
-            // Low concurrency (sequential-ish)
-            const start1 = Date.now();
-            await batch([...tasks], { concurrency: 1 });
-            const duration1 = Date.now() - start1;
-            // High concurrency (parallel)
-            const start2 = Date.now();
-            await batch([...tasks], { concurrency: 10 });
-            const duration2 = Date.now() - start2;
-            // High concurrency should be significantly faster
-            // Allow some margin for timing variability
-            expect(duration2).toBeLessThan(duration1 * 0.8);
-        });
-    });
-    describe("result ordering guarantees", () => {
-        it("should maintain exact order with out-of-order completion and mixed results", async () => {
-            // This is the ultimate ordering test - combining:
-            // 1. Tasks that complete in reverse order (via delays)
-            // 2. Mixed success/failure
-            // 3. High concurrency (multiple workers racing)
-            const executionLog = [];
-            const tasks = [
-                // Task 0: Slow success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task0-complete");
-                        resolve("result0");
-                    }, 100);
-                }),
-                // Task 1: Fast failure
-                () => new Promise((_, reject) => {
-                    setTimeout(() => {
-                        executionLog.push("task1-complete");
-                        reject(new Error("error1"));
-                    }, 10);
-                }),
-                // Task 2: Medium success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task2-complete");
-                        resolve("result2");
-                    }, 50);
-                }),
-                // Task 3: Instant failure
-                () => new Promise((_, reject) => {
-                    executionLog.push("task3-complete");
-                    reject(new Error("error3"));
-                }),
-                // Task 4: Medium-slow success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task4-complete");
-                        resolve("result4");
-                    }, 75);
-                }),
-            ];
-            const results = await batch(tasks, { concurrency: 5, retry: false });
-            // Verify all tasks completed
-            expect(executionLog).toHaveLength(5);
-            expect(executionLog).toContain("task0-complete");
-            expect(executionLog).toContain("task1-complete");
-            expect(executionLog).toContain("task2-complete");
-            expect(executionLog).toContain("task3-complete");
-            expect(executionLog).toContain("task4-complete");
-            // BUT results MUST maintain input order despite out-of-order completion
-            expect(results).toHaveLength(5);
-            // Task 0: position 0, slow success
-            expect(results[0]).toEqual({
-                status: "fulfilled",
-                value: "result0",
-            });
-            // Task 1: position 1, fast failure
-            expect(results[1]).toEqual({
-                status: "rejected",
-                reason: expect.objectContaining({
-                    message: "error1",
-                }),
-            });
-            // Task 2: position 2, medium success
-            expect(results[2]).toEqual({
-                status: "fulfilled",
-                value: "result2",
-            });
-            // Task 3: position 3, instant failure
-            expect(results[3]).toEqual({
-                status: "rejected",
-                reason: expect.objectContaining({
-                    message: "error3",
-                }),
-            });
-            // Task 4: position 4, medium-slow success
-            expect(results[4]).toEqual({
-                status: "fulfilled",
-                value: "result4",
-            });
-        });
-        it("should match Promise.allSettled ordering behavior exactly", async () => {
-            // This test ensures our batch function has identical ordering to Promise.allSettled
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("a"), 30)),
-                () => new Promise((_, reject) => setTimeout(() => reject(new Error("b")), 10)),
-                () => new Promise((resolve) => setTimeout(() => resolve("c"), 20)),
-            ];
-            // Run both in parallel
-            const [batchResults, settledResults] = await Promise.all([
-                batch(tasks.map((t) => t), { concurrency: 3, retry: false }),
-                Promise.allSettled(tasks.map((t) => t())),
-            ]);
-            // Results should have same structure
-            expect(batchResults).toHaveLength(settledResults.length);
-            // Compare each result
-            for (let i = 0; i < batchResults.length; i++) {
-                const batchResult = batchResults[i];
-                const settledResult = settledResults[i];
-                expect(batchResult.status).toBe(settledResult.status);
-                if (batchResult.status === "fulfilled" &&
-                    settledResult.status === "fulfilled") {
-                    expect(batchResult.value).toBe(settledResult.value);
-                }
-                if (batchResult.status === "rejected" &&
-                    settledResult.status === "rejected") {
-                    expect(batchResult.reason).toBeInstanceOf(Error);
-                    expect(settledResult.reason).toBeInstanceOf(Error);
-                }
-            }
-        });
-    });
-    describe("timeout handling", () => {
-        beforeEach(async () => {
-            // Unmock setTimeout for timeout tests to allow real timing
-            vi.unmock("timers/promises");
-            // Re-import batch to get the non-mocked version
-            vi.resetModules();
-        });
-        afterEach(() => {
-            // Restore mocks after timeout tests
-            vi.doMock("timers/promises", () => ({
-                setTimeout: vi.fn(() => Promise.resolve()),
-            }));
-        });
-        it("should throw error when overall batch timeout is exceeded", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = Array.from({ length: 10 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
-            await expect(batch(tasks, { concurrency: 2, timeoutMs: 50 })).rejects.toThrow("Batch operation timed out");
-        });
-        it("should timeout individual tasks when taskTimeoutMs is set", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("instant"), // Instant task - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow"), 500)), // Slow task - should timeout
-                () => Promise.resolve("instant2"), // Another instant task - should not timeout
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 100, // 100ms timeout
-                retry: false,
-                batchDelay: 0, // Disable batch delay for timing reliability
-            });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            if (results[1].status === "rejected") {
-                expect(results[1].reason).toBeInstanceOf(Error);
-                expect(results[1].reason.message).toContain("timed out");
-            }
-            expect(results[2].status).toBe("fulfilled");
-        });
-        it("should not retry tasks that timeout", async () => {
-            const { batch } = await import("./batch-utils");
-            let attemptCount = 0;
-            const slowTask = () => {
-                attemptCount++;
-                return new Promise((resolve) => setTimeout(() => resolve("done"), 200));
-            };
-            const results = await batch([slowTask], {
-                taskTimeoutMs: 50,
-                retry: true,
-            });
-            expect(results[0].status).toBe("rejected");
-            expect(attemptCount).toBe(1); // Should not retry timeout errors
-        });
-        it("should validate timeout parameters", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [() => Promise.resolve("test")];
-            await expect(batch(tasks, { timeoutMs: 0 })).rejects.toThrow("Timeout must be greater than 0");
-            await expect(batch(tasks, { timeoutMs: -100 })).rejects.toThrow("Timeout must be greater than 0");
-            await expect(batch(tasks, { taskTimeoutMs: 0 })).rejects.toThrow("Task timeout must be greater than 0");
-            await expect(batch(tasks, { taskTimeoutMs: -100 })).rejects.toThrow("Task timeout must be greater than 0");
-        });
-        it("should complete tasks that finish before overall timeout", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("task1"), 10)),
-                () => new Promise((resolve) => setTimeout(() => resolve("task2"), 20)),
-                () => new Promise((resolve) => setTimeout(() => resolve("task3"), 30)),
-            ];
-            const results = await batch(tasks, {
-                timeoutMs: 100,
-                concurrency: 3,
-            });
-            expect(results).toHaveLength(3);
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("fulfilled");
-            expect(results[2].status).toBe("fulfilled");
-        });
-        it("should report tasks remaining when batch timeout occurs", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = Array.from({ length: 20 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
-            try {
-                await batch(tasks, { concurrency: 2, timeoutMs: 50 });
-                expect.fail("Should have thrown timeout error");
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(Error);
-                expect(error.message).toContain("task(s) not completed");
-            }
-        });
-        it("should allow taskTimeoutMs without overall timeout affecting quick tasks", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("instant1"),
-                () => Promise.resolve("instant2"),
-                () => Promise.resolve("instant3"),
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 1000,
-                timeoutMs: 5000,
-            });
-            expect(results).toHaveLength(3);
-            expect(results.every((r) => r.status === "fulfilled")).toBe(true);
-        });
-        it("should handle mix of timed out and successful tasks", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("fast1"), // Instant - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow1"), 500)), // Slow - should timeout
-                () => Promise.resolve("fast2"), // Instant - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow2"), 500)), // Slow - should timeout
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 100,
-                retry: false,
-                concurrency: 4,
-                batchDelay: 0, // Disable batch delay for timing reliability
-            });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            expect(results[2].status).toBe("fulfilled");
-            expect(results[3].status).toBe("rejected");
-        });
-        it("should use default timeout when not specified", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("test1"),
-                () => Promise.resolve("test2"),
-            ];
-            // Should not throw with default 3-minute timeout
-            const results = await batch(tasks);
-            expect(results).toHaveLength(2);
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("fulfilled");
-        });
-    });
-});

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

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

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

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