@trigger.dev/react-hooks 0.0.0-v3-prerelease-20241118124944 → 0.0.0-v3-prerelease-20250108131948

package/dist/commonjs/contexts.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
 import type { ApiClientConfiguration } from "@trigger.dev/core/v3";
-declare const TriggerAuthContext: React.Context<ApiClientConfiguration | undefined>, useTriggerAuthContext: () => ApiClientConfiguration;
-export { TriggerAuthContext, useTriggerAuthContext };
+declare const TriggerAuthContext: React.Context<ApiClientConfiguration | undefined>, useTriggerAuthContext: () => ApiClientConfiguration, useTriggerAuthContextOptional: () => ApiClientConfiguration | Partial<ApiClientConfiguration>;
+export { TriggerAuthContext, useTriggerAuthContext, useTriggerAuthContextOptional };

package/dist/commonjs/contexts.js

@@ -1,9 +1,10 @@
 "use client";
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTriggerAuthContext = exports.TriggerAuthContext = void 0;
+exports.useTriggerAuthContextOptional = exports.useTriggerAuthContext = exports.TriggerAuthContext = void 0;
 const createContextAndHook_js_1 = require("./utils/createContextAndHook.js");
-const [TriggerAuthContext, useTriggerAuthContext] = (0, createContextAndHook_js_1.createContextAndHook)("TriggerAuthContext");
+const [TriggerAuthContext, useTriggerAuthContext, useTriggerAuthContextOptional] = (0, createContextAndHook_js_1.createContextAndHook)("TriggerAuthContext");
 exports.TriggerAuthContext = TriggerAuthContext;
 exports.useTriggerAuthContext = useTriggerAuthContext;
+exports.useTriggerAuthContextOptional = useTriggerAuthContextOptional;
 //# sourceMappingURL=contexts.js.map

package/dist/commonjs/contexts.js.map

