documonster 0.20.2 → 0.21.0

package/dist/esm/modules/stream/kernel/compose-impl.js

@@ -0,0 +1,225 @@
+/**
+ * Stream kernel - compose algorithm
+ *
+ * `composeImpl` is a port of Node.js `lib/internal/streams/compose.js`: the
+ * stages are connected with `pipelineImpl`, and one Duplex writes into the
+ * head and reads from the tail. It backs `Readable.prototype.compose` and the
+ * module's `compose()`; the stream classes are passed in by both.
+ */
+import { destroyer } from "./destroy.js";
+import { eos } from "./end-of-stream.js";
+import { createAbortError, errInvalidArgValue, errMissingArgs } from "./errors.js";
+import { pipelineImpl } from "./pipeline-impl.js";
+import { isNodeStream, isReadable, isReadableStream, isTransformStream, isWebStream, isWritable, isWritableStream } from "./stream-utils.js";
+const noop = () => { };
+export function composeImpl(kernel, ...streams) {
+    const { Duplex } = kernel;
+    if (streams.length === 0) {
+        throw errMissingArgs("streams");
+    }
+    if (streams.length === 1) {
+        return Duplex.from(streams[0]);
+    }
+    const orgStreams = streams.slice();
+    if (typeof streams[0] === "function") {
+        streams[0] = Duplex.from(streams[0]);
+    }
+    if (typeof streams[streams.length - 1] === "function") {
+        const idx = streams.length - 1;
+        streams[idx] = Duplex.from(streams[idx]);
+    }
+    for (let n = 0; n < streams.length; ++n) {
+        if (!isNodeStream(streams[n]) && !isWebStream(streams[n])) {
+            continue;
+        }
+        if (n < streams.length - 1 &&
+            !(isReadable(streams[n]) || isReadableStream(streams[n]) || isTransformStream(streams[n]))) {
+            throw errInvalidArgValue(`streams[${n}]`, orgStreams[n], "must be readable");
+        }
+        if (n > 0 &&
+            !(isWritable(streams[n]) || isWritableStream(streams[n]) || isTransformStream(streams[n]))) {
+            throw errInvalidArgValue(`streams[${n}]`, orgStreams[n], "must be writable");
+        }
+    }
+    let ondrain = null;
+    let onfinish = null;
+    // undefined: running; null: the pipeline settled; a function: destroy waiting on it.
+    let onclose;
+    function onfinished(err) {
+        const cb = onclose;
+        onclose = null;
+        if (cb) {
+            cb(err);
+        }
+        else if (err) {
+            d.destroy(err);
+        }
+        else if (!readable && !writable) {
+            d.destroy();
+        }
+    }
+    function finishWrite() {
+        if (onfinish) {
+            const cb = onfinish;
+            onfinish = null;
+            cb();
+        }
+    }
+    const head = streams[0];
+    const tail = pipelineImpl(kernel, streams, onfinished);
+    const writable = !!(isWritable(head) || isWritableStream(head) || isTransformStream(head));
+    const readable = !!(isReadable(tail) || isReadableStream(tail) || isTransformStream(tail));
+    // The Web reader / writer compose takes for itself: released when done,
+    // cancelled or aborted when the composed stream is destroyed early.
+    let headWriter;
+    let tailReader;
+    function releaseHeadWriter() {
+        if (headWriter) {
+            headWriter.releaseLock();
+            headWriter = undefined;
+        }
+    }
+    function releaseTailReader() {
+        if (tailReader) {
+            tailReader.releaseLock();
+            tailReader = undefined;
+        }
+    }
+    /** Stop whatever Web side is still held; resolves once that is done. */
+    function abandonWebSides(err) {
+        const tasks = [];
+        if (tailReader) {
+            const reader = tailReader;
+            tasks.push(reader
+                .cancel(err ?? undefined)
+                .catch(noop)
+                .then(releaseTailReader));
+        }
+        if (headWriter) {
+            const writer = headWriter;
+            tasks.push(writer
+                .abort(err ?? undefined)
+                .catch(noop)
+                .then(releaseHeadWriter));
+        }
+        return Promise.allSettled(tasks);
+    }
+    const d = new Duplex({
+        writableObjectMode: !!head?.writableObjectMode,
+        readableObjectMode: !!tail?.readableObjectMode,
+        writable,
+        readable
+    });
+    if (writable) {
+        if (isNodeStream(head)) {
+            d._write = function (chunk, encoding, callback) {
+                if (head.write(chunk, encoding)) {
+                    callback();
+                }
+                else {
+                    ondrain = callback;
+                }
+            };
+            d._final = function (callback) {
+                head.end();
+                onfinish = callback;
+            };
+            head.on("drain", () => {
+                if (ondrain) {
+                    const cb = ondrain;
+                    ondrain = null;
+                    cb();
+                }
+            });
+        }
+        else {
+            const writer = (isTransformStream(head) ? head.writable : head).getWriter();
+            headWriter = writer;
+            d._write = async function (chunk, _encoding, callback) {
+                try {
+                    await writer.ready;
+                    writer.write(chunk).catch(() => { });
+                    callback();
+                }
+                catch (err) {
+                    callback(err);
+                }
+            };
+            d._final = async function (callback) {
+                try {
+                    await writer.ready;
+                    writer.close().then(releaseHeadWriter, noop);
+                    onfinish = callback;
+                }
+                catch (err) {
+                    callback(err);
+                }
+            };
+        }
+        // The writable side is finished once the tail has produced everything.
+        if (isNodeStream(tail)) {
+            eos(tail, finishWrite);
+        }
+    }
+    if (readable) {
+        if (isNodeStream(tail)) {
+            d._read = function () {
+                tail.resume();
+            };
+            tail.on("data", (chunk) => {
+                if (!d.push(chunk)) {
+                    tail.pause();
+                }
+            });
+            tail.on("end", () => {
+                d.push(null);
+            });
+        }
+        else {
+            const reader = (isTransformStream(tail) ? tail.readable : tail).getReader();
+            tailReader = reader;
+            d._read = async function () {
+                while (true) {
+                    try {
+                        const { value, done } = await reader.read();
+                        if (done) {
+                            releaseTailReader();
+                            d.push(null);
+                            finishWrite();
+                            return;
+                        }
+                        if (!d.push(value)) {
+                            return;
+                        }
+                    }
+                    catch {
+                        return;
+                    }
+                }
+            };
+        }
+    }
+    d._destroy = function (err, callback) {
+        if (!err && onclose !== null) {
+            err = createAbortError();
+        }
+        ondrain = null;
+        onfinish = null;
+        if (isNodeStream(tail)) {
+            destroyer(tail, err);
+        }
+        // Cancelling the tail's reader (or aborting the head's writer) is also
+        // what lets the inner pipeline finish, so wait for it either way.
+        const abandoned = abandonWebSides(err);
+        const finishDestroy = (e) => {
+            abandoned.then(() => callback(e));
+        };
+        if (onclose === null) {
+            finishDestroy(err);
+        }
+        else {
+            onclose = finishDestroy;
+        }
+    };
+    return d;
+}

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

