123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264 |
- "use strict";
- var __extends = (this && this.__extends) || function (d, b) {
- for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
- var Observable_1 = require('../Observable');
- var tryCatch_1 = require('../util/tryCatch');
- var errorObject_1 = require('../util/errorObject');
- var AsyncSubject_1 = require('../AsyncSubject');
- /**
- * We need this JSDoc comment for affecting ESDoc.
- * @extends {Ignored}
- * @hide true
- */
- var BoundCallbackObservable = (function (_super) {
- __extends(BoundCallbackObservable, _super);
- function BoundCallbackObservable(callbackFunc, selector, args, context, scheduler) {
- _super.call(this);
- this.callbackFunc = callbackFunc;
- this.selector = selector;
- this.args = args;
- this.context = context;
- this.scheduler = scheduler;
- }
- /* tslint:enable:max-line-length */
- /**
- * Converts a callback API to a function that returns an Observable.
- *
- * <span class="informal">Give it a function `f` of type `f(x, callback)` and
- * it will return a function `g` that when called as `g(x)` will output an
- * Observable.</span>
- *
- * `bindCallback` is not an operator because its input and output are not
- * Observables. The input is a function `func` with some parameters, the
- * last parameter must be a callback function that `func` calls when it is
- * done.
- *
- * The output of `bindCallback` is a function that takes the same parameters
- * as `func`, except the last one (the callback). When the output function
- * is called with arguments it will return an Observable. If function `func`
- * calls its callback with one argument the Observable will emit that value.
- * If on the other hand the callback is called with multiple values the resulting
- * Observable will emit an array with said values as arguments.
- *
- * It is very important to remember that input function `func` is not called
- * when the output function is, but rather when the Observable returned by the output
- * function is subscribed. This means if `func` makes an AJAX request, that request
- * will be made every time someone subscribes to the resulting Observable, but not before.
- *
- * Optionally, a selector function can be passed to `bindObservable`. The selector function
- * takes the same arguments as the callback and returns the value that will be emitted by the Observable.
- * Even though by default multiple arguments passed to callback appear in the stream as an array
- * the selector function will be called with arguments directly, just as the callback would.
- * This means you can imagine the default selector (when one is not provided explicitly)
- * as a function that aggregates all its arguments into an array, or simply returns first argument
- * if there is only one.
- *
- * The last optional parameter - {@link Scheduler} - can be used to control when the call
- * to `func` happens after someone subscribes to Observable, as well as when results
- * passed to callback will be emitted. By default, the subscription to an Observable calls `func`
- * synchronously, but using `Scheduler.async` as the last parameter will defer the call to `func`,
- * just like wrapping the call in `setTimeout` with a timeout of `0` would. If you use the async Scheduler
- * and call `subscribe` on the output Observable all function calls that are currently executing
- * will end before `func` is invoked.
- *
- * By default results passed to the callback are emitted immediately after `func` invokes the callback.
- * In particular, if the callback is called synchronously the subscription of the resulting Observable
- * will call the `next` function synchronously as well. If you want to defer that call,
- * you may use `Scheduler.async` just as before. This means that by using `Scheduler.async` you can
- * ensure that `func` always calls its callback asynchronously, thus avoiding terrifying Zalgo.
- *
- * Note that the Observable created by the output function will always emit a single value
- * and then complete immediately. If `func` calls the callback multiple times, values from subsequent
- * calls will not appear in the stream. If you need to listen for multiple calls,
- * you probably want to use {@link fromEvent} or {@link fromEventPattern} instead.
- *
- * If `func` depends on some context (`this` property) and is not already bound the context of `func`
- * will be the context that the output function has at call time. In particular, if `func`
- * is called as a method of some objec and if `func` is not already bound, in order to preserve the context
- * it is recommended that the context of the output function is set to that object as well.
- *
- * If the input function calls its callback in the "node style" (i.e. first argument to callback is
- * optional error parameter signaling whether the call failed or not), {@link bindNodeCallback}
- * provides convenient error handling and probably is a better choice.
- * `bindCallback` will treat such functions the same as any other and error parameters
- * (whether passed or not) will always be interpreted as regular callback argument.
- *
- *
- * @example <caption>Convert jQuery's getJSON to an Observable API</caption>
- * // Suppose we have jQuery.getJSON('/my/url', callback)
- * var getJSONAsObservable = Rx.Observable.bindCallback(jQuery.getJSON);
- * var result = getJSONAsObservable('/my/url');
- * result.subscribe(x => console.log(x), e => console.error(e));
- *
- *
- * @example <caption>Receive an array of arguments passed to a callback</caption>
- * someFunction((a, b, c) => {
- * console.log(a); // 5
- * console.log(b); // 'some string'
- * console.log(c); // {someProperty: 'someValue'}
- * });
- *
- * const boundSomeFunction = Rx.Observable.bindCallback(someFunction);
- * boundSomeFunction().subscribe(values => {
- * console.log(values) // [5, 'some string', {someProperty: 'someValue'}]
- * });
- *
- *
- * @example <caption>Use bindCallback with a selector function</caption>
- * someFunction((a, b, c) => {
- * console.log(a); // 'a'
- * console.log(b); // 'b'
- * console.log(c); // 'c'
- * });
- *
- * const boundSomeFunction = Rx.Observable.bindCallback(someFunction, (a, b, c) => a + b + c);
- * boundSomeFunction().subscribe(value => {
- * console.log(value) // 'abc'
- * });
- *
- *
- * @example <caption>Compare behaviour with and without async Scheduler</caption>
- * function iCallMyCallbackSynchronously(cb) {
- * cb();
- * }
- *
- * const boundSyncFn = Rx.Observable.bindCallback(iCallMyCallbackSynchronously);
- * const boundAsyncFn = Rx.Observable.bindCallback(iCallMyCallbackSynchronously, null, Rx.Scheduler.async);
- *
- * boundSyncFn().subscribe(() => console.log('I was sync!'));
- * boundAsyncFn().subscribe(() => console.log('I was async!'));
- * console.log('This happened...');
- *
- * // Logs:
- * // I was sync!
- * // This happened...
- * // I was async!
- *
- *
- * @example <caption>Use bindCallback on an object method</caption>
- * const boundMethod = Rx.Observable.bindCallback(someObject.methodWithCallback);
- * boundMethod.call(someObject) // make sure methodWithCallback has access to someObject
- * .subscribe(subscriber);
- *
- *
- * @see {@link bindNodeCallback}
- * @see {@link from}
- * @see {@link fromPromise}
- *
- * @param {function} func A function with a callback as the last parameter.
- * @param {function} [selector] A function which takes the arguments from the
- * callback and maps them to a value that is emitted on the output Observable.
- * @param {Scheduler} [scheduler] The scheduler on which to schedule the
- * callbacks.
- * @return {function(...params: *): Observable} A function which returns the
- * Observable that delivers the same values the callback would deliver.
- * @static true
- * @name bindCallback
- * @owner Observable
- */
- BoundCallbackObservable.create = function (func, selector, scheduler) {
- if (selector === void 0) { selector = undefined; }
- return function () {
- var args = [];
- for (var _i = 0; _i < arguments.length; _i++) {
- args[_i - 0] = arguments[_i];
- }
- return new BoundCallbackObservable(func, selector, args, this, scheduler);
- };
- };
- /** @deprecated internal use only */ BoundCallbackObservable.prototype._subscribe = function (subscriber) {
- var callbackFunc = this.callbackFunc;
- var args = this.args;
- var scheduler = this.scheduler;
- var subject = this.subject;
- if (!scheduler) {
- if (!subject) {
- subject = this.subject = new AsyncSubject_1.AsyncSubject();
- var handler = function handlerFn() {
- var innerArgs = [];
- for (var _i = 0; _i < arguments.length; _i++) {
- innerArgs[_i - 0] = arguments[_i];
- }
- var source = handlerFn.source;
- var selector = source.selector, subject = source.subject;
- if (selector) {
- var result_1 = tryCatch_1.tryCatch(selector).apply(this, innerArgs);
- if (result_1 === errorObject_1.errorObject) {
- subject.error(errorObject_1.errorObject.e);
- }
- else {
- subject.next(result_1);
- subject.complete();
- }
- }
- else {
- subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs);
- subject.complete();
- }
- };
- // use named function instance to avoid closure.
- handler.source = this;
- var result = tryCatch_1.tryCatch(callbackFunc).apply(this.context, args.concat(handler));
- if (result === errorObject_1.errorObject) {
- subject.error(errorObject_1.errorObject.e);
- }
- }
- return subject.subscribe(subscriber);
- }
- else {
- return scheduler.schedule(BoundCallbackObservable.dispatch, 0, { source: this, subscriber: subscriber, context: this.context });
- }
- };
- BoundCallbackObservable.dispatch = function (state) {
- var self = this;
- var source = state.source, subscriber = state.subscriber, context = state.context;
- var callbackFunc = source.callbackFunc, args = source.args, scheduler = source.scheduler;
- var subject = source.subject;
- if (!subject) {
- subject = source.subject = new AsyncSubject_1.AsyncSubject();
- var handler = function handlerFn() {
- var innerArgs = [];
- for (var _i = 0; _i < arguments.length; _i++) {
- innerArgs[_i - 0] = arguments[_i];
- }
- var source = handlerFn.source;
- var selector = source.selector, subject = source.subject;
- if (selector) {
- var result_2 = tryCatch_1.tryCatch(selector).apply(this, innerArgs);
- if (result_2 === errorObject_1.errorObject) {
- self.add(scheduler.schedule(dispatchError, 0, { err: errorObject_1.errorObject.e, subject: subject }));
- }
- else {
- self.add(scheduler.schedule(dispatchNext, 0, { value: result_2, subject: subject }));
- }
- }
- else {
- var value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs;
- self.add(scheduler.schedule(dispatchNext, 0, { value: value, subject: subject }));
- }
- };
- // use named function to pass values in without closure
- handler.source = source;
- var result = tryCatch_1.tryCatch(callbackFunc).apply(context, args.concat(handler));
- if (result === errorObject_1.errorObject) {
- subject.error(errorObject_1.errorObject.e);
- }
- }
- self.add(subject.subscribe(subscriber));
- };
- return BoundCallbackObservable;
- }(Observable_1.Observable));
- exports.BoundCallbackObservable = BoundCallbackObservable;
- function dispatchNext(arg) {
- var value = arg.value, subject = arg.subject;
- subject.next(value);
- subject.complete();
- }
- function dispatchError(arg) {
- var err = arg.err, subject = arg.subject;
- subject.error(err);
- }
- //# sourceMappingURL=BoundCallbackObservable.js.map
|