@trpc/server 11.0.0-rc.693 → 11.0.0-rc.694

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

@@ -1,10 +1,10 @@
 'use strict';
 
-var unpromise = require('../../vendor/unpromise/unpromise.js');
 var utils = require('../utils.js');
 var asyncIterable = require('./utils/asyncIterable.js');
 var createDeferred = require('./utils/createDeferred.js');
 var disposable = require('./utils/disposable.js');
+var mergeAsyncIterables = require('./utils/mergeAsyncIterables.js');
 var readableStreamFrom = require('./utils/readableStreamFrom.js');
 
 function _define_property(obj, key, value) {
@@ -103,223 +103,189 @@ class MaxDepthError extends Error {
     }
 }
 async function* createBatchStreamProducer(opts) {
-    const env = {
-        stack: [],
-        error: void 0,
-        hasError: false
-    };
-    try {
-        const { data } = opts;
-        let counter = 0;
-        const placeholder = 0;
-        const queue = _ts_add_disposable_resource(env, disposable.makeAsyncResource(new Set(), async ()=>{
-            await Promise.all(Array.from(queue).map((it)=>it.iterator.return?.()));
-        }), true);
-        ;
-        function registerAsync(callback) {
-            const idx = counter++;
-            const iterator = callback(idx)[Symbol.asyncIterator]();
-            const nextPromise = iterator.next();
-            nextPromise.catch(()=>{
-            // prevent unhandled promise rejection
-            });
-            queue.add({
-                iterator,
-                nextPromise
-            });
-            return idx;
-        }
-        function encodePromise(promise, path) {
-            return registerAsync(async function*(idx) {
+    const { data } = opts;
+    let counter = 0;
+    const placeholder = 0;
+    const mergedIterables = mergeAsyncIterables.mergeAsyncIterables();
+    function registerAsync(callback) {
+        const idx = counter++;
+        const iterable = callback(idx);
+        mergedIterables.add(iterable);
+        return idx;
+    }
+    function encodePromise(promise, path) {
+        return registerAsync(async function*(idx) {
+            const error = checkMaxDepth(path);
+            if (error) {
+                // Catch any errors from the original promise to ensure they're reported
+                promise.catch((cause)=>{
+                    opts.onError?.({
+                        error: cause,
+                        path
+                    });
+                });
+                // Replace the promise with a rejected one containing the max depth error
+                promise = Promise.reject(error);
+            }
+            try {
+                const next = await promise;
+                yield [
+                    idx,
+                    PROMISE_STATUS_FULFILLED,
+                    encode(next, path)
+                ];
+            } catch (cause) {
+                opts.onError?.({
+                    error: cause,
+                    path
+                });
+                yield [
+                    idx,
+                    PROMISE_STATUS_REJECTED,
+                    opts.formatError?.({
+                        error: cause,
+                        path
+                    })
+                ];
+            }
+        });
+    }
+    function encodeAsyncIterable(iterable, path) {
+        return registerAsync(async function*(idx) {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
                 const error = checkMaxDepth(path);
                 if (error) {
-                    // Catch any errors from the original promise to ensure they're reported
-                    promise.catch((cause)=>{
-                        opts.onError?.({
-                            error: cause,
-                            path
-                        });
-                    });
-                    // Replace the promise with a rejected one containing the max depth error
-                    promise = Promise.reject(error);
+                    throw error;
                 }
+                const iterator = _ts_add_disposable_resource(env, asyncIterable.iteratorResource(iterable), true);
+                ;
                 try {
-                    const next = await promise;
-                    return [
-                        idx,
-                        PROMISE_STATUS_FULFILLED,
-                        encode(next, path)
-                    ];
+                    while(true){
+                        const next = await iterator.next();
+                        if (next.done) {
+                            yield [
+                                idx,
+                                ASYNC_ITERABLE_STATUS_RETURN,
+                                encode(next.value, path)
+                            ];
+                            break;
+                        }
+                        yield [
+                            idx,
+                            ASYNC_ITERABLE_STATUS_YIELD,
+                            encode(next.value, path)
+                        ];
+                    }
                 } catch (cause) {
                     opts.onError?.({
                         error: cause,
                         path
                     });
-                    return [
+                    yield [
                         idx,
-                        PROMISE_STATUS_REJECTED,
+                        ASYNC_ITERABLE_STATUS_ERROR,
                         opts.formatError?.({
                             error: cause,
                             path
                         })
                     ];
                 }
-            });
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        });
+    }
+    function checkMaxDepth(path) {
+        if (opts.maxDepth && path.length > opts.maxDepth) {
+            return new MaxDepthError(path);
         }
-        function encodeAsyncIterable(iterable, path) {
-            return registerAsync(async function*(idx) {
-                const env = {
-                    stack: [],
-                    error: void 0,
-                    hasError: false
-                };
-                try {
-                    const error = checkMaxDepth(path);
-                    if (error) {
-                        throw error;
-                    }
-                    const iterator = _ts_add_disposable_resource(env, asyncIterable.iteratorResource(iterable), true);
-                    ;
-                    try {
-                        while(true){
-                            const next = await iterator.next();
-                            if (next.done) {
-                                return [
-                                    idx,
-                                    ASYNC_ITERABLE_STATUS_RETURN,
-                                    encode(next.value, path)
-                                ];
-                            }
-                            yield [
-                                idx,
-                                ASYNC_ITERABLE_STATUS_YIELD,
-                                encode(next.value, path)
-                            ];
-                        }
-                    } catch (cause) {
-                        opts.onError?.({
-                            error: cause,
-                            path
-                        });
-                        return [
-                            idx,
-                            ASYNC_ITERABLE_STATUS_ERROR,
-                            opts.formatError?.({
-                                error: cause,
-                                path
-                            })
-                        ];
-                    }
-                } catch (e) {
-                    env.error = e;
-                    env.hasError = true;
-                } finally{
-                    const result = _ts_dispose_resources(env);
-                    if (result) await result;
-                }
-            });
+        return null;
+    }
+    function encodeAsync(value, path) {
+        if (isPromise(value)) {
+            return [
+                CHUNK_VALUE_TYPE_PROMISE,
+                encodePromise(value, path)
+            ];
         }
-        function checkMaxDepth(path) {
-            if (opts.maxDepth && path.length > opts.maxDepth) {
-                return new MaxDepthError(path);
+        if (utils.isAsyncIterable(value)) {
+            if (opts.maxDepth && path.length >= opts.maxDepth) {
+                throw new Error('Max depth reached');
             }
-            return null;
+            return [
+                CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
+                encodeAsyncIterable(value, path)
+            ];
         }
-        function encodeAsync(value, path) {
-            if (isPromise(value)) {
-                return [
-                    CHUNK_VALUE_TYPE_PROMISE,
-                    encodePromise(value, path)
-                ];
-            }
-            if (utils.isAsyncIterable(value)) {
-                if (opts.maxDepth && path.length >= opts.maxDepth) {
-                    throw new Error('Max depth reached');
-                }
-                return [
-                    CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-                    encodeAsyncIterable(value, path)
-                ];
-            }
-            return null;
+        return null;
+    }
+    function encode(value, path) {
+        if (value === undefined) {
+            return [
+                []
+            ];
         }
-        function encode(value, path) {
-            if (value === undefined) {
-                return [
-                    []
-                ];
-            }
-            if (!utils.isObject(value)) {
-                return [
-                    [
-                        value
-                    ]
-                ];
-            }
-            const reg = encodeAsync(value, path);
-            if (reg) {
-                return [
-                    [
-                        placeholder
-                    ],
-                    [
-                        null,
-                        ...reg
-                    ]
-                ];
-            }
-            const newObj = {};
-            const asyncValues = [];
-            for (const [key, item] of Object.entries(value)){
-                const transformed = encodeAsync(item, [
-                    ...path,
-                    key
-                ]);
-                if (!transformed) {
-                    newObj[key] = item;
-                    continue;
-                }
-                newObj[key] = placeholder;
-                asyncValues.push([
-                    key,
-                    ...transformed
-                ]);
-            }
+        if (!utils.isObject(value)) {
+            return [
+                [
+                    value
+                ]
+            ];
+        }
+        const reg = encodeAsync(value, path);
+        if (reg) {
             return [
                 [
-                    newObj
+                    placeholder
                 ],
-                ...asyncValues
+                [
+                    null,
+                    ...reg
+                ]
             ];
         }
-        const newHead = {};
-        for (const [key, item] of Object.entries(data)){
-            newHead[key] = encode(item, [
+        const newObj = {};
+        const asyncValues = [];
+        for (const [key, item] of Object.entries(value)){
+            const transformed = encodeAsync(item, [
+                ...path,
                 key
             ]);
-        }
-        yield newHead;
-        // Process all async iterables in parallel by racing their next values
-        while(queue.size > 0){
-            // Race all iterators to get the next value from any of them
-            const [entry, res] = await unpromise.Unpromise.race(Array.from(queue).map(async (it)=>[
-                    it,
-                    await it.nextPromise
-                ]));
-            yield res.value;
-            // Remove current iterator and re-add if not done
-            queue.delete(entry);
-            if (!res.done) {
-                entry.nextPromise = entry.iterator.next();
-                queue.add(entry);
+            if (!transformed) {
+                newObj[key] = item;
+                continue;
             }
+            newObj[key] = placeholder;
+            asyncValues.push([
+                key,
+                ...transformed
+            ]);
         }
-    } catch (e) {
-        env.error = e;
-        env.hasError = true;
-    } finally{
-        const result = _ts_dispose_resources(env);
-        if (result) await result;
+        return [
+            [
+                newObj
+            ],
+            ...asyncValues
+        ];
+    }
+    const newHead = {};
+    for (const [key, item] of Object.entries(data)){
+        newHead[key] = encode(item, [
+            key
+        ]);
+    }
+    yield newHead;
+    for await (const value of mergedIterables){
+        yield value;
     }
 }
 /**