Bones/node_modules/rx/index.js
SOUTHERNCO\x2mjbyrn 7efe7605b8 Template Upload
2017-05-17 13:45:25 -04:00

221 lines
7.5 KiB
JavaScript

var Rx = require('./dist/rx.all');
require('./dist/rx.sorting');
require('./dist/rx.testing');
// Add specific Node functions
var EventEmitter = require('events').EventEmitter,
Observable = Rx.Observable;
Rx.Node = {
/**
* @deprecated Use Rx.Observable.fromCallback from rx.async.js instead.
*
* Converts a callback function to an observable sequence.
*
* @param {Function} func Function to convert to an asynchronous function.
* @param {Mixed} [context] The context for the func parameter to be executed. If not specified, defaults to undefined.
* @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
* @returns {Function} Asynchronous function.
*/
fromCallback: function (func, context, selector) {
return Observable.fromCallback(func, context, selector);
},
/**
* @deprecated Use Rx.Observable.fromNodeCallback from rx.async.js instead.
*
* Converts a Node.js callback style function to an observable sequence. This must be in function (err, ...) format.
*
* @param {Function} func The function to call
* @param {Mixed} [context] The context for the func parameter to be executed. If not specified, defaults to undefined.
* @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
* @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
*/
fromNodeCallback: function (func, context, selector) {
return Observable.fromNodeCallback(func, context, selector);
},
/**
* @deprecated Use Rx.Observable.fromNodeCallback from rx.async.js instead.
*
* Handles an event from the given EventEmitter as an observable sequence.
*
* @param {EventEmitter} eventEmitter The EventEmitter to subscribe to the given event.
* @param {String} eventName The event name to subscribe
* @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
* @returns {Observable} An observable sequence generated from the named event from the given EventEmitter. The data will be returned as an array of arguments to the handler.
*/
fromEvent: function (eventEmitter, eventName, selector) {
return Observable.fromEvent(eventEmitter, eventName, selector);
},
/**
* Converts the given observable sequence to an event emitter with the given event name.
* The errors are handled on the 'error' event and completion on the 'end' event.
* @param {Observable} observable The observable sequence to convert to an EventEmitter.
* @param {String} eventName The event name to emit onNext calls.
* @returns {EventEmitter} An EventEmitter which emits the given eventName for each onNext call in addition to 'error' and 'end' events.
* You must call publish in order to invoke the subscription on the Observable sequuence.
*/
toEventEmitter: function (observable, eventName, selector) {
var e = new EventEmitter();
// Used to publish the events from the observable
e.publish = function () {
e.subscription = observable.subscribe(
function (x) {
var result = x;
if (selector) {
try {
result = selector(x);
} catch (e) {
e.emit('error', e);
return;
}
}
e.emit(eventName, result);
},
function (err) {
e.emit('error', err);
},
function () {
e.emit('end');
});
};
return e;
},
/**
* Converts a flowing stream to an Observable sequence.
* @param {Stream} stream A stream to convert to a observable sequence.
* @param {String} [finishEventName] Event that notifies about closed stream. ("end" by default)
* @returns {Observable} An observable sequence which fires on each 'data' event as well as handling 'error' and finish events like `end` or `finish`.
*/
fromStream: function (stream, finishEventName) {
stream.pause();
finishEventName || (finishEventName = 'end');
return Observable.create(function (observer) {
function dataHandler (data) {
observer.onNext(data);
}
function errorHandler (err) {
observer.onError(err);
}
function endHandler () {
observer.onCompleted();
}
stream.addListener('data', dataHandler);
stream.addListener('error', errorHandler);
stream.addListener(finishEventName, endHandler);
stream.resume();
return function () {
stream.removeListener('data', dataHandler);
stream.removeListener('error', errorHandler);
stream.removeListener(finishEventName, endHandler);
};
}).publish().refCount();
},
/**
* Converts a flowing readable stream to an Observable sequence.
* @param {Stream} stream A stream to convert to a observable sequence.
* @returns {Observable} An observable sequence which fires on each 'data' event as well as handling 'error' and 'end' events.
*/
fromReadableStream: function (stream) {
return this.fromStream(stream, 'end');
},
/**
* Converts a flowing writeable stream to an Observable sequence.
* @param {Stream} stream A stream to convert to a observable sequence.
* @returns {Observable} An observable sequence which fires on each 'data' event as well as handling 'error' and 'finish' events.
*/
fromWritableStream: function (stream) {
return this.fromStream(stream, 'finish');
},
/**
* Converts a flowing transform stream to an Observable sequence.
* @param {Stream} stream A stream to convert to a observable sequence.
* @returns {Observable} An observable sequence which fires on each 'data' event as well as handling 'error' and 'finish' events.
*/
fromTransformStream: function (stream) {
return this.fromStream(stream, 'finish');
},
/**
* Writes an observable sequence to a stream
* @param {Observable} observable Observable sequence to write to a stream.
* @param {Stream} stream The stream to write to.
* @param {String} [encoding] The encoding of the item to write.
* @returns {Disposable} The subscription handle.
*/
writeToStream: function (observable, stream, encoding) {
var source = observable.pausableBuffered();
function onDrain() {
source.resume();
}
stream.addListener('drain', onDrain);
return source.subscribe(
function (x) {
!stream.write(String(x), encoding) && source.pause();
},
function (err) {
stream.emit('error', err);
},
function () {
// Hack check because STDIO is not closable
!stream._isStdio && stream.end();
stream.removeListener('drain', onDrain);
});
source.resume();
}
};
/**
* Pipes the existing Observable sequence into a Node.js Stream.
* @param {Stream} dest The destination Node.js stream.
* @returns {Stream} The destination stream.
*/
Rx.Observable.prototype.pipe = function (dest) {
var source = this.pausableBuffered();
function onDrain() {
source.resume();
}
dest.addListener('drain', onDrain);
source.subscribe(
function (x) {
!dest.write(String(x)) && source.pause();
},
function (err) {
dest.emit('error', err);
},
function () {
// Hack check because STDIO is not closable
!dest._isStdio && dest.end();
dest.removeListener('drain', onDrain);
});
source.resume();
return dest;
};
module.exports = Rx;