@takeshape/streams 7.194.0

package/README.md

@@ -0,0 +1,5 @@
+# Streams
+
+## Summary
+
+A set of utility functions for working with Node.js streams v3

package/es/index.js

@@ -0,0 +1 @@
+export * from './streams';

package/es/streams.js

@@ -0,0 +1,129 @@
+import { PassThrough, Readable, Writable } from 'stream';
+import BBPromise from 'bluebird';
+import PQueue from 'p-queue';
+import isStream from 'is-stream';
+import through2 from 'through2';
+import basePump from 'pump';
+export const pump = BBPromise.promisify(basePump);
+export async function streamToPromise(stream) {
+  return new Promise((resolve, reject) => {
+    const doneEvent = isStream.writable(stream) ? 'finish' : 'end';
+    stream.on('error', reject).on(doneEvent, resolve);
+  });
+}
+export function createTransform(transform) {
+  return through2.obj(function (content, _, callback) {
+    try {
+      this.push(transform(content));
+      callback();
+    } catch (e) {
+      callback(e);
+    }
+  });
+}
+export function createAsyncTransform(transform) {
+  return through2.obj(function (content, _, callback) {
+    try {
+      transform(content).then(result => {
+        this.push(result);
+        callback();
+      }, callback);
+    } catch (e) {
+      callback(e);
+    }
+  });
+}
+export function createFilter(predicate) {
+  return through2.obj(function (content, _, callback) {
+    try {
+      if (predicate(content)) {
+        this.push(content);
+      }
+
+      callback();
+    } catch (e) {
+      callback(e);
+    }
+  });
+}
+export const createAccumulator = accumulator => through2.obj(function (item, _, cb) {
+  accumulator(item);
+  cb(null, item);
+});
+export const createAsyncWritable = (write, concurrency = 16) => {
+  const queue = new PQueue({
+    concurrency
+  });
+  return new Writable({
+    objectMode: true,
+
+    write(data, _, cb) {
+      queue.add(async () => write(data)).catch(error => this.emit('error', error));
+      cb();
+    },
+
+    final(cb) {
+      void queue.onIdle().then(() => {
+        cb();
+      });
+    }
+
+  });
+};
+export const tee = (...args) => {
+  const first = args[0];
+  const streams = Array.isArray(first) ? first : args;
+  const donePromises = streams.map(streamToPromise);
+  return new Writable({
+    objectMode: true,
+
+    write(data, _, callback) {
+      void Promise.all(streams.map(stream => stream.write(data) || BBPromise.fromCallback(cb => stream.once('drain', cb)) // if .write() => false buffer is full, start promise to wait for drain event
+      )).then(() => {
+        callback();
+      });
+    },
+
+    final(callback) {
+      streams.forEach(stream => {
+        stream.end();
+      });
+      void Promise.all(donePromises).then(() => {
+        callback();
+      });
+    }
+
+  });
+};
+export const readableFromArray = (array, options) => {
+  let index = 0;
+  return new Readable({
+    objectMode: true,
+
+    read() {
+      this.push(index < array.length ? array[index] : null);
+      index++;
+    },
+
+    ...options
+  });
+};
+export const collectStreamIntoArray = (array = [], options = {}) => new Writable({
+  objectMode: true,
+
+  writev(chunks, cb) {
+    chunks.forEach(({
+      chunk
+    }) => array.push(chunk));
+    cb(null);
+  },
+
+  ...options
+});
+export async function readStreamToBuffer(stream) {
+  const chunks = [];
+  const writeStream = new PassThrough();
+  writeStream.on('data', chunk => chunks.push(chunk));
+  await pump(stream, writeStream);
+  return Buffer.concat(chunks);
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './streams';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _streams = require("./streams");
+
+Object.keys(_streams).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _streams[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _streams[key];
+    }
+  });
+});

