@highstate/designer 0.2.2 → 0.3.3

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/jsonl.mjs

@@ -0,0 +1,631 @@
+import { Unpromise } from '../../vendor/unpromise/unpromise.mjs';
+import { isObject, isFunction, isAsyncIterable, run } from '../utils.mjs';
+import { iteratorResource } from './utils/asyncIterable.mjs';
+import { createDeferred } from './utils/createDeferred.mjs';
+import { makeAsyncResource, makeResource } from './utils/disposable.mjs';
+import { readableStreamFrom } from './utils/readableStreamFrom.mjs';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+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);
+}
+// ---------- types
+// ---------- types
+const CHUNK_VALUE_TYPE_PROMISE = 0;
+const CHUNK_VALUE_TYPE_ASYNC_ITERABLE = 1;
+const PROMISE_STATUS_FULFILLED = 0;
+const PROMISE_STATUS_REJECTED = 1;
+const ASYNC_ITERABLE_STATUS_RETURN = 0;
+const ASYNC_ITERABLE_STATUS_YIELD = 1;
+const ASYNC_ITERABLE_STATUS_ERROR = 2;
+function isPromise(value) {
+    return (isObject(value) || isFunction(value)) && typeof value?.['then'] === 'function' && typeof value?.['catch'] === 'function';
+}
+class MaxDepthError extends Error {
+    constructor(path){
+        super('Max depth reached at path: ' + path.join('.')), _define_property(this, "path", void 0), this.path = path;
+    }
+}
+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, 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 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;
+                    return [
+                        idx,
+                        PROMISE_STATUS_FULFILLED,
+                        encode(next, path)
+                    ];
+                } catch (cause) {
+                    opts.onError?.({
+                        error: cause,
+                        path
+                    });
+                    return [
+                        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) {
+                        throw error;
+                    }
+                    const iterator = _ts_add_disposable_resource(env, 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;
+                }
+            });
+        }
+        function checkMaxDepth(path) {
+            if (opts.maxDepth && path.length > opts.maxDepth) {
+                return new MaxDepthError(path);
+            }
+            return null;
+        }
+        function encodeAsync(value, path) {
+            if (isPromise(value)) {
+                return [
+                    CHUNK_VALUE_TYPE_PROMISE,
+                    encodePromise(value, path)
+                ];
+            }
+            if (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;
+        }
+        function encode(value, path) {
+            if (value === undefined) {
+                return [
+                    []
+                ];
+            }
+            if (!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
+                ]);
+            }
+            return [
+                [
+                    newObj
+                ],
+                ...asyncValues
+            ];
+        }
+        const newHead = {};
+        for (const [key, item] of Object.entries(data)){
+            newHead[key] = encode(item, [
+                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.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);
+            }
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+/**
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
+ */ function jsonlStreamProducer(opts) {
+    let stream = readableStreamFrom(createBatchStreamProducer(opts));
+    const { serialize } = opts;
+    if (serialize) {
+        stream = stream.pipeThrough(new TransformStream({
+            transform (chunk, controller) {
+                controller.enqueue(serialize(chunk));
+            }
+        }));
+    }
+    return stream.pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            controller.enqueue(JSON.stringify(chunk) + '\n');
+        }
+    })).pipeThrough(new TextEncoderStream());
+}
+class StreamInterruptedError extends Error {
+    constructor(cause){
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        super('Invalid response or stream interrupted', {
+            cause
+        });
+    }
+}
+class AsyncError extends Error {
+    constructor(data){
+        super('Received error from server'), _define_property(this, "data", void 0), this.data = data;
+    }
+}
+const nodeJsStreamToReaderEsque = (source)=>{
+    return {
+        getReader () {
+            const stream = new ReadableStream({
+                start (controller) {
+                    source.on('data', (chunk)=>{
+                        controller.enqueue(chunk);
+                    });
+                    source.on('end', ()=>{
+                        controller.close();
+                    });
+                    source.on('error', (error)=>{
+                        controller.error(error);
+                    });
+                }
+            });
+            return stream.getReader();
+        }
+    };
+};
+function createLineAccumulator(from) {
+    const reader = 'getReader' in from ? from.getReader() : nodeJsStreamToReaderEsque(from).getReader();
+    let lineAggregate = '';
+    return new ReadableStream({
+        async pull (controller) {
+            const { done, value } = await reader.read();
+            if (done) {
+                controller.close();
+            } else {
+                controller.enqueue(value);
+            }
+        },
+        cancel () {
+            return reader.cancel();
+        }
+    }).pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            lineAggregate += chunk;
+            const parts = lineAggregate.split('\n');
+            lineAggregate = parts.pop() ?? '';
+            for (const part of parts){
+                controller.enqueue(part);
+            }
+        }
+    }));
+}
+function createConsumerStream(from) {
+    const stream = createLineAccumulator(from);
+    let sentHead = false;
+    return stream.pipeThrough(new TransformStream({
+        transform (line, controller) {
+            if (!sentHead) {
+                const head = JSON.parse(line);
+                controller.enqueue(head);
+                sentHead = true;
+            } else {
+                const chunk = JSON.parse(line);
+                controller.enqueue(chunk);
+            }
+        }
+    }));
+}
+/**
+ * Creates a handler for managing stream controllers and their lifecycle
+ */ function createStreamsManager(abortController) {
+    const controllerMap = new Map();
+    /**
+   * Checks if there are no pending controllers or deferred promises
+   */ function isEmpty() {
+        return Array.from(controllerMap.values()).every((c)=>c.closed);
+    }
+    /**
+   * Creates a stream controller
+   */ function createStreamController() {
+        let originalController;
+        const stream = new ReadableStream({
+            start (controller) {
+                originalController = controller;
+            }
+        });
+        const streamController = {
+            enqueue: (v)=>originalController.enqueue(v),
+            close: ()=>{
+                originalController.close();
+                // mark as closed and remove methods
+                Object.assign(streamController, {
+                    closed: true,
+                    close: ()=>{
+                    // noop
+                    },
+                    enqueue: ()=>{
+                    // noop
+                    },
+                    getReaderResource: null
+                });
+                if (isEmpty()) {
+                    abortController.abort();
+                }
+            },
+            closed: false,
+            getReaderResource: ()=>{
+                const reader = stream.getReader();
+                return makeResource(reader, ()=>{
+                    reader.releaseLock();
+                    streamController.close();
+                });
+            }
+        };
+        return streamController;
+    }
+    /**
+   * Gets or creates a stream controller
+   */ function getOrCreate(chunkId) {
+        let c = controllerMap.get(chunkId);
+        if (!c) {
+            c = createStreamController();
+            controllerMap.set(chunkId, c);
+        }
+        return c;
+    }
+    /**
+   * Cancels all pending controllers and rejects deferred promises
+   */ function cancelAll(reason) {
+        const error = new StreamInterruptedError(reason);
+        for (const controller of controllerMap.values()){
+            controller.enqueue(error);
+            controller.close();
+        }
+    }
+    return {
+        getOrCreate,
+        isEmpty,
+        cancelAll
+    };
+}
+/**
+ * JSON Lines stream consumer
+ * @see https://jsonlines.org/
+ */ async function jsonlStreamConsumer(opts) {
+    const { deserialize = (v)=>v } = opts;
+    let source = createConsumerStream(opts.from);
+    if (deserialize) {
+        source = source.pipeThrough(new TransformStream({
+            transform (chunk, controller) {
+                controller.enqueue(deserialize(chunk));
+            }
+        }));
+    }
+    let headDeferred = createDeferred();
+    const streamManager = createStreamsManager(opts.abortController);
+    function decodeChunkDefinition(value) {
+        const [_path, type, chunkId] = value;
+        const controller = streamManager.getOrCreate(chunkId);
+        switch(type){
+            case CHUNK_VALUE_TYPE_PROMISE:
+                {
+                    return run(async ()=>{
+                        const env = {
+                            stack: [],
+                            error: void 0,
+                            hasError: false
+                        };
+                        try {
+                            const reader = _ts_add_disposable_resource(env, controller.getReaderResource(), false);
+                            ;
+                            const { value } = await reader.read();
+                            if (value instanceof StreamInterruptedError) {
+                                throw value;
+                            }
+                            const [_chunkId, status, data] = value;
+                            switch(status){
+                                case PROMISE_STATUS_FULFILLED:
+                                    return decode(data);
+                                case PROMISE_STATUS_REJECTED:
+                                    throw opts.formatError?.({
+                                        error: data
+                                    }) ?? new AsyncError(data);
+                            }
+                        } catch (e) {
+                            env.error = e;
+                            env.hasError = true;
+                        } finally{
+                            _ts_dispose_resources(env);
+                        }
+                    });
+                }
+            case CHUNK_VALUE_TYPE_ASYNC_ITERABLE:
+                {
+                    return run(async function*() {
+                        const env = {
+                            stack: [],
+                            error: void 0,
+                            hasError: false
+                        };
+                        try {
+                            const reader = _ts_add_disposable_resource(env, controller.getReaderResource(), false);
+                            ;
+                            while(true){
+                                const { value } = await reader.read();
+                                if (value instanceof StreamInterruptedError) {
+                                    throw value;
+                                }
+                                const [_chunkId, status, data] = value;
+                                switch(status){
+                                    case ASYNC_ITERABLE_STATUS_YIELD:
+                                        yield decode(data);
+                                        break;
+                                    case ASYNC_ITERABLE_STATUS_RETURN:
+                                        return decode(data);
+                                    case ASYNC_ITERABLE_STATUS_ERROR:
+                                        throw opts.formatError?.({
+                                            error: data
+                                        }) ?? new AsyncError(data);
+                                }
+                            }
+                        } catch (e) {
+                            env.error = e;
+                            env.hasError = true;
+                        } finally{
+                            _ts_dispose_resources(env);
+                        }
+                    });
+                }
+        }
+    }
+    function decode(value) {
+        const [[data], ...asyncProps] = value;
+        for (const value of asyncProps){
+            const [key] = value;
+            const decoded = decodeChunkDefinition(value);
+            if (key === null) {
+                return decoded;
+            }
+            data[key] = decoded;
+        }
+        return data;
+    }
+    const closeOrAbort = (reason)=>{
+        const error = new StreamInterruptedError(reason);
+        headDeferred?.reject(error);
+        streamManager.cancelAll(error);
+    };
+    source.pipeTo(new WritableStream({
+        write (chunkOrHead) {
+            if (headDeferred) {
+                const head = chunkOrHead;
+                for (const [key, value] of Object.entries(chunkOrHead)){
+                    const parsed = decode(value);
+                    head[key] = parsed;
+                }
+                headDeferred.resolve(head);
+                headDeferred = null;
+                return;
+            }
+            const chunk = chunkOrHead;
+            const [idx] = chunk;
+            const controller = streamManager.getOrCreate(idx);
+            controller.enqueue(chunk);
+        },
+        close: closeOrAbort,
+        abort: closeOrAbort
+    }), {
+        signal: opts.abortController.signal
+    }).catch((error)=>{
+        opts.onError?.({
+            error
+        });
+        closeOrAbort(error);
+    });
+    return [
+        await headDeferred.promise,
+        streamManager
+    ];
+}
+
+export { isPromise, jsonlStreamConsumer, jsonlStreamProducer };