@loaders.gl/core/dist/esm/lib/loader-utils/parse-with-worker.js

Framework-independent loaders for 3D graphics formats

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import { toArrayBuffer } from '../../javascript-utils/binary-utils';
import WorkerFarm from '../../worker-utils/worker-farm';
import { parse } from '../parse';
import { getTransferList } from '../../worker-utils/worker-utils';
var _workerFarm = null;

function getWorkerFarm() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var props = {};

  if (options.maxConcurrency) {
    props.maxConcurrency = options.maxConcurrency;
  }

  if (options.onDebug) {
    props.onDebug = options.onDebug;
  }

  if (!_workerFarm) {
    _workerFarm = new WorkerFarm({
      onMessage: onWorkerMessage
    });
  }

  _workerFarm.setProps(props);

  return _workerFarm;
}

function onWorkerMessage(_x) {
  return _onWorkerMessage.apply(this, arguments);
}

function _onWorkerMessage() {
  _onWorkerMessage = _asyncToGenerator(_regeneratorRuntime.mark(function _callee(_ref) {
    var worker, data, resolve, reject, result;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            worker = _ref.worker, data = _ref.data, resolve = _ref.resolve, reject = _ref.reject;
            _context.t0 = data.type;
            _context.next = _context.t0 === 'done' ? 4 : _context.t0 === 'process' ? 6 : _context.t0 === 'error' ? 17 : 19;
            break;

          case 4:
            resolve(data.result);
            return _context.abrupt("break", 19);

          case 6:
            _context.prev = 6;
            _context.next = 9;
            return parse(data.arraybuffer, data.options, data.url);

          case 9:
            result = _context.sent;
            worker.postMessage({
              type: 'process-done',
              id: data.id,
              result: result
            }, getTransferList(result));
            _context.next = 16;
            break;

          case 13:
            _context.prev = 13;
            _context.t1 = _context["catch"](6);
            worker.postMessage({
              type: 'process-error',
              id: data.id,
              message: _context.t1.message
            });

          case 16:
            return _context.abrupt("break", 19);

          case 17:
            reject(data.message);
            return _context.abrupt("break", 19);

          case 19:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[6, 13]]);
  }));
  return _onWorkerMessage.apply(this, arguments);
}

export default function parseWithWorker(workerSource, workerName, data) {
  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  var context = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
  var workerFarm = getWorkerFarm(options);
  options = JSON.parse(JSON.stringify(options));
  return workerFarm.process(workerSource, "loaders.gl-".concat(workerName), {
    arraybuffer: toArrayBuffer(data),
    options: options,
    source: 'loaders.gl',
    type: 'process'
  });
}
//# sourceMappingURL=parse-with-worker.js.map