package/lib/streams.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="styled-components" />
+/// <reference types="webpack-env" />
+import { Readable, ReadableOptions, Transform, Writable, WritableOptions } from 'stream';
+declare type Stream = NodeJS.ReadableStream | NodeJS.WritableStream;
+export interface Pump {
+    (streams: Stream[]): Promise<any>;
+    (...streams: Stream[]): Promise<any>;
+}
+export declare const pump: Pump;
+export declare function streamToPromise(stream: NodeJS.ReadableStream | NodeJS.WritableStream): Promise<void>;
+export declare function createTransform(transform: (data: any) => any): Transform;
+export declare function createAsyncTransform(transform: (data: any) => Promise<any>): Transform;
+export declare function createFilter(predicate: (data: any) => boolean): Transform;
+export declare const createAccumulator: (accumulator: (data: any) => void) => Transform;
+export declare const createAsyncWritable: (write: (data: any) => Promise<void>, concurrency?: number) => Writable;
+export declare const tee: (...args: NodeJS.WritableStream[] | [NodeJS.WritableStream[]]) => Writable;
+export declare const readableFromArray: (array: any[], options?: Partial<ReadableOptions> | undefined) => Readable;
+export declare const collectStreamIntoArray: (array?: any[], options?: Partial<WritableOptions>) => Writable;
+export declare function readStreamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer>;
+export {};
+//# sourceMappingURL=streams.d.ts.map

package/lib/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../src/streams.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAc,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAC,MAAM,QAAQ,CAAC;AAOpG,aAAK,MAAM,GAAG,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;AAE5D,MAAM,WAAW,IAAI;IACnB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACtC;AAED,eAAO,MAAM,IAAI,EAAE,IAAoC,CAAC;AAExD,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAK1G;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,SAAS,CASxE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAWtF;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,GAAG,SAAS,CAWzE;AAED,eAAO,MAAM,iBAAiB,uBAAwB,GAAG,KAAK,IAAI,KAAG,SAIjE,CAAC;AAEL,eAAO,MAAM,mBAAmB,iBAAkB,GAAG,KAAK,QAAQ,IAAI,CAAC,2BAAqB,QAc3F,CAAC;AAEF,eAAO,MAAM,GAAG,YAAa,OAAO,cAAc,EAAE,GAAG,CAAC,OAAO,cAAc,EAAE,CAAC,KAAG,QAyBlF,CAAC;AAEF,eAAO,MAAM,iBAAiB,UAAW,GAAG,EAAE,qDAAuC,QAUpF,CAAC;AAEF,eAAO,MAAM,sBAAsB,WAAW,GAAG,EAAE,YAAgB,QAAQ,eAAe,CAAC,KAAQ,QAQ/F,CAAC;AAEL,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAMvF"}

