@zapier/zapier-sdk 0.41.2 → 0.42.1

package/dist/utils/abort-utils.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Wraps the subset of `AbortSignal` static methods that `combineAbortSignals`
+ * needs. Serves two real uses:
+ *
+ *   1. Runtime feature detection. `AbortSignal.any()` isn't present on every
+ *      platform we support (Node <19, older browsers, some sandboxed
+ *      runtimes), so `combineAbortSignals` checks `any` at call time and
+ *      falls back to manual listener wiring when it's missing.
+ *   2. Test injection. Tests pass a fake `abortSignalApi` to force a
+ *      specific branch (native vs. fallback) regardless of what the current
+ *      runtime actually supports.
+ *
+ * By default, `combineAbortSignals` reads the real globals via
+ * `getAbortSignalApi()`; callers rarely need to pass this explicitly.
+ */
+export interface AbortSignalApi {
+    any?: (signals: AbortSignal[]) => AbortSignal;
+}
+export interface DisposableAbortSignal {
+    signal: AbortSignal;
+    /**
+     * Release the resources backing this signal (timers, event listeners).
+     * Safe to call multiple times.
+     */
+    dispose: () => void;
+}
+export declare function createTimeoutError(timeoutMs: number): Error;
+/**
+ * Creates an AbortSignal that fires after `timeoutMs` using a cancellable
+ * `AbortController` + `setTimeout`. We intentionally don't delegate to the
+ * native `AbortSignal.timeout()` — its returned signal has no way to cancel
+ * the underlying timer, which would make `dispose()` a lie on that path and
+ * give us divergent abort-reason messages across runtimes.
+ *
+ * On Node-like runtimes we `unref()` the timer so a pending timeout doesn't
+ * keep the process alive. In browsers `.unref` is absent and the guard is a
+ * harmless no-op.
+ *
+ * The signal's abort reason is a `DOMException` with `name: "TimeoutError"`
+ * so callers can distinguish timeout-driven aborts from caller-driven ones.
+ *
+ * Always call `dispose()` when the signal is no longer needed to clear the
+ * pending timer.
+ */
+export declare function createTimeoutAbortSignal({ timeoutMs, }: {
+    timeoutMs: number;
+}): DisposableAbortSignal;
+/**
+ * Combines multiple disposable abort handles so the result aborts when *any*
+ * source does. Uses native `AbortSignal.any()` when available; otherwise wires
+ * up listeners manually.
+ *
+ * Returns `undefined` when the array is empty, or passes through a single
+ * handle without wrapping it.
+ *
+ * Always call `dispose()` on the result when it is no longer needed. This
+ * removes event listeners from source signals and calls `dispose()` on every
+ * input handle (releasing timers, etc).
+ */
+export declare function combineAbortSignals({ handles, abortSignalApi, }: {
+    handles: DisposableAbortSignal[];
+    abortSignalApi?: AbortSignalApi;
+}): DisposableAbortSignal | undefined;
+//# sourceMappingURL=abort-utils.d.ts.map

package/dist/utils/abort-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort-utils.d.ts","sourceRoot":"","sources":["../../src/utils/abort-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,CAAC;CAC/C;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAOD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAW3D;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,SAAS,GACV,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,qBAAqB,CAuBxB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,OAAO,EACP,cAAoC,GACrC,EAAE;IACD,OAAO,EAAE,qBAAqB,EAAE,CAAC;IACjC,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,GAAG,qBAAqB,GAAG,SAAS,CAwCpC"}

package/dist/utils/abort-utils.js

@@ -0,0 +1,107 @@
+function getAbortSignalApi() {
+    const api = AbortSignal;
+    return { any: api.any };
+}
+export function createTimeoutError(timeoutMs) {
+    if (typeof DOMException !== "undefined") {
+        return new DOMException(`The operation timed out after ${timeoutMs}ms`, "TimeoutError");
+    }
+    const error = new Error(`The operation timed out after ${timeoutMs}ms`);
+    error.name = "TimeoutError";
+    return error;
+}
+// ---------------------------------------------------------------------------
+// createTimeoutAbortSignal
+// ---------------------------------------------------------------------------
+/**
+ * Creates an AbortSignal that fires after `timeoutMs` using a cancellable
+ * `AbortController` + `setTimeout`. We intentionally don't delegate to the
+ * native `AbortSignal.timeout()` — its returned signal has no way to cancel
+ * the underlying timer, which would make `dispose()` a lie on that path and
+ * give us divergent abort-reason messages across runtimes.
+ *
+ * On Node-like runtimes we `unref()` the timer so a pending timeout doesn't
+ * keep the process alive. In browsers `.unref` is absent and the guard is a
+ * harmless no-op.
+ *
+ * The signal's abort reason is a `DOMException` with `name: "TimeoutError"`
+ * so callers can distinguish timeout-driven aborts from caller-driven ones.
+ *
+ * Always call `dispose()` when the signal is no longer needed to clear the
+ * pending timer.
+ */
+export function createTimeoutAbortSignal({ timeoutMs, }) {
+    const controller = new AbortController();
+    let timer = setTimeout(() => {
+        timer = undefined;
+        controller.abort(createTimeoutError(timeoutMs));
+    }, timeoutMs);
+    // Node (and Bun/Deno): don't let a pending timeout block process exit.
+    // Browsers: `unref` is undefined on the numeric handle; this is a no-op.
+    const maybeUnref = timer.unref;
+    if (typeof maybeUnref === "function") {
+        maybeUnref.call(timer);
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// combineAbortSignals
+// ---------------------------------------------------------------------------
+/**
+ * Combines multiple disposable abort handles so the result aborts when *any*
+ * source does. Uses native `AbortSignal.any()` when available; otherwise wires
+ * up listeners manually.
+ *
+ * Returns `undefined` when the array is empty, or passes through a single
+ * handle without wrapping it.
+ *
+ * Always call `dispose()` on the result when it is no longer needed. This
+ * removes event listeners from source signals and calls `dispose()` on every
+ * input handle (releasing timers, etc).
+ */
+export function combineAbortSignals({ handles, abortSignalApi = getAbortSignalApi(), }) {
+    if (handles.length === 0)
+        return undefined;
+    if (handles.length === 1)
+        return handles[0];
+    const disposeInputs = () => {
+        for (const handle of handles)
+            handle.dispose();
+    };
+    if (abortSignalApi.any) {
+        return {
+            signal: abortSignalApi.any(handles.map((h) => h.signal)),
+            dispose: disposeInputs,
+        };
+    }
+    // Fallback: wire up listeners manually.
+    const controller = new AbortController();
+    const listeners = [];
+    for (const { signal: source } of handles) {
+        if (source.aborted) {
+            controller.abort(source.reason);
+            return { signal: controller.signal, dispose: disposeInputs };
+        }
+        const handler = () => controller.abort(source.reason);
+        source.addEventListener("abort", handler, { once: true });
+        listeners.push({ source, handler });
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            for (const { source, handler } of listeners) {
+                source.removeEventListener("abort", handler);
+            }
+            listeners.length = 0;
+            disposeInputs();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.41.2",
+  "version": "0.42.1",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",