text: import Observable from 'zen-observable';
  import { validateOperation, isTerminating, LinkError, transformOperation, createOperation, } from './linkUtils';
  var passthrough = function (op, forward) { return (forward ? forward(op) : Observable.of()); };
  var toLink = function (handler) {
      return typeof handler === 'function' ? new ApolloLink(handler) : handler;
  };
  export var empty = function () {
      return new ApolloLink(function (op, forward) { return Observable.of(); });
  };
  export var from = function (links) {
      if (links.length === 0)
          return empty();
      return links.map(toLink).reduce(function (x, y) { return x.concat(y); });
  };
  export var split = function (test, left, right) {
      if (right === void 0) { right = new ApolloLink(passthrough); }
      var leftLink = toLink(left);
      var rightLink = toLink(right);
      if (isTerminating(leftLink) && isTerminating(rightLink)) {
          return new ApolloLink(function (operation) {
              return test(operation)
                  ? leftLink.request(operation) || Observable.of()
                  : rightLink.request(operation) || Observable.of();
          });
      }
      else {
          return new ApolloLink(function (operation, forward) {
              return test(operation)
                  ? leftLink.request(operation, forward) || Observable.of()
                  : rightLink.request(operation, forward) || Observable.of();
          });
      }
  };
  export var concat = function (first, second) {
      var firstLink = toLink(first);
      if (isTerminating(firstLink)) {
          console.warn(new LinkError("You are calling concat on a terminating link, which will have no effect", firstLink));
          return firstLink;
      }
      var nextLink = toLink(second);
      if (isTerminating(nextLink)) {
          return new ApolloLink(function (operation) {
              return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();
          });
      }
      else {
          return new ApolloLink(function (operation, forward) {
              return (firstLink.request(operation, function (op) {
                  return nextLink.request(op, forward) || Observable.of();
              }) || Observable.of());
          });
      }
  };
  var ApolloLink = (function () {
      function ApolloLink(request) {
          if (request)
              this.request = request;
      }
      ApolloLink.prototype.split = function (test, left, right) {
          if (right === void 0) { right = new ApolloLink(passthrough); }
          return this.concat(split(test, left, right));
      };
      ApolloLink.prototype.concat = function (next) {
          return concat(this, next);
      };
      ApolloLink.prototype.request = function (operation, forward) {
          throw new Error('request is not implemented');
      };
      ApolloLink.empty = empty;
      ApolloLink.from = from;
      ApolloLink.split = split;
      ApolloLink.execute = execute;
      return ApolloLink;
  }());
  export { ApolloLink };
  export function execute(link, operation) {
      return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());
  }
  //# sourceMappingURL=link.js.map