@trpc/server 11.1.3-alpha-tmp-tsdown.24 → 11.1.3-alpha-tmp-tsdown.26

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

@@ -1,402 +0,0 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
-const require_utils = require('../utils.js');
-const require_disposable = require('./utils/disposable.js');
-const require_usingCtx$1 = require('../../node_modules/.pnpm/@oxc-project_runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js');
-const require_asyncIterable = require('./utils/asyncIterable.js');
-const require_createDeferred = require('./utils/createDeferred.js');
-const require_mergeAsyncIterables = require('./utils/mergeAsyncIterables.js');
-const require_readableStreamFrom = require('./utils/readableStreamFrom.js');
-const require_withPing = require('./utils/withPing.js');
-
-//#region src/unstable-core-do-not-import/stream/jsonl.ts
-var import_usingCtx = require_rolldown_runtime.__toESM(require_usingCtx$1.require_usingCtx());
-function isPlainObject(value) {
-	return Object.prototype.toString.call(value) === "[object Object]";
-}
-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 (require_utils.isObject(value) || require_utils.isFunction(value)) && typeof value?.["then"] === "function" && typeof value?.["catch"] === "function";
-}
-var MaxDepthError = class extends Error {
-	constructor(path) {
-		super("Max depth reached at path: " + path.join("."));
-		this.path = path;
-	}
-};
-async function* createBatchStreamProducer(opts) {
-	const { data } = opts;
-	let counter = 0;
-	const placeholder = 0;
-	const mergedIterables = require_mergeAsyncIterables.mergeAsyncIterables();
-	function registerAsync(callback) {
-		const idx = counter++;
-		const iterable$1 = callback(idx);
-		mergedIterables.add(iterable$1);
-		return idx;
-	}
-	function encodePromise(promise, path) {
-		return registerAsync(async function* (idx) {
-			const error = checkMaxDepth(path);
-			if (error) {
-				promise.catch((cause) => {
-					opts.onError?.({
-						error: cause,
-						path
-					});
-				});
-				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$1, path) {
-		return registerAsync(async function* (idx) {
-			try {
-				var _usingCtx = (0, import_usingCtx.default)();
-				const error = checkMaxDepth(path);
-				if (error) throw error;
-				const iterator = _usingCtx.a(require_asyncIterable.iteratorResource(iterable$1));
-				try {
-					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
-					});
-					yield [
-						idx,
-						ASYNC_ITERABLE_STATUS_ERROR,
-						opts.formatError?.({
-							error: cause,
-							path
-						})
-					];
-				}
-			} catch (_) {
-				_usingCtx.e = _;
-			} finally {
-				await _usingCtx.d();
-			}
-		});
-	}
-	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 (require_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;
-	}
-	function encode(value, path) {
-		if (value === void 0) return [[]];
-		const reg = encodeAsync(value, path);
-		if (reg) return [[placeholder], [null, ...reg]];
-		if (!isPlainObject(value)) return [[value]];
-		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;
-	let iterable = mergedIterables;
-	if (opts.pingMs) iterable = require_withPing.withPing(mergedIterables, opts.pingMs);
-	for await (const value of iterable) yield value;
-}
-/**
-* JSON Lines stream producer
-* @see https://jsonlines.org/
-*/
-function jsonlStreamProducer(opts) {
-	let stream = require_readableStreamFrom.readableStreamFrom(createBatchStreamProducer(opts));
-	const { serialize } = opts;
-	if (serialize) stream = stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
-		if (chunk === require_withPing.PING_SYM) controller.enqueue(require_withPing.PING_SYM);
-		else controller.enqueue(serialize(chunk));
-	} }));
-	return stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
-		if (chunk === require_withPing.PING_SYM) controller.enqueue(" ");
-		else controller.enqueue(JSON.stringify(chunk) + "\n");
-	} })).pipeThrough(new TextEncoderStream());
-}
-var AsyncError = class extends Error {
-	constructor(data) {
-		super("Received error from server");
-		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 = /* @__PURE__ */ 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();
-				clear();
-				if (isEmpty()) abortController.abort();
-			},
-			closed: false,
-			getReaderResource: () => {
-				const reader = stream.getReader();
-				return require_disposable.makeResource(reader, () => {
-					reader.releaseLock();
-					streamController.close();
-				});
-			},
-			error: (reason) => {
-				originalController.error(reason);
-				clear();
-			}
-		};
-		function clear() {
-			Object.assign(streamController, {
-				closed: true,
-				close: () => {},
-				enqueue: () => {},
-				getReaderResource: null,
-				error: () => {}
-			});
-		}
-		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) {
-		for (const controller of controllerMap.values()) controller.error(reason);
-	}
-	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 = require_createDeferred.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 require_utils.run(async () => {
-				try {
-					var _usingCtx3 = (0, import_usingCtx.default)();
-					const reader = _usingCtx3.u(controller.getReaderResource());
-					const { value: value$1 } = await reader.read();
-					const [_chunkId, status, data] = value$1;
-					switch (status) {
-						case PROMISE_STATUS_FULFILLED: return decode(data);
-						case PROMISE_STATUS_REJECTED: throw opts.formatError?.({ error: data }) ?? new AsyncError(data);
-					}
-				} catch (_) {
-					_usingCtx3.e = _;
-				} finally {
-					_usingCtx3.d();
-				}
-			});
-			case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: return require_utils.run(async function* () {
-				try {
-					var _usingCtx4 = (0, import_usingCtx.default)();
-					const reader = _usingCtx4.u(controller.getReaderResource());
-					while (true) {
-						const { value: value$1 } = await reader.read();
-						const [_chunkId, status, data] = value$1;
-						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 (_) {
-					_usingCtx4.e = _;
-				} finally {
-					_usingCtx4.d();
-				}
-			});
-		}
-	}
-	function decode(value) {
-		const [[data], ...asyncProps] = value;
-		for (const value$1 of asyncProps) {
-			const [key] = value$1;
-			const decoded = decodeChunkDefinition(value$1);
-			if (key === null) return decoded;
-			data[key] = decoded;
-		}
-		return data;
-	}
-	const closeOrAbort = (reason) => {
-		headDeferred?.reject(reason);
-		streamManager.cancelAll(reason);
-	};
-	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(new Error("Stream closed")),
-		abort: closeOrAbort
-	}), { signal: opts.abortController.signal }).catch((error) => {
-		opts.onError?.({ error });
-		closeOrAbort(error);
-	});
-	return [await headDeferred.promise, streamManager];
-}
-
-//#endregion
-exports.isPromise = isPromise;
-exports.jsonlStreamConsumer = jsonlStreamConsumer;
-exports.jsonlStreamProducer = jsonlStreamProducer;