package/lib/streams.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.streamToPromise = streamToPromise;
+exports.createTransform = createTransform;
+exports.createAsyncTransform = createAsyncTransform;
+exports.createFilter = createFilter;
+exports.readStreamToBuffer = readStreamToBuffer;
+exports.collectStreamIntoArray = exports.readableFromArray = exports.tee = exports.createAsyncWritable = exports.createAccumulator = exports.pump = void 0;
+
+var _stream = require("stream");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _pQueue = _interopRequireDefault(require("p-queue"));
+
+var _isStream = _interopRequireDefault(require("is-stream"));
+
+var _through = _interopRequireDefault(require("through2"));
+
+var _pump = _interopRequireDefault(require("pump"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pump = _bluebird.default.promisify(_pump.default);
+
+exports.pump = pump;
+
+async function streamToPromise(stream) {
+  return new Promise((resolve, reject) => {
+    const doneEvent = _isStream.default.writable(stream) ? 'finish' : 'end';
+    stream.on('error', reject).on(doneEvent, resolve);
+  });
+}
+
+function createTransform(transform) {
+  return _through.default.obj(function (content, _, callback) {
+    try {
+      this.push(transform(content));
+      callback();
+    } catch (e) {
+      callback(e);
+    }
+  });
+}
+
+function createAsyncTransform(transform) {
+  return _through.default.obj(function (content, _, callback) {
+    try {
+      transform(content).then(result => {
+        this.push(result);
+        callback();
+      }, callback);
+    } catch (e) {
+      callback(e);
+    }
+  });
+}
+
+function createFilter(predicate) {
+  return _through.default.obj(function (content, _, callback) {
+    try {
+      if (predicate(content)) {
+        this.push(content);
+      }
+
+      callback();
+    } catch (e) {
+      callback(e);
+    }
+  });
+}
+
+const createAccumulator = accumulator => _through.default.obj(function (item, _, cb) {
+  accumulator(item);
+  cb(null, item);
+});
+
+exports.createAccumulator = createAccumulator;
+
+const createAsyncWritable = (write, concurrency = 16) => {
+  const queue = new _pQueue.default({
+    concurrency
+  });
+  return new _stream.Writable({
+    objectMode: true,
+
+    write(data, _, cb) {
+      queue.add(async () => write(data)).catch(error => this.emit('error', error));
+      cb();
+    },
+
+    final(cb) {
+      void queue.onIdle().then(() => {
+        cb();
+      });
+    }
+
+  });
+};
+
+exports.createAsyncWritable = createAsyncWritable;
+
+const tee = (...args) => {
+  const first = args[0];
+  const streams = Array.isArray(first) ? first : args;
+  const donePromises = streams.map(streamToPromise);
+  return new _stream.Writable({
+    objectMode: true,
+
+    write(data, _, callback) {
+      void Promise.all(streams.map(stream => stream.write(data) || _bluebird.default.fromCallback(cb => stream.once('drain', cb)) // if .write() => false buffer is full, start promise to wait for drain event
+      )).then(() => {
+        callback();
+      });
+    },
+
+    final(callback) {
+      streams.forEach(stream => {
+        stream.end();
+      });
+      void Promise.all(donePromises).then(() => {
+        callback();
+      });
+    }
+
+  });
+};
+
+exports.tee = tee;
+
+const readableFromArray = (array, options) => {
+  let index = 0;
+  return new _stream.Readable({
+    objectMode: true,
+
+    read() {
+      this.push(index < array.length ? array[index] : null);
+      index++;
+    },
+
+    ...options
+  });
+};
+
+exports.readableFromArray = readableFromArray;
+
+const collectStreamIntoArray = (array = [], options = {}) => new _stream.Writable({
+  objectMode: true,
+
+  writev(chunks, cb) {
+    chunks.forEach(({
+      chunk
+    }) => array.push(chunk));
+    cb(null);
+  },
+
+  ...options
+});
+
+exports.collectStreamIntoArray = collectStreamIntoArray;
+
+async function readStreamToBuffer(stream) {
+  const chunks = [];
+  const writeStream = new _stream.PassThrough();
+  writeStream.on('data', chunk => chunks.push(chunk));
+  await pump(stream, writeStream);
+  return Buffer.concat(chunks);
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@takeshape/streams",
+  "version": "7.194.0",
+  "description": "Stream helpers",
+  "homepage": "https://www.takeshape.io",
+  "repository": {
+    "type": "git",
+    "url": "github.com:takeshape/takeshape.git"
+  },
+  "author": "asprouse",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=12"
+  },
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "es"
+  ],
+  "dependencies": {
+    "bluebird": "^3.7.2",
+    "is-stream": "^2.0.0",
+    "p-queue": "^6.4.0",
+    "pump": "^3.0.0",
+    "through2": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/bluebird": "^3.5.32",
+    "@types/pump": "^1.1.0",
+    "@types/through2": "^2.0.36"
+  },
+  "scripts": {
+    "lint": "eslint . --ext .js,.ts",
+    "lint:code:ci": "eslint . --ext .js,.ts --format junit -o \"${HOME}/test-results/${npm_package_name#*\\/}/eslint-results.xml\"",
+    "test": "jest",
+    "test-changed": "pnpm run test -- --changedSince=master",
+    "test:ci": "JEST_JUNIT_OUTPUT_DIR=\"${HOME}/test-results/${npm_package_name#*\\/}\" JEST_JUNIT_OUTPUT_NAME=jest-results.xml jest --ci --reporters=default --reporters=jest-junit",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf build lib es *.tsbuildinfo",
+    "build": "pnpm clean && pnpm build:types && pnpm build:js && pnpm build:es && pnpm build:copy",
+    "build:types": "tsc --emitDeclarationOnly --project tsconfig.build.json",
+    "build:js": "cross-env BABEL_MODULES=commonjs babel src --out-dir lib --extensions \".js,.ts\" --ignore '**/__tests__'",
+    "build:es": "cross-env BABEL_MODULES=es babel src --out-dir es --extensions \".js,.ts\" --ignore '**/__tests__'",
+    "build:copy": "cp -rf build/src/* lib/",
+    "will-it-blend": "pnpm typecheck && pnpm lint -- --quiet && pnpm test -- --silent --coverage false"
+  }
+}