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

package/dist/utils/gl-utils.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setLayerBlending = setLayerBlending;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _core = require("@luma.gl/core");
+
+var _defaultSettings = require("../constants/default-settings");
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+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 getGlConst = function getGlConst(d) {
+  return _constants["default"][d];
+};
+
+function setLayerBlending(gl, layerBlending) {
+  var blending = _defaultSettings.LAYER_BLENDINGS[layerBlending];
+  var blendFunc = blending.blendFunc,
+      blendEquation = blending.blendEquation;
+  (0, _core.setParameters)(gl, _objectSpread((0, _defineProperty2["default"])({}, _constants["default"].BLEND, true), blendFunc ? {
+    blendFunc: blendFunc.map(getGlConst),
+    blendEquation: Array.isArray(blendEquation) ? blendEquation.map(getGlConst) : getGlConst(blendEquation)
+  } : {}));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/gpu-filter-utils.js

@@ -0,0 +1,261 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setFilterGpuMode = setFilterGpuMode;
+exports.assignGpuChannels = assignGpuChannels;
+exports.assignGpuChannel = assignGpuChannel;
+exports.resetFilterGpuMode = resetFilterGpuMode;
+exports.getGpuFilterProps = getGpuFilterProps;
+exports.getDatasetFieldIndexForFilter = getDatasetFieldIndexForFilter;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _utils = require("./utils");
+
+var _defaultSettings = require("../constants/default-settings");
+
+var _dataUtils = require("./data-utils");
+
+var _moment = _interopRequireDefault(require("moment"));
+
+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; }
+
+/**
+ * Set gpu mode based on current number of gpu filters exists
+ * @type {typeof import('./gpu-filter-utils').setFilterGpuMode}
+ */
+function setFilterGpuMode(filter, filters) {
+  // filter can be applied to multiple datasets, hence gpu filter mode should also be
+  // an array, however, to keep us sane, for now, we only check if there is available channel for every dataId,
+  // if all of them has, we set gpu mode to true
+  // TODO: refactor filter so we don't keep an array of everything
+  filter.dataId.forEach(function (dataId, datasetIdx) {
+    var gpuFilters = filters.filter(function (f) {
+      return f.dataId.includes(dataId) && f.gpu;
+    });
+
+    if (filter.gpu && gpuFilters.length === _defaultSettings.MAX_GPU_FILTERS) {
+      return (0, _utils.set)(['gpu'], false, filter);
+    }
+  });
+  return filter;
+}
+/**
+ * Scan though all filters and assign gpu chanel to gpu filter
+ * @type {typeof import('./gpu-filter-utils').assignGpuChannels}
+ */
+
+
+function assignGpuChannels(allFilters) {
+  return allFilters.reduce(function (accu, f, index) {
+    var filters = accu; // if gpu is true assign and validate gpu Channel
+
+    if (f.gpu) {
+      f = assignGpuChannel(f, accu);
+      filters = (0, _utils.set)([index], f, accu);
+    }
+
+    return filters;
+  }, allFilters);
+}
+/**
+ * Assign a new gpu filter a channel based on first availability
+ * @type {typeof import('./gpu-filter-utils').assignGpuChannel}
+ */
+
+
+function assignGpuChannel(filter, filters) {
+  // find first available channel
+  if (!filter.gpu) {
+    return filter;
+  }
+
+  var gpuChannel = filter.gpuChannel || [];
+  filter.dataId.forEach(function (dataId, datasetIdx) {
+    var findGpuChannel = function findGpuChannel(channel) {
+      return function (f) {
+        var dataIdx = (0, _utils.toArray)(f.dataId).indexOf(dataId);
+        return f.id !== filter.id && dataIdx > -1 && f.gpu && (0, _utils.toArray)(f.gpuChannel)[dataIdx] === channel;
+      };
+    };
+
+    if (Number.isFinite(gpuChannel[datasetIdx]) && !filters.find(findGpuChannel(gpuChannel[datasetIdx]))) {
+      // if value is already assigned and valid
+      return;
+    }
+
+    var i = 0;
+
+    while (i < _defaultSettings.MAX_GPU_FILTERS) {
+      if (!filters.find(findGpuChannel(i))) {
+        gpuChannel[datasetIdx] = i;
+        return;
+      }
+
+      i++;
+    }
+  }); // if cannot find channel for all dataid, set gpu back to false
+  // TODO: refactor filter to handle same filter different gpu mode
+
+  if (!gpuChannel.length || !gpuChannel.every(Number.isFinite)) {
+    return _objectSpread(_objectSpread({}, filter), {}, {
+      gpu: false
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, filter), {}, {
+    gpuChannel: gpuChannel
+  });
+}
+/**
+ * Edit filter.gpu to ensure that only
+ * X number of gpu filers can coexist.
+ * @type {typeof import('./gpu-filter-utils').resetFilterGpuMode}
+ */
+
+
+function resetFilterGpuMode(filters) {
+  var gpuPerDataset = {};
+  return filters.map(function (f, i) {
+    if (f.gpu) {
+      var gpu = true;
+      (0, _utils.toArray)(f.dataId).forEach(function (dataId) {
+        var count = gpuPerDataset[dataId];
+
+        if (count === _defaultSettings.MAX_GPU_FILTERS) {
+          gpu = false;
+        } else {
+          gpuPerDataset[dataId] = count ? count + 1 : 1;
+        }
+      });
+
+      if (!gpu) {
+        return (0, _utils.set)(['gpu'], false, f);
+      }
+    }
+
+    return f;
+  });
+}
+/**
+ * Initial filter uniform
+ * @returns {Array<Array<Number>>}
+ */
+
+
+function getEmptyFilterRange() {
+  return new Array(_defaultSettings.MAX_GPU_FILTERS).fill(0).map(function (d) {
+    return [0, 0];
+  });
+}
+/**
+ * Returns index of the data element.
+ * @param {any} d Data element with row index info.
+ * @returns number
+ */
+
+
+var defaultGetIndex = function defaultGetIndex(d) {
+  return d.index;
+};
+/**
+ * Returns value at the specified row from the data container.
+ * @param {import('./table-utils/data-container-interface').DataContainerInterface} dc Data container.
+ * @param {any} d Data element with row index info.
+ * @param {number} fieldIndex Column index in the data container.
+ * @returns
+ */
+
+
+var defaultGetData = function defaultGetData(dc, d, fieldIndex) {
+  return dc.valueAt(d.index, fieldIndex);
+};
+/**
+ * @param {Array<Object>} channels
+ * @param {string} dataId
+ * @param {Array<Object>} fields
+ * @return {Function} getFilterValue
+ */
+
+
+var getFilterValueAccessor = function getFilterValueAccessor(channels, dataId, fields) {
+  return function (dc) {
+    return function () {
+      var getIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultGetIndex;
+      var getData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultGetData;
+      return function (d) {
+        return (// for empty channel, value is 0 and min max would be [0, 0]
+          channels.map(function (filter) {
+            if (!filter) {
+              return 0;
+            }
+
+            var fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);
+            var field = fields[fieldIndex];
+            var value = filter.type === _defaultSettings.FILTER_TYPES.timeRange ? field.filterProps && Array.isArray(field.filterProps.mappedValue) ? field.filterProps.mappedValue[getIndex(d)] : _moment["default"].utc(getData(dc, d, fieldIndex)).valueOf() : getData(dc, d, fieldIndex);
+            return (0, _dataUtils.notNullorUndefined)(value) ? value - filter.domain[0] : Number.MIN_SAFE_INTEGER;
+          })
+        );
+      };
+    };
+  };
+};
+/**
+ * Get filter properties for gpu filtering
+ * @type {typeof import('./gpu-filter-utils').getGpuFilterProps}
+ */
+
+
+function getGpuFilterProps(filters, dataId, fields) {
+  var filterRange = getEmptyFilterRange();
+  var triggers = {}; // array of filter for each channel, undefined, if no filter is assigned to that channel
+
+  var channels = [];
+
+  var _loop = function _loop(i) {
+    var filter = filters.find(function (f) {
+      return f.gpu && f.dataId.includes(dataId) && f.gpuChannel && f.gpuChannel[f.dataId.indexOf(dataId)] === i;
+    }); // @ts-ignore
+
+    filterRange[i][0] = filter ? filter.value[0] - filter.domain[0] : 0; // @ts-ignore
+
+    filterRange[i][1] = filter ? filter.value[1] - filter.domain[0] : 0;
+    triggers["gpuFilter_".concat(i)] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;
+    channels.push(filter);
+  };
+
+  for (var i = 0; i < _defaultSettings.MAX_GPU_FILTERS; i++) {
+    _loop(i);
+  }
+
+  var filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);
+  return {
+    filterRange: filterRange,
+    filterValueUpdateTriggers: triggers,
+    filterValueAccessor: filterValueAccessor
+  };
+}
+/**
+ * Return dataset field index from filter.fieldIdx
+ * The index matches the same dataset index for filter.dataId
+ * @type {typeof import('./gpu-filter-utils').getDatasetFieldIndexForFilter}
+ */
+
+
+function getDatasetFieldIndexForFilter(dataId, filter) {
+  var datasetIndex = (0, _utils.toArray)(filter.dataId).indexOf(dataId);
+
+  if (datasetIndex < 0) {
+    return -1;
+  }
+
+  var fieldIndex = filter.fieldIdx[datasetIndex];
+  return (0, _dataUtils.notNullorUndefined)(fieldIndex) ? fieldIndex : -1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utils/gpu-filter-utils.js"],"names":["setFilterGpuMode","filter","filters","dataId","forEach","datasetIdx","gpuFilters","f","includes","gpu","length","MAX_GPU_FILTERS","assignGpuChannels","allFilters","reduce","accu","index","assignGpuChannel","gpuChannel","findGpuChannel","channel","dataIdx","indexOf","id","Number","isFinite","find","i","every","resetFilterGpuMode","gpuPerDataset","map","count","getEmptyFilterRange","Array","fill","d","defaultGetIndex","defaultGetData","dc","fieldIndex","valueAt","getFilterValueAccessor","channels","fields","getIndex","getData","getDatasetFieldIndexForFilter","field","value","type","FILTER_TYPES","timeRange","filterProps","isArray","mappedValue","moment","utc","valueOf","domain","MIN_SAFE_INTEGER","getGpuFilterProps","filterRange","triggers","name","push","filterValueAccessor","filterValueUpdateTriggers","datasetIndex","fieldIdx"],"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 {set, toArray} from './utils';\nimport {MAX_GPU_FILTERS, FILTER_TYPES} from 'constants/default-settings';\nimport {notNullorUndefined} from './data-utils';\nimport moment from 'moment';\n\n/**\n * Set gpu mode based on current number of gpu filters exists\n * @type {typeof import('./gpu-filter-utils').setFilterGpuMode}\n */\nexport function setFilterGpuMode(filter, filters) {\n  // filter can be applied to multiple datasets, hence gpu filter mode should also be\n  // an array, however, to keep us sane, for now, we only check if there is available channel for every dataId,\n  // if all of them has, we set gpu mode to true\n  // TODO: refactor filter so we don't keep an array of everything\n\n  filter.dataId.forEach((dataId, datasetIdx) => {\n    const gpuFilters = filters.filter(f => f.dataId.includes(dataId) && f.gpu);\n\n    if (filter.gpu && gpuFilters.length === MAX_GPU_FILTERS) {\n      return set(['gpu'], false, filter);\n    }\n  });\n\n  return filter;\n}\n\n/**\n * Scan though all filters and assign gpu chanel to gpu filter\n * @type {typeof import('./gpu-filter-utils').assignGpuChannels}\n */\nexport function assignGpuChannels(allFilters) {\n  return allFilters.reduce((accu, f, index) => {\n    let filters = accu;\n\n    // if gpu is true assign and validate gpu Channel\n    if (f.gpu) {\n      f = assignGpuChannel(f, accu);\n      filters = set([index], f, accu);\n    }\n\n    return filters;\n  }, allFilters);\n}\n/**\n * Assign a new gpu filter a channel based on first availability\n * @type {typeof import('./gpu-filter-utils').assignGpuChannel}\n */\nexport function assignGpuChannel(filter, filters) {\n  // find first available channel\n  if (!filter.gpu) {\n    return filter;\n  }\n\n  const gpuChannel = filter.gpuChannel || [];\n\n  filter.dataId.forEach((dataId, datasetIdx) => {\n    const findGpuChannel = channel => f => {\n      const dataIdx = toArray(f.dataId).indexOf(dataId);\n      return (\n        f.id !== filter.id && dataIdx > -1 && f.gpu && toArray(f.gpuChannel)[dataIdx] === channel\n      );\n    };\n\n    if (\n      Number.isFinite(gpuChannel[datasetIdx]) &&\n      !filters.find(findGpuChannel(gpuChannel[datasetIdx]))\n    ) {\n      // if value is already assigned and valid\n      return;\n    }\n\n    let i = 0;\n\n    while (i < MAX_GPU_FILTERS) {\n      if (!filters.find(findGpuChannel(i))) {\n        gpuChannel[datasetIdx] = i;\n        return;\n      }\n      i++;\n    }\n  });\n\n  // if cannot find channel for all dataid, set gpu back to false\n  // TODO: refactor filter to handle same filter different gpu mode\n  if (!gpuChannel.length || !gpuChannel.every(Number.isFinite)) {\n    return {\n      ...filter,\n      gpu: false\n    };\n  }\n\n  return {\n    ...filter,\n    gpuChannel\n  };\n}\n/**\n * Edit filter.gpu to ensure that only\n * X number of gpu filers can coexist.\n * @type {typeof import('./gpu-filter-utils').resetFilterGpuMode}\n */\nexport function resetFilterGpuMode(filters) {\n  const gpuPerDataset = {};\n\n  return filters.map((f, i) => {\n    if (f.gpu) {\n      let gpu = true;\n      toArray(f.dataId).forEach(dataId => {\n        const count = gpuPerDataset[dataId];\n\n        if (count === MAX_GPU_FILTERS) {\n          gpu = false;\n        } else {\n          gpuPerDataset[dataId] = count ? count + 1 : 1;\n        }\n      });\n\n      if (!gpu) {\n        return set(['gpu'], false, f);\n      }\n    }\n\n    return f;\n  });\n}\n\n/**\n * Initial filter uniform\n * @returns {Array<Array<Number>>}\n */\nfunction getEmptyFilterRange() {\n  return new Array(MAX_GPU_FILTERS).fill(0).map(d => [0, 0]);\n}\n\n/**\n * Returns index of the data element.\n * @param {any} d Data element with row index info.\n * @returns number\n */\nconst defaultGetIndex = d => d.index;\n\n/**\n * Returns value at the specified row from the data container.\n * @param {import('./table-utils/data-container-interface').DataContainerInterface} dc Data container.\n * @param {any} d Data element with row index info.\n * @param {number} fieldIndex Column index in the data container.\n * @returns\n */\nconst defaultGetData = (dc, d, fieldIndex) => {\n  return dc.valueAt(d.index, fieldIndex);\n};\n\n/**\n * @param {Array<Object>} channels\n * @param {string} dataId\n * @param {Array<Object>} fields\n * @return {Function} getFilterValue\n */\nconst getFilterValueAccessor = (channels, dataId, fields) => dc => (\n  getIndex = defaultGetIndex,\n  getData = defaultGetData\n) => d =>\n  // for empty channel, value is 0 and min max would be [0, 0]\n  channels.map(filter => {\n    if (!filter) {\n      return 0;\n    }\n    const fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);\n    const field = fields[fieldIndex];\n\n    const value =\n      filter.type === FILTER_TYPES.timeRange\n        ? field.filterProps && Array.isArray(field.filterProps.mappedValue)\n          ? field.filterProps.mappedValue[getIndex(d)]\n          : moment.utc(getData(dc, d, fieldIndex)).valueOf()\n        : getData(dc, d, fieldIndex);\n\n    return notNullorUndefined(value) ? value - filter.domain[0] : Number.MIN_SAFE_INTEGER;\n  });\n\n/**\n * Get filter properties for gpu filtering\n * @type {typeof import('./gpu-filter-utils').getGpuFilterProps}\n */\nexport function getGpuFilterProps(filters, dataId, fields) {\n  const filterRange = getEmptyFilterRange();\n  const triggers = {};\n\n  // array of filter for each channel, undefined, if no filter is assigned to that channel\n  const channels = [];\n\n  for (let i = 0; i < MAX_GPU_FILTERS; i++) {\n    const filter = filters.find(\n      f =>\n        f.gpu &&\n        f.dataId.includes(dataId) &&\n        f.gpuChannel &&\n        f.gpuChannel[f.dataId.indexOf(dataId)] === i\n    );\n\n    // @ts-ignore\n    filterRange[i][0] = filter ? filter.value[0] - filter.domain[0] : 0;\n    // @ts-ignore\n    filterRange[i][1] = filter ? filter.value[1] - filter.domain[0] : 0;\n\n    triggers[`gpuFilter_${i}`] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;\n    channels.push(filter);\n  }\n\n  const filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);\n\n  return {\n    filterRange,\n    filterValueUpdateTriggers: triggers,\n    filterValueAccessor\n  };\n}\n\n/**\n * Return dataset field index from filter.fieldIdx\n * The index matches the same dataset index for filter.dataId\n * @type {typeof import('./gpu-filter-utils').getDatasetFieldIndexForFilter}\n */\nexport function getDatasetFieldIndexForFilter(dataId, filter) {\n  const datasetIndex = toArray(filter.dataId).indexOf(dataId);\n  if (datasetIndex < 0) {\n    return -1;\n  }\n\n  const fieldIndex = filter.fieldIdx[datasetIndex];\n\n  return notNullorUndefined(fieldIndex) ? fieldIndex : -1;\n}\n"]}

package/dist/utils/index.js

@@ -0,0 +1,226 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "maybeToDate", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.maybeToDate;
+  }
+});
+Object.defineProperty(exports, "roundValToStep", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.roundValToStep;
+  }
+});
+Object.defineProperty(exports, "timeToUnixMilli", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.timeToUnixMilli;
+  }
+});
+Object.defineProperty(exports, "defaultFormatter", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.defaultFormatter;
+  }
+});
+Object.defineProperty(exports, "FIELD_DISPLAY_FORMAT", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.FIELD_DISPLAY_FORMAT;
+  }
+});
+Object.defineProperty(exports, "createNewDataEntry", {
+  enumerable: true,
+  get: function get() {
+    return _datasetUtils.createNewDataEntry;
+  }
+});
+Object.defineProperty(exports, "datasetColorMaker", {
+  enumerable: true,
+  get: function get() {
+    return _datasetUtils.datasetColorMaker;
+  }
+});
+Object.defineProperty(exports, "findDefaultColorField", {
+  enumerable: true,
+  get: function get() {
+    return _datasetUtils.findDefaultColorField;
+  }
+});
+Object.defineProperty(exports, "hexToRgb", {
+  enumerable: true,
+  get: function get() {
+    return _colorUtils.hexToRgb;
+  }
+});
+Object.defineProperty(exports, "errorNotification", {
+  enumerable: true,
+  get: function get() {
+    return _notificationsUtils.errorNotification;
+  }
+});
+Object.defineProperty(exports, "dataURItoBlob", {
+  enumerable: true,
+  get: function get() {
+    return _exportUtils.dataURItoBlob;
+  }
+});
+Object.defineProperty(exports, "downloadFile", {
+  enumerable: true,
+  get: function get() {
+    return _exportUtils.downloadFile;
+  }
+});
+Object.defineProperty(exports, "calculateLayerData", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.calculateLayerData;
+  }
+});
+Object.defineProperty(exports, "prepareLayersToRender", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.prepareLayersToRender;
+  }
+});
+Object.defineProperty(exports, "prepareLayersForDeck", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.prepareLayersForDeck;
+  }
+});
+Object.defineProperty(exports, "negateAccessor", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.negateAccessor;
+  }
+});
+Object.defineProperty(exports, "applyFilterFieldName", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.applyFilterFieldName;
+  }
+});
+Object.defineProperty(exports, "applyFiltersToDatasets", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.applyFiltersToDatasets;
+  }
+});
+Object.defineProperty(exports, "validateFilterWithData", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.validateFilterWithData;
+  }
+});
+Object.defineProperty(exports, "validateFiltersUpdateDatasets", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.validateFiltersUpdateDatasets;
+  }
+});
+Object.defineProperty(exports, "getIntervalBins", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.getIntervalBins;
+  }
+});
+Object.defineProperty(exports, "getNumericStepSize", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.getNumericStepSize;
+  }
+});
+Object.defineProperty(exports, "formatNumberByStep", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.formatNumberByStep;
+  }
+});
+Object.defineProperty(exports, "resetFilterGpuMode", {
+  enumerable: true,
+  get: function get() {
+    return _gpuFilterUtils.resetFilterGpuMode;
+  }
+});
+Object.defineProperty(exports, "assignGpuChannels", {
+  enumerable: true,
+  get: function get() {
+    return _gpuFilterUtils.assignGpuChannels;
+  }
+});
+Object.defineProperty(exports, "updateAllLayerDomainData", {
+  enumerable: true,
+  get: function get() {
+    return _visStateUpdaters.updateAllLayerDomainData;
+  }
+});
+Object.defineProperty(exports, "getHexFields", {
+  enumerable: true,
+  get: function get() {
+    return _h3Utils.getHexFields;
+  }
+});
+Object.defineProperty(exports, "containValidTime", {
+  enumerable: true,
+  get: function get() {
+    return _tripUtils.containValidTime;
+  }
+});
+Object.defineProperty(exports, "KeplerTable", {
+  enumerable: true,
+  get: function get() {
+    return _keplerTable["default"];
+  }
+});
+Object.defineProperty(exports, "findPointFieldPairs", {
+  enumerable: true,
+  get: function get() {
+    return _keplerTable.findPointFieldPairs;
+  }
+});
+Object.defineProperty(exports, "createDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createDataContainer;
+  }
+});
+Object.defineProperty(exports, "createIndexedDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createIndexedDataContainer;
+  }
+});
+
+var _dataUtils = require("./data-utils");
+
+var _datasetUtils = require("./dataset-utils");
+
+var _colorUtils = require("./color-utils");
+
+var _notificationsUtils = require("./notifications-utils");
+
+var _exportUtils = require("./export-utils");
+
+var _layerUtils = require("./layer-utils");
+
+var _filterUtils = require("./filter-utils");
+
+var _gpuFilterUtils = require("./gpu-filter-utils");
+
+var _visStateUpdaters = require("../reducers/vis-state-updaters");
+
+var _h3Utils = require("../layers/h3-hexagon-layer/h3-utils");
+
+var _tripUtils = require("../layers/trip-layer/trip-utils");
+
+var _keplerTable = _interopRequireWildcard(require("./table-utils/kepler-table"));
+
+var _dataContainerUtils = require("./table-utils/data-container-utils");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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