@trpc/server 11.1.2 → 11.1.3-alpha-tmp-tsdown.23

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

@@ -1,239 +1,152 @@
-import { createDeferred } from './createDeferred.mjs';
-import { makeAsyncResource } from './disposable.mjs';
+import { __toESM } from "../../../_virtual/rolldown_runtime.mjs";
+import { makeAsyncResource } from "./disposable.mjs";
+import { require_usingCtx } from "../../../node_modules/.pnpm/@oxc-project_runtime@0.71.0/node_modules/@oxc-project/runtime/src/helpers/usingCtx.mjs";
+import { createDeferred } from "./createDeferred.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 (!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];
-            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 {
-        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);
-}
+//#region src/unstable-core-do-not-import/stream/utils/mergeAsyncIterables.ts
+var import_usingCtx = __toESM(require_usingCtx());
 function createManagedIterator(iterable, onResult) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    let state = 'idle';
-    function cleanup() {
-        state = 'done';
-        onResult = ()=>{
-        // noop
-        };
-    }
-    function pull() {
-        if (state !== 'idle') {
-            return;
-        }
-        state = 'pending';
-        const next = iterator.next();
-        next.then((result)=>{
-            if (result.done) {
-                state = 'done';
-                onResult({
-                    status: 'return',
-                    value: result.value
-                });
-                cleanup();
-                return;
-            }
-            state = 'idle';
-            onResult({
-                status: 'yield',
-                value: result.value
-            });
-        }).catch((cause)=>{
-            onResult({
-                status: 'error',
-                error: cause
-            });
-            cleanup();
-        });
-    }
-    return {
-        pull,
-        destroy: async ()=>{
-            cleanup();
-            await iterator.return?.();
-        }
-    };
+	const iterator = iterable[Symbol.asyncIterator]();
+	let state = "idle";
+	function cleanup() {
+		state = "done";
+		onResult = () => {};
+	}
+	function pull() {
+		if (state !== "idle") return;
+		state = "pending";
+		const next = iterator.next();
+		next.then((result) => {
+			if (result.done) {
+				state = "done";
+				onResult({
+					status: "return",
+					value: result.value
+				});
+				cleanup();
+				return;
+			}
+			state = "idle";
+			onResult({
+				status: "yield",
+				value: result.value
+			});
+		}).catch((cause) => {
+			onResult({
+				status: "error",
+				error: cause
+			});
+			cleanup();
+		});
+	}
+	return {
+		pull,
+		destroy: async () => {
+			cleanup();
+			await iterator.return?.();
+		}
+	};
 }
 /**
- * Creates a new async iterable that merges multiple async iterables into a single stream.
- * Values from the input iterables are yielded in the order they resolve, similar to Promise.race().
- *
- * New iterables can be added dynamically using the returned {@link MergedAsyncIterables.add} method, even after iteration has started.
- *
- * If any of the input iterables throws an error, that error will be propagated through the merged stream.
- * Other iterables will not continue to be processed.
- *
- * @template TYield The type of values yielded by the input iterables
- */ function mergeAsyncIterables() {
-    let state = 'idle';
-    let flushSignal = createDeferred();
-    /**
-   * used while {@link state} is `idle`
-   */ const iterables = [];
-    /**
-   * used while {@link state} is `pending`
-   */ const iterators = new Set();
-    const buffer = [];
-    function initIterable(iterable) {
-        if (state !== 'pending') {
-            // shouldn't happen
-            return;
-        }
-        const iterator = createManagedIterator(iterable, (result)=>{
-            if (state !== 'pending') {
-                // shouldn't happen
-                return;
-            }
-            switch(result.status){
-                case 'yield':
-                    buffer.push([
-                        iterator,
-                        result
-                    ]);
-                    break;
-                case 'return':
-                    iterators.delete(iterator);
-                    break;
-                case 'error':
-                    buffer.push([
-                        iterator,
-                        result
-                    ]);
-                    iterators.delete(iterator);
-                    break;
-            }
-            flushSignal.resolve();
-        });
-        iterators.add(iterator);
-        iterator.pull();
-    }
-    return {
-        add (iterable) {
-            switch(state){
-                case 'idle':
-                    iterables.push(iterable);
-                    break;
-                case 'pending':
-                    initIterable(iterable);
-                    break;
-            }
-        },
-        async *[Symbol.asyncIterator] () {
-            const env = {
-                stack: [],
-                error: void 0,
-                hasError: false
-            };
-            try {
-                if (state !== 'idle') {
-                    throw new Error('Cannot iterate twice');
-                }
-                state = 'pending';
-                const _finally = _ts_add_disposable_resource(env, makeAsyncResource({}, async ()=>{
-                    state = 'done';
-                    const errors = [];
-                    await Promise.all(Array.from(iterators.values()).map(async (it)=>{
-                        try {
-                            await it.destroy();
-                        } catch (cause) {
-                            errors.push(cause);
-                        }
-                    }));
-                    buffer.length = 0;
-                    iterators.clear();
-                    flushSignal.resolve();
-                    if (errors.length > 0) {
-                        throw new AggregateError(errors);
-                    }
-                }), true);
-                ;
-                while(iterables.length > 0){
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    initIterable(iterables.shift());
-                }
-                while(iterators.size > 0){
-                    await flushSignal.promise;
-                    while(buffer.length > 0){
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        const [iterator, result] = buffer.shift();
-                        switch(result.status){
-                            case 'yield':
-                                yield result.value;
-                                iterator.pull();
-                                break;
-                            case 'error':
-                                throw result.error;
-                        }
-                    }
-                    flushSignal = createDeferred();
-                }
-            } catch (e) {
-                env.error = e;
-                env.hasError = true;
-            } finally{
-                const result = _ts_dispose_resources(env);
-                if (result) await result;
-            }
-        }
-    };
+* Creates a new async iterable that merges multiple async iterables into a single stream.
+* Values from the input iterables are yielded in the order they resolve, similar to Promise.race().
+*
+* New iterables can be added dynamically using the returned {@link MergedAsyncIterables.add} method, even after iteration has started.
+*
+* If any of the input iterables throws an error, that error will be propagated through the merged stream.
+* Other iterables will not continue to be processed.
+*
+* @template TYield The type of values yielded by the input iterables
+*/
+function mergeAsyncIterables() {
+	let state = "idle";
+	let flushSignal = createDeferred();
+	/**
+	* used while {@link state} is `idle`
+	*/
+	const iterables = [];
+	/**
+	* used while {@link state} is `pending`
+	*/
+	const iterators = new Set();
+	const buffer = [];
+	function initIterable(iterable) {
+		if (state !== "pending") return;
+		const iterator = createManagedIterator(iterable, (result) => {
+			if (state !== "pending") return;
+			switch (result.status) {
+				case "yield":
+					buffer.push([iterator, result]);
+					break;
+				case "return":
+					iterators.delete(iterator);
+					break;
+				case "error":
+					buffer.push([iterator, result]);
+					iterators.delete(iterator);
+					break;
+			}
+			flushSignal.resolve();
+		});
+		iterators.add(iterator);
+		iterator.pull();
+	}
+	return {
+		add(iterable) {
+			switch (state) {
+				case "idle":
+					iterables.push(iterable);
+					break;
+				case "pending":
+					initIterable(iterable);
+					break;
+				case "done": break;
+			}
+		},
+		async *[Symbol.asyncIterator]() {
+			try {
+				var _usingCtx = (0, import_usingCtx.default)();
+				if (state !== "idle") throw new Error("Cannot iterate twice");
+				state = "pending";
+				const _finally = _usingCtx.a(makeAsyncResource({}, async () => {
+					state = "done";
+					const errors = [];
+					await Promise.all(Array.from(iterators.values()).map(async (it) => {
+						try {
+							await it.destroy();
+						} catch (cause) {
+							errors.push(cause);
+						}
+					}));
+					buffer.length = 0;
+					iterators.clear();
+					flushSignal.resolve();
+					if (errors.length > 0) throw new AggregateError(errors);
+				}));
+				while (iterables.length > 0) initIterable(iterables.shift());
+				while (iterators.size > 0) {
+					await flushSignal.promise;
+					while (buffer.length > 0) {
+						const [iterator, result] = buffer.shift();
+						switch (result.status) {
+							case "yield":
+								yield result.value;
+								iterator.pull();
+								break;
+							case "error": throw result.error;
+						}
+					}
+					flushSignal = createDeferred();
+				}
+			} catch (_) {
+				_usingCtx.e = _;
+			} finally {
+				await _usingCtx.d();
+			}
+		}
+	};
 }
 
+//#endregion
 export { mergeAsyncIterables };
+//# sourceMappingURL=mergeAsyncIterables.mjs.map

package/dist/unstable-core-do-not-import/stream/utils/mergeAsyncIterables.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeAsyncIterables.mjs","names":["iterable: AsyncIterable<TYield, TReturn>","onResult: (result: ManagedIteratorResult<TYield, TReturn>) => void","state: 'idle' | 'pending' | 'done'","iterables: AsyncIterable<TYield, void, unknown>[]","buffer: Array<\n    [\n      iterator: ManagedIterator<TYield, void>,\n      result: Exclude<\n        ManagedIteratorResult<TYield, void>,\n        { status: 'return' }\n      >,\n    ]\n  >","iterable: AsyncIterable<TYield, void, unknown>","errors: unknown[]"],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/mergeAsyncIterables.ts"],"sourcesContent":["import { createDeferred } from './createDeferred';\nimport { makeAsyncResource } from './disposable';\n\ntype ManagedIteratorResult<TYield, TReturn> =\n  | { status: 'yield'; value: TYield }\n  | { status: 'return'; value: TReturn }\n  | { status: 'error'; error: unknown };\nfunction createManagedIterator<TYield, TReturn>(\n  iterable: AsyncIterable<TYield, TReturn>,\n  onResult: (result: ManagedIteratorResult<TYield, TReturn>) => void,\n) {\n  const iterator = iterable[Symbol.asyncIterator]();\n  let state: 'idle' | 'pending' | 'done' = 'idle';\n\n  function cleanup() {\n    state = 'done';\n    onResult = () => {\n      // noop\n    };\n  }\n\n  function pull() {\n    if (state !== 'idle') {\n      return;\n    }\n    state = 'pending';\n\n    const next = iterator.next();\n    next\n      .then((result) => {\n        if (result.done) {\n          state = 'done';\n          onResult({ status: 'return', value: result.value });\n          cleanup();\n          return;\n        }\n        state = 'idle';\n        onResult({ status: 'yield', value: result.value });\n      })\n      .catch((cause) => {\n        onResult({ status: 'error', error: cause });\n        cleanup();\n      });\n  }\n\n  return {\n    pull,\n    destroy: async () => {\n      cleanup();\n      await iterator.return?.();\n    },\n  };\n}\ntype ManagedIterator<TYield, TReturn> = ReturnType<\n  typeof createManagedIterator<TYield, TReturn>\n>;\n\ninterface MergedAsyncIterables<TYield>\n  extends AsyncIterable<TYield, void, unknown> {\n  add(iterable: AsyncIterable<TYield>): void;\n}\n\n/**\n * Creates a new async iterable that merges multiple async iterables into a single stream.\n * Values from the input iterables are yielded in the order they resolve, similar to Promise.race().\n *\n * New iterables can be added dynamically using the returned {@link MergedAsyncIterables.add} method, even after iteration has started.\n *\n * If any of the input iterables throws an error, that error will be propagated through the merged stream.\n * Other iterables will not continue to be processed.\n *\n * @template TYield The type of values yielded by the input iterables\n */\nexport function mergeAsyncIterables<TYield>(): MergedAsyncIterables<TYield> {\n  let state: 'idle' | 'pending' | 'done' = 'idle';\n  let flushSignal = createDeferred();\n\n  /**\n   * used while {@link state} is `idle`\n   */\n  const iterables: AsyncIterable<TYield, void, unknown>[] = [];\n  /**\n   * used while {@link state} is `pending`\n   */\n  const iterators = new Set<ManagedIterator<TYield, void>>();\n\n  const buffer: Array<\n    [\n      iterator: ManagedIterator<TYield, void>,\n      result: Exclude<\n        ManagedIteratorResult<TYield, void>,\n        { status: 'return' }\n      >,\n    ]\n  > = [];\n\n  function initIterable(iterable: AsyncIterable<TYield, void, unknown>) {\n    if (state !== 'pending') {\n      // shouldn't happen\n      return;\n    }\n    const iterator = createManagedIterator(iterable, (result) => {\n      if (state !== 'pending') {\n        // shouldn't happen\n        return;\n      }\n      switch (result.status) {\n        case 'yield':\n          buffer.push([iterator, result]);\n          break;\n        case 'return':\n          iterators.delete(iterator);\n          break;\n        case 'error':\n          buffer.push([iterator, result]);\n          iterators.delete(iterator);\n          break;\n      }\n      flushSignal.resolve();\n    });\n    iterators.add(iterator);\n    iterator.pull();\n  }\n\n  return {\n    add(iterable: AsyncIterable<TYield, void, unknown>) {\n      switch (state) {\n        case 'idle':\n          iterables.push(iterable);\n          break;\n        case 'pending':\n          initIterable(iterable);\n          break;\n        case 'done': {\n          // shouldn't happen\n          break;\n        }\n      }\n    },\n    async *[Symbol.asyncIterator]() {\n      if (state !== 'idle') {\n        throw new Error('Cannot iterate twice');\n      }\n      state = 'pending';\n\n      await using _finally = makeAsyncResource({}, async () => {\n        state = 'done';\n\n        const errors: unknown[] = [];\n        await Promise.all(\n          Array.from(iterators.values()).map(async (it) => {\n            try {\n              await it.destroy();\n            } catch (cause) {\n              errors.push(cause);\n            }\n          }),\n        );\n        buffer.length = 0;\n        iterators.clear();\n        flushSignal.resolve();\n\n        if (errors.length > 0) {\n          throw new AggregateError(errors);\n        }\n      });\n\n      while (iterables.length > 0) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        initIterable(iterables.shift()!);\n      }\n\n      while (iterators.size > 0) {\n        await flushSignal.promise;\n\n        while (buffer.length > 0) {\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          const [iterator, result] = buffer.shift()!;\n\n          switch (result.status) {\n            case 'yield':\n              yield result.value;\n              iterator.pull();\n              break;\n            case 'error':\n              throw result.error;\n          }\n        }\n        flushSignal = createDeferred();\n      }\n    },\n  };\n}\n"],"mappings":";;;;;;;AAOA,SAAS,sBACPA,UACAC,UACA;CACA,MAAM,WAAW,SAAS,OAAO,gBAAgB;CACjD,IAAIC,QAAqC;CAEzC,SAAS,UAAU;AACjB,UAAQ;AACR,aAAW,MAAM,CAEhB;CACF;CAED,SAAS,OAAO;AACd,MAAI,UAAU,OACZ;AAEF,UAAQ;EAER,MAAM,OAAO,SAAS,MAAM;AAC5B,OACG,KAAK,CAAC,WAAW;AAChB,OAAI,OAAO,MAAM;AACf,YAAQ;AACR,aAAS;KAAE,QAAQ;KAAU,OAAO,OAAO;IAAO,EAAC;AACnD,aAAS;AACT;GACD;AACD,WAAQ;AACR,YAAS;IAAE,QAAQ;IAAS,OAAO,OAAO;GAAO,EAAC;EACnD,EAAC,CACD,MAAM,CAAC,UAAU;AAChB,YAAS;IAAE,QAAQ;IAAS,OAAO;GAAO,EAAC;AAC3C,YAAS;EACV,EAAC;CACL;AAED,QAAO;EACL;EACA,SAAS,YAAY;AACnB,YAAS;AACT,SAAM,SAAS,UAAU;EAC1B;CACF;AACF;;;;;;;;;;;;AAqBD,SAAgB,sBAA4D;CAC1E,IAAIA,QAAqC;CACzC,IAAI,cAAc,gBAAgB;;;;CAKlC,MAAMC,YAAoD,CAAE;;;;CAI5D,MAAM,YAAY,IAAI;CAEtB,MAAMC,SAQF,CAAE;CAEN,SAAS,aAAaC,UAAgD;AACpE,MAAI,UAAU,UAEZ;EAEF,MAAM,WAAW,sBAAsB,UAAU,CAAC,WAAW;AAC3D,OAAI,UAAU,UAEZ;AAEF,WAAQ,OAAO,QAAf;IACE,KAAK;AACH,YAAO,KAAK,CAAC,UAAU,MAAO,EAAC;AAC/B;IACF,KAAK;AACH,eAAU,OAAO,SAAS;AAC1B;IACF,KAAK;AACH,YAAO,KAAK,CAAC,UAAU,MAAO,EAAC;AAC/B,eAAU,OAAO,SAAS;AAC1B;GACH;AACD,eAAY,SAAS;EACtB,EAAC;AACF,YAAU,IAAI,SAAS;AACvB,WAAS,MAAM;CAChB;AAED,QAAO;EACL,IAAIA,UAAgD;AAClD,WAAQ,OAAR;IACE,KAAK;AACH,eAAU,KAAK,SAAS;AACxB;IACF,KAAK;AACH,kBAAa,SAAS;AACtB;IACF,KAAK,OAEH;GAEH;EACF;EACD,QAAQ,OAAO,iBAAiB;;;AAC9B,QAAI,UAAU,OACZ,OAAM,IAAI,MAAM;AAElB,YAAQ;IAER,MAAY,uBAAW,kBAAkB,CAAE,GAAE,YAAY;AACvD,aAAQ;KAER,MAAMC,SAAoB,CAAE;AAC5B,WAAM,QAAQ,IACZ,MAAM,KAAK,UAAU,QAAQ,CAAC,CAAC,IAAI,OAAO,OAAO;AAC/C,UAAI;AACF,aAAM,GAAG,SAAS;MACnB,SAAQ,OAAO;AACd,cAAO,KAAK,MAAM;MACnB;KACF,EAAC,CACH;AACD,YAAO,SAAS;AAChB,eAAU,OAAO;AACjB,iBAAY,SAAS;AAErB,SAAI,OAAO,SAAS,EAClB,OAAM,IAAI,eAAe;IAE5B,EAAC;AAEF,WAAO,UAAU,SAAS,EAExB,cAAa,UAAU,OAAO,CAAE;AAGlC,WAAO,UAAU,OAAO,GAAG;AACzB,WAAM,YAAY;AAElB,YAAO,OAAO,SAAS,GAAG;MAExB,MAAM,CAAC,UAAU,OAAO,GAAG,OAAO,OAAO;AAEzC,cAAQ,OAAO,QAAf;OACE,KAAK;AACH,cAAM,OAAO;AACb,iBAAS,MAAM;AACf;OACF,KAAK,QACH,OAAM,OAAO;MAChB;KACF;AACD,mBAAc,gBAAgB;IAC/B;;;;;;EACF;CACF;AACF"}

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

