@deck.gl/carto 9.0.17 → 9.0.18

package/dist/dist.dev.js

@@ -6993,7 +6993,7 @@ var __exports__ = (() => {
     CARTO_SOURCES: () => CARTO_SOURCES,
     CartoAPIError: () => CartoAPIError,
     H3TileLayer: () => H3TileLayer,
-    QuadbinHeatmapTileLayer: () => quadbin_heatmap_tile_layer_default,
+    HeatmapTileLayer: () => heatmap_tile_layer_default,
     QuadbinTileLayer: () => QuadbinTileLayer,
     RasterTileLayer: () => RasterTileLayer,
     SOURCE_DEFAULTS: () => SOURCE_DEFAULTS,
@@ -7811,318 +7811,13 @@ var __exports__ = (() => {
   H3TileLayer.layerName = "H3TileLayer";
   H3TileLayer.defaultProps = defaultProps2;
 
-  // src/layers/point-label-layer.ts
-  var import_core6 = __toESM(require_core(), 1);
+  // src/layers/heatmap-tile-layer.ts
+  var import_core8 = __toESM(require_core(), 1);
   var import_layers = __toESM(require_layers(), 1);
-  var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
-  var EnhancedTextBackgroundLayer = class extends import_layers._TextBackgroundLayer {
-    getShaders() {
-      const shaders = super.getShaders();
-      let vs = shaders.vs;
-      vs = vs.replaceAll("padding.", "_padding.");
-      vs = vs.replace(
-        "void main(void) {",
-        "void main(void) {\n  vec4 _padding = padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);"
-      );
-      return { ...shaders, vs };
-    }
-  };
-  EnhancedTextBackgroundLayer.layerName = "EnhancedTextBackgroundLayer";
-  var EnhancedTextLayer = class extends import_layers.TextLayer {
-    filterSubLayer({ layer, renderPass }) {
-      const background = layer.id.includes("primary-background");
-      if (renderPass === "collision") {
-        return background;
-      }
-      return !background;
-    }
-  };
-  EnhancedTextLayer.layerName = "EnhancedTextLayer";
-  var defaultProps3 = {
-    ...import_layers.TextLayer.defaultProps,
-    getRadius: { type: "accessor", value: 1 },
-    radiusScale: { type: "number", min: 0, value: 1 }
-  };
-  var PointLabelLayer = class extends import_core6.CompositeLayer {
-    calculatePixelOffset(secondary) {
-      const {
-        getTextAnchor: anchor,
-        getAlignmentBaseline: alignment,
-        getRadius,
-        getSecondaryText,
-        radiusScale,
-        secondarySizeScale,
-        sizeScale
-      } = this.props;
-      const xMult = anchor === "middle" ? 0 : anchor === "start" ? 1 : -1;
-      const yMult = alignment === "center" ? 0 : alignment === "bottom" ? 1 : -1;
-      const xPadding = sizeScale / 4;
-      const yPadding = sizeScale * (1 + 1 / 4);
-      const secondaryOffset = 0.6 * (1 - yMult) * sizeScale;
-      let yOffset = secondary ? secondaryOffset : 0;
-      if (anchor === "middle" && alignment === "top" && getSecondaryText) {
-        yOffset -= secondaryOffset;
-        yOffset -= secondarySizeScale;
-        yOffset += sizeScale;
-      }
-      const radiusPadding = 1 + 1 / 4;
-      return typeof getRadius === "function" ? (d, info) => {
-        const r = (info ? getRadius(d, info) : 1) * radiusScale * radiusPadding;
-        return [xMult * (r + xPadding), yMult * (r + yPadding) + yOffset];
-      } : [
-        xMult * (getRadius * radiusScale * radiusPadding + xPadding),
-        yMult * (getRadius * radiusScale * radiusPadding + yPadding) + yOffset
-      ];
-    }
-    calculateBackgroundPadding() {
-      const { getTextAnchor: anchor, getAlignmentBaseline: alignment, sizeScale } = this.props;
-      const paddingX = 12 * sizeScale;
-      const paddingY = 3 * sizeScale;
-      const backgroundPadding = [0, 0, 0, 0];
-      if (alignment === "top") {
-        backgroundPadding[TOP] = paddingY;
-      } else if (alignment === "bottom") {
-        backgroundPadding[BOTTOM] = paddingY;
-      } else {
-        backgroundPadding[TOP] = 0.5 * paddingY;
-        backgroundPadding[BOTTOM] = 0.5 * paddingY;
-      }
-      if (anchor === "start") {
-        backgroundPadding[LEFT] = paddingX;
-      } else if (anchor === "end") {
-        backgroundPadding[RIGHT] = paddingX;
-      } else {
-        backgroundPadding[LEFT] = 0.5 * paddingX;
-        backgroundPadding[RIGHT] = 0.5 * paddingX;
-      }
-      return backgroundPadding;
-    }
-    renderTextLayer(id4, { updateTriggers: updateTriggersOverride = {}, ...props }) {
-      const {
-        data,
-        characterSet,
-        fontFamily,
-        fontSettings,
-        fontWeight,
-        outlineColor,
-        outlineWidth,
-        sizeScale,
-        radiusScale,
-        getAlignmentBaseline,
-        getColor,
-        getPosition,
-        getTextAnchor,
-        updateTriggers
-      } = this.props;
-      return new EnhancedTextLayer(
-        this.getSubLayerProps({
-          id: id4,
-          data,
-          characterSet,
-          fontFamily,
-          fontSettings,
-          fontWeight,
-          outlineColor,
-          outlineWidth,
-          sizeScale,
-          getAlignmentBaseline,
-          getColor,
-          getPosition,
-          getTextAnchor,
-          updateTriggers: {
-            ...updateTriggers,
-            ...updateTriggersOverride,
-            getPixelOffset: [
-              updateTriggers.getRadius,
-              updateTriggers.getTextAnchor,
-              updateTriggers.getAlignmentBaseline,
-              radiusScale,
-              sizeScale
-            ]
-          }
-        }),
-        {
-          getSize: 1,
-          _subLayerProps: { background: { type: EnhancedTextBackgroundLayer } }
-        },
-        props
-      );
-    }
-    renderLayers() {
-      const {
-        getText,
-        getSecondaryColor,
-        getSecondaryText,
-        secondaryOutlineColor,
-        secondarySizeScale,
-        updateTriggers
-      } = this.props;
-      const getPixelOffset = this.calculatePixelOffset(false);
-      const backgroundPadding = this.calculateBackgroundPadding();
-      const out = [
-        this.renderTextLayer(`${updateTriggers.getText}-primary`, {
-          backgroundPadding,
-          getText,
-          getPixelOffset,
-          background: true
-        }),
-        Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
-          getText: getSecondaryText,
-          getPixelOffset: this.calculatePixelOffset(true),
-          getAlignmentBaseline: "top",
-          ...getSecondaryColor && { getColor: getSecondaryColor },
-          ...secondarySizeScale && { sizeScale: secondarySizeScale },
-          ...secondaryOutlineColor && { outlineColor: secondaryOutlineColor }
-        })
-      ];
-      return out;
-    }
-  };
-  PointLabelLayer.layerName = "PointLabelLayer";
-  PointLabelLayer.defaultProps = defaultProps3;
-
-  // src/layers/quadbin-tile-layer.ts
-  var import_core7 = __toESM(require_core(), 1);
-
-  // src/layers/quadbin-layer.ts
-  var import_geo_layers4 = __toESM(require_geo_layers(), 1);
-
-  // ../../node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
-  var PI = Math.PI;
-  var PI_4 = PI / 4;
-  var DEGREES_TO_RADIANS = PI / 180;
-  var RADIANS_TO_DEGREES = 180 / PI;
-  var TILE_SIZE = 512;
-  function worldToLngLat(xy) {
-    const [x, y] = xy;
-    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-    return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
-  }
-
-  // ../../node_modules/@math.gl/web-mercator/dist/get-bounds.js
-  var DEGREES_TO_RADIANS2 = Math.PI / 180;
-
-  // src/layers/quadbin-utils.ts
-  var TILE_SIZE2 = 512;
-  function quadbinToOffset(quadbin) {
-    const { x, y, z } = cellToTile(quadbin);
-    const scale = TILE_SIZE2 / (1 << z);
-    return [x * scale, TILE_SIZE2 - y * scale, scale];
-  }
-  function quadbinToWorldBounds(quadbin, coverage) {
-    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
-    return [
-      [xOffset, yOffset],
-      [xOffset + coverage * scale, yOffset - coverage * scale]
-    ];
-  }
-  function getQuadbinPolygon(quadbin, coverage = 1) {
-    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
-    const [w, n] = worldToLngLat(topLeft);
-    const [e, s] = worldToLngLat(bottomRight);
-    return [e, n, e, s, w, s, w, n, e, n];
-  }
-
-  // src/layers/quadbin-layer.ts
-  var defaultProps4 = {
-    getQuadbin: { type: "accessor", value: (d) => d.quadbin }
-  };
-  var QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
-    indexToBounds() {
-      const { data, extruded, getQuadbin } = this.props;
-      const coverage = extruded ? 0.99 : 1;
-      return {
-        data,
-        _normalize: false,
-        positionFormat: "XY",
-        getPolygon: (x, objectInfo) => getQuadbinPolygon(getQuadbin(x, objectInfo), coverage),
-        updateTriggers: { getPolygon: coverage }
-      };
-    }
-  };
-  QuadbinLayer.layerName = "QuadbinLayer";
-  QuadbinLayer.defaultProps = defaultProps4;
-
-  // src/layers/quadbin-tileset-2d.ts
-  var import_geo_layers5 = __toESM(require_geo_layers(), 1);
-  var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
-    getTileIndices(opts) {
-      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
-    }
-    getTileId({ q, i }) {
-      return i || bigIntToHex(q);
-    }
-    getTileMetadata({ q }) {
-      return super.getTileMetadata(cellToTile(q));
-    }
-    getTileZoom({ q }) {
-      return Number(getResolution2(q));
-    }
-    getParentIndex({ q }) {
-      return { q: cellToParent2(q) };
-    }
-  };
-
-  // src/layers/quadbin-tile-layer.ts
-  var renderSubLayers2 = (props) => {
-    const { data } = props;
-    if (!data || !data.length)
-      return null;
-    const isBigInt = typeof data[0].id === "bigint";
-    return new QuadbinLayer(props, {
-      getQuadbin: isBigInt ? (d) => d.id : (d) => hexToBigInt(d.id)
-    });
-  };
-  var defaultProps5 = {
-    data: TilejsonPropType,
-    tileSize: DEFAULT_TILE_SIZE
-  };
-  var QuadbinTileLayer = class extends import_core7.CompositeLayer {
-    getLoadOptions() {
-      const loadOptions = super.getLoadOptions() || {};
-      const tileJSON = this.props.data;
-      injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
-      return loadOptions;
-    }
-    renderLayers() {
-      const tileJSON = this.props.data;
-      if (!tileJSON)
-        return null;
-      const { tiles: data, maxresolution: maxZoom } = tileJSON;
-      return [
-        new SpatialIndexTileLayer(this.props, {
-          id: `quadbin-tile-layer-${this.props.id}`,
-          data,
-          TilesetClass: QuadbinTileset2D,
-          renderSubLayers: renderSubLayers2,
-          maxZoom,
-          loadOptions: this.getLoadOptions()
-        })
-      ];
-    }
-  };
-  QuadbinTileLayer.layerName = "QuadbinTileLayer";
-  QuadbinTileLayer.defaultProps = defaultProps5;
-
-  // src/layers/quadbin-heatmap-tile-layer.ts
-  var import_core9 = __toESM(require_core(), 1);
-  var import_layers2 = __toESM(require_layers(), 1);
-
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/math/random/random.js
-  var fs = `float random(vec3 scale, float seed) {
-return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
-}
-`;
-  var random = {
-    name: "random",
-    fs
-  };
 
   // src/layers/heatmap.ts
   var glsl = (s) => `${s}`;
