@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/unstable-core-do-not-import/stream/sse.mjs

@@ -1,88 +1,162 @@
+import { Unpromise } from '../../vendor/unpromise/unpromise.mjs';
 import { getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
-import { run } from '../utils.mjs';
+import { isAbortError } from '../http/isAbortError.mjs';
+import { run, identity } from '../utils.mjs';
 import { isTrackedEnvelope } from './tracked.mjs';
-import { createTimeoutPromise } from './utils/createDeferred.mjs';
-import { createReadableStream } from './utils/createReadableStream.mjs';
+import { takeWithGrace, withMaxDuration } from './utils/asyncIterable.mjs';
+import { makeAsyncResource } from './utils/disposable.mjs';
+import { readableStreamFrom } from './utils/readableStreamFrom.mjs';
+import { timerResource, disposablePromiseTimerResult } from './utils/timerResource.mjs';
+import { withPing, PING_SYM } from './utils/withPing.mjs';
 
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+const PING_EVENT = 'ping';
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
+const CONNECTED_EVENT = 'connected';
 /**
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamProducer(opts) {
-    const stream = createReadableStream();
-    stream.controller.enqueue({
-        comment: 'connected'
-    });
-    const { serialize =(v)=>v  } = opts;
+    const { serialize = identity } = opts;
     const ping = {
         enabled: opts.ping?.enabled ?? false,
         intervalMs: opts.ping?.intervalMs ?? 1000
     };
-    run(async ()=>{
-        const iterator = opts.data[Symbol.asyncIterator]();
-        const closedPromise = stream.cancelledPromise.then(()=>'closed');
-        const maxDurationPromise = createTimeoutPromise(opts.maxDurationMs ?? Infinity, 'maxDuration');
-        let nextPromise = iterator.next();
-        while(true){
-            const pingPromise = createTimeoutPromise(ping.enabled ? ping.intervalMs : Infinity, 'ping');
-            const next = await Promise.race([
-                nextPromise.catch(getTRPCErrorFromUnknown),
-                pingPromise.promise,
-                closedPromise,
-                maxDurationPromise.promise
-            ]);
-            pingPromise.clear();
-            if (next === 'closed') {
-                break;
-            }
-            if (next === 'maxDuration') {
-                break;
-            }
-            if (next === 'ping') {
-                stream.controller.enqueue({
-                    comment: 'ping'
-                });
+    const client = opts.client ?? {};
+    if (ping.enabled && client.reconnectAfterInactivityMs && ping.intervalMs > client.reconnectAfterInactivityMs) {
+        throw new Error(`Ping interval must be less than client reconnect interval to prevent unnecessary reconnection - ping.intervalMs: ${ping.intervalMs} client.reconnectAfterInactivityMs: ${client.reconnectAfterInactivityMs}`);
+    }
+    async function* generator() {
+        yield {
+            event: CONNECTED_EVENT,
+            data: JSON.stringify(client)
+        };
+        let iterable = opts.data;
+        if (opts.emitAndEndImmediately) {
+            iterable = takeWithGrace(iterable, {
+                count: 1,
+                gracePeriodMs: 1
+            });
+        }
+        if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            iterable = withMaxDuration(iterable, {
+                maxDurationMs: opts.maxDurationMs
+            });
+        }
+        if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
+            iterable = withPing(iterable, ping.intervalMs);
+        }
+        // We need those declarations outside the loop for garbage collection reasons. If they were
+        // declared inside, they would not be freed until the next value is present.
+        let value;
+        let chunk;
+        for await (value of iterable){
+            if (value === PING_SYM) {
+                yield {
+                    event: PING_EVENT,
+                    data: ''
+                };
                 continue;
             }
-            if (next instanceof Error) {
-                const data = opts.formatError ? opts.formatError({
-                    error: next
-                }) : null;
-                stream.controller.enqueue({
-                    event: SERIALIZED_ERROR_EVENT,
-                    data: JSON.stringify(serialize(data))
-                });
-                break;
-            }
-            if (next.done) {
-                break;
-            }
-            const value = next.value;
-            const chunk = isTrackedEnvelope(value) ? {
+            chunk = isTrackedEnvelope(value) ? {
                 id: value[0],
                 data: value[1]
             } : {
                 data: value
             };
-            if ('data' in chunk) {
-                chunk.data = JSON.stringify(serialize(chunk.data));
-            }
-            stream.controller.enqueue(chunk);
-            if (opts.emitAndEndImmediately) {
-                // end the stream in the next tick so that we can send a few more events from the queue
-                setTimeout(maxDurationPromise.resolve, 1);
-            }
-            nextPromise = iterator.next();
+            chunk.data = JSON.stringify(serialize(chunk.data));
+            yield chunk;
+            // free up references for garbage collection
+            value = null;
+            chunk = null;
         }
-        maxDurationPromise.clear();
-        await iterator.return?.();
+    }
+    async function* generatorWithErrorHandling() {
         try {
-            stream.controller.close();
-        } catch  {}
-    }).catch((error)=>{
-        return stream.controller.error(error);
-    });
-    return stream.readable.pipeThrough(new TransformStream({
+            yield* generator();
+        } catch (cause) {
+            if (isAbortError(cause)) {
+                // ignore abort errors, send any other errors
+                return;
+            }
+            // `err` must be caused by `opts.data`, `JSON.stringify` or `serialize`.
+            // So, a user error in any case.
+            const error = getTRPCErrorFromUnknown(cause);
+            const data = opts.formatError?.({
+                error
+            }) ?? null;
+            yield {
+                event: SERIALIZED_ERROR_EVENT,
+                data: JSON.stringify(serialize(data))
+            };
+        }
+    }
+    const stream = readableStreamFrom(generatorWithErrorHandling());
+    return stream.pipeThrough(new TransformStream({
         transform (chunk, controller) {
             if ('event' in chunk) {
                 controller.enqueue(`event: ${chunk.event}\n`);
@@ -100,75 +174,176 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
         }
     }));
 }
+async function withTimeout(opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const timeoutPromise = _ts_add_disposable_resource(env, timerResource(opts.timeoutMs), false);
+        ;
+        const res = await Unpromise.race([
+            opts.promise,
+            timeoutPromise.start()
+        ]);
+        if (res === disposablePromiseTimerResult) {
+            return await opts.onTimeout();
+        }
+        return res;
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        _ts_dispose_resources(env);
+    }
+}
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamConsumer(opts) {
-    const { deserialize =(v)=>v  } = opts;
-    const eventSource = opts.from;
-    const stream = createReadableStream();
-    const transform = new TransformStream({
-        async transform (chunk, controller) {
-            const data = deserialize(JSON.parse(chunk.data));
-            if (chunk.type === SERIALIZED_ERROR_EVENT) {
+    const { deserialize = (v)=>v } = opts;
+    let clientOptions = {};
+    const signal = opts.signal;
+    let _es = null;
+    const createStream = ()=>new ReadableStream({
+            async start (controller) {
+                const [url, init] = await Promise.all([
+                    opts.url(),
+                    opts.init()
+                ]);
+                const eventSource = _es = new opts.EventSource(url, init);
                 controller.enqueue({
-                    ok: false,
-                    error: data
+                    type: 'connecting',
+                    eventSource: _es,
+                    event: null
                 });
-                return;
-            }
-            // console.debug('transforming', chunk.type, chunk.data);
-            const def = {
-                data
-            };
-            if (chunk.lastEventId) {
-                def.id = chunk.lastEventId;
-            }
-            controller.enqueue({
-                ok: true,
-                data: def
-            });
-        }
-    });
-    eventSource.addEventListener('message', (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener('error', (cause)=>{
-        if (eventSource.readyState === EventSource.CLOSED) {
-            stream.controller.error(cause);
-        }
-    });
-    const readable = stream.readable.pipeThrough(transform);
-    return {
-        [Symbol.asyncIterator] () {
-            const reader = readable.getReader();
-            const iterator = {
-                async next () {
-                    const value = await reader.read();
-                    if (value.done) {
-                        return {
-                            value: undefined,
-                            done: true
-                        };
+                eventSource.addEventListener(CONNECTED_EVENT, (_msg)=>{
+                    const msg = _msg;
+                    const options = JSON.parse(msg.data);
+                    clientOptions = options;
+                    controller.enqueue({
+                        type: 'connected',
+                        options,
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
+                    const msg = _msg;
+                    controller.enqueue({
+                        type: 'serialized-error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener(PING_EVENT, ()=>{
+                    controller.enqueue({
+                        type: 'ping',
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener('error', (event)=>{
+                    if (eventSource.readyState === EventSource.CLOSED) {
+                        controller.error(event);
+                    } else {
+                        controller.enqueue({
+                            type: 'connecting',
+                            eventSource,
+                            event
+                        });
                     }
-                    return {
-                        value: value.value,
-                        done: false
-                    };
-                },
-                async return () {
-                    reader.releaseLock();
-                    return {
-                        value: undefined,
-                        done: true
+                });
+                eventSource.addEventListener('message', (_msg)=>{
+                    const msg = _msg;
+                    const chunk = deserialize(JSON.parse(msg.data));
+                    const def = {
+                        data: chunk
                     };
+                    if (msg.lastEventId) {
+                        def.id = msg.lastEventId;
+                    }
+                    controller.enqueue({
+                        type: 'data',
+                        data: def,
+                        eventSource
+                    });
+                });
+                const onAbort = ()=>{
+                    controller.close();
+                    eventSource.close();
+                };
+                if (signal.aborted) {
+                    onAbort();
+                } else {
+                    signal.addEventListener('abort', onAbort);
                 }
-            };
-            return iterator;
+            },
+            cancel () {
+                _es?.close();
+            }
+        });
+    const getStreamResource = ()=>{
+        let stream = createStream();
+        let reader = stream.getReader();
+        async function dispose() {
+            await reader.cancel();
+            _es = null;
         }
+        return makeAsyncResource({
+            read () {
+                return reader.read();
+            },
+            async recreate () {
+                await dispose();
+                stream = createStream();
+                reader = stream.getReader();
+            }
+        }, dispose);
     };
+    return run(async function*() {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            const stream = _ts_add_disposable_resource(env, getStreamResource(), true);
+            ;
+            while(true){
+                let promise = stream.read();
+                const timeoutMs = clientOptions.reconnectAfterInactivityMs;
+                if (timeoutMs) {
+                    promise = withTimeout({
+                        promise,
+                        timeoutMs,
+                        onTimeout: async ()=>{
+                            const res = {
+                                value: {
+                                    type: 'timeout',
+                                    ms: timeoutMs,
+                                    eventSource: _es
+                                },
+                                done: false
+                            };
+                            // Close and release old reader
+                            await stream.recreate();
+                            return res;
+                        }
+                    });
+                }
+                const result = await promise;
+                if (result.done) {
+                    return result.value;
+                }
+                yield result.value;
+            }
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
+    });
 }
 const sseHeaders = {
     'Content-Type': 'text/event-stream',

package/dist/unstable-core-do-not-import/stream/sse.types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @internal
+ */
+export declare namespace EventSourceLike {
+    export interface InitDict {
+        withCredentials?: boolean;
+    }
+    export interface MessageEvent extends Event {
+        data: any;
+        lastEventId?: string;
+    }
+    export interface Event {
+    }
+    type EventSourceListenerLike = (event: Event) => void;
+    export type AnyConstructorLike<TInit extends InitDict> = new (url: string, eventSourceInitDict?: TInit) => Instance;
+    export interface Instance {
+        readonly CLOSED: number;
+        readonly CONNECTING: number;
+        readonly OPEN: number;
+        addEventListener(type: string, listener: EventSourceListenerLike): void;
+        removeEventListener(type: string, listener: EventSourceListenerLike): void;
+        close: () => void;
+        readyState: number;
+    }
+    export type AnyConstructor = AnyConstructorLike<any>;
+    export type ListenerOf<T extends AnyConstructor> = Parameters<InstanceType<T>['addEventListener']>[1];
+    export type EventOf<T extends AnyConstructor> = Parameters<ListenerOf<T>>[0];
+    export type InitDictOf<T extends AnyConstructor> = ConstructorParameters<T>[1];
+    export {};
+}
+//# sourceMappingURL=sse.types.d.ts.map

package/dist/unstable-core-do-not-import/stream/sse.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.types.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/sse.types.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,yBAAiB,eAAe,CAAC;IAC/B,MAAM,WAAW,QAAQ;QACvB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B;IAED,MAAM,WAAW,YAAa,SAAQ,KAAK;QACzC,IAAI,EAAE,GAAG,CAAC;QACV,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;IACD,MAAM,WAAW,KAAK;KAAG;IAEzB,KAAK,uBAAuB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEtD,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,QAAQ,IAAI,KACvD,GAAG,EAAE,MAAM,EACX,mBAAmB,CAAC,EAAE,KAAK,KACxB,QAAQ,CAAC;IAEd,MAAM,WAAW,QAAQ;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAEtB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,GAAG,IAAI,CAAC;QACxE,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,GAAG,IAAI,CAAC;QAC3E,KAAK,EAAE,MAAM,IAAI,CAAC;QAElB,UAAU,EAAE,MAAM,CAAC;KACpB;IAED,MAAM,MAAM,cAAc,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;IAErD,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,cAAc,IAAI,UAAU,CAC3D,YAAY,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CACpC,CAAC,CAAC,CAAC,CAAC;IACL,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,cAAc,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,cAAc,IAC7C,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;CAC/B"}

package/dist/unstable-core-do-not-import/stream/tracked.d.ts

@@ -3,7 +3,7 @@ type TrackedId = string & {
     __brand: 'TrackedId';
 };
 export type TrackedEnvelope<TData> = [TrackedId, TData, typeof trackedSymbol];
-type Tracked<TData> = {
+type TrackedData<TData> = {
     /**
      * The id of the message to keep track of in case the connection gets lost
      */
@@ -26,6 +26,6 @@ export declare function isTrackedEnvelope<TData>(value: unknown): value is Track
  * Automatically track an event so that it can be resumed from a given id if the connection is lost
  */
 export declare function tracked<TData>(id: string, data: TData): TrackedEnvelope<TData>;
-export type inferTrackedOutput<TData> = TData extends TrackedEnvelope<infer $Data> ? Tracked<$Data> : TData;
+export type inferTrackedOutput<TData> = TData extends TrackedEnvelope<infer $Data> ? TrackedData<$Data> : TData;
 export {};
 //# sourceMappingURL=tracked.d.ts.map

package/dist/unstable-core-do-not-import/stream/tracked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracked.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/tracked.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa,eAA4B,CAAC;AAEhD,KAAK,SAAS,GAAG,MAAM,GAAG;IACxB,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AACF,MAAM,MAAM,eAAe,CAAC,KAAK,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,aAAa,CAAC,CAAC;AAE9E,KAAK,OAAO,CAAC,KAAK,IAAI;IACpB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AACF;;;GAGG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,KAAK,CAAC;CACb,GAAG,eAAe,CAAC,KAAK,CAAC,CAEzB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EACrC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,eAAe,CAAC,KAAK,CAAC,CAEjC;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAC3B,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,KAAK,GACV,eAAe,CAAC,KAAK,CAAC,CAQxB;AAED,MAAM,MAAM,kBAAkB,CAAC,KAAK,IAAI,KAAK,SAAS,eAAe,CACnE,MAAM,KAAK,CACZ,GACG,OAAO,CAAC,KAAK,CAAC,GACd,KAAK,CAAC"}
+{"version":3,"file":"tracked.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/tracked.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa,eAAW,CAAC;AAE/B,KAAK,SAAS,GAAG,MAAM,GAAG;IACxB,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AACF,MAAM,MAAM,eAAe,CAAC,KAAK,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,aAAa,CAAC,CAAC;AAE9E,KAAK,WAAW,CAAC,KAAK,IAAI;IACxB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AACF;;;GAGG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,0BAE5D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EACrC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,eAAe,CAAC,KAAK,CAAC,CAEjC;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAC3B,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,KAAK,GACV,eAAe,CAAC,KAAK,CAAC,CAQxB;AAED,MAAM,MAAM,kBAAkB,CAAC,KAAK,IAClC,KAAK,SAAS,eAAe,CAAC,MAAM,KAAK,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC"}

package/dist/unstable-core-do-not-import/stream/tracked.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const trackedSymbol = Symbol('TrackedEnvelope');
+const trackedSymbol = Symbol();
 /**
  * Produce a typed server-sent event message
  * @deprecated use `tracked(id, data)` instead

package/dist/unstable-core-do-not-import/stream/tracked.mjs

@@ -1,4 +1,4 @@
-const trackedSymbol = Symbol('TrackedEnvelope');
+const trackedSymbol = Symbol();
 /**
  * Produce a typed server-sent event message
  * @deprecated use `tracked(id, data)` instead

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.d.ts

@@ -0,0 +1,17 @@
+export declare function iteratorResource<TYield, TReturn, TNext>(iterable: AsyncIterable<TYield, TReturn, TNext>): AsyncIterator<TYield, TReturn, TNext> & AsyncDisposable;
+/**
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */
+export declare function withMaxDuration<T>(iterable: AsyncIterable<T>, opts: {
+    maxDurationMs: number;
+}): AsyncGenerator<T>;
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
+ * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
+ * values may still come through. After this period, the generator stops.
+ */
+export declare function takeWithGrace<T>(iterable: AsyncIterable<T>, opts: {
+    count: number;
+    gracePeriodMs: number;
+}): AsyncGenerator<T>;
+//# sourceMappingURL=asyncIterable.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EACrD,QAAQ,EAAE,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,GAC9C,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,eAAe,CAMzD;AACD;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CAyBnB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB,GACA,cAAc,CAAC,CAAC,CAAC,CA+BnB"}