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

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

@@ -0,0 +1,544 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeSuffixAndDelimiters = removeSuffixAndDelimiters;
+exports.findPointFieldPairs = findPointFieldPairs;
+exports.sortDatasetByColumn = sortDatasetByColumn;
+exports.copyTable = copyTable;
+exports.copyTableAndUpdate = copyTableAndUpdate;
+exports["default"] = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+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");
+
+var _utils = require("../utils");
+
+var _gpuFilterUtils = require("../gpu-filter-utils");
+
+var _filterUtils = require("../filter-utils");
+
+var _dataUtils = require("../data-utils");
+
+var _dataScaleUtils = require("../data-scale-utils");
+
+var _dataContainerUtils = require("./data-container-utils");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+// Unique identifier of each field
+var FID_KEY = 'name';
+/** @typedef {import('./kepler-table').KeplerTable} KeplerTableClass} */
+
+/**
+ * @type {KeplerTableClass}
+ */
+
+var KeplerTable = /*#__PURE__*/function () {
+  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);
+    // TODO - what to do if validation fails? Can kepler handle exceptions?
+    // const validatedData = validateInputData(data);
+    // if (!validatedData) {
+    //   return this;
+    // }
+    var dataContainer = (0, _dataContainerUtils.createDataContainer)(data.rows, {
+      fields: data.fields
+    });
+
+    var datasetInfo = _objectSpread({
+      id: (0, _utils.generateHashId)(4),
+      label: 'new dataset'
+    }, info || {});
+
+    var dataId = datasetInfo.id;
+    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();
+    this.id = datasetInfo.id;
+    this.label = datasetInfo.label;
+    this.color = color;
+    this.metadata = _objectSpread(_objectSpread({}, metadata), {}, {
+      id: datasetInfo.id,
+      label: datasetInfo.label
+    });
+    this.dataContainer = dataContainer;
+    this.allIndexes = allIndexes;
+    this.filteredIndex = allIndexes;
+    this.filteredIndexForDomain = allIndexes;
+    this.fieldPairs = findPointFieldPairs(fields);
+    this.fields = fields;
+    this.gpuFilter = (0, _gpuFilterUtils.getGpuFilterProps)([], dataId, fields);
+
+    if (supportedFilterTypes) {
+      this.supportedFilterTypes = supportedFilterTypes;
+    }
+  }
+  /**
+   * Get field
+   * @param columnName
+   */
+
+
+  (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;
+    }
+    /**
+     * 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 the value of a cell
+     */
+
+  }, {
+    key: "getValue",
+    value: function getValue(columnName, rowIdx) {
+      var 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));
+    }
+    /**
+     * Save filterProps to field and retrieve it
+     * @param {string} 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;
+    }
+    /**
+     * 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;
+      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;
+      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)
+          };
+      }
+    }
+    /**
+     *  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);
+      }
+    }
+    /**
+     * 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));
+      }
+    }
+  }]);
+  return KeplerTable;
+}(); // HELPER FUNCTIONS (MAINLY EXPORTED FOR TEST...)
+
+
+function removeSuffixAndDelimiters(layerName, suffix) {
+  return layerName.replace(new RegExp(suffix, 'ig'), '').replace(/[_,.]+/g, ' ').trim();
+}
+/**
+ * Find point fields pairs from fields
+ *
+ * @param fields
+ * @returns found point fields
+ * @type {typeof import('./kepler-table').findPointFieldPairs}
+ */
+
+
+function findPointFieldPairs(fields) {
+  var allNames = fields.map(function (f) {
+    return f.name.toLowerCase();
+  }); // get list of all fields with matching suffixes
+
+  var acc = [];
+  var result = allNames.reduce(function (carry, fieldName, idx) {
+    // This search for pairs will early exit if found.
+    var _iterator = _createForOfIteratorHelper(_defaultSettings.TRIP_POINT_FIELDS),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var suffixPair = _step.value;
+
+        // match first suffix```
+        if (fieldName.endsWith(suffixPair[0])) {
+          var _ret = function () {
+            // 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
+              };
+            }
+          }();
+
+          if ((0, _typeof2["default"])(_ret) === "object") return _ret.v;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return carry;
+  }, acc); // prioritize the 'latitude'/'longitude' pair
+
+  result.sort(function (a, b) {
+    if (a.defaultName === '' && a.suffix[0] === 'latitude') return -1;
+    if (b.defaultName === '' && b.suffix[0] === 'latitude') return 1;
+    return 0;
+  });
+  return result;
+}
+/**
+ *
+ * @param dataset
+ * @param column
+ * @param mode
+ * @type {typeof import('./kepler-table').sortDatasetByColumn}
+ */
+
+
+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;
+  });
+
+  if (fieldIndex < 0) {
+    return dataset;
+  }
+
+  var sortBy = _defaultSettings.SORT_ORDER[mode] || _defaultSettings.SORT_ORDER.ASCENDING;
+
+  if (sortBy === _defaultSettings.SORT_ORDER.UNSORT) {
+    return _objectSpread(_objectSpread({}, dataset), {}, {
+      sortColumn: {},
+      sortOrder: null
+    });
+  }
+
+  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));
+  });
+  return _objectSpread(_objectSpread({}, dataset), {}, {
+    sortColumn: (0, _defineProperty2["default"])({}, column, sortBy),
+    sortOrder: sortOrder
+  });
+}
+
+function copyTable(original) {
+  return Object.assign(Object.create(Object.getPrototypeOf(original)), original);
+}
+
+function copyTableAndUpdate(original) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return Object.entries(options).reduce(function (acc, entry) {
+    acc[entry[0]] = entry[1];
+    return acc;
+  }, copyTable(original));
+}
+
+var _default = KeplerTable;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/utils/table-utils/kepler-table.js"],"names":["FID_KEY","KeplerTable","info","data","color","metadata","supportedFilterTypes","dataContainer","rows","fields","datasetInfo","id","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","columnName","field","find","fd","_assetField","findIndex","Boolean","rowIdx","getColumnField","index","newField","Object","assign","getColumnFieldIdx","hasOwnProperty","filterProps","fieldDomain","getColumnFilterDomain","updateColumnField","filters","layers","opt","oldFilterRecord","filterRecord","length","changedFilters","shouldCalDomain","dynamicDomain","shouldCalIndex","cpu","filterResult","dynamicDomainFilters","cpuFilters","filterFuncs","reduce","acc","filter","fieldIndex","cpuOnly","ignoreDomain","filteredIdxCPU","filterRecordCPU","gpu","copied","copyTable","filtered","filterTable","domain","real","integer","string","scaleType","SCALE_TYPES","Console","error","indexValueAccessor","sortFunction","ordinal","point","quantile","log","quantize","linear","sqrt","fieldName","condition","removeSuffixAndDelimiters","layerName","suffix","replace","RegExp","trim","allNames","toLowerCase","result","carry","idx","TRIP_POINT_FIELDS","suffixPair","endsWith","otherPattern","partner","partnerIdx","d","defaultName","push","pair","lat","value","lng","sort","a","b","sortDatasetByColumn","dataset","column","mode","sortBy","SORT_ORDER","ASCENDING","UNSORT","sortColumn","sortOrder","ascending","descending","slice","valueAt","original","create","getPrototypeOf","copyTableAndUpdate","options","entries","entry"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {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} 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';\n\n// Unique identifier of each field\nconst FID_KEY = 'name';\n\n/** @typedef {import('./kepler-table').KeplerTable} KeplerTableClass} */\n\n/**\n * @type {KeplerTableClass}\n */\nclass KeplerTable {\n  constructor({info = {}, data, color, metadata, supportedFilterTypes}) {\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    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\n    const fields = 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) {\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) {\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, rowIdx) {\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, newField) {\n    this.fields = Object.assign([...this.fields], {[fieldIdx]: newField});\n  }\n\n  /**\n   * Save filterProps to field and retrieve it\n   * @param {string} columnName\n   */\n  getColumnFilterProps(columnName) {\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, layers, opt) {\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 = {};\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, layers) {\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) {\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(field, scaleType) {\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  /**\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, condition) {\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 * @type {typeof import('./kepler-table').findPointFieldPairs}\n */\nexport function findPointFieldPairs(fields) {\n  const allNames = fields.map(f => f.name.toLowerCase());\n\n  // get list of all fields with matching suffixes\n  const acc = [];\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 {typeof import('./kepler-table').sortDatasetByColumn}\n */\nexport function sortDatasetByColumn(dataset, column, mode) {\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    return {\n      ...dataset,\n      sortColumn: {},\n      sortOrder: null\n    };\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  return {\n    ...dataset,\n    sortColumn: {\n      [column]: sortBy\n    },\n    sortOrder\n  };\n}\n\nexport function copyTable(original) {\n  return Object.assign(Object.create(Object.getPrototypeOf(original)), original);\n}\n\nexport function copyTableAndUpdate(original, options = {}) {\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"]}