-  var fs2 = glsl`\
+  var fs = glsl`\
 uniform heatmapUniforms {
   vec2 delta;
   float radiusPixels;
@@ -8133,11 +7828,10 @@ uniform heatmapUniforms {
   vec3 color4;
   vec3 color5;
   vec3 color6;
+  float intensity;
   float opacity;
 } heatmap;
 
-// Controls quality of heatmap, larger values increase quality at expense of performance
-const float SUPPORT = 8.0;
 const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
 
 vec3 colorGradient(float value) {
@@ -8156,20 +7850,18 @@ vec3 colorGradient(float value) {
   } else if (value < STOPS.w) {
     range = STOPS.zw;
     c1 = heatmap.color4; c2 = heatmap.color5;
-  } else if (value < 1.0 ) {
+  } else {
     range = vec2(STOPS.w, 1.0);
     c1 = heatmap.color5; c2 = heatmap.color6;
-  } else {
-    // Fade out to white
-    range = vec2(1.0, 10.0);
-    c1 = heatmap.color6; c2 = vec3(255.0);
   }
 
-  float f = (value - range.x) / (range.y - range.x);
+  float f = (clamp(value, 0.0, 1.0) - range.x) / (range.y - range.x);
   return mix(c1, c2, f) / 255.0;
 }
 
 const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+const float MAX_VAL = SHIFT.z * 255.0;
+const float SCALE = MAX_VAL / 8.0;
 vec4 pack(float value) {
   return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
 }
@@ -8181,16 +7873,15 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   bool firstPass = (heatmap.delta.y < 0.5);
   float accumulator = 0.0;
 
-  // Randomize the lookup values to hide the fixed number of samples
-  float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
+  // Controls quality of heatmap, larger values increase quality at expense of performance
+  float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);
 
   // Gaussian normalization parameters
