@volter/tabnode 0.2.14-volter.88

package/src/node-lib/internal/stream_base_commons.js

@@ -0,0 +1,280 @@
+'use strict';
+
+const {
+  Array,
+  Symbol,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const { FastBuffer } = require('internal/buffer');
+const {
+  WriteWrap,
+  kReadBytesOrError,
+  kArrayBufferOffset,
+  kBytesWritten,
+  kLastWriteWasAsync,
+  streamBaseState,
+} = internalBinding('stream_wrap');
+const { UV_EOF } = internalBinding('uv');
+const {
+  ErrnoException,
+} = require('internal/errors');
+const { owner_symbol } = require('internal/async_hooks').symbols;
+const {
+  kTimeout,
+  setUnrefTimeout,
+  getTimerDuration,
+} = require('internal/timers');
+const { isUint8Array } = require('internal/util/types');
+const { clearTimeout } = require('timers');
+const { validateFunction } = require('internal/validators');
+
+const kMaybeDestroy = Symbol('kMaybeDestroy');
+const kUpdateTimer = Symbol('kUpdateTimer');
+const kAfterAsyncWrite = Symbol('kAfterAsyncWrite');
+const kHandle = Symbol('kHandle');
+const kBoundSession = Symbol('kBoundSession');
+const kSession = Symbol('kSession');
+
+let debug = require('internal/util/debuglog').debuglog('stream', (fn) => {
+  debug = fn;
+});
+const kBuffer = Symbol('kBuffer');
+const kBufferGen = Symbol('kBufferGen');
+const kBufferCb = Symbol('kBufferCb');
+
+function handleWriteReq(req, data, encoding) {
+  const { handle } = req;
+
+  switch (encoding) {
+    case 'buffer':
+    {
+      const ret = handle.writeBuffer(req, data);
+      if (streamBaseState[kLastWriteWasAsync])
+        req.buffer = data;
+      return ret;
+    }
+    case 'latin1':
+    case 'binary':
+      return handle.writeLatin1String(req, data);
+    case 'utf8':
+    case 'utf-8':
+      return handle.writeUtf8String(req, data);
+    case 'ascii':
+      return handle.writeAsciiString(req, data);
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return handle.writeUcs2String(req, data);
+    default:
+    {
+      const buffer = Buffer.from(data, encoding);
+      const ret = handle.writeBuffer(req, buffer);
+      if (streamBaseState[kLastWriteWasAsync])
+        req.buffer = buffer;
+      return ret;
+    }
+  }
+}
+
+function onWriteComplete(status) {
+  debug('onWriteComplete', status, this.error);
+
+  const stream = this.handle[owner_symbol];
+
+  if (status < 0) {
+    const error = new ErrnoException(status, 'write', this.error);
+    if (typeof this.callback === 'function') {
+      return this.callback(error);
+    }
+
+    return stream.destroy(error);
+  }
+
+  if (stream.destroyed) {
+    if (typeof this.callback === 'function')
+      this.callback(null);
+    return;
+  }
+
+  stream[kUpdateTimer]();
+  stream[kAfterAsyncWrite](this);
+
+  if (typeof this.callback === 'function')
+    this.callback(null);
+}
+
+function createWriteWrap(handle, callback) {
+  const req = new WriteWrap();
+
+  req.handle = handle;
+  req.oncomplete = onWriteComplete;
+  req.async = false;
+  req.bytes = 0;
+  req.buffer = null;
+  req.callback = callback;
+
+  return req;
+}
+
+function writevGeneric(self, data, cb) {
+  const req = createWriteWrap(self[kHandle], cb);
+  const allBuffers = data.allBuffers;
+  let chunks;
+  if (allBuffers) {
+    chunks = data;
+    for (let i = 0; i < data.length; i++)
+      data[i] = data[i].chunk;
+  } else {
+    chunks = new Array(data.length << 1);
+    for (let i = 0; i < data.length; i++) {
+      const entry = data[i];
+      chunks[i * 2] = entry.chunk;
+      chunks[i * 2 + 1] = entry.encoding;
+    }
+  }
+  const err = req.handle.writev(req, chunks, allBuffers);
+
+  // Retain chunks
+  if (err === 0) req._chunks = chunks;
+
+  afterWriteDispatched(req, err, cb);
+  return req;
+}
+
+function writeGeneric(self, data, encoding, cb) {
+  const req = createWriteWrap(self[kHandle], cb);
+  const err = handleWriteReq(req, data, encoding);
+
+  afterWriteDispatched(req, err, cb);
+  return req;
+}
+
+function afterWriteDispatched(req, err, cb) {
+  req.bytes = streamBaseState[kBytesWritten];
+  req.async = !!streamBaseState[kLastWriteWasAsync];
+
+  if (err !== 0)
+    return cb(new ErrnoException(err, 'write', req.error));
+
+  if (!req.async && typeof req.callback === 'function') {
+    req.callback();
+  }
+}
+
+function onStreamRead(arrayBuffer) {
+  const nread = streamBaseState[kReadBytesOrError];
+
+  const handle = this;
+  const stream = this[owner_symbol];
+
+  stream[kUpdateTimer]();
+
+  if (nread > 0 && !stream.destroyed) {
+    let ret;
+    let result;
+    const userBuf = stream[kBuffer];
+    if (userBuf) {
+      result = (stream[kBufferCb](nread, userBuf) !== false);
+      const bufGen = stream[kBufferGen];
+      if (bufGen !== null) {
+        const nextBuf = bufGen();
+        if (isUint8Array(nextBuf))
+          stream[kBuffer] = ret = nextBuf;
+      }
+    } else {
+      const offset = streamBaseState[kArrayBufferOffset];
+      const buf = new FastBuffer(arrayBuffer, offset, nread);
+      result = stream.push(buf);
+    }
+    if (!result) {
+      handle.reading = false;
+      if (!stream.destroyed) {
+        const err = handle.readStop();
+        if (err)
+          stream.destroy(new ErrnoException(err, 'read'));
+      }
+    }
+
+    return ret;
+  }
+
+  if (nread === 0) {
+    return;
+  }
+
+  // After seeing EOF, most streams will be closed permanently,
+  // and will not deliver any more read events after this point.
+  // (equivalently, it should have called readStop on itself already).
+  // Some streams may be reset and explicitly started again with a call
+  // to readStart, such as TTY.
+
+  if (nread !== UV_EOF) {
+    // CallJSOnreadMethod expects the return value to be a buffer.
+    // Ref: https://github.com/nodejs/node/pull/34375
+    stream.destroy(new ErrnoException(nread, 'read'));
+    return;
+  }
+
+  // Defer this until we actually emit end
+  if (stream._readableState.endEmitted) {
+    if (stream[kMaybeDestroy])
+      stream[kMaybeDestroy]();
+  } else {
+    if (stream[kMaybeDestroy])
+      stream.on('end', stream[kMaybeDestroy]);
+
+    // Push a null to signal the end of data.
+    // Do it before `maybeDestroy` for correct order of events:
+    // `end` -> `close`
+    stream.push(null);
+    stream.read(0);
+  }
+}
+
+function setStreamTimeout(msecs, callback) {
+  if (this.destroyed)
+    return this;
+
+  this.timeout = msecs;
+
+  // Type checking identical to timers.enroll()
+  msecs = getTimerDuration(msecs, 'msecs');
+
+  // Attempt to clear an existing timer in both cases -
+  //  even if it will be rescheduled we don't want to leak an existing timer.
+  clearTimeout(this[kTimeout]);
+
+  if (msecs === 0) {
+    if (callback !== undefined) {
+      validateFunction(callback, 'callback');
+      this.removeListener('timeout', callback);
+    }
+  } else {
+    this[kTimeout] = setUnrefTimeout(this._onTimeout.bind(this), msecs);
+    if (this[kSession]) this[kSession][kUpdateTimer]();
+    if (this[kBoundSession]) this[kBoundSession][kUpdateTimer]();
+
+    if (callback !== undefined) {
+      validateFunction(callback, 'callback');
+      this.once('timeout', callback);
+    }
+  }
+  return this;
+}
+
+module.exports = {
+  writevGeneric,
+  writeGeneric,
+  onStreamRead,
+  kAfterAsyncWrite,
+  kMaybeDestroy,
+  kUpdateTimer,
+  kHandle,
+  kSession,
+  setStreamTimeout,
+  kBuffer,
+  kBufferCb,
+  kBufferGen,
+};

package/src/node-lib/internal/streams/add-abort-signal.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const {
+  SymbolDispose,
+} = require('internal/util');
+
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+  },
+} = require('internal/errors');
+
+const {
+  isNodeStream,
+  isWebStream,
+  kControllerErrorFunction,
+} = require('internal/streams/utils');
+
+const eos = require('internal/streams/end-of-stream');
+let addAbortListener;
+
+// 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);
+  }
+};
+
+module.exports.addAbortSignal = function addAbortSignal(signal, stream) {
+  validateAbortSignal(signal, 'signal');
+  if (!isNodeStream(stream) && !isWebStream(stream)) {
+    throw new ERR_INVALID_ARG_TYPE('stream', ['ReadableStream', 'WritableStream', 'Stream'], stream);
+  }
+  return module.exports.addAbortSignalNoValidate(signal, stream);
+};
+
+module.exports.addAbortSignalNoValidate = function(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 {
+    addAbortListener ??= require('internal/events/abort_listener').addAbortListener;
+    const disposable = addAbortListener(signal, onAbort);
+    eos(stream, disposable[SymbolDispose]);
+  }
+  return stream;
+};

