visaljs 0.0.7 → 0.0.8

package/node/prelude/internal/stream_web_adapters.js

@@ -0,0 +1,143 @@
+// Readable.toWeb and fromWeb, Writable.toWeb and fromWeb, Duplex.toWeb and fromWeb: a node:stream
+// as a web stream and back, linked into programs that name them (internal/features.js). Node's
+// are lib/internal/webstreams/adapters.js; these give the same streams for the common cases.
+import { Duplex, finished, Readable, Writable } from "../stream.js";
+import { features } from "./features.js";
+
+/* Readable.toWeb(readable): a ReadableStream of its chunks (Uint8Arrays, unless in object mode) */
+function newReadableStreamFromStreamReadable(streamReadable) {
+  const objectMode = streamReadable.readableObjectMode;
+  let controller;
+  let closed = false;
+  const onData = (chunk) => {
+    if (closed) return;
+    if (Buffer.isBuffer(chunk) && !objectMode) chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    controller.enqueue(chunk);
+    if (controller.desiredSize <= 0) streamReadable.pause();
+  };
+  return new ReadableStream({
+    start(c) {
+      controller = c;
+      streamReadable.on("data", onData);
+      finished(streamReadable, (error) => {
+        if (closed) return;
+        closed = true;
+        if (error) controller.error(error);
+        else controller.close();
+      });
+      if (streamReadable.readableEnded) {
+        closed = true;
+        controller.close();
+      }
+    },
+    pull() {
+      streamReadable.resume();
+    },
+    cancel(reason) {
+      closed = true;
+      streamReadable.destroy(reason);
+    },
+  }, { highWaterMark: objectMode ? 16 : 65536, size: objectMode ? undefined : (chunk) => chunk.byteLength });
+}
+
+/* Readable.fromWeb(readableStream): a Readable of its chunks */
+function newStreamReadableFromReadableStream(readableStream, options) {
+  const reader = readableStream.getReader();
+  let closed = false;
+  const readable = new Readable({
+    objectMode: !!(options && options.objectMode),
+    highWaterMark: options?.highWaterMark,
+    encoding: options?.encoding,
+    signal: options?.signal,
+    read() {
+      reader.read().then(({ value, done }) => {
+        if (done) this.push(null);
+        else this.push(value);
+      }, (error) => this.destroy(error));
+    },
+    destroy(error, callback) {
+      if (!closed) reader.cancel(error).then(() => callback(error), (e) => callback(e));
+      else callback(error);
+    },
+  });
+  reader.closed.then(() => (closed = true), () => (closed = true));
+  return readable;
+}
+
+/* Writable.toWeb(writable): a WritableStream writing to it */
+function newWritableStreamFromStreamWritable(streamWritable) {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise((resolve, reject) => {
+        if (streamWritable.write(chunk, (error) => error && reject(error))) resolve();
+        else streamWritable.once("drain", resolve);
+      });
+    },
+    close() {
+      return new Promise((resolve, reject) => {
+        finished(streamWritable, { readable: false }, (error) => (error ? reject(error) : resolve()));
+        streamWritable.end();
+      });
+    },
+    abort(reason) {
+      streamWritable.destroy(reason);
+    },
+  });
+}
+
+/* Writable.fromWeb(writableStream): a Writable writing to it */
+function newStreamWritableFromWritableStream(writableStream, options) {
+  const writer = writableStream.getWriter();
+  return new Writable({
+    objectMode: !!(options && options.objectMode),
+    decodeStrings: options?.decodeStrings,
+    highWaterMark: options?.highWaterMark,
+    signal: options?.signal,
+    write(chunk, encoding, cb) {
+      writer.write(chunk).then(() => cb(), cb);
+    },
+    final(cb) {
+      writer.close().then(() => cb(), cb);
+    },
+    destroy(error, cb) {
+      writer.abort(error).then(() => cb(error), () => cb(error));
+    },
+  });
+}
+
+/* Duplex.toWeb(duplex): its readable and writable sides as web streams */
+function newReadableWritablePairFromDuplex(duplex) {
+  return { readable: newReadableStreamFromStreamReadable(duplex), writable: newWritableStreamFromStreamWritable(duplex) };
+}
+
+/* Duplex.fromWeb({ readable, writable }): a Duplex reading one and writing the other */
+function newStreamDuplexFromReadableWritablePair(pair, options) {
+  const reader = pair.readable.getReader();
+  const writer = pair.writable.getWriter();
+  return new Duplex({
+    objectMode: !!(options && options.objectMode),
+    encoding: options?.encoding,
+    decodeStrings: options?.decodeStrings,
+    signal: options?.signal,
+    read() {
+      reader.read().then(({ value, done }) => {
+        if (done) this.push(null);
+        else this.push(value);
+      }, (error) => this.destroy(error));
+    },
+    write(chunk, encoding, cb) {
+      writer.write(chunk).then(() => cb(), cb);
+    },
+    final(cb) {
+      writer.close().then(() => cb(), cb);
+    },
+    destroy(error, cb) {
+      Promise.allSettled([reader.cancel(error), writer.abort(error)]).then(() => cb(error));
+    },
+  });
+}
+
+features.webStreamsAdapters = {
+  newReadableStreamFromStreamReadable, newStreamReadableFromReadableStream, newWritableStreamFromStreamWritable,
+  newStreamWritableFromWritableStream, newReadableWritablePairFromDuplex, newStreamDuplexFromReadableWritablePair,
+};