@@ -0,0 +1,255 @@
+/**
+ * Stream kernel - destroy / construct lifecycle
+ *
+ * Port of Node.js `lib/internal/streams/destroy.js`. Every stream class shares
+ * these functions, so a Duplex is destroyed once — both of its states are
+ * marked in the same call, and `'error'` / `'close'` are emitted once.
+ */
+import { aggregateTwoErrors, createAbortError, errMultipleCallback } from "./errors.js";
+import { nextTick } from "./state.js";
+import { isDestroyed, isFinished, kIsDestroyed } from "./stream-utils.js";
+const kDestroy = Symbol("kDestroy");
+const kConstruct = Symbol("kConstruct");
+function checkError(err, w, r) {
+    if (err) {
+        if (w && !w.errored) {
+            w.errored = err;
+        }
+        if (r && !r.errored) {
+            r.errored = err;
+        }
+    }
+}
+export function destroy(err, cb) {
+    const r = this._readableState;
+    const w = this._writableState;
+    const s = (w || r);
+    if (w?.destroyed || r?.destroyed) {
+        if (typeof cb === "function") {
+            cb();
+        }
+        return this;
+    }
+    // Mark destroyed before any callback runs so re-entrant destroy() is a no-op.
+    checkError(err, w, r);
+    if (w) {
+        w.destroyed = true;
+    }
+    if (r) {
+        r.destroyed = true;
+    }
+    if (!s.constructed) {
+        this.once(kDestroy, (er) => {
+            callDestroy(this, aggregateTwoErrors(er, err), cb);
+        });
+    }
+    else {
+        callDestroy(this, err, cb);
+    }
+    return this;
+}
+function callDestroy(self, err, cb) {
+    let called = false;
+    const onDestroy = (err) => {
+        if (called) {
+            return;
+        }
+        called = true;
+        const r = self._readableState;
+        const w = self._writableState;
+        checkError(err, w, r);
+        if (w) {
+            w.closed = true;
+        }
+        if (r) {
+            r.closed = true;
+        }
+        if (typeof cb === "function") {
+            cb(err);
+        }
+        if (err) {
+            nextTick(() => emitErrorCloseNT(self, err));
+        }
+        else {
+            nextTick(() => emitCloseNT(self));
+        }
+    };
+    try {
+        self._destroy(err || null, onDestroy);
+    }
+    catch (e) {
+        onDestroy(e);
+    }
+}
+function emitErrorCloseNT(self, err) {
+    emitErrorNT(self, err);
+    emitCloseNT(self);
+}
+function emitCloseNT(self) {
+    const r = self._readableState;
+    const w = self._writableState;
+    if (w) {
+        w.closeEmitted = true;
+    }
+    if (r) {
+        r.closeEmitted = true;
+    }
+    if (w?.emitClose || r?.emitClose) {
+        self.emit("close");
+    }
+}
+function emitErrorNT(self, err) {
+    const r = self._readableState;
+    const w = self._writableState;
+    if (w?.errorEmitted || r?.errorEmitted) {
+        return;
+    }
+    if (w) {
+        w.errorEmitted = true;
+    }
+    if (r) {
+        r.errorEmitted = true;
+    }
+    self.emit("error", err);
+}
+export function undestroy() {
+    const r = this._readableState;
+    const w = this._writableState;
+    if (r) {
+        r.constructed = true;
+        r.closed = false;
+        r.closeEmitted = false;
+        r.destroyed = false;
+        r.errored = null;
+        r.errorEmitted = false;
+        r.reading = false;
+        r.ended = r.readable === false;
+        r.endEmitted = r.readable === false;
+    }
+    if (w) {
+        w.constructed = true;
+        w.destroyed = false;
+        w.closed = false;
+        w.closeEmitted = false;
+        w.errored = null;
+        w.errorEmitted = false;
+        w.finalCalled = false;
+        w.prefinished = false;
+        w.ended = w.writable === false;
+        w.ending = w.writable === false;
+        w.finished = w.writable === false;
+    }
+}
+/**
+ * Report an error the way the stream is configured to: destroy it when
+ * `autoDestroy` is on, otherwise record and emit it without tearing down.
+ */
+export function errorOrDestroy(stream, err, sync) {
+    const r = stream._readableState;
+    const w = stream._writableState;
+    if (w?.destroyed || r?.destroyed) {
+        return;
+    }
+    if (r?.autoDestroy || w?.autoDestroy) {
+        stream.destroy(err);
+    }
+    else if (err) {
+        if (w && !w.errored) {
+            w.errored = err;
+        }
+        if (r && !r.errored) {
+            r.errored = err;
+        }
+        if (sync) {
+            nextTick(() => emitErrorNT(stream, err));
+        }
+        else {
+            emitErrorNT(stream, err);
+        }
+    }
+}
+export function construct(stream, cb) {
+    if (typeof stream._construct !== "function") {
+        return;
+    }
+    const r = stream._readableState;
+    const w = stream._writableState;
+    if (r) {
+        r.constructed = false;
+    }
+    if (w) {
+        w.constructed = false;
+    }
+    stream.once(kConstruct, cb);
+    if (stream.listenerCount(kConstruct) > 1) {
+        // Duplex: the second side registers its callback on the same run.
+        return;
+    }
+    nextTick(() => constructNT(stream));
+}
+function constructNT(stream) {
+    let called = false;
+    const onConstruct = (err) => {
+        if (called) {
+            errorOrDestroy(stream, err ?? errMultipleCallback());
+            return;
+        }
+        called = true;
+        const r = stream._readableState;
+        const w = stream._writableState;
+        const s = (w || r);
+        if (r) {
+            r.constructed = true;
+        }
+        if (w) {
+            w.constructed = true;
+        }
+        if (s.destroyed) {
+            stream.emit(kDestroy, err);
+        }
+        else if (err) {
+            errorOrDestroy(stream, err, true);
+        }
+        else {
+            stream.emit(kConstruct);
+        }
+    };
+    try {
+        stream._construct(err => {
+            nextTick(() => onConstruct(err));
+        });
+    }
+    catch (err) {
+        nextTick(() => onConstruct(err));
+    }
+}
+/**
+ * Tear down any stream-like object. A stream that has not finished cleanly is
+ * destroyed with an AbortError so whoever is waiting on it learns why.
+ */
+export function destroyer(stream, err) {
+    if (!stream || isDestroyed(stream)) {
+        return;
+    }
+    if (!err && !isFinished(stream)) {
+        err = createAbortError();
+    }
+    if (typeof stream.destroy === "function") {
+        stream.destroy(err);
+    }
+    else if (typeof stream.close === "function") {
+        stream.close();
+    }
+    else if (err) {
+        nextTick(() => {
+            stream.emit("error", err);
+            nextTick(() => stream.emit("close"));
+        });
+    }
+    else {
+        nextTick(() => stream.emit("close"));
+    }
+    if (!stream.destroyed) {
+        stream[kIsDestroyed] = true;
+    }
+}