Upload Kmake

lib/stream/consumers.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const {
+  JSONParse,
+} = primordials;
+
+const {
+  TextDecoder,
+} = require('internal/encoding');
+
+const {
+  Blob,
+} = require('internal/blob');
+
+const {
+  Buffer,
+} = require('buffer');
+
+/**
+ * @typedef {import('../internal/webstreams/readablestream').ReadableStream
+ * } ReadableStream
+ * @typedef {import('../internal/streams/readable')} Readable
+ */
+
+/**
+ * @param {AsyncIterable|ReadableStream|Readable} stream
+ * @returns {Promise<Blob>}
+ */
+async function blob(stream) {
+  const chunks = [];
+  for await (const chunk of stream)
+    chunks.push(chunk);
+  return new Blob(chunks);
+}
+
+/**
+ * @param {AsyncIterable|ReadableStream|Readable} stream
+ * @returns {Promise<ArrayBuffer>}
+ */
+async function arrayBuffer(stream) {
+  const ret = await blob(stream);
+  return ret.arrayBuffer();
+}
+
+/**
+ * @param {AsyncIterable|ReadableStream|Readable} stream
+ * @returns {Promise<Buffer>}
+ */
+async function buffer(stream) {
+  return Buffer.from(await arrayBuffer(stream));
+}
+
+/**
+ * @param {AsyncIterable|ReadableStream|Readable} stream
+ * @returns {Promise<string>}
+ */
+async function text(stream) {
+  const dec = new TextDecoder();
+  let str = '';
+  for await (const chunk of stream) {
+    if (typeof chunk === 'string')
+      str += chunk;
+    else
+      str += dec.decode(chunk, { stream: true });
+  }
+  // Flush the streaming TextDecoder so that any pending
+  // incomplete multibyte characters are handled.
+  str += dec.decode(undefined, { stream: false });
+  return str;
+}
+
+/**
+ * @param {AsyncIterable|ReadableStream|Readable} stream
+ * @returns {Promise<any>}
+ */
+async function json(stream) {
+  const str = await text(stream);
+  return JSONParse(str);
+}
+
+module.exports = {
+  arrayBuffer,
+  blob,
+  buffer,
+  text,
+  json,
+};

lib/stream/promises.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const {
+  ArrayPrototypePop,
+  Promise,
+} = primordials;
+
+const {
+  isIterable,
+  isNodeStream,
+  isWebStream,
+} = require('internal/streams/utils');
+
+const { pipelineImpl: pl } = require('internal/streams/pipeline');
+const { finished } = require('internal/streams/end-of-stream');
+
+require('stream');
+
+function pipeline(...streams) {
+  return new Promise((resolve, reject) => {
+    let signal;
+    let end;
+    const lastArg = streams[streams.length - 1];
+    if (lastArg && typeof lastArg === 'object' &&
+        !isNodeStream(lastArg) && !isIterable(lastArg) && !isWebStream(lastArg)) {
+      const options = ArrayPrototypePop(streams);
+      signal = options.signal;
+      end = options.end;
+    }
+
+    pl(streams, (err, value) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(value);
+      }
+    }, { signal, end });
+  });
+}
+
+module.exports = {
+  finished,
+  pipeline,
+};

lib/stream/web.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const {
+  TransformStream,
+  TransformStreamDefaultController,
+} = require('internal/webstreams/transformstream');
+
+const {
+  WritableStream,
+  WritableStreamDefaultController,
+  WritableStreamDefaultWriter,
+} = require('internal/webstreams/writablestream');
+
+const {
+  ReadableStream,
+  ReadableStreamDefaultReader,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableByteStreamController,
+  ReadableStreamDefaultController,
+} = require('internal/webstreams/readablestream');
+
+const {
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+} = require('internal/webstreams/queuingstrategies');
+
+const {
+  TextEncoderStream,
+  TextDecoderStream,
+} = require('internal/webstreams/encoding');
+
+const {
+  CompressionStream,
+  DecompressionStream,
+} = require('internal/webstreams/compression');
+
+module.exports = {
+  ReadableStream,
+  ReadableStreamDefaultReader,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableByteStreamController,
+  ReadableStreamDefaultController,
+  TransformStream,
+  TransformStreamDefaultController,
+  WritableStream,
+  WritableStreamDefaultWriter,
+  WritableStreamDefaultController,
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  TextEncoderStream,
+  TextDecoderStream,
+  CompressionStream,
+  DecompressionStream,
+};