package/node/prelude/internal/streams/add_abort_signal.js

@@ -0,0 +1,58 @@
+import * as __internal_errors from "./errors.js";
+import * as __internal_util from "./validators.js";
+import * as __internal_streams_utils from "./utils.js";
+import * as __internal_streams_end_of_stream from "./end_of_stream.js";
+
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+  },
+} = __internal_errors;
+
+const {
+  isNodeStream,
+  isWebStream,
+  kControllerErrorFunction,
+} = __internal_streams_utils;
+
+const { eos } = __internal_streams_end_of_stream;
+const { addAbortListener } = __internal_util;
+
+// This method is inlined here for readable-stream
+// It also does not allow for signal to not exist on the stream
+// https://github.com/nodejs/node/pull/36061#discussion_r533718029
+const validateAbortSignal = (signal, name) => {
+  if (typeof signal !== 'object' ||
+       !('aborted' in signal)) {
+    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal);
+  }
+};
+
+export function addAbortSignal(signal, stream) {
+  validateAbortSignal(signal, 'signal');
+  if (!isNodeStream(stream) && !isWebStream(stream)) {
+    throw new ERR_INVALID_ARG_TYPE('stream', ['ReadableStream', 'WritableStream', 'Stream'], stream);
+  }
+  return addAbortSignalNoValidate(signal, stream);
+};
+
+export function addAbortSignalNoValidate(signal, stream) {
+  if (typeof signal !== 'object' || !('aborted' in signal)) {
+    return stream;
+  }
+  const onAbort = isNodeStream(stream) ?
+    () => {
+      stream.destroy(new AbortError(undefined, { cause: signal.reason }));
+    } :
+    () => {
+      stream[kControllerErrorFunction](new AbortError(undefined, { cause: signal.reason }));
+    };
+  if (signal.aborted) {
+    onAbort();
+  } else {
+    const disposable = addAbortListener(signal, onAbort);
+    eos(stream, disposable[Symbol.dispose]);
+  }
+  return stream;
+};

package/node/prelude/internal/streams/compose.js

