documonster 0.20.2 → 0.21.0

package/dist/esm/modules/stream/kernel/duplexify.js

@@ -0,0 +1,355 @@
+/**
+ * Stream kernel - Duplex.from()
+ *
+ * Port of Node.js `lib/internal/streams/duplexify.js`: turn a stream, Web
+ * stream, iterable, async generator function, promise or `{ readable,
+ * writable }` pair into a Duplex. The stream classes are passed in so this module
+ * does not import `classes.ts`, which imports it.
+ */
+import { destroyer } from "./destroy.js";
+import { eos } from "./end-of-stream.js";
+import { createAbortError, errInvalidArgType, errInvalidReturnValue } from "./errors.js";
+import { from } from "./from.js";
+import { nextTick } from "./state.js";
+import { isDuplexNodeStream, isIterable, isNodeStream, isReadable, isReadableNodeStream, isReadableStream, isWritable, isWritableNodeStream, isWritableStream } from "./stream-utils.js";
+export function duplexify(kernel, body, name) {
+    const { Readable, Writable, Duplex } = kernel;
+    if (isDuplexNodeStream(body)) {
+        return body;
+    }
+    if (isReadableNodeStream(body)) {
+        return duplexifyPair(kernel, { readable: body });
+    }
+    if (isWritableNodeStream(body)) {
+        return duplexifyPair(kernel, { writable: body });
+    }
+    if (isNodeStream(body)) {
+        return duplexifyPair(kernel, { writable: false, readable: false });
+    }
+    if (isReadableStream(body)) {
+        return duplexifyPair(kernel, { readable: Readable.fromWeb(body) });
+    }
+    if (isWritableStream(body)) {
+        return duplexifyPair(kernel, { writable: Writable.fromWeb(body) });
+    }
+    if (typeof body === "function") {
+        const { value, write, final, destroy } = fromAsyncGen(body);
+        if (isDuplexNodeStream(value)) {
+            return value;
+        }
+        if (isIterable(value)) {
+            return from(Duplex, value, { objectMode: true, write, final, destroy });
+        }
+        const then = value?.then;
+        if (typeof then === "function") {
+            const promise = then.call(value, (val) => {
+                if (val != null) {
+                    throw errInvalidReturnValue("nully", "body", val);
+                }
+            }, (err) => {
+                destroyer(d, err);
+            });
+            const d = new Duplex({
+                objectMode: true,
+                readable: false,
+                write,
+                final(cb) {
+                    final(async () => {
+                        try {
+                            await promise;
+                            nextTick(() => cb(null));
+                        }
+                        catch (err) {
+                            nextTick(() => cb(err));
+                        }
+                    });
+                },
+                destroy
+            });
+            return d;
+        }
+        throw errInvalidReturnValue("Iterable, AsyncIterable or AsyncFunction", name, value);
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+        return duplexify(kernel, body.arrayBuffer(), name);
+    }
+    if (isIterable(body)) {
+        return from(Duplex, body, { objectMode: true, writable: false });
+    }
+    if (isReadableStream(body?.readable) && isWritableStream(body?.writable)) {
+        return Duplex.fromWeb(body);
+    }
+    if (typeof body?.writable === "object" || typeof body?.readable === "object") {
+        const readable = body?.readable
+            ? isReadableNodeStream(body.readable)
+                ? body.readable
+                : duplexify(kernel, body.readable, name)
+            : undefined;
+        const writable = body?.writable
+            ? isWritableNodeStream(body.writable)
+                ? body.writable
+                : duplexify(kernel, body.writable, name)
+            : undefined;
+        return duplexifyPair(kernel, { readable, writable });
+    }
+    const then = body?.then;
+    if (typeof then === "function") {
+        then.call(body, (val) => {
+            if (val != null) {
+                d.push(val);
+            }
+            d.push(null);
+        }, (err) => {
+            destroyer(d, err);
+        });
+        const d = new Duplex({ objectMode: true, writable: false, read() { } });
+        return d;
+    }
+    throw invalidDuplexBody(body, name);
+}
+/** The error `Duplex.from` throws for a `body` it cannot use. */
+export function invalidDuplexBody(body, name = "body") {
+    return errInvalidArgType(name, [
+        "Blob",
+        "ReadableStream",
+        "WritableStream",
+        "Stream",
+        "Iterable",
+        "AsyncIterable",
+        "Function",
+        "{ readable, writable } pair",
+        "Promise"
+    ], body);
+}
+/**
+ * What `duplexify` would reject inside `body`, found without touching `body`:
+ * the branches above, in the same order, with nothing created, locked or
+ * subscribed to. `undefined` when it would accept it. A function counts as
+ * accepted — what it returns is known only by calling it.
+ */
+export function rejectedDuplexBody(body) {
+    if (isNodeStream(body) ||
+        isReadableStream(body) ||
+        isWritableStream(body) ||
+        typeof body === "function" ||
+        (typeof Blob !== "undefined" && body instanceof Blob) ||
+        isIterable(body) ||
+        (isReadableStream(body?.readable) && isWritableStream(body?.writable))) {
+        return undefined;
+    }
+    if (typeof body?.writable === "object" || typeof body?.readable === "object") {
+        const readable = body?.readable;
+        const writable = body?.writable;
+        return ((readable && !isReadableNodeStream(readable) ? rejectedDuplexBody(readable) : undefined) ??
+            (writable && !isWritableNodeStream(writable) ? rejectedDuplexBody(writable) : undefined));
+    }
+    return typeof body?.then === "function" ? undefined : { value: body };
+}
+function isThenable(value) {
+    return !isNodeStream(value) && typeof value?.then === "function";
+}
+/** Whether `duplexify` would read `body` as a `{ readable, writable }` object of its own. */
+function isSidesObject(body) {
+    return (!isNodeStream(body) &&
+        !isReadableStream(body) &&
+        !isWritableStream(body) &&
+        typeof body !== "function" &&
+        !isIterable(body) &&
+        !(isReadableStream(body?.readable) && isWritableStream(body?.writable)) &&
+        (typeof body?.writable === "object" || typeof body?.readable === "object"));
+}
+/**
+ * `body` with every promise `duplexify` would subscribe to — the body itself,
+ * or a side of a `{ readable, writable }` object, at any depth — adopted into
+ * a native promise. A native promise always calls back later; a thenable that
+ * calls back at once reaches `duplexify` before its Duplex exists, and throws
+ * `Cannot read properties of undefined` — in Node's own `Duplex.from`, too.
+ */
+export function adoptThenables(body) {
+    if (isThenable(body)) {
+        return Promise.resolve(body);
+    }
+    if (isSidesObject(body)) {
+        const sides = {};
+        if ("readable" in body) {
+            sides.readable = adoptThenables(body.readable);
+        }
+        if ("writable" in body) {
+            sides.writable = adoptThenables(body.writable);
+        }
+        return sides;
+    }
+    return body;
+}
+/** Call `visit` on every promise `duplexify` would subscribe to inside `body`. */
+export function forEachThenable(body, visit) {
+    if (isThenable(body)) {
+        visit(body);
+    }
+    else if (isSidesObject(body)) {
+        forEachThenable(body.readable, visit);
+        forEachThenable(body.writable, visit);
+    }
+}
+/** Feed writes into an async generator function and read what it yields. */
+function fromAsyncGen(fn) {
+    let resolve = null;
+    let promise = new Promise(r => {
+        resolve = r;
+    });
+    const ac = new AbortController();
+    const signal = ac.signal;
+    const value = fn((async function* () {
+        while (true) {
+            const current = promise;
+            promise = null;
+            const { chunk, done, cb } = await current;
+            nextTick(cb);
+            if (done) {
+                return;
+            }
+            if (signal.aborted) {
+                throw createAbortError(signal.reason);
+            }
+            promise = new Promise(r => {
+                resolve = r;
+            });
+            yield chunk;
+        }
+    })(), { signal });
+    return {
+        value,
+        write(chunk, _encoding, cb) {
+            const r = resolve;
+            resolve = null;
+            r({ chunk, done: false, cb });
+        },
+        final(cb) {
+            const r = resolve;
+            resolve = null;
+            r({ done: true, cb });
+        },
+        destroy(err, cb) {
+            ac.abort(err);
+            if (resolve !== null) {
+                const r = resolve;
+                resolve = null;
+                r({ done: true, cb() { } });
+            }
+            cb(err);
+        }
+    };
+}
+function duplexifyPair(kernel, pair) {
+    const { Readable, Duplex } = kernel;
+    const r = pair.readable && typeof pair.readable.read !== "function"
+        ? Readable.wrap(pair.readable)
+        : pair.readable;
+    const w = pair.writable;
+    let readable = !!isReadable(r);
+    let writable = !!isWritable(w);
+    let ondrain = null;
+    let onfinish = null;
+    let onreadable = null;
+    // undefined: still open; null: both sides finished; a function: destroy waiting on them.
+    let onclose;
+    const d = new Duplex({
+        readableObjectMode: !!r?.readableObjectMode,
+        writableObjectMode: !!w?.writableObjectMode,
+        readable,
+        writable
+    });
+    function onfinished(err) {
+        const cb = onclose;
+        onclose = null;
+        if (cb) {
+            cb(err);
+        }
+        else if (err) {
+            d.destroy(err);
+        }
+    }
+    if (writable) {
+        eos(w, err => {
+            writable = false;
+            if (err) {
+                destroyer(r, err);
+            }
+            onfinished(err);
+        });
+        d._write = function (chunk, encoding, callback) {
+            if (w.write(chunk, encoding)) {
+                callback();
+            }
+            else {
+                ondrain = callback;
+            }
+        };
+        d._final = function (callback) {
+            w.end();
+            onfinish = callback;
+        };
+        w.on("drain", () => {
+            if (ondrain) {
+                const cb = ondrain;
+                ondrain = null;
+                cb();
+            }
+        });
+        w.on("finish", () => {
+            if (onfinish) {
+                const cb = onfinish;
+                onfinish = null;
+                cb();
+            }
+        });
+    }
+    if (readable) {
+        eos(r, err => {
+            readable = false;
+            if (err) {
+                destroyer(w, err);
+            }
+            onfinished(err);
+        });
+        r.on("readable", () => {
+            if (onreadable) {
+                const cb = onreadable;
+                onreadable = null;
+                cb();
+            }
+        });
+        r.on("end", () => {
+            d.push(null);
+        });
+        d._read = function () {
+            while (true) {
+                const buf = r.read();
+                if (buf === null) {
+                    onreadable = d._read;
+                    return;
+                }
+                if (!d.push(buf)) {
+                    return;
+                }
+            }
+        };
+    }
+    d._destroy = function (err, callback) {
+        if (!err && onclose !== null) {
+            err = createAbortError();
+        }
+        onreadable = null;
+        ondrain = null;
+        onfinish = null;
+        if (onclose === null) {
+            callback(err);
+        }
+        else {
+            onclose = callback;
+            destroyer(w, err);
+            destroyer(r, err);
+        }
+    };
+    return d;
+}