-  const float sigma = SUPPORT / 3.0;
-  const float a = -0.5 / (sigma * sigma);
-  const float w0 = 0.3989422804014327 / sigma; // 1D normalization
-
+  float sigma = SUPPORT / 3.0;
+  float a = -0.5 / (sigma * sigma);
+  float w0 = 0.3989422804014327 / sigma; // 1D normalization
   for (float t = -SUPPORT; t <= SUPPORT; t++) {
-    vec2 percent = (t * heatmap.delta + offset - 0.5) / SUPPORT;
+    vec2 percent = (t * heatmap.delta - 0.5) / SUPPORT;
     vec2 delta = percent * heatmap.radiusPixels / texSize;
     vec4 offsetColor = texture(source, texCoord + delta);
 
@@ -8207,8 +7898,18 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     return pack(accumulator);
   }
 
+  // Undo scaling to obtain normalized density
+  float density = 10.0 * heatmap.intensity * accumulator / SCALE;
+ 
+  // Domain also in normalized density units
+  vec2 domain = heatmap.colorDomain;
+
   // Apply domain
-  float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+  float f = (density - domain[0]) / (domain[1] - domain[0]);
+
+  // sqrt/log scaling??
+  // float f = (log(density) - log(domain[0] + 1.0)) / (log(domain[1] + 1.0) - log(domain[0] + 1.0));
+  // f = sqrt(f);
 
   // Color map
   vec4 color = vec4(0.0);
@@ -8241,6 +7942,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       color4: { value: [0, 0, 0] },
       color5: { value: [0, 0, 0] },
       color6: { value: [0, 0, 0] },
