writable stream that concatenates strings or binary data and calls a callback with the result. 

writable stream that concatenates strings or binary data and calls a callback with the result

mafintosh

maxogden

concat-stream

var Writable = require('readable-stream').Writable

  var U8 = require('typedarray').Uint8Array

  if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)

    encoding =  String(encoding).toLowerCase()

    if (encoding === 'u8' || encoding === 'uint8') {

  Writable.call(this, { objectMode: true })

  this.shouldInferEncoding = shouldInferEncoding

  if (cb) this.on('finish', function () { cb(this.getBody()) })

ConcatStream.prototype._write = function(chunk, enc, next) {

ConcatStream.prototype.inferEncoding = function (buff) {

  var firstBuffer = buff === undefined ? this.body[0] : buff;

  if (Buffer.isBuffer(firstBuffer)) return 'buffer'

  if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array'

  if (Array.isArray(firstBuffer)) return 'array'

  if (typeof firstBuffer === 'string') return 'string'

  if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object'

ConcatStream.prototype.getBody = function () {

  if (!this.encoding && this.body.length === 0) return []

  if (this.shouldInferEncoding) this.encoding = this.inferEncoding()

  if (this.encoding === 'array') return arrayConcat(this.body)

  if (this.encoding === 'string') return stringConcat(this.body)

  if (this.encoding === 'buffer') return bufferConcat(this.body)

  if (this.encoding === 'uint8array') return u8Concat(this.body)

var isArray = Array.isArray || function (arr) {

  return Object.prototype.toString.call(arr) == '[object Array]'

  return /Array\]$/.test(Object.prototype.toString.call(arr))

  return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function')

  for (var i = 0; i < parts.length; i++) {

      strings.push(new Buffer(String(p)))

      strings.push(bufferFrom(String(p)))

  for (var i = 0, offset = 0; i < parts.length; i++) {

    for (var j = 0; j < part.length; j++) {

  "description": "writable stream that concatenates strings or binary data and calls a callback with the result",

  "author": "Max Ogden <max@maxogden.com>",

    "url": "http://github.com/maxogden/concat-stream.git"

    "url": "http://github.com/maxogden/concat-stream/issues"

    "test": "tape test/*.js test/server/*.js"

Writable stream that concatenates all the data from a stream and calls a callback with the result. Use this when you want to collect all the data from a stream into a single buffer.

[![Build Status](https://travis-ci.org/maxogden/concat-stream.svg?branch=master)](https://travis-ci.org/maxogden/concat-stream)

[![NPM](https://nodei.co/npm/concat-stream.png)](https://nodei.co/npm/concat-stream/)

Streams emit many buffers. If you want to collect all of the buffers, and when the stream ends concatenate all of the buffers together and receive a single buffer then this is the module for you.

Only use this if you know you can fit all of the output of your stream into a single Buffer (e.g. in RAM).

There are also `objectMode` streams that emit things other than Buffers, and you can concatenate these too. See below for details.

`concat-stream` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.

var readStream = fs.createReadStream('cat.png')

  // imageBuffer is all of `cat.png` as a node.js Buffer

  // handle your error appropriately here, e.g.:

  console.error(err) // print the error to STDERR

  process.exit(1) // exit program with non-zero exit code

// data will be [1,2,3,4,5,6] in the above callback

Return a `writable` stream that will fire `cb(data)` with all of the data that

was written to the stream. Data can be written to `writable` as strings,

Buffers, arrays of byte integers, and Uint8Arrays. 

By default `concat-stream` will give you back the same data type as the type of the first buffer written to the stream. Use `opts.encoding` to set what format `data` should be returned as, e.g. if you if you don't want to rely on the built-in type checking or for some other reason.

* `array` - get an array of byte integers

* `uint8array`, `u8`, `uint8` - get back a Uint8Array

If you don't specify an encoding, and the types can't be inferred (e.g. you write things that aren't in the list above), it will try to convert concat them into a `Buffer`.

If nothing is written to `writable` then `data` will be an empty array `[]`.

`concat-stream` does not handle errors for you, so you must handle errors on whatever streams you pipe into `concat-stream`. This is a general rule when programming with node.js streams: always handle errors on each and every stream. Since `concat-stream` is not itself a stream it does not emit errors.

We recommend using [`end-of-stream`](https://npmjs.org/end-of-stream) or [`pump`](https://npmjs.org/pump) for writing error tolerant stream code.

		var Writable = require('readable-stream').Writable
		var inherits = require('inherits')
		var bufferFrom = require('buffer-from')

		@@ -90,5 +91,5 @@ if (typeof Uint8Array === 'undefined') {
		} else if (isBufferish(p)) {
		strings.push(new Buffer(p))
		strings.push(bufferFrom(p))
		} else {
		strings.push(new Buffer(String(p)))
		strings.push(bufferFrom(String(p)))
		}
		@@ -112,5 +113,5 @@ }
		} else if (isBufferish(p)) {
		bufs.push(new Buffer(p))
		bufs.push(bufferFrom(p))
		} else {
		bufs.push(new Buffer(String(p)))
		bufs.push(bufferFrom(String(p)))
		}
		@@ -133,3 +134,3 @@ }
		if (typeof parts[i] === 'string') {
		parts[i] = new Buffer(parts[i])
		parts[i] = bufferFrom(parts[i])
		}
		@@ -136,0 +137,0 @@ len += parts[i].length

		{
		"name": "concat-stream",
		"version": "1.6.1",
		"version": "1.6.2",
		"description": "writable stream that concatenates strings or binary data and calls a callback with the result",
		@@ -31,5 +31,6 @@ "tags": [
		"dependencies": {
		"buffer-from": "^1.0.0",
		"inherits": "^2.0.3",
		"typedarray": "^0.0.6",
		"readable-stream": "^2.2.2"
		"readable-stream": "^2.2.2",
		"typedarray": "^0.0.6"
		},
		@@ -36,0 +37,0 @@ "devDependencies": {

		@@ -65,3 +65,3 @@ # concat-stream
		write.write('!')
		write.end(Buffer('!!1'))
		write.end(Buffer.from('!!1'))
		```
		@@ -68,0 +68,0 @@

Improved metrics

Worsened metrics

Dependency changes