text: "use strict";
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  Object.defineProperty(exports, "__esModule", { value: true });
  var isFunction_1 = require("../util/isFunction");
  var Observable_1 = require("../Observable");
  var Subscription_1 = require("../Subscription");
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */
  var FromEventPatternObservable = /** @class */ (function (_super) {
      __extends(FromEventPatternObservable, _super);
      function FromEventPatternObservable(addHandler, removeHandler, selector) {
          var _this = _super.call(this) || this;
          _this.addHandler = addHandler;
          _this.removeHandler = removeHandler;
          _this.selector = selector;
          return _this;
      }
      /**
       * 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);
      };
      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] = arguments[_i];
              }
              _this._callSelector(subscriber, args);
          } : function (e) { subscriber.next(e); };
          var retValue = this._callAddHandler(handler, subscriber);
          if (!isFunction_1.isFunction(removeHandler)) {
              return;
          }
          subscriber.add(new Subscription_1.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_1.Observable));
  exports.FromEventPatternObservable = FromEventPatternObservable;
  //# sourceMappingURL=FromEventPatternObservable.js.map