package/src/node-lib/internal/streams/compose.js

@@ -0,0 +1,257 @@
+'use strict';
+
+const {
+  ArrayPrototypeSlice,
+} = primordials;
+
+const { pipeline } = require('internal/streams/pipeline');
+const Duplex = require('internal/streams/duplex');
+const { destroyer } = require('internal/streams/destroy');
+const {
+  isNodeStream,
+  isReadable,
+  isWritable,
+  isWebStream,
+  isTransformStream,
+  isWritableStream,
+  isReadableStream,
+} = require('internal/streams/utils');
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+    ERR_MISSING_ARGS,
+  },
+} = require('internal/errors');
+const eos = require('internal/streams/end-of-stream');
+
+module.exports = function compose(...streams) {
+  if (streams.length === 0) {
+    throw new ERR_MISSING_ARGS('streams');
+  }
+
+  if (streams.length === 1) {
+    return Duplex.from(streams[0]);
+  }
+
+  const orgStreams = ArrayPrototypeSlice(streams);
+
+  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 onreadable;
+  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)) {
+      tail.on('readable', function() {
+        if (onreadable) {
+          const cb = onreadable;
+          onreadable = null;
+          cb();
+        }
+      });
+
+      tail.on('end', function() {
+        d.push(null);
+      });
+
+      d._read = function() {
+        while (true) {
+          const buf = tail.read();
+          if (buf === null) {
+            onreadable = d._read;
+            return;
+          }
+
+          if (!d.push(buf)) {
+            return;
+          }
+        }
+      };
+    } 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 (!d.push(value)) {
+              return;
+            }
+
+            if (done) {
+              d.push(null);
+              return;
+            }
+          } catch {
+            return;
+          }
+        }
+      };
+    }
+  }
+
+  d._destroy = function(err, callback) {
+    if (!err && onclose !== null) {
+      err = new AbortError();
+    }
+
+    onreadable = null;
+    ondrain = null;
+    onfinish = null;
+
+    if (isNodeStream(tail)) {
+      destroyer(tail, err);
+    }
+
+    if (onclose === null) {
+      callback(err);
+    } else {
+      onclose = callback;
+    }
+  };
+
+  return d;
+};