@kepler.gl/utils 3.1.0-alpha.0 → 3.1.0-alpha.2

package/dist/split-map-utils.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addNewLayersToSplitMap = addNewLayersToSplitMap;
+exports.computeSplitMapLayers = computeSplitMapLayers;
+exports.getInitialMapLayersForSplitMap = getInitialMapLayersForSplitMap;
+exports.removeLayerFromSplitMaps = removeLayerFromSplitMaps;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * Add new layers to both existing maps
+ * @param {Object} splitMaps
+ * @param {Object|Array<Object>} layers
+ * @returns {Array<Object>} new splitMaps
+ */
+function addNewLayersToSplitMap(splitMaps, layers) {
+  var newLayers = Array.isArray(layers) ? layers : [layers];
+  if (!splitMaps.length || !newLayers.length) {
+    return splitMaps;
+  }
+
+  // add new layer to both maps,
+  // don't override, if layer.id is already in splitMaps
+  return splitMaps.map(function (settings) {
+    return _objectSpread(_objectSpread({}, settings), {}, {
+      layers: _objectSpread(_objectSpread({}, settings.layers), newLayers.reduce(function (accu, newLayer) {
+        return (
+          // @ts-ignore
+          newLayer.id in settings.layers || !newLayer.config.isVisible ? accu : _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, newLayer.id, newLayer.config.isVisible))
+        );
+      }, {}))
+    });
+  });
+}
+
+/**
+ * Remove an existing layer from split map settings
+ * @param {Object} splitMaps
+ * @param {Object} layer
+ * @returns {Object} Maps of custom layer objects
+ */
+function removeLayerFromSplitMaps(splitMaps, layer) {
+  if (!splitMaps.length) {
+    return splitMaps;
+  }
+  return splitMaps.map(function (settings) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _settings$layers = settings.layers,
+      _layer$id = layer.id,
+      _ = _settings$layers[_layer$id],
+      newLayers = (0, _objectWithoutProperties2["default"])(_settings$layers, [_layer$id].map(_toPropertyKey));
+    return _objectSpread(_objectSpread({}, settings), {}, {
+      layers: newLayers
+    });
+  });
+}
+
+/**
+ * This method will compute the default maps layer settings
+ * based on the current layers visibility
+ * @param {Array<Object>} layers
+ * @returns {Array<Object>} layer visibility for each panel
+ */
+function getInitialMapLayersForSplitMap(layers) {
+  return layers.filter(function (layer) {
+    return layer.config.isVisible;
+  }).reduce(function (newLayers, currentLayer) {
+    return _objectSpread(_objectSpread({}, newLayers), {}, (0, _defineProperty2["default"])({}, currentLayer.id, currentLayer.config.isVisible));
+  }, {});
+}
+
+/**
+ * This method will get default splitMap settings based on existing layers
+ * @param {Array<Object>} layers
+ * @param {Object} options
+ * @returns {Array<Object>} split map settings
+ */
+function computeSplitMapLayers(layers, options) {
+  var mapLayers = getInitialMapLayersForSplitMap(layers);
+  var _ref = options || {},
+    duplicate = _ref.duplicate;
+  // show all visible layers in left map, leave right map empty
+  return [{
+    layers: mapLayers
+  }, {
+    layers: duplicate ? (0, _lodash["default"])(mapLayers) : {}
+  }];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_toPropertyKey","t","i","_toPrimitive","_typeof","r","e","Symbol","toPrimitive","call","TypeError","String","Number","ownKeys","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","addNewLayersToSplitMap","splitMaps","layers","newLayers","Array","isArray","map","settings","reduce","accu","newLayer","id","config","isVisible","removeLayerFromSplitMaps","layer","_settings$layers","_layer$id","_","_objectWithoutProperties2","getInitialMapLayersForSplitMap","currentLayer","computeSplitMapLayers","options","mapLayers","_ref","duplicate","cloneDeep"],"sources":["../src/split-map-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport cloneDeep from 'lodash.clonedeep';\n\n/**\n * Add new layers to both existing maps\n * @param {Object} splitMaps\n * @param {Object|Array<Object>} layers\n * @returns {Array<Object>} new splitMaps\n */\nexport function addNewLayersToSplitMap(splitMaps, layers) {\n  const newLayers = Array.isArray(layers) ? layers : [layers];\n\n  if (!splitMaps.length || !newLayers.length) {\n    return splitMaps;\n  }\n\n  // add new layer to both maps,\n  // don't override, if layer.id is already in splitMaps\n  return splitMaps.map(settings => ({\n    ...settings,\n    layers: {\n      ...settings.layers,\n      ...newLayers.reduce(\n        (accu, newLayer) =>\n          // @ts-ignore\n          newLayer.id in settings.layers || !newLayer.config.isVisible\n            ? accu\n            : {\n                ...accu,\n                [newLayer.id]: newLayer.config.isVisible\n              },\n        {}\n      )\n    }\n  }));\n}\n\n/**\n * Remove an existing layer from split map settings\n * @param {Object} splitMaps\n * @param {Object} layer\n * @returns {Object} Maps of custom layer objects\n */\nexport function removeLayerFromSplitMaps(splitMaps, layer) {\n  if (!splitMaps.length) {\n    return splitMaps;\n  }\n  return splitMaps.map(settings => {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const {[layer.id]: _, ...newLayers} = settings.layers;\n    return {\n      ...settings,\n      layers: newLayers\n    };\n  });\n}\n\n/**\n * This method will compute the default maps layer settings\n * based on the current layers visibility\n * @param {Array<Object>} layers\n * @returns {Array<Object>} layer visibility for each panel\n */\nexport function getInitialMapLayersForSplitMap(layers) {\n  return layers\n    .filter(layer => layer.config.isVisible)\n    .reduce(\n      (newLayers, currentLayer) => ({\n        ...newLayers,\n        [currentLayer.id]: currentLayer.config.isVisible\n      }),\n      {}\n    );\n}\n\n/**\n * This method will get default splitMap settings based on existing layers\n * @param {Array<Object>} layers\n * @param {Object} options\n * @returns {Array<Object>} split map settings\n */\nexport function computeSplitMapLayers(layers, options?: {duplicate: boolean}) {\n  const mapLayers = getInitialMapLayersForSplitMap(layers);\n  const {duplicate} = options || {};\n  // show all visible layers in left map, leave right map empty\n  return [{layers: mapLayers}, {layers: duplicate ? cloneDeep(mapLayers) : {}}];\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/strings.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Capitalize first letter of a string
+ */
+export declare function capitalizeFirstLetter(str: string): string;

package/dist/strings.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Capitalize first letter of a string
+ */
+function capitalizeFirstLetter(str) {
+  return typeof str === 'string' ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYXBpdGFsaXplRmlyc3RMZXR0ZXIiLCJzdHIiLCJjaGFyQXQiLCJ0b1VwcGVyQ2FzZSIsInNsaWNlIl0sInNvdXJjZXMiOlsiLi4vc3JjL3N0cmluZ3MudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuLyoqXG4gKiBDYXBpdGFsaXplIGZpcnN0IGxldHRlciBvZiBhIHN0cmluZ1xuICovXG5leHBvcnQgZnVuY3Rpb24gY2FwaXRhbGl6ZUZpcnN0TGV0dGVyKHN0cjogc3RyaW5nKTogc3RyaW5nIHtcbiAgcmV0dXJuIHR5cGVvZiBzdHIgPT09ICdzdHJpbmcnID8gc3RyLmNoYXJBdCgwKS50b1VwcGVyQ2FzZSgpICsgc3RyLnNsaWNlKDEpIDogc3RyO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQTtBQUNBOztBQUVBO0FBQ0E7QUFDQTtBQUNPLFNBQVNBLHFCQUFxQkEsQ0FBQ0MsR0FBVyxFQUFVO0VBQ3pELE9BQU8sT0FBT0EsR0FBRyxLQUFLLFFBQVEsR0FBR0EsR0FBRyxDQUFDQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUNDLFdBQVcsQ0FBQyxDQUFDLEdBQUdGLEdBQUcsQ0FBQ0csS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHSCxHQUFHO0FBQ25GIiwiaWdub3JlTGlzdCI6W119

package/dist/time.d.ts

@@ -0,0 +1,54 @@
+import { AnimationConfig, Timeline, TimeRangeFilter, Filter } from '@kepler.gl/types';
+import { KeplerTableModel } from './types';
+export declare const TIMELINE_MODES: {
+    inner: string;
+    outer: string;
+};
+export declare const TileTimeInterval: {
+    YEAR: string;
+    MONTH: string;
+    DAY: string;
+    HOUR: string;
+    MINUTE: string;
+};
+export declare const TIME_INTERVALS_ORDERED: string[];
+export declare const LayerToFilterTimeInterval: {
+    [x: string]: string;
+};
+export declare const SAMPLE_TIMELINE: {
+    value: number[];
+    domain: number[];
+    speed: number;
+    enableInteraction: boolean;
+    isAnimating: boolean;
+    step: null;
+    mode: string;
+};
+export declare const getTimelineFromAnimationConfig: (animationConfig: AnimationConfig) => Timeline;
+export declare function getIntervalByTicks(ticks: any, start: any, stop: any): string;
+/**
+ * mappedValue is saved to dataset.fields.filterProps
+ * @param dataset {KeplerTable}
+ * @param filter
+ */
+export declare function getFilterMappedValue(dataset: KeplerTableModel<any, any>, filter: Filter): Filter['mappedValue'] | null;
+export declare function intervalToFunction(id: string): any;
+/**
+ * Get initial interval from filter and datasets
+ * @param filter
+ * @param datasets
+ * @returns
+ */
+export declare function getInitialInterval(filter: Filter, datasets: Record<string, KeplerTableModel<any, any>>): string;
+/**
+ *
+ * @param options
+ * @param domain
+ */
+export declare function filterIntervalOptions(options: any, domain: any): any;
+/**
+ * Get timeline from filter
+ * @param filter TimeRangeFilter filter
+ * @returns Timeline
+ */
+export declare const getTimelineFromFilter: (filter: TimeRangeFilter) => Timeline;

package/dist/time.js

@@ -0,0 +1,325 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileTimeInterval = exports.TIME_INTERVALS_ORDERED = exports.TIMELINE_MODES = exports.SAMPLE_TIMELINE = exports.LayerToFilterTimeInterval = void 0;
+exports.filterIntervalOptions = filterIntervalOptions;
+exports.getFilterMappedValue = getFilterMappedValue;
+exports.getInitialInterval = getInitialInterval;
+exports.getIntervalByTicks = getIntervalByTicks;
+exports.getTimelineFromFilter = exports.getTimelineFromAnimationConfig = void 0;
+exports.intervalToFunction = intervalToFunction;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _d3Array = require("d3-array");
+var _moment = _interopRequireDefault(require("moment"));
+var _constants = require("@kepler.gl/constants");
+var _commonUtils = require("@kepler.gl/common-utils");
+var _aggregation = require("./aggregation");
+var _plot = require("./plot");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var TIMELINE_MODES = exports.TIMELINE_MODES = {
+  inner: 'inner',
+  outer: 'outer'
+};
+var TileTimeInterval = exports.TileTimeInterval = {
+  YEAR: 'Y',
+  MONTH: 'M',
+  DAY: 'D',
+  HOUR: 'H',
+  MINUTE: 'T'
+};
+var TIME_INTERVALS_ORDERED = exports.TIME_INTERVALS_ORDERED = [TileTimeInterval.MINUTE, TileTimeInterval.HOUR, TileTimeInterval.DAY, TileTimeInterval.MONTH, TileTimeInterval.YEAR];
+var LayerToFilterTimeInterval = exports.LayerToFilterTimeInterval = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, TileTimeInterval.MINUTE, _constants.INTERVAL['1-minute']), TileTimeInterval.HOUR, _constants.INTERVAL['1-hour']), TileTimeInterval.DAY, _constants.INTERVAL['1-day']), TileTimeInterval.MONTH, _constants.INTERVAL['1-month']), TileTimeInterval.YEAR, _constants.INTERVAL['1-year']);
+var SAMPLE_TIMELINE = exports.SAMPLE_TIMELINE = {
+  // value: [15], // represent 15% of the all width
+  value: [5, 15],
+  // represent start at 5% and ends at 15%
+  domain: [1, 100],
+  // represent the total domain
+  speed: 1,
+  enableInteraction: false,
+  // can use interact with this timeline
+  isAnimating: false,
+  step: null,
+  // @todo: giuseppe coverType: 'inner' | 'outer'
+  mode: TIMELINE_MODES.inner
+  //  ....
+};
+var getTimelineFromAnimationConfig = exports.getTimelineFromAnimationConfig = function getTimelineFromAnimationConfig(animationConfig) {
+  var currentTime = animationConfig.currentTime,
+    domain = animationConfig.domain,
+    speed = animationConfig.speed,
+    isAnimating = animationConfig.isAnimating,
+    timeSteps = animationConfig.timeSteps,
+    defaultTimeFormat = animationConfig.defaultTimeFormat,
+    timeFormat = animationConfig.timeFormat,
+    timezone = animationConfig.timezone;
+  return {
+    // @ts-expect-error
+    value: (0, _commonUtils.toArray)(currentTime),
+    enableInteraction: true,
+    domain: domain,
+    speed: speed,
+    isAnimating: isAnimating || false,
+    timeSteps: timeSteps,
+    defaultTimeFormat: defaultTimeFormat,
+    timeFormat: timeFormat,
+    timezone: timezone,
+    timeBins: null,
+    marks: null
+  };
+};
+
+// check if the data inherent default time interval
+
+// https://github.com/d3/d3-scale/blob/732ed4b1cd5c643700571d1089c7deb8472242a6/src/time.js#L69
+// given number of ticks, calculate a reasonable interval
+function getIntervalByTicks(ticks, start, stop) {
+  if (ticks === null) ticks = 10;
+  var tickIntervals = Object.values(_constants.TICK_INTERVALS);
+  var interval;
+  var step;
+  // If a desired tick count is specified, pick a reasonable tick interval
+  // based on the extent of the domain and a rough estimate of tick size.
+  // Otherwise, assume interval is already a time interval and use it.
+  if (typeof ticks === 'number') {
+    var target = Math.abs(stop - start) / ticks;
+    var i = (0, _d3Array.bisector)(function (d) {
+      return d.duration;
+    }).right(tickIntervals, target);
+    if (i === tickIntervals.length) {
+      step = (0, _d3Array.tickStep)(start / _constants.durationYear, stop / _constants.durationYear, ticks);
+      interval = 'year';
+    } else if (i) {
+      var tickInterval = tickIntervals[target / tickIntervals[i - 1].duration < tickIntervals[i].duration / target ? i - 1 : i];
+      // @ts-ignore TODO/ib
+      step = tickInterval.step;
+      // @ts-ignore TODO/ib
+      interval = tickInterval.interval;
+    } else {
+      step = Math.max((0, _d3Array.tickStep)(start, stop, ticks), 1);
+      interval = 'millisecond';
+    }
+  }
+  return "".concat(step, "-").concat(interval);
+}
+
+// get a  number of unique samples
+function getUniqueSamples(values, count) {
+  var i = -1;
+  var samples = [];
+  var sampleMap = {};
+  while (i++ < values.length && samples.length < count) {
+    var v = values[i];
+    if (v !== undefined && v !== null && !sampleMap[v]) {
+      sampleMap[v] = true;
+      samples.push(v);
+    }
+  }
+  return Object.values(samples);
+}
+
+/**
+ * Given an array of epoch timestamp. sort it, if number of element
+ * share the same time interval exceed thresholf, and total steps smaller than 100, return it, else return null
+ * @param values
+ */
+function detectInterval() {
+  var values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var domain = arguments.length > 1 ? arguments[1] : undefined;
+  var maxSteps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10;
+  var threshold = 0.7;
+  var sorted = values.sort(_d3Array.ascending);
+
+  // get first 100 unique sorted ts
+  var samples = getUniqueSamples(sorted, 100);
+  if (samples.length < 2) {
+    return null;
+  }
+
+  // get all intervals
+  var intervals = samples.reduce(function (accu, d, i) {
+    if (i > 0) {
+      var duration = _moment["default"].duration(_moment["default"].utc(samples[i]).diff(_moment["default"].utc(samples[i - 1])));
+      var _getDurationUnit = getDurationUnit(duration),
+        _getDurationUnit2 = (0, _slicedToArray2["default"])(_getDurationUnit, 2),
+        dur = _getDurationUnit2[0],
+        c = _getDurationUnit2[1];
+      accu.push("".concat(c, "-").concat(dur));
+    }
+    return accu;
+  }, []);
+
+  // find the most occured interval
+  var occur = (0, _aggregation.getFrequency)(intervals);
+  var maxOccr = Object.keys(occur).reduce(function (prev, key) {
+    return occur[prev] >= occur[key] ? prev : key;
+  }, Object.keys(occur)[0]);
+
+  // if occurance passed threshold
+  var mostOccur = occur[maxOccr] / intervals.length;
+  if (mostOccur >= threshold) {
+    var _maxOccr$split = maxOccr.split('-'),
+      _maxOccr$split2 = (0, _slicedToArray2["default"])(_maxOccr$split, 2),
+      step = _maxOccr$split2[0],
+      dur = _maxOccr$split2[1];
+    var durationSecond = _constants.DURATIONS[dur] * parseInt(step); // eslint-disable-line radix
+    var totalSteps = (domain[1] - domain[0]) / durationSecond;
+    if (totalSteps < maxSteps) {
+      // duration function is .days interval is day
+      return maxOccr.substring(0, maxOccr.length - 1);
+    }
+  }
+  return null;
+}
+
+/**
+ * mappedValue is saved to dataset.fields.filterProps
+ * @param dataset {KeplerTable}
+ * @param filter
+ */
+function getFilterMappedValue(dataset, filter) {
+  var dataId = dataset.id;
+  var fieldName = filter.name[filter.dataId.indexOf(dataId)];
+  var field = dataset.getColumnField(fieldName);
+  if (!field) {
+    // eslint-disable-next-line no-console, no-undef
+    console.warn("field ".concat(fieldName, " does not exist on dataset"));
+    return null;
+  }
+  var mappedValue = (field.filterProps || {}).mappedValue;
+  if (!mappedValue) {
+    // eslint-disable-next-line no-console, no-undef
+    console.warn("mappedValue doesnt exist on filter field ".concat(filter.name));
+    return null;
+  }
+  return mappedValue;
+}
+/**
+ * Find the round unit of given durmostOccurtion: x years | months | days
+ * @param duration
+ */
+function getDurationUnit(duration) {
+  var durFuncs = Object.keys(_constants.DURATIONS);
+  for (var i = 0; i < durFuncs.length; i++) {
+    var c = duration[durFuncs[i]]();
+    if (c > 0) {
+      return [durFuncs[i], c];
+    }
+  }
+  return ['milliseconds', 1];
+}
+function intervalToFunction(id) {
+  var _id$split = id.split('-'),
+    _id$split2 = (0, _slicedToArray2["default"])(_id$split, 2),
+    stepStr = _id$split2[0],
+    interval = _id$split2[1];
+  var step = parseInt(stepStr); // eslint-disable-line radix
+  if (!step) {
+    // eslint-disable-next-line no-console, no-undef
+    console.warn('Step is not an integer');
+    return null;
+  }
+  if (!_constants.TIME_INTERVALS[interval]) {
+    // eslint-disable-next-line no-console, no-undef
+    console.warn("Undefined time interval ".concat(interval));
+    return null;
+  }
+  return _constants.TIME_INTERVALS[interval].every(step);
+}
+
+/**
+ * Get initial interval from filter and datasets
+ * @param filter
+ * @param datasets
+ * @returns
+ */
+function getInitialInterval(filter, datasets) {
+  var domain = filter.domain;
+  var mergeMappedValue = filter.dataId.reduce(function (accu, dataId) {
+    var mappedValue = getFilterMappedValue(datasets[dataId], filter);
+    if (!mappedValue) {
+      return accu;
+    }
+    for (var i = 0; i < mappedValue.length; i++) {
+      accu.push(mappedValue[i]);
+    }
+    return accu;
+  }, []);
+
+  // check if data has predefined interval
+  var interval = detectInterval(mergeMappedValue, domain);
+  if (!interval) {
+    // @ts-expect-error need better types for domain
+    var _domain = (0, _slicedToArray2["default"])(domain, 2),
+      t0 = _domain[0],
+      t1 = _domain[1];
+    interval = getIntervalByTicks(_constants.BINS_LARGE, t0, t1);
+  }
+  return interval;
+}
+
+// Filter interval options by time filter domain
+// max number of interval is 1000
+/**
+ *
+ * @param options
+ * @param domain
+ */
+function filterIntervalOptions(options, domain) {
+  var maxBins = 1000;
+  var minBins = 2;
+  var timeSpan = domain[1] - domain[0];
+  return options.filter(function (op) {
+    var id = op.id;
+    if (!_constants.TICK_INTERVALS[id]) {
+      return false;
+    }
+    var interval = _constants.TICK_INTERVALS[id];
+
+    // rough count on bins
+    var count = timeSpan / (interval.step * interval.duration);
+    return count >= minBins && count <= maxBins;
+  });
+}
+
+/**
+ * Get timeline from filter
+ * @param filter TimeRangeFilter filter
+ * @returns Timeline
+ */
+var getTimelineFromFilter = exports.getTimelineFromFilter = function getTimelineFromFilter(filter) {
+  var value = filter.value,
+    domain = filter.domain,
+    speed = filter.speed,
+    isAnimating = filter.isAnimating,
+    step = filter.step,
+    timeSteps = filter.timeSteps,
+    defaultTimeFormat = filter.defaultTimeFormat,
+    timeFormat = filter.timeFormat,
+    timezone = filter.timezone,
+    timeBins = filter.timeBins,
+    animationWindow = filter.animationWindow,
+    plotType = filter.plotType;
+  return {
+    value: value,
+    enableInteraction: true,
+    domain: domain,
+    speed: speed,
+    isAnimating: isAnimating,
+    step: step,
+    timeSteps: timeSteps,
+    defaultTimeFormat: defaultTimeFormat,
+    timeFormat: timeFormat,
+    timezone: timezone,
+    timeBins: timeBins,
+    animationWindow: animationWindow,
+    marks: (0, _plot.getBinThresholds)(plotType === null || plotType === void 0 ? void 0 : plotType.interval, domain)
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_d3Array","require","_moment","_interopRequireDefault","_constants","_commonUtils","_aggregation","_plot","TIMELINE_MODES","exports","inner","outer","TileTimeInterval","YEAR","MONTH","DAY","HOUR","MINUTE","TIME_INTERVALS_ORDERED","LayerToFilterTimeInterval","_defineProperty2","INTERVAL","SAMPLE_TIMELINE","value","domain","speed","enableInteraction","isAnimating","step","mode","getTimelineFromAnimationConfig","animationConfig","currentTime","timeSteps","defaultTimeFormat","timeFormat","timezone","toArray","timeBins","marks","getIntervalByTicks","ticks","start","stop","tickIntervals","Object","values","TICK_INTERVALS","interval","target","Math","abs","i","bisector","d","duration","right","length","tickStep","durationYear","tickInterval","max","concat","getUniqueSamples","count","samples","sampleMap","v","undefined","push","detectInterval","arguments","maxSteps","threshold","sorted","sort","ascending","intervals","reduce","accu","moment","utc","diff","_getDurationUnit","getDurationUnit","_getDurationUnit2","_slicedToArray2","dur","c","occur","getFrequency","maxOccr","keys","prev","key","mostOccur","_maxOccr$split","split","_maxOccr$split2","durationSecond","DURATIONS","parseInt","totalSteps","substring","getFilterMappedValue","dataset","filter","dataId","id","fieldName","name","indexOf","field","getColumnField","console","warn","mappedValue","filterProps","durFuncs","intervalToFunction","_id$split","_id$split2","stepStr","TIME_INTERVALS","every","getInitialInterval","datasets","mergeMappedValue","_domain","t0","t1","BINS_LARGE","filterIntervalOptions","options","maxBins","minBins","timeSpan","op","getTimelineFromFilter","animationWindow","plotType","getBinThresholds"],"sources":["../src/time.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {ascending, bisector, tickStep} from 'd3-array';\nimport moment from 'moment';\n\nimport {\n  TICK_INTERVALS,\n  BINS_LARGE,\n  DURATIONS,\n  TIME_INTERVALS,\n  durationYear,\n  INTERVAL,\n  TickInterval\n} from '@kepler.gl/constants';\nimport {toArray} from '@kepler.gl/common-utils';\nimport {AnimationConfig, Timeline, TimeRangeFilter, Filter} from '@kepler.gl/types';\n\nimport {getFrequency} from './aggregation';\nimport {getBinThresholds} from './plot';\nimport {KeplerTableModel} from './types';\n\nexport const TIMELINE_MODES = {\n  inner: 'inner',\n  outer: 'outer'\n};\n\nexport const TileTimeInterval = {\n  YEAR: 'Y',\n  MONTH: 'M',\n  DAY: 'D',\n  HOUR: 'H',\n  MINUTE: 'T'\n};\n\nexport const TIME_INTERVALS_ORDERED = [\n  TileTimeInterval.MINUTE,\n  TileTimeInterval.HOUR,\n  TileTimeInterval.DAY,\n  TileTimeInterval.MONTH,\n  TileTimeInterval.YEAR\n];\n\nexport const LayerToFilterTimeInterval = {\n  [TileTimeInterval.MINUTE]: INTERVAL['1-minute'],\n  [TileTimeInterval.HOUR]: INTERVAL['1-hour'],\n  [TileTimeInterval.DAY]: INTERVAL['1-day'],\n  [TileTimeInterval.MONTH]: INTERVAL['1-month'],\n  [TileTimeInterval.YEAR]: INTERVAL['1-year']\n};\n\nexport const SAMPLE_TIMELINE = {\n  // value: [15], // represent 15% of the all width\n  value: [5, 15], // represent start at 5% and ends at 15%\n  domain: [1, 100], // represent the total domain\n  speed: 1,\n  enableInteraction: false, // can use interact with this timeline\n  isAnimating: false,\n  step: null,\n  // @todo: giuseppe coverType: 'inner' | 'outer'\n  mode: TIMELINE_MODES.inner\n  //  ....\n};\n\nexport const getTimelineFromAnimationConfig = (animationConfig: AnimationConfig): Timeline => {\n  const {\n    currentTime,\n    domain,\n    speed,\n    isAnimating,\n    timeSteps,\n    defaultTimeFormat,\n    timeFormat,\n    timezone\n  } = animationConfig;\n\n  return {\n    // @ts-expect-error\n    value: toArray(currentTime),\n    enableInteraction: true,\n    domain,\n    speed,\n    isAnimating: isAnimating || false,\n    timeSteps,\n    defaultTimeFormat,\n    timeFormat,\n    timezone,\n    timeBins: null,\n    marks: null\n  };\n};\n\n// check if the data inherent default time interval\n\n// https://github.com/d3/d3-scale/blob/732ed4b1cd5c643700571d1089c7deb8472242a6/src/time.js#L69\n// given number of ticks, calculate a reasonable interval\nexport function getIntervalByTicks(ticks, start, stop) {\n  if (ticks === null) ticks = 10;\n  const tickIntervals = Object.values(TICK_INTERVALS);\n  let interval;\n  let step;\n  // If a desired tick count is specified, pick a reasonable tick interval\n  // based on the extent of the domain and a rough estimate of tick size.\n  // Otherwise, assume interval is already a time interval and use it.\n  if (typeof ticks === 'number') {\n    const target = Math.abs(stop - start) / ticks;\n    const i = bisector((d: TickInterval) => d.duration).right(tickIntervals, target);\n    if (i === tickIntervals.length) {\n      step = tickStep(start / durationYear, stop / durationYear, ticks);\n      interval = 'year';\n    } else if (i) {\n      const tickInterval =\n        tickIntervals[\n          target / tickIntervals[i - 1].duration < tickIntervals[i].duration / target ? i - 1 : i\n        ];\n      // @ts-ignore TODO/ib\n      step = tickInterval.step;\n      // @ts-ignore TODO/ib\n      interval = tickInterval.interval;\n    } else {\n      step = Math.max(tickStep(start, stop, ticks), 1);\n      interval = 'millisecond';\n    }\n  }\n\n  return `${step}-${interval}`;\n}\n\n// get a  number of unique samples\nfunction getUniqueSamples(values, count) {\n  let i = -1;\n  const samples: any[] = [];\n  const sampleMap = {};\n  while (i++ < values.length && samples.length < count) {\n    const v = values[i];\n    if (v !== undefined && v !== null && !sampleMap[v]) {\n      sampleMap[v] = true;\n      samples.push(v);\n    }\n  }\n\n  return Object.values(samples);\n}\n\n/**\n * Given an array of epoch timestamp. sort it, if number of element\n * share the same time interval exceed thresholf, and total steps smaller than 100, return it, else return null\n * @param values\n */\nfunction detectInterval(values: number[] = [], domain, maxSteps = 10) {\n  const threshold = 0.7;\n\n  const sorted = values.sort(ascending);\n\n  // get first 100 unique sorted ts\n  const samples = getUniqueSamples(sorted, 100);\n  if (samples.length < 2) {\n    return null;\n  }\n\n  // get all intervals\n  const intervals = samples.reduce((accu, d, i) => {\n    if (i > 0) {\n      const duration = moment.duration(moment.utc(samples[i]).diff(moment.utc(samples[i - 1])));\n      const [dur, c] = getDurationUnit(duration);\n      accu.push(`${c}-${dur}`);\n    }\n    return accu;\n  }, []);\n\n  // find the most occured interval\n  const occur = getFrequency(intervals);\n  const maxOccr = Object.keys(occur).reduce(\n    (prev, key) => (occur[prev] >= occur[key] ? prev : key),\n    Object.keys(occur)[0]\n  );\n\n  // if occurance passed threshold\n  const mostOccur = occur[maxOccr] / intervals.length;\n  if (mostOccur >= threshold) {\n    const [step, dur] = maxOccr.split('-');\n    const durationSecond = DURATIONS[dur] * parseInt(step); // eslint-disable-line radix\n    const totalSteps = (domain[1] - domain[0]) / durationSecond;\n\n    if (totalSteps < maxSteps) {\n      // duration function is .days interval is day\n      return maxOccr.substring(0, maxOccr.length - 1);\n    }\n  }\n\n  return null;\n}\n\n/**\n * mappedValue is saved to dataset.fields.filterProps\n * @param dataset {KeplerTable}\n * @param filter\n */\nexport function getFilterMappedValue(\n  dataset: KeplerTableModel<any, any>,\n  filter: Filter\n): Filter['mappedValue'] | null {\n  const dataId = dataset.id;\n  const fieldName = filter.name[filter.dataId.indexOf(dataId)];\n  const field = dataset.getColumnField(fieldName);\n\n  if (!field) {\n    // eslint-disable-next-line no-console, no-undef\n    console.warn(`field ${fieldName} does not exist on dataset`);\n    return null;\n  }\n  const mappedValue = (field.filterProps || {}).mappedValue;\n  if (!mappedValue) {\n    // eslint-disable-next-line no-console, no-undef\n    console.warn(`mappedValue doesnt exist on filter field ${filter.name}`);\n    return null;\n  }\n  return mappedValue;\n}\n/**\n * Find the round unit of given durmostOccurtion: x years | months | days\n * @param duration\n */\nfunction getDurationUnit(duration) {\n  const durFuncs = Object.keys(DURATIONS);\n  for (let i = 0; i < durFuncs.length; i++) {\n    const c = duration[durFuncs[i]]();\n    if (c > 0) {\n      return [durFuncs[i], c];\n    }\n  }\n  return ['milliseconds', 1];\n}\n\nexport function intervalToFunction(id: string) {\n  const [stepStr, interval] = id.split('-');\n  const step = parseInt(stepStr); // eslint-disable-line radix\n  if (!step) {\n    // eslint-disable-next-line no-console, no-undef\n    console.warn('Step is not an integer');\n    return null;\n  }\n\n  if (!TIME_INTERVALS[interval]) {\n    // eslint-disable-next-line no-console, no-undef\n    console.warn(`Undefined time interval ${interval}`);\n    return null;\n  }\n\n  return TIME_INTERVALS[interval].every(step);\n}\n\n/**\n * Get initial interval from filter and datasets\n * @param filter\n * @param datasets\n * @returns\n */\nexport function getInitialInterval(\n  filter: Filter,\n  datasets: Record<string, KeplerTableModel<any, any>>\n): string {\n  const {domain} = filter;\n  const mergeMappedValue = filter.dataId.reduce((accu, dataId) => {\n    const mappedValue = getFilterMappedValue(datasets[dataId], filter);\n    if (!mappedValue) {\n      return accu;\n    }\n\n    for (let i = 0; i < mappedValue.length; i++) {\n      accu.push(mappedValue[i]);\n    }\n    return accu;\n  }, [] as any[]);\n\n  // check if data has predefined interval\n  let interval = detectInterval(mergeMappedValue, domain);\n\n  if (!interval) {\n    // @ts-expect-error need better types for domain\n    const [t0, t1] = domain;\n    interval = getIntervalByTicks(BINS_LARGE, t0, t1);\n  }\n\n  return interval;\n}\n\n// Filter interval options by time filter domain\n// max number of interval is 1000\n/**\n *\n * @param options\n * @param domain\n */\nexport function filterIntervalOptions(options, domain) {\n  const maxBins = 1000;\n  const minBins = 2;\n  const timeSpan = domain[1] - domain[0];\n\n  return options.filter(op => {\n    const {id} = op;\n    if (!TICK_INTERVALS[id]) {\n      return false;\n    }\n\n    const interval = TICK_INTERVALS[id];\n\n    // rough count on bins\n    const count = timeSpan / (interval.step * interval.duration);\n\n    return count >= minBins && count <= maxBins;\n  });\n}\n\n/**\n * Get timeline from filter\n * @param filter TimeRangeFilter filter\n * @returns Timeline\n */\nexport const getTimelineFromFilter = (filter: TimeRangeFilter): Timeline => {\n  const {\n    value,\n    domain,\n    speed,\n    isAnimating,\n    step,\n    // @ts-expect-error\n    timeSteps,\n    defaultTimeFormat,\n    timeFormat,\n    timezone,\n    timeBins,\n    animationWindow,\n    plotType\n  } = filter;\n\n  return {\n    value,\n    enableInteraction: true,\n    domain,\n    speed,\n    isAnimating,\n    step,\n    timeSteps,\n    defaultTimeFormat,\n    timeFormat,\n    timezone,\n    timeBins,\n    animationWindow,\n    marks: getBinThresholds(plotType?.interval, domain)\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;AAGA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,UAAA,GAAAH,OAAA;AASA,IAAAI,YAAA,GAAAJ,OAAA;AAGA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,KAAA,GAAAN,OAAA;AAnBA;AACA;;AAqBO,IAAMO,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG;EAC5BE,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE;AACT,CAAC;AAEM,IAAMC,gBAAgB,GAAAH,OAAA,CAAAG,gBAAA,GAAG;EAC9BC,IAAI,EAAE,GAAG;EACTC,KAAK,EAAE,GAAG;EACVC,GAAG,EAAE,GAAG;EACRC,IAAI,EAAE,GAAG;EACTC,MAAM,EAAE;AACV,CAAC;AAEM,IAAMC,sBAAsB,GAAAT,OAAA,CAAAS,sBAAA,GAAG,CACpCN,gBAAgB,CAACK,MAAM,EACvBL,gBAAgB,CAACI,IAAI,EACrBJ,gBAAgB,CAACG,GAAG,EACpBH,gBAAgB,CAACE,KAAK,EACtBF,gBAAgB,CAACC,IAAI,CACtB;AAEM,IAAMM,yBAAyB,GAAAV,OAAA,CAAAU,yBAAA,OAAAC,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBACnCR,gBAAgB,CAACK,MAAM,EAAGI,mBAAQ,CAAC,UAAU,CAAC,GAC9CT,gBAAgB,CAACI,IAAI,EAAGK,mBAAQ,CAAC,QAAQ,CAAC,GAC1CT,gBAAgB,CAACG,GAAG,EAAGM,mBAAQ,CAAC,OAAO,CAAC,GACxCT,gBAAgB,CAACE,KAAK,EAAGO,mBAAQ,CAAC,SAAS,CAAC,GAC5CT,gBAAgB,CAACC,IAAI,EAAGQ,mBAAQ,CAAC,QAAQ,CAAC,CAC5C;AAEM,IAAMC,eAAe,GAAAb,OAAA,CAAAa,eAAA,GAAG;EAC7B;EACAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;EAAE;EAChBC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC;EAAE;EAClBC,KAAK,EAAE,CAAC;EACRC,iBAAiB,EAAE,KAAK;EAAE;EAC1BC,WAAW,EAAE,KAAK;EAClBC,IAAI,EAAE,IAAI;EACV;EACAC,IAAI,EAAErB,cAAc,CAACE;EACrB;AACF,CAAC;AAEM,IAAMoB,8BAA8B,GAAArB,OAAA,CAAAqB,8BAAA,GAAG,SAAjCA,8BAA8BA,CAAIC,eAAgC,EAAe;EAC5F,IACEC,WAAW,GAQTD,eAAe,CARjBC,WAAW;IACXR,MAAM,GAOJO,eAAe,CAPjBP,MAAM;IACNC,KAAK,GAMHM,eAAe,CANjBN,KAAK;IACLE,WAAW,GAKTI,eAAe,CALjBJ,WAAW;IACXM,SAAS,GAIPF,eAAe,CAJjBE,SAAS;IACTC,iBAAiB,GAGfH,eAAe,CAHjBG,iBAAiB;IACjBC,UAAU,GAERJ,eAAe,CAFjBI,UAAU;IACVC,QAAQ,GACNL,eAAe,CADjBK,QAAQ;EAGV,OAAO;IACL;IACAb,KAAK,EAAE,IAAAc,oBAAO,EAACL,WAAW,CAAC;IAC3BN,iBAAiB,EAAE,IAAI;IACvBF,MAAM,EAANA,MAAM;IACNC,KAAK,EAALA,KAAK;IACLE,WAAW,EAAEA,WAAW,IAAI,KAAK;IACjCM,SAAS,EAATA,SAAS;IACTC,iBAAiB,EAAjBA,iBAAiB;IACjBC,UAAU,EAAVA,UAAU;IACVC,QAAQ,EAARA,QAAQ;IACRE,QAAQ,EAAE,IAAI;IACdC,KAAK,EAAE;EACT,CAAC;AACH,CAAC;;AAED;;AAEA;AACA;AACO,SAASC,kBAAkBA,CAACC,KAAK,EAAEC,KAAK,EAAEC,IAAI,EAAE;EACrD,IAAIF,KAAK,KAAK,IAAI,EAAEA,KAAK,GAAG,EAAE;EAC9B,IAAMG,aAAa,GAAGC,MAAM,CAACC,MAAM,CAACC,yBAAc,CAAC;EACnD,IAAIC,QAAQ;EACZ,IAAIpB,IAAI;EACR;EACA;EACA;EACA,IAAI,OAAOa,KAAK,KAAK,QAAQ,EAAE;IAC7B,IAAMQ,MAAM,GAAGC,IAAI,CAACC,GAAG,CAACR,IAAI,GAAGD,KAAK,CAAC,GAAGD,KAAK;IAC7C,IAAMW,CAAC,GAAG,IAAAC,iBAAQ,EAAC,UAACC,CAAe;MAAA,OAAKA,CAAC,CAACC,QAAQ;IAAA,EAAC,CAACC,KAAK,CAACZ,aAAa,EAAEK,MAAM,CAAC;IAChF,IAAIG,CAAC,KAAKR,aAAa,CAACa,MAAM,EAAE;MAC9B7B,IAAI,GAAG,IAAA8B,iBAAQ,EAAChB,KAAK,GAAGiB,uBAAY,EAAEhB,IAAI,GAAGgB,uBAAY,EAAElB,KAAK,CAAC;MACjEO,QAAQ,GAAG,MAAM;IACnB,CAAC,MAAM,IAAII,CAAC,EAAE;MACZ,IAAMQ,YAAY,GAChBhB,aAAa,CACXK,MAAM,GAAGL,aAAa,CAACQ,CAAC,GAAG,CAAC,CAAC,CAACG,QAAQ,GAAGX,aAAa,CAACQ,CAAC,CAAC,CAACG,QAAQ,GAAGN,MAAM,GAAGG,CAAC,GAAG,CAAC,GAAGA,CAAC,CACxF;MACH;MACAxB,IAAI,GAAGgC,YAAY,CAAChC,IAAI;MACxB;MACAoB,QAAQ,GAAGY,YAAY,CAACZ,QAAQ;IAClC,CAAC,MAAM;MACLpB,IAAI,GAAGsB,IAAI,CAACW,GAAG,CAAC,IAAAH,iBAAQ,EAAChB,KAAK,EAAEC,IAAI,EAAEF,KAAK,CAAC,EAAE,CAAC,CAAC;MAChDO,QAAQ,GAAG,aAAa;IAC1B;EACF;EAEA,UAAAc,MAAA,CAAUlC,IAAI,OAAAkC,MAAA,CAAId,QAAQ;AAC5B;;AAEA;AACA,SAASe,gBAAgBA,CAACjB,MAAM,EAAEkB,KAAK,EAAE;EACvC,IAAIZ,CAAC,GAAG,CAAC,CAAC;EACV,IAAMa,OAAc,GAAG,EAAE;EACzB,IAAMC,SAAS,GAAG,CAAC,CAAC;EACpB,OAAOd,CAAC,EAAE,GAAGN,MAAM,CAACW,MAAM,IAAIQ,OAAO,CAACR,MAAM,GAAGO,KAAK,EAAE;IACpD,IAAMG,CAAC,GAAGrB,MAAM,CAACM,CAAC,CAAC;IACnB,IAAIe,CAAC,KAAKC,SAAS,IAAID,CAAC,KAAK,IAAI,IAAI,CAACD,SAAS,CAACC,CAAC,CAAC,EAAE;MAClDD,SAAS,CAACC,CAAC,CAAC,GAAG,IAAI;MACnBF,OAAO,CAACI,IAAI,CAACF,CAAC,CAAC;IACjB;EACF;EAEA,OAAOtB,MAAM,CAACC,MAAM,CAACmB,OAAO,CAAC;AAC/B;;AAEA;AACA;AACA;AACA;AACA;AACA,SAASK,cAAcA,CAAA,EAA+C;EAAA,IAA9CxB,MAAgB,GAAAyB,SAAA,CAAAd,MAAA,QAAAc,SAAA,QAAAH,SAAA,GAAAG,SAAA,MAAG,EAAE;EAAA,IAAE/C,MAAM,GAAA+C,SAAA,CAAAd,MAAA,OAAAc,SAAA,MAAAH,SAAA;EAAA,IAAEI,QAAQ,GAAAD,SAAA,CAAAd,MAAA,QAAAc,SAAA,QAAAH,SAAA,GAAAG,SAAA,MAAG,EAAE;EAClE,IAAME,SAAS,GAAG,GAAG;EAErB,IAAMC,MAAM,GAAG5B,MAAM,CAAC6B,IAAI,CAACC,kBAAS,CAAC;;EAErC;EACA,IAAMX,OAAO,GAAGF,gBAAgB,CAACW,MAAM,EAAE,GAAG,CAAC;EAC7C,IAAIT,OAAO,CAACR,MAAM,GAAG,CAAC,EAAE;IACtB,OAAO,IAAI;EACb;;EAEA;EACA,IAAMoB,SAAS,GAAGZ,OAAO,CAACa,MAAM,CAAC,UAACC,IAAI,EAAEzB,CAAC,EAAEF,CAAC,EAAK;IAC/C,IAAIA,CAAC,GAAG,CAAC,EAAE;MACT,IAAMG,QAAQ,GAAGyB,kBAAM,CAACzB,QAAQ,CAACyB,kBAAM,CAACC,GAAG,CAAChB,OAAO,CAACb,CAAC,CAAC,CAAC,CAAC8B,IAAI,CAACF,kBAAM,CAACC,GAAG,CAAChB,OAAO,CAACb,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;MACzF,IAAA+B,gBAAA,GAAiBC,eAAe,CAAC7B,QAAQ,CAAC;QAAA8B,iBAAA,OAAAC,eAAA,aAAAH,gBAAA;QAAnCI,GAAG,GAAAF,iBAAA;QAAEG,CAAC,GAAAH,iBAAA;MACbN,IAAI,CAACV,IAAI,IAAAP,MAAA,CAAI0B,CAAC,OAAA1B,MAAA,CAAIyB,GAAG,CAAE,CAAC;IAC1B;IACA,OAAOR,IAAI;EACb,CAAC,EAAE,EAAE,CAAC;;EAEN;EACA,IAAMU,KAAK,GAAG,IAAAC,yBAAY,EAACb,SAAS,CAAC;EACrC,IAAMc,OAAO,GAAG9C,MAAM,CAAC+C,IAAI,CAACH,KAAK,CAAC,CAACX,MAAM,CACvC,UAACe,IAAI,EAAEC,GAAG;IAAA,OAAML,KAAK,CAACI,IAAI,CAAC,IAAIJ,KAAK,CAACK,GAAG,CAAC,GAAGD,IAAI,GAAGC,GAAG;EAAA,CAAC,EACvDjD,MAAM,CAAC+C,IAAI,CAACH,KAAK,CAAC,CAAC,CAAC,CACtB,CAAC;;EAED;EACA,IAAMM,SAAS,GAAGN,KAAK,CAACE,OAAO,CAAC,GAAGd,SAAS,CAACpB,MAAM;EACnD,IAAIsC,SAAS,IAAItB,SAAS,EAAE;IAC1B,IAAAuB,cAAA,GAAoBL,OAAO,CAACM,KAAK,CAAC,GAAG,CAAC;MAAAC,eAAA,OAAAZ,eAAA,aAAAU,cAAA;MAA/BpE,IAAI,GAAAsE,eAAA;MAAEX,GAAG,GAAAW,eAAA;IAChB,IAAMC,cAAc,GAAGC,oBAAS,CAACb,GAAG,CAAC,GAAGc,QAAQ,CAACzE,IAAI,CAAC,CAAC,CAAC;IACxD,IAAM0E,UAAU,GAAG,CAAC9E,MAAM,CAAC,CAAC,CAAC,GAAGA,MAAM,CAAC,CAAC,CAAC,IAAI2E,cAAc;IAE3D,IAAIG,UAAU,GAAG9B,QAAQ,EAAE;MACzB;MACA,OAAOmB,OAAO,CAACY,SAAS,CAAC,CAAC,EAAEZ,OAAO,CAAClC,MAAM,GAAG,CAAC,CAAC;IACjD;EACF;EAEA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACO,SAAS+C,oBAAoBA,CAClCC,OAAmC,EACnCC,MAAc,EACgB;EAC9B,IAAMC,MAAM,GAAGF,OAAO,CAACG,EAAE;EACzB,IAAMC,SAAS,GAAGH,MAAM,CAACI,IAAI,CAACJ,MAAM,CAACC,MAAM,CAACI,OAAO,CAACJ,MAAM,CAAC,CAAC;EAC5D,IAAMK,KAAK,GAAGP,OAAO,CAACQ,cAAc,CAACJ,SAAS,CAAC;EAE/C,IAAI,CAACG,KAAK,EAAE;IACV;IACAE,OAAO,CAACC,IAAI,UAAArD,MAAA,CAAU+C,SAAS,+BAA4B,CAAC;IAC5D,OAAO,IAAI;EACb;EACA,IAAMO,WAAW,GAAG,CAACJ,KAAK,CAACK,WAAW,IAAI,CAAC,CAAC,EAAED,WAAW;EACzD,IAAI,CAACA,WAAW,EAAE;IAChB;IACAF,OAAO,CAACC,IAAI,6CAAArD,MAAA,CAA6C4C,MAAM,CAACI,IAAI,CAAE,CAAC;IACvE,OAAO,IAAI;EACb;EACA,OAAOM,WAAW;AACpB;AACA;AACA;AACA;AACA;AACA,SAAShC,eAAeA,CAAC7B,QAAQ,EAAE;EACjC,IAAM+D,QAAQ,GAAGzE,MAAM,CAAC+C,IAAI,CAACQ,oBAAS,CAAC;EACvC,KAAK,IAAIhD,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGkE,QAAQ,CAAC7D,MAAM,EAAEL,CAAC,EAAE,EAAE;IACxC,IAAMoC,CAAC,GAAGjC,QAAQ,CAAC+D,QAAQ,CAAClE,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,IAAIoC,CAAC,GAAG,CAAC,EAAE;MACT,OAAO,CAAC8B,QAAQ,CAAClE,CAAC,CAAC,EAAEoC,CAAC,CAAC;IACzB;EACF;EACA,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;AAC5B;AAEO,SAAS+B,kBAAkBA,CAACX,EAAU,EAAE;EAC7C,IAAAY,SAAA,GAA4BZ,EAAE,CAACX,KAAK,CAAC,GAAG,CAAC;IAAAwB,UAAA,OAAAnC,eAAA,aAAAkC,SAAA;IAAlCE,OAAO,GAAAD,UAAA;IAAEzE,QAAQ,GAAAyE,UAAA;EACxB,IAAM7F,IAAI,GAAGyE,QAAQ,CAACqB,OAAO,CAAC,CAAC,CAAC;EAChC,IAAI,CAAC9F,IAAI,EAAE;IACT;IACAsF,OAAO,CAACC,IAAI,CAAC,wBAAwB,CAAC;IACtC,OAAO,IAAI;EACb;EAEA,IAAI,CAACQ,yBAAc,CAAC3E,QAAQ,CAAC,EAAE;IAC7B;IACAkE,OAAO,CAACC,IAAI,4BAAArD,MAAA,CAA4Bd,QAAQ,CAAE,CAAC;IACnD,OAAO,IAAI;EACb;EAEA,OAAO2E,yBAAc,CAAC3E,QAAQ,CAAC,CAAC4E,KAAK,CAAChG,IAAI,CAAC;AAC7C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASiG,kBAAkBA,CAChCnB,MAAc,EACdoB,QAAoD,EAC5C;EACR,IAAOtG,MAAM,GAAIkF,MAAM,CAAhBlF,MAAM;EACb,IAAMuG,gBAAgB,GAAGrB,MAAM,CAACC,MAAM,CAAC7B,MAAM,CAAC,UAACC,IAAI,EAAE4B,MAAM,EAAK;IAC9D,IAAMS,WAAW,GAAGZ,oBAAoB,CAACsB,QAAQ,CAACnB,MAAM,CAAC,EAAED,MAAM,CAAC;IAClE,IAAI,CAACU,WAAW,EAAE;MAChB,OAAOrC,IAAI;IACb;IAEA,KAAK,IAAI3B,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGgE,WAAW,CAAC3D,MAAM,EAAEL,CAAC,EAAE,EAAE;MAC3C2B,IAAI,CAACV,IAAI,CAAC+C,WAAW,CAAChE,CAAC,CAAC,CAAC;IAC3B;IACA,OAAO2B,IAAI;EACb,CAAC,EAAE,EAAW,CAAC;;EAEf;EACA,IAAI/B,QAAQ,GAAGsB,cAAc,CAACyD,gBAAgB,EAAEvG,MAAM,CAAC;EAEvD,IAAI,CAACwB,QAAQ,EAAE;IACb;IACA,IAAAgF,OAAA,OAAA1C,eAAA,aAAiB9D,MAAM;MAAhByG,EAAE,GAAAD,OAAA;MAAEE,EAAE,GAAAF,OAAA;IACbhF,QAAQ,GAAGR,kBAAkB,CAAC2F,qBAAU,EAAEF,EAAE,EAAEC,EAAE,CAAC;EACnD;EAEA,OAAOlF,QAAQ;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASoF,qBAAqBA,CAACC,OAAO,EAAE7G,MAAM,EAAE;EACrD,IAAM8G,OAAO,GAAG,IAAI;EACpB,IAAMC,OAAO,GAAG,CAAC;EACjB,IAAMC,QAAQ,GAAGhH,MAAM,CAAC,CAAC,CAAC,GAAGA,MAAM,CAAC,CAAC,CAAC;EAEtC,OAAO6G,OAAO,CAAC3B,MAAM,CAAC,UAAA+B,EAAE,EAAI;IAC1B,IAAO7B,EAAE,GAAI6B,EAAE,CAAR7B,EAAE;IACT,IAAI,CAAC7D,yBAAc,CAAC6D,EAAE,CAAC,EAAE;MACvB,OAAO,KAAK;IACd;IAEA,IAAM5D,QAAQ,GAAGD,yBAAc,CAAC6D,EAAE,CAAC;;IAEnC;IACA,IAAM5C,KAAK,GAAGwE,QAAQ,IAAIxF,QAAQ,CAACpB,IAAI,GAAGoB,QAAQ,CAACO,QAAQ,CAAC;IAE5D,OAAOS,KAAK,IAAIuE,OAAO,IAAIvE,KAAK,IAAIsE,OAAO;EAC7C,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACO,IAAMI,qBAAqB,GAAAjI,OAAA,CAAAiI,qBAAA,GAAG,SAAxBA,qBAAqBA,CAAIhC,MAAuB,EAAe;EAC1E,IACEnF,KAAK,GAaHmF,MAAM,CAbRnF,KAAK;IACLC,MAAM,GAYJkF,MAAM,CAZRlF,MAAM;IACNC,KAAK,GAWHiF,MAAM,CAXRjF,KAAK;IACLE,WAAW,GAUT+E,MAAM,CAVR/E,WAAW;IACXC,IAAI,GASF8E,MAAM,CATR9E,IAAI;IAEJK,SAAS,GAOPyE,MAAM,CAPRzE,SAAS;IACTC,iBAAiB,GAMfwE,MAAM,CANRxE,iBAAiB;IACjBC,UAAU,GAKRuE,MAAM,CALRvE,UAAU;IACVC,QAAQ,GAINsE,MAAM,CAJRtE,QAAQ;IACRE,QAAQ,GAGNoE,MAAM,CAHRpE,QAAQ;IACRqG,eAAe,GAEbjC,MAAM,CAFRiC,eAAe;IACfC,QAAQ,GACNlC,MAAM,CADRkC,QAAQ;EAGV,OAAO;IACLrH,KAAK,EAALA,KAAK;IACLG,iBAAiB,EAAE,IAAI;IACvBF,MAAM,EAANA,MAAM;IACNC,KAAK,EAALA,KAAK;IACLE,WAAW,EAAXA,WAAW;IACXC,IAAI,EAAJA,IAAI;IACJK,SAAS,EAATA,SAAS;IACTC,iBAAiB,EAAjBA,iBAAiB;IACjBC,UAAU,EAAVA,UAAU;IACVC,QAAQ,EAARA,QAAQ;IACRE,QAAQ,EAARA,QAAQ;IACRqG,eAAe,EAAfA,eAAe;IACfpG,KAAK,EAAE,IAAAsG,sBAAgB,EAACD,QAAQ,aAARA,QAAQ,uBAARA,QAAQ,CAAE5F,QAAQ,EAAExB,MAAM;EACpD,CAAC;AACH,CAAC","ignoreList":[]}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+import { Filter, Field, FilterDatasetOpt } from '@kepler.gl/types';
+import { DataContainerInterface } from './data-container-interface';
+export interface KeplerTableModel<K, L, F extends Field = any> {
+    id: string;
+    fields: F[];
+    getColumnFieldIdx(columnName: string): number;
+    filterTable(filters: Filter[], layers: L[], opt?: FilterDatasetOpt): K;
+    getColumnFilterProps(columnName: string): Field['filterProps'] | null | undefined;
+    dataContainer: DataContainerInterface;
+    filterTableCPU(filters: Filter[], layers: L[]): K;
+    getColumnField(fieldName: string): Field | undefined;
+    gpuFilter: {
+        filterRange: number[][];
+        filterValueUpdateTriggers: any;
+        filterValueAccessor: (dc: DataContainerInterface) => (getIndex?: (any: any) => number, getData?: (dc_: DataContainerInterface, d: any, fieldIndex: number) => any) => (d: any) => (number | number[])[];
+    };
+    filteredIndex: number[];
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL3R5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmltcG9ydCB7RmlsdGVyLCBGaWVsZCwgRmlsdGVyRGF0YXNldE9wdH0gZnJvbSAnQGtlcGxlci5nbC90eXBlcyc7XG5cbmltcG9ydCB7RGF0YUNvbnRhaW5lckludGVyZmFjZX0gZnJvbSAnLi9kYXRhLWNvbnRhaW5lci1pbnRlcmZhY2UnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEtlcGxlclRhYmxlTW9kZWw8SywgTCwgRiBleHRlbmRzIEZpZWxkID0gYW55PiB7XG4gIGlkOiBzdHJpbmc7XG4gIGZpZWxkczogRltdO1xuICBnZXRDb2x1bW5GaWVsZElkeChjb2x1bW5OYW1lOiBzdHJpbmcpOiBudW1iZXI7XG4gIGZpbHRlclRhYmxlKGZpbHRlcnM6IEZpbHRlcltdLCBsYXllcnM6IExbXSwgb3B0PzogRmlsdGVyRGF0YXNldE9wdCk6IEs7XG4gIGdldENvbHVtbkZpbHRlclByb3BzKGNvbHVtbk5hbWU6IHN0cmluZyk6IEZpZWxkWydmaWx0ZXJQcm9wcyddIHwgbnVsbCB8IHVuZGVmaW5lZDtcbiAgZGF0YUNvbnRhaW5lcjogRGF0YUNvbnRhaW5lckludGVyZmFjZTtcbiAgZmlsdGVyVGFibGVDUFUoZmlsdGVyczogRmlsdGVyW10sIGxheWVyczogTFtdKTogSztcbiAgZ2V0Q29sdW1uRmllbGQoZmllbGROYW1lOiBzdHJpbmcpOiBGaWVsZCB8IHVuZGVmaW5lZDtcbiAgZ3B1RmlsdGVyOiB7XG4gICAgZmlsdGVyUmFuZ2U6IG51bWJlcltdW107XG4gICAgZmlsdGVyVmFsdWVVcGRhdGVUcmlnZ2VyczogYW55O1xuICAgIGZpbHRlclZhbHVlQWNjZXNzb3I6IChcbiAgICAgIGRjOiBEYXRhQ29udGFpbmVySW50ZXJmYWNlXG4gICAgKSA9PiAoXG4gICAgICBnZXRJbmRleD86IChhbnkpID0+IG51bWJlcixcbiAgICAgIGdldERhdGE/OiAoZGNfOiBEYXRhQ29udGFpbmVySW50ZXJmYWNlLCBkOiBhbnksIGZpZWxkSW5kZXg6IG51bWJlcikgPT4gYW55XG4gICAgKSA9PiAoZDogYW55KSA9PiAobnVtYmVyIHwgbnVtYmVyW10pW107XG4gIH07XG4gIGZpbHRlcmVkSW5kZXg6IG51bWJlcltdO1xufVxuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119