@loaders.gl/core/dist/esm/lib/loader-utils/get-data.js

Framework-independent loaders for 3D graphics formats

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import { isFetchResponse, isReadableStream, isAsyncIterable, isIterable, isIterator, isFileReadable } from '../../javascript-utils/is-type';
import { getStreamIterator } from '../../javascript-utils/stream-utils';
import fetchFileReadable from '../fetch/fetch-file.browser';
import { checkFetchResponseStatus, checkFetchResponseStatusSync } from './check-errors';
var ERR_DATA = 'Cannot convert supplied data type';
export function getUrlFromData(data, url) {
  if (isFetchResponse(data)) {
    url = url || data.url;
  } else if (isFileReadable(url)) {
    url = url.name;
  }

  return typeof url === 'string' ? url.replace(/\?.*/, '') : url;
}
export function getArrayBufferOrStringFromDataSync(data, loader) {
  if (loader.text && typeof data === 'string') {
    return data;
  }

  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
    var arrayBuffer = data.buffer || data;

    if (loader.text && !loader.binary) {
      var textDecoder = new TextDecoder('utf8');
      return textDecoder.decode(arrayBuffer);
    }

    return arrayBuffer;
  }

  throw new Error(ERR_DATA);
}
export function getArrayBufferOrStringFromData(_x, _x2) {
  return _getArrayBufferOrStringFromData.apply(this, arguments);
}

function _getArrayBufferOrStringFromData() {
  _getArrayBufferOrStringFromData = _asyncToGenerator(_regeneratorRuntime.mark(function _callee(data, loader) {
    var isArrayBuffer;
    return _regeneratorRuntime.wrap(function _callee$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return data;

          case 2:
            data = _context2.sent;
            isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);

            if (!(typeof data === 'string' || isArrayBuffer)) {
              _context2.next = 6;
              break;
            }

            return _context2.abrupt("return", getArrayBufferOrStringFromDataSync(data, loader));

          case 6:
            if (!isFileReadable(data)) {
              _context2.next = 10;
              break;
            }

            _context2.next = 9;
            return fetchFileReadable(data);

          case 9:
            data = _context2.sent;

          case 10:
            if (!isFetchResponse(data)) {
              _context2.next = 23;
              break;
            }

            _context2.next = 13;
            return checkFetchResponseStatus(data);

          case 13:
            if (!loader.binary) {
              _context2.next = 19;
              break;
            }

            _context2.next = 16;
            return data.arrayBuffer();

          case 16:
            _context2.t0 = _context2.sent;
            _context2.next = 22;
            break;

          case 19:
            _context2.next = 21;
            return data.text();

          case 21:
            _context2.t0 = _context2.sent;

          case 22:
            return _context2.abrupt("return", _context2.t0);

          case 23:
            throw new Error(ERR_DATA);

          case 24:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee);
  }));
  return _getArrayBufferOrStringFromData.apply(this, arguments);
}

export function getAsyncIteratorFromData(data) {
  if (isIterator(data)) {
    return data;
  }

  if (isFetchResponse(data) && data.body) {
    checkFetchResponseStatusSync(data);
    return getStreamIterator(data.body);
  }

  if (isReadableStream(data)) {
    return getStreamIterator(data);
  }

  if (isAsyncIterable(data)) {
    return data[Symbol.asyncIterator]();
  }

  return getIteratorFromData(data);
}
export function getIteratorFromData(data) {
  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
    return _regeneratorRuntime.mark(function oneChunk() {
      return _regeneratorRuntime.wrap(function oneChunk$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return data.buffer || data;

            case 2:
            case "end":
              return _context.stop();
          }
        }
      }, oneChunk);
    })();
  }

  if (isIterator(data)) {
    return data;
  }

  if (isIterable(data)) {
    return data[Symbol.iterator]();
  }

  throw new Error(ERR_DATA);
}
//# sourceMappingURL=get-data.js.map