@kepler.gl/deckgl-layers 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/cjs/index.js

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ThreeDBuildingLayer: true,
+  DeckGLClusterLayer: true,
+  EnhancedColumnLayer: true,
+  EnhancedGridLayer: true,
+  EnhancedHexagonLayer: true,
+  EnhancedLineLayer: true,
+  SvgIconLayer: true,
+  FilterArrowExtension: true,
+  RasterLayer: true,
+  RasterMeshLayer: true,
+  RasterWebGL: true,
+  WMSLayer: true
+};
+Object.defineProperty(exports, "DeckGLClusterLayer", {
+  enumerable: true,
+  get: function get() {
+    return _clusterLayer["default"];
+  }
+});
+Object.defineProperty(exports, "EnhancedColumnLayer", {
+  enumerable: true,
+  get: function get() {
+    return _enhancedColumnLayer["default"];
+  }
+});
+Object.defineProperty(exports, "EnhancedGridLayer", {
+  enumerable: true,
+  get: function get() {
+    return _enhancedCpuGridLayer["default"];
+  }
+});
+Object.defineProperty(exports, "EnhancedHexagonLayer", {
+  enumerable: true,
+  get: function get() {
+    return _enhancedHexagonLayer["default"];
+  }
+});
+Object.defineProperty(exports, "EnhancedLineLayer", {
+  enumerable: true,
+  get: function get() {
+    return _lineLayer["default"];
+  }
+});
+Object.defineProperty(exports, "FilterArrowExtension", {
+  enumerable: true,
+  get: function get() {
+    return _filterArrowLayer["default"];
+  }
+});
+Object.defineProperty(exports, "RasterLayer", {
+  enumerable: true,
+  get: function get() {
+    return _rasterLayer["default"];
+  }
+});
+Object.defineProperty(exports, "RasterMeshLayer", {
+  enumerable: true,
+  get: function get() {
+    return _rasterMeshLayer["default"];
+  }
+});
+exports.RasterWebGL = void 0;
+Object.defineProperty(exports, "SvgIconLayer", {
+  enumerable: true,
+  get: function get() {
+    return _svgIconLayer["default"];
+  }
+});
+Object.defineProperty(exports, "ThreeDBuildingLayer", {
+  enumerable: true,
+  get: function get() {
+    return _dBuildingLayer["default"];
+  }
+});
+Object.defineProperty(exports, "WMSLayer", {
+  enumerable: true,
+  get: function get() {
+    return _wmsLayer["default"];
+  }
+});
+var _dBuildingLayer = _interopRequireDefault(require("./3d-building-layer/3d-building-layer"));
+var _clusterLayer = _interopRequireDefault(require("./cluster-layer/cluster-layer"));
+var _enhancedColumnLayer = _interopRequireDefault(require("./column-layer/enhanced-column-layer"));
+var _enhancedCpuGridLayer = _interopRequireDefault(require("./grid-layer/enhanced-cpu-grid-layer"));
+var _enhancedHexagonLayer = _interopRequireDefault(require("./hexagon-layer/enhanced-hexagon-layer"));
+var _lineLayer = _interopRequireDefault(require("./line-layer/line-layer"));
+var _svgIconLayer = _interopRequireDefault(require("./svg-icon-layer/svg-icon-layer"));
+var _filterArrowLayer = _interopRequireDefault(require("./deckgl-extensions/filter-arrow-layer"));
+var _rasterLayer = _interopRequireDefault(require("./raster/raster-layer/raster-layer"));
+var _rasterMeshLayer = _interopRequireDefault(require("./raster/raster-mesh-layer/raster-mesh-layer"));
+var _RasterWebGL = _interopRequireWildcard(require("./raster/webgl"));
+exports.RasterWebGL = _RasterWebGL;
+var _wmsLayer = _interopRequireDefault(require("./wms/wms-layer"));
+var _shaderUtils = require("./layer-utils/shader-utils");
+Object.keys(_shaderUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _shaderUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _shaderUtils[key];
+    }
+  });
+});
+var _aggregationUtils = require("./layer-utils/aggregation-utils");
+Object.keys(_aggregationUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _aggregationUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _aggregationUtils[key];
+    }
+  });
+});
+var _types = require("./3d-building-layer/types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+var _dBuildingUtils = require("./3d-building-layer/3d-building-utils");
+Object.keys(_dBuildingUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _dBuildingUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dBuildingUtils[key];
+    }
+  });
+});
+var _globe = require("./globe");
+Object.keys(_globe).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _globe[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _globe[key];
+    }
+  });
+});
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cjs/layer-utils/aggregation-utils.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildAggregatedBinMap = buildAggregatedBinMap;
+exports.classifyBinsByCustomBreaks = classifyBinsByCustomBreaks;
+exports.enrichedAggregationUpdate = enrichedAggregationUpdate;
+exports.enrichedRenderLayers = enrichedRenderLayers;
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Build a Record<index, AggregatedBin> from the raw Float32Array of per-bin
+ * aggregated values returned by deck.gl 9's CPUAggregator/WebGLAggregator.
+ * The resulting map is compatible with the format kepler.gl expects for
+ * histogram rendering and color-scale selector.
+ */
+function buildAggregatedBinMap(binValues, binCount, aggregator) {
+  var bins = {};
+  for (var i = 0; i < binCount; i++) {
+    var _aggregator$getBin$co, _aggregator$getBin;
+    var val = binValues[i];
+    var count = (_aggregator$getBin$co = aggregator === null || aggregator === void 0 || (_aggregator$getBin = aggregator.getBin) === null || _aggregator$getBin === void 0 || (_aggregator$getBin = _aggregator$getBin.call(aggregator, i)) === null || _aggregator$getBin === void 0 ? void 0 : _aggregator$getBin.count) !== null && _aggregator$getBin$co !== void 0 ? _aggregator$getBin$co : 0;
+    bins[i] = {
+      i: i,
+      value: val,
+      counts: count
+    };
+  }
+  return bins;
+}
+
+/**
+ * Classify raw per-bin aggregated values into break indices according to
+ * a custom colorMap, and patch the deck.gl internal `state.colors` so the
+ * GPU shader renders the correct color for each bin.
+ *
+ * Custom breaks define thresholds [t0, t1, …, t_{N-2}] for N colors:
+ *   color 0: value < t0
+ *   color i: t_{i-1} <= value < t_i
+ *   color N-1: value >= t_{N-2}
+ *
+ * We replace the values in `state.colors.attribute` / `state.colors.input`
+ * with integer break indices [0 … N-1].  Combined with `colorScaleType: 'quantize'`
+ * and `colorDomain: [0, N-1]`, the shader's linear interpolation maps each index
+ * to the correct color texture pixel.
+ *
+ * `rawValues` must be the original aggregated values (not previously classified).
+ */
+function classifyBinsByCustomBreaks(stateColors, binCount, colorMap, rawValues) {
+  if (!rawValues || binCount === 0) return;
+  var thresholds = [];
+  var _iterator = _createForOfIteratorHelper(colorMap),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var entry = _step.value;
+      if (typeof entry[0] === 'number' && Number.isFinite(entry[0])) {
+        thresholds.push(entry[0]);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  thresholds.sort(function (a, b) {
+    return a - b;
+  });
+  var numColors = colorMap.length;
+  var classified = new Float32Array(rawValues.length);
+  for (var i = 0; i < binCount; i++) {
+    var v = rawValues[i];
+    if (!Number.isFinite(v)) {
+      classified[i] = NaN;
+      continue;
+    }
+    var idx = numColors - 1;
+    for (var t = 0; t < thresholds.length; t++) {
+      if (v < thresholds[t]) {
+        idx = t;
+        break;
+      }
+    }
+    classified[i] = idx;
+  }
+  for (var _i = binCount; _i < classified.length; _i++) {
+    classified[_i] = NaN;
+  }
+  var classifiedAttr = {
+    value: classified,
+    type: 'float32',
+    size: 1
+  };
+  stateColors.input = classifiedAttr;
+  stateColors.attribute = classifiedAttr;
+}
+
+// ---------------------------------------------------------------------------
+// Shared _onAggregationUpdate / renderLayers logic for ScaleEnhanced* layers
+// ---------------------------------------------------------------------------
+//
+// deck.gl 9's _onAggregationUpdate is private and its onSetColorDomain
+// callback only provides [min, max].  That is sufficient for quantize/linear
+// scales but d3.scaleQuantile needs the *full sorted array* of bin values to
+// compute correct break points — without it the legend labels are wrong
+// (see https://github.com/keplergl/kepler.gl/issues/3381).
+//
+// deck.gl does not expose a public hook for post-aggregation data, and props
+// are Object.freeze()'d so we cannot suppress the parent's callback.  Instead
+// we let the parent fire its [min, max] call, then immediately fire a second
+// enriched call with per-bin values (aggregatedBins) and, for quantile scale,
+// the full sorted domain.  The second call overwrites the first downstream in
+// _onLayerSetDomain.
+//
+// This can be removed once deck.gl exposes a richer post-aggregation callback
+// or makes _onAggregationUpdate / AttributeWithScale part of the public API.
+
+/**
+ * Enriched _onAggregationUpdate implementation shared by ScaleEnhancedHexagonLayer
+ * and ScaleEnhancedGridLayer.
+ *
+ * @param layer       The enhanced layer instance (`this`)
+ * @param ParentClass The deck.gl parent class (HexagonLayer or GridLayer)
+ * @param channel     The aggregation channel index passed by deck.gl
+ */
+function enrichedAggregationUpdate(layer, ParentClass, channel) {
+  var _props$onSetColorDoma;
+  ParentClass.prototype._onAggregationUpdate.call(layer, {
+    channel: channel
+  });
+  if (channel !== 0) return;
+  var props = layer.getCurrentLayer().props;
+  var aggregator = layer.state.aggregator;
+  var result = aggregator.getResult(0);
+  var binValues = result === null || result === void 0 ? void 0 : result.value;
+  if (!binValues || aggregator.binCount <= 0) return;
+  layer.setState({
+    rawColorBinValues: Float32Array.from(binValues.subarray(0, aggregator.binCount))
+  });
+  var domain = aggregator.getResultDomain(0);
+  var aggregatedBins = buildAggregatedBinMap(binValues, aggregator.binCount, aggregator);
+  if (props.colorMap) {
+    classifyBinsByCustomBreaks(layer.state.colors, aggregator.binCount, props.colorMap, binValues);
+  }
+  var enrichedDomain = domain;
+  if (props.colorScaleType === 'quantile') {
+    enrichedDomain = Array.from(binValues).slice(0, aggregator.binCount).filter(Number.isFinite).sort(function (a, b) {
+      return a - b;
+    });
+  }
+  (_props$onSetColorDoma = props.onSetColorDomain) === null || _props$onSetColorDoma === void 0 || _props$onSetColorDoma.call(props, {
+    domain: enrichedDomain,
+    aggregatedBins: aggregatedBins
+  });
+}
+
+/**
+ * Shared renderLayers() wrapper that re-classifies bins when custom colorMap
+ * changes between renders without triggering a full re-aggregation.
+ *
+ * @param layer       The enhanced layer instance (`this`)
+ * @param ParentClass The deck.gl parent class (HexagonLayer or GridLayer)
+ * @returns The sublayers returned by the parent's renderLayers()
+ */
+function enrichedRenderLayers(layer, ParentClass) {
+  var props = layer.getCurrentLayer().props;
+  var _layer$state = layer.state,
+    colors = _layer$state.colors,
+    rawColorBinValues = _layer$state.rawColorBinValues,
+    aggregator = _layer$state.aggregator;
+  if (props.colorMap && colors && rawColorBinValues && (aggregator === null || aggregator === void 0 ? void 0 : aggregator.binCount) > 0) {
+    classifyBinsByCustomBreaks(colors, aggregator.binCount, props.colorMap, rawColorBinValues);
+  }
+  return ParentClass.prototype.renderLayers.call(layer);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["buildAggregatedBinMap","binValues","binCount","aggregator","bins","i","_aggregator$getBin$co","_aggregator$getBin","val","count","getBin","call","value","counts","classifyBinsByCustomBreaks","stateColors","colorMap","rawValues","thresholds","_iterator","_createForOfIteratorHelper","_step","s","n","done","entry","Number","isFinite","push","err","e","f","sort","a","b","numColors","length","classified","Float32Array","v","NaN","idx","t","classifiedAttr","type","size","input","attribute","enrichedAggregationUpdate","layer","ParentClass","channel","_props$onSetColorDoma","prototype","_onAggregationUpdate","props","getCurrentLayer","state","result","getResult","setState","rawColorBinValues","from","subarray","domain","getResultDomain","aggregatedBins","colors","enrichedDomain","colorScaleType","Array","slice","filter","onSetColorDomain","enrichedRenderLayers","_layer$state","renderLayers"],"sources":["../../../src/layer-utils/aggregation-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {AggregatedBin, ColorMap} from '@kepler.gl/types';\n\n/**\n * Build a Record<index, AggregatedBin> from the raw Float32Array of per-bin\n * aggregated values returned by deck.gl 9's CPUAggregator/WebGLAggregator.\n * The resulting map is compatible with the format kepler.gl expects for\n * histogram rendering and color-scale selector.\n */\nexport function buildAggregatedBinMap(\n  binValues: ArrayLike<number>,\n  binCount: number,\n  aggregator?: any\n): Record<number, AggregatedBin> {\n  const bins: Record<number, AggregatedBin> = {};\n  for (let i = 0; i < binCount; i++) {\n    const val = binValues[i];\n    const count = aggregator?.getBin?.(i)?.count ?? 0;\n    bins[i] = {i, value: val, counts: count};\n  }\n  return bins;\n}\n\n/**\n * Classify raw per-bin aggregated values into break indices according to\n * a custom colorMap, and patch the deck.gl internal `state.colors` so the\n * GPU shader renders the correct color for each bin.\n *\n * Custom breaks define thresholds [t0, t1, …, t_{N-2}] for N colors:\n *   color 0: value < t0\n *   color i: t_{i-1} <= value < t_i\n *   color N-1: value >= t_{N-2}\n *\n * We replace the values in `state.colors.attribute` / `state.colors.input`\n * with integer break indices [0 … N-1].  Combined with `colorScaleType: 'quantize'`\n * and `colorDomain: [0, N-1]`, the shader's linear interpolation maps each index\n * to the correct color texture pixel.\n *\n * `rawValues` must be the original aggregated values (not previously classified).\n */\nexport function classifyBinsByCustomBreaks(\n  stateColors: any,\n  binCount: number,\n  colorMap: ColorMap,\n  rawValues: Float32Array\n): void {\n  if (!rawValues || binCount === 0) return;\n\n  const thresholds: number[] = [];\n  for (const entry of colorMap) {\n    if (typeof entry[0] === 'number' && Number.isFinite(entry[0])) {\n      thresholds.push(entry[0]);\n    }\n  }\n  thresholds.sort((a, b) => a - b);\n\n  const numColors = colorMap.length;\n  const classified = new Float32Array(rawValues.length);\n  for (let i = 0; i < binCount; i++) {\n    const v = rawValues[i];\n    if (!Number.isFinite(v)) {\n      classified[i] = NaN;\n      continue;\n    }\n    let idx = numColors - 1;\n    for (let t = 0; t < thresholds.length; t++) {\n      if (v < thresholds[t]) {\n        idx = t;\n        break;\n      }\n    }\n    classified[i] = idx;\n  }\n  for (let i = binCount; i < classified.length; i++) {\n    classified[i] = NaN;\n  }\n\n  const classifiedAttr = {value: classified, type: 'float32', size: 1};\n  stateColors.input = classifiedAttr;\n  stateColors.attribute = classifiedAttr;\n}\n\n// ---------------------------------------------------------------------------\n// Shared _onAggregationUpdate / renderLayers logic for ScaleEnhanced* layers\n// ---------------------------------------------------------------------------\n//\n// deck.gl 9's _onAggregationUpdate is private and its onSetColorDomain\n// callback only provides [min, max].  That is sufficient for quantize/linear\n// scales but d3.scaleQuantile needs the *full sorted array* of bin values to\n// compute correct break points — without it the legend labels are wrong\n// (see https://github.com/keplergl/kepler.gl/issues/3381).\n//\n// deck.gl does not expose a public hook for post-aggregation data, and props\n// are Object.freeze()'d so we cannot suppress the parent's callback.  Instead\n// we let the parent fire its [min, max] call, then immediately fire a second\n// enriched call with per-bin values (aggregatedBins) and, for quantile scale,\n// the full sorted domain.  The second call overwrites the first downstream in\n// _onLayerSetDomain.\n//\n// This can be removed once deck.gl exposes a richer post-aggregation callback\n// or makes _onAggregationUpdate / AttributeWithScale part of the public API.\n\n/**\n * Enriched _onAggregationUpdate implementation shared by ScaleEnhancedHexagonLayer\n * and ScaleEnhancedGridLayer.\n *\n * @param layer       The enhanced layer instance (`this`)\n * @param ParentClass The deck.gl parent class (HexagonLayer or GridLayer)\n * @param channel     The aggregation channel index passed by deck.gl\n */\nexport function enrichedAggregationUpdate(layer: any, ParentClass: any, channel: number): void {\n  (ParentClass.prototype as any)._onAggregationUpdate.call(layer, {channel});\n\n  if (channel !== 0) return;\n\n  const props = layer.getCurrentLayer().props;\n  const {aggregator} = layer.state;\n  const result = aggregator.getResult(0);\n  const binValues = result?.value as Float32Array | undefined;\n  if (!binValues || aggregator.binCount <= 0) return;\n\n  layer.setState({\n    rawColorBinValues: Float32Array.from(binValues.subarray(0, aggregator.binCount))\n  });\n\n  const domain = aggregator.getResultDomain(0);\n  const aggregatedBins = buildAggregatedBinMap(binValues, aggregator.binCount, aggregator);\n\n  if (props.colorMap) {\n    classifyBinsByCustomBreaks(layer.state.colors, aggregator.binCount, props.colorMap, binValues);\n  }\n\n  let enrichedDomain = domain;\n  if (props.colorScaleType === 'quantile') {\n    enrichedDomain = Array.from(binValues)\n      .slice(0, aggregator.binCount)\n      .filter(Number.isFinite)\n      .sort((a: number, b: number) => a - b);\n  }\n  props.onSetColorDomain?.({domain: enrichedDomain, aggregatedBins});\n}\n\n/**\n * Shared renderLayers() wrapper that re-classifies bins when custom colorMap\n * changes between renders without triggering a full re-aggregation.\n *\n * @param layer       The enhanced layer instance (`this`)\n * @param ParentClass The deck.gl parent class (HexagonLayer or GridLayer)\n * @returns The sublayers returned by the parent's renderLayers()\n */\nexport function enrichedRenderLayers(layer: any, ParentClass: any): any {\n  const props = layer.getCurrentLayer().props;\n  const {colors, rawColorBinValues, aggregator} = layer.state;\n  if (props.colorMap && colors && rawColorBinValues && aggregator?.binCount > 0) {\n    classifyBinsByCustomBreaks(colors, aggregator.binCount, props.colorMap, rawColorBinValues);\n  }\n  return (ParentClass.prototype as any).renderLayers.call(layer);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/layer-utils/cluster-utils.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.getGeoJSON = getGeoJSON;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _supercluster = _interopRequireDefault(require("supercluster"));
+var _memoize = _interopRequireDefault(require("es-toolkit/compat/memoize"));
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// es-toolkit/compat memoize does not export lodash's MemoizedFunction type.
+
+function getGeoJSON(data, getPosition, filterData) {
+  var raw = typeof filterData === 'function' ? data.filter(filterData) : data;
+  return raw.map(function (d) {
+    return {
+      type: 'Point',
+      properties: {
+        data: d,
+        points: [d],
+        point_count: 1,
+        point_count_abbreviated: '1'
+      },
+      geometry: {
+        coordinates: getPosition(d)
+      }
+    };
+  }).filter(function (d) {
+    return d.geometry.coordinates.every(Number.isFinite);
+  });
+}
+var clusterResolver = function clusterResolver(_ref) {
+  var clusterRadius = _ref.clusterRadius;
+  return "".concat(clusterRadius);
+};
+var getClusterer = function getClusterer(_ref2) {
+  var clusterRadius = _ref2.clusterRadius,
+    geoJSON = _ref2.geoJSON;
+  return new _supercluster["default"]({
+    maxZoom: 20,
+    radius: clusterRadius,
+    reduce: function reduce(accumulated, props) {
+      accumulated.points = [].concat((0, _toConsumableArray2["default"])(accumulated.points), (0, _toConsumableArray2["default"])(props.points));
+    },
+    map: function map(props) {
+      return {
+        points: [props.data]
+      };
+    }
+  }).load(geoJSON);
+};
+var ClusterBuilder = exports["default"] = /*#__PURE__*/function () {
+  function ClusterBuilder() {
+    (0, _classCallCheck2["default"])(this, ClusterBuilder);
+    (0, _defineProperty2["default"])(this, "clusterer", void 0);
+    this.clusterer = (0, _memoize["default"])(getClusterer, clusterResolver);
+  }
+  return (0, _createClass2["default"])(ClusterBuilder, [{
+    key: "clustersAtZoom",
+    value: function clustersAtZoom(_ref3) {
+      var bbox = _ref3.bbox,
+        clusterRadius = _ref3.clusterRadius,
+        geoJSON = _ref3.geoJSON,
+        zoom = _ref3.zoom;
+      var clusterer = this.clusterer({
+        clusterRadius: clusterRadius,
+        geoJSON: geoJSON
+      });
+
+      // map clusters to formatted bins to be passed to deck.gl bin-sorter
+      var clusters = clusterer.getClusters(bbox, zoom).map(function (c, i) {
+        return {
+          points: c.properties.points,
+          position: c.geometry.coordinates,
+          index: i
+        };
+      });
+      return clusters;
+    }
+  }, {
+    key: "clearClustererCache",
+    value: function clearClustererCache() {
+      var _this$clusterer$cache, _this$clusterer$cache2;
+      (_this$clusterer$cache = (_this$clusterer$cache2 = this.clusterer.cache).clear) === null || _this$clusterer$cache === void 0 || _this$clusterer$cache.call(_this$clusterer$cache2);
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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