@@ -0,0 +1,244 @@
+import * as __internal_streams_pipeline from "./pipeline.js";
+import * as __internal_streams_duplex from "./duplex.js";
+import * as __internal_streams_destroy from "./destroy.js";
+import * as __internal_streams_utils from "./utils.js";
+import * as __internal_errors from "./errors.js";
+import * as __internal_streams_end_of_stream from "./end_of_stream.js";
+
+const { pipeline } = __internal_streams_pipeline;
+const Duplex = __internal_streams_duplex.default;
+const { destroyer } = __internal_streams_destroy;
+const {
+  isNodeStream,
+  isReadable,
+  isWritable,
+  isWebStream,
+  isTransformStream,
+  isWritableStream,
+  isReadableStream,
+} = __internal_streams_utils;
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+    ERR_MISSING_ARGS,
+  },
+} = __internal_errors;
+const { eos } = __internal_streams_end_of_stream;
+
+export default function compose(...streams) {
+  if (streams.length === 0) {
+    throw new ERR_MISSING_ARGS('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])) {
+      // TODO(ronag): Add checks for non streams.
+      continue;
+    }
+    if (
+      n < streams.length - 1 &&
+      !(
+        isReadable(streams[n]) ||
+        isReadableStream(streams[n]) ||
+        isTransformStream(streams[n])
+      )
+    ) {
+      throw new ERR_INVALID_ARG_VALUE(
+        `streams[${n}]`,
+        orgStreams[n],
+        'must be readable',
+      );
+    }
+    if (
+      n > 0 &&
+      !(
+        isWritable(streams[n]) ||
+        isWritableStream(streams[n]) ||
+        isTransformStream(streams[n])
+      )
+    ) {
+      throw new ERR_INVALID_ARG_VALUE(
+        `streams[${n}]`,
+        orgStreams[n],
+        'must be writable',
+      );
+    }
+  }
+
+  let ondrain;
+  let onfinish;
+  let onclose;
+  let d;
+
+  function onfinished(err) {
+    const cb = onclose;
+    onclose = null;
+
+    if (cb) {
+      cb(err);
+    } else if (err) {
+      d.destroy(err);
+    } else if (!readable && !writable) {
+      d.destroy();
+    }
+  }
+
+  const head = streams[0];
+  const tail = pipeline(streams, onfinished);
+
+  const writable = !!(
+    isWritable(head) ||
+    isWritableStream(head) ||
+    isTransformStream(head)
+  );
+  const readable = !!(
+    isReadable(tail) ||
+    isReadableStream(tail) ||
+    isTransformStream(tail)
+  );
+
+  // TODO(ronag): Avoid double buffering.
+  // Implement Writable/Readable/Duplex traits.
+  // See, https://github.com/nodejs/node/pull/33515.
+  d = new Duplex({
+    // TODO (ronag): highWaterMark?
+    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', function() {
+        if (ondrain) {
+          const cb = ondrain;
+          ondrain = null;
+          cb();
+        }
+      });
+    } else if (isWebStream(head)) {
+      const writable = isTransformStream(head) ? head.writable : head;
+      const writer = writable.getWriter();
+
+      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().catch(() => {});
+          onfinish = callback;
+        } catch (err) {
+          callback(err);
+        }
+      };
+    }
+
+    const toRead = isTransformStream(tail) ? tail.readable : tail;
+
+    eos(toRead, () => {
+      if (onfinish) {
+        const cb = onfinish;
+        onfinish = null;
+        cb();
+      }
+    });
+  }
+
+  if (readable) {
+    if (isNodeStream(tail)) {
+      d._read = function() {
+        tail.resume();
+      };
+
+      tail.on('data', function(chunk) {
+        if (!d.push(chunk)) {
+          tail.pause();
+        }
+      });
+
+      tail.on('end', function() {
+        d.push(null);
+      });
+    } else if (isWebStream(tail)) {
+      const readable = isTransformStream(tail) ? tail.readable : tail;
+      const reader = readable.getReader();
+      d._read = async function() {
+        while (true) {
+          try {
+            const { value, done } = await reader.read();
+
+            if (done) {
+              d.push(null);
+              return;
+            }
+
+            if (!d.push(value)) {
+              return;
+            }
+          } catch {
+            return;
+          }
+        }
+      };
+    }
+  }
+
+  d._destroy = function(err, callback) {
+    if (!err && onclose !== null) {
+      err = new AbortError();
+    }
+
+    ondrain = null;
+    onfinish = null;
+
+    if (isNodeStream(tail)) {
+      destroyer(tail, err);
+    }
+
+    if (onclose === null) {
+      callback(err);
+    } else {
+      onclose = callback;
+    }
+  };
+
+  return d;
+};