work.suroh.tk/node_modules/rxjs/_esm5/observable/FromEventPatternObservable.js

115 lines
4.5 KiB
JavaScript
Raw Normal View History

2019-12-02 12:22:45 +00:00
/** PURE_IMPORTS_START .._util_isFunction,.._Observable,.._Subscription PURE_IMPORTS_END */
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 __());
};
import { isFunction } from '../util/isFunction';
import { Observable } from '../Observable';
import { Subscription } from '../Subscription';
/**
* We need this JSDoc comment for affecting ESDoc.
* @extends {Ignored}
* @hide true
*/
export var FromEventPatternObservable = /*@__PURE__*/ (/*@__PURE__*/ function (_super) {
__extends(FromEventPatternObservable, _super);
function FromEventPatternObservable(addHandler, removeHandler, selector) {
_super.call(this);
this.addHandler = addHandler;
this.removeHandler = removeHandler;
this.selector = selector;
}
/**
* Creates an Observable from an API based on addHandler/removeHandler
* functions.
*
* <span class="informal">Converts any addHandler/removeHandler API to an
* Observable.</span>
*
* <img src="./img/fromEventPattern.png" width="100%">
*
* Creates an Observable by using the `addHandler` and `removeHandler`
* functions to add and remove the handlers, with an optional selector
* function to project the event arguments to a result. The `addHandler` is
* called when the output Observable is subscribed, and `removeHandler` is
* called when the Subscription is unsubscribed.
*
* @example <caption>Emits clicks happening on the DOM document</caption>
* function addClickHandler(handler) {
* document.addEventListener('click', handler);
* }
*
* function removeClickHandler(handler) {
* document.removeEventListener('click', handler);
* }
*
* var clicks = Rx.Observable.fromEventPattern(
* addClickHandler,
* removeClickHandler
* );
* clicks.subscribe(x => console.log(x));
*
* @see {@link from}
* @see {@link fromEvent}
*
* @param {function(handler: Function): any} addHandler A function that takes
* a `handler` function as argument and attaches it somehow to the actual
* source of events.
* @param {function(handler: Function, signal?: any): void} [removeHandler] An optional function that
* takes a `handler` function as argument and removes it in case it was
* previously attached using `addHandler`. if addHandler returns signal to teardown when remove,
* removeHandler function will forward it.
* @param {function(...args: any): T} [selector] An optional function to
* post-process results. It takes the arguments from the event handler and
* should return a single value.
* @return {Observable<T>}
* @static true
* @name fromEventPattern
* @owner Observable
*/
FromEventPatternObservable.create = function (addHandler, removeHandler, selector) {
return new FromEventPatternObservable(addHandler, removeHandler, selector);
};
/** @deprecated internal use only */ FromEventPatternObservable.prototype._subscribe = function (subscriber) {
var _this = this;
var removeHandler = this.removeHandler;
var handler = !!this.selector ? function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i - 0] = arguments[_i];
}
_this._callSelector(subscriber, args);
} : function (e) { subscriber.next(e); };
var retValue = this._callAddHandler(handler, subscriber);
if (!isFunction(removeHandler)) {
return;
}
subscriber.add(new Subscription(function () {
//TODO: determine whether or not to forward to error handler
removeHandler(handler, retValue);
}));
};
FromEventPatternObservable.prototype._callSelector = function (subscriber, args) {
try {
var result = this.selector.apply(this, args);
subscriber.next(result);
}
catch (e) {
subscriber.error(e);
}
};
FromEventPatternObservable.prototype._callAddHandler = function (handler, errorSubscriber) {
try {
return this.addHandler(handler) || null;
}
catch (e) {
errorSubscriber.error(e);
}
};
return FromEventPatternObservable;
}(Observable));
//# sourceMappingURL=FromEventPatternObservable.js.map