response-iterator/dist/umd/response-iterator.cjs

Creates an async iterator for a variety of inputs in the browser and node. Supports fetch, node-fetch, and cross-fetch

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.responseIterator = factory());
})(this, (function () { 'use strict';

  function _define_property(obj, key, value) {
      if (key in obj) {
          Object.defineProperty(obj, key, {
              value: value,
              enumerable: true,
              configurable: true,
              writable: true
          });
      } else {
          obj[key] = value;
      }
      return obj;
  }
  function asyncIterator(source) {
      var iterator = source[Symbol.asyncIterator]();
      return _define_property({
          next: function next() {
              return iterator.next();
          }
      }, Symbol.asyncIterator, function() {
          return this;
      });
  }

  var hasIterator$3 = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
  /* c8 ignore start */ function nodeStreamIterator(stream) {
      var cleanup = null;
      var error = null;
      var done = false;
      var data = [];
      var waiting = [];
      function onData(chunk) {
          if (error) return;
          if (waiting.length) return waiting.shift()[0]({
              value: chunk,
              done: false
          });
          data.push(chunk);
      }
      function onError(err) {
          error = err;
          var all = waiting.slice();
          all.forEach(function(pair) {
              pair[1](err);
          });
          !cleanup || cleanup();
      }
      function onEnd() {
          done = true;
          var all = waiting.slice();
          all.forEach(function(pair) {
              pair[0]({
                  value: undefined,
                  done: true
              });
          });
          !cleanup || cleanup();
      }
      cleanup = function() {
          cleanup = null;
          stream.removeListener('data', onData);
          stream.removeListener('error', onError);
          stream.removeListener('end', onEnd);
          stream.removeListener('finish', onEnd);
          stream.removeListener('close', onEnd);
      };
      stream.on('data', onData);
      stream.on('error', onError);
      stream.on('end', onEnd);
      stream.on('finish', onEnd);
      stream.on('close', onEnd);
      function getNext() {
          return new Promise(function(resolve, reject) {
              if (error) return reject(error);
              if (data.length) return resolve({
                  value: data.shift(),
                  done: false
              });
              if (done) return resolve({
                  value: undefined,
                  done: true
              });
              waiting.push([
                  resolve,
                  reject
              ]);
          });
      }
      var iterator = {
          next: function next() {
              return getNext();
          }
      };
      if (hasIterator$3) {
          iterator[Symbol.asyncIterator] = function() {
              return this;
          };
      }
      return iterator;
  } /* c8 ignore stop */

  var hasIterator$2 = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
  /* c8 ignore start */ function promiseIterator(promise) {
      var resolved = false;
      var iterator = {
          next: function next() {
              if (resolved) return Promise.resolve({
                  value: undefined,
                  done: true
              });
              resolved = true;
              return new Promise(function(resolve, reject) {
                  promise.then(function(value) {
                      resolve({
                          value: value,
                          done: false
                      });
                  }).catch(reject);
              });
          }
      };
      if (hasIterator$2) {
          iterator[Symbol.asyncIterator] = function() {
              return this;
          };
      }
      return iterator;
  } /* c8 ignore stop */

  var hasIterator$1 = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
  /* c8 ignore start */ function readerIterator(reader) {
      var iterator = {
          next: function next() {
              return reader.read(undefined);
          }
      };
      if (hasIterator$1) {
          iterator[Symbol.asyncIterator] = function() {
              return this;
          };
      }
      return iterator;
  } /* c8 ignore stop */

  var hasIterator = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
  /**
   * @param response A response. Supports fetch, node-fetch, and cross-fetch
   */ function responseIterator(response) {
      if (response === undefined) throw new Error('Missing response for responseIterator');
      // determine the body
      var body = response;
      if (response.body) body = response.body;
      else if (response.data) body = response.data;
      else if (response._bodyBlob) body = response._bodyBlob; // cross-fetch
      /* c8 ignore stop */ // adapt the body
      if (hasIterator && body[Symbol.asyncIterator]) return asyncIterator(body);
      /* c8 ignore start */ if (body.getReader) return readerIterator(body.getReader());
      if (body.stream) return readerIterator(body.stream().getReader());
      if (body.arrayBuffer) return promiseIterator(body.arrayBuffer());
      if (body.pipe) return nodeStreamIterator(body);
      /* c8 ignore stop */ throw new Error('Unknown body type for responseIterator. Maybe you are not passing a streamable response');
  }

  return responseIterator;

}));
//# sourceMappingURL=response-iterator.cjs.map