+      intensity: { value: 1, min: 0.1, max: 10 },
       opacity: { value: 1, min: 0, max: 1 }
     },
     uniformTypes: {
@@ -8253,6 +7955,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       color4: "vec3<f32>",
       color5: "vec3<f32>",
       color6: "vec3<f32>",
+      intensity: "f32",
       opacity: "f32"
     },
     getUniforms: (opts) => {
@@ -8261,6 +7964,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
         colorRange = defaultColorRange,
         radiusPixels = 20,
         colorDomain = [0, 1],
+        intensity = 1,
         opacity = 1
       } = opts;
       const [color1, color2, color3, color4, color5, color6] = colorRange;
@@ -8274,11 +7978,11 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
         color6,
         radiusPixels,
         colorDomain,
+        intensity,
         opacity
       };
     },
-    dependencies: [random],
-    fs: fs2,
+    fs,
     passes: [
       { sampler: true, uniforms: { delta: [1, 0] } },
       { sampler: true, uniforms: { delta: [0, 1] } }
@@ -8286,7 +7990,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/layers/post-process-utils.ts
-  var import_core8 = __toESM(require_core(), 1);
+  var import_core6 = __toESM(require_core(), 1);
   var TEXTURE_PROPS = {
     format: "rgba8unorm",
     mipmaps: false,
@@ -8303,7 +8007,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     }
     return layer;
   }
