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

package/dist/utils/filter-utils.js

@@ -0,0 +1,1286 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultFilter = getDefaultFilter;
+exports.shouldApplyFilter = shouldApplyFilter;
+exports.validatePolygonFilter = validatePolygonFilter;
+exports.validateFilter = validateFilter;
+exports.validateFilterWithData = validateFilterWithData;
+exports.getFilterProps = getFilterProps;
+exports.getFilterFunction = getFilterFunction;
+exports.updateFilterDataId = updateFilterDataId;
+exports.filterDataByFilterTypes = filterDataByFilterTypes;
+exports.getFilterRecord = getFilterRecord;
+exports.diffFilters = diffFilters;
+exports.adjustValueToFilterDomain = adjustValueToFilterDomain;
+exports.getNumericFieldDomain = getNumericFieldDomain;
+exports.getNumericStepSize = getNumericStepSize;
+exports.getTimestampFieldDomain = getTimestampFieldDomain;
+exports.histogramConstruct = histogramConstruct;
+exports.getHistogram = getHistogram;
+exports.formatNumberByStep = formatNumberByStep;
+exports.isInRange = isInRange;
+exports.isInPolygon = isInPolygon;
+exports.isValidTimeDomain = isValidTimeDomain;
+exports.getTimeWidgetTitleFormatter = getTimeWidgetTitleFormatter;
+exports.getTimeWidgetHintFormatter = getTimeWidgetHintFormatter;
+exports.isValidFilterValue = isValidFilterValue;
+exports.getFilterPlot = getFilterPlot;
+exports.getDefaultFilterPlotType = getDefaultFilterPlotType;
+exports.applyFiltersToDatasets = applyFiltersToDatasets;
+exports.applyFilterFieldName = applyFilterFieldName;
+exports.mergeFilterDomainStep = mergeFilterDomainStep;
+exports.generatePolygonFilter = generatePolygonFilter;
+exports.filterDatasetCPU = filterDatasetCPU;
+exports.validateFiltersUpdateDatasets = validateFiltersUpdateDatasets;
+exports.getIntervalBins = getIntervalBins;
+exports.getFilterIdInFeature = exports.featureToFilterValue = exports.getPolygonFilterFunctor = exports.LAYER_FILTERS = exports.FILTER_ID_LENGTH = exports.DEFAULT_FILTER_STRUCTURE = exports.FILTER_COMPONENTS = exports.LIMITED_FILTER_EFFECT_PROPS = exports.FILTER_UPDATER_PROPS = exports.PLOT_TYPES = exports.enlargedHistogramBins = exports.histogramBins = exports.TimestampStepMap = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _d3Array = require("d3-array");
+
+var _keymirror = _interopRequireDefault(require("keymirror"));
+
+var _console = require("global/console");
+
+var _lodash = _interopRequireDefault(require("lodash.get"));
+
+var _lodash2 = _interopRequireDefault(require("lodash.isequal"));
+
+var _booleanWithin = _interopRequireDefault(require("@turf/boolean-within"));
+
+var _helpers = require("@turf/helpers");
+
+var _decimal = require("decimal.js");
+
+var _defaultSettings = require("../constants/default-settings");
+
+var _dataUtils = require("./data-utils");
+
+var ScaleUtils = _interopRequireWildcard(require("./data-scale-utils"));
+
+var _types = require("../layers/types");
+
+var _utils = require("./utils");
+
+var _h3Utils = require("../layers/h3-hexagon-layer/h3-utils");
+
+var _FILTER_TYPES$timeRan, _FILTER_TYPES$range, _SupportedPlotType, _FILTER_COMPONENTS;
+
+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; }
+
+// TYPE
+
+/** @typedef {import('./table-utils/kepler-table').FilterRecord} FilterRecord */
+
+/** @typedef {import('./filter-utils').FilterResult} FilterResult */
+var TimestampStepMap = [{
+  max: 1,
+  step: 0.05
+}, {
+  max: 10,
+  step: 0.1
+}, {
+  max: 100,
+  step: 1
+}, {
+  max: 500,
+  step: 5
+}, {
+  max: 1000,
+  step: 10
+}, {
+  max: 5000,
+  step: 50
+}, {
+  max: Number.POSITIVE_INFINITY,
+  step: 1000
+}];
+exports.TimestampStepMap = TimestampStepMap;
+var histogramBins = 30;
+exports.histogramBins = histogramBins;
+var enlargedHistogramBins = 100;
+exports.enlargedHistogramBins = enlargedHistogramBins;
+var durationSecond = 1000;
+var durationMinute = durationSecond * 60;
+var durationHour = durationMinute * 60;
+var durationDay = durationHour * 24;
+var durationWeek = durationDay * 7;
+var durationYear = durationDay * 365;
+var PLOT_TYPES = (0, _keymirror["default"])({
+  histogram: null,
+  lineChart: null
+});
+exports.PLOT_TYPES = PLOT_TYPES;
+var FILTER_UPDATER_PROPS = (0, _keymirror["default"])({
+  dataId: null,
+  name: null,
+  layerId: null
+});
+exports.FILTER_UPDATER_PROPS = FILTER_UPDATER_PROPS;
+var LIMITED_FILTER_EFFECT_PROPS = (0, _keymirror["default"])((0, _defineProperty2["default"])({}, FILTER_UPDATER_PROPS.name, null));
+/**
+ * Max number of filter value buffers that deck.gl provides
+ */
+
+exports.LIMITED_FILTER_EFFECT_PROPS = LIMITED_FILTER_EFFECT_PROPS;
+var SupportedPlotType = (_SupportedPlotType = {}, (0, _defineProperty2["default"])(_SupportedPlotType, _defaultSettings.FILTER_TYPES.timeRange, (_FILTER_TYPES$timeRan = {
+  "default": 'histogram'
+}, (0, _defineProperty2["default"])(_FILTER_TYPES$timeRan, _defaultSettings.ALL_FIELD_TYPES.integer, 'lineChart'), (0, _defineProperty2["default"])(_FILTER_TYPES$timeRan, _defaultSettings.ALL_FIELD_TYPES.real, 'lineChart'), _FILTER_TYPES$timeRan)), (0, _defineProperty2["default"])(_SupportedPlotType, _defaultSettings.FILTER_TYPES.range, (_FILTER_TYPES$range = {
+  "default": 'histogram'
+}, (0, _defineProperty2["default"])(_FILTER_TYPES$range, _defaultSettings.ALL_FIELD_TYPES.integer, 'lineChart'), (0, _defineProperty2["default"])(_FILTER_TYPES$range, _defaultSettings.ALL_FIELD_TYPES.real, 'lineChart'), _FILTER_TYPES$range)), _SupportedPlotType);
+var FILTER_COMPONENTS = (_FILTER_COMPONENTS = {}, (0, _defineProperty2["default"])(_FILTER_COMPONENTS, _defaultSettings.FILTER_TYPES.select, 'SingleSelectFilter'), (0, _defineProperty2["default"])(_FILTER_COMPONENTS, _defaultSettings.FILTER_TYPES.multiSelect, 'MultiSelectFilter'), (0, _defineProperty2["default"])(_FILTER_COMPONENTS, _defaultSettings.FILTER_TYPES.timeRange, 'TimeRangeFilter'), (0, _defineProperty2["default"])(_FILTER_COMPONENTS, _defaultSettings.FILTER_TYPES.range, 'RangeFilter'), (0, _defineProperty2["default"])(_FILTER_COMPONENTS, _defaultSettings.FILTER_TYPES.polygon, 'PolygonFilter'), _FILTER_COMPONENTS);
+exports.FILTER_COMPONENTS = FILTER_COMPONENTS;
+var DEFAULT_FILTER_STRUCTURE = {
+  dataId: [],
+  // [string]
+  freeze: false,
+  id: null,
+  // time range filter specific
+  fixedDomain: false,
+  enlarged: false,
+  isAnimating: false,
+  animationWindow: _defaultSettings.ANIMATION_WINDOW.free,
+  speed: 1,
+  // field specific
+  name: [],
+  // string
+  type: null,
+  fieldIdx: [],
+  // [integer]
+  domain: null,
+  value: null,
+  // plot
+  plotType: PLOT_TYPES.histogram,
+  yAxis: null,
+  interval: null,
+  // mode
+  gpu: false
+};
+exports.DEFAULT_FILTER_STRUCTURE = DEFAULT_FILTER_STRUCTURE;
+var FILTER_ID_LENGTH = 4;
+exports.FILTER_ID_LENGTH = FILTER_ID_LENGTH;
+var LAYER_FILTERS = [_defaultSettings.FILTER_TYPES.polygon];
+/**
+ * Generates a filter with a dataset id as dataId
+ * @type {typeof import('./filter-utils').getDefaultFilter}
+ */
+
+exports.LAYER_FILTERS = LAYER_FILTERS;
+
+function getDefaultFilter(dataId) {
+  return _objectSpread(_objectSpread({}, DEFAULT_FILTER_STRUCTURE), {}, {
+    // store it as dataId and it could be one or many
+    dataId: (0, _utils.toArray)(dataId),
+    id: (0, _utils.generateHashId)(FILTER_ID_LENGTH)
+  });
+}
+/**
+ * Check if a filter is valid based on the given dataId
+ * @param  filter to validate
+ * @param  datasetId id to validate filter against
+ * @return true if a filter is valid, false otherwise
+ * @type {typeof import('./filter-utils').shouldApplyFilter}
+ */
+
+
+function shouldApplyFilter(filter, datasetId) {
+  var dataIds = (0, _utils.toArray)(filter.dataId);
+  return dataIds.includes(datasetId) && filter.value !== null;
+}
+/**
+ * Validates and modifies polygon filter structure
+ * @param dataset
+ * @param filter
+ * @param layers
+ * @return - {filter, dataset}
+ * @type {typeof import('./filter-utils').validatePolygonFilter}
+ */
+
+
+function validatePolygonFilter(dataset, filter, layers) {
+  var failed = {
+    dataset: dataset,
+    filter: null
+  };
+  var value = filter.value,
+      layerId = filter.layerId,
+      type = filter.type,
+      dataId = filter.dataId;
+
+  if (!layerId || !isValidFilterValue(type, value)) {
+    return failed;
+  }
+
+  var isValidDataset = dataId.includes(dataset.id);
+
+  if (!isValidDataset) {
+    return failed;
+  }
+
+  var layer = layers.find(function (l) {
+    return layerId.includes(l.id);
+  });
+
+  if (!layer) {
+    return failed;
+  }
+
+  return {
+    filter: _objectSpread(_objectSpread({}, filter), {}, {
+      freeze: true,
+      fieldIdx: []
+    }),
+    dataset: dataset
+  };
+}
+/**
+ * Custom filter validators
+ */
+
+
+var filterValidators = (0, _defineProperty2["default"])({}, _defaultSettings.FILTER_TYPES.polygon, validatePolygonFilter);
+/**
+ * Default validate filter function
+ * @param dataset
+ * @param filter
+ * @return - {filter, dataset}
+ * @type {typeof import('./filter-utils').validateFilter}
+ */
+
+function validateFilter(dataset, filter) {
+  // match filter.dataId
+  var failed = {
+    dataset: dataset,
+    filter: null
+  };
+  var filterDataId = (0, _utils.toArray)(filter.dataId);
+  var filterDatasetIndex = filterDataId.indexOf(dataset.id);
+
+  if (filterDatasetIndex < 0) {
+    // the current filter is not mapped against the current dataset
+    return failed;
+  }
+
+  var initializeFilter = _objectSpread(_objectSpread(_objectSpread({}, getDefaultFilter(filter.dataId)), filter), {}, {
+    dataId: filterDataId,
+    name: (0, _utils.toArray)(filter.name)
+  });
+
+  var fieldName = initializeFilter.name[filterDatasetIndex];
+
+  var _applyFilterFieldName = applyFilterFieldName(initializeFilter, dataset, fieldName, filterDatasetIndex, {
+    mergeDomain: true
+  }),
+      updatedFilter = _applyFilterFieldName.filter,
+      updatedDataset = _applyFilterFieldName.dataset;
+
+  if (!updatedFilter) {
+    return failed;
+  }
+
+  updatedFilter.value = adjustValueToFilterDomain(filter.value, updatedFilter);
+  updatedFilter.enlarged = typeof filter.enlarged === 'boolean' ? filter.enlarged : updatedFilter.enlarged;
+
+  if (updatedFilter.value === null) {
+    // cannot adjust saved value to filter
+    return failed;
+  }
+
+  return {
+    filter: validateFilterYAxis(updatedFilter, updatedDataset),
+    dataset: updatedDataset
+  };
+}
+/**
+ * Validate saved filter config with new data,
+ * calculate domain and fieldIdx based new fields and data
+ *
+ * @param dataset
+ * @param filter - filter to be validate
+ * @param layers - layers
+ * @return validated filter
+ * @type {typeof import('./filter-utils').validateFilterWithData}
+ */
+
+
+function validateFilterWithData(dataset, filter, layers) {
+  // @ts-ignore
+  return filterValidators.hasOwnProperty(filter.type) ? filterValidators[filter.type](dataset, filter, layers) : validateFilter(dataset, filter);
+}
+/**
+ * Validate YAxis
+ * @param filter
+ * @param dataset
+ * @return {*}
+ */
+
+
+function validateFilterYAxis(filter, dataset) {
+  // TODO: validate yAxis against other datasets
+  var fields = dataset.fields;
+  var _filter = filter,
+      yAxis = _filter.yAxis; // TODO: validate yAxis against other datasets
+
+  if (yAxis) {
+    var matchedAxis = fields.find(function (_ref) {
+      var name = _ref.name,
+          type = _ref.type;
+      return name === yAxis.name && type === yAxis.type;
+    });
+    filter = matchedAxis ? _objectSpread(_objectSpread({}, filter), {}, {
+      yAxis: matchedAxis
+    }, getFilterPlot(_objectSpread(_objectSpread({}, filter), {}, {
+      yAxis: matchedAxis
+    }), dataset)) : filter;
+  }
+
+  return filter;
+}
+/**
+ * Get default filter prop based on field type
+ *
+ * @param field
+ * @param fieldDomain
+ * @returns default filter
+ * @type {typeof import('./filter-utils').getFilterProps}
+ */
+
+
+function getFilterProps(field, fieldDomain) {
+  var filterProps = _objectSpread(_objectSpread({}, fieldDomain), {}, {
+    fieldType: field.type
+  });
+
+  switch (field.type) {
+    case _defaultSettings.ALL_FIELD_TYPES.real:
+    case _defaultSettings.ALL_FIELD_TYPES.integer:
+      return _objectSpread(_objectSpread({}, filterProps), {}, {
+        value: fieldDomain.domain,
+        type: _defaultSettings.FILTER_TYPES.range,
+        typeOptions: [_defaultSettings.FILTER_TYPES.range],
+        gpu: true
+      });
+
+    case _defaultSettings.ALL_FIELD_TYPES["boolean"]:
+      return _objectSpread(_objectSpread({}, filterProps), {}, {
+        type: _defaultSettings.FILTER_TYPES.select,
+        value: true,
+        gpu: false
+      });
+
+    case _defaultSettings.ALL_FIELD_TYPES.string:
+    case _defaultSettings.ALL_FIELD_TYPES.date:
+      return _objectSpread(_objectSpread({}, filterProps), {}, {
+        type: _defaultSettings.FILTER_TYPES.multiSelect,
+        value: [],
+        gpu: false
+      });
+
+    case _defaultSettings.ALL_FIELD_TYPES.timestamp:
+      return _objectSpread(_objectSpread({}, filterProps), {}, {
+        type: _defaultSettings.FILTER_TYPES.timeRange,
+        enlarged: true,
+        fixedDomain: true,
+        value: filterProps.domain,
+        gpu: true
+      });
+
+    default:
+      return {};
+  }
+}
+
+var getPolygonFilterFunctor = function getPolygonFilterFunctor(layer, filter, dataContainer) {
+  var getPosition = layer.getPositionAccessor(dataContainer);
+
+  switch (layer.type) {
+    case _types.LAYER_TYPES.point:
+    case _types.LAYER_TYPES.icon:
+      return function (data) {
+        var pos = getPosition(data);
+        return pos.every(Number.isFinite) && isInPolygon(pos, filter.value);
+      };
+
+    case _types.LAYER_TYPES.arc:
+    case _types.LAYER_TYPES.line:
+      return function (data) {
+        var pos = getPosition(data);
+        return pos.every(Number.isFinite) && [[pos[0], pos[1]], [pos[3], pos[4]]].every(function (point) {
+          return isInPolygon(point, filter.value);
+        });
+      };
+
+    case _types.LAYER_TYPES.hexagonId:
+      if (layer.dataToFeature && layer.dataToFeature.centroids) {
+        return function (data) {
+          // null or getCentroid({id})
+          var centroid = layer.dataToFeature.centroids[data.index];
+          return centroid && isInPolygon(centroid, filter.value);
+        };
+      }
+
+      return function (data) {
+        var id = getPosition(data);
+
+        if (!(0, _h3Utils.h3IsValid)(id)) {
+          return false;
+        }
+
+        var pos = (0, _h3Utils.getCentroid)({
+          id: id
+        });
+        return pos.every(Number.isFinite) && isInPolygon(pos, filter.value);
+      };
+
+    default:
+      return function () {
+        return true;
+      };
+  }
+};
+/**
+ * @param field dataset Field
+ * @param dataId Dataset id
+ * @param filter Filter object
+ * @param layers list of layers to filter upon
+ * @param dataContainer Data container
+ * @return filterFunction
+ * @type {typeof import('./filter-utils').getFilterFunction}
+ */
+
+
+exports.getPolygonFilterFunctor = getPolygonFilterFunctor;
+
+function getFilterFunction(field, dataId, filter, layers, dataContainer) {
+  // field could be null in polygon filter
+  var valueAccessor = field ? field.valueAccessor : function (data) {
+    return null;
+  };
+
+  var defaultFunc = function defaultFunc(d) {
+    return true;
+  };
+
+  switch (filter.type) {
+    case _defaultSettings.FILTER_TYPES.range:
+      return function (data) {
+        return isInRange(valueAccessor(data), filter.value);
+      };
+
+    case _defaultSettings.FILTER_TYPES.multiSelect:
+      return function (data) {
+        return filter.value.includes(valueAccessor(data));
+      };
+
+    case _defaultSettings.FILTER_TYPES.select:
+      return function (data) {
+        return valueAccessor(data) === filter.value;
+      };
+
+    case _defaultSettings.FILTER_TYPES.timeRange:
+      if (!field) {
+        return defaultFunc;
+      }
+
+      var mappedValue = (0, _lodash["default"])(field, ['filterProps', 'mappedValue']);
+      var accessor = Array.isArray(mappedValue) ? function (data) {
+        return mappedValue[data.index];
+      } : function (data) {
+        return (0, _dataUtils.timeToUnixMilli)(valueAccessor(data), field.format);
+      };
+      return function (data) {
+        return isInRange(accessor(data), filter.value);
+      };
+
+    case _defaultSettings.FILTER_TYPES.polygon:
+      if (!layers || !layers.length) {
+        return defaultFunc;
+      } // @ts-ignore
+
+
+      var layerFilterFunctions = filter.layerId.map(function (id) {
+        return layers.find(function (l) {
+          return l.id === id;
+        });
+      }).filter(function (l) {
+        return l && l.config.dataId === dataId;
+      }).map(function (layer) {
+        return getPolygonFilterFunctor(layer, filter, dataContainer);
+      });
+      return function (data) {
+        return layerFilterFunctions.every(function (filterFunc) {
+          return filterFunc(data);
+        });
+      };
+
+    default:
+      return defaultFunc;
+  }
+}
+
+function updateFilterDataId(dataId) {
+  return getDefaultFilter(dataId);
+}
+/**
+ * @type {typeof import('./filter-utils').filterDataByFilterTypes}
+ */
+
+
+function filterDataByFilterTypes(_ref2, dataContainer) {
+  var dynamicDomainFilters = _ref2.dynamicDomainFilters,
+      cpuFilters = _ref2.cpuFilters,
+      filterFuncs = _ref2.filterFuncs;
+
+  var result = _objectSpread(_objectSpread({}, dynamicDomainFilters ? {
+    filteredIndexForDomain: []
+  } : {}), cpuFilters ? {
+    filteredIndex: []
+  } : {});
+
+  var filterContext = {
+    index: -1,
+    dataContainer: dataContainer
+  };
+
+  var filterFuncCaller = function filterFuncCaller(filter) {
+    return filterFuncs[filter.id](filterContext);
+  };
+
+  var numRows = dataContainer.numRows();
+
+  for (var i = 0; i < numRows; ++i) {
+    filterContext.index = i;
+    var matchForDomain = dynamicDomainFilters && dynamicDomainFilters.every(filterFuncCaller);
+
+    if (matchForDomain) {
+      // @ts-ignore
+      result.filteredIndexForDomain.push(filterContext.index);
+    }
+
+    var matchForRender = cpuFilters && cpuFilters.every(filterFuncCaller);
+
+    if (matchForRender) {
+      // @ts-ignore
+      result.filteredIndex.push(filterContext.index);
+    }
+  }
+
+  return result;
+}
+/**
+ * Get a record of filters based on domain type and gpu / cpu
+ * @type {typeof import('./filter-utils').getFilterRecord}
+ */
+
+
+function getFilterRecord(dataId, filters) {
+  var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  /**
+   * @type {FilterRecord}
+   */
+  var filterRecord = {
+    dynamicDomain: [],
+    fixedDomain: [],
+    cpu: [],
+    gpu: []
+  };
+  filters.forEach(function (f) {
+    if (isValidFilterValue(f.type, f.value) && (0, _utils.toArray)(f.dataId).includes(dataId)) {
+      (f.fixedDomain || opt.ignoreDomain ? filterRecord.fixedDomain : filterRecord.dynamicDomain).push(f);
+      (f.gpu && !opt.cpuOnly ? filterRecord.gpu : filterRecord.cpu).push(f);
+    }
+  });
+  return filterRecord;
+}
+/**
+ * Compare filter records to get what has changed
+ * @type {typeof import('./filter-utils').diffFilters}
+ */
+
+
+function diffFilters(filterRecord) {
+  var oldFilterRecord = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var filterChanged = {};
+  Object.entries(filterRecord).forEach(function (_ref3) {
+    var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+        record = _ref4[0],
+        items = _ref4[1];
+
+    items.forEach(function (filter) {
+      var oldFilter = (oldFilterRecord[record] || []).find(function (f) {
+        return f.id === filter.id;
+      });
+
+      if (!oldFilter) {
+        // added
+        filterChanged = (0, _utils.set)([record, filter.id], 'added', filterChanged);
+      } else {
+        // check  what has changed
+        ['name', 'value', 'dataId'].forEach(function (prop) {
+          if (filter[prop] !== oldFilter[prop]) {
+            filterChanged = (0, _utils.set)([record, filter.id], "".concat(prop, "_changed"), filterChanged);
+          }
+        });
+      }
+    });
+    (oldFilterRecord[record] || []).forEach(function (oldFilter) {
+      // deleted
+      if (!items.find(function (f) {
+        return f.id === oldFilter.id;
+      })) {
+        filterChanged = (0, _utils.set)([record, oldFilter.id], 'deleted', filterChanged);
+      }
+    });
+
+    if (!filterChanged[record]) {
+      filterChanged[record] = null;
+    }
+  }); // @ts-ignore
+
+  return filterChanged;
+}
+/**
+ * Call by parsing filters from URL
+ * Check if value of filter within filter domain, if not adjust it to match
+ * filter domain
+ *
+ * @type {typeof import('./filter-utils').adjustValueToFilterDomain}
+ * @returns value - adjusted value to match filter or null to remove filter
+ */
+
+/* eslint-disable complexity */
+
+
+function adjustValueToFilterDomain(value, _ref5) {
+  var domain = _ref5.domain,
+      type = _ref5.type;
+
+  if (!domain || !type) {
+    return false;
+  }
+
+  switch (type) {
+    case _defaultSettings.FILTER_TYPES.range:
+    case _defaultSettings.FILTER_TYPES.timeRange:
+      if (!Array.isArray(value) || value.length !== 2) {
+        return domain.map(function (d) {
+          return d;
+        });
+      }
+
+      return value.map(function (d, i) {
+        return (0, _dataUtils.notNullorUndefined)(d) && isInRange(d, domain) ? d : domain[i];
+      });
+
+    case _defaultSettings.FILTER_TYPES.multiSelect:
+      if (!Array.isArray(value)) {
+        return [];
+      }
+
+      var filteredValue = value.filter(function (d) {
+        return domain.includes(d);
+      });
+      return filteredValue.length ? filteredValue : [];
+
+    case _defaultSettings.FILTER_TYPES.select:
+      return domain.includes(value) ? value : true;
+
+    default:
+      return null;
+  }
+}
+/* eslint-enable complexity */
+
+/**
+ * Calculate numeric domain and suitable step
+ *
+ * @type {typeof import('./filter-utils').getNumericFieldDomain}
+ */
+
+
+function getNumericFieldDomain(dataContainer, valueAccessor) {
+  var domain = [0, 1];
+  var step = 0.1;
+  var mappedValue = dataContainer.mapIndex(valueAccessor);
+
+  if (dataContainer.numRows() > 1) {
+    domain = ScaleUtils.getLinearDomain(mappedValue);
+    var diff = domain[1] - domain[0]; // in case equal domain, [96, 96], which will break quantize scale
+
+    if (!diff) {
+      domain[1] = domain[0] + 1;
+    }
+
+    step = getNumericStepSize(diff) || step;
+    domain[0] = formatNumberByStep(domain[0], step, 'floor');
+    domain[1] = formatNumberByStep(domain[1], step, 'ceil');
+  } // @ts-ignore
+
+
+  var _getHistogram = getHistogram(domain, mappedValue),
+      histogram = _getHistogram.histogram,
+      enlargedHistogram = _getHistogram.enlargedHistogram;
+
+  return {
+    domain: domain,
+    step: step,
+    histogram: histogram,
+    enlargedHistogram: enlargedHistogram
+  };
+}
+/**
+ * Calculate step size for range and timerange filter
+ *
+ * @type {typeof import('./filter-utils').getNumericStepSize}
+ */
+
+
+function getNumericStepSize(diff) {
+  diff = Math.abs(diff);
+
+  if (diff > 100) {
+    return 1;
+  } else if (diff > 3) {
+    return 0.01;
+  } else if (diff > 1) {
+    return 0.001;
+  } // Try to get at least 1000 steps - and keep the step size below that of
+  // the (diff > 1) case.
+
+
+  var x = diff / 1000; // Find the exponent and truncate to 10 to the power of that exponent
+
+  var exponentialForm = x.toExponential();
+  var exponent = parseFloat(exponentialForm.split('e')[1]); // Getting ready for node 12
+  // this is why we need decimal.js
+  // Math.pow(10, -5) = 0.000009999999999999999
+  // the above result shows in browser and node 10
+  // node 12 behaves correctly
+
+  return new _decimal.Decimal(10).pow(exponent).toNumber();
+}
+/**
+ * Calculate timestamp domain and suitable step
+ * @type {typeof import('./filter-utils').getTimestampFieldDomain}
+ */
+
+
+function getTimestampFieldDomain(dataContainer, valueAccessor) {
+  // to avoid converting string format time to epoch
+  // every time we compare we store a value mapped to int in filter domain
+  var mappedValue = dataContainer.mapIndex(valueAccessor);
+  var domain = ScaleUtils.getLinearDomain(mappedValue);
+  var defaultTimeFormat = getTimeWidgetTitleFormatter(domain);
+  var step = 0.01;
+  var diff = domain[1] - domain[0];
+  var entry = TimestampStepMap.find(function (f) {
+    return f.max >= diff;
+  });
+
+  if (entry) {
+    step = entry.step;
+  }
+
+  var _getHistogram2 = getHistogram(domain, mappedValue),
+      histogram = _getHistogram2.histogram,
+      enlargedHistogram = _getHistogram2.enlargedHistogram;
+
+  return {
+    domain: domain,
+    step: step,
+    mappedValue: mappedValue,
+    histogram: histogram,
+    enlargedHistogram: enlargedHistogram,
+    defaultTimeFormat: defaultTimeFormat
+  };
+}
+/**
+ *
+ * @type {typeof import('./filter-utils').histogramConstruct}
+ */
+
+
+function histogramConstruct(domain, mappedValue, bins) {
+  return (0, _d3Array.histogram)().thresholds((0, _d3Array.ticks)(domain[0], domain[1], bins)).domain(domain)(mappedValue).map(function (bin) {
+    return {
+      count: bin.length,
+      x0: bin.x0,
+      x1: bin.x1
+    };
+  });
+}
+/**
+ * Calculate histogram from domain and array of values
+ *
+ * @type {typeof import('./filter-utils').getHistogram}
+ */
+
+
+function getHistogram(domain, mappedValue) {
+  var histogram = histogramConstruct(domain, mappedValue, histogramBins);
+  var enlargedHistogram = histogramConstruct(domain, mappedValue, enlargedHistogramBins);
+  return {
+    histogram: histogram,
+    enlargedHistogram: enlargedHistogram
+  };
+}
+/**
+ * round number based on step
+ *
+ * @param {Number} val
+ * @param {Number} step
+ * @param {string} bound
+ * @returns {Number} rounded number
+ */
+
+
+function formatNumberByStep(val, step, bound) {
+  if (bound === 'floor') {
+    return Math.floor(val * (1 / step)) / (1 / step);
+  }
+
+  return Math.ceil(val * (1 / step)) / (1 / step);
+}
+/**
+ *
+ * @type {typeof import('./filter-utils').isInRange}
+ */
+
+
+function isInRange(val, domain) {
+  if (!Array.isArray(domain)) {
+    return false;
+  }
+
+  return val >= domain[0] && val <= domain[1];
+}
+/**
+ * Determines whether a point is within the provided polygon
+ *
+ * @param point as input search [lat, lng]
+ * @param polygon Points must be within these (Multi)Polygon(s)
+ * @return {boolean}
+ */
+
+
+function isInPolygon(point, polygon) {
+  return (0, _booleanWithin["default"])((0, _helpers.point)(point), polygon);
+}
+
+function isValidTimeDomain(domain) {
+  return Array.isArray(domain) && domain.every(Number.isFinite);
+}
+
+function getTimeWidgetTitleFormatter(domain) {
+  if (!isValidTimeDomain(domain)) {
+    return null;
+  }
+
+  var diff = domain[1] - domain[0]; // Local aware formats
+  // https://momentjs.com/docs/#/parsing/string-format
+
+  return diff > durationYear ? 'L' : diff > durationDay ? 'L LT' : 'L LTS';
+}
+
+function getTimeWidgetHintFormatter(domain) {
+  if (!isValidTimeDomain(domain)) {
+    return null;
+  }
+
+  var diff = domain[1] - domain[0];
+  return diff > durationWeek ? 'L' : diff > durationDay ? 'L LT' : diff > durationHour ? 'LT' : 'LTS';
+}
+/**
+ * Sanity check on filters to prepare for save
+ * @type {typeof import('./filter-utils').isValidFilterValue}
+ */
+
+/* eslint-disable complexity */
+
+
+function isValidFilterValue(type, value) {
+  if (!type) {
+    return false;
+  }
+
+  switch (type) {
+    case _defaultSettings.FILTER_TYPES.select:
+      return value === true || value === false;
+
+    case _defaultSettings.FILTER_TYPES.range:
+    case _defaultSettings.FILTER_TYPES.timeRange:
+      return Array.isArray(value) && value.every(function (v) {
+        return v !== null && !isNaN(v);
+      });
+
+    case _defaultSettings.FILTER_TYPES.multiSelect:
+      return Array.isArray(value) && Boolean(value.length);
+
+    case _defaultSettings.FILTER_TYPES.input:
+      return Boolean(value.length);
+
+    case _defaultSettings.FILTER_TYPES.polygon:
+      var coordinates = (0, _lodash["default"])(value, ['geometry', 'coordinates']);
+      return Boolean(value && value.id && coordinates);
+
+    default:
+      return true;
+  }
+}
+/**
+ *
+ * @type {typeof import('./filter-utils').getFilterPlot}
+ */
+
+
+function getFilterPlot(filter, dataset) {
+  if (filter.plotType === PLOT_TYPES.histogram || !filter.yAxis) {
+    // histogram should be calculated when create filter
+    return {};
+  }
+
+  var _filter$mappedValue = filter.mappedValue,
+      mappedValue = _filter$mappedValue === void 0 ? [] : _filter$mappedValue;
+  var yAxis = filter.yAxis;
+  var fieldIdx = dataset.getColumnFieldIdx(yAxis.name);
+
+  if (fieldIdx < 0) {
+    _console.console.warn("yAxis ".concat(yAxis.name, " does not exist in dataset"));
+
+    return {
+      lineChart: {},
+      yAxis: yAxis
+    };
+  } // return lineChart
+
+
+  var series = dataset.dataContainer.map(function (row, rowIndex) {
+    return {
+      x: mappedValue[rowIndex],
+      y: row.valueAt(fieldIdx)
+    };
+  }, true).filter(function (_ref6) {
+    var x = _ref6.x,
+        y = _ref6.y;
+    return Number.isFinite(x) && Number.isFinite(y);
+  }).sort(function (a, b) {
+    return (0, _d3Array.ascending)(a.x, b.x);
+  });
+  var yDomain = (0, _d3Array.extent)(series, function (d) {
+    return d.y;
+  });
+  var xDomain = [series[0].x, series[series.length - 1].x];
+  return {
+    lineChart: {
+      series: series,
+      yDomain: yDomain,
+      xDomain: xDomain
+    },
+    yAxis: yAxis
+  };
+}
+
+function getDefaultFilterPlotType(filter) {
+  var filterPlotTypes = SupportedPlotType[filter.type];
+
+  if (!filterPlotTypes) {
+    return null;
+  }
+
+  if (!filter.yAxis) {
+    return filterPlotTypes["default"];
+  }
+
+  return filterPlotTypes[filter.yAxis.type] || null;
+}
+/**
+ *
+ * @param datasetIds list of dataset ids to be filtered
+ * @param datasets all datasets
+ * @param filters all filters to be applied to datasets
+ * @return datasets - new updated datasets
+ * @type {typeof import('./filter-utils').applyFiltersToDatasets}
+ */
+
+
+function applyFiltersToDatasets(datasetIds, datasets, filters, layers) {
+  var dataIds = (0, _utils.toArray)(datasetIds);
+  return dataIds.reduce(function (acc, dataId) {
+    var layersToFilter = (layers || []).filter(function (l) {
+      return l.config.dataId === dataId;
+    });
+    var appliedFilters = filters.filter(function (d) {
+      return shouldApplyFilter(d, dataId);
+    });
+    var table = datasets[dataId];
+    return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, dataId, table.filterTable(appliedFilters, layersToFilter, {})));
+  }, datasets);
+}
+/**
+ * Applies a new field name value to fielter and update both filter and dataset
+ * @param filter - to be applied the new field name on
+ * @param dataset - dataset the field belongs to
+ * @param fieldName - field.name
+ * @param filterDatasetIndex - field.name
+ * @param option
+ * @return - {filter, datasets}
+ * @type {typeof import('./filter-utils').applyFilterFieldName}
+ */
+
+
+function applyFilterFieldName(filter, dataset, fieldName) {
+  var filterDatasetIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var option = arguments.length > 4 ? arguments[4] : undefined;
+  // using filterDatasetIndex we can filter only the specified dataset
+  var mergeDomain = option && option.hasOwnProperty('mergeDomain') ? option.mergeDomain : false;
+  var fieldIndex = dataset.getColumnFieldIdx(fieldName); // if no field with same name is found, move to the next datasets
+
+  if (fieldIndex === -1) {
+    // throw new Error(`fieldIndex not found. Dataset must contain a property with name: ${fieldName}`);
+    return {
+      filter: null,
+      dataset: dataset
+    };
+  } // TODO: validate field type
+
+
+  var filterProps = dataset.getColumnFilterProps(fieldName);
+
+  var newFilter = _objectSpread(_objectSpread({}, mergeDomain ? mergeFilterDomainStep(filter, filterProps) : _objectSpread(_objectSpread({}, filter), filterProps)), {}, {
+    name: Object.assign((0, _toConsumableArray2["default"])((0, _utils.toArray)(filter.name)), (0, _defineProperty2["default"])({}, filterDatasetIndex, fieldName)),
+    fieldIdx: Object.assign((0, _toConsumableArray2["default"])((0, _utils.toArray)(filter.fieldIdx)), (0, _defineProperty2["default"])({}, filterDatasetIndex, fieldIndex)),
+    // TODO, since we allow to add multiple fields to a filter we can no longer freeze the filter
+    freeze: true
+  });
+
+  return {
+    filter: newFilter,
+    dataset: dataset
+  };
+}
+/**
+ * Merge one filter with other filter prop domain
+ * @type {typeof import('./filter-utils').mergeFilterDomainStep}
+ */
+
+/* eslint-disable complexity */
+
+
+function mergeFilterDomainStep(filter, filterProps) {
+  if (!filter) {
+    return null;
+  }
+
+  if (!filterProps) {
+    return filter;
+  }
+
+  if (filter.fieldType && filter.fieldType !== filterProps.fieldType || !filterProps.domain) {
+    return filter;
+  }
+
+  var combinedDomain = !filter.domain ? filterProps.domain : [].concat((0, _toConsumableArray2["default"])(filter.domain || []), (0, _toConsumableArray2["default"])(filterProps.domain || [])).sort(function (a, b) {
+    return a - b;
+  });
+
+  var newFilter = _objectSpread(_objectSpread(_objectSpread({}, filter), filterProps), {}, {
+    domain: [combinedDomain[0], combinedDomain[combinedDomain.length - 1]]
+  });
+
+  switch (filterProps.fieldType) {
+    case _defaultSettings.ALL_FIELD_TYPES.string:
+    case _defaultSettings.ALL_FIELD_TYPES.date:
+      return _objectSpread(_objectSpread({}, newFilter), {}, {
+        domain: (0, _dataUtils.unique)(combinedDomain).sort()
+      });
+
+    case _defaultSettings.ALL_FIELD_TYPES.timestamp:
+      // @ts-ignore
+      var step = filter.step < filterProps.step ? filter.step : filterProps.step;
+      return _objectSpread(_objectSpread({}, newFilter), {}, {
+        step: step
+      });
+
+    case _defaultSettings.ALL_FIELD_TYPES.real:
+    case _defaultSettings.ALL_FIELD_TYPES.integer:
+    default:
+      return newFilter;
+  }
+}
+/* eslint-enable complexity */
+
+/**
+ * Generates polygon filter
+ * @type {typeof import('./filter-utils').featureToFilterValue}
+ */
+
+
+var featureToFilterValue = function featureToFilterValue(feature, filterId) {
+  var properties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return _objectSpread(_objectSpread({}, feature), {}, {
+    id: feature.id,
+    properties: _objectSpread(_objectSpread(_objectSpread({}, feature.properties), properties), {}, {
+      filterId: filterId
+    })
+  });
+};
+/**
+ * @type {typeof import('./filter-utils').getFilterIdInFeature}
+ */
+
+
+exports.featureToFilterValue = featureToFilterValue;
+
+var getFilterIdInFeature = function getFilterIdInFeature(f) {
+  return (0, _lodash["default"])(f, ['properties', 'filterId']);
+};
+/**
+ * Generates polygon filter
+ * @type {typeof import('./filter-utils').generatePolygonFilter}
+ */
+
+
+exports.getFilterIdInFeature = getFilterIdInFeature;
+
+function generatePolygonFilter(layers, feature) {
+  var dataId = layers.map(function (l) {
+    return l.config.dataId;
+  }).filter(function (d) {
+    return d;
+  });
+  var layerId = layers.map(function (l) {
+    return l.id;
+  });
+  var name = layers.map(function (l) {
+    return l.config.label;
+  }); // @ts-ignore
+
+  var filter = getDefaultFilter(dataId);
+  return _objectSpread(_objectSpread({}, filter), {}, {
+    fixedDomain: true,
+    type: _defaultSettings.FILTER_TYPES.polygon,
+    name: name,
+    layerId: layerId,
+    value: featureToFilterValue(feature, filter.id, {
+      isVisible: true
+    })
+  });
+}
+/**
+ * Run filter entirely on CPU
+ * @type {typeof import('./filter-utils').filterDatasetCPU}
+ */
+
+
+function filterDatasetCPU(state, dataId) {
+  var datasetFilters = state.filters.filter(function (f) {
+    return f.dataId.includes(dataId);
+  });
+  var dataset = state.datasets[dataId];
+
+  if (!dataset) {
+    return state;
+  }
+
+  var cpuFilteredDataset = dataset.filterTableCPU(datasetFilters, state.layers);
+  return (0, _utils.set)(['datasets', dataId], cpuFilteredDataset, state);
+}
+/**
+ * Validate parsed filters with datasets and add filterProps to field
+ * @type {typeof import('./filter-utils').validateFiltersUpdateDatasets}
+ */
+
+
+function validateFiltersUpdateDatasets(state) {
+  var filtersToValidate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var validated = [];
+  var failed = [];
+  var datasets = state.datasets;
+  var updatedDatasets = datasets; // merge filters
+
+  filtersToValidate.forEach(function (filter) {
+    // we can only look for datasets define in the filter dataId
+    var datasetIds = (0, _utils.toArray)(filter.dataId); // we can merge a filter only if all datasets in filter.dataId are loaded
+
+    if (datasetIds.every(function (d) {
+      return datasets[d];
+    })) {
+      // all datasetIds in filter must be present the state datasets
+      var _datasetIds$reduce = datasetIds.reduce(function (acc, datasetId) {
+        var dataset = updatedDatasets[datasetId];
+        var layers = state.layers.filter(function (l) {
+          return l.config.dataId === dataset.id;
+        });
+
+        var _validateFilterWithDa = validateFilterWithData(acc.augmentedDatasets[datasetId] || dataset, filter, layers),
+            updatedFilter = _validateFilterWithDa.filter,
+            updatedDataset = _validateFilterWithDa.dataset;
+
+        if (updatedFilter) {
+          return _objectSpread(_objectSpread({}, acc), {}, {
+            // merge filter props
+            filter: acc.filter ? _objectSpread(_objectSpread({}, acc.filter), mergeFilterDomainStep(acc, updatedFilter)) : updatedFilter,
+            applyToDatasets: [].concat((0, _toConsumableArray2["default"])(acc.applyToDatasets), [datasetId]),
+            augmentedDatasets: _objectSpread(_objectSpread({}, acc.augmentedDatasets), {}, (0, _defineProperty2["default"])({}, datasetId, updatedDataset))
+          });
+        }
+
+        return acc;
+      }, {
+        filter: null,
+        applyToDatasets: [],
+        augmentedDatasets: {}
+      }),
+          validatedFilter = _datasetIds$reduce.filter,
+          applyToDatasets = _datasetIds$reduce.applyToDatasets,
+          augmentedDatasets = _datasetIds$reduce.augmentedDatasets;
+
+      if (validatedFilter && (0, _lodash2["default"])(datasetIds, applyToDatasets)) {
+        validated.push(validatedFilter);
+        updatedDatasets = _objectSpread(_objectSpread({}, updatedDatasets), augmentedDatasets);
+      }
+    } else {
+      failed.push(filter);
+    }
+  });
+  return {
+    validated: validated,
+    failed: failed,
+    updatedDatasets: updatedDatasets
+  };
+}
+/**
+ * Retrieve interval bins for time filter
+ * @type {typeof import('./filter-utils').getIntervalBins}
+ */
+
+
+function getIntervalBins(filter) {
+  var _filter$plotType;
+
+  var bins = filter.bins;
+  var interval = (_filter$plotType = filter.plotType) === null || _filter$plotType === void 0 ? void 0 : _filter$plotType.interval;
+
+  if (!interval || !bins || Object.keys(bins).length === 0) {
+    return null;
+  }
+
+  var values = Object.values(bins);
+  return values[0] ? values[0][interval] : null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utils/filter-utils.js"],"names":["TimestampStepMap","max","step","Number","POSITIVE_INFINITY","histogramBins","enlargedHistogramBins","durationSecond","durationMinute","durationHour","durationDay","durationWeek","durationYear","PLOT_TYPES","histogram","lineChart","FILTER_UPDATER_PROPS","dataId","name","layerId","LIMITED_FILTER_EFFECT_PROPS","SupportedPlotType","FILTER_TYPES","timeRange","ALL_FIELD_TYPES","integer","real","range","FILTER_COMPONENTS","select","multiSelect","polygon","DEFAULT_FILTER_STRUCTURE","freeze","id","fixedDomain","enlarged","isAnimating","animationWindow","ANIMATION_WINDOW","free","speed","type","fieldIdx","domain","value","plotType","yAxis","interval","gpu","FILTER_ID_LENGTH","LAYER_FILTERS","getDefaultFilter","shouldApplyFilter","filter","datasetId","dataIds","includes","validatePolygonFilter","dataset","layers","failed","isValidFilterValue","isValidDataset","layer","find","l","filterValidators","validateFilter","filterDataId","filterDatasetIndex","indexOf","initializeFilter","fieldName","applyFilterFieldName","mergeDomain","updatedFilter","updatedDataset","adjustValueToFilterDomain","validateFilterYAxis","validateFilterWithData","hasOwnProperty","fields","matchedAxis","getFilterPlot","getFilterProps","field","fieldDomain","filterProps","fieldType","typeOptions","string","date","timestamp","getPolygonFilterFunctor","dataContainer","getPosition","getPositionAccessor","LAYER_TYPES","point","icon","data","pos","every","isFinite","isInPolygon","arc","line","hexagonId","dataToFeature","centroids","centroid","index","getFilterFunction","valueAccessor","defaultFunc","d","isInRange","mappedValue","accessor","Array","isArray","format","length","layerFilterFunctions","map","config","filterFunc","updateFilterDataId","filterDataByFilterTypes","dynamicDomainFilters","cpuFilters","filterFuncs","result","filteredIndexForDomain","filteredIndex","filterContext","filterFuncCaller","numRows","i","matchForDomain","push","matchForRender","getFilterRecord","filters","opt","filterRecord","dynamicDomain","cpu","forEach","f","ignoreDomain","cpuOnly","diffFilters","oldFilterRecord","filterChanged","Object","entries","record","items","oldFilter","prop","filteredValue","getNumericFieldDomain","mapIndex","ScaleUtils","getLinearDomain","diff","getNumericStepSize","formatNumberByStep","getHistogram","enlargedHistogram","Math","abs","x","exponentialForm","toExponential","exponent","parseFloat","split","Decimal","pow","toNumber","getTimestampFieldDomain","defaultTimeFormat","getTimeWidgetTitleFormatter","entry","histogramConstruct","bins","thresholds","bin","count","x0","x1","val","bound","floor","ceil","isValidTimeDomain","getTimeWidgetHintFormatter","v","isNaN","Boolean","input","coordinates","getColumnFieldIdx","Console","warn","series","row","rowIndex","y","valueAt","sort","a","b","yDomain","xDomain","getDefaultFilterPlotType","filterPlotTypes","applyFiltersToDatasets","datasetIds","datasets","reduce","acc","layersToFilter","appliedFilters","table","filterTable","option","fieldIndex","getColumnFilterProps","newFilter","mergeFilterDomainStep","assign","combinedDomain","featureToFilterValue","feature","filterId","properties","getFilterIdInFeature","generatePolygonFilter","label","isVisible","filterDatasetCPU","state","datasetFilters","cpuFilteredDataset","filterTableCPU","validateFiltersUpdateDatasets","filtersToValidate","validated","updatedDatasets","augmentedDatasets","applyToDatasets","validatedFilter","getIntervalBins","keys","values"],"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 {ascending, extent, histogram as d3Histogram, ticks} from 'd3-array';\nimport keyMirror from 'keymirror';\nimport {console as Console} from 'global/console';\nimport get from 'lodash.get';\nimport isEqual from 'lodash.isequal';\n\nimport booleanWithin from '@turf/boolean-within';\nimport {point as turfPoint} from '@turf/helpers';\nimport {Decimal} from 'decimal.js';\nimport {ALL_FIELD_TYPES, FILTER_TYPES, ANIMATION_WINDOW} from 'constants/default-settings';\nimport {notNullorUndefined, unique, timeToUnixMilli} from './data-utils';\nimport * as ScaleUtils from './data-scale-utils';\nimport {LAYER_TYPES} from 'layers/types';\nimport {generateHashId, set, toArray} from './utils';\nimport {getCentroid, h3IsValid} from 'layers/h3-hexagon-layer/h3-utils';\n\n// TYPE\n/** @typedef {import('./table-utils/kepler-table').FilterRecord} FilterRecord */\n/** @typedef {import('./filter-utils').FilterResult} FilterResult */\n\nexport const TimestampStepMap = [\n  {max: 1, step: 0.05},\n  {max: 10, step: 0.1},\n  {max: 100, step: 1},\n  {max: 500, step: 5},\n  {max: 1000, step: 10},\n  {max: 5000, step: 50},\n  {max: Number.POSITIVE_INFINITY, step: 1000}\n];\n\nexport const histogramBins = 30;\nexport const enlargedHistogramBins = 100;\n\nconst durationSecond = 1000;\nconst durationMinute = durationSecond * 60;\nconst durationHour = durationMinute * 60;\nconst durationDay = durationHour * 24;\nconst durationWeek = durationDay * 7;\nconst durationYear = durationDay * 365;\n\nexport const PLOT_TYPES = keyMirror({\n  histogram: null,\n  lineChart: null\n});\n\nexport const FILTER_UPDATER_PROPS = keyMirror({\n  dataId: null,\n  name: null,\n  layerId: null\n});\n\nexport const LIMITED_FILTER_EFFECT_PROPS = keyMirror({\n  [FILTER_UPDATER_PROPS.name]: null\n});\n/**\n * Max number of filter value buffers that deck.gl provides\n */\n\nconst SupportedPlotType = {\n  [FILTER_TYPES.timeRange]: {\n    default: 'histogram',\n    [ALL_FIELD_TYPES.integer]: 'lineChart',\n    [ALL_FIELD_TYPES.real]: 'lineChart'\n  },\n  [FILTER_TYPES.range]: {\n    default: 'histogram',\n    [ALL_FIELD_TYPES.integer]: 'lineChart',\n    [ALL_FIELD_TYPES.real]: 'lineChart'\n  }\n};\n\nexport const FILTER_COMPONENTS = {\n  [FILTER_TYPES.select]: 'SingleSelectFilter',\n  [FILTER_TYPES.multiSelect]: 'MultiSelectFilter',\n  [FILTER_TYPES.timeRange]: 'TimeRangeFilter',\n  [FILTER_TYPES.range]: 'RangeFilter',\n  [FILTER_TYPES.polygon]: 'PolygonFilter'\n};\n\nexport const DEFAULT_FILTER_STRUCTURE = {\n  dataId: [], // [string]\n  freeze: false,\n  id: null,\n\n  // time range filter specific\n  fixedDomain: false,\n  enlarged: false,\n  isAnimating: false,\n  animationWindow: ANIMATION_WINDOW.free,\n  speed: 1,\n\n  // field specific\n  name: [], // string\n  type: null,\n  fieldIdx: [], // [integer]\n  domain: null,\n  value: null,\n\n  // plot\n  plotType: PLOT_TYPES.histogram,\n  yAxis: null,\n  interval: null,\n\n  // mode\n  gpu: false\n};\n\nexport const FILTER_ID_LENGTH = 4;\n\nexport const LAYER_FILTERS = [FILTER_TYPES.polygon];\n\n/**\n * Generates a filter with a dataset id as dataId\n * @type {typeof import('./filter-utils').getDefaultFilter}\n */\nexport function getDefaultFilter(dataId) {\n  return {\n    ...DEFAULT_FILTER_STRUCTURE,\n    // store it as dataId and it could be one or many\n    dataId: toArray(dataId),\n    id: generateHashId(FILTER_ID_LENGTH)\n  };\n}\n\n/**\n * Check if a filter is valid based on the given dataId\n * @param  filter to validate\n * @param  datasetId id to validate filter against\n * @return true if a filter is valid, false otherwise\n * @type {typeof import('./filter-utils').shouldApplyFilter}\n */\nexport function shouldApplyFilter(filter, datasetId) {\n  const dataIds = toArray(filter.dataId);\n  return dataIds.includes(datasetId) && filter.value !== null;\n}\n\n/**\n * Validates and modifies polygon filter structure\n * @param dataset\n * @param filter\n * @param layers\n * @return - {filter, dataset}\n * @type {typeof import('./filter-utils').validatePolygonFilter}\n */\nexport function validatePolygonFilter(dataset, filter, layers) {\n  const failed = {dataset, filter: null};\n  const {value, layerId, type, dataId} = filter;\n\n  if (!layerId || !isValidFilterValue(type, value)) {\n    return failed;\n  }\n\n  const isValidDataset = dataId.includes(dataset.id);\n\n  if (!isValidDataset) {\n    return failed;\n  }\n\n  const layer = layers.find(l => layerId.includes(l.id));\n\n  if (!layer) {\n    return failed;\n  }\n\n  return {\n    filter: {\n      ...filter,\n      freeze: true,\n      fieldIdx: []\n    },\n    dataset\n  };\n}\n\n/**\n * Custom filter validators\n */\nconst filterValidators = {\n  [FILTER_TYPES.polygon]: validatePolygonFilter\n};\n\n/**\n * Default validate filter function\n * @param dataset\n * @param filter\n * @return - {filter, dataset}\n * @type {typeof import('./filter-utils').validateFilter}\n */\nexport function validateFilter(dataset, filter) {\n  // match filter.dataId\n  const failed = {dataset, filter: null};\n  const filterDataId = toArray(filter.dataId);\n\n  const filterDatasetIndex = filterDataId.indexOf(dataset.id);\n  if (filterDatasetIndex < 0) {\n    // the current filter is not mapped against the current dataset\n    return failed;\n  }\n\n  const initializeFilter = {\n    ...getDefaultFilter(filter.dataId),\n    ...filter,\n    dataId: filterDataId,\n    name: toArray(filter.name)\n  };\n\n  const fieldName = initializeFilter.name[filterDatasetIndex];\n  const {filter: updatedFilter, dataset: updatedDataset} = applyFilterFieldName(\n    initializeFilter,\n    dataset,\n    fieldName,\n    filterDatasetIndex,\n    {mergeDomain: true}\n  );\n\n  if (!updatedFilter) {\n    return failed;\n  }\n\n  updatedFilter.value = adjustValueToFilterDomain(filter.value, updatedFilter);\n  updatedFilter.enlarged =\n    typeof filter.enlarged === 'boolean' ? filter.enlarged : updatedFilter.enlarged;\n\n  if (updatedFilter.value === null) {\n    // cannot adjust saved value to filter\n    return failed;\n  }\n\n  return {\n    filter: validateFilterYAxis(updatedFilter, updatedDataset),\n    dataset: updatedDataset\n  };\n}\n\n/**\n * Validate saved filter config with new data,\n * calculate domain and fieldIdx based new fields and data\n *\n * @param dataset\n * @param filter - filter to be validate\n * @param layers - layers\n * @return validated filter\n * @type {typeof import('./filter-utils').validateFilterWithData}\n */\nexport function validateFilterWithData(dataset, filter, layers) {\n  // @ts-ignore\n  return filterValidators.hasOwnProperty(filter.type)\n    ? filterValidators[filter.type](dataset, filter, layers)\n    : validateFilter(dataset, filter);\n}\n\n/**\n * Validate YAxis\n * @param filter\n * @param dataset\n * @return {*}\n */\nfunction validateFilterYAxis(filter, dataset) {\n  // TODO: validate yAxis against other datasets\n\n  const {fields} = dataset;\n  const {yAxis} = filter;\n  // TODO: validate yAxis against other datasets\n  if (yAxis) {\n    const matchedAxis = fields.find(({name, type}) => name === yAxis.name && type === yAxis.type);\n\n    filter = matchedAxis\n      ? {\n          ...filter,\n          yAxis: matchedAxis,\n          ...getFilterPlot({...filter, yAxis: matchedAxis}, dataset)\n        }\n      : filter;\n  }\n\n  return filter;\n}\n\n/**\n * Get default filter prop based on field type\n *\n * @param field\n * @param fieldDomain\n * @returns default filter\n * @type {typeof import('./filter-utils').getFilterProps}\n */\nexport function getFilterProps(field, fieldDomain) {\n  const filterProps = {\n    ...fieldDomain,\n    fieldType: field.type\n  };\n\n  switch (field.type) {\n    case ALL_FIELD_TYPES.real:\n    case ALL_FIELD_TYPES.integer:\n      return {\n        ...filterProps,\n        value: fieldDomain.domain,\n        type: FILTER_TYPES.range,\n        typeOptions: [FILTER_TYPES.range],\n        gpu: true\n      };\n\n    case ALL_FIELD_TYPES.boolean:\n      return {\n        ...filterProps,\n        type: FILTER_TYPES.select,\n        value: true,\n        gpu: false\n      };\n\n    case ALL_FIELD_TYPES.string:\n    case ALL_FIELD_TYPES.date:\n      return {\n        ...filterProps,\n        type: FILTER_TYPES.multiSelect,\n        value: [],\n        gpu: false\n      };\n\n    case ALL_FIELD_TYPES.timestamp:\n      return {\n        ...filterProps,\n        type: FILTER_TYPES.timeRange,\n        enlarged: true,\n        fixedDomain: true,\n        value: filterProps.domain,\n        gpu: true\n      };\n\n    default:\n      return {};\n  }\n}\n\nexport const getPolygonFilterFunctor = (layer, filter, dataContainer) => {\n  const getPosition = layer.getPositionAccessor(dataContainer);\n\n  switch (layer.type) {\n    case LAYER_TYPES.point:\n    case LAYER_TYPES.icon:\n      return data => {\n        const pos = getPosition(data);\n        return pos.every(Number.isFinite) && isInPolygon(pos, filter.value);\n      };\n    case LAYER_TYPES.arc:\n    case LAYER_TYPES.line:\n      return data => {\n        const pos = getPosition(data);\n        return (\n          pos.every(Number.isFinite) &&\n          [\n            [pos[0], pos[1]],\n            [pos[3], pos[4]]\n          ].every(point => isInPolygon(point, filter.value))\n        );\n      };\n    case LAYER_TYPES.hexagonId:\n      if (layer.dataToFeature && layer.dataToFeature.centroids) {\n        return data => {\n          // null or getCentroid({id})\n          const centroid = layer.dataToFeature.centroids[data.index];\n          return centroid && isInPolygon(centroid, filter.value);\n        };\n      }\n      return data => {\n        const id = getPosition(data);\n        if (!h3IsValid(id)) {\n          return false;\n        }\n        const pos = getCentroid({id});\n        return pos.every(Number.isFinite) && isInPolygon(pos, filter.value);\n      };\n    default:\n      return () => true;\n  }\n};\n\n/**\n * @param field dataset Field\n * @param dataId Dataset id\n * @param filter Filter object\n * @param layers list of layers to filter upon\n * @param dataContainer Data container\n * @return filterFunction\n * @type {typeof import('./filter-utils').getFilterFunction}\n */\nexport function getFilterFunction(field, dataId, filter, layers, dataContainer) {\n  // field could be null in polygon filter\n  const valueAccessor = field ? field.valueAccessor : data => null;\n  const defaultFunc = d => true;\n\n  switch (filter.type) {\n    case FILTER_TYPES.range:\n      return data => isInRange(valueAccessor(data), filter.value);\n    case FILTER_TYPES.multiSelect:\n      return data => filter.value.includes(valueAccessor(data));\n    case FILTER_TYPES.select:\n      return data => valueAccessor(data) === filter.value;\n    case FILTER_TYPES.timeRange:\n      if (!field) {\n        return defaultFunc;\n      }\n      const mappedValue = get(field, ['filterProps', 'mappedValue']);\n      const accessor = Array.isArray(mappedValue)\n        ? data => mappedValue[data.index]\n        : data => timeToUnixMilli(valueAccessor(data), field.format);\n      return data => isInRange(accessor(data), filter.value);\n    case FILTER_TYPES.polygon:\n      if (!layers || !layers.length) {\n        return defaultFunc;\n      }\n      // @ts-ignore\n      const layerFilterFunctions = filter.layerId\n        .map(id => layers.find(l => l.id === id))\n        .filter(l => l && l.config.dataId === dataId)\n        .map(layer => getPolygonFilterFunctor(layer, filter, dataContainer));\n\n      return data => layerFilterFunctions.every(filterFunc => filterFunc(data));\n    default:\n      return defaultFunc;\n  }\n}\n\nexport function updateFilterDataId(dataId) {\n  return getDefaultFilter(dataId);\n}\n\n/**\n * @type {typeof import('./filter-utils').filterDataByFilterTypes}\n */\nexport function filterDataByFilterTypes(\n  {dynamicDomainFilters, cpuFilters, filterFuncs},\n  dataContainer\n) {\n  const result = {\n    ...(dynamicDomainFilters ? {filteredIndexForDomain: []} : {}),\n    ...(cpuFilters ? {filteredIndex: []} : {})\n  };\n\n  const filterContext = {index: -1, dataContainer};\n  const filterFuncCaller = filter => filterFuncs[filter.id](filterContext);\n\n  const numRows = dataContainer.numRows();\n  for (let i = 0; i < numRows; ++i) {\n    filterContext.index = i;\n\n    const matchForDomain = dynamicDomainFilters && dynamicDomainFilters.every(filterFuncCaller);\n    if (matchForDomain) {\n      // @ts-ignore\n      result.filteredIndexForDomain.push(filterContext.index);\n    }\n\n    const matchForRender = cpuFilters && cpuFilters.every(filterFuncCaller);\n    if (matchForRender) {\n      // @ts-ignore\n      result.filteredIndex.push(filterContext.index);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Get a record of filters based on domain type and gpu / cpu\n * @type {typeof import('./filter-utils').getFilterRecord}\n */\nexport function getFilterRecord(dataId, filters, opt = {}) {\n  /**\n   * @type {FilterRecord}\n   */\n  const filterRecord = {\n    dynamicDomain: [],\n    fixedDomain: [],\n    cpu: [],\n    gpu: []\n  };\n\n  filters.forEach(f => {\n    if (isValidFilterValue(f.type, f.value) && toArray(f.dataId).includes(dataId)) {\n      (f.fixedDomain || opt.ignoreDomain\n        ? filterRecord.fixedDomain\n        : filterRecord.dynamicDomain\n      ).push(f);\n\n      (f.gpu && !opt.cpuOnly ? filterRecord.gpu : filterRecord.cpu).push(f);\n    }\n  });\n\n  return filterRecord;\n}\n\n/**\n * Compare filter records to get what has changed\n * @type {typeof import('./filter-utils').diffFilters}\n */\nexport function diffFilters(filterRecord, oldFilterRecord = {}) {\n  let filterChanged = {};\n\n  Object.entries(filterRecord).forEach(([record, items]) => {\n    items.forEach(filter => {\n      const oldFilter = (oldFilterRecord[record] || []).find(f => f.id === filter.id);\n\n      if (!oldFilter) {\n        // added\n        filterChanged = set([record, filter.id], 'added', filterChanged);\n      } else {\n        // check  what has changed\n        ['name', 'value', 'dataId'].forEach(prop => {\n          if (filter[prop] !== oldFilter[prop]) {\n            filterChanged = set([record, filter.id], `${prop}_changed`, filterChanged);\n          }\n        });\n      }\n    });\n\n    (oldFilterRecord[record] || []).forEach(oldFilter => {\n      // deleted\n      if (!items.find(f => f.id === oldFilter.id)) {\n        filterChanged = set([record, oldFilter.id], 'deleted', filterChanged);\n      }\n    });\n\n    if (!filterChanged[record]) {\n      filterChanged[record] = null;\n    }\n  });\n\n  // @ts-ignore\n  return filterChanged;\n}\n/**\n * Call by parsing filters from URL\n * Check if value of filter within filter domain, if not adjust it to match\n * filter domain\n *\n * @type {typeof import('./filter-utils').adjustValueToFilterDomain}\n * @returns value - adjusted value to match filter or null to remove filter\n */\n/* eslint-disable complexity */\nexport function adjustValueToFilterDomain(value, {domain, type}) {\n  if (!domain || !type) {\n    return false;\n  }\n\n  switch (type) {\n    case FILTER_TYPES.range:\n    case FILTER_TYPES.timeRange:\n      if (!Array.isArray(value) || value.length !== 2) {\n        return domain.map(d => d);\n      }\n\n      return value.map((d, i) => (notNullorUndefined(d) && isInRange(d, domain) ? d : domain[i]));\n\n    case FILTER_TYPES.multiSelect:\n      if (!Array.isArray(value)) {\n        return [];\n      }\n      const filteredValue = value.filter(d => domain.includes(d));\n      return filteredValue.length ? filteredValue : [];\n\n    case FILTER_TYPES.select:\n      return domain.includes(value) ? value : true;\n\n    default:\n      return null;\n  }\n}\n/* eslint-enable complexity */\n\n/**\n * Calculate numeric domain and suitable step\n *\n * @type {typeof import('./filter-utils').getNumericFieldDomain}\n */\nexport function getNumericFieldDomain(dataContainer, valueAccessor) {\n  let domain = [0, 1];\n  let step = 0.1;\n\n  const mappedValue = dataContainer.mapIndex(valueAccessor);\n\n  if (dataContainer.numRows() > 1) {\n    domain = ScaleUtils.getLinearDomain(mappedValue);\n    const diff = domain[1] - domain[0];\n\n    // in case equal domain, [96, 96], which will break quantize scale\n    if (!diff) {\n      domain[1] = domain[0] + 1;\n    }\n\n    step = getNumericStepSize(diff) || step;\n    domain[0] = formatNumberByStep(domain[0], step, 'floor');\n    domain[1] = formatNumberByStep(domain[1], step, 'ceil');\n  }\n\n  // @ts-ignore\n  const {histogram, enlargedHistogram} = getHistogram(domain, mappedValue);\n\n  return {domain, step, histogram, enlargedHistogram};\n}\n\n/**\n * Calculate step size for range and timerange filter\n *\n * @type {typeof import('./filter-utils').getNumericStepSize}\n */\nexport function getNumericStepSize(diff) {\n  diff = Math.abs(diff);\n\n  if (diff > 100) {\n    return 1;\n  } else if (diff > 3) {\n    return 0.01;\n  } else if (diff > 1) {\n    return 0.001;\n  }\n  // Try to get at least 1000 steps - and keep the step size below that of\n  // the (diff > 1) case.\n  const x = diff / 1000;\n  // Find the exponent and truncate to 10 to the power of that exponent\n\n  const exponentialForm = x.toExponential();\n  const exponent = parseFloat(exponentialForm.split('e')[1]);\n\n  // Getting ready for node 12\n  // this is why we need decimal.js\n  // Math.pow(10, -5) = 0.000009999999999999999\n  // the above result shows in browser and node 10\n  // node 12 behaves correctly\n  return new Decimal(10).pow(exponent).toNumber();\n}\n\n/**\n * Calculate timestamp domain and suitable step\n * @type {typeof import('./filter-utils').getTimestampFieldDomain}\n */\nexport function getTimestampFieldDomain(dataContainer, valueAccessor) {\n  // to avoid converting string format time to epoch\n  // every time we compare we store a value mapped to int in filter domain\n\n  const mappedValue = dataContainer.mapIndex(valueAccessor);\n  const domain = ScaleUtils.getLinearDomain(mappedValue);\n  const defaultTimeFormat = getTimeWidgetTitleFormatter(domain);\n\n  let step = 0.01;\n\n  const diff = domain[1] - domain[0];\n  const entry = TimestampStepMap.find(f => f.max >= diff);\n  if (entry) {\n    step = entry.step;\n  }\n\n  const {histogram, enlargedHistogram} = getHistogram(domain, mappedValue);\n\n  return {\n    domain,\n    step,\n    mappedValue,\n    histogram,\n    enlargedHistogram,\n    defaultTimeFormat\n  };\n}\n\n/**\n *\n * @type {typeof import('./filter-utils').histogramConstruct}\n */\nexport function histogramConstruct(domain, mappedValue, bins) {\n  return d3Histogram()\n    .thresholds(ticks(domain[0], domain[1], bins))\n    .domain(domain)(mappedValue)\n    .map(bin => ({\n      count: bin.length,\n      x0: bin.x0,\n      x1: bin.x1\n    }));\n}\n/**\n * Calculate histogram from domain and array of values\n *\n * @type {typeof import('./filter-utils').getHistogram}\n */\nexport function getHistogram(domain, mappedValue) {\n  const histogram = histogramConstruct(domain, mappedValue, histogramBins);\n  const enlargedHistogram = histogramConstruct(domain, mappedValue, enlargedHistogramBins);\n\n  return {histogram, enlargedHistogram};\n}\n\n/**\n * round number based on step\n *\n * @param {Number} val\n * @param {Number} step\n * @param {string} bound\n * @returns {Number} rounded number\n */\nexport function formatNumberByStep(val, step, bound) {\n  if (bound === 'floor') {\n    return Math.floor(val * (1 / step)) / (1 / step);\n  }\n\n  return Math.ceil(val * (1 / step)) / (1 / step);\n}\n\n/**\n *\n * @type {typeof import('./filter-utils').isInRange}\n */\nexport function isInRange(val, domain) {\n  if (!Array.isArray(domain)) {\n    return false;\n  }\n\n  return val >= domain[0] && val <= domain[1];\n}\n\n/**\n * Determines whether a point is within the provided polygon\n *\n * @param point as input search [lat, lng]\n * @param polygon Points must be within these (Multi)Polygon(s)\n * @return {boolean}\n */\nexport function isInPolygon(point, polygon) {\n  return booleanWithin(turfPoint(point), polygon);\n}\nexport function isValidTimeDomain(domain) {\n  return Array.isArray(domain) && domain.every(Number.isFinite);\n}\nexport function getTimeWidgetTitleFormatter(domain) {\n  if (!isValidTimeDomain(domain)) {\n    return null;\n  }\n\n  const diff = domain[1] - domain[0];\n\n  // Local aware formats\n  // https://momentjs.com/docs/#/parsing/string-format\n  return diff > durationYear ? 'L' : diff > durationDay ? 'L LT' : 'L LTS';\n}\n\nexport function getTimeWidgetHintFormatter(domain) {\n  if (!isValidTimeDomain(domain)) {\n    return null;\n  }\n\n  const diff = domain[1] - domain[0];\n  return diff > durationWeek\n    ? 'L'\n    : diff > durationDay\n    ? 'L LT'\n    : diff > durationHour\n    ? 'LT'\n    : 'LTS';\n}\n\n/**\n * Sanity check on filters to prepare for save\n * @type {typeof import('./filter-utils').isValidFilterValue}\n */\n/* eslint-disable complexity */\nexport function isValidFilterValue(type, value) {\n  if (!type) {\n    return false;\n  }\n  switch (type) {\n    case FILTER_TYPES.select:\n      return value === true || value === false;\n\n    case FILTER_TYPES.range:\n    case FILTER_TYPES.timeRange:\n      return Array.isArray(value) && value.every(v => v !== null && !isNaN(v));\n\n    case FILTER_TYPES.multiSelect:\n      return Array.isArray(value) && Boolean(value.length);\n\n    case FILTER_TYPES.input:\n      return Boolean(value.length);\n\n    case FILTER_TYPES.polygon:\n      const coordinates = get(value, ['geometry', 'coordinates']);\n      return Boolean(value && value.id && coordinates);\n\n    default:\n      return true;\n  }\n}\n\n/**\n *\n * @type {typeof import('./filter-utils').getFilterPlot}\n */\nexport function getFilterPlot(filter, dataset) {\n  if (filter.plotType === PLOT_TYPES.histogram || !filter.yAxis) {\n    // histogram should be calculated when create filter\n    return {};\n  }\n\n  const {mappedValue = []} = filter;\n  const {yAxis} = filter;\n  const fieldIdx = dataset.getColumnFieldIdx(yAxis.name);\n  if (fieldIdx < 0) {\n    Console.warn(`yAxis ${yAxis.name} does not exist in dataset`);\n    return {lineChart: {}, yAxis};\n  }\n\n  // return lineChart\n  const series = dataset.dataContainer\n    .map(\n      (row, rowIndex) => ({\n        x: mappedValue[rowIndex],\n        y: row.valueAt(fieldIdx)\n      }),\n      true\n    )\n    .filter(({x, y}) => Number.isFinite(x) && Number.isFinite(y))\n    .sort((a, b) => ascending(a.x, b.x));\n\n  const yDomain = extent(series, d => d.y);\n  const xDomain = [series[0].x, series[series.length - 1].x];\n\n  return {lineChart: {series, yDomain, xDomain}, yAxis};\n}\n\nexport function getDefaultFilterPlotType(filter) {\n  const filterPlotTypes = SupportedPlotType[filter.type];\n  if (!filterPlotTypes) {\n    return null;\n  }\n\n  if (!filter.yAxis) {\n    return filterPlotTypes.default;\n  }\n\n  return filterPlotTypes[filter.yAxis.type] || null;\n}\n\n/**\n *\n * @param datasetIds list of dataset ids to be filtered\n * @param datasets all datasets\n * @param filters all filters to be applied to datasets\n * @return datasets - new updated datasets\n * @type {typeof import('./filter-utils').applyFiltersToDatasets}\n */\nexport function applyFiltersToDatasets(datasetIds, datasets, filters, layers) {\n  const dataIds = toArray(datasetIds);\n  return dataIds.reduce((acc, dataId) => {\n    const layersToFilter = (layers || []).filter(l => l.config.dataId === dataId);\n    const appliedFilters = filters.filter(d => shouldApplyFilter(d, dataId));\n    const table = datasets[dataId];\n\n    return {\n      ...acc,\n      [dataId]: table.filterTable(appliedFilters, layersToFilter, {})\n    };\n  }, datasets);\n}\n\n/**\n * Applies a new field name value to fielter and update both filter and dataset\n * @param filter - to be applied the new field name on\n * @param dataset - dataset the field belongs to\n * @param fieldName - field.name\n * @param filterDatasetIndex - field.name\n * @param option\n * @return - {filter, datasets}\n * @type {typeof import('./filter-utils').applyFilterFieldName}\n */\nexport function applyFilterFieldName(filter, dataset, fieldName, filterDatasetIndex = 0, option) {\n  // using filterDatasetIndex we can filter only the specified dataset\n  const mergeDomain = option && option.hasOwnProperty('mergeDomain') ? option.mergeDomain : false;\n\n  const fieldIndex = dataset.getColumnFieldIdx(fieldName);\n  // if no field with same name is found, move to the next datasets\n  if (fieldIndex === -1) {\n    // throw new Error(`fieldIndex not found. Dataset must contain a property with name: ${fieldName}`);\n    return {filter: null, dataset};\n  }\n\n  // TODO: validate field type\n  const filterProps = dataset.getColumnFilterProps(fieldName);\n\n  const newFilter = {\n    ...(mergeDomain ? mergeFilterDomainStep(filter, filterProps) : {...filter, ...filterProps}),\n    name: Object.assign([...toArray(filter.name)], {[filterDatasetIndex]: fieldName}),\n    fieldIdx: Object.assign([...toArray(filter.fieldIdx)], {\n      [filterDatasetIndex]: fieldIndex\n    }),\n    // TODO, since we allow to add multiple fields to a filter we can no longer freeze the filter\n    freeze: true\n  };\n\n  return {\n    filter: newFilter,\n    dataset\n  };\n}\n\n/**\n * Merge one filter with other filter prop domain\n * @type {typeof import('./filter-utils').mergeFilterDomainStep}\n */\n/* eslint-disable complexity */\nexport function mergeFilterDomainStep(filter, filterProps) {\n  if (!filter) {\n    return null;\n  }\n\n  if (!filterProps) {\n    return filter;\n  }\n\n  if ((filter.fieldType && filter.fieldType !== filterProps.fieldType) || !filterProps.domain) {\n    return filter;\n  }\n\n  const combinedDomain = !filter.domain\n    ? filterProps.domain\n    : [...(filter.domain || []), ...(filterProps.domain || [])].sort((a, b) => a - b);\n\n  const newFilter = {\n    ...filter,\n    ...filterProps,\n    domain: [combinedDomain[0], combinedDomain[combinedDomain.length - 1]]\n  };\n\n  switch (filterProps.fieldType) {\n    case ALL_FIELD_TYPES.string:\n    case ALL_FIELD_TYPES.date:\n      return {\n        ...newFilter,\n        domain: unique(combinedDomain).sort()\n      };\n\n    case ALL_FIELD_TYPES.timestamp:\n      // @ts-ignore\n      const step = filter.step < filterProps.step ? filter.step : filterProps.step;\n\n      return {\n        ...newFilter,\n        step\n      };\n    case ALL_FIELD_TYPES.real:\n    case ALL_FIELD_TYPES.integer:\n    default:\n      return newFilter;\n  }\n}\n/* eslint-enable complexity */\n\n/**\n * Generates polygon filter\n * @type {typeof import('./filter-utils').featureToFilterValue}\n */\nexport const featureToFilterValue = (feature, filterId, properties = {}) => ({\n  ...feature,\n  id: feature.id,\n  properties: {\n    ...feature.properties,\n    ...properties,\n    filterId\n  }\n});\n\n/**\n * @type {typeof import('./filter-utils').getFilterIdInFeature}\n */\nexport const getFilterIdInFeature = f => get(f, ['properties', 'filterId']);\n\n/**\n * Generates polygon filter\n * @type {typeof import('./filter-utils').generatePolygonFilter}\n */\nexport function generatePolygonFilter(layers, feature) {\n  const dataId = layers.map(l => l.config.dataId).filter(d => d);\n  const layerId = layers.map(l => l.id);\n  const name = layers.map(l => l.config.label);\n  // @ts-ignore\n  const filter = getDefaultFilter(dataId);\n  return {\n    ...filter,\n    fixedDomain: true,\n    type: FILTER_TYPES.polygon,\n    name,\n    layerId,\n    value: featureToFilterValue(feature, filter.id, {isVisible: true})\n  };\n}\n\n/**\n * Run filter entirely on CPU\n * @type {typeof import('./filter-utils').filterDatasetCPU}\n */\nexport function filterDatasetCPU(state, dataId) {\n  const datasetFilters = state.filters.filter(f => f.dataId.includes(dataId));\n  const dataset = state.datasets[dataId];\n\n  if (!dataset) {\n    return state;\n  }\n\n  const cpuFilteredDataset = dataset.filterTableCPU(datasetFilters, state.layers);\n\n  return set(['datasets', dataId], cpuFilteredDataset, state);\n}\n\n/**\n * Validate parsed filters with datasets and add filterProps to field\n * @type {typeof import('./filter-utils').validateFiltersUpdateDatasets}\n */\nexport function validateFiltersUpdateDatasets(state, filtersToValidate = []) {\n  const validated = [];\n  const failed = [];\n  const {datasets} = state;\n  let updatedDatasets = datasets;\n\n  // merge filters\n  filtersToValidate.forEach(filter => {\n    // we can only look for datasets define in the filter dataId\n    const datasetIds = toArray(filter.dataId);\n\n    // we can merge a filter only if all datasets in filter.dataId are loaded\n    if (datasetIds.every(d => datasets[d])) {\n      // all datasetIds in filter must be present the state datasets\n      const {filter: validatedFilter, applyToDatasets, augmentedDatasets} = datasetIds.reduce(\n        (acc, datasetId) => {\n          const dataset = updatedDatasets[datasetId];\n          const layers = state.layers.filter(l => l.config.dataId === dataset.id);\n          const {filter: updatedFilter, dataset: updatedDataset} = validateFilterWithData(\n            acc.augmentedDatasets[datasetId] || dataset,\n            filter,\n            layers\n          );\n\n          if (updatedFilter) {\n            return {\n              ...acc,\n              // merge filter props\n              filter: acc.filter\n                ? {\n                    ...acc.filter,\n                    ...mergeFilterDomainStep(acc, updatedFilter)\n                  }\n                : updatedFilter,\n\n              applyToDatasets: [...acc.applyToDatasets, datasetId],\n\n              augmentedDatasets: {\n                ...acc.augmentedDatasets,\n                [datasetId]: updatedDataset\n              }\n            };\n          }\n\n          return acc;\n        },\n        {\n          filter: null,\n          applyToDatasets: [],\n          augmentedDatasets: {}\n        }\n      );\n\n      if (validatedFilter && isEqual(datasetIds, applyToDatasets)) {\n        validated.push(validatedFilter);\n        updatedDatasets = {\n          ...updatedDatasets,\n          ...augmentedDatasets\n        };\n      }\n    } else {\n      failed.push(filter);\n    }\n  });\n\n  return {validated, failed, updatedDatasets};\n}\n\n/**\n * Retrieve interval bins for time filter\n * @type {typeof import('./filter-utils').getIntervalBins}\n */\nexport function getIntervalBins(filter) {\n  const {bins} = filter;\n  const interval = filter.plotType?.interval;\n  if (!interval || !bins || Object.keys(bins).length === 0) {\n    return null;\n  }\n  const values = Object.values(bins);\n  return values[0] ? values[0][interval] : null;\n}\n"]}