@@ -1 +1 @@
-{"version":3,"file":"contexts.js","sourceRoot":"","sources":["../../src/contexts.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;;AAGb,6EAAuE;AAGvE,MAAM,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,GAC/C,IAAA,8CAAoB,EAAyB,oBAAoB,CAAC,CAAC;AAE5D,gDAAkB;AAAE,sDAAqB"}
+{"version":3,"file":"contexts.js","sourceRoot":"","sources":["../../src/contexts.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;;AAGb,6EAAuE;AAGvE,MAAM,CAAC,kBAAkB,EAAE,qBAAqB,EAAE,6BAA6B,CAAC,GAC9E,IAAA,8CAAoB,EAAyB,oBAAoB,CAAC,CAAC;AAE5D,gDAAkB;AAAE,sDAAqB;AAAE,sEAA6B"}

package/dist/commonjs/hooks/useApiClient.d.ts

@@ -1,2 +1,39 @@
-import { ApiClient } from "@trigger.dev/core/v3";
-export declare function useApiClient(): ApiClient;
+import { ApiClient, ApiRequestOptions } from "@trigger.dev/core/v3";
+/**
+ * Configuration options for creating an API client instance.
+ */
+export type UseApiClientOptions = {
+    /** Optional access token for authentication */
+    accessToken?: string;
+    /** Optional base URL for the API endpoints */
+    baseURL?: string;
+    /** Optional additional request configuration */
+    requestOptions?: ApiRequestOptions;
+    /**
+     * Enable or disable the API client instance.
+     *
+     * Set enabled to false if you don't have an accessToken and don't want to throw an error.
+     */
+    enabled?: boolean;
+};
+/**
+ * Hook to create an API client instance using authentication context or provided options.
+ *
+ * @param {UseApiClientOptions} [options] - Configuration options for the API client
+ * @returns {ApiClient} An initialized API client instance
+ * @throws {Error} When no access token is available in either context or options
+ *
+ * @example
+ * ```ts
+ * // Using context authentication
+ * const apiClient = useApiClient();
+ *
+ * // Using custom options
+ * const apiClient = useApiClient({
+ *   accessToken: "your-access-token",
+ *   baseURL: "https://api.my-trigger.com",
+ *   requestOptions: { retry: { maxAttempts: 10 } }
+ * });
+ * ```
+ */
+export declare function useApiClient(options?: UseApiClientOptions): ApiClient | undefined;

package/dist/commonjs/hooks/useApiClient.js

@@ -4,12 +4,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useApiClient = useApiClient;
 const v3_1 = require("@trigger.dev/core/v3");
 const contexts_js_1 = require("../contexts.js");
-function useApiClient() {
-    const auth = (0, contexts_js_1.useTriggerAuthContext)();
-    const baseUrl = auth.baseURL ?? "https://api.trigger.dev";
-    if (!auth.accessToken) {
-        throw new Error("Missing accessToken in TriggerAuthContext");
+/**
+ * Hook to create an API client instance using authentication context or provided options.
+ *
+ * @param {UseApiClientOptions} [options] - Configuration options for the API client
+ * @returns {ApiClient} An initialized API client instance
+ * @throws {Error} When no access token is available in either context or options
+ *
+ * @example
+ * ```ts
+ * // Using context authentication
+ * const apiClient = useApiClient();
+ *
+ * // Using custom options
+ * const apiClient = useApiClient({
+ *   accessToken: "your-access-token",
+ *   baseURL: "https://api.my-trigger.com",
+ *   requestOptions: { retry: { maxAttempts: 10 } }
+ * });
+ * ```
+ */
+function useApiClient(options) {
+    const auth = (0, contexts_js_1.useTriggerAuthContextOptional)();
+    const baseUrl = options?.baseURL ?? auth?.baseURL ?? "https://api.trigger.dev";
+    const accessToken = options?.accessToken ?? auth?.accessToken;
+    if (!accessToken) {
+        if (options?.enabled === false) {
+            return undefined;
+        }
+        throw new Error("Missing accessToken in TriggerAuthContext or useApiClient options");
     }
-    return new v3_1.ApiClient(baseUrl, auth.accessToken, auth.requestOptions);
+    const requestOptions = {
+        ...auth?.requestOptions,
+        ...options?.requestOptions,
+    };
+    return new v3_1.ApiClient(baseUrl, accessToken, requestOptions);
 }
 //# sourceMappingURL=useApiClient.js.map

package/dist/commonjs/hooks/useApiClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"useApiClient.js","sourceRoot":"","sources":["../../../src/hooks/useApiClient.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;AAKb,oCAUC;AAbD,6CAAiD;AACjD,gDAAuD;AAEvD,SAAgB,YAAY;IAC1B,MAAM,IAAI,GAAG,IAAA,mCAAqB,GAAE,CAAC;IAErC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,yBAAyB,CAAC;IAE1D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,IAAI,cAAS,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;AACvE,CAAC"}
+{"version":3,"file":"useApiClient.js","sourceRoot":"","sources":["../../../src/hooks/useApiClient.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;AA4Cb,oCAoBC;AA9DD,6CAAoE;AACpE,gDAA+D;AAqB/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,YAAY,CAAC,OAA6B;IACxD,MAAM,IAAI,GAAG,IAAA,2CAA6B,GAAE,CAAC;IAE7C,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI,yBAAyB,CAAC;IAC/E,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,IAAI,EAAE,WAAW,CAAC;IAE9D,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,IAAI,OAAO,EAAE,OAAO,KAAK,KAAK,EAAE,CAAC;YAC/B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;IACvF,CAAC;IAED,MAAM,cAAc,GAAsB;QACxC,GAAG,IAAI,EAAE,cAAc;QACvB,GAAG,OAAO,EAAE,cAAc;KAC3B,CAAC;IAEF,OAAO,IAAI,cAAS,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC7D,CAAC"}

package/dist/commonjs/hooks/useRealtime.d.ts

@@ -0,0 +1,117 @@
+import { AnyTask, RealtimeRun } from "@trigger.dev/core/v3";
+import { UseApiClientOptions } from "./useApiClient.js";
+export type UseRealtimeRunOptions = UseApiClientOptions & {
+    id?: string;
+    enabled?: boolean;
+    experimental_throttleInMs?: number;
+};
+export type UseRealtimeSingleRunOptions<TTask extends AnyTask = AnyTask> = UseRealtimeRunOptions & {
+    /**
+     * Callback this is called when the run completes, an error occurs, or the subscription is stopped.
+     *
+     * @param {RealtimeRun<TTask>} run - The run object
+     * @param {Error} [err] - The error that occurred
+     */
+    onComplete?: (run: RealtimeRun<TTask>, err?: Error) => void;
+    /**
+     * Whether to stop the subscription when the run completes
+     *
+     * @default true
+     *
+     * Set this to false if you are making updates to the run metadata after completion through child runs
+     */
+    stopOnCompletion?: boolean;
+};
+export type UseRealtimeRunInstance<TTask extends AnyTask = AnyTask> = {
+    run: RealtimeRun<TTask> | undefined;
+    error: Error | undefined;
+    /**
+     * Abort the current request immediately.
+     */
+    stop: () => void;
+};
+/**
+ * Hook to subscribe to realtime updates of a task run.
+ *
+ * @template TTask - The type of the task
+ * @param {string} [runId] - The unique identifier of the run to subscribe to
+ * @param {UseRealtimeSingleRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunInstance<TTask>} An object containing the current state of the run, error handling, and control methods
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { run, error } = useRealtimeRun<typeof myTask>('run-id-123');
+ * ```
+ */
+export declare function useRealtimeRun<TTask extends AnyTask>(runId?: string, options?: UseRealtimeSingleRunOptions<TTask>): UseRealtimeRunInstance<TTask>;
+export type StreamResults<TStreams extends Record<string, any>> = {
+    [K in keyof TStreams]: Array<TStreams[K]>;
+};
+export type UseRealtimeRunWithStreamsInstance<TTask extends AnyTask = AnyTask, TStreams extends Record<string, any> = Record<string, any>> = {
+    run: RealtimeRun<TTask> | undefined;
+    streams: StreamResults<TStreams>;
+    error: Error | undefined;
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop: () => void;
+};
+/**
+ * Hook to subscribe to realtime updates of a task run with associated data streams.
+ *
+ * @template TTask - The type of the task
+ * @template TStreams - The type of the streams data
+ * @param {string} [runId] - The unique identifier of the run to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunWithStreamsInstance<TTask, TStreams>} An object containing the current state of the run, streams data, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { run, streams, error } = useRealtimeRunWithStreams<typeof myTask, {
+ *   output: string;
+ * }>('run-id-123');
+ * ```
+ */
+export declare function useRealtimeRunWithStreams<TTask extends AnyTask = AnyTask, TStreams extends Record<string, any> = Record<string, any>>(runId?: string, options?: UseRealtimeSingleRunOptions<TTask>): UseRealtimeRunWithStreamsInstance<TTask, TStreams>;
+export type UseRealtimeRunsInstance<TTask extends AnyTask = AnyTask> = {
+    runs: RealtimeRun<TTask>[];
+    error: Error | undefined;
+    /**
+     * Abort the current request immediately.
+     */
+    stop: () => void;
+};
+/**
+ * Hook to subscribe to realtime updates of task runs filtered by tag(s).
+ *
+ * @template TTask - The type of the task
+ * @param {string | string[]} tag - The tag or array of tags to filter runs by
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunsInstance<TTask>} An object containing the current state of the runs and any error encountered
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>('my-tag');
+ * // Or with multiple tags
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>(['tag1', 'tag2']);
+ * ```
+ */
+export declare function useRealtimeRunsWithTag<TTask extends AnyTask>(tag: string | string[], options?: UseRealtimeRunOptions): UseRealtimeRunsInstance<TTask>;
+/**
+ * Hook to subscribe to realtime updates of a batch of task runs.
+ *
+ * @template TTask - The type of the task
+ * @param {string} batchId - The unique identifier of the batch to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunsInstance<TTask>} An object containing the current state of the runs, error handling, and control methods
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { runs, error } = useRealtimeBatch<typeof myTask>('batch-id-123');
+ * ```
+ */
+export declare function useRealtimeBatch<TTask extends AnyTask>(batchId: string, options?: UseRealtimeRunOptions): UseRealtimeRunsInstance<TTask>;

package/dist/commonjs/hooks/useRealtime.js

@@ -0,0 +1,409 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRealtimeRun = useRealtimeRun;
+exports.useRealtimeRunWithStreams = useRealtimeRunWithStreams;
+exports.useRealtimeRunsWithTag = useRealtimeRunsWithTag;
+exports.useRealtimeBatch = useRealtimeBatch;
+const react_1 = require("react");
+const trigger_swr_js_1 = require("../utils/trigger-swr.js");
+const useApiClient_js_1 = require("./useApiClient.js");
+const throttle_js_1 = require("../utils/throttle.js");
+/**
+ * Hook to subscribe to realtime updates of a task run.
+ *
+ * @template TTask - The type of the task
+ * @param {string} [runId] - The unique identifier of the run to subscribe to
+ * @param {UseRealtimeSingleRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunInstance<TTask>} An object containing the current state of the run, error handling, and control methods
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { run, error } = useRealtimeRun<typeof myTask>('run-id-123');
+ * ```
+ */
+function useRealtimeRun(runId, options) {
+    const hookId = (0, react_1.useId)();
+    const idKey = options?.id ?? hookId;
+    // Store the streams state in SWR, using the idKey as the key to share states.
+    const { data: run, mutate: mutateRun } = (0, trigger_swr_js_1.useSWR)([idKey, "run"], null);
+    const { data: error = undefined, mutate: setError } = (0, trigger_swr_js_1.useSWR)([idKey, "error"], null);
+    // Add state to track when the subscription is complete
+    const { data: isComplete = false, mutate: setIsComplete } = (0, trigger_swr_js_1.useSWR)([idKey, "complete"], null);
+    // Abort controller to cancel the current API call.
+    const abortControllerRef = (0, react_1.useRef)(null);
+    const stop = (0, react_1.useCallback)(() => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+        }
+    }, []);
+    const apiClient = (0, useApiClient_js_1.useApiClient)(options);
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!runId || !apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeRun(runId, apiClient, mutateRun, abortControllerRef, typeof options?.stopOnCompletion === "boolean" ? options.stopOnCompletion : true);
+        }
+        catch (err) {
+            // Ignore abort errors as they are expected.
+            if (err.name === "AbortError") {
+                abortControllerRef.current = null;
+                return;
+            }
+            setError(err);
+        }
+        finally {
+            if (abortControllerRef.current) {
+                abortControllerRef.current = null;
+            }
+            // Mark the subscription as complete
+            setIsComplete(true);
+        }
+    }, [runId, mutateRun, abortControllerRef, apiClient, setError]);
+    const hasCalledOnCompleteRef = (0, react_1.useRef)(false);
+    // Effect to handle onComplete callback
+    (0, react_1.useEffect)(() => {
+        if (isComplete && run && options?.onComplete && !hasCalledOnCompleteRef.current) {
+            options.onComplete(run, error);
+            hasCalledOnCompleteRef.current = true;
+        }
+    }, [isComplete, run, error, options?.onComplete]);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        if (!runId) {
+            return;
+        }
+        triggerRequest().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [runId, stop, options?.enabled]);
+    return { run, error, stop };
+}
+/**
+ * Hook to subscribe to realtime updates of a task run with associated data streams.
+ *
+ * @template TTask - The type of the task
+ * @template TStreams - The type of the streams data
+ * @param {string} [runId] - The unique identifier of the run to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunWithStreamsInstance<TTask, TStreams>} An object containing the current state of the run, streams data, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { run, streams, error } = useRealtimeRunWithStreams<typeof myTask, {
+ *   output: string;
+ * }>('run-id-123');
+ * ```
+ */
+function useRealtimeRunWithStreams(runId, options) {
+    const hookId = (0, react_1.useId)();
+    const idKey = options?.id ?? hookId;
+    const [initialStreamsFallback] = (0, react_1.useState)({});
+    // Store the streams state in SWR, using the idKey as the key to share states.
+    const { data: streams, mutate: mutateStreams } = (0, trigger_swr_js_1.useSWR)([idKey, "streams"], null, {
+        fallbackData: initialStreamsFallback,
+    });
+    // Keep the latest streams in a ref.
+    const streamsRef = (0, react_1.useRef)(streams ?? {});
+    (0, react_1.useEffect)(() => {
+        streamsRef.current = streams || {};
+    }, [streams]);
+    // Store the streams state in SWR, using the idKey as the key to share states.
+    const { data: run, mutate: mutateRun } = (0, trigger_swr_js_1.useSWR)([idKey, "run"], null);
+    // Add state to track when the subscription is complete
+    const { data: isComplete = false, mutate: setIsComplete } = (0, trigger_swr_js_1.useSWR)([idKey, "complete"], null);
+    const { data: error = undefined, mutate: setError } = (0, trigger_swr_js_1.useSWR)([idKey, "error"], null);
+    // Abort controller to cancel the current API call.
+    const abortControllerRef = (0, react_1.useRef)(null);
+    const stop = (0, react_1.useCallback)(() => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+        }
+    }, []);
+    const apiClient = (0, useApiClient_js_1.useApiClient)(options);
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!runId || !apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeRunWithStreams(runId, apiClient, mutateRun, mutateStreams, streamsRef, abortControllerRef, typeof options?.stopOnCompletion === "boolean" ? options.stopOnCompletion : true, options?.experimental_throttleInMs);
+        }
+        catch (err) {
+            // Ignore abort errors as they are expected.
+            if (err.name === "AbortError") {
+                abortControllerRef.current = null;
+                return;
+            }
+            setError(err);
+        }
+        finally {
+            if (abortControllerRef.current) {
+                abortControllerRef.current = null;
+            }
+            // Mark the subscription as complete
+            setIsComplete(true);
+        }
+    }, [runId, mutateRun, mutateStreams, streamsRef, abortControllerRef, apiClient, setError]);
+    const hasCalledOnCompleteRef = (0, react_1.useRef)(false);
+    // Effect to handle onComplete callback
+    (0, react_1.useEffect)(() => {
+        if (isComplete && run && options?.onComplete && !hasCalledOnCompleteRef.current) {
+            options.onComplete(run, error);
+            hasCalledOnCompleteRef.current = true;
+        }
+    }, [isComplete, run, error, options?.onComplete]);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        if (!runId) {
+            return;
+        }
+        triggerRequest().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [runId, stop, options?.enabled]);
+    return { run, streams: streams ?? initialStreamsFallback, error, stop };
+}
+/**
+ * Hook to subscribe to realtime updates of task runs filtered by tag(s).
+ *
+ * @template TTask - The type of the task
+ * @param {string | string[]} tag - The tag or array of tags to filter runs by
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunsInstance<TTask>} An object containing the current state of the runs and any error encountered
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>('my-tag');
+ * // Or with multiple tags
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>(['tag1', 'tag2']);
+ * ```
+ */
+function useRealtimeRunsWithTag(tag, options) {
+    const hookId = (0, react_1.useId)();
+    const idKey = options?.id ?? hookId;
+    // Store the streams state in SWR, using the idKey as the key to share states.
+    const { data: runs, mutate: mutateRuns } = (0, trigger_swr_js_1.useSWR)([idKey, "run"], null, {
+        fallbackData: [],
+    });
+    // Keep the latest streams in a ref.
+    const runsRef = (0, react_1.useRef)([]);
+    (0, react_1.useEffect)(() => {
+        runsRef.current = runs ?? [];
+    }, [runs]);
+    const { data: error = undefined, mutate: setError } = (0, trigger_swr_js_1.useSWR)([idKey, "error"], null);
+    // Abort controller to cancel the current API call.
+    const abortControllerRef = (0, react_1.useRef)(null);
+    const stop = (0, react_1.useCallback)(() => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+        }
+    }, []);
+    const apiClient = (0, useApiClient_js_1.useApiClient)(options);
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeRunsWithTag(tag, apiClient, mutateRuns, runsRef, abortControllerRef);
+        }
+        catch (err) {
+            // Ignore abort errors as they are expected.
+            if (err.name === "AbortError") {
+                abortControllerRef.current = null;
+                return;
+            }
+            setError(err);
+        }
+        finally {
+            if (abortControllerRef.current) {
+                abortControllerRef.current = null;
+            }
+        }
+    }, [tag, mutateRuns, runsRef, abortControllerRef, apiClient, setError]);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        triggerRequest().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [tag, stop, options?.enabled]);
+    return { runs: runs ?? [], error, stop };
+}
+/**
+ * Hook to subscribe to realtime updates of a batch of task runs.
+ *
+ * @template TTask - The type of the task
+ * @param {string} batchId - The unique identifier of the batch to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunsInstance<TTask>} An object containing the current state of the runs, error handling, and control methods
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { runs, error } = useRealtimeBatch<typeof myTask>('batch-id-123');
+ * ```
+ */
+function useRealtimeBatch(batchId, options) {
+    const hookId = (0, react_1.useId)();
+    const idKey = options?.id ?? hookId;
+    // Store the streams state in SWR, using the idKey as the key to share states.
+    const { data: runs, mutate: mutateRuns } = (0, trigger_swr_js_1.useSWR)([idKey, "run"], null, {
+        fallbackData: [],
+    });
+    // Keep the latest streams in a ref.
+    const runsRef = (0, react_1.useRef)([]);
+    (0, react_1.useEffect)(() => {
+        runsRef.current = runs ?? [];
+    }, [runs]);
+    const { data: error = undefined, mutate: setError } = (0, trigger_swr_js_1.useSWR)([idKey, "error"], null);
+    // Abort controller to cancel the current API call.
+    const abortControllerRef = (0, react_1.useRef)(null);
+    const stop = (0, react_1.useCallback)(() => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+        }
+    }, []);
+    const apiClient = (0, useApiClient_js_1.useApiClient)(options);
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeBatch(batchId, apiClient, mutateRuns, runsRef, abortControllerRef);
+        }
+        catch (err) {
+            // Ignore abort errors as they are expected.
+            if (err.name === "AbortError") {
+                abortControllerRef.current = null;
+                return;
+            }
+            setError(err);
+        }
+        finally {
+            if (abortControllerRef.current) {
+                abortControllerRef.current = null;
+            }
+        }
+    }, [batchId, mutateRuns, runsRef, abortControllerRef, apiClient, setError]);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        triggerRequest().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [batchId, stop, options?.enabled]);
+    return { runs: runs ?? [], error, stop };
+}
+async function processRealtimeBatch(batchId, apiClient, mutateRunsData, existingRunsRef, abortControllerRef) {
+    const subscription = apiClient.subscribeToBatch(batchId, {
+        signal: abortControllerRef.current?.signal,
+    });
+    for await (const part of subscription) {
+        mutateRunsData(insertRunShapeInOrder(existingRunsRef.current, part));
+    }
+}
+// Inserts and then orders by the run number, and ensures that the run is not duplicated
+function insertRunShapeInOrder(previousRuns, run) {
+    const existingRun = previousRuns.find((r) => r.id === run.id);
+    if (existingRun) {
+        return previousRuns.map((r) => (r.id === run.id ? run : r));
+    }
+    const runNumber = run.number;
+    const index = previousRuns.findIndex((r) => r.number > runNumber);
+    if (index === -1) {
+        return [...previousRuns, run];
+    }
+    return [...previousRuns.slice(0, index), run, ...previousRuns.slice(index)];
+}
+async function processRealtimeRunsWithTag(tag, apiClient, mutateRunsData, existingRunsRef, abortControllerRef) {
+    const subscription = apiClient.subscribeToRunsWithTag(tag, {
+        signal: abortControllerRef.current?.signal,
+    });
+    for await (const part of subscription) {
+        mutateRunsData(insertRunShape(existingRunsRef.current, part));
+    }
+}
+// Replaces or inserts a run shape, ordered by the createdAt timestamp
+function insertRunShape(previousRuns, run) {
+    const existingRun = previousRuns.find((r) => r.id === run.id);
+    if (existingRun) {
+        return previousRuns.map((r) => (r.id === run.id ? run : r));
+    }
+    const createdAt = run.createdAt;
+    const index = previousRuns.findIndex((r) => r.createdAt > createdAt);
+    if (index === -1) {
+        return [...previousRuns, run];
+    }
+    return [...previousRuns.slice(0, index), run, ...previousRuns.slice(index)];
+}
+async function processRealtimeRunWithStreams(runId, apiClient, mutateRunData, mutateStreamData, existingDataRef, abortControllerRef, stopOnCompletion = true, throttleInMs) {
+    const subscription = apiClient.subscribeToRun(runId, {
+        signal: abortControllerRef.current?.signal,
+        closeOnComplete: stopOnCompletion,
+    });
+    const streamQueue = (0, throttle_js_1.createThrottledQueue)(async (updates) => {
+        const nextStreamData = { ...existingDataRef.current };
+        // Group updates by type
+        const updatesByType = updates.reduce((acc, update) => {
+            if (!acc[update.type]) {
+                acc[update.type] = [];
+            }
+            acc[update.type].push(update.chunk);
+            return acc;
+        }, {});
+        // Apply all updates
+        for (const [type, chunks] of Object.entries(updatesByType)) {
+            // @ts-ignore
+            nextStreamData[type] = [...(existingDataRef.current[type] || []), ...chunks];
+        }
+        mutateStreamData(nextStreamData);
+    }, throttleInMs);
+    for await (const part of subscription.withStreams()) {
+        if (part.type === "run") {
+            mutateRunData(part.run);
+        }
+        else {
+            streamQueue.add({
+                type: part.type,
+                // @ts-ignore
+                chunk: part.chunk,
+            });
+        }
+    }
+}
+async function processRealtimeRun(runId, apiClient, mutateRunData, abortControllerRef, stopOnCompletion = true) {
+    const subscription = apiClient.subscribeToRun(runId, {
+        signal: abortControllerRef.current?.signal,
+        closeOnComplete: stopOnCompletion,
+    });
+    for await (const part of subscription) {
+        mutateRunData(part);
+    }
+}
+//# sourceMappingURL=useRealtime.js.map