-  var DrawCallbackLayer = class extends import_core8.Layer {
+  var DrawCallbackLayer = class extends import_core6.Layer {
     initializeState() {
       this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
     }
@@ -8335,7 +8039,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       initializeState(context) {
         super.initializeState(context);
         this._createTextures();
-        this.internalState.postProcess = new import_core8.PostProcessEffect(effect, this.props);
+        this.internalState.postProcess = new import_core6.PostProcessEffect(effect, this.props);
         this.internalState.postProcess.setup(context);
       }
       updateState(params) {
@@ -8399,55 +8103,211 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     }, _a.layerName = `PostProcess${BaseLayer.layerName}`, _a;
   }
 
-  // src/layers/quadbin-heatmap-tile-layer.ts
-  var RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
+  // src/layers/quadbin-tile-layer.ts
+  var import_core7 = __toESM(require_core(), 1);
+
+  // src/layers/quadbin-layer.ts
+  var import_geo_layers4 = __toESM(require_geo_layers(), 1);
+
+  // ../../node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
+  var PI = Math.PI;
+  var PI_4 = PI / 4;
+  var DEGREES_TO_RADIANS = PI / 180;
+  var RADIANS_TO_DEGREES = 180 / PI;
+  var TILE_SIZE = 512;
+  function worldToLngLat(xy) {
+    const [x, y] = xy;
+    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+    return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
+  }
+
+  // ../../node_modules/@math.gl/web-mercator/dist/get-bounds.js
+  var DEGREES_TO_RADIANS2 = Math.PI / 180;
+
+  // src/layers/quadbin-utils.ts
+  var TILE_SIZE2 = 512;
+  function quadbinToOffset(quadbin) {
+    const { x, y, z } = cellToTile(quadbin);
+    const scale = TILE_SIZE2 / (1 << z);
+    return [x * scale, TILE_SIZE2 - y * scale, scale];
+  }
+  function quadbinToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
+    return [
+      [xOffset, yOffset],
+      [xOffset + coverage * scale, yOffset - coverage * scale]
+    ];
+  }
+  function getQuadbinPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
+    const [w, n] = worldToLngLat(topLeft);
+    const [e, s] = worldToLngLat(bottomRight);
+    return [e, n, e, s, w, s, w, n, e, n];
+  }
+
+  // src/layers/quadbin-layer.ts
+  var defaultProps3 = {
+    getQuadbin: { type: "accessor", value: (d) => d.quadbin }
+  };
+  var QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
+    indexToBounds() {
+      const { data, extruded, getQuadbin } = this.props;
+      const coverage = extruded ? 0.99 : 1;
+      return {
+        data,
+        _normalize: false,
+        positionFormat: "XY",
+        getPolygon: (x, objectInfo) => getQuadbinPolygon(getQuadbin(x, objectInfo), coverage),
+        updateTriggers: { getPolygon: coverage }
+      };
+    }
+  };
+  QuadbinLayer.layerName = "QuadbinLayer";
+  QuadbinLayer.defaultProps = defaultProps3;
+
+  // src/layers/quadbin-tileset-2d.ts
+  var import_geo_layers5 = __toESM(require_geo_layers(), 1);
+  var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
+    getTileIndices(opts) {
+      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
+    }
+    getTileId({ q, i }) {
+      return i || bigIntToHex(q);
+    }
+    getTileMetadata({ q }) {
+      return super.getTileMetadata(cellToTile(q));
+    }
+    getTileZoom({ q }) {
+      return Number(getResolution2(q));
+    }
+    getParentIndex({ q }) {
+      return { q: cellToParent2(q) };
+    }
+  };
+
+  // src/layers/quadbin-tile-layer.ts
+  var renderSubLayers2 = (props) => {
+    const { data } = props;
+    if (!data || !data.length)
+      return null;
+    const isBigInt = typeof data[0].id === "bigint";
+    return new QuadbinLayer(props, {
+      getQuadbin: isBigInt ? (d) => d.id : (d) => hexToBigInt(d.id)
+    });
+  };
+  var defaultProps4 = {
+    data: TilejsonPropType,
+    tileSize: DEFAULT_TILE_SIZE
+  };
+  var QuadbinTileLayer = class extends import_core7.CompositeLayer {
+    getLoadOptions() {
+      const loadOptions = super.getLoadOptions() || {};
+      const tileJSON = this.props.data;
+      injectAccessToken(loadOptions, tileJSON.accessToken);
+      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
+      return loadOptions;
+    }
+    renderLayers() {
+      const tileJSON = this.props.data;
+      if (!tileJSON)
+        return null;
+      const { tiles: data, maxresolution: maxZoom } = tileJSON;
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `quadbin-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: QuadbinTileset2D,
+          renderSubLayers: renderSubLayers2,
+          maxZoom,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
+    }
+  };
+  QuadbinTileLayer.layerName = "QuadbinTileLayer";
+  QuadbinTileLayer.defaultProps = defaultProps4;
+
+  // src/layers/heatmap-tile-layer.ts
+  function unitDensityForCell(cell) {
+    const cellResolution = Number(getResolution2(cell));
+    return Math.pow(4, cellResolution);
+  }
+  var RTTSolidPolygonLayer = class extends RTTModifier(import_layers.SolidPolygonLayer) {
     getShaders(type) {
       const shaders = super.getShaders(type);
       shaders.inject = {
-        "vs:#decl": "uniform float cellResolution;",
-        "vs:DECKGL_FILTER_COLOR": `
-  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
-  float value = 255.0 * dot(SHIFT, color.rgb);
+        "vs:#decl": `
+uniform float densityFactor;
+`,
+        "vs:#main-end": `
+      // Value from getWeight accessor
+  float weight = elevations;
 
   // Keep "power" delivered to screen constant when tiles update
-  float relativeZoom = log2(project_uScale) - cellResolution + 3.5; // range 0-1
-  float relativeArea = pow(2.0, -2.0 * relativeZoom); // range 0.25-1
-  value *= relativeArea;
+  // by outputting normalized density 
+  weight *= densityFactor;
 
   // Pack float into 3 channels to pass to heatmap shader
-  color = vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
-      `
+  // SCALE value important, as we don't want to saturate
+  // but also want enough definition to avoid banding
+  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+  const float MAX_VAL = SHIFT.z * 255.0;
+  const float SCALE = MAX_VAL / 8.0;
+  weight *= SCALE;
+  weight = clamp(weight, 0.0, MAX_VAL);
+  vColor = vec4(mod(vec3(weight, floor(weight / SHIFT.yz)), 256.0), 255.0) / 255.0;
+`
       };
       return shaders;
     }
     draw(opts) {
-      const cell0 = this.props.data[0];
-      const cellResolution = Number(getResolution2(cell0.id));
+      const cell = this.props.data[0];
+      const maxDensity = this.props.elevationScale;
+      const densityFactor = unitDensityForCell(cell.id) / maxDensity;
       for (const model of this.state.models) {
-        model.setUniforms({ cellResolution });
+        model.setUniforms({ densityFactor });
       }
       super.draw(opts);
     }
   };
   RTTSolidPolygonLayer.layerName = "RTTSolidPolygonLayer";
   var PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
-  function encodeWeight(w) {
-    return [w % 256, Math.floor(w / 256), Math.floor(w / (256 * 256))];
-  }
-  var defaultProps6 = {
+  var defaultProps5 = {
     data: TilejsonPropType,
-    getWeight: { type: "accessor", value: 1 }
+    getWeight: { type: "accessor", value: 1 },
+    onMaxDensityChange: { type: "function", optional: true, value: null },
+    colorDomain: { type: "array", value: [0, 1] },
+    intensity: { type: "number", value: 1 },
+    radiusPixels: { type: "number", min: 0, max: 100, value: 20 }
   };
-  var QuadbinHeatmapTileLayer = class extends import_core9.CompositeLayer {
+  var HeatmapTileLayer = class extends import_core8.CompositeLayer {
+    initializeState() {
+      this.state = {
+        isLoaded: false,
+        tiles: /* @__PURE__ */ new Set(),
+        viewportChanged: false
+      };
+    }
+    shouldUpdateState({ changeFlags }) {
+      const { viewportChanged } = changeFlags;
+      this.setState({ viewportChanged });
+      return changeFlags.somethingChanged;
+    }
     renderLayers() {
       const {
         data,
         getWeight,
         colorDomain,
         colorRange,
+        intensity,
         radiusPixels,
         _subLayerProps,
         updateTriggers,
+        onMaxDensityChange,
+        onViewportLoad,
+        onTileLoad,
+        onTileUnload,
         ...tileLayerProps
       } = this.props;
       const subLayerProps = {
@@ -8463,27 +8323,245 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
           }
         }
       };
-      const getFillColor = typeof getWeight === "function" ? (d, info) => encodeWeight(getWeight(d, info)) : encodeWeight(getWeight);
+      let tileZ = 0;
+      let maxDensity = 0;
+      const tiles2 = [...this.state.tiles].filter((t) => t.isVisible && t.data);
+      for (const tile of tiles2) {
+        const cell = tile.data[0];
+        const unitDensity = unitDensityForCell(cell.id);
+        maxDensity = Math.max(tile.userData.maxWeight * unitDensity, maxDensity);
+        tileZ = Math.max(tile.zoom, tileZ);
+      }
+      const overzoom = this.context.viewport.zoom - tileZ;
+      const estimatedMaxDensity = maxDensity * Math.pow(2, overzoom);
+      maxDensity = estimatedMaxDensity;
+      if (typeof onMaxDensityChange === "function") {
+        onMaxDensityChange(maxDensity);
+      }
       return new PostProcessQuadbinTileLayer(
         tileLayerProps,
         this.getSubLayerProps({
           id: "heatmap",
           data,
-          getFillColor,
+          getFillColor: 0,
+          getElevation: getWeight,
+          elevationScale: maxDensity,
           colorDomain,
           colorRange,
           radiusPixels,
+          intensity,
           _subLayerProps: subLayerProps,
+          refinementStrategy: "no-overlap",
+          extruded: false,
+          stroked: false,
           updateTriggers: {
-            getPosition: updateTriggers.getWeight
-          }
+            getElevation: updateTriggers.getWeight
+          },
+          onViewportLoad: (tiles3) => {
+            this.setState({ isLoaded: true });
+            if (typeof onViewportLoad === "function") {
+              onViewportLoad(tiles3);
+            }
+          },
+          onTileLoad: (tile) => {
+            let maxWeight = -Infinity;
+            if (typeof getWeight !== "function") {
+              maxWeight = getWeight;
+            } else if (tile.content) {
+              for (const d of tile.content) {
+                maxWeight = Math.max(getWeight(d, {}), maxWeight);
+              }
+            }
+            tile.userData = { maxWeight };
+            this.state.tiles.add(tile);
+            if (typeof onTileLoad === "function") {
+              onTileLoad(tile);
+            }
+          },
+          onTileUnload: (tile) => {
+            this.state.tiles.delete(tile);
+            if (typeof onTileUnload === "function") {
+              onTileUnload(tile);
+            }
+          },
+          transitions: { elevationScale: { type: "spring", stiffness: 0.3, damping: 0.5 } }
         })
       );
     }
   };
-  QuadbinHeatmapTileLayer.layerName = "QuadbinHeatmapTileLayer";
-  QuadbinHeatmapTileLayer.defaultProps = defaultProps6;
-  var quadbin_heatmap_tile_layer_default = QuadbinHeatmapTileLayer;
+  HeatmapTileLayer.layerName = "HeatmapTileLayer";
+  HeatmapTileLayer.defaultProps = defaultProps5;
+  var heatmap_tile_layer_default = HeatmapTileLayer;
+
+  // src/layers/point-label-layer.ts
+  var import_core9 = __toESM(require_core(), 1);
+  var import_layers2 = __toESM(require_layers(), 1);
+  var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
+  var EnhancedTextBackgroundLayer = class extends import_layers2._TextBackgroundLayer {
+    getShaders() {
+      const shaders = super.getShaders();
+      let vs = shaders.vs;
+      vs = vs.replaceAll("padding.", "_padding.");
+      vs = vs.replace(
+        "void main(void) {",
+        "void main(void) {\n  vec4 _padding = padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);"
+      );
+      return { ...shaders, vs };
+    }
+  };
+  EnhancedTextBackgroundLayer.layerName = "EnhancedTextBackgroundLayer";
+  var EnhancedTextLayer = class extends import_layers2.TextLayer {
+    filterSubLayer({ layer, renderPass }) {
+      const background = layer.id.includes("primary-background");
+      if (renderPass === "collision") {
+        return background;
+      }
+      return !background;
+    }
+  };
+  EnhancedTextLayer.layerName = "EnhancedTextLayer";
+  var defaultProps6 = {
+    ...import_layers2.TextLayer.defaultProps,
+    getRadius: { type: "accessor", value: 1 },
+    radiusScale: { type: "number", min: 0, value: 1 }
+  };
+  var PointLabelLayer = class extends import_core9.CompositeLayer {
+    calculatePixelOffset(secondary) {
+      const {
+        getTextAnchor: anchor,
+        getAlignmentBaseline: alignment,
+        getRadius,
+        getSecondaryText,
+        radiusScale,
+        secondarySizeScale,
+        sizeScale
+      } = this.props;
+      const xMult = anchor === "middle" ? 0 : anchor === "start" ? 1 : -1;
+      const yMult = alignment === "center" ? 0 : alignment === "bottom" ? 1 : -1;
+      const xPadding = sizeScale / 4;
+      const yPadding = sizeScale * (1 + 1 / 4);
+      const secondaryOffset = 0.6 * (1 - yMult) * sizeScale;
+      let yOffset = secondary ? secondaryOffset : 0;
+      if (anchor === "middle" && alignment === "top" && getSecondaryText) {
+        yOffset -= secondaryOffset;
+        yOffset -= secondarySizeScale;
+        yOffset += sizeScale;
+      }
+      const radiusPadding = 1 + 1 / 4;
+      return typeof getRadius === "function" ? (d, info) => {
+        const r = (info ? getRadius(d, info) : 1) * radiusScale * radiusPadding;
+        return [xMult * (r + xPadding), yMult * (r + yPadding) + yOffset];
+      } : [
+        xMult * (getRadius * radiusScale * radiusPadding + xPadding),
+        yMult * (getRadius * radiusScale * radiusPadding + yPadding) + yOffset
+      ];
+    }
+    calculateBackgroundPadding() {
+      const { getTextAnchor: anchor, getAlignmentBaseline: alignment, sizeScale } = this.props;
+      const paddingX = 12 * sizeScale;
+      const paddingY = 3 * sizeScale;
+      const backgroundPadding = [0, 0, 0, 0];
+      if (alignment === "top") {
+        backgroundPadding[TOP] = paddingY;
+      } else if (alignment === "bottom") {
+        backgroundPadding[BOTTOM] = paddingY;
+      } else {
+        backgroundPadding[TOP] = 0.5 * paddingY;
+        backgroundPadding[BOTTOM] = 0.5 * paddingY;
+      }
+      if (anchor === "start") {
+        backgroundPadding[LEFT] = paddingX;
+      } else if (anchor === "end") {
+        backgroundPadding[RIGHT] = paddingX;
+      } else {
+        backgroundPadding[LEFT] = 0.5 * paddingX;
+        backgroundPadding[RIGHT] = 0.5 * paddingX;
+      }
+      return backgroundPadding;
+    }
+    renderTextLayer(id4, { updateTriggers: updateTriggersOverride = {}, ...props }) {
+      const {
+        data,
+        characterSet,
+        fontFamily,
+        fontSettings,
+        fontWeight,
+        outlineColor,
+        outlineWidth,
+        sizeScale,
+        radiusScale,
+        getAlignmentBaseline,
+        getColor,
+        getPosition,
+        getTextAnchor,
+        updateTriggers
+      } = this.props;
+      return new EnhancedTextLayer(
+        this.getSubLayerProps({
+          id: id4,
+          data,
+          characterSet,
+          fontFamily,
+          fontSettings,
+          fontWeight,
+          outlineColor,
+          outlineWidth,
+          sizeScale,
+          getAlignmentBaseline,
+          getColor,
+          getPosition,
+          getTextAnchor,
+          updateTriggers: {
+            ...updateTriggers,
+            ...updateTriggersOverride,
+            getPixelOffset: [
+              updateTriggers.getRadius,
+              updateTriggers.getTextAnchor,
+              updateTriggers.getAlignmentBaseline,
+              radiusScale,
+              sizeScale
+            ]
+          }
+        }),
+        {
+          getSize: 1,
+          _subLayerProps: { background: { type: EnhancedTextBackgroundLayer } }
+        },
+        props
+      );
+    }
+    renderLayers() {
+      const {
+        getText,
+        getSecondaryColor,
+        getSecondaryText,
+        secondaryOutlineColor,
+        secondarySizeScale,
+        updateTriggers
+      } = this.props;
+      const getPixelOffset = this.calculatePixelOffset(false);
+      const backgroundPadding = this.calculateBackgroundPadding();
+      const out = [
+        this.renderTextLayer(`${updateTriggers.getText}-primary`, {
+          backgroundPadding,
+          getText,
+          getPixelOffset,
+          background: true
+        }),
+        Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
+          getText: getSecondaryText,
+          getPixelOffset: this.calculatePixelOffset(true),
+          getAlignmentBaseline: "top",
+          ...getSecondaryColor && { getColor: getSecondaryColor },
+          ...secondarySizeScale && { sizeScale: secondarySizeScale },
+          ...secondaryOutlineColor && { outlineColor: secondaryOutlineColor }
+        })
+      ];
+      return out;
+    }
+  };
+  PointLabelLayer.layerName = "PointLabelLayer";
+  PointLabelLayer.defaultProps = defaultProps6;
 
   // src/layers/raster-tile-layer.ts
   var import_core11 = __toESM(require_core(), 1);
@@ -8831,170 +8909,6 @@ void main(void) {
   var import_extensions = __toESM(require_extensions(), 1);
   var import_geo_layers6 = __toESM(require_geo_layers(), 1);
   var import_layers4 = __toESM(require_layers(), 1);
-
-  // ../../node_modules/@loaders.gl/gis/dist/lib/binary-features/binary-to-geojson.js
-  function binaryToGeojson(data, options) {
-    const globalFeatureId = options?.globalFeatureId;
-    if (globalFeatureId !== void 0) {
-      return getSingleFeature(data, globalFeatureId);
-    }
-    return parseFeatures(data, options?.type);
-  }
-  function getSingleFeature(data, globalFeatureId) {
-    const dataArray = normalizeInput(data);
-    for (const data2 of dataArray) {
-      let lastIndex = 0;
-      let lastValue = data2.featureIds.value[0];
-      for (let i = 0; i < data2.featureIds.value.length; i++) {
-        const currValue = data2.featureIds.value[i];
-        if (currValue === lastValue) {
-          continue;
-        }
-        if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
-          return parseFeature(data2, lastIndex, i);
-        }
-        lastIndex = i;
-        lastValue = currValue;
-      }
-      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
-        return parseFeature(data2, lastIndex, data2.featureIds.value.length);
-      }
-    }
-    throw new Error(`featureId:${globalFeatureId} not found`);
-  }
-  function parseFeatures(data, type) {
-    const dataArray = normalizeInput(data, type);
-    return parseFeatureCollection(dataArray);
-  }
-  function binaryToGeometry(data, startIndex, endIndex) {
-    switch (data.type) {
-      case "Point":
-        return pointToGeoJson(data, startIndex, endIndex);
-      case "LineString":
-        return lineStringToGeoJson(data, startIndex, endIndex);
-      case "Polygon":
-        return polygonToGeoJson(data, startIndex, endIndex);
-      default:
-        const unexpectedInput = data;
-        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
-    }
-  }
-  function normalizeInput(data, type) {
-    const features = [];
-    if (data.points) {
-      data.points.type = "Point";
-      features.push(data.points);
-    }
-    if (data.lines) {
-      data.lines.type = "LineString";
-      features.push(data.lines);
-    }
-    if (data.polygons) {
-      data.polygons.type = "Polygon";
-      features.push(data.polygons);
-    }
-    return features;
-  }
-  function parseFeatureCollection(dataArray) {
-    const features = [];
-    for (const data of dataArray) {
-      if (data.featureIds.value.length === 0) {
-        continue;
-      }
-      let lastIndex = 0;
-      let lastValue = data.featureIds.value[0];
-      for (let i = 0; i < data.featureIds.value.length; i++) {
-        const currValue = data.featureIds.value[i];
-        if (currValue === lastValue) {
-          continue;
-        }
-        features.push(parseFeature(data, lastIndex, i));
-        lastIndex = i;
-        lastValue = currValue;
-      }
-      features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
-    }
-    return features;
-  }
-  function parseFeature(data, startIndex, endIndex) {
-    const geometry = binaryToGeometry(data, startIndex, endIndex);
-    const properties = parseProperties(data, startIndex, endIndex);
-    const fields = parseFields(data, startIndex, endIndex);
-    return { type: "Feature", geometry, properties, ...fields };
-  }
-  function parseFields(data, startIndex = 0, endIndex) {
-    return data.fields && data.fields[data.featureIds.value[startIndex]];
-  }
-  function parseProperties(data, startIndex = 0, endIndex) {
-    const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
-    for (const key in data.numericProps) {
-      properties[key] = data.numericProps[key].value[startIndex];
-    }
-    return properties;
-  }
-  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const { positions } = data;
-    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const multi = polygonIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = [];
-      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-        const startRingIndex = primitivePolygonIndices[i];
-        const endRingIndex = primitivePolygonIndices[i + 1];
-        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-        coordinates2.push(ringCoordinates);
-      }
-      return { type: "Polygon", coordinates: coordinates2 };
-    }
-    const coordinates = [];
-    for (let i = 0; i < polygonIndices.length - 1; i++) {
-      const startPolygonIndex = polygonIndices[i];
-      const endPolygonIndex = polygonIndices[i + 1];
-      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
-      coordinates.push(polygonCoordinates);
-    }
-    return { type: "MultiPolygon", coordinates };
-  }
-  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const { positions } = data;
-    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const multi = pathIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-      return { type: "LineString", coordinates: coordinates2 };
-    }
-    const coordinates = [];
-    for (let i = 0; i < pathIndices.length - 1; i++) {
-      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-      coordinates.push(ringCoordinates);
-    }
-    return { type: "MultiLineString", coordinates };
-  }
-  function pointToGeoJson(data, startIndex, endIndex) {
-    const { positions } = data;
-    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-    const multi = coordinates.length > 1;
-    if (multi) {
-      return { type: "MultiPoint", coordinates };
-    }
-    return { type: "Point", coordinates: coordinates[0] };
-  }
-  function ringToGeoJson(positions, startIndex, endIndex) {
-    startIndex = startIndex || 0;
-    endIndex = endIndex || positions.value.length / positions.size;
-    const ringCoordinates = [];
-    for (let j = startIndex; j < endIndex; j++) {
-      const coord = Array();
-      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-        coord.push(Number(positions.value[k]));
-      }
-      ringCoordinates.push(coord);
-    }
-    return ringCoordinates;
-  }
-
-  // src/layers/vector-tile-layer.ts
   (0, import_core12.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
   var defaultProps9 = {
     ...import_geo_layers6.MVTLayer.defaultProps,
@@ -9073,15 +8987,10 @@ void main(void) {
       const subLayer = new import_layers4.GeoJsonLayer(subLayerProps);
       return subLayer;
     }
-    getPickingInfo(params) {
-      const info = super.getPickingInfo(params);
-      if (this.state.binary && info.index !== -1) {
-        const { data } = params.sourceLayer.props;
-        info.object = binaryToGeojson(data, {
-          globalFeatureId: info.index
-        });
-      }
-      return info;
+    _isWGS84() {
+      if (this.state.mvt)
+        return super._isWGS84();
+      return true;
     }
   };
   VectorTileLayer.layerName = "VectorTileLayer";
@@ -14599,9 +14508,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/index.ts
   var CARTO_LAYERS = {
     H3TileLayer,
+    HeatmapTileLayer: heatmap_tile_layer_default,
     _PointLabelLayer: PointLabelLayer,
     QuadbinTileLayer,
-    QuadbinHeatmapTileLayer: quadbin_heatmap_tile_layer_default,
     RasterTileLayer,
     VectorTileLayer
   };