@trigger.dev/react-hooks 0.0.0-bun-runtimes-20260909131057

package/dist/commonjs/hooks/useRealtime.js

@@ -0,0 +1,642 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRealtimeRun = useRealtimeRun;
+exports.useRealtimeRunWithStreams = useRealtimeRunWithStreams;
+exports.useRealtimeRunsWithTag = useRealtimeRunsWithTag;
+exports.useRealtimeBatch = useRealtimeBatch;
+exports.useRealtimeStream = useRealtimeStream;
+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");
+const useStableRequestCallback_js_1 = require("../utils/useStableRequestCallback.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 onComplete = options?.onComplete;
+    const skipColumns = options?.skipColumns;
+    const stopOnCompletion = options?.stopOnCompletion;
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!runId || !apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeRun(runId, { skipColumns }, apiClient, mutateRun, setError, abortControllerRef, typeof stopOnCompletion === "boolean" ? 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, apiClient, mutateRun, setError, setIsComplete, skipColumns, stopOnCompletion]);
+    const requestSubscription = (0, useStableRequestCallback_js_1.useStableRequestCallback)(triggerRequest);
+    const hasCalledOnCompleteRef = (0, react_1.useRef)(false);
+    // Effect to handle onComplete callback
+    // Only call onComplete when the run has actually finished (has finishedAt),
+    // not just when the subscription stream ends (which can happen due to network issues)
+    (0, react_1.useEffect)(() => {
+        if (isComplete && run?.finishedAt && onComplete && !hasCalledOnCompleteRef.current) {
+            onComplete(run, error);
+            hasCalledOnCompleteRef.current = true;
+        }
+    }, [isComplete, run, error, onComplete]);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        if (!runId) {
+            return;
+        }
+        requestSubscription().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [runId, stop, options?.enabled, requestSubscription]);
+    (0, react_1.useEffect)(() => {
+        if (run?.finishedAt) {
+            setIsComplete(true);
+        }
+    }, [run, setIsComplete]);
+    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 onComplete = options?.onComplete;
+    const skipColumns = options?.skipColumns;
+    const stopOnCompletion = options?.stopOnCompletion;
+    const throttleInMs = options?.throttleInMs;
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!runId || !apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeRunWithStreams(runId, { skipColumns }, apiClient, mutateRun, mutateStreams, streamsRef, setError, abortControllerRef, typeof stopOnCompletion === "boolean" ? stopOnCompletion : true, throttleInMs ?? 16);
+        }
+        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,
+        apiClient,
+        mutateRun,
+        mutateStreams,
+        setError,
+        setIsComplete,
+        skipColumns,
+        stopOnCompletion,
+        throttleInMs,
+    ]);
+    const requestSubscription = (0, useStableRequestCallback_js_1.useStableRequestCallback)(triggerRequest);
+    const hasCalledOnCompleteRef = (0, react_1.useRef)(false);
+    // Effect to handle onComplete callback
+    // Only call onComplete when the run has actually finished (has finishedAt),
+    // not just when the subscription stream ends (which can happen due to network issues)
+    (0, react_1.useEffect)(() => {
+        if (isComplete && run?.finishedAt && onComplete && !hasCalledOnCompleteRef.current) {
+            onComplete(run, error);
+            hasCalledOnCompleteRef.current = true;
+        }
+    }, [isComplete, run, error, onComplete]);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        if (!runId) {
+            return;
+        }
+        requestSubscription().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [runId, stop, options?.enabled, requestSubscription]);
+    (0, react_1.useEffect)(() => {
+        if (run?.finishedAt) {
+            setIsComplete(true);
+        }
+    }, [run, setIsComplete]);
+    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']);
+ * // Or with a createdAt filter
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>('my-tag', { createdAt: '1h' });
+ * ```
+ */
+function useRealtimeRunsWithTag(tag, options) {
+    const normalizedTag = (Array.isArray(tag) ? tag : [tag]).join("-");
+    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 createdAt = options?.createdAt;
+    const skipColumns = options?.skipColumns;
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeRunsWithTag(tag, { createdAt, skipColumns }, apiClient, mutateRuns, runsRef, setError, 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, createdAt, skipColumns, apiClient, mutateRuns, setError]);
+    const requestSubscription = (0, useStableRequestCallback_js_1.useStableRequestCallback)(triggerRequest);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        requestSubscription().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [normalizedTag, stop, options?.enabled, requestSubscription]);
+    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, setError, 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]);
+    const requestSubscription = (0, useStableRequestCallback_js_1.useStableRequestCallback)(triggerRequest);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        requestSubscription().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [batchId, stop, options?.enabled, requestSubscription]);
+    return { runs: runs ?? [], error, stop };
+}
+function useRealtimeStream(runIdOrDefinedStream, streamKeyOrOptionsOrRunId, options) {
+    let runId;
+    let streamKey;
+    let resolvedOptions;
+    if (typeof runIdOrDefinedStream === "string") {
+        runId = runIdOrDefinedStream;
+        streamKey =
+            typeof streamKeyOrOptionsOrRunId === "string" ? streamKeyOrOptionsOrRunId : "default";
+        resolvedOptions =
+            typeof streamKeyOrOptionsOrRunId === "string" ? options : streamKeyOrOptionsOrRunId;
+    }
+    else {
+        if (typeof streamKeyOrOptionsOrRunId !== "string") {
+            throw new Error("Invalid second argument to useRealtimeStream. When using a defined stream instance, the second argument to useRealtimeStream must be a run ID.");
+        }
+        runId = streamKeyOrOptionsOrRunId;
+        streamKey = runIdOrDefinedStream.id;
+        resolvedOptions = options;
+    }
+    return useRealtimeStreamImplementation(runId, streamKey, resolvedOptions);
+}
+function useRealtimeStreamImplementation(runId, streamKey, options) {
+    const hookId = (0, react_1.useId)();
+    const idKey = options?.id ?? hookId;
+    const [initialPartsFallback] = (0, react_1.useState)([]);
+    // Store the streams state in SWR, using the idKey as the key to share states.
+    const { data: parts, mutate: mutateParts } = (0, trigger_swr_js_1.useSWR)([idKey, runId, streamKey, "parts"], null, {
+        fallbackData: initialPartsFallback,
+    });
+    // Keep the latest streams in a ref.
+    const partsRef = (0, react_1.useRef)(parts ?? []);
+    (0, react_1.useEffect)(() => {
+        partsRef.current = parts || [];
+    }, [parts]);
+    const { data: persistedLastEventId, mutate: mutateLastEventId } = (0, trigger_swr_js_1.useSWR)([idKey, runId, streamKey, "lastEventId"], null);
+    const lastEventIdRef = (0, react_1.useRef)(persistedLastEventId);
+    const streamIdentityRef = (0, react_1.useRef)(`${idKey}:${runId}:${streamKey}`);
+    (0, react_1.useEffect)(() => {
+        const identity = `${idKey}:${runId}:${streamKey}`;
+        if (streamIdentityRef.current !== identity) {
+            streamIdentityRef.current = identity;
+            lastEventIdRef.current = persistedLastEventId;
+        }
+    }, [idKey, runId, streamKey, persistedLastEventId]);
+    // Add state to track when the subscription is complete
+    const { data: _isComplete = false, mutate: setIsComplete } = (0, trigger_swr_js_1.useSWR)([idKey, runId, streamKey, "complete"], null);
+    const { data: error = undefined, mutate: setError } = (0, trigger_swr_js_1.useSWR)([idKey, runId, streamKey, "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 onDataCallback = options?.onData;
+    const onData = (0, react_1.useCallback)((data) => {
+        if (onDataCallback) {
+            onDataCallback(data);
+        }
+    }, [onDataCallback]);
+    const onPartsCallback = options?.onParts;
+    const onParts = (0, react_1.useCallback)((partsBatch) => {
+        if (onPartsCallback) {
+            onPartsCallback(partsBatch);
+        }
+    }, [onPartsCallback]);
+    const apiClient = (0, useApiClient_js_1.useApiClient)(options);
+    const timeoutInSeconds = options?.timeoutInSeconds;
+    const startIndex = options?.startIndex;
+    const startEventId = options?.lastEventId;
+    const throttleInMs = options?.throttleInMs;
+    const from = options?.from;
+    const maxParts = options?.maxParts;
+    (0, react_1.useEffect)(() => {
+        if (maxParts != null && maxParts >= 0) {
+            const current = partsRef.current;
+            if (current.length > maxParts) {
+                mutateParts(current.slice(current.length - maxParts));
+            }
+        }
+    }, [maxParts, mutateParts]);
+    const triggerRequest = (0, react_1.useCallback)(async () => {
+        try {
+            if (!runId || !apiClient) {
+                return;
+            }
+            const abortController = new AbortController();
+            abortControllerRef.current = abortController;
+            await processRealtimeStream(runId, streamKey, apiClient, mutateParts, partsRef, setError, onData, abortControllerRef, timeoutInSeconds, startIndex, throttleInMs ?? 16, from, maxParts, lastEventIdRef, (id) => mutateLastEventId(id, false), startEventId !== undefined ? String(startEventId) : undefined, onParts);
+        }
+        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,
+        streamKey,
+        apiClient,
+        mutateParts,
+        setError,
+        setIsComplete,
+        onData,
+        onParts,
+        timeoutInSeconds,
+        startIndex,
+        startEventId,
+        throttleInMs,
+        from,
+        maxParts,
+        mutateLastEventId,
+    ]);
+    const requestSubscription = (0, useStableRequestCallback_js_1.useStableRequestCallback)(triggerRequest);
+    (0, react_1.useEffect)(() => {
+        if (typeof options?.enabled === "boolean" && !options.enabled) {
+            return;
+        }
+        if (!runId) {
+            return;
+        }
+        requestSubscription().finally(() => { });
+        return () => {
+            stop();
+        };
+    }, [runId, stop, options?.enabled, requestSubscription]);
+    return { parts: parts ?? initialPartsFallback, lastEventId: persistedLastEventId, error, stop };
+}
+async function processRealtimeBatch(batchId, apiClient, mutateRunsData, existingRunsRef, onError, abortControllerRef) {
+    const subscription = apiClient.subscribeToBatch(batchId, {
+        signal: abortControllerRef.current?.signal,
+        onFetchError: onError,
+    });
+    for await (const part of subscription) {
+        mutateRunsData(insertRunShapeInOrder(existingRunsRef.current, part));
+    }
+}
+// Inserts and then orders by the run createdAt timestamp, 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 runCreatedAt = run.createdAt;
+    const index = previousRuns.findIndex((r) => r.createdAt > runCreatedAt);
+    if (index === -1) {
+        return [...previousRuns, run];
+    }
+    return [...previousRuns.slice(0, index), run, ...previousRuns.slice(index)];
+}
+async function processRealtimeRunsWithTag(tag, filters, apiClient, mutateRunsData, existingRunsRef, onError, abortControllerRef) {
+    const subscription = apiClient.subscribeToRunsWithTag(tag, filters, {
+        signal: abortControllerRef.current?.signal,
+        onFetchError: onError,
+    });
+    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, filters, apiClient, mutateRunData, mutateStreamData, existingDataRef, onError, abortControllerRef, stopOnCompletion = true, throttleInMs) {
+    const subscription = apiClient.subscribeToRun(runId, {
+        signal: abortControllerRef.current?.signal,
+        closeOnComplete: stopOnCompletion,
+        onFetchError: onError,
+        skipColumns: filters.skipColumns,
+    });
+    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, filters, apiClient, mutateRunData, onError, abortControllerRef, stopOnCompletion = true) {
+    const subscription = apiClient.subscribeToRun(runId, {
+        signal: abortControllerRef.current?.signal,
+        closeOnComplete: stopOnCompletion,
+        onFetchError: onError,
+        skipColumns: filters.skipColumns,
+    });
+    for await (const part of subscription) {
+        mutateRunData(part);
+    }
+}
+async function processRealtimeStream(runId, streamKey, apiClient, mutatePartsData, existingPartsRef, onError, onData, abortControllerRef, timeoutInSeconds, startIndex, throttleInMs, from, maxParts, lastEventIdRef, persistLastEventId, userLastEventId, onParts) {
+    try {
+        const resumeFromEventId = lastEventIdRef?.current ??
+            userLastEventId ??
+            (startIndex ? (startIndex - 1).toString() : undefined);
+        const partsQueue = (0, throttle_js_1.createThrottledQueue)(async (batch) => {
+            const combined = [...existingPartsRef.current, ...batch.map((part) => part.chunk)];
+            const bounded = maxParts != null && maxParts >= 0 && combined.length > maxParts
+                ? combined.slice(combined.length - maxParts)
+                : combined;
+            existingPartsRef.current = bounded;
+            mutatePartsData(bounded);
+            if (persistLastEventId && lastEventIdRef?.current) {
+                persistLastEventId(lastEventIdRef.current);
+            }
+            onParts?.(batch);
+        }, throttleInMs);
+        const stream = await apiClient.fetchStream(runId, streamKey, {
+            signal: abortControllerRef.current?.signal,
+            timeoutInSeconds,
+            lastEventId: resumeFromEventId,
+            from: startIndex !== undefined ? undefined : from,
+            onPart: (part) => {
+                if (part.id && lastEventIdRef) {
+                    lastEventIdRef.current = part.id;
+                }
+                partsQueue.add(part);
+            },
+        });
+        for await (const part of stream) {
+            onData(part);
+        }
+        await partsQueue.flush();
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            return;
+        }
+        if (err instanceof Error) {
+            onError(err);
+        }
+        else {
+            onError(new Error(String(err)));
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=useRealtime.js.map