through2-asyncmap

An async-only version of through2-map

1
2var map = require("through2-asyncmap")
3
4var truncate = map(function (chunk, callback) {
5  setImmediate(function () {
6    callback(null, chunk.slice(0, 10))
7  })
8})
9
10// vs. with through2:
11var truncate = through2(function (chunk, encoding, callback) {
12  setImmediate(function () {
13    this.push(chunk.slice(0, 10))
14    return callback()
15  })
16})
17
18// Then use your map:
19source.pipe(truncate).pipe(sink)
20
21// Additionally accepts `wantStrings` argument to convert buffers into strings
22var stripTags = map({wantStrings: true}, function (str, next) {
23  // OMG don't actually use this
24  setImmediate(function () {next(null, str.replace(/<.*?>/g, ""))}
25})
26
27// Works like `Array.prototype.map` meaning you can specify a function that
28// takes up to two* arguments: fn(chunk, index)
29var spaceout = map({wantStrings: true}, function (chunk, index, callback) {
30  setImmediate(functio () {
31    callback(null, (index % 2 == 0) ? chunk + "\n\n" : chunk)
32  })
33})
34
35// vs. with through2:
36var spaceout = through2(function (chunk, encoding, callback) {
37  if (this.index == undefined) {
38    this.index = 0
39  }
40  setImmediate(function () {
41    var buf = (this.index++ % 2 == 0) ? Buffer.concat(chunk, new Buffer("\n\n")) : chunk
42    this.push(buf)
43    return callback()
44  })
45})
46

*Differences from Array.prototype.map:

• Cannot insert null elements into the stream without aborting.
• No third array callback argument. That would require realizing the entire stream, which is generally counter-productive to stream operations.
• Array.prototype.map doesn't modify the source Array, which is somewhat nonsensical when applied to streams.

API

require("through2-asyncmap")([options,] fn)

Create a stream.Transform instance that will call fn(chunk, [index,] callback) on each stream segment.

callback is expected to return two arguments: callback(error, replacementChunk) and will replace the provided chunk with replacementChunk

If error is true, it will emit that error on the stream.

var Tx = require("through2-asyncmap").ctor([options,] fn)

Create a reusable stream.Transform TYPE that can be called via new Tx or Tx() to create an instance.

require("through2-asyncmap").obj([options,] fn)

Create a through2-asyncmap instance that defaults to objectMode: true.

require("through2-asyncmap").objCtor([options,] fn)

Just like ctor, but with objectMode: true defaulting to true.

Options

• wantStrings: Automatically call chunk.toString() for the super lazy.
• all other through2 options

LICENSE

MIT