@loaders.gl/core/dist/esm/lib/parse-in-batches.js

Framework-independent loaders for 3D graphics formats

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import { isLoaderObject } from './loader-utils/normalize-loader';
import { mergeLoaderAndUserOptions } from './loader-utils/normalize-options';
import { getAsyncIteratorFromData } from './loader-utils/get-data';
import { getLoaderContext } from './loader-utils/get-loader-context';
import { selectLoader } from './select-loader';
export function parseInBatches(_x, _x2, _x3, _x4) {
  return _parseInBatches.apply(this, arguments);
}

function _parseInBatches() {
  _parseInBatches = _asyncToGenerator(_regeneratorRuntime.mark(function _callee(data, loaders, options, url) {
    var loader, context;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
              url = options;
              options = loaders;
              loaders = null;
            }

            loader = selectLoader(loaders, url, null);
            options = mergeLoaderAndUserOptions(options, loader);
            context = getLoaderContext({
              url: url
            }, options);
            return _context.abrupt("return", parseWithLoaderInBatches(loader, data, options, context));

          case 5:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _parseInBatches.apply(this, arguments);
}

function parseWithLoaderInBatches(loader, data, options, context) {
  if (loader.parseInBatches) {
    var inputIterator = getAsyncIteratorFromData(data);
    var outputIterator = loader.parseInBatches(inputIterator, options, context, loader);
    return outputIterator;
  }

  throw new Error('parseWithLoaderInBatchesSync not available');
}
//# sourceMappingURL=parse-in-batches.js.map