package/dist/esm/modules/stream/kernel/end-of-stream.js

@@ -0,0 +1,212 @@
+/**
+ * Stream kernel - end-of-stream detection
+ *
+ * Port of Node.js `lib/internal/streams/end-of-stream.js`: one place that
+ * decides when a stream is done and whether it ended cleanly or prematurely.
+ * `finished`, `pipeline`, `compose`, async iteration and the Web adapters all
+ * rely on it, so they cannot disagree about completion.
+ */
+import { createAbortError, errInvalidArgType, errStreamPrematureClose } from "./errors.js";
+import { nextTick } from "./state.js";
+import { isClosed, isNodeStream, isReadable, isReadableErrored, isReadableFinished, isReadableNodeStream, isWritable, isWritableErrored, isWritableFinished, isWritableNodeStream, willEmitClose as streamWillEmitClose } from "./stream-utils.js";
+const nop = () => { };
+function getEosErrored(stream) {
+    return isWritableErrored(stream) || isReadableErrored(stream) || null;
+}
+function getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished) {
+    const errored = getEosErrored(stream);
+    if (errored) {
+        return errored;
+    }
+    if (readable && !readableFinished && isReadableNodeStream(stream, true)) {
+        if (!isReadableFinished(stream, false)) {
+            return errStreamPrematureClose();
+        }
+    }
+    if (writable && !writableFinished) {
+        if (!isWritableFinished(stream, false)) {
+            return errStreamPrematureClose();
+        }
+    }
+    return null;
+}
+export function eos(stream, optionsOrCallback, maybeCallback) {
+    let options;
+    let callback;
+    if (typeof optionsOrCallback === "function") {
+        options = {};
+        callback = optionsOrCallback;
+    }
+    else {
+        options = optionsOrCallback ?? {};
+        callback = maybeCallback;
+    }
+    if (!isNodeStream(stream)) {
+        throw errInvalidArgType("stream", ["ReadableStream", "WritableStream", "Stream"], stream);
+    }
+    const readable = options.readable ?? isReadableNodeStream(stream);
+    const writable = options.writable ?? isWritableNodeStream(stream);
+    let willEmitClose = !!streamWillEmitClose(stream) &&
+        isReadableNodeStream(stream) === readable &&
+        isWritableNodeStream(stream) === writable;
+    let writableFinished = isWritableFinished(stream, false);
+    let readableFinished = isReadableFinished(stream, false);
+    const wState = stream._writableState;
+    const rState = stream._readableState;
+    // undefined: still pending; null: done cleanly; Error: done with an error.
+    let immediateResult;
+    if (isClosed(stream)) {
+        immediateResult = getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished);
+    }
+    else if (wState?.errorEmitted || rState?.errorEmitted) {
+        if (!willEmitClose) {
+            immediateResult = getEosErrored(stream);
+        }
+    }
+    else if (!readable &&
+        (!willEmitClose || isReadable(stream)) &&
+        (writableFinished || isWritable(stream) === false) &&
+        (wState == null || wState.pendingcb === undefined || wState.pendingcb === 0)) {
+        immediateResult = getEosErrored(stream);
+    }
+    else if (!writable &&
+        (!willEmitClose || isWritable(stream)) &&
+        (readableFinished || isReadable(stream) === false)) {
+        immediateResult = getEosErrored(stream);
+    }
+    let cleanup = () => {
+        callback = nop;
+    };
+    if (immediateResult !== undefined) {
+        if (options.error !== false) {
+            stream.on("error", nop);
+            cleanup = () => {
+                callback = nop;
+                stream.removeListener("error", nop);
+            };
+        }
+    }
+    else if (options.signal?.aborted) {
+        immediateResult = createAbortError(options.signal.reason);
+    }
+    if (immediateResult !== undefined) {
+        const result = immediateResult;
+        const report = () => {
+            if (result === null) {
+                callback.call(stream);
+            }
+            else {
+                callback.call(stream, result);
+            }
+        };
+        if (options.synchronous) {
+            report();
+        }
+        else {
+            nextTick(report);
+        }
+        return cleanup;
+    }
+    let called = false;
+    const userCallback = callback;
+    callback = function (err) {
+        if (called) {
+            return;
+        }
+        called = true;
+        userCallback.call(this, err);
+    };
+    const onlegacyfinish = () => {
+        if (!stream.writable) {
+            onfinish();
+        }
+    };
+    const onfinish = () => {
+        writableFinished = true;
+        if (stream.destroyed) {
+            willEmitClose = false;
+        }
+        if (willEmitClose && (!stream.readable || readable)) {
+            return;
+        }
+        if (!readable || readableFinished) {
+            callback.call(stream);
+        }
+    };
+    const onend = () => {
+        readableFinished = true;
+        if (stream.destroyed) {
+            willEmitClose = false;
+        }
+        if (willEmitClose && (!stream.writable || writable)) {
+            return;
+        }
+        if (!writable || writableFinished) {
+            callback.call(stream);
+        }
+    };
+    const onerror = (err) => {
+        callback.call(stream, err);
+    };
+    const onclose = () => {
+        const error = getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished);
+        if (error === null) {
+            callback.call(stream);
+        }
+        else {
+            callback.call(stream, error);
+        }
+    };
+    // Legacy streams have no writable state to say when they finished.
+    if (writable && !wState) {
+        stream.on("end", onlegacyfinish);
+        stream.on("close", onlegacyfinish);
+    }
+    stream.on("end", onend);
+    stream.on("finish", onfinish);
+    if (options.error !== false) {
+        stream.on("error", onerror);
+    }
+    stream.on("close", onclose);
+    cleanup = () => {
+        callback = nop;
+        stream.removeListener("end", onlegacyfinish);
+        stream.removeListener("close", onlegacyfinish);
+        stream.removeListener("finish", onfinish);
+        stream.removeListener("end", onend);
+        stream.removeListener("error", onerror);
+        stream.removeListener("close", onclose);
+    };
+    const signal = options.signal;
+    if (signal) {
+        const abort = () => {
+            const endCallback = callback;
+            cleanup();
+            endCallback.call(stream, createAbortError(signal.reason));
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        const originalCallback = callback;
+        callback = function (err) {
+            signal.removeEventListener("abort", abort);
+            originalCallback.call(this, err);
+        };
+    }
+    return cleanup;
+}
+/** Destroy `stream` when `signal` aborts; detaches once the stream is done. */
+export function addAbortSignalNoValidate(signal, stream) {
+    if (typeof signal !== "object" || !("aborted" in signal)) {
+        return stream;
+    }
+    const onAbort = () => {
+        stream.destroy(createAbortError(signal.reason));
+    };
+    if (signal.aborted) {
+        onAbort();
+    }
+    else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        eos(stream, () => signal.removeEventListener("abort", onAbort));
+    }
+    return stream;
+}