Buffers events from a stream until you are ready to handle them.
npm install delayed-streamBuffers events from a stream until you are ready to handle them.
`` bash`
npm install delayed-stream
The following example shows how to write a http echo server that delays its
response by 1000 ms.
` javascript
var DelayedStream = require('delayed-stream');
var http = require('http');
http.createServer(function(req, res) {
var delayed = DelayedStream.create(req);
setTimeout(function() {
res.writeHead(200);
delayed.pipe(res);
}, 1000);
});
`
If you are not using Stream#pipe, you can also manually release the buffereddelayedStream.resume()
events by calling :
` javascript
var delayed = DelayedStream.create(req);
setTimeout(function() {
// Emit all buffered events and resume underlaying source
delayed.resume();
}, 1000);
`
In order to use this meta stream properly, here are a few things you should
know about the implementation.
All events of the source stream are hijacked by overwriting the source.emit
method. Until node implements a catch-all event listener, this is the only way.
However, delayed-stream still continues to emit all events it captures on the
source, regardless of whether you have released the delayed stream yet or
not.
Upon creation, delayed-stream captures all source events and stores them indelayedStream.release()
an internal event buffer. Once is called, alldelayedStream
buffered events are emitted on the , and the event buffer is
cleared. After that, delayed-stream merely acts as a proxy for the underlaying
source.
Error events on source are buffered / proxied just like any other events.delayedStream.create
However, attaches a no-op 'error' listener to thesource. This way you only have to handle errors on the delayedStream
object, rather than in two places.
delayed-stream provides a maxDataSize property that can be used to limitsource
the amount of data being buffered. In order to protect you from bad source.pause()
streams that don't react to , this feature is enabled by
default.
Returns a new delayedStream. Available options are:
* pauseStreammaxDataSize
*
The description for those properties can be found below.
The source stream managed by this object. This is useful if you aredelayedStream
passing your around, and you still want to access propertiessource
on the object.
Whether to pause the underlaying source when callingDelayedStream.create(). Modifying this property afterwards has no effect.
The amount of data to buffer before emitting an error.
If the underlaying source is emitting Buffer objects, the maxDataSize
refers to bytes.
If the underlaying source is emitting JavaScript strings, the size refers to
characters.
If you know what you are doing, you can set this property to Infinity to
disable this feature. You can also modify this property during runtime.
The amount of data buffered so far.
An ECMA5 getter that returns the value of source.readable.
If the delayedStream has not been released so far, delayedStream.release()
is called.
In either case, source.resume() is called.
Calls source.pause().
Calls delayedStream.resume() and then proxies the arguments to source.pipe.
Emits and clears all events that have been buffered up so far. This does not
resume the underlaying source, use delayedStream.resume()` instead.
delayed-stream is licensed under the MIT license.