@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/processors/file-handler.js

@@ -0,0 +1,432 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGeoJson = isGeoJson;
+exports.isFeature = isFeature;
+exports.isFeatureCollection = isFeatureCollection;
+exports.isRowObject = isRowObject;
+exports.isKeplerGlMap = isKeplerGlMap;
+exports.makeProgressIterator = makeProgressIterator;
+exports.readBatch = readBatch;
+exports.readFileInBatches = readFileInBatches;
+exports.processFileData = processFileData;
+exports.filesToDataPayload = filesToDataPayload;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
+var _core = require("@loaders.gl/core");
+
+var _json = require("@loaders.gl/json");
+
+var _csv = require("@loaders.gl/csv");
+
+var _dataProcessor = require("./data-processor");
+
+var _utils = require("../utils/utils");
+
+var _defaultSettings = require("../constants/default-settings");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var BATCH_TYPE = {
+  METADATA: 'metadata',
+  PARTIAL_RESULT: 'partial-result',
+  FINAL_RESULT: 'final-result'
+};
+var CSV_LOADER_OPTIONS = {
+  batchSize: 4000,
+  // Auto de tect number of rows per batch (network batch size)
+  rowFormat: 'object',
+  dynamicTyping: false // not working for now
+
+};
+var JSON_LOADER_OPTIONS = {
+  // instruct loaders.gl on what json paths to stream
+  jsonpaths: ['$', // JSON Row array
+  '$.features', // GeoJSON
+  '$.datasets' // KeplerGL JSON
+  ]
+};
+
+function isGeoJson(json) {
+  // json can be feature collection
+  // or single feature
+  return (0, _utils.isPlainObject)(json) && (isFeature(json) || isFeatureCollection(json));
+}
+
+function isFeature(json) {
+  return json.type === 'Feature' && json.geometry;
+}
+
+function isFeatureCollection(json) {
+  return json.type === 'FeatureCollection' && json.features;
+}
+
+function isRowObject(json) {
+  return Array.isArray(json) && (0, _utils.isPlainObject)(json[0]);
+}
+
+function isKeplerGlMap(json) {
+  return Boolean((0, _utils.isPlainObject)(json) && json.datasets && json.config && json.info && json.info.app === 'kepler.gl');
+}
+
+function makeProgressIterator(_x, _x2) {
+  return _makeProgressIterator.apply(this, arguments);
+} // eslint-disable-next-line complexity
+
+
+function _makeProgressIterator() {
+  _makeProgressIterator = (0, _wrapAsyncGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(asyncIterator, info) {
+    var rowCount, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch, rowCountInBatch, percent, progress;
+
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            rowCount = 0;
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context.prev = 3;
+            _iterator = (0, _asyncIterator2["default"])(asyncIterator);
+
+          case 5:
+            _context.next = 7;
+            return (0, _awaitAsyncGenerator2["default"])(_iterator.next());
+
+          case 7:
+            _step = _context.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context.next = 11;
+            return (0, _awaitAsyncGenerator2["default"])(_step.value);
+
+          case 11:
+            _value = _context.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context.next = 23;
+              break;
+            }
+
+            batch = _value;
+            rowCountInBatch = batch.data && batch.data.length || 0;
+            rowCount += rowCountInBatch;
+            percent = Number.isFinite(batch.bytesUsed) ? batch.bytesUsed / info.size : null; // Update progress object
+
+            progress = _objectSpread({
+              rowCount: rowCount,
+              rowCountInBatch: rowCountInBatch
+            }, Number.isFinite(percent) ? {
+              percent: percent
+            } : {});
+            _context.next = 20;
+            return _objectSpread(_objectSpread({}, batch), {}, {
+              progress: progress
+            });
+
+          case 20:
+            _iteratorNormalCompletion = true;
+            _context.next = 5;
+            break;
+
+          case 23:
+            _context.next = 29;
+            break;
+
+          case 25:
+            _context.prev = 25;
+            _context.t0 = _context["catch"](3);
+            _didIteratorError = true;
+            _iteratorError = _context.t0;
+
+          case 29:
+            _context.prev = 29;
+            _context.prev = 30;
+
+            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
+              _context.next = 34;
+              break;
+            }
+
+            _context.next = 34;
+            return (0, _awaitAsyncGenerator2["default"])(_iterator["return"]());
+
+          case 34:
+            _context.prev = 34;
+
+            if (!_didIteratorError) {
+              _context.next = 37;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 37:
+            return _context.finish(34);
+
+          case 38:
+            return _context.finish(29);
+
+          case 39:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[3, 25, 29, 39], [30,, 34, 38]]);
+  }));
+  return _makeProgressIterator.apply(this, arguments);
+}
+
+function readBatch(_x3, _x4) {
+  return _readBatch.apply(this, arguments);
+}
+
+function _readBatch() {
+  _readBatch = (0, _wrapAsyncGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(asyncIterator, fileName) {
+    var result, batches, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _value2, batch, streamingPath, i;
+
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            result = null;
+            batches = [];
+            _iteratorNormalCompletion2 = true;
+            _didIteratorError2 = false;
+            _context2.prev = 4;
+            _iterator2 = (0, _asyncIterator2["default"])(asyncIterator);
+
+          case 6:
+            _context2.next = 8;
+            return (0, _awaitAsyncGenerator2["default"])(_iterator2.next());
+
+          case 8:
+            _step2 = _context2.sent;
+            _iteratorNormalCompletion2 = _step2.done;
+            _context2.next = 12;
+            return (0, _awaitAsyncGenerator2["default"])(_step2.value);
+
+          case 12:
+            _value2 = _context2.sent;
+
+            if (_iteratorNormalCompletion2) {
+              _context2.next = 21;
+              break;
+            }
+
+            batch = _value2;
+
+            // Last batch will have this special type and will provide all the root
+            // properties of the parsed document.
+            // Only json parse will have `FINAL_RESULT`
+            if (batch.batchType === BATCH_TYPE.FINAL_RESULT) {
+              if (batch.container) {
+                result = _objectSpread({}, batch.container);
+              } // Set the streamed data correctly is Batch json path is set
+              // and the path streamed is not the top level object (jsonpath = '$')
+
+
+              if (batch.jsonpath && batch.jsonpath.length > 1) {
+                streamingPath = new _json._JSONPath(batch.jsonpath);
+                streamingPath.setFieldAtPath(result, batches);
+              } else if (batch.jsonpath && batch.jsonpath.length === 1) {
+                // The streamed object is a ROW JSON-batch (jsonpath = '$')
+                // row objects
+                result = batches;
+              }
+            } else {
+              for (i = 0; i < batch.data.length; i++) {
+                batches.push(batch.data[i]);
+              }
+            }
+
+            _context2.next = 18;
+            return _objectSpread(_objectSpread(_objectSpread({}, batch), batch.schema ? {
+              headers: Object.keys(batch.schema)
+            } : {}), {}, {
+              fileName: fileName,
+              // if dataset is CSV, data is set to the raw batches
+              data: result ? result : batches
+            });
+
+          case 18:
+            _iteratorNormalCompletion2 = true;
+            _context2.next = 6;
+            break;
+
+          case 21:
+            _context2.next = 27;
+            break;
+
+          case 23:
+            _context2.prev = 23;
+            _context2.t0 = _context2["catch"](4);
+            _didIteratorError2 = true;
+            _iteratorError2 = _context2.t0;
+
+          case 27:
+            _context2.prev = 27;
+            _context2.prev = 28;
+
+            if (!(!_iteratorNormalCompletion2 && _iterator2["return"] != null)) {
+              _context2.next = 32;
+              break;
+            }
+
+            _context2.next = 32;
+            return (0, _awaitAsyncGenerator2["default"])(_iterator2["return"]());
+
+          case 32:
+            _context2.prev = 32;
+
+            if (!_didIteratorError2) {
+              _context2.next = 35;
+              break;
+            }
+
+            throw _iteratorError2;
+
+          case 35:
+            return _context2.finish(32);
+
+          case 36:
+            return _context2.finish(27);
+
+          case 37:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[4, 23, 27, 37], [28,, 32, 36]]);
+  }));
+  return _readBatch.apply(this, arguments);
+}
+
+function readFileInBatches(_x5) {
+  return _readFileInBatches.apply(this, arguments);
+}
+
+function _readFileInBatches() {
+  _readFileInBatches = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref) {
+    var file, _ref$fileCache, fileCache, _ref$loaders, loaders, _ref$loadOptions, loadOptions, batchIterator, progressIterator;
+
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            file = _ref.file, _ref$fileCache = _ref.fileCache, fileCache = _ref$fileCache === void 0 ? [] : _ref$fileCache, _ref$loaders = _ref.loaders, loaders = _ref$loaders === void 0 ? [] : _ref$loaders, _ref$loadOptions = _ref.loadOptions, loadOptions = _ref$loadOptions === void 0 ? {} : _ref$loadOptions;
+            loaders = [_json.JSONLoader, _csv.CSVLoader].concat((0, _toConsumableArray2["default"])(loaders));
+            loadOptions = _objectSpread({
+              csv: CSV_LOADER_OPTIONS,
+              json: JSON_LOADER_OPTIONS,
+              metadata: true
+            }, loadOptions);
+            _context3.next = 5;
+            return (0, _core.parseInBatches)(file, loaders, loadOptions);
+
+          case 5:
+            batchIterator = _context3.sent;
+            progressIterator = makeProgressIterator(batchIterator, {
+              size: file.size
+            });
+            return _context3.abrupt("return", readBatch(progressIterator, file.name));
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _readFileInBatches.apply(this, arguments);
+}
+
+function processFileData(_ref2) {
+  var content = _ref2.content,
+      fileCache = _ref2.fileCache;
+  return new Promise(function (resolve, reject) {
+    var data = content.data;
+    var format;
+    var processor;
+
+    if (isKeplerGlMap(data)) {
+      format = _defaultSettings.DATASET_FORMATS.keplergl;
+      processor = _dataProcessor.processKeplerglJSON;
+    } else if (isRowObject(data)) {
+      format = _defaultSettings.DATASET_FORMATS.row;
+      processor = _dataProcessor.processRowObject;
+    } else if (isGeoJson(data)) {
+      format = _defaultSettings.DATASET_FORMATS.geojson;
+      processor = _dataProcessor.processGeojson;
+    }
+
+    if (format && processor) {
+      var result = processor(data);
+      resolve([].concat((0, _toConsumableArray2["default"])(fileCache), [{
+        data: result,
+        info: {
+          label: content.fileName,
+          format: format
+        }
+      }]));
+    }
+
+    reject('Unknow File Format');
+  });
+}
+
+function filesToDataPayload(fileCache) {
+  // seperate out files which could be a single datasets. or a keplergl map json
+  var collection = fileCache.reduce(function (accu, file) {
+    var data = file.data,
+        _file$info = file.info,
+        info = _file$info === void 0 ? {} : _file$info;
+    var format = info.format;
+
+    if (format === _defaultSettings.DATASET_FORMATS.keplergl) {
+      // if file contains a single kepler map dataset & config
+      accu.keplerMaps.push(_objectSpread(_objectSpread({}, data), {}, {
+        options: {
+          centerMap: !(data.config && data.config.mapState)
+        }
+      }));
+    } else if (_defaultSettings.DATASET_FORMATS[format]) {
+      // if file contains only data
+      var newDataset = {
+        data: data,
+        info: _objectSpread({
+          id: info.id || (0, _utils.generateHashId)(4)
+        }, info)
+      };
+      accu.datasets.push(newDataset);
+    }
+
+    return accu;
+  }, {
+    datasets: [],
+    keplerMaps: []
+  }); // add kepler map first with config
+  // add datasets later in one add data call
+
+  return collection.keplerMaps.concat({
+    datasets: collection.datasets
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/processors/file-handler.js"],"names":["BATCH_TYPE","METADATA","PARTIAL_RESULT","FINAL_RESULT","CSV_LOADER_OPTIONS","batchSize","rowFormat","dynamicTyping","JSON_LOADER_OPTIONS","jsonpaths","isGeoJson","json","isFeature","isFeatureCollection","type","geometry","features","isRowObject","Array","isArray","isKeplerGlMap","Boolean","datasets","config","info","app","makeProgressIterator","asyncIterator","rowCount","batch","rowCountInBatch","data","length","percent","Number","isFinite","bytesUsed","size","progress","readBatch","fileName","result","batches","batchType","container","jsonpath","streamingPath","_JSONPath","setFieldAtPath","i","push","schema","headers","Object","keys","readFileInBatches","file","fileCache","loaders","loadOptions","JSONLoader","CSVLoader","csv","metadata","batchIterator","progressIterator","name","processFileData","content","Promise","resolve","reject","format","processor","DATASET_FORMATS","keplergl","processKeplerglJSON","row","processRowObject","geojson","processGeojson","label","filesToDataPayload","collection","reduce","accu","keplerMaps","options","centerMap","mapState","newDataset","id","concat"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {parseInBatches} from '@loaders.gl/core';\nimport {JSONLoader, _JSONPath} from '@loaders.gl/json';\nimport {CSVLoader} from '@loaders.gl/csv';\nimport {processGeojson, processKeplerglJSON, processRowObject} from './data-processor';\nimport {isPlainObject, generateHashId} from 'utils/utils';\nimport {DATASET_FORMATS} from 'constants/default-settings';\n\nconst BATCH_TYPE = {\n  METADATA: 'metadata',\n  PARTIAL_RESULT: 'partial-result',\n  FINAL_RESULT: 'final-result'\n};\n\nconst CSV_LOADER_OPTIONS = {\n  batchSize: 4000, // Auto de tect number of rows per batch (network batch size)\n  rowFormat: 'object',\n  dynamicTyping: false // not working for now\n};\n\nconst JSON_LOADER_OPTIONS = {\n  // instruct loaders.gl on what json paths to stream\n  jsonpaths: [\n    '$', // JSON Row array\n    '$.features', // GeoJSON\n    '$.datasets' // KeplerGL JSON\n  ]\n};\n\nexport function isGeoJson(json) {\n  // json can be feature collection\n  // or single feature\n  return isPlainObject(json) && (isFeature(json) || isFeatureCollection(json));\n}\n\nexport function isFeature(json) {\n  return json.type === 'Feature' && json.geometry;\n}\n\nexport function isFeatureCollection(json) {\n  return json.type === 'FeatureCollection' && json.features;\n}\n\nexport function isRowObject(json) {\n  return Array.isArray(json) && isPlainObject(json[0]);\n}\n\nexport function isKeplerGlMap(json) {\n  return Boolean(\n    isPlainObject(json) &&\n      json.datasets &&\n      json.config &&\n      json.info &&\n      json.info.app === 'kepler.gl'\n  );\n}\n\nexport async function* makeProgressIterator(asyncIterator, info) {\n  let rowCount = 0;\n\n  for await (const batch of asyncIterator) {\n    const rowCountInBatch = (batch.data && batch.data.length) || 0;\n    rowCount += rowCountInBatch;\n    const percent = Number.isFinite(batch.bytesUsed) ? batch.bytesUsed / info.size : null;\n\n    // Update progress object\n    const progress = {\n      rowCount,\n      rowCountInBatch,\n      // @ts-ignore\n      ...(Number.isFinite(percent) ? {percent} : {})\n    };\n\n    yield {...batch, progress};\n  }\n}\n\n// eslint-disable-next-line complexity\nexport async function* readBatch(asyncIterator, fileName) {\n  let result = null;\n  const batches = [];\n\n  for await (const batch of asyncIterator) {\n    // Last batch will have this special type and will provide all the root\n    // properties of the parsed document.\n    // Only json parse will have `FINAL_RESULT`\n    if (batch.batchType === BATCH_TYPE.FINAL_RESULT) {\n      if (batch.container) {\n        result = {...batch.container};\n      }\n      // Set the streamed data correctly is Batch json path is set\n      // and the path streamed is not the top level object (jsonpath = '$')\n      if (batch.jsonpath && batch.jsonpath.length > 1) {\n        const streamingPath = new _JSONPath(batch.jsonpath);\n        streamingPath.setFieldAtPath(result, batches);\n      } else if (batch.jsonpath && batch.jsonpath.length === 1) {\n        // The streamed object is a ROW JSON-batch (jsonpath = '$')\n        // row objects\n        result = batches;\n      }\n    } else {\n      for (let i = 0; i < batch.data.length; i++) {\n        batches.push(batch.data[i]);\n      }\n    }\n\n    yield {\n      ...batch,\n      ...(batch.schema ? {headers: Object.keys(batch.schema)} : {}),\n      fileName,\n      // if dataset is CSV, data is set to the raw batches\n      data: result ? result : batches\n    };\n  }\n}\n\nexport async function readFileInBatches({file, fileCache = [], loaders = [], loadOptions = {}}) {\n  loaders = [JSONLoader, CSVLoader, ...loaders];\n  loadOptions = {\n    csv: CSV_LOADER_OPTIONS,\n    json: JSON_LOADER_OPTIONS,\n    metadata: true,\n    ...loadOptions\n  };\n\n  const batchIterator = await parseInBatches(file, loaders, loadOptions);\n  const progressIterator = makeProgressIterator(batchIterator, {size: file.size});\n\n  return readBatch(progressIterator, file.name);\n}\n\nexport function processFileData({content, fileCache}) {\n  return new Promise((resolve, reject) => {\n    const {data} = content;\n\n    let format;\n    let processor;\n    if (isKeplerGlMap(data)) {\n      format = DATASET_FORMATS.keplergl;\n      processor = processKeplerglJSON;\n    } else if (isRowObject(data)) {\n      format = DATASET_FORMATS.row;\n      processor = processRowObject;\n    } else if (isGeoJson(data)) {\n      format = DATASET_FORMATS.geojson;\n      processor = processGeojson;\n    }\n\n    if (format && processor) {\n      const result = processor(data);\n\n      resolve([\n        ...fileCache,\n        {\n          data: result,\n          info: {\n            label: content.fileName,\n            format\n          }\n        }\n      ]);\n    }\n\n    reject('Unknow File Format');\n  });\n}\n\nexport function filesToDataPayload(fileCache) {\n  // seperate out files which could be a single datasets. or a keplergl map json\n  const collection = fileCache.reduce(\n    (accu, file) => {\n      const {data, info = {}} = file;\n      const {format} = info;\n      if (format === DATASET_FORMATS.keplergl) {\n        // if file contains a single kepler map dataset & config\n        accu.keplerMaps.push({\n          ...data,\n          options: {\n            centerMap: !(data.config && data.config.mapState)\n          }\n        });\n      } else if (DATASET_FORMATS[format]) {\n        // if file contains only data\n        const newDataset = {\n          data,\n          info: {\n            id: info.id || generateHashId(4),\n            ...info\n          }\n        };\n        accu.datasets.push(newDataset);\n      }\n      return accu;\n    },\n    {datasets: [], keplerMaps: []}\n  );\n\n  // add kepler map first with config\n  // add datasets later in one add data call\n  return collection.keplerMaps.concat({datasets: collection.datasets});\n}\n"]}

package/dist/processors/index.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "formatCsv", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.formatCsv;
+  }
+});
+Object.defineProperty(exports, "processGeojson", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.processGeojson;
+  }
+});
+Object.defineProperty(exports, "processCsvData", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.processCsvData;
+  }
+});
+Object.defineProperty(exports, "processRowObject", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.processRowObject;
+  }
+});
+Object.defineProperty(exports, "processKeplerglJSON", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.processKeplerglJSON;
+  }
+});
+Object.defineProperty(exports, "processKeplerglDataset", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.processKeplerglDataset;
+  }
+});
+Object.defineProperty(exports, "analyzerTypeToFieldType", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.analyzerTypeToFieldType;
+  }
+});
+Object.defineProperty(exports, "getFieldsFromData", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.getFieldsFromData;
+  }
+});
+Object.defineProperty(exports, "parseRowsByFields", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.parseRowsByFields;
+  }
+});
+Object.defineProperty(exports, "parseCsvRowsByFieldType", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.parseCsvRowsByFieldType;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _dataProcessor.Processors;
+  }
+});
+Object.defineProperty(exports, "readFileInBatches", {
+  enumerable: true,
+  get: function get() {
+    return _fileHandler.readFileInBatches;
+  }
+});
+Object.defineProperty(exports, "processFileData", {
+  enumerable: true,
+  get: function get() {
+    return _fileHandler.processFileData;
+  }
+});
+Object.defineProperty(exports, "filesToDataPayload", {
+  enumerable: true,
+  get: function get() {
+    return _fileHandler.filesToDataPayload;
+  }
+});
+Object.defineProperty(exports, "isKeplerGlMap", {
+  enumerable: true,
+  get: function get() {
+    return _fileHandler.isKeplerGlMap;
+  }
+});
+Object.defineProperty(exports, "readBatch", {
+  enumerable: true,
+  get: function get() {
+    return _fileHandler.readBatch;
+  }
+});
+
+var _dataProcessor = require("./data-processor");
+
+var _fileHandler = require("./file-handler");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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