@kepler.gl/deckgl-layers 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/esm/globe/mvt-label-layer.js

@@ -0,0 +1,187 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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) { _defineProperty(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; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { CompositeLayer } from '@deck.gl/core';
+import { GeoJsonLayer, TextLayer } from '@deck.gl/layers';
+import EnhancedMultiIconLayer from './enhanced-multi-icon-layer';
+
+// Custom globe basemap label layer.
+//
+// This composite is used as the `renderSubLayers` of the globe basemap MVTLayer.
+// It renders two things per tile:
+//   1. A GeoJsonLayer for admin lines / water fills (same visuals as before).
+//   2. A TextLayer for place labels (country names), gated on `config.labels`.
+//
+// The TextLayer uses a custom `EnhancedMultiIconLayer` as its glyph (characters)
+// sublayer, which culls labels on the far side of the globe so they aren't drawn
+// through the planet.
+
+export var MVTLabelLayer = /*#__PURE__*/function (_CompositeLayer) {
+  function MVTLabelLayer() {
+    _classCallCheck(this, MVTLabelLayer);
+    return _callSuper(this, MVTLabelLayer, arguments);
+  }
+  _inherits(MVTLabelLayer, _CompositeLayer);
+  return _createClass(MVTLabelLayer, [{
+    key: "getLabel",
+    value: function getLabel(feature) {
+      var properties = feature.properties;
+      switch (properties === null || properties === void 0 ? void 0 : properties.layerName) {
+        // Mapbox `mapbox-streets-v8` schema.
+        case 'place_label':
+          switch (properties["class"]) {
+            case 'country':
+              return properties.name_en || properties.name || '';
+            default:
+              return '';
+          }
+        // CARTO / OpenMapTiles schema.
+        case 'place':
+          switch (properties["class"]) {
+            case 'country':
+              return properties['name:en'] || properties.name_en || properties.name || '';
+            default:
+              return '';
+          }
+        default:
+          return '';
+      }
+    }
+  }, {
+    key: "getLabelSize",
+    value: function getLabelSize() {
+      return 10;
+    }
+  }, {
+    key: "getLabelAnchors",
+    value: function getLabelAnchors(feature) {
+      // @ts-expect-error geometry type is narrowed by the switch below
+      var _ref = feature.geometry || {},
+        type = _ref.type,
+        coordinates = _ref.coordinates;
+      switch (type) {
+        case 'Point':
+          return [coordinates];
+        case 'MultiPoint':
+          return coordinates;
+        default:
+          return [];
+      }
+    }
+  }, {
+    key: "updateState",
+    value: function updateState(_ref2) {
+      var _this = this;
+      var changeFlags = _ref2.changeFlags;
+      var data = this.props.data;
+      if (changeFlags.dataChanged && data) {
+        var features = data.features || data;
+        var labelData = (features || []).flatMap(function (feature, index) {
+          var labelAnchors = _this.getLabelAnchors(feature);
+          return labelAnchors.map(function (p) {
+            return _this.getSubLayerRow({
+              position: p
+            }, feature, index);
+          });
+        });
+        this.setState({
+          labelData: labelData
+        });
+      }
+    }
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      var _this$props = this.props,
+        config = _this$props.config,
+        labelSizeUnits = _this$props.labelSizeUnits,
+        labelBackground = _this$props.labelBackground,
+        billboard = _this$props.billboard;
+      var layers = [];
+
+      // admin lines and water
+      layers.push(new GeoJsonLayer(this.props, this.getSubLayerProps({
+        id: 'geojson'
+      }), {
+        data: this.props.data,
+        updateTriggers: {
+          getFillColor: {
+            water: config.water,
+            waterColor: config.waterColor
+          },
+          getLineColor: {
+            adminLines: config.adminLines,
+            adminLinesColor: config.adminLinesColor
+          }
+        }
+      }));
+
+      // labels
+      if (config.labels) {
+        layers.push(new TextLayer(this.getSubLayerProps({
+          id: 'text'
+        }), {
+          data: this.state.labelData,
+          parameters: {
+            // Globe mode sets a global `cull: true` (to backface-cull the sphere
+            // surface). That also backface-culls the glyph quads, hiding all labels,
+            // so explicitly disable culling here. depthTest off keeps labels on top of
+            // the globe surface rather than clipping into it.
+            cull: false,
+            depthTest: false,
+            depthMask: false
+          },
+          billboard: billboard,
+          sizeUnits: labelSizeUnits,
+          // Build the font atlas from the actual labels so accented / non-ASCII
+          // characters (ü, ó, etc. in country names) aren't dropped as "missing".
+          characterSet: 'auto',
+          fontFamily: 'Monaco, monospace',
+          background: Boolean(labelBackground),
+          getBackgroundColor: function getBackgroundColor() {
+            return labelBackground || [0, 0, 0, 0];
+          },
+          getPosition: function getPosition(d) {
+            return d.position;
+          },
+          getText: this.getSubLayerAccessor(this.getLabel),
+          getSize: this.getSubLayerAccessor(this.getLabelSize),
+          getColor: function getColor() {
+            return config.labelsColor;
+          },
+          _subLayerProps: {
+            characters: {
+              type: EnhancedMultiIconLayer
+            }
+          },
+          updateTriggers: {
+            getColor: config.labelsColor
+          }
+        }));
+      }
+      return layers;
+    }
+  }]);
+}(CompositeLayer);
+_defineProperty(MVTLabelLayer, "layerName", 'MVTLabelLayer');
+_defineProperty(MVTLabelLayer, "defaultProps", _objectSpread(_objectSpread({}, GeoJsonLayer.defaultProps), {}, {
+  billboard: true,
+  labelSizeUnits: 'pixels',
+  labelBackground: {
+    type: 'color',
+    value: null,
+    optional: true
+  },
+  fontFamily: 'Monaco, monospace'
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CompositeLayer","GeoJsonLayer","TextLayer","EnhancedMultiIconLayer","MVTLabelLayer","_CompositeLayer","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","value","getLabel","feature","properties","layerName","name_en","name","getLabelSize","getLabelAnchors","_ref","geometry","type","coordinates","updateState","_ref2","_this","changeFlags","data","props","dataChanged","features","labelData","flatMap","index","labelAnchors","map","p","getSubLayerRow","position","setState","renderLayers","_this$props","config","labelSizeUnits","labelBackground","billboard","layers","push","getSubLayerProps","id","updateTriggers","getFillColor","water","waterColor","getLineColor","adminLines","adminLinesColor","labels","state","parameters","cull","depthTest","depthMask","sizeUnits","characterSet","fontFamily","background","Boolean","getBackgroundColor","getPosition","d","getText","getSubLayerAccessor","getSize","getColor","labelsColor","_subLayerProps","characters","_defineProperty","_objectSpread","defaultProps","optional"],"sources":["../../../src/globe/mvt-label-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {CompositeLayer, Color, Layer, UpdateParameters, AccessorFunction} from '@deck.gl/core';\nimport {GeoJsonLayer, TextLayer} from '@deck.gl/layers';\n\nimport type {Globe} from '@kepler.gl/constants';\nimport type {Feature} from 'geojson';\n\nimport EnhancedMultiIconLayer from './enhanced-multi-icon-layer';\n\n// Custom globe basemap label layer.\n//\n// This composite is used as the `renderSubLayers` of the globe basemap MVTLayer.\n// It renders two things per tile:\n//   1. A GeoJsonLayer for admin lines / water fills (same visuals as before).\n//   2. A TextLayer for place labels (country names), gated on `config.labels`.\n//\n// The TextLayer uses a custom `EnhancedMultiIconLayer` as its glyph (characters)\n// sublayer, which culls labels on the far side of the globe so they aren't drawn\n// through the planet.\n\ntype MVTLabelLayerProps = {\n  data: {features: Feature[]} | Feature[];\n  config: Globe['config'];\n  labelSizeUnits?: 'meters' | 'common' | 'pixels';\n  labelBackground?: Color;\n  billboard?: boolean;\n};\n\nexport class MVTLabelLayer extends CompositeLayer<MVTLabelLayerProps> {\n  static layerName = 'MVTLabelLayer';\n  static defaultProps = {\n    ...GeoJsonLayer.defaultProps,\n    billboard: true,\n    labelSizeUnits: 'pixels',\n    labelBackground: {type: 'color', value: null, optional: true},\n    fontFamily: 'Monaco, monospace'\n  };\n\n  getLabel(feature: Feature): string {\n    const {properties} = feature;\n\n    switch (properties?.layerName) {\n      // Mapbox `mapbox-streets-v8` schema.\n      case 'place_label':\n        switch (properties.class) {\n          case 'country':\n            return properties.name_en || properties.name || '';\n          default:\n            return '';\n        }\n      // CARTO / OpenMapTiles schema.\n      case 'place':\n        switch (properties.class) {\n          case 'country':\n            return properties['name:en'] || properties.name_en || properties.name || '';\n          default:\n            return '';\n        }\n      default:\n        return '';\n    }\n  }\n\n  getLabelSize(): number {\n    return 10;\n  }\n\n  getLabelAnchors(feature: Feature): number[][] {\n    // @ts-expect-error geometry type is narrowed by the switch below\n    const {type, coordinates} = feature.geometry || {};\n    switch (type) {\n      case 'Point':\n        return [coordinates];\n      case 'MultiPoint':\n        return coordinates;\n      default:\n        return [];\n    }\n  }\n\n  updateState({changeFlags}: UpdateParameters<this>): void {\n    const {data} = this.props;\n    if (changeFlags.dataChanged && data) {\n      const features = (data as {features: Feature[]}).features || (data as Feature[]);\n      const labelData = (features || []).flatMap((feature, index) => {\n        const labelAnchors = this.getLabelAnchors(feature);\n        return labelAnchors.map(p => this.getSubLayerRow({position: p}, feature, index));\n      });\n\n      this.setState({labelData});\n    }\n  }\n\n  renderLayers(): Layer[] {\n    const {config, labelSizeUnits, labelBackground, billboard} = this.props;\n    const layers: Layer[] = [];\n\n    // admin lines and water\n    layers.push(\n      new GeoJsonLayer(this.props as any, this.getSubLayerProps({id: 'geojson'}), {\n        data: this.props.data as any,\n        updateTriggers: {\n          getFillColor: {\n            water: config.water,\n            waterColor: config.waterColor\n          },\n          getLineColor: {\n            adminLines: config.adminLines,\n            adminLinesColor: config.adminLinesColor\n          }\n        }\n      })\n    );\n\n    // labels\n    if (config.labels) {\n      layers.push(\n        new TextLayer(this.getSubLayerProps({id: 'text'}), {\n          data: this.state.labelData as any,\n          parameters: {\n            // Globe mode sets a global `cull: true` (to backface-cull the sphere\n            // surface). That also backface-culls the glyph quads, hiding all labels,\n            // so explicitly disable culling here. depthTest off keeps labels on top of\n            // the globe surface rather than clipping into it.\n            cull: false,\n            depthTest: false,\n            depthMask: false\n          },\n          billboard,\n          sizeUnits: labelSizeUnits,\n          // Build the font atlas from the actual labels so accented / non-ASCII\n          // characters (ü, ó, etc. in country names) aren't dropped as \"missing\".\n          characterSet: 'auto',\n          fontFamily: 'Monaco, monospace',\n          background: Boolean(labelBackground),\n          getBackgroundColor: () => (labelBackground || [0, 0, 0, 0]) as Color,\n          getPosition: (d: any) => d.position,\n          getText: this.getSubLayerAccessor(this.getLabel) as AccessorFunction<Feature, string>,\n          getSize: this.getSubLayerAccessor(this.getLabelSize),\n          getColor: () => config.labelsColor as Color,\n          _subLayerProps: {\n            characters: {\n              type: EnhancedMultiIconLayer\n            }\n          } as any,\n          updateTriggers: {\n            getColor: config.labelsColor\n          }\n        })\n      );\n    }\n\n    return layers;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/grid-layer/enhanced-cpu-grid-layer.js

@@ -0,0 +1,112 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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) { _defineProperty(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; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { GridLayer } from '@deck.gl/aggregation-layers';
+import { enrichedAggregationUpdate, enrichedRenderLayers } from '../layer-utils/aggregation-utils';
+import { makeGlobeCellLayerClass, runBinOptionsWithMercatorViewport } from '../layer-utils/globe-cell-utils';
+/**
+ * In deck.gl 9, GridLayer natively supports CPU aggregation via gpuAggregation: false,
+ * custom getColorValue/getElevationValue accessors, percentile filtering, and scale types.
+ * The custom CPUAggregator override from deck.gl 8 is no longer needed.
+ *
+ * We override getPickingInfo to add `cellOutline` — an array of [lng, lat] coordinates
+ * computed in common space so the outline aligns with rendered cells at all latitudes.
+ *
+ * We also override _onAggregationUpdate to send per-bin aggregated values through
+ * onSetColorDomain so the legend can compute proper quantile/custom breaks.
+ */
+// @ts-expect-error -- overriding private _onAggregationUpdate to enrich the onSetColorDomain callback
+var ScaleEnhancedGridLayer = /*#__PURE__*/function (_GridLayer) {
+  function ScaleEnhancedGridLayer() {
+    _classCallCheck(this, ScaleEnhancedGridLayer);
+    return _callSuper(this, ScaleEnhancedGridLayer, arguments);
+  }
+  _inherits(ScaleEnhancedGridLayer, _GridLayer);
+  return _createClass(ScaleEnhancedGridLayer, [{
+    key: "_onAggregationUpdate",
+    value:
+    // HACK: 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
+    function _onAggregationUpdate(_ref) {
+      var channel = _ref.channel;
+      enrichedAggregationUpdate(this, GridLayer, channel);
+    }
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      return enrichedRenderLayers(this, GridLayer);
+    }
+
+    // In globe mode, run deck.gl's bin/common-space setup under a WebMercatorViewport
+    // so binning and the cell shader's flat common space are genuine Web Mercator, which
+    // the globe cell subclass then remaps onto the sphere surface. No-op in 2D/3D mode.
+  }, {
+    key: "_updateBinOptions",
+    value: function _updateBinOptions() {
+      var _this = this;
+      runBinOptionsWithMercatorViewport(this, function () {
+        return GridLayer.prototype._updateBinOptions.call(_this);
+      });
+    }
+
+    // deck.gl's GridCellLayer positions cells in flat common space, which lands them
+    // on the XY plane through the globe center. Swap in a globe-aware subclass that
+    // curves cells onto the sphere surface (no-op in 2D/3D mode).
+  }, {
+    key: "getSubLayerClass",
+    value: function getSubLayerClass(subLayerId, DefaultLayerClass) {
+      var resolved = _superPropGet(ScaleEnhancedGridLayer, "getSubLayerClass", this, 3)([subLayerId, DefaultLayerClass]);
+      if (subLayerId === 'cells') {
+        return makeGlobeCellLayerClass(resolved, 'grid');
+      }
+      return resolved;
+    }
+  }, {
+    key: "getPickingInfo",
+    value: function getPickingInfo(params) {
+      var info = _superPropGet(ScaleEnhancedGridLayer, "getPickingInfo", this, 3)([params]);
+      if (info.object) {
+        var _this$props$coverage;
+        var _ref2 = this.state,
+          cellOriginCommon = _ref2.cellOriginCommon,
+          cellSizeCommon = _ref2.cellSizeCommon,
+          aggregatorViewport = _ref2.aggregatorViewport;
+        var coverage = (_this$props$coverage = this.props.coverage) !== null && _this$props$coverage !== void 0 ? _this$props$coverage : 1;
+        if (!cellOriginCommon || !cellSizeCommon || !aggregatorViewport) {
+          console.error('ScaleEnhancedGridLayer: expected internal state properties ' + '(cellOriginCommon, cellSizeCommon, aggregatorViewport) are missing. ' + 'Hover outline will not be shown. This may indicate a deck.gl version change.');
+          return info;
+        }
+        var _ref3 = info.object,
+          col = _ref3.col,
+          row = _ref3.row;
+        if (typeof col !== 'number' || typeof row !== 'number') return info;
+        var cx = (col + 0.5) * cellSizeCommon[0] + cellOriginCommon[0];
+        var cy = (row + 0.5) * cellSizeCommon[1] + cellOriginCommon[1];
+        var hw = 0.5 * coverage * cellSizeCommon[0];
+        var hh = 0.5 * coverage * cellSizeCommon[1];
+        info.object.cellOutline = [aggregatorViewport.unprojectFlat([cx - hw, cy - hh]), aggregatorViewport.unprojectFlat([cx + hw, cy - hh]), aggregatorViewport.unprojectFlat([cx + hw, cy + hh]), aggregatorViewport.unprojectFlat([cx - hw, cy + hh]), aggregatorViewport.unprojectFlat([cx - hw, cy - hh])];
+      }
+      return info;
+    }
+  }]);
+}(GridLayer);
+_defineProperty(ScaleEnhancedGridLayer, "defaultProps", _objectSpread(_objectSpread({}, GridLayer.defaultProps), {}, {
+  gpuAggregation: false
+}));
+export { ScaleEnhancedGridLayer as default };
+ScaleEnhancedGridLayer.layerName = 'ScaleEnhancedGridLayer';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["GridLayer","enrichedAggregationUpdate","enrichedRenderLayers","makeGlobeCellLayerClass","runBinOptionsWithMercatorViewport","ScaleEnhancedGridLayer","_GridLayer","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","value","_onAggregationUpdate","_ref","channel","renderLayers","_updateBinOptions","_this","prototype","call","getSubLayerClass","subLayerId","DefaultLayerClass","resolved","_superPropGet","getPickingInfo","params","info","object","_this$props$coverage","_ref2","state","cellOriginCommon","cellSizeCommon","aggregatorViewport","coverage","props","console","error","_ref3","col","row","cx","cy","hw","hh","cellOutline","unprojectFlat","_defineProperty","_objectSpread","defaultProps","gpuAggregation","default","layerName"],"sources":["../../../src/grid-layer/enhanced-cpu-grid-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {GridLayer, GridLayerPickingInfo} from '@deck.gl/aggregation-layers';\nimport {GetPickingInfoParams, Layer, PickingInfo, Viewport} from '@deck.gl/core';\nimport {enrichedAggregationUpdate, enrichedRenderLayers} from '../layer-utils/aggregation-utils';\nimport {\n  makeGlobeCellLayerClass,\n  runBinOptionsWithMercatorViewport\n} from '../layer-utils/globe-cell-utils';\n\ninterface GridInternalState {\n  cellOriginCommon?: [number, number];\n  cellSizeCommon?: [number, number];\n  aggregatorViewport?: Viewport & {unprojectFlat(xy: number[]): number[]};\n}\n\ninterface GridPickingObject {\n  col: number;\n  row: number;\n  cellOutline?: number[][];\n  [key: string]: unknown;\n}\n\n/**\n * In deck.gl 9, GridLayer natively supports CPU aggregation via gpuAggregation: false,\n * custom getColorValue/getElevationValue accessors, percentile filtering, and scale types.\n * The custom CPUAggregator override from deck.gl 8 is no longer needed.\n *\n * We override getPickingInfo to add `cellOutline` — an array of [lng, lat] coordinates\n * computed in common space so the outline aligns with rendered cells at all latitudes.\n *\n * We also override _onAggregationUpdate to send per-bin aggregated values through\n * onSetColorDomain so the legend can compute proper quantile/custom breaks.\n */\n// @ts-expect-error -- overriding private _onAggregationUpdate to enrich the onSetColorDomain callback\nexport default class ScaleEnhancedGridLayer extends GridLayer<any> {\n  static defaultProps = {\n    ...GridLayer.defaultProps,\n    gpuAggregation: false\n  };\n\n  // HACK: 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  _onAggregationUpdate({channel}: {channel: number}) {\n    enrichedAggregationUpdate(this, GridLayer, channel);\n  }\n\n  renderLayers() {\n    return enrichedRenderLayers(this, GridLayer);\n  }\n\n  // In globe mode, run deck.gl's bin/common-space setup under a WebMercatorViewport\n  // so binning and the cell shader's flat common space are genuine Web Mercator, which\n  // the globe cell subclass then remaps onto the sphere surface. No-op in 2D/3D mode.\n  _updateBinOptions() {\n    runBinOptionsWithMercatorViewport(this, () =>\n      (GridLayer.prototype as any)._updateBinOptions.call(this)\n    );\n  }\n\n  // deck.gl's GridCellLayer positions cells in flat common space, which lands them\n  // on the XY plane through the globe center. Swap in a globe-aware subclass that\n  // curves cells onto the sphere surface (no-op in 2D/3D mode).\n  getSubLayerClass<T extends Layer>(subLayerId: string, DefaultLayerClass: {new (...args: any[]): T}) {\n    const resolved = super.getSubLayerClass(subLayerId, DefaultLayerClass);\n    if (subLayerId === 'cells') {\n      return makeGlobeCellLayerClass(\n        resolved as unknown as {new (...args: any[]): T},\n        'grid'\n      ) as unknown as {\n        new (...args: any[]): T;\n      };\n    }\n    return resolved;\n  }\n\n  getPickingInfo(params: GetPickingInfoParams): PickingInfo {\n    const info = super.getPickingInfo(params) as GridLayerPickingInfo<Record<string, unknown>>;\n    if (info.object) {\n      const {cellOriginCommon, cellSizeCommon, aggregatorViewport} = this\n        .state as unknown as GridInternalState;\n      const coverage = this.props.coverage ?? 1;\n      if (!cellOriginCommon || !cellSizeCommon || !aggregatorViewport) {\n        console.error(\n          'ScaleEnhancedGridLayer: expected internal state properties ' +\n            '(cellOriginCommon, cellSizeCommon, aggregatorViewport) are missing. ' +\n            'Hover outline will not be shown. This may indicate a deck.gl version change.'\n        );\n        return info;\n      }\n      const {col, row} = info.object as GridPickingObject;\n      if (typeof col !== 'number' || typeof row !== 'number') return info;\n      const cx = (col + 0.5) * cellSizeCommon[0] + cellOriginCommon[0];\n      const cy = (row + 0.5) * cellSizeCommon[1] + cellOriginCommon[1];\n      const hw = 0.5 * coverage * cellSizeCommon[0];\n      const hh = 0.5 * coverage * cellSizeCommon[1];\n\n      (info.object as GridPickingObject).cellOutline = [\n        aggregatorViewport.unprojectFlat([cx - hw, cy - hh]),\n        aggregatorViewport.unprojectFlat([cx + hw, cy - hh]),\n        aggregatorViewport.unprojectFlat([cx + hw, cy + hh]),\n        aggregatorViewport.unprojectFlat([cx - hw, cy + hh]),\n        aggregatorViewport.unprojectFlat([cx - hw, cy - hh])\n      ];\n    }\n    return info;\n  }\n}\n\nScaleEnhancedGridLayer.layerName = 'ScaleEnhancedGridLayer';\n"],"mappings":";;;;;;;;;;;;AAAA;AACA;;AAEA,SAAQA,SAAS,QAA6B,6BAA6B;AAE3E,SAAQC,yBAAyB,EAAEC,oBAAoB,QAAO,kCAAkC;AAChG,SACEC,uBAAuB,EACvBC,iCAAiC,QAC5B,iCAAiC;AAexC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA,IACqBC,sBAAsB,0BAAAC,UAAA;EAAA,SAAAD,uBAAA;IAAAE,eAAA,OAAAF,sBAAA;IAAA,OAAAG,UAAA,OAAAH,sBAAA,EAAAI,SAAA;EAAA;EAAAC,SAAA,CAAAL,sBAAA,EAAAC,UAAA;EAAA,OAAAK,YAAA,CAAAN,sBAAA;IAAAO,GAAA;IAAAC,KAAA;IAMzC;IACA;IACA;IACA;IACA,SAAAC,oBAAoBA,CAAAC,IAAA,EAA+B;MAAA,IAA7BC,OAAO,GAAAD,IAAA,CAAPC,OAAO;MAC3Bf,yBAAyB,CAAC,IAAI,EAAED,SAAS,EAAEgB,OAAO,CAAC;IACrD;EAAC;IAAAJ,GAAA;IAAAC,KAAA,EAED,SAAAI,YAAYA,CAAA,EAAG;MACb,OAAOf,oBAAoB,CAAC,IAAI,EAAEF,SAAS,CAAC;IAC9C;;IAEA;IACA;IACA;EAAA;IAAAY,GAAA;IAAAC,KAAA,EACA,SAAAK,iBAAiBA,CAAA,EAAG;MAAA,IAAAC,KAAA;MAClBf,iCAAiC,CAAC,IAAI,EAAE;QAAA,OACrCJ,SAAS,CAACoB,SAAS,CAASF,iBAAiB,CAACG,IAAI,CAACF,KAAI,CAAC;MAAA,CAC3D,CAAC;IACH;;IAEA;IACA;IACA;EAAA;IAAAP,GAAA;IAAAC,KAAA,EACA,SAAAS,gBAAgBA,CAAkBC,UAAkB,EAAEC,iBAA4C,EAAE;MAClG,IAAMC,QAAQ,GAAAC,aAAA,CAAArB,sBAAA,gCAA0BkB,UAAU,EAAEC,iBAAiB,EAAC;MACtE,IAAID,UAAU,KAAK,OAAO,EAAE;QAC1B,OAAOpB,uBAAuB,CAC5BsB,QAAQ,EACR,MACF,CAAC;MAGH;MACA,OAAOA,QAAQ;IACjB;EAAC;IAAAb,GAAA;IAAAC,KAAA,EAED,SAAAc,cAAcA,CAACC,MAA4B,EAAe;MACxD,IAAMC,IAAI,GAAAH,aAAA,CAAArB,sBAAA,8BAAwBuB,MAAM,EAAkD;MAC1F,IAAIC,IAAI,CAACC,MAAM,EAAE;QAAA,IAAAC,oBAAA;QACf,IAAAC,KAAA,GAA+D,IAAI,CAChEC,KAAK;UADDC,gBAAgB,GAAAF,KAAA,CAAhBE,gBAAgB;UAAEC,cAAc,GAAAH,KAAA,CAAdG,cAAc;UAAEC,kBAAkB,GAAAJ,KAAA,CAAlBI,kBAAkB;QAE3D,IAAMC,QAAQ,IAAAN,oBAAA,GAAG,IAAI,CAACO,KAAK,CAACD,QAAQ,cAAAN,oBAAA,cAAAA,oBAAA,GAAI,CAAC;QACzC,IAAI,CAACG,gBAAgB,IAAI,CAACC,cAAc,IAAI,CAACC,kBAAkB,EAAE;UAC/DG,OAAO,CAACC,KAAK,CACX,6DAA6D,GAC3D,sEAAsE,GACtE,8EACJ,CAAC;UACD,OAAOX,IAAI;QACb;QACA,IAAAY,KAAA,GAAmBZ,IAAI,CAACC,MAAM;UAAvBY,GAAG,GAAAD,KAAA,CAAHC,GAAG;UAAEC,GAAG,GAAAF,KAAA,CAAHE,GAAG;QACf,IAAI,OAAOD,GAAG,KAAK,QAAQ,IAAI,OAAOC,GAAG,KAAK,QAAQ,EAAE,OAAOd,IAAI;QACnE,IAAMe,EAAE,GAAG,CAACF,GAAG,GAAG,GAAG,IAAIP,cAAc,CAAC,CAAC,CAAC,GAAGD,gBAAgB,CAAC,CAAC,CAAC;QAChE,IAAMW,EAAE,GAAG,CAACF,GAAG,GAAG,GAAG,IAAIR,cAAc,CAAC,CAAC,CAAC,GAAGD,gBAAgB,CAAC,CAAC,CAAC;QAChE,IAAMY,EAAE,GAAG,GAAG,GAAGT,QAAQ,GAAGF,cAAc,CAAC,CAAC,CAAC;QAC7C,IAAMY,EAAE,GAAG,GAAG,GAAGV,QAAQ,GAAGF,cAAc,CAAC,CAAC,CAAC;QAE5CN,IAAI,CAACC,MAAM,CAAuBkB,WAAW,GAAG,CAC/CZ,kBAAkB,CAACa,aAAa,CAAC,CAACL,EAAE,GAAGE,EAAE,EAAED,EAAE,GAAGE,EAAE,CAAC,CAAC,EACpDX,kBAAkB,CAACa,aAAa,CAAC,CAACL,EAAE,GAAGE,EAAE,EAAED,EAAE,GAAGE,EAAE,CAAC,CAAC,EACpDX,kBAAkB,CAACa,aAAa,CAAC,CAACL,EAAE,GAAGE,EAAE,EAAED,EAAE,GAAGE,EAAE,CAAC,CAAC,EACpDX,kBAAkB,CAACa,aAAa,CAAC,CAACL,EAAE,GAAGE,EAAE,EAAED,EAAE,GAAGE,EAAE,CAAC,CAAC,EACpDX,kBAAkB,CAACa,aAAa,CAAC,CAACL,EAAE,GAAGE,EAAE,EAAED,EAAE,GAAGE,EAAE,CAAC,CAAC,CACrD;MACH;MACA,OAAOlB,IAAI;IACb;EAAC;AAAA,EAzEiD7B,SAAS;AAAAkD,eAAA,CAAxC7C,sBAAsB,kBAAA8C,aAAA,CAAAA,aAAA,KAEpCnD,SAAS,CAACoD,YAAY;EACzBC,cAAc,EAAE;AAAK;AAAA,SAHJhD,sBAAsB,IAAAiD,OAAA;AA4E3CjD,sBAAsB,CAACkD,SAAS,GAAG,wBAAwB","ignoreList":[]}

package/dist/esm/hexagon-layer/enhanced-hexagon-layer.js

@@ -0,0 +1,130 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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) { _defineProperty(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; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { HexagonLayer } from '@deck.gl/aggregation-layers';
+import { enrichedAggregationUpdate, enrichedRenderLayers } from '../layer-utils/aggregation-utils';
+import { makeGlobeCellLayerClass, runBinOptionsWithMercatorViewport } from '../layer-utils/globe-cell-utils';
+var THIRD_PI = Math.PI / 3;
+var HexbinVertices = Array.from({
+  length: 6
+}, function (_, i) {
+  var angle = i * THIRD_PI;
+  return [Math.sin(angle), -Math.cos(angle)];
+});
+function getHexbinCentroid(id, radius) {
+  var DIST_X = 2 * Math.sin(THIRD_PI);
+  var DIST_Y = 1.5;
+  return [(id[0] + (id[1] & 1) / 2) * radius * DIST_X, id[1] * radius * DIST_Y];
+}
+/**
+ * In deck.gl 9, HexagonLayer natively supports CPU aggregation via gpuAggregation: false,
+ * custom getColorValue/getElevationValue accessors, percentile filtering, and scale types.
+ *
+ * We override getPickingInfo to add `cellOutline` — an array of [lng, lat] coordinates
+ * computed in common space so the outline aligns with rendered cells at all latitudes.
+ *
+ * We also override _onAggregationUpdate to send per-bin aggregated values through
+ * onSetColorDomain so the legend can compute proper quantile/custom breaks.
+ */
+// @ts-expect-error -- overriding private _onAggregationUpdate to enrich the onSetColorDomain callback
+var ScaleEnhancedHexagonLayer = /*#__PURE__*/function (_HexagonLayer) {
+  function ScaleEnhancedHexagonLayer() {
+    _classCallCheck(this, ScaleEnhancedHexagonLayer);
+    return _callSuper(this, ScaleEnhancedHexagonLayer, arguments);
+  }
+  _inherits(ScaleEnhancedHexagonLayer, _HexagonLayer);
+  return _createClass(ScaleEnhancedHexagonLayer, [{
+    key: "_onAggregationUpdate",
+    value:
+    // HACK: 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
+    function _onAggregationUpdate(_ref) {
+      var channel = _ref.channel;
+      enrichedAggregationUpdate(this, HexagonLayer, channel);
+    }
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      return enrichedRenderLayers(this, HexagonLayer);
+    }
+
+    // In globe mode, run deck.gl's bin/common-space setup under a WebMercatorViewport
+    // so binning and the cell shader's flat common space are genuine Web Mercator, which
+    // the globe cell subclass then remaps onto the sphere surface. No-op in 2D/3D mode.
+  }, {
+    key: "_updateBinOptions",
+    value: function _updateBinOptions() {
+      var _this = this;
+      runBinOptionsWithMercatorViewport(this, function () {
+        return HexagonLayer.prototype._updateBinOptions.call(_this);
+      });
+    }
+
+    // deck.gl's HexagonCellLayer positions cells in flat common space, which lands
+    // them on the XY plane through the globe center. Swap in a globe-aware subclass
+    // that curves cells onto the sphere surface (no-op in 2D/3D mode).
+  }, {
+    key: "getSubLayerClass",
+    value: function getSubLayerClass(subLayerId, DefaultLayerClass) {
+      var resolved = _superPropGet(ScaleEnhancedHexagonLayer, "getSubLayerClass", this, 3)([subLayerId, DefaultLayerClass]);
+      if (subLayerId === 'cells') {
+        return makeGlobeCellLayerClass(resolved, 'hexagon');
+      }
+      return resolved;
+    }
+  }, {
+    key: "getPickingInfo",
+    value: function getPickingInfo(params) {
+      var info = _superPropGet(ScaleEnhancedHexagonLayer, "getPickingInfo", this, 3)([params]);
+      if (info.object) {
+        var _this$props$coverage, _hexOriginCommon$, _hexOriginCommon$2;
+        var _ref2 = this.state,
+          radiusCommon = _ref2.radiusCommon,
+          hexOriginCommon = _ref2.hexOriginCommon,
+          aggregatorViewport = _ref2.aggregatorViewport;
+        var coverage = (_this$props$coverage = this.props.coverage) !== null && _this$props$coverage !== void 0 ? _this$props$coverage : 1;
+        if (!radiusCommon || !aggregatorViewport) {
+          console.error('ScaleEnhancedHexagonLayer: expected internal state properties ' + '(radiusCommon, aggregatorViewport) are missing. ' + 'Hover outline will not be shown. This may indicate a deck.gl version change.');
+          return info;
+        }
+        var _ref3 = info.object,
+          col = _ref3.col,
+          row = _ref3.row;
+        if (typeof col !== 'number' || typeof row !== 'number') return info;
+        var centroid = getHexbinCentroid([col, row], radiusCommon);
+        var ox = (_hexOriginCommon$ = hexOriginCommon === null || hexOriginCommon === void 0 ? void 0 : hexOriginCommon[0]) !== null && _hexOriginCommon$ !== void 0 ? _hexOriginCommon$ : 0;
+        var oy = (_hexOriginCommon$2 = hexOriginCommon === null || hexOriginCommon === void 0 ? void 0 : hexOriginCommon[1]) !== null && _hexOriginCommon$2 !== void 0 ? _hexOriginCommon$2 : 0;
+        var r = radiusCommon * coverage;
+        var outline = [];
+        for (var i = 0; i < 6; i++) {
+          var vx = centroid[0] + r * HexbinVertices[i][0] + ox;
+          var vy = centroid[1] + r * HexbinVertices[i][1] + oy;
+          outline.push(aggregatorViewport.unprojectFlat([vx, vy]));
+        }
+        outline.push(outline[0]);
+        info.object.cellOutline = outline;
+      }
+      return info;
+    }
+  }]);
+}(HexagonLayer);
+_defineProperty(ScaleEnhancedHexagonLayer, "defaultProps", _objectSpread(_objectSpread({}, HexagonLayer.defaultProps), {}, {
+  gpuAggregation: false
+}));
+export { ScaleEnhancedHexagonLayer as default };
+ScaleEnhancedHexagonLayer.layerName = 'ScaleEnhancedHexagonLayer';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["HexagonLayer","enrichedAggregationUpdate","enrichedRenderLayers","makeGlobeCellLayerClass","runBinOptionsWithMercatorViewport","THIRD_PI","Math","PI","HexbinVertices","Array","from","length","_","i","angle","sin","cos","getHexbinCentroid","id","radius","DIST_X","DIST_Y","ScaleEnhancedHexagonLayer","_HexagonLayer","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","value","_onAggregationUpdate","_ref","channel","renderLayers","_updateBinOptions","_this","prototype","call","getSubLayerClass","subLayerId","DefaultLayerClass","resolved","_superPropGet","getPickingInfo","params","info","object","_this$props$coverage","_hexOriginCommon$","_hexOriginCommon$2","_ref2","state","radiusCommon","hexOriginCommon","aggregatorViewport","coverage","props","console","error","_ref3","col","row","centroid","ox","oy","r","outline","vx","vy","push","unprojectFlat","cellOutline","_defineProperty","_objectSpread","defaultProps","gpuAggregation","default","layerName"],"sources":["../../../src/hexagon-layer/enhanced-hexagon-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {HexagonLayer, HexagonLayerPickingInfo} from '@deck.gl/aggregation-layers';\nimport {GetPickingInfoParams, Layer, PickingInfo, Viewport} from '@deck.gl/core';\nimport {enrichedAggregationUpdate, enrichedRenderLayers} from '../layer-utils/aggregation-utils';\nimport {\n  makeGlobeCellLayerClass,\n  runBinOptionsWithMercatorViewport\n} from '../layer-utils/globe-cell-utils';\n\nconst THIRD_PI = Math.PI / 3;\nconst HexbinVertices = Array.from({length: 6}, (_, i) => {\n  const angle = i * THIRD_PI;\n  return [Math.sin(angle), -Math.cos(angle)];\n});\n\nfunction getHexbinCentroid(id: [number, number], radius: number): [number, number] {\n  const DIST_X = 2 * Math.sin(THIRD_PI);\n  const DIST_Y = 1.5;\n  return [(id[0] + (id[1] & 1) / 2) * radius * DIST_X, id[1] * radius * DIST_Y];\n}\n\ninterface HexInternalState {\n  radiusCommon?: number;\n  hexOriginCommon?: [number, number];\n  aggregatorViewport?: Viewport & {unprojectFlat(xy: number[]): number[]};\n}\n\ninterface HexPickingObject {\n  col: number;\n  row: number;\n  cellOutline?: number[][];\n  [key: string]: unknown;\n}\n\n/**\n * In deck.gl 9, HexagonLayer natively supports CPU aggregation via gpuAggregation: false,\n * custom getColorValue/getElevationValue accessors, percentile filtering, and scale types.\n *\n * We override getPickingInfo to add `cellOutline` — an array of [lng, lat] coordinates\n * computed in common space so the outline aligns with rendered cells at all latitudes.\n *\n * We also override _onAggregationUpdate to send per-bin aggregated values through\n * onSetColorDomain so the legend can compute proper quantile/custom breaks.\n */\n// @ts-expect-error -- overriding private _onAggregationUpdate to enrich the onSetColorDomain callback\nexport default class ScaleEnhancedHexagonLayer extends HexagonLayer<any> {\n  static defaultProps = {\n    ...HexagonLayer.defaultProps,\n    gpuAggregation: false\n  };\n\n  // HACK: 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  _onAggregationUpdate({channel}: {channel: number}) {\n    enrichedAggregationUpdate(this, HexagonLayer, channel);\n  }\n\n  renderLayers() {\n    return enrichedRenderLayers(this, HexagonLayer);\n  }\n\n  // In globe mode, run deck.gl's bin/common-space setup under a WebMercatorViewport\n  // so binning and the cell shader's flat common space are genuine Web Mercator, which\n  // the globe cell subclass then remaps onto the sphere surface. No-op in 2D/3D mode.\n  _updateBinOptions() {\n    runBinOptionsWithMercatorViewport(this, () =>\n      (HexagonLayer.prototype as any)._updateBinOptions.call(this)\n    );\n  }\n\n  // deck.gl's HexagonCellLayer positions cells in flat common space, which lands\n  // them on the XY plane through the globe center. Swap in a globe-aware subclass\n  // that curves cells onto the sphere surface (no-op in 2D/3D mode).\n  getSubLayerClass<T extends Layer>(subLayerId: string, DefaultLayerClass: {new (...args: any[]): T}) {\n    const resolved = super.getSubLayerClass(subLayerId, DefaultLayerClass);\n    if (subLayerId === 'cells') {\n      return makeGlobeCellLayerClass(\n        resolved as unknown as {new (...args: any[]): T},\n        'hexagon'\n      ) as unknown as {\n        new (...args: any[]): T;\n      };\n    }\n    return resolved;\n  }\n\n  getPickingInfo(params: GetPickingInfoParams): PickingInfo {\n    const info = super.getPickingInfo(params) as HexagonLayerPickingInfo<Record<string, unknown>>;\n    if (info.object) {\n      const {radiusCommon, hexOriginCommon, aggregatorViewport} = this\n        .state as unknown as HexInternalState;\n      const coverage = this.props.coverage ?? 1;\n      if (!radiusCommon || !aggregatorViewport) {\n        console.error(\n          'ScaleEnhancedHexagonLayer: expected internal state properties ' +\n            '(radiusCommon, aggregatorViewport) are missing. ' +\n            'Hover outline will not be shown. This may indicate a deck.gl version change.'\n        );\n        return info;\n      }\n      const {col, row} = info.object as HexPickingObject;\n      if (typeof col !== 'number' || typeof row !== 'number') return info;\n      const centroid = getHexbinCentroid([col, row], radiusCommon);\n      const ox = hexOriginCommon?.[0] ?? 0;\n      const oy = hexOriginCommon?.[1] ?? 0;\n      const r = radiusCommon * coverage;\n\n      const outline: number[][] = [];\n      for (let i = 0; i < 6; i++) {\n        const vx = centroid[0] + r * HexbinVertices[i][0] + ox;\n        const vy = centroid[1] + r * HexbinVertices[i][1] + oy;\n        outline.push(aggregatorViewport.unprojectFlat([vx, vy]));\n      }\n      outline.push(outline[0]);\n      (info.object as HexPickingObject).cellOutline = outline;\n    }\n    return info;\n  }\n}\n\nScaleEnhancedHexagonLayer.layerName = 'ScaleEnhancedHexagonLayer';\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export { default as ThreeDBuildingLayer } from './3d-building-layer/3d-building-layer';
+export { default as DeckGLClusterLayer } from './cluster-layer/cluster-layer';
+export { default as EnhancedColumnLayer } from './column-layer/enhanced-column-layer';
+export { default as EnhancedGridLayer } from './grid-layer/enhanced-cpu-grid-layer';
+export { default as EnhancedHexagonLayer } from './hexagon-layer/enhanced-hexagon-layer';
+export { default as EnhancedLineLayer } from './line-layer/line-layer';
+export { default as SvgIconLayer } from './svg-icon-layer/svg-icon-layer';
+export { default as FilterArrowExtension } from './deckgl-extensions/filter-arrow-layer';
+export { default as RasterLayer } from './raster/raster-layer/raster-layer';
+export { default as RasterMeshLayer } from './raster/raster-mesh-layer/raster-mesh-layer';
+import * as _RasterWebGL from './raster/webgl';
+export { _RasterWebGL as RasterWebGL };
+export { default as WMSLayer } from './wms/wms-layer';
+export * from './layer-utils/shader-utils';
+export * from './layer-utils/aggregation-utils';
+export * from './3d-building-layer/types';
+export * from './3d-building-layer/3d-building-utils';
+export * from './globe';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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