@@ -1,25 +1,27 @@
-'use strict';
 
+//#region src/unstable-core-do-not-import/stream/utils/readableStreamFrom.ts
 /**
- * Creates a ReadableStream from an AsyncIterable.
- *
- * @param iterable - The source AsyncIterable to stream from
- * @returns A ReadableStream that yields values from the AsyncIterable
- */ function readableStreamFrom(iterable) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    return new ReadableStream({
-        async cancel () {
-            await iterator.return?.();
-        },
-        async pull (controller) {
-            const result = await iterator.next();
-            if (result.done) {
-                controller.close();
-                return;
-            }
-            controller.enqueue(result.value);
-        }
-    });
+* Creates a ReadableStream from an AsyncIterable.
+*
+* @param iterable - The source AsyncIterable to stream from
+* @returns A ReadableStream that yields values from the AsyncIterable
+*/
+function readableStreamFrom(iterable) {
+	const iterator = iterable[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async cancel() {
+			await iterator.return?.();
+		},
+		async pull(controller) {
+			const result = await iterator.next();
+			if (result.done) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(result.value);
+		}
+	});
 }
 
-exports.readableStreamFrom = readableStreamFrom;
+//#endregion
+exports.readableStreamFrom = readableStreamFrom;

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

@@ -1,23 +1,27 @@
+//#region src/unstable-core-do-not-import/stream/utils/readableStreamFrom.ts
 /**
- * Creates a ReadableStream from an AsyncIterable.
- *
- * @param iterable - The source AsyncIterable to stream from
- * @returns A ReadableStream that yields values from the AsyncIterable
- */ function readableStreamFrom(iterable) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    return new ReadableStream({
-        async cancel () {
-            await iterator.return?.();
-        },
-        async pull (controller) {
-            const result = await iterator.next();
-            if (result.done) {
-                controller.close();
-                return;
-            }
-            controller.enqueue(result.value);
-        }
-    });
+* Creates a ReadableStream from an AsyncIterable.
+*
+* @param iterable - The source AsyncIterable to stream from
+* @returns A ReadableStream that yields values from the AsyncIterable
+*/
+function readableStreamFrom(iterable) {
+	const iterator = iterable[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async cancel() {
+			await iterator.return?.();
+		},
+		async pull(controller) {
+			const result = await iterator.next();
+			if (result.done) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(result.value);
+		}
+	});
 }
 
