@carto/kepler.gl 0.0.85 → 0.0.86-alpha.deck9.1

package/dist/utils/table-utils/kepler-table.js

@@ -6,15 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.copyTable = copyTable;
 exports.copyTableAndUpdate = copyTableAndUpdate;
-exports["default"] = void 0;
+exports.default = void 0;
 exports.findPointFieldPairs = findPointFieldPairs;
 exports.pinTableColumns = pinTableColumns;
 exports.removeSuffixAndDelimiters = removeSuffixAndDelimiters;
 exports.sortDatasetByColumn = sortDatasetByColumn;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _console = require("global/console");
 var _defaultSettings = require("../../constants/default-settings");
 var _d3Array = require("d3-array");
@@ -25,11 +22,7 @@ var _dataUtils = require("../data-utils");
 var _dataScaleUtils = require("../data-scale-utils");
 var _dataContainerUtils = require("./data-container-utils");
 var _colorUtils = require("../color-utils");
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // Copyright (c) 2022 Uber Technologies, Inc.
+// Copyright (c) 2022 Uber Technologies, Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -48,24 +41,43 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
+
 // import {validateInputData} from 'processors/data-processor';
+
 // Unique identifier of each field
-var FID_KEY = 'name';
-var KeplerTable = /*#__PURE__*/function () {
-  // fields and data
-
-  // table-injected metadata
-
-  // table-injected metadata
-
-  function KeplerTable(_ref) {
-    var _ref$info = _ref.info,
-      info = _ref$info === void 0 ? {} : _ref$info,
-      data = _ref.data,
-      color = _ref.color,
-      metadata = _ref.metadata,
-      supportedFilterTypes = _ref.supportedFilterTypes;
-    (0, _classCallCheck2["default"])(this, KeplerTable);
+const FID_KEY = 'name';
+class KeplerTable {
+  constructor(_ref) {
+    let {
+      info = {},
+      data,
+      color,
+      metadata,
+      supportedFilterTypes
+    } = _ref;
+    (0, _defineProperty2.default)(this, "id", void 0);
+    (0, _defineProperty2.default)(this, "type", void 0);
+    (0, _defineProperty2.default)(this, "label", void 0);
+    (0, _defineProperty2.default)(this, "color", void 0);
+    // fields and data
+    (0, _defineProperty2.default)(this, "fields", void 0);
+    (0, _defineProperty2.default)(this, "dataContainer", void 0);
+    (0, _defineProperty2.default)(this, "allIndexes", void 0);
+    (0, _defineProperty2.default)(this, "filteredIndex", void 0);
+    (0, _defineProperty2.default)(this, "filteredIdxCPU", void 0);
+    (0, _defineProperty2.default)(this, "filteredIndexForDomain", void 0);
+    (0, _defineProperty2.default)(this, "fieldPairs", void 0);
+    (0, _defineProperty2.default)(this, "gpuFilter", void 0);
+    (0, _defineProperty2.default)(this, "filterRecord", void 0);
+    (0, _defineProperty2.default)(this, "filterRecordCPU", void 0);
+    (0, _defineProperty2.default)(this, "changedFilters", void 0);
+    // table-injected metadata
+    (0, _defineProperty2.default)(this, "sortColumn", void 0);
+    (0, _defineProperty2.default)(this, "sortOrder", void 0);
+    (0, _defineProperty2.default)(this, "pinnedColumns", void 0);
+    (0, _defineProperty2.default)(this, "supportedFilterTypes", void 0);
+    // table-injected metadata
+    (0, _defineProperty2.default)(this, "metadata", void 0);
     // TODO - what to do if validation fails? Can kepler handle exceptions?
     // const validatedData = validateInputData(data);
     // if (!validatedData) {
@@ -73,33 +85,34 @@ var KeplerTable = /*#__PURE__*/function () {
     // }
 
     // @ts-expect-error
-    var dataContainer = (0, _dataContainerUtils.createDataContainer)(data.rows, {
+    const dataContainer = (0, _dataContainerUtils.createDataContainer)(data.rows, {
       fields: data.fields
     });
-    var datasetInfo = _objectSpread({
+    const datasetInfo = {
       id: (0, _utils.generateHashId)(4),
-      label: 'new dataset'
-    }, info || {});
-    var dataId = datasetInfo.id;
+      label: 'new dataset',
+      ...(info || {})
+    };
+    const dataId = datasetInfo.id;
     // @ts-expect-error
-    var fields = data.fields.map(function (f, i) {
-      return _objectSpread(_objectSpread({}, f), {}, {
-        fieldIdx: i,
-        id: f.name,
-        displayName: f.displayName || f.name,
-        valueAccessor: _dataUtils.maybeToDate.bind(null,
-        // is time
-        f.type === _defaultSettings.ALL_FIELD_TYPES.timestamp || f.type === _defaultSettings.ALL_FIELD_TYPES.date, i, f.format, dataContainer)
-      });
-    });
-    var allIndexes = dataContainer.getPlainIndex();
+    const fields = data.fields.map((f, i) => ({
+      ...f,
+      fieldIdx: i,
+      id: f.name,
+      displayName: f.displayName || f.name,
+      valueAccessor: _dataUtils.maybeToDate.bind(null,
+      // is time
+      f.type === _defaultSettings.ALL_FIELD_TYPES.timestamp || f.type === _defaultSettings.ALL_FIELD_TYPES.date, i, f.format, dataContainer)
+    }));
+    const allIndexes = dataContainer.getPlainIndex();
     this.id = datasetInfo.id;
     this.label = datasetInfo.label;
     this.color = color;
-    this.metadata = _objectSpread(_objectSpread({}, metadata), {}, {
+    this.metadata = {
+      ...metadata,
       id: datasetInfo.id,
       label: datasetInfo.label
-    });
+    };
     this.dataContainer = dataContainer;
     this.allIndexes = allIndexes;
     this.filteredIndex = allIndexes;
@@ -116,298 +129,283 @@ var KeplerTable = /*#__PURE__*/function () {
    * Get field
    * @param columnName
    */
-  return (0, _createClass2["default"])(KeplerTable, [{
-    key: "getColumnField",
-    value: function getColumnField(columnName) {
-      var field = this.fields.find(function (fd) {
-        return fd[FID_KEY] === columnName;
-      });
-      this._assetField(columnName, field);
-      return field;
-    }
+  getColumnField(columnName) {
+    const field = this.fields.find(fd => fd[FID_KEY] === columnName);
+    this._assetField(columnName, field);
+    return field;
+  }
 
-    /**
-     * Get fieldIdx
-     * @param columnName
-     */
-  }, {
-    key: "getColumnFieldIdx",
-    value: function getColumnFieldIdx(columnName) {
-      var fieldIdx = this.fields.findIndex(function (fd) {
-        return fd[FID_KEY] === columnName;
-      });
-      this._assetField(columnName, Boolean(fieldIdx > -1));
-      return fieldIdx;
-    }
+  /**
+   * Get fieldIdx
+   * @param columnName
+   */
+  getColumnFieldIdx(columnName) {
+    const fieldIdx = this.fields.findIndex(fd => fd[FID_KEY] === columnName);
+    this._assetField(columnName, Boolean(fieldIdx > -1));
+    return fieldIdx;
+  }
 
-    /**
-     * Get the value of a cell
-     */
-  }, {
-    key: "getValue",
-    value: function getValue(columnName, rowIdx) {
-      var field = this.getColumnField(columnName);
-      return field ? field.valueAccessor({
-        index: rowIdx
-      }) : null;
-    }
+  /**
+   * Get the value of a cell
+   */
+  getValue(columnName, rowIdx) {
+    const field = this.getColumnField(columnName);
+    return field ? field.valueAccessor({
+      index: rowIdx
+    }) : null;
+  }
 
-    /**
-     * Updates existing field with a new object
-     * @param fieldIdx
-     * @param newField
-     */
-  }, {
-    key: "updateColumnField",
-    value: function updateColumnField(fieldIdx, newField) {
-      this.fields = Object.assign((0, _toConsumableArray2["default"])(this.fields), (0, _defineProperty2["default"])({}, fieldIdx, newField));
-    }
+  /**
+   * Updates existing field with a new object
+   * @param fieldIdx
+   * @param newField
+   */
+  updateColumnField(fieldIdx, newField) {
+    this.fields = Object.assign([...this.fields], {
+      [fieldIdx]: newField
+    });
+  }
 
-    /**
-     * Update dataset color by custom color
-     * @param newColor
-     */
-  }, {
-    key: "updateTableColor",
-    value: function updateTableColor(newColor) {
-      this.color = newColor;
-    }
+  /**
+   * Update dataset color by custom color
+   * @param newColor
+   */
+  updateTableColor(newColor) {
+    this.color = newColor;
+  }
 
-    /**
-     * Save filterProps to field and retrieve it
-     * @param columnName
-     */
-  }, {
-    key: "getColumnFilterProps",
-    value: function getColumnFilterProps(columnName) {
-      var fieldIdx = this.getColumnFieldIdx(columnName);
-      if (fieldIdx < 0) {
-        return null;
-      }
-      var field = this.fields[fieldIdx];
-      if (field.hasOwnProperty('filterProps')) {
-        return field.filterProps;
-      }
-      var fieldDomain = this.getColumnFilterDomain(field);
-      if (!fieldDomain) {
-        return null;
-      }
-      var filterProps = (0, _filterUtils.getFilterProps)(field, fieldDomain);
-      var newField = _objectSpread(_objectSpread({}, field), {}, {
-        filterProps: filterProps
-      });
-      this.updateColumnField(fieldIdx, newField);
-      return filterProps;
+  /**
+   * Save filterProps to field and retrieve it
+   * @param columnName
+   */
+  getColumnFilterProps(columnName) {
+    const fieldIdx = this.getColumnFieldIdx(columnName);
+    if (fieldIdx < 0) {
+      return null;
+    }
+    const field = this.fields[fieldIdx];
+    if (field.hasOwnProperty('filterProps')) {
+      return field.filterProps;
+    }
+    const fieldDomain = this.getColumnFilterDomain(field);
+    if (!fieldDomain) {
+      return null;
     }
+    const filterProps = (0, _filterUtils.getFilterProps)(field, fieldDomain);
+    const newField = {
+      ...field,
+      filterProps
+    };
+    this.updateColumnField(fieldIdx, newField);
+    return filterProps;
+  }
 
-    /**
-     * Apply filters to dataset, return the filtered dataset with updated `gpuFilter`, `filterRecord`, `filteredIndex`, `filteredIndexForDomain`
-     * @param filters
-     * @param layers
-     * @param opt
-     */
-  }, {
-    key: "filterTable",
-    value: function filterTable(filters, layers, opt) {
-      var _this = this;
-      var dataContainer = this.dataContainer,
-        dataId = this.id,
-        oldFilterRecord = this.filterRecord,
-        fields = this.fields;
-
-      // if there is no filters
-      var filterRecord = (0, _filterUtils.getFilterRecord)(dataId, filters, opt || {});
-      this.filterRecord = filterRecord;
-      this.gpuFilter = (0, _gpuFilterUtils.getGpuFilterProps)(filters, dataId, fields);
-
-      // const newDataset = set(['filterRecord'], filterRecord, dataset);
-
-      if (!filters.length) {
-        this.filteredIndex = this.allIndexes;
-        this.filteredIndexForDomain = this.allIndexes;
-        return this;
-      }
-      this.changedFilters = (0, _filterUtils.diffFilters)(filterRecord, oldFilterRecord);
-
-      // generate 2 sets of filter result
-      // filteredIndex used to calculate layer data
-      // filteredIndexForDomain used to calculate layer Domain
-      var shouldCalDomain = Boolean(this.changedFilters.dynamicDomain);
-      var shouldCalIndex = Boolean(this.changedFilters.cpu);
-      var filterResult = {};
-      if (shouldCalDomain || shouldCalIndex) {
-        var dynamicDomainFilters = shouldCalDomain ? filterRecord.dynamicDomain : null;
-        var cpuFilters = shouldCalIndex ? filterRecord.cpu : null;
-        var filterFuncs = filters.reduce(function (acc, filter) {
-          var fieldIndex = (0, _gpuFilterUtils.getDatasetFieldIndexForFilter)(_this.id, filter);
-          var field = fieldIndex !== -1 ? fields[fieldIndex] : null;
-          return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, filter.id, (0, _filterUtils.getFilterFunction)(field, _this.id, filter, layers, dataContainer)));
-        }, {});
-        filterResult = (0, _filterUtils.filterDataByFilterTypes)({
-          dynamicDomainFilters: dynamicDomainFilters,
-          cpuFilters: cpuFilters,
-          filterFuncs: filterFuncs
-        }, dataContainer);
-      }
-      this.filteredIndex = filterResult.filteredIndex || this.filteredIndex;
-      this.filteredIndexForDomain = filterResult.filteredIndexForDomain || this.filteredIndexForDomain;
+  /**
+   * Apply filters to dataset, return the filtered dataset with updated `gpuFilter`, `filterRecord`, `filteredIndex`, `filteredIndexForDomain`
+   * @param filters
+   * @param layers
+   * @param opt
+   */
+  filterTable(filters, layers, opt) {
+    const {
+      dataContainer,
+      id: dataId,
+      filterRecord: oldFilterRecord,
+      fields
+    } = this;
+
+    // if there is no filters
+    const filterRecord = (0, _filterUtils.getFilterRecord)(dataId, filters, opt || {});
+    this.filterRecord = filterRecord;
+    this.gpuFilter = (0, _gpuFilterUtils.getGpuFilterProps)(filters, dataId, fields);
+
+    // const newDataset = set(['filterRecord'], filterRecord, dataset);
+
+    if (!filters.length) {
+      this.filteredIndex = this.allIndexes;
+      this.filteredIndexForDomain = this.allIndexes;
       return this;
     }
+    this.changedFilters = (0, _filterUtils.diffFilters)(filterRecord, oldFilterRecord);
+
+    // generate 2 sets of filter result
+    // filteredIndex used to calculate layer data
+    // filteredIndexForDomain used to calculate layer Domain
+    const shouldCalDomain = Boolean(this.changedFilters.dynamicDomain);
+    const shouldCalIndex = Boolean(this.changedFilters.cpu);
+    let filterResult = {};
+    if (shouldCalDomain || shouldCalIndex) {
+      const dynamicDomainFilters = shouldCalDomain ? filterRecord.dynamicDomain : null;
+      const cpuFilters = shouldCalIndex ? filterRecord.cpu : null;
+      const filterFuncs = filters.reduce((acc, filter) => {
+        const fieldIndex = (0, _gpuFilterUtils.getDatasetFieldIndexForFilter)(this.id, filter);
+        const field = fieldIndex !== -1 ? fields[fieldIndex] : null;
+        return {
+          ...acc,
+          [filter.id]: (0, _filterUtils.getFilterFunction)(field, this.id, filter, layers, dataContainer)
+        };
+      }, {});
+      filterResult = (0, _filterUtils.filterDataByFilterTypes)({
+        dynamicDomainFilters,
+        cpuFilters,
+        filterFuncs
+      }, dataContainer);
+    }
+    this.filteredIndex = filterResult.filteredIndex || this.filteredIndex;
+    this.filteredIndexForDomain = filterResult.filteredIndexForDomain || this.filteredIndexForDomain;
+    return this;
+  }
 
-    /**
-     * Apply filters to a dataset all on CPU, assign to `filteredIdxCPU`, `filterRecordCPU`
-     * @param filters
-     * @param layers
-     */
-  }, {
-    key: "filterTableCPU",
-    value: function filterTableCPU(filters, layers) {
-      var opt = {
-        cpuOnly: true,
-        ignoreDomain: true
-      };
-
-      // no filter
-      if (!filters.length) {
-        this.filteredIdxCPU = this.allIndexes;
-        this.filterRecordCPU = (0, _filterUtils.getFilterRecord)(this.id, filters, opt);
-        return this;
-      }
-
-      // no gpu filter
-      if (!filters.find(function (f) {
-        return f.gpu;
-      })) {
-        this.filteredIdxCPU = this.filteredIndex;
-        this.filterRecordCPU = (0, _filterUtils.getFilterRecord)(this.id, filters, opt);
-        return this;
-      }
-
-      // make a copy for cpu filtering
-      var copied = copyTable(this);
-      copied.filterRecord = this.filterRecordCPU;
-      copied.filteredIndex = this.filteredIdxCPU || [];
-      var filtered = copied.filterTable(filters, layers, opt);
-      this.filteredIdxCPU = filtered.filteredIndex;
-      this.filterRecordCPU = filtered.filterRecord;
+  /**
+   * Apply filters to a dataset all on CPU, assign to `filteredIdxCPU`, `filterRecordCPU`
+   * @param filters
+   * @param layers
+   */
+  filterTableCPU(filters, layers) {
+    const opt = {
+      cpuOnly: true,
+      ignoreDomain: true
+    };
+
+    // no filter
+    if (!filters.length) {
+      this.filteredIdxCPU = this.allIndexes;
+      this.filterRecordCPU = (0, _filterUtils.getFilterRecord)(this.id, filters, opt);
       return this;
     }
 
-    /**
-     * Calculate field domain based on field type and data
-     * for Filter
-     */
-  }, {
-    key: "getColumnFilterDomain",
-    value: function getColumnFilterDomain(field) {
-      var dataContainer = this.dataContainer;
-      var valueAccessor = field.valueAccessor;
-      var domain;
-      switch (field.type) {
-        case _defaultSettings.ALL_FIELD_TYPES.real:
-        case _defaultSettings.ALL_FIELD_TYPES.integer:
-          // calculate domain and step
-          return (0, _filterUtils.getNumericFieldDomain)(dataContainer, valueAccessor);
-        case _defaultSettings.ALL_FIELD_TYPES["boolean"]:
-          return {
-            domain: [true, false]
-          };
-        case _defaultSettings.ALL_FIELD_TYPES.string:
-        case _defaultSettings.ALL_FIELD_TYPES.date:
-          domain = (0, _dataScaleUtils.getOrdinalDomain)(dataContainer, valueAccessor);
-          return {
-            domain: domain
-          };
-        case _defaultSettings.ALL_FIELD_TYPES.timestamp:
-          return (0, _filterUtils.getTimestampFieldDomain)(dataContainer, valueAccessor);
-        default:
-          return {
-            domain: (0, _dataScaleUtils.getOrdinalDomain)(dataContainer, valueAccessor)
-          };
-      }
+    // no gpu filter
+    if (!filters.find(f => f.gpu)) {
+      this.filteredIdxCPU = this.filteredIndex;
+      this.filterRecordCPU = (0, _filterUtils.getFilterRecord)(this.id, filters, opt);
+      return this;
     }
 
-    /**
-     *  Get the domain of this column based on scale type
-     */
-  }, {
-    key: "getColumnLayerDomain",
-    value: function getColumnLayerDomain(field, scaleType) {
-      var dataContainer = this.dataContainer,
-        filteredIndexForDomain = this.filteredIndexForDomain;
-      if (!_defaultSettings.SCALE_TYPES[scaleType]) {
-        _console.console.error("scale type ".concat(scaleType, " not supported"));
-        return null;
-      }
-      var valueAccessor = field.valueAccessor;
-      var indexValueAccessor = function indexValueAccessor(i) {
-        return valueAccessor({
-          index: i
-        });
-      };
-      var sortFunction = (0, _dataUtils.getSortingFunction)(field.type);
-      switch (scaleType) {
-        case _defaultSettings.SCALE_TYPES.ordinal:
-        case _defaultSettings.SCALE_TYPES.point:
-          // do not recalculate ordinal domain based on filtered data
-          // don't need to update ordinal domain every time
-          return (0, _dataScaleUtils.getOrdinalDomain)(dataContainer, valueAccessor);
-        case _defaultSettings.SCALE_TYPES.quantile:
-          return (0, _dataScaleUtils.getQuantileDomain)(filteredIndexForDomain, indexValueAccessor, sortFunction);
-        case _defaultSettings.SCALE_TYPES.log:
-          return (0, _dataScaleUtils.getLogDomain)(filteredIndexForDomain, indexValueAccessor);
-        case _defaultSettings.SCALE_TYPES.quantize:
-        case _defaultSettings.SCALE_TYPES.linear:
-        case _defaultSettings.SCALE_TYPES.sqrt:
-        default:
-          return (0, _dataScaleUtils.getLinearDomain)(filteredIndexForDomain, indexValueAccessor);
-      }
-    }
-  }, {
-    key: "calculateLegend",
-    value: function calculateLegend(leftField, rightField) {
-      var limitOfNumberOfLegendEntries = 20;
-      var leftValues = this.dataContainer.mapIndex(leftField.valueAccessor);
-      var rightValues = this.dataContainer.mapIndex(rightField.valueAccessor);
-      var pairing = leftValues.reduce(function (previous, current, idx) {
-        previous.push([current, rightValues[idx]]);
-        return previous;
-      }, []);
-      return (0, _dataUtils.uniqueSortedPairByFrequency)(pairing).map(function (row) {
+    // make a copy for cpu filtering
+    const copied = copyTable(this);
+    copied.filterRecord = this.filterRecordCPU;
+    copied.filteredIndex = this.filteredIdxCPU || [];
+    const filtered = copied.filterTable(filters, layers, opt);
+    this.filteredIdxCPU = filtered.filteredIndex;
+    this.filterRecordCPU = filtered.filterRecord;
+    return this;
+  }
+
+  /**
+   * Calculate field domain based on field type and data
+   * for Filter
+   */
+  getColumnFilterDomain(field) {
+    const {
+      dataContainer
+    } = this;
+    const {
+      valueAccessor
+    } = field;
+    let domain;
+    switch (field.type) {
+      case _defaultSettings.ALL_FIELD_TYPES.real:
+      case _defaultSettings.ALL_FIELD_TYPES.integer:
+        // calculate domain and step
+        return (0, _filterUtils.getNumericFieldDomain)(dataContainer, valueAccessor);
+      case _defaultSettings.ALL_FIELD_TYPES.boolean:
+        return {
+          domain: [true, false]
+        };
+      case _defaultSettings.ALL_FIELD_TYPES.string:
+      case _defaultSettings.ALL_FIELD_TYPES.date:
+        domain = (0, _dataScaleUtils.getOrdinalDomain)(dataContainer, valueAccessor);
         return {
-          label: row.left,
-          color: (0, _colorUtils.checkColorOrFallback)(row.right)
+          domain
+        };
+      case _defaultSettings.ALL_FIELD_TYPES.timestamp:
+        return (0, _filterUtils.getTimestampFieldDomain)(dataContainer, valueAccessor);
+      default:
+        return {
+          domain: (0, _dataScaleUtils.getOrdinalDomain)(dataContainer, valueAccessor)
         };
-      }).slice(0, limitOfNumberOfLegendEntries + 1); // Limit to limitOfNumberOfLegendEntries + 1, then limit to limitOfNumberOfLegendEntries in LegendManagers
     }
+  }
 
-    /**
-     * Get a sample of rows to calculate layer boundaries
-     */
-    // getSampleData(rows)
-
-    /**
-     * Parse cell value based on column type and return a string representation
-     * Value the field value, type the field type
-     */
-    // parseFieldValue(value, type)
-
-    // sortDatasetByColumn()
-
-    /**
-     * Assert whether field exist
-     * @param fieldName
-     * @param condition
-     */
-  }, {
-    key: "_assetField",
-    value: function _assetField(fieldName, condition) {
-      if (!condition) {
-        _console.console.error("".concat(fieldName, " doesnt exist in dataset ").concat(this.id));
-      }
+  /**
+   *  Get the domain of this column based on scale type
+   */
+  getColumnLayerDomain(field, scaleType) {
+    const {
+      dataContainer,
+      filteredIndexForDomain
+    } = this;
+    if (!_defaultSettings.SCALE_TYPES[scaleType]) {
+      _console.console.error(`scale type ${scaleType} not supported`);
+      return null;
+    }
+    const {
+      valueAccessor
+    } = field;
+    const indexValueAccessor = i => valueAccessor({
+      index: i
+    });
+    const sortFunction = (0, _dataUtils.getSortingFunction)(field.type);
+    switch (scaleType) {
+      case _defaultSettings.SCALE_TYPES.ordinal:
+      case _defaultSettings.SCALE_TYPES.point:
+        // do not recalculate ordinal domain based on filtered data
+        // don't need to update ordinal domain every time
+        return (0, _dataScaleUtils.getOrdinalDomain)(dataContainer, valueAccessor);
+      case _defaultSettings.SCALE_TYPES.quantile:
+        return (0, _dataScaleUtils.getQuantileDomain)(filteredIndexForDomain, indexValueAccessor, sortFunction);
+      case _defaultSettings.SCALE_TYPES.log:
+        return (0, _dataScaleUtils.getLogDomain)(filteredIndexForDomain, indexValueAccessor);
+      case _defaultSettings.SCALE_TYPES.quantize:
+      case _defaultSettings.SCALE_TYPES.linear:
+      case _defaultSettings.SCALE_TYPES.sqrt:
+      default:
+        return (0, _dataScaleUtils.getLinearDomain)(filteredIndexForDomain, indexValueAccessor);
     }
-  }]);
-}(); // HELPER FUNCTIONS (MAINLY EXPORTED FOR TEST...)
+  }
+  calculateLegend(leftField, rightField) {
+    const limitOfNumberOfLegendEntries = 20;
+    const leftValues = this.dataContainer.mapIndex(leftField.valueAccessor);
+    const rightValues = this.dataContainer.mapIndex(rightField.valueAccessor);
+    const pairing = leftValues.reduce((previous, current, idx) => {
+      previous.push([current, rightValues[idx]]);
+      return previous;
+    }, []);
+    return (0, _dataUtils.uniqueSortedPairByFrequency)(pairing).map(row => {
+      return {
+        label: row.left,
+        color: (0, _colorUtils.checkColorOrFallback)(row.right)
+      };
+    }).slice(0, limitOfNumberOfLegendEntries + 1); // Limit to limitOfNumberOfLegendEntries + 1, then limit to limitOfNumberOfLegendEntries in LegendManagers
+  }
+
+  /**
+   * Get a sample of rows to calculate layer boundaries
+   */
+  // getSampleData(rows)
+
+  /**
+   * Parse cell value based on column type and return a string representation
+   * Value the field value, type the field type
+   */
+  // parseFieldValue(value, type)
+
+  // sortDatasetByColumn()
+
+  /**
+   * Assert whether field exist
+   * @param fieldName
+   * @param condition
+   */
+  _assetField(fieldName, condition) {
+    if (!condition) {
+      _console.console.error(`${fieldName} doesnt exist in dataset ${this.id}`);
+    }
+  }
+}
+
+// HELPER FUNCTIONS (MAINLY EXPORTED FOR TEST...)
+
 function removeSuffixAndDelimiters(layerName, suffix) {
   return layerName.replace(new RegExp(suffix, 'ig'), '').replace(/[_,.]+/g, ' ').trim();
 }
@@ -419,64 +417,44 @@ function removeSuffixAndDelimiters(layerName, suffix) {
  * @returns found point fields
  */
 function findPointFieldPairs(fields) {
-  var allNames = fields.map(function (f) {
-    return f.name.toLowerCase();
-  });
+  const allNames = fields.map(f => f.name.toLowerCase());
 
   // get list of all fields with matching suffixes
-  var acc = [];
-  var result = allNames.reduce(function (carry, fieldName, idx) {
+  const acc = [];
+  const result = allNames.reduce((carry, fieldName, idx) => {
     // This search for pairs will early exit if found.
-    var _iterator = _createForOfIteratorHelper(_defaultSettings.TRIP_POINT_FIELDS),
-      _step;
-    try {
-      var _loop = function _loop() {
-          var suffixPair = _step.value;
-          // match first suffix```
-          if (fieldName.endsWith(suffixPair[0])) {
-            // match second suffix
-            var otherPattern = new RegExp("".concat(suffixPair[0], "$"));
-            var partner = fieldName.replace(otherPattern, suffixPair[1]);
-            var partnerIdx = allNames.findIndex(function (d) {
-              return d === partner;
-            });
-            if (partnerIdx > -1) {
-              var defaultName = removeSuffixAndDelimiters(fieldName, suffixPair[0]);
-              carry.push({
-                defaultName: defaultName,
-                pair: {
-                  lat: {
-                    fieldIdx: idx,
-                    value: fields[idx].name
-                  },
-                  lng: {
-                    fieldIdx: partnerIdx,
-                    value: fields[partnerIdx].name
-                  }
-                },
-                suffix: suffixPair
-              });
-              return {
-                v: carry
-              };
-            }
-          }
-        },
-        _ret;
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        _ret = _loop();
-        if (_ret) return _ret.v;
+    for (const suffixPair of _defaultSettings.TRIP_POINT_FIELDS) {
+      // match first suffix```
+      if (fieldName.endsWith(suffixPair[0])) {
+        // match second suffix
+        const otherPattern = new RegExp(`${suffixPair[0]}\$`);
+        const partner = fieldName.replace(otherPattern, suffixPair[1]);
+        const partnerIdx = allNames.findIndex(d => d === partner);
+        if (partnerIdx > -1) {
+          const defaultName = removeSuffixAndDelimiters(fieldName, suffixPair[0]);
+          carry.push({
+            defaultName,
+            pair: {
+              lat: {
+                fieldIdx: idx,
+                value: fields[idx].name
+              },
+              lng: {
+                fieldIdx: partnerIdx,
+                value: fields[partnerIdx].name
+              }
+            },
+            suffix: suffixPair
+          });
+          return carry;
+        }
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
     }
     return carry;
   }, acc);
 
   // prioritize the 'latitude'/'longitude' pair
-  result.sort(function (a, b) {
+  result.sort((a, b) => {
     if (a.defaultName === '' && a.suffix[0] === 'latitude') return -1;
     if (b.defaultName === '' && b.suffix[0] === 'latitude') return 1;
     return 0;
@@ -492,47 +470,45 @@ function findPointFieldPairs(fields) {
  * @type
  */
 function sortDatasetByColumn(dataset, column, mode) {
-  var allIndexes = dataset.allIndexes,
-    fields = dataset.fields,
-    dataContainer = dataset.dataContainer;
-  var fieldIndex = fields.findIndex(function (f) {
-    return f.name === column;
-  });
+  const {
+    allIndexes,
+    fields,
+    dataContainer
+  } = dataset;
+  const fieldIndex = fields.findIndex(f => f.name === column);
   if (fieldIndex < 0) {
     return dataset;
   }
-  var sortBy = _defaultSettings.SORT_ORDER[mode || ''] || _defaultSettings.SORT_ORDER.ASCENDING;
+  const sortBy = _defaultSettings.SORT_ORDER[mode || ''] || _defaultSettings.SORT_ORDER.ASCENDING;
   if (sortBy === _defaultSettings.SORT_ORDER.UNSORT) {
     dataset.sortColumn = {};
     dataset.sortOrder = null;
     return dataset;
   }
-  var sortFunction = sortBy === _defaultSettings.SORT_ORDER.ASCENDING ? _d3Array.ascending : _d3Array.descending;
-  var sortOrder = allIndexes.slice().sort(function (a, b) {
-    return sortFunction(dataContainer.valueAt(a, fieldIndex), dataContainer.valueAt(b, fieldIndex));
-  });
-  dataset.sortColumn = (0, _defineProperty2["default"])({}, column, sortBy);
+  const sortFunction = sortBy === _defaultSettings.SORT_ORDER.ASCENDING ? _d3Array.ascending : _d3Array.descending;
+  const sortOrder = allIndexes.slice().sort((a, b) => sortFunction(dataContainer.valueAt(a, fieldIndex), dataContainer.valueAt(b, fieldIndex)));
+  dataset.sortColumn = {
+    [column]: sortBy
+  };
   dataset.sortOrder = sortOrder;
   return dataset;
 }
 function pinTableColumns(dataset, column) {
-  var field = dataset.getColumnField(column);
+  const field = dataset.getColumnField(column);
   if (!field) {
     return dataset;
   }
-  var pinnedColumns;
+  let pinnedColumns;
   if (Array.isArray(dataset.pinnedColumns) && dataset.pinnedColumns.includes(field.name)) {
     // unpin it
-    pinnedColumns = dataset.pinnedColumns.filter(function (co) {
-      return co !== field.name;
-    });
+    pinnedColumns = dataset.pinnedColumns.filter(co => co !== field.name);
   } else {
     pinnedColumns = (dataset.pinnedColumns || []).concat(field.name);
   }
 
   // @ts-ignore
   return copyTableAndUpdate(dataset, {
-    pinnedColumns: pinnedColumns
+    pinnedColumns
   });
 }
 function copyTable(original) {
@@ -544,11 +520,11 @@ function copyTable(original) {
  * @returns
  */
 function copyTableAndUpdate(original) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return Object.entries(options).reduce(function (acc, entry) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return Object.entries(options).reduce((acc, entry) => {
     acc[entry[0]] = entry[1];
     return acc;
   }, copyTable(original));
 }
-var _default = exports["default"] = KeplerTable;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_console","require","_defaultSettings","_d3Array","_utils","_gpuFilterUtils","_filterUtils","_dataUtils","_dataScaleUtils","_dataContainerUtils","_colorUtils","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","ownKeys","Object","keys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","FID_KEY","KeplerTable","_ref","_ref$info","info","data","color","metadata","supportedFilterTypes","_classCallCheck2","dataContainer","createDataContainer","rows","fields","datasetInfo","id","generateHashId","label","dataId","map","i","fieldIdx","displayName","valueAccessor","maybeToDate","bind","type","ALL_FIELD_TYPES","timestamp","date","format","allIndexes","getPlainIndex","filteredIndex","filteredIndexForDomain","fieldPairs","findPointFieldPairs","gpuFilter","getGpuFilterProps","_createClass2","key","getColumnField","columnName","field","find","fd","_assetField","getColumnFieldIdx","findIndex","Boolean","getValue","rowIdx","index","updateColumnField","newField","assign","_toConsumableArray2","updateTableColor","newColor","getColumnFilterProps","hasOwnProperty","filterProps","fieldDomain","getColumnFilterDomain","getFilterProps","filterTable","filters","layers","opt","_this","oldFilterRecord","filterRecord","getFilterRecord","changedFilters","diffFilters","shouldCalDomain","dynamicDomain","shouldCalIndex","cpu","filterResult","dynamicDomainFilters","cpuFilters","filterFuncs","reduce","acc","fieldIndex","getDatasetFieldIndexForFilter","getFilterFunction","filterDataByFilterTypes","filterTableCPU","cpuOnly","ignoreDomain","filteredIdxCPU","filterRecordCPU","gpu","copied","copyTable","filtered","domain","real","integer","getNumericFieldDomain","string","getOrdinalDomain","getTimestampFieldDomain","getColumnLayerDomain","scaleType","SCALE_TYPES","Console","error","concat","indexValueAccessor","sortFunction","getSortingFunction","ordinal","point","quantile","getQuantileDomain","log","getLogDomain","quantize","linear","sqrt","getLinearDomain","calculateLegend","leftField","rightField","limitOfNumberOfLegendEntries","leftValues","mapIndex","rightValues","pairing","previous","current","idx","uniqueSortedPairByFrequency","row","left","checkColorOrFallback","right","fieldName","condition","removeSuffixAndDelimiters","layerName","suffix","replace","RegExp","trim","allNames","toLowerCase","result","carry","_iterator","TRIP_POINT_FIELDS","_step","_loop","suffixPair","endsWith","otherPattern","partner","partnerIdx","d","defaultName","pair","lat","lng","v","_ret","err","sort","b","sortDatasetByColumn","dataset","column","mode","sortBy","SORT_ORDER","ASCENDING","UNSORT","sortColumn","sortOrder","ascending","descending","valueAt","pinTableColumns","pinnedColumns","includes","co","copyTableAndUpdate","original","create","getPrototypeOf","options","undefined","entries","entry","_default","exports"],"sources":["../../../src/utils/table-utils/kepler-table.ts"],"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 {console as Console} from 'global/console';\nimport {TRIP_POINT_FIELDS, SORT_ORDER} from 'constants/default-settings';\nimport {ascending, descending} from 'd3-array';\n\n// import {validateInputData} from 'processors/data-processor';\nimport {generateHashId} from 'utils/utils';\nimport {getGpuFilterProps, getDatasetFieldIndexForFilter} from 'utils/gpu-filter-utils';\nimport {\n  getFilterProps,\n  getFilterRecord,\n  diffFilters,\n  getFilterFunction,\n  filterDataByFilterTypes,\n  getNumericFieldDomain,\n  getTimestampFieldDomain,\n  FilterResult\n} from 'utils/filter-utils';\nimport {maybeToDate, getSortingFunction} from 'utils/data-utils';\nimport {\n  getQuantileDomain,\n  getOrdinalDomain,\n  getLogDomain,\n  getLinearDomain\n} from 'utils/data-scale-utils';\n\nimport {ALL_FIELD_TYPES, SCALE_TYPES} from 'constants/default-settings';\n\nimport {createDataContainer} from './data-container-utils';\nimport {uniqueSortedPairByFrequency} from 'utils/data-utils';\nimport {checkColorOrFallback} from 'utils/color-utils';\n\nimport {RGBColor} from 'reducers/types';\nimport {Layer} from 'layers';\nimport {FieldDomain, Filter} from 'reducers/vis-state-updaters';\nimport {DataContainerInterface} from './data-container-interface';\nimport {ProtoDataset} from 'actions';\n\nexport type Field = {\n  analyzerType: string;\n  id?: string;\n  name: string;\n  displayName: string;\n  format: string;\n  type: string;\n  fieldIdx: number;\n  valueAccessor(v: {index: number}): any;\n  filterProps?: any;\n  metadata?: any;\n};\n\nexport type GpuFilter = {\n  filterRange: number[][];\n  filterValueUpdateTriggers: any;\n  filterValueAccessor: (\n    dc: DataContainerInterface\n  ) => (\n    getIndex?: (any) => number,\n    getData?: (dc: DataContainerInterface, d: any, fieldIndex: number) => any\n  ) => (d: any) => number;\n};\n\nexport type FieldPair = {\n  defaultName: string;\n  pair: {\n    [key: string]: {\n      fieldIdx: number;\n      value: string;\n    };\n  };\n  suffix: string[];\n};\n\nexport type FilterRecord = {\n  dynamicDomain: Filter[];\n  fixedDomain: Filter[];\n  cpu: Filter[];\n  gpu: Filter[];\n};\n\nexport type FilterDatasetOpt = {\n  // only allow cpu filtering\n  cpuOnly?: boolean;\n  // ignore filter for domain calculation\n  ignoreDomain?: boolean;\n};\n\n// Unique identifier of each field\nconst FID_KEY = 'name';\n\nclass KeplerTable {\n  readonly id: string;\n\n  type?: string;\n  label: string;\n  color: RGBColor;\n\n  // fields and data\n  fields: Field[];\n\n  dataContainer: DataContainerInterface;\n\n  allIndexes: number[];\n  filteredIndex: number[];\n  filteredIdxCPU?: number[];\n  filteredIndexForDomain: number[];\n  fieldPairs: FieldPair[];\n  gpuFilter: GpuFilter;\n  filterRecord?: FilterRecord;\n  filterRecordCPU?: FilterRecord;\n  changedFilters?: any;\n\n  // table-injected metadata\n  sortColumn?: {\n    // column name: sorted idx\n    [key: string]: string; // ASCENDING | DESCENDING | UNSORT\n  };\n  sortOrder?: number[] | null;\n\n  pinnedColumns?: string[];\n  supportedFilterTypes: string[] | undefined;\n  // table-injected metadata\n  metadata: object;\n\n  constructor({\n    info = {},\n    data,\n    color,\n    metadata,\n    supportedFilterTypes\n  }: {\n    info?: ProtoDataset['info'];\n    data: ProtoDataset['data'];\n    color: RGBColor;\n    metadata?: ProtoDataset['metadata'];\n    supportedFilterTypes?: ProtoDataset['supportedFilterTypes'];\n  }) {\n    // TODO - what to do if validation fails? Can kepler handle exceptions?\n    // const validatedData = validateInputData(data);\n    // if (!validatedData) {\n    //   return this;\n    // }\n\n    // @ts-expect-error\n    const dataContainer = createDataContainer(data.rows, {fields: data.fields});\n\n    const datasetInfo = {\n      id: generateHashId(4),\n      label: 'new dataset',\n      ...(info || {})\n    };\n    const dataId = datasetInfo.id;\n    // @ts-expect-error\n    const fields: Field[] = data.fields.map((f, i) => ({\n      ...f,\n      fieldIdx: i,\n      id: f.name,\n      displayName: f.displayName || f.name,\n      valueAccessor: maybeToDate.bind(\n        null,\n        // is time\n        f.type === ALL_FIELD_TYPES.timestamp || f.type === ALL_FIELD_TYPES.date,\n        i,\n        f.format,\n        dataContainer\n      )\n    }));\n\n    const allIndexes = dataContainer.getPlainIndex();\n\n    this.id = datasetInfo.id;\n    this.label = datasetInfo.label;\n    this.color = color;\n    this.metadata = {\n      ...metadata,\n      id: datasetInfo.id,\n      label: datasetInfo.label\n    };\n\n    this.dataContainer = dataContainer;\n    this.allIndexes = allIndexes;\n    this.filteredIndex = allIndexes;\n    this.filteredIndexForDomain = allIndexes;\n    this.fieldPairs = findPointFieldPairs(fields);\n    this.fields = fields;\n    this.gpuFilter = getGpuFilterProps([], dataId, fields);\n    if (supportedFilterTypes) {\n      this.supportedFilterTypes = supportedFilterTypes;\n    }\n  }\n\n  /**\n   * Get field\n   * @param columnName\n   */\n  getColumnField(columnName: string): Field | undefined {\n    const field = this.fields.find(fd => fd[FID_KEY] === columnName);\n    this._assetField(columnName, field);\n    return field;\n  }\n\n  /**\n   * Get fieldIdx\n   * @param columnName\n   */\n  getColumnFieldIdx(columnName: string): number {\n    const fieldIdx = this.fields.findIndex(fd => fd[FID_KEY] === columnName);\n    this._assetField(columnName, Boolean(fieldIdx > -1));\n    return fieldIdx;\n  }\n\n  /**\n   * Get the value of a cell\n   */\n  getValue(columnName: string, rowIdx: number): any {\n    const field = this.getColumnField(columnName);\n    return field ? field.valueAccessor({index: rowIdx}) : null;\n  }\n\n  /**\n   * Updates existing field with a new object\n   * @param fieldIdx\n   * @param newField\n   */\n  updateColumnField(fieldIdx: number, newField: Field): void {\n    this.fields = Object.assign([...this.fields], {[fieldIdx]: newField});\n  }\n\n  /**\n   * Update dataset color by custom color\n   * @param newColor\n   */\n  updateTableColor(newColor: RGBColor): void {\n    this.color = newColor;\n  }\n\n  /**\n   * Save filterProps to field and retrieve it\n   * @param columnName\n   */\n  getColumnFilterProps(columnName: string): Field['filterProps'] | null | undefined {\n    const fieldIdx = this.getColumnFieldIdx(columnName);\n    if (fieldIdx < 0) {\n      return null;\n    }\n    const field = this.fields[fieldIdx];\n    if (field.hasOwnProperty('filterProps')) {\n      return field.filterProps;\n    }\n\n    const fieldDomain = this.getColumnFilterDomain(field);\n    if (!fieldDomain) {\n      return null;\n    }\n\n    const filterProps = getFilterProps(field, fieldDomain);\n    const newField = {\n      ...field,\n      filterProps\n    };\n\n    this.updateColumnField(fieldIdx, newField);\n\n    return filterProps;\n  }\n\n  /**\n   * Apply filters to dataset, return the filtered dataset with updated `gpuFilter`, `filterRecord`, `filteredIndex`, `filteredIndexForDomain`\n   * @param filters\n   * @param layers\n   * @param opt\n   */\n  filterTable(filters: Filter[], layers: Layer[], opt?: FilterDatasetOpt): KeplerTable {\n    const {dataContainer, id: dataId, filterRecord: oldFilterRecord, fields} = this;\n\n    // if there is no filters\n    const filterRecord = getFilterRecord(dataId, filters, opt || {});\n\n    this.filterRecord = filterRecord;\n    this.gpuFilter = getGpuFilterProps(filters, dataId, fields);\n\n    // const newDataset = set(['filterRecord'], filterRecord, dataset);\n\n    if (!filters.length) {\n      this.filteredIndex = this.allIndexes;\n      this.filteredIndexForDomain = this.allIndexes;\n      return this;\n    }\n\n    this.changedFilters = diffFilters(filterRecord, oldFilterRecord);\n\n    // generate 2 sets of filter result\n    // filteredIndex used to calculate layer data\n    // filteredIndexForDomain used to calculate layer Domain\n    const shouldCalDomain = Boolean(this.changedFilters.dynamicDomain);\n    const shouldCalIndex = Boolean(this.changedFilters.cpu);\n\n    let filterResult: FilterResult = {};\n    if (shouldCalDomain || shouldCalIndex) {\n      const dynamicDomainFilters = shouldCalDomain ? filterRecord.dynamicDomain : null;\n      const cpuFilters = shouldCalIndex ? filterRecord.cpu : null;\n\n      const filterFuncs = filters.reduce((acc, filter) => {\n        const fieldIndex = getDatasetFieldIndexForFilter(this.id, filter);\n        const field = fieldIndex !== -1 ? fields[fieldIndex] : null;\n\n        return {\n          ...acc,\n          [filter.id]: getFilterFunction(field, this.id, filter, layers, dataContainer)\n        };\n      }, {});\n\n      filterResult = filterDataByFilterTypes(\n        {dynamicDomainFilters, cpuFilters, filterFuncs},\n        dataContainer\n      );\n    }\n\n    this.filteredIndex = filterResult.filteredIndex || this.filteredIndex;\n    this.filteredIndexForDomain =\n      filterResult.filteredIndexForDomain || this.filteredIndexForDomain;\n\n    return this;\n  }\n\n  /**\n   * Apply filters to a dataset all on CPU, assign to `filteredIdxCPU`, `filterRecordCPU`\n   * @param filters\n   * @param layers\n   */\n  filterTableCPU(filters: Filter[], layers: Layer[]): KeplerTable {\n    const opt = {\n      cpuOnly: true,\n      ignoreDomain: true\n    };\n\n    // no filter\n    if (!filters.length) {\n      this.filteredIdxCPU = this.allIndexes;\n      this.filterRecordCPU = getFilterRecord(this.id, filters, opt);\n      return this;\n    }\n\n    // no gpu filter\n    if (!filters.find(f => f.gpu)) {\n      this.filteredIdxCPU = this.filteredIndex;\n      this.filterRecordCPU = getFilterRecord(this.id, filters, opt);\n      return this;\n    }\n\n    // make a copy for cpu filtering\n    const copied = copyTable(this);\n\n    copied.filterRecord = this.filterRecordCPU;\n    copied.filteredIndex = this.filteredIdxCPU || [];\n\n    const filtered = copied.filterTable(filters, layers, opt);\n\n    this.filteredIdxCPU = filtered.filteredIndex;\n    this.filterRecordCPU = filtered.filterRecord;\n\n    return this;\n  }\n\n  /**\n   * Calculate field domain based on field type and data\n   * for Filter\n   */\n  getColumnFilterDomain(field: Field): FieldDomain {\n    const {dataContainer} = this;\n    const {valueAccessor} = field;\n\n    let domain;\n\n    switch (field.type) {\n      case ALL_FIELD_TYPES.real:\n      case ALL_FIELD_TYPES.integer:\n        // calculate domain and step\n        return getNumericFieldDomain(dataContainer, valueAccessor);\n\n      case ALL_FIELD_TYPES.boolean:\n        return {domain: [true, false]};\n\n      case ALL_FIELD_TYPES.string:\n      case ALL_FIELD_TYPES.date:\n        domain = getOrdinalDomain(dataContainer, valueAccessor);\n        return {domain};\n\n      case ALL_FIELD_TYPES.timestamp:\n        return getTimestampFieldDomain(dataContainer, valueAccessor);\n\n      default:\n        return {domain: getOrdinalDomain(dataContainer, valueAccessor)};\n    }\n  }\n\n  /**\n   *  Get the domain of this column based on scale type\n   */\n  getColumnLayerDomain(\n    field: Field,\n    scaleType: string\n  ): number[] | string[] | [number, number] | null {\n    const {dataContainer, filteredIndexForDomain} = this;\n\n    if (!SCALE_TYPES[scaleType]) {\n      Console.error(`scale type ${scaleType} not supported`);\n      return null;\n    }\n\n    const {valueAccessor} = field;\n    const indexValueAccessor = i => valueAccessor({index: i});\n    const sortFunction = getSortingFunction(field.type);\n\n    switch (scaleType) {\n      case SCALE_TYPES.ordinal:\n      case SCALE_TYPES.point:\n        // do not recalculate ordinal domain based on filtered data\n        // don't need to update ordinal domain every time\n        return getOrdinalDomain(dataContainer, valueAccessor);\n\n      case SCALE_TYPES.quantile:\n        return getQuantileDomain(filteredIndexForDomain, indexValueAccessor, sortFunction);\n\n      case SCALE_TYPES.log:\n        return getLogDomain(filteredIndexForDomain, indexValueAccessor);\n\n      case SCALE_TYPES.quantize:\n      case SCALE_TYPES.linear:\n      case SCALE_TYPES.sqrt:\n      default:\n        return getLinearDomain(filteredIndexForDomain, indexValueAccessor);\n    }\n  }\n\n  calculateLegend(leftField, rightField) {\n    const limitOfNumberOfLegendEntries = 20;\n    const leftValues = this.dataContainer.mapIndex(leftField.valueAccessor);\n    const rightValues = this.dataContainer.mapIndex(rightField.valueAccessor);\n\n    const pairing = leftValues.reduce((previous, current, idx) => {\n      previous.push([current, rightValues[idx]]);\n      return previous;\n    }, []);\n\n    return uniqueSortedPairByFrequency(pairing)\n      .map(row => {\n        return {\n          label: row.left,\n          color: checkColorOrFallback(row.right)\n        };\n      })\n      .slice(0, limitOfNumberOfLegendEntries + 1); // Limit to limitOfNumberOfLegendEntries + 1, then limit to limitOfNumberOfLegendEntries in LegendManagers\n  }\n\n  /**\n   * Get a sample of rows to calculate layer boundaries\n   */\n  // getSampleData(rows)\n\n  /**\n   * Parse cell value based on column type and return a string representation\n   * Value the field value, type the field type\n   */\n  // parseFieldValue(value, type)\n\n  // sortDatasetByColumn()\n\n  /**\n   * Assert whether field exist\n   * @param fieldName\n   * @param condition\n   */\n  _assetField(fieldName: string, condition: any): void {\n    if (!condition) {\n      Console.error(`${fieldName} doesnt exist in dataset ${this.id}`);\n    }\n  }\n}\n\n// HELPER FUNCTIONS (MAINLY EXPORTED FOR TEST...)\n\nexport function removeSuffixAndDelimiters(layerName, suffix) {\n  return layerName\n    .replace(new RegExp(suffix, 'ig'), '')\n    .replace(/[_,.]+/g, ' ')\n    .trim();\n}\n\n/**\n * Find point fields pairs from fields\n *\n * @param fields\n * @returns found point fields\n */\nexport function findPointFieldPairs(fields: Field[]): FieldPair[] {\n  const allNames = fields.map(f => f.name.toLowerCase());\n\n  // get list of all fields with matching suffixes\n  const acc: FieldPair[] = [];\n  const result = allNames.reduce((carry, fieldName, idx) => {\n    // This search for pairs will early exit if found.\n    for (const suffixPair of TRIP_POINT_FIELDS) {\n      // match first suffix```\n      if (fieldName.endsWith(suffixPair[0])) {\n        // match second suffix\n        const otherPattern = new RegExp(`${suffixPair[0]}\\$`);\n        const partner = fieldName.replace(otherPattern, suffixPair[1]);\n\n        const partnerIdx = allNames.findIndex(d => d === partner);\n        if (partnerIdx > -1) {\n          const defaultName = removeSuffixAndDelimiters(fieldName, suffixPair[0]);\n\n          carry.push({\n            defaultName,\n            pair: {\n              lat: {\n                fieldIdx: idx,\n                value: fields[idx].name\n              },\n              lng: {\n                fieldIdx: partnerIdx,\n                value: fields[partnerIdx].name\n              }\n            },\n            suffix: suffixPair\n          });\n          return carry;\n        }\n      }\n    }\n    return carry;\n  }, acc);\n\n  // prioritize the 'latitude'/'longitude' pair\n  result.sort((a, b) => {\n    if (a.defaultName === '' && a.suffix[0] === 'latitude') return -1;\n    if (b.defaultName === '' && b.suffix[0] === 'latitude') return 1;\n    return 0;\n  });\n\n  return result;\n}\n\n/**\n *\n * @param dataset\n * @param column\n * @param mode\n * @type\n */\nexport function sortDatasetByColumn(\n  dataset: KeplerTable,\n  column: string,\n  mode?: string\n): KeplerTable {\n  const {allIndexes, fields, dataContainer} = dataset;\n  const fieldIndex = fields.findIndex(f => f.name === column);\n  if (fieldIndex < 0) {\n    return dataset;\n  }\n\n  const sortBy = SORT_ORDER[mode || ''] || SORT_ORDER.ASCENDING;\n\n  if (sortBy === SORT_ORDER.UNSORT) {\n    dataset.sortColumn = {};\n    dataset.sortOrder = null;\n\n    return dataset;\n  }\n\n  const sortFunction = sortBy === SORT_ORDER.ASCENDING ? ascending : descending;\n  const sortOrder = allIndexes\n    .slice()\n    .sort((a, b) =>\n      sortFunction(dataContainer.valueAt(a, fieldIndex), dataContainer.valueAt(b, fieldIndex))\n    );\n\n  dataset.sortColumn = {\n    [column]: sortBy\n  };\n  dataset.sortOrder = sortOrder;\n\n  return dataset;\n}\n\nexport function pinTableColumns(dataset: KeplerTable, column: string): KeplerTable {\n  const field = dataset.getColumnField(column);\n  if (!field) {\n    return dataset;\n  }\n\n  let pinnedColumns;\n  if (Array.isArray(dataset.pinnedColumns) && dataset.pinnedColumns.includes(field.name)) {\n    // unpin it\n    pinnedColumns = dataset.pinnedColumns.filter(co => co !== field.name);\n  } else {\n    pinnedColumns = (dataset.pinnedColumns || []).concat(field.name);\n  }\n\n  // @ts-ignore\n  return copyTableAndUpdate(dataset, {pinnedColumns});\n}\nexport function copyTable<T extends {}>(original: T): T {\n  return Object.assign(Object.create(Object.getPrototypeOf(original)), original);\n}\n\n/**\n * @type\n * @returns\n */\nexport function copyTableAndUpdate<T extends {}>(original: T, options: Partial<T> = {}): T {\n  return Object.entries(options).reduce((acc, entry) => {\n    acc[entry[0]] = entry[1];\n    return acc;\n  }, copyTable(original));\n}\n\nexport default KeplerTable;\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AAGA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,eAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AAUA,IAAAM,UAAA,GAAAN,OAAA;AACA,IAAAO,eAAA,GAAAP,OAAA;AASA,IAAAQ,mBAAA,GAAAR,OAAA;AAEA,IAAAS,WAAA,GAAAT,OAAA;AAAuD,SAAAU,2BAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,yBAAAC,MAAA,IAAAH,CAAA,CAAAG,MAAA,CAAAC,QAAA,KAAAJ,CAAA,qBAAAE,CAAA,QAAAG,KAAA,CAAAC,OAAA,CAAAN,CAAA,MAAAE,CAAA,GAAAK,2BAAA,CAAAP,CAAA,MAAAC,CAAA,IAAAD,CAAA,uBAAAA,CAAA,CAAAQ,MAAA,IAAAN,CAAA,KAAAF,CAAA,GAAAE,CAAA,OAAAO,EAAA,MAAAC,CAAA,YAAAA,EAAA,eAAAC,CAAA,EAAAD,CAAA,EAAAE,CAAA,WAAAA,EAAA,WAAAH,EAAA,IAAAT,CAAA,CAAAQ,MAAA,KAAAK,IAAA,WAAAA,IAAA,MAAAC,KAAA,EAAAd,CAAA,CAAAS,EAAA,UAAAR,CAAA,WAAAA,EAAAD,CAAA,UAAAA,CAAA,KAAAe,CAAA,EAAAL,CAAA,gBAAAM,SAAA,iJAAAC,CAAA,EAAAC,CAAA,OAAAC,CAAA,gBAAAR,CAAA,WAAAA,EAAA,IAAAT,CAAA,GAAAA,CAAA,CAAAkB,IAAA,CAAApB,CAAA,MAAAY,CAAA,WAAAA,EAAA,QAAAZ,CAAA,GAAAE,CAAA,CAAAmB,IAAA,WAAAH,CAAA,GAAAlB,CAAA,CAAAa,IAAA,EAAAb,CAAA,KAAAC,CAAA,WAAAA,EAAAD,CAAA,IAAAmB,CAAA,OAAAF,CAAA,GAAAjB,CAAA,KAAAe,CAAA,WAAAA,EAAA,UAAAG,CAAA,YAAAhB,CAAA,cAAAA,CAAA,8BAAAiB,CAAA,QAAAF,CAAA;AAAA,SAAAV,4BAAAP,CAAA,EAAAkB,CAAA,QAAAlB,CAAA,2BAAAA,CAAA,SAAAsB,iBAAA,CAAAtB,CAAA,EAAAkB,CAAA,OAAAhB,CAAA,MAAAqB,QAAA,CAAAH,IAAA,CAAApB,CAAA,EAAAwB,KAAA,6BAAAtB,CAAA,IAAAF,CAAA,CAAAyB,WAAA,KAAAvB,CAAA,GAAAF,CAAA,CAAAyB,WAAA,CAAAC,IAAA,aAAAxB,CAAA,cAAAA,CAAA,GAAAG,KAAA,CAAAsB,IAAA,CAAA3B,CAAA,oBAAAE,CAAA,+CAAA0B,IAAA,CAAA1B,CAAA,IAAAoB,iBAAA,CAAAtB,CAAA,EAAAkB,CAAA;AAAA,SAAAI,kBAAAtB,CAAA,EAAAkB,CAAA,aAAAA,CAAA,IAAAA,CAAA,GAAAlB,CAAA,CAAAQ,MAAA,MAAAU,CAAA,GAAAlB,CAAA,CAAAQ,MAAA,YAAAP,CAAA,MAAAW,CAAA,GAAAP,KAAA,CAAAa,CAAA,GAAAjB,CAAA,GAAAiB,CAAA,EAAAjB,CAAA,IAAAW,CAAA,CAAAX,CAAA,IAAAD,CAAA,CAAAC,CAAA,UAAAW,CAAA;AAAA,SAAAiB,QAAA5B,CAAA,EAAAD,CAAA,QAAAE,CAAA,GAAA4B,MAAA,CAAAC,IAAA,CAAA9B,CAAA,OAAA6B,MAAA,CAAAE,qBAAA,QAAAf,CAAA,GAAAa,MAAA,CAAAE,qBAAA,CAAA/B,CAAA,GAAAD,CAAA,KAAAiB,CAAA,GAAAA,CAAA,CAAAgB,MAAA,WAAAjC,CAAA,WAAA8B,MAAA,CAAAI,wBAAA,CAAAjC,CAAA,EAAAD,CAAA,EAAAmC,UAAA,OAAAjC,CAAA,CAAAkC,IAAA,CAAAC,KAAA,CAAAnC,CAAA,EAAAe,CAAA,YAAAf,CAAA;AAAA,SAAAoC,cAAArC,CAAA,aAAAD,CAAA,MAAAA,CAAA,GAAAuC,SAAA,CAAA/B,MAAA,EAAAR,CAAA,UAAAE,CAAA,WAAAqC,SAAA,CAAAvC,CAAA,IAAAuC,SAAA,CAAAvC,CAAA,QAAAA,CAAA,OAAA6B,OAAA,CAAAC,MAAA,CAAA5B,CAAA,OAAAsC,OAAA,WAAAxC,CAAA,QAAAyC,gBAAA,aAAAxC,CAAA,EAAAD,CAAA,EAAAE,CAAA,CAAAF,CAAA,SAAA8B,MAAA,CAAAY,yBAAA,GAAAZ,MAAA,CAAAa,gBAAA,CAAA1C,CAAA,EAAA6B,MAAA,CAAAY,yBAAA,CAAAxC,CAAA,KAAA2B,OAAA,CAAAC,MAAA,CAAA5B,CAAA,GAAAsC,OAAA,WAAAxC,CAAA,IAAA8B,MAAA,CAAAc,cAAA,CAAA3C,CAAA,EAAAD,CAAA,EAAA8B,MAAA,CAAAI,wBAAA,CAAAhC,CAAA,EAAAF,CAAA,iBAAAC,CAAA,IAjDvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAMA;AAkFA;AACA,IAAM4C,OAAO,GAAG,MAAM;AAAC,IAEjBC,WAAW;EAOf;;EAeA;;EASA;;EAGA,SAAAA,YAAAC,IAAA,EAYG;IAAA,IAAAC,SAAA,GAAAD,IAAA,CAXDE,IAAI;MAAJA,IAAI,GAAAD,SAAA,cAAG,CAAC,CAAC,GAAAA,SAAA;MACTE,IAAI,GAAAH,IAAA,CAAJG,IAAI;MACJC,KAAK,GAAAJ,IAAA,CAALI,KAAK;MACLC,QAAQ,GAAAL,IAAA,CAARK,QAAQ;MACRC,oBAAoB,GAAAN,IAAA,CAApBM,oBAAoB;IAAA,IAAAC,gBAAA,mBAAAR,WAAA;IAQpB;IACA;IACA;IACA;IACA;;IAEA;IACA,IAAMS,aAAa,GAAG,IAAAC,uCAAmB,EAACN,IAAI,CAACO,IAAI,EAAE;MAACC,MAAM,EAAER,IAAI,CAACQ;IAAM,CAAC,CAAC;IAE3E,IAAMC,WAAW,GAAArB,aAAA;MACfsB,EAAE,EAAE,IAAAC,qBAAc,EAAC,CAAC,CAAC;MACrBC,KAAK,EAAE;IAAa,GAChBb,IAAI,IAAI,CAAC,CAAC,CACf;IACD,IAAMc,MAAM,GAAGJ,WAAW,CAACC,EAAE;IAC7B;IACA,IAAMF,MAAe,GAAGR,IAAI,CAACQ,MAAM,CAACM,GAAG,CAAC,UAACjD,CAAC,EAAEkD,CAAC;MAAA,OAAA3B,aAAA,CAAAA,aAAA,KACxCvB,CAAC;QACJmD,QAAQ,EAAED,CAAC;QACXL,EAAE,EAAE7C,CAAC,CAACW,IAAI;QACVyC,WAAW,EAAEpD,CAAC,CAACoD,WAAW,IAAIpD,CAAC,CAACW,IAAI;QACpC0C,aAAa,EAAEC,sBAAW,CAACC,IAAI,CAC7B,IAAI;QACJ;QACAvD,CAAC,CAACwD,IAAI,KAAKC,gCAAe,CAACC,SAAS,IAAI1D,CAAC,CAACwD,IAAI,KAAKC,gCAAe,CAACE,IAAI,EACvET,CAAC,EACDlD,CAAC,CAAC4D,MAAM,EACRpB,aACF;MAAC;IAAA,CACD,CAAC;IAEH,IAAMqB,UAAU,GAAGrB,aAAa,CAACsB,aAAa,CAAC,CAAC;IAEhD,IAAI,CAACjB,EAAE,GAAGD,WAAW,CAACC,EAAE;IACxB,IAAI,CAACE,KAAK,GAAGH,WAAW,CAACG,KAAK;IAC9B,IAAI,CAACX,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,QAAQ,GAAAd,aAAA,CAAAA,aAAA,KACRc,QAAQ;MACXQ,EAAE,EAAED,WAAW,CAACC,EAAE;MAClBE,KAAK,EAAEH,WAAW,CAACG;IAAK,EACzB;IAED,IAAI,CAACP,aAAa,GAAGA,aAAa;IAClC,IAAI,CAACqB,UAAU,GAAGA,UAAU;IAC5B,IAAI,CAACE,aAAa,GAAGF,UAAU;IAC/B,IAAI,CAACG,sBAAsB,GAAGH,UAAU;IACxC,IAAI,CAACI,UAAU,GAAGC,mBAAmB,CAACvB,MAAM,CAAC;IAC7C,IAAI,CAACA,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACwB,SAAS,GAAG,IAAAC,iCAAiB,EAAC,EAAE,EAAEpB,MAAM,EAAEL,MAAM,CAAC;IACtD,IAAIL,oBAAoB,EAAE;MACxB,IAAI,CAACA,oBAAoB,GAAGA,oBAAoB;IAClD;EACF;;EAEA;AACF;AACA;AACA;EAHE,WAAA+B,aAAA,aAAAtC,WAAA;IAAAuC,GAAA;IAAAvE,KAAA,EAIA,SAAAwE,cAAcA,CAACC,UAAkB,EAAqB;MACpD,IAAMC,KAAK,GAAG,IAAI,CAAC9B,MAAM,CAAC+B,IAAI,CAAC,UAAAC,EAAE;QAAA,OAAIA,EAAE,CAAC7C,OAAO,CAAC,KAAK0C,UAAU;MAAA,EAAC;MAChE,IAAI,CAACI,WAAW,CAACJ,UAAU,EAAEC,KAAK,CAAC;MACnC,OAAOA,KAAK;IACd;;IAEA;AACF;AACA;AACA;EAHE;IAAAH,GAAA;IAAAvE,KAAA,EAIA,SAAA8E,iBAAiBA,CAACL,UAAkB,EAAU;MAC5C,IAAMrB,QAAQ,GAAG,IAAI,CAACR,MAAM,CAACmC,SAAS,CAAC,UAAAH,EAAE;QAAA,OAAIA,EAAE,CAAC7C,OAAO,CAAC,KAAK0C,UAAU;MAAA,EAAC;MACxE,IAAI,CAACI,WAAW,CAACJ,UAAU,EAAEO,OAAO,CAAC5B,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC;MACpD,OAAOA,QAAQ;IACjB;;IAEA;AACF;AACA;EAFE;IAAAmB,GAAA;IAAAvE,KAAA,EAGA,SAAAiF,QAAQA,CAACR,UAAkB,EAAES,MAAc,EAAO;MAChD,IAAMR,KAAK,GAAG,IAAI,CAACF,cAAc,CAACC,UAAU,CAAC;MAC7C,OAAOC,KAAK,GAAGA,KAAK,CAACpB,aAAa,CAAC;QAAC6B,KAAK,EAAED;MAAM,CAAC,CAAC,GAAG,IAAI;IAC5D;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAX,GAAA;IAAAvE,KAAA,EAKA,SAAAoF,iBAAiBA,CAAChC,QAAgB,EAAEiC,QAAe,EAAQ;MACzD,IAAI,CAACzC,MAAM,GAAG5B,MAAM,CAACsE,MAAM,KAAAC,mBAAA,aAAK,IAAI,CAAC3C,MAAM,OAAAjB,gBAAA,iBAAKyB,QAAQ,EAAGiC,QAAQ,CAAC,CAAC;IACvE;;IAEA;AACF;AACA;AACA;EAHE;IAAAd,GAAA;IAAAvE,KAAA,EAIA,SAAAwF,gBAAgBA,CAACC,QAAkB,EAAQ;MACzC,IAAI,CAACpD,KAAK,GAAGoD,QAAQ;IACvB;;IAEA;AACF;AACA;AACA;EAHE;IAAAlB,GAAA;IAAAvE,KAAA,EAIA,SAAA0F,oBAAoBA,CAACjB,UAAkB,EAA2C;MAChF,IAAMrB,QAAQ,GAAG,IAAI,CAAC0B,iBAAiB,CAACL,UAAU,CAAC;MACnD,IAAIrB,QAAQ,GAAG,CAAC,EAAE;QAChB,OAAO,IAAI;MACb;MACA,IAAMsB,KAAK,GAAG,IAAI,CAAC9B,MAAM,CAACQ,QAAQ,CAAC;MACnC,IAAIsB,KAAK,CAACiB,cAAc,CAAC,aAAa,CAAC,EAAE;QACvC,OAAOjB,KAAK,CAACkB,WAAW;MAC1B;MAEA,IAAMC,WAAW,GAAG,IAAI,CAACC,qBAAqB,CAACpB,KAAK,CAAC;MACrD,IAAI,CAACmB,WAAW,EAAE;QAChB,OAAO,IAAI;MACb;MAEA,IAAMD,WAAW,GAAG,IAAAG,2BAAc,EAACrB,KAAK,EAAEmB,WAAW,CAAC;MACtD,IAAMR,QAAQ,GAAA7D,aAAA,CAAAA,aAAA,KACTkD,KAAK;QACRkB,WAAW,EAAXA;MAAW,EACZ;MAED,IAAI,CAACR,iBAAiB,CAAChC,QAAQ,EAAEiC,QAAQ,CAAC;MAE1C,OAAOO,WAAW;IACpB;;IAEA;AACF;AACA;AACA;AACA;AACA;EALE;IAAArB,GAAA;IAAAvE,KAAA,EAMA,SAAAgG,WAAWA,CAACC,OAAiB,EAAEC,MAAe,EAAEC,GAAsB,EAAe;MAAA,IAAAC,KAAA;MACnF,IAAO3D,aAAa,GAAuD,IAAI,CAAxEA,aAAa;QAAMQ,MAAM,GAA2C,IAAI,CAAzDH,EAAE;QAAwBuD,eAAe,GAAY,IAAI,CAA7CC,YAAY;QAAmB1D,MAAM,GAAI,IAAI,CAAdA,MAAM;;MAEvE;MACA,IAAM0D,YAAY,GAAG,IAAAC,4BAAe,EAACtD,MAAM,EAAEgD,OAAO,EAAEE,GAAG,IAAI,CAAC,CAAC,CAAC;MAEhE,IAAI,CAACG,YAAY,GAAGA,YAAY;MAChC,IAAI,CAAClC,SAAS,GAAG,IAAAC,iCAAiB,EAAC4B,OAAO,EAAEhD,MAAM,EAAEL,MAAM,CAAC;;MAE3D;;MAEA,IAAI,CAACqD,OAAO,CAACvG,MAAM,EAAE;QACnB,IAAI,CAACsE,aAAa,GAAG,IAAI,CAACF,UAAU;QACpC,IAAI,CAACG,sBAAsB,GAAG,IAAI,CAACH,UAAU;QAC7C,OAAO,IAAI;MACb;MAEA,IAAI,CAAC0C,cAAc,GAAG,IAAAC,wBAAW,EAACH,YAAY,EAAED,eAAe,CAAC;;MAEhE;MACA;MACA;MACA,IAAMK,eAAe,GAAG1B,OAAO,CAAC,IAAI,CAACwB,cAAc,CAACG,aAAa,CAAC;MAClE,IAAMC,cAAc,GAAG5B,OAAO,CAAC,IAAI,CAACwB,cAAc,CAACK,GAAG,CAAC;MAEvD,IAAIC,YAA0B,GAAG,CAAC,CAAC;MACnC,IAAIJ,eAAe,IAAIE,cAAc,EAAE;QACrC,IAAMG,oBAAoB,GAAGL,eAAe,GAAGJ,YAAY,CAACK,aAAa,GAAG,IAAI;QAChF,IAAMK,UAAU,GAAGJ,cAAc,GAAGN,YAAY,CAACO,GAAG,GAAG,IAAI;QAE3D,IAAMI,WAAW,GAAGhB,OAAO,CAACiB,MAAM,CAAC,UAACC,GAAG,EAAEhG,MAAM,EAAK;UAClD,IAAMiG,UAAU,GAAG,IAAAC,6CAA6B,EAACjB,KAAI,CAACtD,EAAE,EAAE3B,MAAM,CAAC;UACjE,IAAMuD,KAAK,GAAG0C,UAAU,KAAK,CAAC,CAAC,GAAGxE,MAAM,CAACwE,UAAU,CAAC,GAAG,IAAI;UAE3D,OAAA5F,aAAA,CAAAA,aAAA,KACK2F,GAAG,WAAAxF,gBAAA,iBACLR,MAAM,CAAC2B,EAAE,EAAG,IAAAwE,8BAAiB,EAAC5C,KAAK,EAAE0B,KAAI,CAACtD,EAAE,EAAE3B,MAAM,EAAE+E,MAAM,EAAEzD,aAAa,CAAC;QAEjF,CAAC,EAAE,CAAC,CAAC,CAAC;QAENqE,YAAY,GAAG,IAAAS,oCAAuB,EACpC;UAACR,oBAAoB,EAApBA,oBAAoB;UAAEC,UAAU,EAAVA,UAAU;UAAEC,WAAW,EAAXA;QAAW,CAAC,EAC/CxE,aACF,CAAC;MACH;MAEA,IAAI,CAACuB,aAAa,GAAG8C,YAAY,CAAC9C,aAAa,IAAI,IAAI,CAACA,aAAa;MACrE,IAAI,CAACC,sBAAsB,GACzB6C,YAAY,CAAC7C,sBAAsB,IAAI,IAAI,CAACA,sBAAsB;MAEpE,OAAO,IAAI;IACb;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAM,GAAA;IAAAvE,KAAA,EAKA,SAAAwH,cAAcA,CAACvB,OAAiB,EAAEC,MAAe,EAAe;MAC9D,IAAMC,GAAG,GAAG;QACVsB,OAAO,EAAE,IAAI;QACbC,YAAY,EAAE;MAChB,CAAC;;MAED;MACA,IAAI,CAACzB,OAAO,CAACvG,MAAM,EAAE;QACnB,IAAI,CAACiI,cAAc,GAAG,IAAI,CAAC7D,UAAU;QACrC,IAAI,CAAC8D,eAAe,GAAG,IAAArB,4BAAe,EAAC,IAAI,CAACzD,EAAE,EAAEmD,OAAO,EAAEE,GAAG,CAAC;QAC7D,OAAO,IAAI;MACb;;MAEA;MACA,IAAI,CAACF,OAAO,CAACtB,IAAI,CAAC,UAAA1E,CAAC;QAAA,OAAIA,CAAC,CAAC4H,GAAG;MAAA,EAAC,EAAE;QAC7B,IAAI,CAACF,cAAc,GAAG,IAAI,CAAC3D,aAAa;QACxC,IAAI,CAAC4D,eAAe,GAAG,IAAArB,4BAAe,EAAC,IAAI,CAACzD,EAAE,EAAEmD,OAAO,EAAEE,GAAG,CAAC;QAC7D,OAAO,IAAI;MACb;;MAEA;MACA,IAAM2B,MAAM,GAAGC,SAAS,CAAC,IAAI,CAAC;MAE9BD,MAAM,CAACxB,YAAY,GAAG,IAAI,CAACsB,eAAe;MAC1CE,MAAM,CAAC9D,aAAa,GAAG,IAAI,CAAC2D,cAAc,IAAI,EAAE;MAEhD,IAAMK,QAAQ,GAAGF,MAAM,CAAC9B,WAAW,CAACC,OAAO,EAAEC,MAAM,EAAEC,GAAG,CAAC;MAEzD,IAAI,CAACwB,cAAc,GAAGK,QAAQ,CAAChE,aAAa;MAC5C,IAAI,CAAC4D,eAAe,GAAGI,QAAQ,CAAC1B,YAAY;MAE5C,OAAO,IAAI;IACb;;IAEA;AACF;AACA;AACA;EAHE;IAAA/B,GAAA;IAAAvE,KAAA,EAIA,SAAA8F,qBAAqBA,CAACpB,KAAY,EAAe;MAC/C,IAAOjC,aAAa,GAAI,IAAI,CAArBA,aAAa;MACpB,IAAOa,aAAa,GAAIoB,KAAK,CAAtBpB,aAAa;MAEpB,IAAI2E,MAAM;MAEV,QAAQvD,KAAK,CAACjB,IAAI;QAChB,KAAKC,gCAAe,CAACwE,IAAI;QACzB,KAAKxE,gCAAe,CAACyE,OAAO;UAC1B;UACA,OAAO,IAAAC,kCAAqB,EAAC3F,aAAa,EAAEa,aAAa,CAAC;QAE5D,KAAKI,gCAAe,WAAQ;UAC1B,OAAO;YAACuE,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK;UAAC,CAAC;QAEhC,KAAKvE,gCAAe,CAAC2E,MAAM;QAC3B,KAAK3E,gCAAe,CAACE,IAAI;UACvBqE,MAAM,GAAG,IAAAK,gCAAgB,EAAC7F,aAAa,EAAEa,aAAa,CAAC;UACvD,OAAO;YAAC2E,MAAM,EAANA;UAAM,CAAC;QAEjB,KAAKvE,gCAAe,CAACC,SAAS;UAC5B,OAAO,IAAA4E,oCAAuB,EAAC9F,aAAa,EAAEa,aAAa,CAAC;QAE9D;UACE,OAAO;YAAC2E,MAAM,EAAE,IAAAK,gCAAgB,EAAC7F,aAAa,EAAEa,aAAa;UAAC,CAAC;MACnE;IACF;;IAEA;AACF;AACA;EAFE;IAAAiB,GAAA;IAAAvE,KAAA,EAGA,SAAAwI,oBAAoBA,CAClB9D,KAAY,EACZ+D,SAAiB,EAC8B;MAC/C,IAAOhG,aAAa,GAA4B,IAAI,CAA7CA,aAAa;QAAEwB,sBAAsB,GAAI,IAAI,CAA9BA,sBAAsB;MAE5C,IAAI,CAACyE,4BAAW,CAACD,SAAS,CAAC,EAAE;QAC3BE,gBAAO,CAACC,KAAK,eAAAC,MAAA,CAAeJ,SAAS,mBAAgB,CAAC;QACtD,OAAO,IAAI;MACb;MAEA,IAAOnF,aAAa,GAAIoB,KAAK,CAAtBpB,aAAa;MACpB,IAAMwF,kBAAkB,GAAG,SAArBA,kBAAkBA,CAAG3F,CAAC;QAAA,OAAIG,aAAa,CAAC;UAAC6B,KAAK,EAAEhC;QAAC,CAAC,CAAC;MAAA;MACzD,IAAM4F,YAAY,GAAG,IAAAC,6BAAkB,EAACtE,KAAK,CAACjB,IAAI,CAAC;MAEnD,QAAQgF,SAAS;QACf,KAAKC,4BAAW,CAACO,OAAO;QACxB,KAAKP,4BAAW,CAACQ,KAAK;UACpB;UACA;UACA,OAAO,IAAAZ,gCAAgB,EAAC7F,aAAa,EAAEa,aAAa,CAAC;QAEvD,KAAKoF,4BAAW,CAACS,QAAQ;UACvB,OAAO,IAAAC,iCAAiB,EAACnF,sBAAsB,EAAE6E,kBAAkB,EAAEC,YAAY,CAAC;QAEpF,KAAKL,4BAAW,CAACW,GAAG;UAClB,OAAO,IAAAC,4BAAY,EAACrF,sBAAsB,EAAE6E,kBAAkB,CAAC;QAEjE,KAAKJ,4BAAW,CAACa,QAAQ;QACzB,KAAKb,4BAAW,CAACc,MAAM;QACvB,KAAKd,4BAAW,CAACe,IAAI;QACrB;UACE,OAAO,IAAAC,+BAAe,EAACzF,sBAAsB,EAAE6E,kBAAkB,CAAC;MACtE;IACF;EAAC;IAAAvE,GAAA;IAAAvE,KAAA,EAED,SAAA2J,eAAeA,CAACC,SAAS,EAAEC,UAAU,EAAE;MACrC,IAAMC,4BAA4B,GAAG,EAAE;MACvC,IAAMC,UAAU,GAAG,IAAI,CAACtH,aAAa,CAACuH,QAAQ,CAACJ,SAAS,CAACtG,aAAa,CAAC;MACvE,IAAM2G,WAAW,GAAG,IAAI,CAACxH,aAAa,CAACuH,QAAQ,CAACH,UAAU,CAACvG,aAAa,CAAC;MAEzE,IAAM4G,OAAO,GAAGH,UAAU,CAAC7C,MAAM,CAAC,UAACiD,QAAQ,EAAEC,OAAO,EAAEC,GAAG,EAAK;QAC5DF,QAAQ,CAAC7I,IAAI,CAAC,CAAC8I,OAAO,EAAEH,WAAW,CAACI,GAAG,CAAC,CAAC,CAAC;QAC1C,OAAOF,QAAQ;MACjB,CAAC,EAAE,EAAE,CAAC;MAEN,OAAO,IAAAG,sCAA2B,EAACJ,OAAO,CAAC,CACxChH,GAAG,CAAC,UAAAqH,GAAG,EAAI;QACV,OAAO;UACLvH,KAAK,EAAEuH,GAAG,CAACC,IAAI;UACfnI,KAAK,EAAE,IAAAoI,gCAAoB,EAACF,GAAG,CAACG,KAAK;QACvC,CAAC;MACH,CAAC,CAAC,CACDhK,KAAK,CAAC,CAAC,EAAEoJ,4BAA4B,GAAG,CAAC,CAAC,CAAC,CAAC;IACjD;;IAEA;AACF;AACA;IACE;;IAEA;AACF;AACA;AACA;IACE;;IAEA;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAvF,GAAA;IAAAvE,KAAA,EAKA,SAAA6E,WAAWA,CAAC8F,SAAiB,EAAEC,SAAc,EAAQ;MACnD,IAAI,CAACA,SAAS,EAAE;QACdjC,gBAAO,CAACC,KAAK,IAAAC,MAAA,CAAI8B,SAAS,+BAAA9B,MAAA,CAA4B,IAAI,CAAC/F,EAAE,CAAE,CAAC;MAClE;IACF;EAAC;AAAA,KAGH;AAEO,SAAS+H,yBAAyBA,CAACC,SAAS,EAAEC,MAAM,EAAE;EAC3D,OAAOD,SAAS,CACbE,OAAO,CAAC,IAAIC,MAAM,CAACF,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CACrCC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CACvBE,IAAI,CAAC,CAAC;AACX;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS/G,mBAAmBA,CAACvB,MAAe,EAAe;EAChE,IAAMuI,QAAQ,GAAGvI,MAAM,CAACM,GAAG,CAAC,UAAAjD,CAAC;IAAA,OAAIA,CAAC,CAACW,IAAI,CAACwK,WAAW,CAAC,CAAC;EAAA,EAAC;;EAEtD;EACA,IAAMjE,GAAgB,GAAG,EAAE;EAC3B,IAAMkE,MAAM,GAAGF,QAAQ,CAACjE,MAAM,CAAC,UAACoE,KAAK,EAAEX,SAAS,EAAEN,GAAG,EAAK;IACxD;IAAA,IAAAkB,SAAA,GAAAtM,0BAAA,CACyBuM,kCAAiB;MAAAC,KAAA;IAAA;MAAA,IAAAC,KAAA,YAAAA,MAAA,EAAE;UAAA,IAAjCC,UAAU,GAAAF,KAAA,CAAAzL,KAAA;UACnB;UACA,IAAI2K,SAAS,CAACiB,QAAQ,CAACD,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE;YACrC;YACA,IAAME,YAAY,GAAG,IAAIZ,MAAM,IAAApC,MAAA,CAAI8C,UAAU,CAAC,CAAC,CAAC,MAAI,CAAC;YACrD,IAAMG,OAAO,GAAGnB,SAAS,CAACK,OAAO,CAACa,YAAY,EAAEF,UAAU,CAAC,CAAC,CAAC,CAAC;YAE9D,IAAMI,UAAU,GAAGZ,QAAQ,CAACpG,SAAS,CAAC,UAAAiH,CAAC;cAAA,OAAIA,CAAC,KAAKF,OAAO;YAAA,EAAC;YACzD,IAAIC,UAAU,GAAG,CAAC,CAAC,EAAE;cACnB,IAAME,WAAW,GAAGpB,yBAAyB,CAACF,SAAS,EAAEgB,UAAU,CAAC,CAAC,CAAC,CAAC;cAEvEL,KAAK,CAAChK,IAAI,CAAC;gBACT2K,WAAW,EAAXA,WAAW;gBACXC,IAAI,EAAE;kBACJC,GAAG,EAAE;oBACH/I,QAAQ,EAAEiH,GAAG;oBACbrK,KAAK,EAAE4C,MAAM,CAACyH,GAAG,CAAC,CAACzJ;kBACrB,CAAC;kBACDwL,GAAG,EAAE;oBACHhJ,QAAQ,EAAE2I,UAAU;oBACpB/L,KAAK,EAAE4C,MAAM,CAACmJ,UAAU,CAAC,CAACnL;kBAC5B;gBACF,CAAC;gBACDmK,MAAM,EAAEY;cACV,CAAC,CAAC;cAAC;gBAAAU,CAAA,EACIf;cAAK;YACd;UACF;QACF,CAAC;QAAAgB,IAAA;MA5BD,KAAAf,SAAA,CAAA1L,CAAA,MAAA4L,KAAA,GAAAF,SAAA,CAAAzL,CAAA,IAAAC,IAAA;QAAAuM,IAAA,GAAAZ,KAAA;QAAA,IAAAY,IAAA,SAAAA,IAAA,CAAAD,CAAA;MAAA;IA4BC,SAAAE,GAAA;MAAAhB,SAAA,CAAApM,CAAA,CAAAoN,GAAA;IAAA;MAAAhB,SAAA,CAAAtL,CAAA;IAAA;IACD,OAAOqL,KAAK;EACd,CAAC,EAAEnE,GAAG,CAAC;;EAEP;EACAkE,MAAM,CAACmB,IAAI,CAAC,UAACpM,CAAC,EAAEqM,CAAC,EAAK;IACpB,IAAIrM,CAAC,CAAC6L,WAAW,KAAK,EAAE,IAAI7L,CAAC,CAAC2K,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,OAAO,CAAC,CAAC;IACjE,IAAI0B,CAAC,CAACR,WAAW,KAAK,EAAE,IAAIQ,CAAC,CAAC1B,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,OAAO,CAAC;IAChE,OAAO,CAAC;EACV,CAAC,CAAC;EAEF,OAAOM,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASqB,mBAAmBA,CACjCC,OAAoB,EACpBC,MAAc,EACdC,IAAa,EACA;EACb,IAAO/I,UAAU,GAA2B6I,OAAO,CAA5C7I,UAAU;IAAElB,MAAM,GAAmB+J,OAAO,CAAhC/J,MAAM;IAAEH,aAAa,GAAIkK,OAAO,CAAxBlK,aAAa;EACxC,IAAM2E,UAAU,GAAGxE,MAAM,CAACmC,SAAS,CAAC,UAAA9E,CAAC;IAAA,OAAIA,CAAC,CAACW,IAAI,KAAKgM,MAAM;EAAA,EAAC;EAC3D,IAAIxF,UAAU,GAAG,CAAC,EAAE;IAClB,OAAOuF,OAAO;EAChB;EAEA,IAAMG,MAAM,GAAGC,2BAAU,CAACF,IAAI,IAAI,EAAE,CAAC,IAAIE,2BAAU,CAACC,SAAS;EAE7D,IAAIF,MAAM,KAAKC,2BAAU,CAACE,MAAM,EAAE;IAChCN,OAAO,CAACO,UAAU,GAAG,CAAC,CAAC;IACvBP,OAAO,CAACQ,SAAS,GAAG,IAAI;IAExB,OAAOR,OAAO;EAChB;EAEA,IAAM5D,YAAY,GAAG+D,MAAM,KAAKC,2BAAU,CAACC,SAAS,GAAGI,kBAAS,GAAGC,mBAAU;EAC7E,IAAMF,SAAS,GAAGrJ,UAAU,CACzBpD,KAAK,CAAC,CAAC,CACP8L,IAAI,CAAC,UAACpM,CAAC,EAAEqM,CAAC;IAAA,OACT1D,YAAY,CAACtG,aAAa,CAAC6K,OAAO,CAAClN,CAAC,EAAEgH,UAAU,CAAC,EAAE3E,aAAa,CAAC6K,OAAO,CAACb,CAAC,EAAErF,UAAU,CAAC,CAAC;EAAA,CAC1F,CAAC;EAEHuF,OAAO,CAACO,UAAU,OAAAvL,gBAAA,iBACfiL,MAAM,EAAGE,MAAM,CACjB;EACDH,OAAO,CAACQ,SAAS,GAAGA,SAAS;EAE7B,OAAOR,OAAO;AAChB;AAEO,SAASY,eAAeA,CAACZ,OAAoB,EAAEC,MAAc,EAAe;EACjF,IAAMlI,KAAK,GAAGiI,OAAO,CAACnI,cAAc,CAACoI,MAAM,CAAC;EAC5C,IAAI,CAAClI,KAAK,EAAE;IACV,OAAOiI,OAAO;EAChB;EAEA,IAAIa,aAAa;EACjB,IAAIjO,KAAK,CAACC,OAAO,CAACmN,OAAO,CAACa,aAAa,CAAC,IAAIb,OAAO,CAACa,aAAa,CAACC,QAAQ,CAAC/I,KAAK,CAAC9D,IAAI,CAAC,EAAE;IACtF;IACA4M,aAAa,GAAGb,OAAO,CAACa,aAAa,CAACrM,MAAM,CAAC,UAAAuM,EAAE;MAAA,OAAIA,EAAE,KAAKhJ,KAAK,CAAC9D,IAAI;IAAA,EAAC;EACvE,CAAC,MAAM;IACL4M,aAAa,GAAG,CAACb,OAAO,CAACa,aAAa,IAAI,EAAE,EAAE3E,MAAM,CAACnE,KAAK,CAAC9D,IAAI,CAAC;EAClE;;EAEA;EACA,OAAO+M,kBAAkB,CAAChB,OAAO,EAAE;IAACa,aAAa,EAAbA;EAAa,CAAC,CAAC;AACrD;AACO,SAASzF,SAASA,CAAe6F,QAAW,EAAK;EACtD,OAAO5M,MAAM,CAACsE,MAAM,CAACtE,MAAM,CAAC6M,MAAM,CAAC7M,MAAM,CAAC8M,cAAc,CAACF,QAAQ,CAAC,CAAC,EAAEA,QAAQ,CAAC;AAChF;;AAEA;AACA;AACA;AACA;AACO,SAASD,kBAAkBA,CAAeC,QAAW,EAA+B;EAAA,IAA7BG,OAAmB,GAAAtM,SAAA,CAAA/B,MAAA,QAAA+B,SAAA,QAAAuM,SAAA,GAAAvM,SAAA,MAAG,CAAC,CAAC;EACpF,OAAOT,MAAM,CAACiN,OAAO,CAACF,OAAO,CAAC,CAAC7G,MAAM,CAAC,UAACC,GAAG,EAAE+G,KAAK,EAAK;IACpD/G,GAAG,CAAC+G,KAAK,CAAC,CAAC,CAAC,CAAC,GAAGA,KAAK,CAAC,CAAC,CAAC;IACxB,OAAO/G,GAAG;EACZ,CAAC,EAAEY,SAAS,CAAC6F,QAAQ,CAAC,CAAC;AACzB;AAAC,IAAAO,QAAA,GAAAC,OAAA,cAEcpM,WAAW","ignoreList":[]}
+var _default = exports.default = KeplerTable;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_console","require","_defaultSettings","_d3Array","_utils","_gpuFilterUtils","_filterUtils","_dataUtils","_dataScaleUtils","_dataContainerUtils","_colorUtils","FID_KEY","KeplerTable","constructor","_ref","info","data","color","metadata","supportedFilterTypes","_defineProperty2","default","dataContainer","createDataContainer","rows","fields","datasetInfo","id","generateHashId","label","dataId","map","f","i","fieldIdx","name","displayName","valueAccessor","maybeToDate","bind","type","ALL_FIELD_TYPES","timestamp","date","format","allIndexes","getPlainIndex","filteredIndex","filteredIndexForDomain","fieldPairs","findPointFieldPairs","gpuFilter","getGpuFilterProps","getColumnField","columnName","field","find","fd","_assetField","getColumnFieldIdx","findIndex","Boolean","getValue","rowIdx","index","updateColumnField","newField","Object","assign","updateTableColor","newColor","getColumnFilterProps","hasOwnProperty","filterProps","fieldDomain","getColumnFilterDomain","getFilterProps","filterTable","filters","layers","opt","filterRecord","oldFilterRecord","getFilterRecord","length","changedFilters","diffFilters","shouldCalDomain","dynamicDomain","shouldCalIndex","cpu","filterResult","dynamicDomainFilters","cpuFilters","filterFuncs","reduce","acc","filter","fieldIndex","getDatasetFieldIndexForFilter","getFilterFunction","filterDataByFilterTypes","filterTableCPU","cpuOnly","ignoreDomain","filteredIdxCPU","filterRecordCPU","gpu","copied","copyTable","filtered","domain","real","integer","getNumericFieldDomain","boolean","string","getOrdinalDomain","getTimestampFieldDomain","getColumnLayerDomain","scaleType","SCALE_TYPES","Console","error","indexValueAccessor","sortFunction","getSortingFunction","ordinal","point","quantile","getQuantileDomain","log","getLogDomain","quantize","linear","sqrt","getLinearDomain","calculateLegend","leftField","rightField","limitOfNumberOfLegendEntries","leftValues","mapIndex","rightValues","pairing","previous","current","idx","push","uniqueSortedPairByFrequency","row","left","checkColorOrFallback","right","slice","fieldName","condition","removeSuffixAndDelimiters","layerName","suffix","replace","RegExp","trim","allNames","toLowerCase","result","carry","suffixPair","TRIP_POINT_FIELDS","endsWith","otherPattern","partner","partnerIdx","d","defaultName","pair","lat","value","lng","sort","a","b","sortDatasetByColumn","dataset","column","mode","sortBy","SORT_ORDER","ASCENDING","UNSORT","sortColumn","sortOrder","ascending","descending","valueAt","pinTableColumns","pinnedColumns","Array","isArray","includes","co","concat","copyTableAndUpdate","original","create","getPrototypeOf","options","arguments","undefined","entries","entry","_default","exports"],"sources":["../../../src/utils/table-utils/kepler-table.ts"],"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 {console as Console} from 'global/console';\nimport {TRIP_POINT_FIELDS, SORT_ORDER} from 'constants/default-settings';\nimport {ascending, descending} from 'd3-array';\n\n// import {validateInputData} from 'processors/data-processor';\nimport {generateHashId} from 'utils/utils';\nimport {getGpuFilterProps, getDatasetFieldIndexForFilter} from 'utils/gpu-filter-utils';\nimport {\n  getFilterProps,\n  getFilterRecord,\n  diffFilters,\n  getFilterFunction,\n  filterDataByFilterTypes,\n  getNumericFieldDomain,\n  getTimestampFieldDomain,\n  FilterResult\n} from 'utils/filter-utils';\nimport {maybeToDate, getSortingFunction} from 'utils/data-utils';\nimport {\n  getQuantileDomain,\n  getOrdinalDomain,\n  getLogDomain,\n  getLinearDomain\n} from 'utils/data-scale-utils';\n\nimport {ALL_FIELD_TYPES, SCALE_TYPES} from 'constants/default-settings';\n\nimport {createDataContainer} from './data-container-utils';\nimport {uniqueSortedPairByFrequency} from 'utils/data-utils';\nimport {checkColorOrFallback} from 'utils/color-utils';\n\nimport {RGBColor} from 'reducers/types';\nimport {Layer} from 'layers';\nimport {FieldDomain, Filter} from 'reducers/vis-state-updaters';\nimport {DataContainerInterface} from './data-container-interface';\nimport {ProtoDataset} from 'actions';\n\nexport type Field = {\n  analyzerType: string;\n  id?: string;\n  name: string;\n  displayName: string;\n  format: string;\n  type: string;\n  fieldIdx: number;\n  valueAccessor(v: {index: number}): any;\n  filterProps?: any;\n  metadata?: any;\n};\n\nexport type GpuFilter = {\n  filterRange: number[][];\n  filterValueUpdateTriggers: any;\n  filterValueAccessor: (\n    dc: DataContainerInterface\n  ) => (\n    getIndex?: (any) => number,\n    getData?: (dc: DataContainerInterface, d: any, fieldIndex: number) => any\n  ) => (d: any) => number;\n};\n\nexport type FieldPair = {\n  defaultName: string;\n  pair: {\n    [key: string]: {\n      fieldIdx: number;\n      value: string;\n    };\n  };\n  suffix: string[];\n};\n\nexport type FilterRecord = {\n  dynamicDomain: Filter[];\n  fixedDomain: Filter[];\n  cpu: Filter[];\n  gpu: Filter[];\n};\n\nexport type FilterDatasetOpt = {\n  // only allow cpu filtering\n  cpuOnly?: boolean;\n  // ignore filter for domain calculation\n  ignoreDomain?: boolean;\n};\n\n// Unique identifier of each field\nconst FID_KEY = 'name';\n\nclass KeplerTable {\n  readonly id: string;\n\n  type?: string;\n  label: string;\n  color: RGBColor;\n\n  // fields and data\n  fields: Field[];\n\n  dataContainer: DataContainerInterface;\n\n  allIndexes: number[];\n  filteredIndex: number[];\n  filteredIdxCPU?: number[];\n  filteredIndexForDomain: number[];\n  fieldPairs: FieldPair[];\n  gpuFilter: GpuFilter;\n  filterRecord?: FilterRecord;\n  filterRecordCPU?: FilterRecord;\n  changedFilters?: any;\n\n  // table-injected metadata\n  sortColumn?: {\n    // column name: sorted idx\n    [key: string]: string; // ASCENDING | DESCENDING | UNSORT\n  };\n  sortOrder?: number[] | null;\n\n  pinnedColumns?: string[];\n  supportedFilterTypes: string[] | undefined;\n  // table-injected metadata\n  metadata: object;\n\n  constructor({\n    info = {},\n    data,\n    color,\n    metadata,\n    supportedFilterTypes\n  }: {\n    info?: ProtoDataset['info'];\n    data: ProtoDataset['data'];\n    color: RGBColor;\n    metadata?: ProtoDataset['metadata'];\n    supportedFilterTypes?: ProtoDataset['supportedFilterTypes'];\n  }) {\n    // TODO - what to do if validation fails? Can kepler handle exceptions?\n    // const validatedData = validateInputData(data);\n    // if (!validatedData) {\n    //   return this;\n    // }\n\n    // @ts-expect-error\n    const dataContainer = createDataContainer(data.rows, {fields: data.fields});\n\n    const datasetInfo = {\n      id: generateHashId(4),\n      label: 'new dataset',\n      ...(info || {})\n    };\n    const dataId = datasetInfo.id;\n    // @ts-expect-error\n    const fields: Field[] = data.fields.map((f, i) => ({\n      ...f,\n      fieldIdx: i,\n      id: f.name,\n      displayName: f.displayName || f.name,\n      valueAccessor: maybeToDate.bind(\n        null,\n        // is time\n        f.type === ALL_FIELD_TYPES.timestamp || f.type === ALL_FIELD_TYPES.date,\n        i,\n        f.format,\n        dataContainer\n      )\n    }));\n\n    const allIndexes = dataContainer.getPlainIndex();\n\n    this.id = datasetInfo.id;\n    this.label = datasetInfo.label;\n    this.color = color;\n    this.metadata = {\n      ...metadata,\n      id: datasetInfo.id,\n      label: datasetInfo.label\n    };\n\n    this.dataContainer = dataContainer;\n    this.allIndexes = allIndexes;\n    this.filteredIndex = allIndexes;\n    this.filteredIndexForDomain = allIndexes;\n    this.fieldPairs = findPointFieldPairs(fields);\n    this.fields = fields;\n    this.gpuFilter = getGpuFilterProps([], dataId, fields);\n    if (supportedFilterTypes) {\n      this.supportedFilterTypes = supportedFilterTypes;\n    }\n  }\n\n  /**\n   * Get field\n   * @param columnName\n   */\n  getColumnField(columnName: string): Field | undefined {\n    const field = this.fields.find(fd => fd[FID_KEY] === columnName);\n    this._assetField(columnName, field);\n    return field;\n  }\n\n  /**\n   * Get fieldIdx\n   * @param columnName\n   */\n  getColumnFieldIdx(columnName: string): number {\n    const fieldIdx = this.fields.findIndex(fd => fd[FID_KEY] === columnName);\n    this._assetField(columnName, Boolean(fieldIdx > -1));\n    return fieldIdx;\n  }\n\n  /**\n   * Get the value of a cell\n   */\n  getValue(columnName: string, rowIdx: number): any {\n    const field = this.getColumnField(columnName);\n    return field ? field.valueAccessor({index: rowIdx}) : null;\n  }\n\n  /**\n   * Updates existing field with a new object\n   * @param fieldIdx\n   * @param newField\n   */\n  updateColumnField(fieldIdx: number, newField: Field): void {\n    this.fields = Object.assign([...this.fields], {[fieldIdx]: newField});\n  }\n\n  /**\n   * Update dataset color by custom color\n   * @param newColor\n   */\n  updateTableColor(newColor: RGBColor): void {\n    this.color = newColor;\n  }\n\n  /**\n   * Save filterProps to field and retrieve it\n   * @param columnName\n   */\n  getColumnFilterProps(columnName: string): Field['filterProps'] | null | undefined {\n    const fieldIdx = this.getColumnFieldIdx(columnName);\n    if (fieldIdx < 0) {\n      return null;\n    }\n    const field = this.fields[fieldIdx];\n    if (field.hasOwnProperty('filterProps')) {\n      return field.filterProps;\n    }\n\n    const fieldDomain = this.getColumnFilterDomain(field);\n    if (!fieldDomain) {\n      return null;\n    }\n\n    const filterProps = getFilterProps(field, fieldDomain);\n    const newField = {\n      ...field,\n      filterProps\n    };\n\n    this.updateColumnField(fieldIdx, newField);\n\n    return filterProps;\n  }\n\n  /**\n   * Apply filters to dataset, return the filtered dataset with updated `gpuFilter`, `filterRecord`, `filteredIndex`, `filteredIndexForDomain`\n   * @param filters\n   * @param layers\n   * @param opt\n   */\n  filterTable(filters: Filter[], layers: Layer[], opt?: FilterDatasetOpt): KeplerTable {\n    const {dataContainer, id: dataId, filterRecord: oldFilterRecord, fields} = this;\n\n    // if there is no filters\n    const filterRecord = getFilterRecord(dataId, filters, opt || {});\n\n    this.filterRecord = filterRecord;\n    this.gpuFilter = getGpuFilterProps(filters, dataId, fields);\n\n    // const newDataset = set(['filterRecord'], filterRecord, dataset);\n\n    if (!filters.length) {\n      this.filteredIndex = this.allIndexes;\n      this.filteredIndexForDomain = this.allIndexes;\n      return this;\n    }\n\n    this.changedFilters = diffFilters(filterRecord, oldFilterRecord);\n\n    // generate 2 sets of filter result\n    // filteredIndex used to calculate layer data\n    // filteredIndexForDomain used to calculate layer Domain\n    const shouldCalDomain = Boolean(this.changedFilters.dynamicDomain);\n    const shouldCalIndex = Boolean(this.changedFilters.cpu);\n\n    let filterResult: FilterResult = {};\n    if (shouldCalDomain || shouldCalIndex) {\n      const dynamicDomainFilters = shouldCalDomain ? filterRecord.dynamicDomain : null;\n      const cpuFilters = shouldCalIndex ? filterRecord.cpu : null;\n\n      const filterFuncs = filters.reduce((acc, filter) => {\n        const fieldIndex = getDatasetFieldIndexForFilter(this.id, filter);\n        const field = fieldIndex !== -1 ? fields[fieldIndex] : null;\n\n        return {\n          ...acc,\n          [filter.id]: getFilterFunction(field, this.id, filter, layers, dataContainer)\n        };\n      }, {});\n\n      filterResult = filterDataByFilterTypes(\n        {dynamicDomainFilters, cpuFilters, filterFuncs},\n        dataContainer\n      );\n    }\n\n    this.filteredIndex = filterResult.filteredIndex || this.filteredIndex;\n    this.filteredIndexForDomain =\n      filterResult.filteredIndexForDomain || this.filteredIndexForDomain;\n\n    return this;\n  }\n\n  /**\n   * Apply filters to a dataset all on CPU, assign to `filteredIdxCPU`, `filterRecordCPU`\n   * @param filters\n   * @param layers\n   */\n  filterTableCPU(filters: Filter[], layers: Layer[]): KeplerTable {\n    const opt = {\n      cpuOnly: true,\n      ignoreDomain: true\n    };\n\n    // no filter\n    if (!filters.length) {\n      this.filteredIdxCPU = this.allIndexes;\n      this.filterRecordCPU = getFilterRecord(this.id, filters, opt);\n      return this;\n    }\n\n    // no gpu filter\n    if (!filters.find(f => f.gpu)) {\n      this.filteredIdxCPU = this.filteredIndex;\n      this.filterRecordCPU = getFilterRecord(this.id, filters, opt);\n      return this;\n    }\n\n    // make a copy for cpu filtering\n    const copied = copyTable(this);\n\n    copied.filterRecord = this.filterRecordCPU;\n    copied.filteredIndex = this.filteredIdxCPU || [];\n\n    const filtered = copied.filterTable(filters, layers, opt);\n\n    this.filteredIdxCPU = filtered.filteredIndex;\n    this.filterRecordCPU = filtered.filterRecord;\n\n    return this;\n  }\n\n  /**\n   * Calculate field domain based on field type and data\n   * for Filter\n   */\n  getColumnFilterDomain(field: Field): FieldDomain {\n    const {dataContainer} = this;\n    const {valueAccessor} = field;\n\n    let domain;\n\n    switch (field.type) {\n      case ALL_FIELD_TYPES.real:\n      case ALL_FIELD_TYPES.integer:\n        // calculate domain and step\n        return getNumericFieldDomain(dataContainer, valueAccessor);\n\n      case ALL_FIELD_TYPES.boolean:\n        return {domain: [true, false]};\n\n      case ALL_FIELD_TYPES.string:\n      case ALL_FIELD_TYPES.date:\n        domain = getOrdinalDomain(dataContainer, valueAccessor);\n        return {domain};\n\n      case ALL_FIELD_TYPES.timestamp:\n        return getTimestampFieldDomain(dataContainer, valueAccessor);\n\n      default:\n        return {domain: getOrdinalDomain(dataContainer, valueAccessor)};\n    }\n  }\n\n  /**\n   *  Get the domain of this column based on scale type\n   */\n  getColumnLayerDomain(\n    field: Field,\n    scaleType: string\n  ): number[] | string[] | [number, number] | null {\n    const {dataContainer, filteredIndexForDomain} = this;\n\n    if (!SCALE_TYPES[scaleType]) {\n      Console.error(`scale type ${scaleType} not supported`);\n      return null;\n    }\n\n    const {valueAccessor} = field;\n    const indexValueAccessor = i => valueAccessor({index: i});\n    const sortFunction = getSortingFunction(field.type);\n\n    switch (scaleType) {\n      case SCALE_TYPES.ordinal:\n      case SCALE_TYPES.point:\n        // do not recalculate ordinal domain based on filtered data\n        // don't need to update ordinal domain every time\n        return getOrdinalDomain(dataContainer, valueAccessor);\n\n      case SCALE_TYPES.quantile:\n        return getQuantileDomain(filteredIndexForDomain, indexValueAccessor, sortFunction);\n\n      case SCALE_TYPES.log:\n        return getLogDomain(filteredIndexForDomain, indexValueAccessor);\n\n      case SCALE_TYPES.quantize:\n      case SCALE_TYPES.linear:\n      case SCALE_TYPES.sqrt:\n      default:\n        return getLinearDomain(filteredIndexForDomain, indexValueAccessor);\n    }\n  }\n\n  calculateLegend(leftField, rightField) {\n    const limitOfNumberOfLegendEntries = 20;\n    const leftValues = this.dataContainer.mapIndex(leftField.valueAccessor);\n    const rightValues = this.dataContainer.mapIndex(rightField.valueAccessor);\n\n    const pairing = leftValues.reduce((previous, current, idx) => {\n      previous.push([current, rightValues[idx]]);\n      return previous;\n    }, []);\n\n    return uniqueSortedPairByFrequency(pairing)\n      .map(row => {\n        return {\n          label: row.left,\n          color: checkColorOrFallback(row.right)\n        };\n      })\n      .slice(0, limitOfNumberOfLegendEntries + 1); // Limit to limitOfNumberOfLegendEntries + 1, then limit to limitOfNumberOfLegendEntries in LegendManagers\n  }\n\n  /**\n   * Get a sample of rows to calculate layer boundaries\n   */\n  // getSampleData(rows)\n\n  /**\n   * Parse cell value based on column type and return a string representation\n   * Value the field value, type the field type\n   */\n  // parseFieldValue(value, type)\n\n  // sortDatasetByColumn()\n\n  /**\n   * Assert whether field exist\n   * @param fieldName\n   * @param condition\n   */\n  _assetField(fieldName: string, condition: any): void {\n    if (!condition) {\n      Console.error(`${fieldName} doesnt exist in dataset ${this.id}`);\n    }\n  }\n}\n\n// HELPER FUNCTIONS (MAINLY EXPORTED FOR TEST...)\n\nexport function removeSuffixAndDelimiters(layerName, suffix) {\n  return layerName\n    .replace(new RegExp(suffix, 'ig'), '')\n    .replace(/[_,.]+/g, ' ')\n    .trim();\n}\n\n/**\n * Find point fields pairs from fields\n *\n * @param fields\n * @returns found point fields\n */\nexport function findPointFieldPairs(fields: Field[]): FieldPair[] {\n  const allNames = fields.map(f => f.name.toLowerCase());\n\n  // get list of all fields with matching suffixes\n  const acc: FieldPair[] = [];\n  const result = allNames.reduce((carry, fieldName, idx) => {\n    // This search for pairs will early exit if found.\n    for (const suffixPair of TRIP_POINT_FIELDS) {\n      // match first suffix```\n      if (fieldName.endsWith(suffixPair[0])) {\n        // match second suffix\n        const otherPattern = new RegExp(`${suffixPair[0]}\\$`);\n        const partner = fieldName.replace(otherPattern, suffixPair[1]);\n\n        const partnerIdx = allNames.findIndex(d => d === partner);\n        if (partnerIdx > -1) {\n          const defaultName = removeSuffixAndDelimiters(fieldName, suffixPair[0]);\n\n          carry.push({\n            defaultName,\n            pair: {\n              lat: {\n                fieldIdx: idx,\n                value: fields[idx].name\n              },\n              lng: {\n                fieldIdx: partnerIdx,\n                value: fields[partnerIdx].name\n              }\n            },\n            suffix: suffixPair\n          });\n          return carry;\n        }\n      }\n    }\n    return carry;\n  }, acc);\n\n  // prioritize the 'latitude'/'longitude' pair\n  result.sort((a, b) => {\n    if (a.defaultName === '' && a.suffix[0] === 'latitude') return -1;\n    if (b.defaultName === '' && b.suffix[0] === 'latitude') return 1;\n    return 0;\n  });\n\n  return result;\n}\n\n/**\n *\n * @param dataset\n * @param column\n * @param mode\n * @type\n */\nexport function sortDatasetByColumn(\n  dataset: KeplerTable,\n  column: string,\n  mode?: string\n): KeplerTable {\n  const {allIndexes, fields, dataContainer} = dataset;\n  const fieldIndex = fields.findIndex(f => f.name === column);\n  if (fieldIndex < 0) {\n    return dataset;\n  }\n\n  const sortBy = SORT_ORDER[mode || ''] || SORT_ORDER.ASCENDING;\n\n  if (sortBy === SORT_ORDER.UNSORT) {\n    dataset.sortColumn = {};\n    dataset.sortOrder = null;\n\n    return dataset;\n  }\n\n  const sortFunction = sortBy === SORT_ORDER.ASCENDING ? ascending : descending;\n  const sortOrder = allIndexes\n    .slice()\n    .sort((a, b) =>\n      sortFunction(dataContainer.valueAt(a, fieldIndex), dataContainer.valueAt(b, fieldIndex))\n    );\n\n  dataset.sortColumn = {\n    [column]: sortBy\n  };\n  dataset.sortOrder = sortOrder;\n\n  return dataset;\n}\n\nexport function pinTableColumns(dataset: KeplerTable, column: string): KeplerTable {\n  const field = dataset.getColumnField(column);\n  if (!field) {\n    return dataset;\n  }\n\n  let pinnedColumns;\n  if (Array.isArray(dataset.pinnedColumns) && dataset.pinnedColumns.includes(field.name)) {\n    // unpin it\n    pinnedColumns = dataset.pinnedColumns.filter(co => co !== field.name);\n  } else {\n    pinnedColumns = (dataset.pinnedColumns || []).concat(field.name);\n  }\n\n  // @ts-ignore\n  return copyTableAndUpdate(dataset, {pinnedColumns});\n}\nexport function copyTable<T extends {}>(original: T): T {\n  return Object.assign(Object.create(Object.getPrototypeOf(original)), original);\n}\n\n/**\n * @type\n * @returns\n */\nexport function copyTableAndUpdate<T extends {}>(original: T, options: Partial<T> = {}): T {\n  return Object.entries(options).reduce((acc, entry) => {\n    acc[entry[0]] = entry[1];\n    return acc;\n  }, copyTable(original));\n}\n\nexport default KeplerTable;\n"],"mappings":"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","ignoreList":[]}