rouzer 5.2.1 → 5.2.2

package/dist/ndjson.d.ts

@@ -57,5 +57,5 @@ export declare function decodeNdjson<T = unknown>(stream: ReadableStream<Uint8Ar
  * `content-type: application/x-ndjson; charset=utf-8` unless the caller supplies
  * a content type in `init.headers`.
  */
-export declare function ndjsonResponse<T>(source: NdjsonSource<T>, init?: ResponseInit & NdjsonEncodeOptions): Response;
+export declare function ndjsonResponse<T>(source: NdjsonSource<T>, { signal, ...init }?: ResponseInit & NdjsonEncodeOptions): Response;
 export {};

package/dist/ndjson.js

@@ -52,107 +52,184 @@ export const routerPlugin = {
  * closed.
  */
 export function encodeNdjson(source, options = {}) {
-    const iterator = getAsyncIterator(source);
-    const encoder = new TextEncoder();
-    const { signal } = options;
-    let cancelled = false;
-    let cleanup;
-    let abortHandler;
-    function removeAbortHandler() {
-        if (signal && abortHandler) {
-            signal.removeEventListener('abort', abortHandler);
-            abortHandler = undefined;
-        }
-    }
-    function cancelIterator(reason) {
-        cancelled = true;
-        removeAbortHandler();
-        cleanup ??= Promise.resolve(iterator.return?.(reason)).then(() => { });
-        return cleanup;
+    return new ReadableStream(new NdjsonEncoder(source, options));
+}
+/**
+ * Decode a newline-delimited JSON byte stream.
+ *
+ * @remarks UTF-8 chunks may split JSON lines. Both `\n` and `\r\n` line endings
+ * are accepted, and a final line does not need a trailing newline. Malformed
+ * lines throw a `SyntaxError` that includes the 1-based line number.
+ */
+export function decodeNdjson(stream) {
+    return new NdjsonDecoder(stream);
+}
+class NdjsonEncoder {
+    options;
+    iterator;
+    encoder = new TextEncoder();
+    cancelled = false;
+    cleanup;
+    abortHandler;
+    constructor(source, options) {
+        this.options = options;
+        this.iterator = getAsyncIterator(source);
     }
-    return new ReadableStream({
-        start(controller) {
-            if (!signal) {
-                return;
-            }
-            abortHandler = () => {
-                void cancelIterator(signal.reason).catch(() => { });
+    start(controller) {
+        const { signal } = this.options;
+        if (signal) {
+            this.abortHandler = () => {
+                void this.cancel(signal.reason).catch(() => { });
                 try {
                     controller.close();
                 }
                 catch { }
             };
             if (signal.aborted) {
-                abortHandler();
-                return;
+                this.abortHandler();
             }
-            signal.addEventListener('abort', abortHandler, { once: true });
-        },
-        async pull(controller) {
-            if (cancelled) {
-                controller.close();
-                return;
+            else {
+                signal.addEventListener('abort', this.abortHandler, { once: true });
             }
-            const { done, value } = await iterator.next();
-            if (cancelled) {
-                return;
+        }
+    }
+    async pull(controller) {
+        if (this.cancelled) {
+            controller.close();
+            return;
+        }
+        const { done, value } = await this.iterator.next();
+        if (this.cancelled) {
+            return;
+        }
+        if (done) {
+            this.removeAbortHandler();
+            controller.close();
+            return;
+        }
+        const line = JSON.stringify(value);
+        if (line === undefined) {
+            throw new TypeError('NDJSON items must serialize to a JSON text; received undefined');
+        }
+        controller.enqueue(this.encoder.encode(`${line}\n`));
+    }
+    async cancel(reason) {
+        if (!this.cancelled) {
+            this.cancelled = true;
+            this.removeAbortHandler();
+            this.cleanup ??= Promise.resolve(this.iterator.return?.(reason)).then(() => { });
+        }
+        await this.cleanup;
+    }
+    removeAbortHandler() {
+        const { signal } = this.options;
+        if (signal && this.abortHandler) {
+            signal.removeEventListener('abort', this.abortHandler);
+            this.abortHandler = undefined;
+        }
+    }
+}
+class NdjsonDecoder {
+    reader;
+    decoder = new TextDecoder();
+    buffer = '';
+    lineNumber = 0;
+    closed = false;
+    doneReading = false;
+    readerReleased = false;
+    constructor(stream) {
+        this.reader = stream.getReader();
+    }
+    [Symbol.asyncIterator]() {
+        return new NdjsonAsyncIterator(this);
+    }
+    releaseReader() {
+        if (!this.readerReleased) {
+            this.readerReleased = true;
+            this.reader.releaseLock();
+        }
+    }
+    async cancelReader(reason) {
+        if (!this.doneReading) {
+            await this.reader.cancel(reason).catch(() => { });
+        }
+        this.releaseReader();
+    }
+    async parseNextLine(line) {
+        try {
+            this.lineNumber += 1;
+            return {
+                done: false,
+                value: parseNdjsonLine(stripCarriageReturn(line), this.lineNumber),
+            };
+        }
+        catch (error) {
+            this.closed = true;
+            await this.cancelReader(error);
+            throw error;
+        }
+    }
+}
+class NdjsonAsyncIterator {
+    decoder;
+    closed = false;
+    constructor(decoder) {
+        this.decoder = decoder;
+    }
+    async next() {
+        if (this.closed || this.decoder.closed) {
+            return { done: true, value: undefined };
+        }
+        while (true) {
+            const newlineIndex = this.decoder.buffer.indexOf('\n');
+            if (newlineIndex !== -1) {
+                const line = this.decoder.buffer.slice(0, newlineIndex);
+                this.decoder.buffer = this.decoder.buffer.slice(newlineIndex + 1);
+                return this.decoder.parseNextLine(line);
             }
-            if (done) {
-                removeAbortHandler();
-                controller.close();
-                return;
+            if (this.decoder.doneReading) {
+                this.close();
+                this.decoder.releaseReader();
+                if (this.decoder.buffer.length > 0) {
+                    const line = this.decoder.buffer;
+                    this.decoder.buffer = '';
+                    return this.decoder.parseNextLine(line);
+                }
+                return { done: true, value: undefined };
             }
-            const line = JSON.stringify(value);
-            if (line === undefined) {
-                throw new TypeError('NDJSON items must serialize to a JSON text; received undefined');
+            let chunk;
+            try {
+                chunk = await this.decoder.reader.read();
             }
-            controller.enqueue(encoder.encode(`${line}\n`));
-        },
-        async cancel(reason) {
-            await cancelIterator(reason);
-        },
-    });
-}
-/**
- * Decode a newline-delimited JSON byte stream.
- *
- * @remarks UTF-8 chunks may split JSON lines. Both `\n` and `\r\n` line endings
- * are accepted, and a final line does not need a trailing newline. Malformed
- * lines throw a `SyntaxError` that includes the 1-based line number.
- */
-export async function* decodeNdjson(stream) {
-    const reader = stream.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    let lineNumber = 0;
-    let doneReading = false;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                buffer += decoder.decode();
-                doneReading = true;
-                break;
+            catch (error) {
+                this.close();
+                this.decoder.releaseReader();
+                throw error;
+            }
+            if (this.closed || this.decoder.closed) {
+                return { done: true, value: undefined };
             }
-            buffer += decoder.decode(value, { stream: true });
-            let newlineIndex;
-            while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
-                const line = stripCarriageReturn(buffer.slice(0, newlineIndex));
-                buffer = buffer.slice(newlineIndex + 1);
-                lineNumber += 1;
-                yield parseNdjsonLine(line, lineNumber);
+            if (chunk.done) {
+                this.decoder.buffer += this.decoder.decoder.decode();
+                this.decoder.doneReading = true;
+            }
+            else {
+                this.decoder.buffer += this.decoder.decoder.decode(chunk.value, {
+                    stream: true,
+                });
             }
-        }
-        if (buffer.length > 0) {
-            lineNumber += 1;
-            yield parseNdjsonLine(stripCarriageReturn(buffer), lineNumber);
         }
     }
-    finally {
-        if (!doneReading) {
-            await reader.cancel().catch(() => { });
+    async return(reason) {
+        if (!this.closed) {
+            this.close();
+            await this.decoder.cancelReader(reason);
         }
-        reader.releaseLock();
+        return { done: true, value: undefined };
+    }
+    close() {
+        this.closed = true;
+        this.decoder.closed = true;
     }
 }
 /**
@@ -162,32 +239,28 @@ export async function* decodeNdjson(stream) {
  * `content-type: application/x-ndjson; charset=utf-8` unless the caller supplies
  * a content type in `init.headers`.
  */
-export function ndjsonResponse(source, init = {}) {
-    const { signal, ...responseInit } = init;
+export function ndjsonResponse(source, { signal, ...init } = {}) {
     const headers = new Headers(init.headers);
     if (!headers.has('content-type')) {
         headers.set('content-type', 'application/x-ndjson; charset=utf-8');
     }
     return new Response(encodeNdjson(source, { signal }), {
-        ...responseInit,
+        ...init,
         headers,
     });
 }
 function getAsyncIterator(source) {
-    const asyncIterator = source[Symbol.asyncIterator]?.();
-    if (asyncIterator) {
-        return asyncIterator;
+    if (Symbol.asyncIterator in source) {
+        return source[Symbol.asyncIterator]();
     }
-    const iterator = source[Symbol.iterator]?.();
-    if (iterator) {
+    if (Symbol.iterator in source) {
+        const iterator = source[Symbol.iterator]();
         return {
-            next() {
-                return Promise.resolve(iterator.next());
-            },
-            async return() {
-                iterator.return?.();
-                return { done: true, value: undefined };
-            },
+            next: async (value) => iterator.next(value),
+            return: iterator.return
+                ? async (value) => iterator.return(value)
+                : undefined,
+            throw: iterator.throw ? async (error) => iterator.throw(error) : undefined,
         };
     }
     throw new TypeError('NDJSON source must be iterable');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "5.2.1",
+  "version": "5.2.2",
   "packageManager": "pnpm@11.5.1",
   "type": "module",
   "exports": {