+//#endregion
 export { readableStreamFrom };
+//# sourceMappingURL=readableStreamFrom.mjs.map

package/dist/unstable-core-do-not-import/stream/utils/readableStreamFrom.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"readableStreamFrom.mjs","names":["iterable: AsyncIterable<TYield, void>"],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/readableStreamFrom.ts"],"sourcesContent":["/**\n * Creates a ReadableStream from an AsyncIterable.\n *\n * @param iterable - The source AsyncIterable to stream from\n * @returns A ReadableStream that yields values from the AsyncIterable\n */\nexport function readableStreamFrom<TYield>(\n  iterable: AsyncIterable<TYield, void>,\n): ReadableStream<TYield> {\n  const iterator = iterable[Symbol.asyncIterator]();\n\n  return new ReadableStream({\n    async cancel() {\n      await iterator.return?.();\n    },\n\n    async pull(controller) {\n      const result = await iterator.next();\n\n      if (result.done) {\n        controller.close();\n        return;\n      }\n\n      controller.enqueue(result.value);\n    },\n  });\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,mBACdA,UACwB;CACxB,MAAM,WAAW,SAAS,OAAO,gBAAgB;AAEjD,QAAO,IAAI,eAAe;EACxB,MAAM,SAAS;AACb,SAAM,SAAS,UAAU;EAC1B;EAED,MAAM,KAAK,YAAY;GACrB,MAAM,SAAS,MAAM,SAAS,MAAM;AAEpC,OAAI,OAAO,MAAM;AACf,eAAW,OAAO;AAClB;GACD;AAED,cAAW,QAAQ,OAAO,MAAM;EACjC;CACF;AACF"}

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

@@ -1,26 +1,20 @@
-'use strict';
-
-var disposable = require('./disposable.js');
+const require__Users_julius_dev_trpc_packages_server_src_unstable_core_do_not_import_stream_utils_disposable = require('./disposable.js');
 
+//#region src/unstable-core-do-not-import/stream/utils/timerResource.ts
 const disposablePromiseTimerResult = Symbol();
 function timerResource(ms) {
-    let timer = null;
-    return disposable.makeResource({
-        start () {
-            if (timer) {
-                throw new Error('Timer already started');
-            }
-            const promise = new Promise((resolve)=>{
-                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
-            });
-            return promise;
-        }
-    }, ()=>{
-        if (timer) {
-            clearTimeout(timer);
-        }
-    });
+	let timer = null;
+	return require__Users_julius_dev_trpc_packages_server_src_unstable_core_do_not_import_stream_utils_disposable.makeResource({ start() {
+		if (timer) throw new Error("Timer already started");
+		const promise = new Promise((resolve) => {
+			timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
+		});
+		return promise;
+	} }, () => {
+		if (timer) clearTimeout(timer);
+	});
 }
 
+//#endregion
 exports.disposablePromiseTimerResult = disposablePromiseTimerResult;
-exports.timerResource = timerResource;
+exports.timerResource = timerResource;

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

@@ -1,23 +1,20 @@
-import { makeResource } from './disposable.mjs';
+import { makeResource } from "./disposable.mjs";
 
+//#region src/unstable-core-do-not-import/stream/utils/timerResource.ts
 const disposablePromiseTimerResult = Symbol();
 function timerResource(ms) {
-    let timer = null;
-    return makeResource({
-        start () {
-            if (timer) {
-                throw new Error('Timer already started');
-            }
-            const promise = new Promise((resolve)=>{
-                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
-            });
-            return promise;
-        }
-    }, ()=>{
-        if (timer) {
-            clearTimeout(timer);
-        }
-    });
+	let timer = null;
+	return makeResource({ start() {
+		if (timer) throw new Error("Timer already started");
+		const promise = new Promise((resolve) => {
+			timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
+		});
+		return promise;
+	} }, () => {
+		if (timer) clearTimeout(timer);
+	});
 }
 
+//#endregion
 export { disposablePromiseTimerResult, timerResource };
+//# sourceMappingURL=timerResource.mjs.map

package/dist/unstable-core-do-not-import/stream/utils/timerResource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timerResource.mjs","names":["ms: number","timer: ReturnType<typeof setTimeout> | null"],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/timerResource.ts"],"sourcesContent":["import { makeResource } from './disposable';\n\nexport const disposablePromiseTimerResult = Symbol();\n\nexport function timerResource(ms: number) {\n  let timer: ReturnType<typeof setTimeout> | null = null;\n\n  return makeResource(\n    {\n      start() {\n        if (timer) {\n          throw new Error('Timer already started');\n        }\n\n        const promise = new Promise<typeof disposablePromiseTimerResult>(\n          (resolve) => {\n            timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);\n          },\n        );\n        return promise;\n      },\n    },\n    () => {\n      if (timer) {\n        clearTimeout(timer);\n      }\n    },\n  );\n}\n"],"mappings":";;;AAEA,MAAa,+BAA+B,QAAQ;AAEpD,SAAgB,cAAcA,IAAY;CACxC,IAAIC,QAA8C;AAElD,QAAO,aACL,EACE,QAAQ;AACN,MAAI,MACF,OAAM,IAAI,MAAM;EAGlB,MAAM,UAAU,IAAI,QAClB,CAAC,YAAY;AACX,WAAQ,WAAW,MAAM,QAAQ,6BAA6B,EAAE,GAAG;EACpE;AAEH,SAAO;CACR,EACF,GACD,MAAM;AACJ,MAAI,MACF,cAAa,MAAM;CAEtB,EACF;AACF"}