funstream/CHANGELOG.md

Funstream gives you iteratorish methods on your streams.

# 4.2.0

* Add `stream.fun.writable()` to get a promisey way of asserting a stream is ready for data
* Add `stream.toJson()` which takes a series of objects and emits them as a JSON stringified array.
* Add `stream.toNdjson()` which takes a series of objects and emits them as new-line delimited JSON.
* Add `stream.fromJson()` which is the same as `stream.json()`
* Add `stream.fromNdjson()` which is the same as `stream.ndjson()`
* Fixed `fun.finished` and `fun.ended`, which previously would refuse to run.

# 4.1.1

* Fix `stream.lines()` (and in turn `stream.ndjson()`) to support CRLF terminated lines.
* Fix a bug where if multiple chunks were emitted without newlines end them and then the stream closed, they would be emitted with newlines injected between them (but as a single "line").

# 4.1.0

* Add support for `stream.lines()` to split the stream on lines and emit one line at a time.
* Add support for `stream.ndjson()` to parse the stream as newline delimited JSON and emit one object at a time.

# 4.0.0

* Our recently introduced closed/finished/ended methods stomped on some stream implementation's use of them
  as properties. Change the API to put them in a safer place.

# 3.2.0

* Fix crash when a stream object's pipe method was readonly. (For example, with minipass.)
* Improve stream ducktyping to support minipass based streams.
* Fix error in reduceTo family of functions when promise returning reductions, where we were running
  all the reductions in parallel rather than waiting for them to complete individually.
* Guard against crashes when promises are rejected with null/undefined values.
* Improve error messaging on invalid arguments.
* Add support for `fun(123n)` working like `fun(123)`

# 3.1.0

* Fix bug where, when mixing in promise-streams (when upgrading a regular
  stream to a funstream), the provision of ended versus finished methods was
  swapped.
* Add support for async generators (thank you Node 10!!)
* Add `stream.mutate()`, which acts like `stream.map()` but doesn't do anything with the return value of the
  callback. `stream.mutate(_ => { ... })` is equiv of `stream.map(_ => { ...; return _})`
* Add `stream.collect()` as an alias for `stream.list()`
* Add `fun.with(cb)` constructor that passes the callback a stream that's ended when the promise
  returned by the callback is resolved. This makes manual writing to a stream far more convenient.
* Add `stream.json()` convenience method, equiv of `stream.concat().then(_ => JSON.parse(_))`
* Fix error propagation in `stream.reduce()`.
* Guard iterator/thenable type checking when given symbols. This would
  caused a crash if you constructed a funstream from a Symbol.  Weird, but
  shouldn't crash.

# 3.0.0

I'm doing a 3.0.0 to backout the feature added in 2.3.0 where Readable
streams were thenable.

This turns out to be very unfun.  Specifically it means that async functions
can't return fun-streams, something I very much want to do.

Because it's still sometimes nice to get a promise in these circumstances,
you can ask for one with a few ways:

`.finished()` is available on writable and duplex streams and resolves when the stream
emits `finish`.  Is is a no-op on writable streams, as they already are a
promise that resolves when the stream emits `finish`.

`.ended()` is available on readable and duplex streams and resolves when the
stream emits `end`.

`.closed()` is available on writable and duplex streams and resolves when the
stream emits `close`.  Note that not all streams emit `close` and if this is
one of those then the promise will never resolve.

# 2.6.1

* Revert: Patch to preserve funopts confuses itself.

# 2.6.0

* Feature: Lazily convert promises to streams.  If you funify a promise and
  use as a promise, no stream infrastructure will be created.  (This is
  important for promise-returning fun functions.)
* Feature: Funify writable promise-streams as if they were promises.  This
  means that if they a value that value will be preserved, and that means
  that `fun().reduce().forEach()` will work, for instance.
* Feature: `forEach` on array-streams now has a synchronous fast-path
  implementation, where we ignore the stream entirely and just loop over the
  in memory array.
* Tests: Many, MANY, were added. A number of files are at 100% coverage now.
* Fix: Async reduce streams previously would finish early and given incomplete results.
* Fix: The async reduceTo impelementation previously did not work at all.
* Fix: Reduce streams weren't copying along options from their parents.
  This only matters if you chain off of them as a fun-stream and not a
  promise.
* Fix: `.concat()` will now work with streams w/ elements that can't be added to strings. (eg, Symbols)
* Fix: If you pass an existing readable fun-stream to fun we used to just
  return it.  We still do that if you provide the same options as the
  fun-stream, if you didn't we pipe into a new one with your options.
* Fix: `.grab()` now returns a promise-stream.
* Fix: Sugar like `.concat()` would previously fail if you'd explictly set the mode to `.async()`. This is now fixed.

# 2.5.1

* Readme improvements

# 2.5.0

* Strings can now be fun too.
* Also Buffers.
* Improve stream duck typing
* Really, truely, all things are _also_ promises now.

# 2.4.0

* Add pipe-chain bundling in the form of `fun(stream => stream.pipe.chain)`.

# 2.3.2

* Fix async flatMap

# 2.3.1

* Eep actually include flat-map-stream in the artifact

# 2.3.0

New features!

* All streams are promises: `fun(mystream).then(…)` will wait wait for your
  stream to `end` in the case of read streams or `finish` in the case of
  write and duplex streams.
  There's no overhead to this: No promise is constructed if you don't call
  a promise method on the resulting objects.
  If you want a Bluebird (or other, non-native) promise implementation you
  can pass one in as an option `fun(mystream, {Promise: require('bluebird'})`
* flat: emit each object of an array as a new element of the stream
* flatMap: transform the input and apply flat as above to the output
* list: sugar for turning the stream into an array
* grab: opperate on the entire stream as an array while still chaining back
  into a stream
* concat: returns the entire stream as a single string

Improvements!

* forEach: sync calls have a fast-path now
* All module loading that can be lazy, now is lazy, for faster loads and
  less memory use.

Bug fixes!

* The async stream reducer was entirely broken. Now fixed.


# 2.2.0

* Writable streams are now fun!  Fun a writable stream and get a
  promise/stream hybrid.  The promise part will resolve when the stream
  finishes, or rejects when it errors.  The stream part is still a perfectly
  ordinary write stream with all the usual features.
* Errors aren't fun, but they now at least cop to who was to blame for them in `error.src`.
* Generators can be fun! Fun a generator to get a fun stream of values.

* Bug fix: `forEach` fun now gets option choices and those your choice of promises.
* More symbols are more fun. isFun property is now Symbol(ISFUN) and no longer polutes your namespaces.