@deck.gl/carto 9.0.16 → 9.0.18

package/dist/index.cjs

@@ -31,7 +31,7 @@ __export(dist_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,
@@ -273,7 +273,7 @@ var isObject = (x) => x !== null && typeof x === "object";
 var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION = true ? "9.0.16" : "latest";
+var VERSION = true ? "9.0.18" : "latest";
 var id = "cartoRasterTile";
 var DEFAULT_OPTIONS = {
   cartoRasterTile: {
@@ -544,7 +544,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION2 = true ? "9.0.16" : "latest";
+var VERSION2 = true ? "9.0.18" : "latest";
 var id2 = "cartoSpatialTile";
 var DEFAULT_OPTIONS2 = {
   cartoSpatialTile: {
@@ -775,280 +775,12 @@ var H3TileLayer = _H3TileLayer;
   _H3TileLayer.defaultProps = defaultProps2;
 })();
 
-// dist/layers/point-label-layer.js
-var import_core6 = require("@deck.gl/core");
-var import_layers = require("@deck.gl/layers");
-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 };
-  }
-};
-var EnhancedTextBackgroundLayer = _EnhancedTextBackgroundLayer;
-(() => {
-  _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;
-  }
-};
-var EnhancedTextLayer = _EnhancedTextLayer;
-(() => {
-  _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;
-  }
-};
-var PointLabelLayer = _PointLabelLayer;
-(() => {
-  _PointLabelLayer.layerName = "PointLabelLayer";
-})();
-(() => {
-  _PointLabelLayer.defaultProps = defaultProps3;
-})();
-
-// dist/layers/quadbin-tile-layer.js
-var import_core7 = require("@deck.gl/core");
-
-// dist/layers/quadbin-layer.js
-var import_geo_layers4 = require("@deck.gl/geo-layers");
-
-// dist/layers/quadbin-utils.js
-var import_web_mercator = require("@math.gl/web-mercator");
-var import_quadbin2 = require("quadbin");
-var TILE_SIZE = 512;
-function quadbinToOffset(quadbin) {
-  const { x, y, z } = (0, import_quadbin2.cellToTile)(quadbin);
-  const scale = TILE_SIZE / (1 << z);
-  return [x * scale, TILE_SIZE - 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] = (0, import_web_mercator.worldToLngLat)(topLeft);
-  const [e, s] = (0, import_web_mercator.worldToLngLat)(bottomRight);
-  return [e, n, e, s, w, s, w, n, e, n];
-}
-
-// dist/layers/quadbin-layer.js
-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 }
-    };
-  }
-};
-var QuadbinLayer = _QuadbinLayer;
-(() => {
-  _QuadbinLayer.layerName = "QuadbinLayer";
-})();
-(() => {
-  _QuadbinLayer.defaultProps = defaultProps4;
-})();
-
-// dist/layers/quadbin-tileset-2d.js
-var import_geo_layers5 = require("@deck.gl/geo-layers");
-var import_quadbin3 = require("quadbin");
-var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
-  getTileIndices(opts) {
-    return super.getTileIndices(opts).map(import_quadbin3.tileToCell).map((q) => ({ q, i: (0, import_quadbin3.bigIntToHex)(q) }));
-  }
-  getTileId({ q, i }) {
-    return i || (0, import_quadbin3.bigIntToHex)(q);
-  }
-  getTileMetadata({ q }) {
-    return super.getTileMetadata((0, import_quadbin3.cellToTile)(q));
-  }
-  getTileZoom({ q }) {
-    return Number((0, import_quadbin3.getResolution)(q));
-  }
-  getParentIndex({ q }) {
-    return { q: (0, import_quadbin3.cellToParent)(q) };
-  }
-};
-
-// dist/layers/quadbin-tile-layer.js
-var import_quadbin4 = require("quadbin");
-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) => (0, import_quadbin4.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()
-      })
-    ];
-  }
-};
-var QuadbinTileLayer = _QuadbinTileLayer;
-(() => {
-  _QuadbinTileLayer.layerName = "QuadbinTileLayer";
-})();
-(() => {
-  _QuadbinTileLayer.defaultProps = defaultProps5;
-})();
-
-// dist/layers/quadbin-heatmap-tile-layer.js
+// dist/layers/heatmap-tile-layer.js
 var import_quadbin5 = require("quadbin");
-var import_core9 = require("@deck.gl/core");
-var import_layers2 = require("@deck.gl/layers");
+var import_core8 = require("@deck.gl/core");
+var import_layers = require("@deck.gl/layers");
 
 // dist/layers/heatmap.js
-var import_shadertools = require("@luma.gl/shadertools");
 var fs = `uniform heatmapUniforms {
 vec2 delta;
 float radiusPixels;
@@ -1059,9 +791,9 @@ vec3 color3;
 vec3 color4;
 vec3 color5;
 vec3 color6;
+float intensity;
 float opacity;
 } heatmap;
-const float SUPPORT = 8.0;
 const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
 vec3 colorGradient(float value) {
 vec3 c1;
@@ -1079,17 +811,16 @@ c1 = heatmap.color3; c2 = heatmap.color4;
 } 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 {
-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;
 }
@@ -1099,12 +830,12 @@ return 255.0 * dot(color, SHIFT);
 vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 bool firstPass = (heatmap.delta.y < 0.5);
 float accumulator = 0.0;
-float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
-const float sigma = SUPPORT / 3.0;
-const float a = -0.5 / (sigma * sigma);
-const float w0 = 0.3989422804014327 / sigma;
+float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);
+float sigma = SUPPORT / 3.0;
+float a = -0.5 / (sigma * sigma);
+float w0 = 0.3989422804014327 / sigma;
 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);
 float value = unpack(offsetColor.rgb);
@@ -1114,7 +845,9 @@ accumulator += value * weight;
 if (firstPass) {
 return pack(accumulator);
 }
-float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+float density = 10.0 * heatmap.intensity * accumulator / SCALE;
+vec2 domain = heatmap.colorDomain;
+float f = (density - domain[0]) / (domain[1] - domain[0]);
 vec4 color = vec4(0.0);
 color.rgb = colorGradient(f);
 color.a = smoothstep(0.0, 0.1, f);
@@ -1143,6 +876,7 @@ var heatmap = {
     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: {
@@ -1155,10 +889,11 @@ var heatmap = {
     color4: "vec3<f32>",
     color5: "vec3<f32>",
     color6: "vec3<f32>",
+    intensity: "f32",
     opacity: "f32"
   },
   getUniforms: (opts) => {
-    const { delta = [1, 0], colorRange = defaultColorRange, radiusPixels = 20, colorDomain = [0, 1], opacity = 1 } = opts;
+    const { delta = [1, 0], colorRange = defaultColorRange, radiusPixels = 20, colorDomain = [0, 1], intensity = 1, opacity = 1 } = opts;
     const [color1, color2, color3, color4, color5, color6] = colorRange;
     return {
       delta,
@@ -1170,10 +905,10 @@ var heatmap = {
       color6,
       radiusPixels,
       colorDomain,
+      intensity,
       opacity
     };
   },
-  dependencies: [import_shadertools.random],
   fs,
   passes: [
     { sampler: true, uniforms: { delta: [1, 0] } },
@@ -1182,7 +917,7 @@ var heatmap = {
 };
 
 // dist/layers/post-process-utils.js
-var import_core8 = require("@deck.gl/core");
+var import_core6 = require("@deck.gl/core");
 var TEXTURE_PROPS = {
   format: "rgba8unorm",
   mipmaps: false,
@@ -1199,7 +934,7 @@ function getPostProcessLayer(layer) {
   }
   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}`;
   }
@@ -1236,7 +971,7 @@ function PostProcessModifier(BaseLayer, effect) {
     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) {
@@ -1302,32 +1037,168 @@ function PostProcessModifier(BaseLayer, effect) {
   })(), _a;
 }
 
-// dist/layers/quadbin-heatmap-tile-layer.js
-var _RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
+// dist/layers/quadbin-tile-layer.js
+var import_core7 = require("@deck.gl/core");
+
+// dist/layers/quadbin-layer.js
+var import_geo_layers4 = require("@deck.gl/geo-layers");
+
+// dist/layers/quadbin-utils.js
+var import_web_mercator = require("@math.gl/web-mercator");
+var import_quadbin2 = require("quadbin");
+var TILE_SIZE = 512;
+function quadbinToOffset(quadbin) {
+  const { x, y, z } = (0, import_quadbin2.cellToTile)(quadbin);
+  const scale = TILE_SIZE / (1 << z);
+  return [x * scale, TILE_SIZE - 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] = (0, import_web_mercator.worldToLngLat)(topLeft);
+  const [e, s] = (0, import_web_mercator.worldToLngLat)(bottomRight);
+  return [e, n, e, s, w, s, w, n, e, n];
+}
+
+// dist/layers/quadbin-layer.js
+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 }
+    };
+  }
+};
+var QuadbinLayer = _QuadbinLayer;
+(() => {
+  _QuadbinLayer.layerName = "QuadbinLayer";
+})();
+(() => {
+  _QuadbinLayer.defaultProps = defaultProps3;
+})();
+
+// dist/layers/quadbin-tileset-2d.js
+var import_geo_layers5 = require("@deck.gl/geo-layers");
+var import_quadbin3 = require("quadbin");
+var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
+  getTileIndices(opts) {
+    return super.getTileIndices(opts).map(import_quadbin3.tileToCell).map((q) => ({ q, i: (0, import_quadbin3.bigIntToHex)(q) }));
+  }
+  getTileId({ q, i }) {
+    return i || (0, import_quadbin3.bigIntToHex)(q);
+  }
+  getTileMetadata({ q }) {
+    return super.getTileMetadata((0, import_quadbin3.cellToTile)(q));
+  }
+  getTileZoom({ q }) {
+    return Number((0, import_quadbin3.getResolution)(q));
+  }
+  getParentIndex({ q }) {
+    return { q: (0, import_quadbin3.cellToParent)(q) };
+  }
+};
+
+// dist/layers/quadbin-tile-layer.js
+var import_quadbin4 = require("quadbin");
+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) => (0, import_quadbin4.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()
+      })
+    ];
+  }
+};
+var QuadbinTileLayer = _QuadbinTileLayer;
+(() => {
+  _QuadbinTileLayer.layerName = "QuadbinTileLayer";
+})();
+(() => {
+  _QuadbinTileLayer.defaultProps = defaultProps4;
+})();
+
+// dist/layers/heatmap-tile-layer.js
+function unitDensityForCell(cell) {
+  const cellResolution = Number((0, import_quadbin5.getResolution)(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((0, import_quadbin5.getResolution)(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);
   }
@@ -1337,17 +1208,30 @@ var RTTSolidPolygonLayer = _RTTSolidPolygonLayer;
   _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() {
     var _a, _b, _c;
-    const { getWeight, colorDomain, colorRange, radiusPixels, _subLayerProps } = this.props;
+    const { data, getWeight, colorDomain, colorRange, intensity, radiusPixels, _subLayerProps, updateTriggers, onMaxDensityChange, onViewportLoad, onTileLoad, onTileUnload, ...tileLayerProps } = this.props;
     const subLayerProps = {
       ..._subLayerProps,
       cell: {
@@ -1361,29 +1245,221 @@ var _QuadbinHeatmapTileLayer = class extends import_core9.CompositeLayer {
         }
       }
     };
-    const getFillColor = typeof getWeight === "function" ? (d, info) => encodeWeight(getWeight(d, info)) : encodeWeight(getWeight);
-    return new PostProcessQuadbinTileLayer(this.getSubLayerProps({
+    let tileZ = 0;
+    let maxDensity = 0;
+    const tiles = [...this.state.tiles].filter((t) => t.isVisible && t.data);
+    for (const tile of tiles) {
+      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: this.props.data,
-      getFillColor,
+      data,
+      getFillColor: 0,
+      getElevation: getWeight,
+      elevationScale: maxDensity,
       colorDomain,
       colorRange,
       radiusPixels,
+      intensity,
       _subLayerProps: subLayerProps,
+      refinementStrategy: "no-overlap",
+      extruded: false,
+      stroked: false,
       updateTriggers: {
-        getPosition: this.props.updateTriggers.getWeight
-      }
+        getElevation: updateTriggers.getWeight
+      },
+      onViewportLoad: (tiles2) => {
+        this.setState({ isLoaded: true });
+        if (typeof onViewportLoad === "function") {
+          onViewportLoad(tiles2);
+        }
+      },
+      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 } }
     }));
   }
 };
-var QuadbinHeatmapTileLayer = _QuadbinHeatmapTileLayer;
+var HeatmapTileLayer = _HeatmapTileLayer;
+(() => {
+  _HeatmapTileLayer.layerName = "HeatmapTileLayer";
+})();
+(() => {
+  _HeatmapTileLayer.defaultProps = defaultProps5;
+})();
+var heatmap_tile_layer_default = HeatmapTileLayer;
+
+// dist/layers/point-label-layer.js
+var import_core9 = require("@deck.gl/core");
+var import_layers2 = require("@deck.gl/layers");
+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 };
+  }
+};
+var EnhancedTextBackgroundLayer = _EnhancedTextBackgroundLayer;
+(() => {
+  _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;
+  }
+};
+var EnhancedTextLayer = _EnhancedTextLayer;
+(() => {
+  _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;
+  }
+};
+var PointLabelLayer = _PointLabelLayer;
 (() => {
-  _QuadbinHeatmapTileLayer.layerName = "QuadbinHeatmapTileLayer";
+  _PointLabelLayer.layerName = "PointLabelLayer";
 })();
 (() => {
-  _QuadbinHeatmapTileLayer.defaultProps = defaultProps6;
+  _PointLabelLayer.defaultProps = defaultProps6;
 })();
-var quadbin_heatmap_tile_layer_default = QuadbinHeatmapTileLayer;
 
 // dist/layers/raster-tile-layer.js
 var import_core11 = require("@deck.gl/core");
@@ -1639,7 +1715,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut = __toESM(require("earcut"), 1);
-var VERSION3 = true ? "9.0.16" : "latest";
+var VERSION3 = true ? "9.0.18" : "latest";
 var id3 = "cartoVectorTile";
 var DEFAULT_OPTIONS3 = {
   cartoVectorTile: {
@@ -1699,7 +1775,6 @@ var carto_vector_tile_loader_default = CartoVectorTileLoader;
 var import_extensions = require("@deck.gl/extensions");
 var import_geo_layers6 = require("@deck.gl/geo-layers");
 var import_layers4 = require("@deck.gl/layers");
-var import_gis = require("@loaders.gl/gis");
 (0, import_core12.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
 var defaultProps9 = {
   ...import_geo_layers6.MVTLayer.defaultProps,
@@ -1778,15 +1853,10 @@ var _VectorTileLayer = class extends import_geo_layers6.MVTLayer {
     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 = (0, import_gis.binaryToGeojson)(data, {
-        globalFeatureId: info.index
-      });
-    }
-    return info;
+  _isWGS84() {
+    if (this.state.mvt)
+      return super._isWGS84();
+    return true;
   }
 };
 var VectorTileLayer = _VectorTileLayer;
@@ -1799,7 +1869,7 @@ var VectorTileLayer = _VectorTileLayer;
 
 // dist/api/carto-api-error.js
 var CartoAPIError = class extends Error {
-  constructor(error, errorContext, response) {
+  constructor(error, errorContext, response, responseJson) {
     let responseString = "Failed to connect";
     if (response) {
       responseString = "Server returned: ";
@@ -1828,6 +1898,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     super(message);
     this.name = "CartoAPIError";
     this.response = response;
+    this.responseJson = responseJson;
     this.error = error;
     this.errorContext = errorContext;
   }
@@ -2042,19 +2113,10 @@ function colorContinuous({ attr, domain, colors = DEFAULT_PALETTE, nullColor = N
 }
 
 // dist/api/common.js
-var import_core13 = require("@deck.gl/core");
 var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
 var DEFAULT_CLIENT = "deck-gl-carto";
 var V3_MINOR_VERSION = "3.4";
 var MAX_GET_LENGTH = 8192;
-var DEFAULT_PARAMETERS = {
-  v: V3_MINOR_VERSION,
-  deckglVersion: import_core13.VERSION
-};
-var DEFAULT_HEADERS = {
-  Accept: "application/json",
-  "Content-Type": "application/json"
-};
 
 // dist/api/endpoints.js
 function joinPath(...args) {
@@ -2080,34 +2142,40 @@ function buildQueryUrl({ apiBaseUrl, connectionName }) {
 }
 
 // dist/api/request-with-parameters.js
-function encodeParameter(name, value) {
-  if (isPureObject(value) || Array.isArray(value)) {
-    return `${name}=${encodeURIComponent(JSON.stringify(value))}`;
-  }
-  return `${name}=${encodeURIComponent(value)}`;
-}
+var import_core13 = require("@deck.gl/core");
+var DEFAULT_PARAMETERS = {
+  v: V3_MINOR_VERSION,
+  deckglVersion: import_core13.VERSION
+};
+var DEFAULT_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/json"
+};
 var REQUEST_CACHE = /* @__PURE__ */ new Map();
-async function requestWithParameters({ baseUrl, parameters, headers: customHeaders, errorContext }) {
+async function requestWithParameters({ baseUrl, parameters = {}, headers: customHeaders = {}, errorContext }) {
   parameters = { ...DEFAULT_PARAMETERS, ...parameters };
-  const key = createCacheKey(baseUrl, parameters || {}, customHeaders || {});
+  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
+  const key = createCacheKey(baseUrl, parameters, customHeaders);
   if (REQUEST_CACHE.has(key)) {
     return REQUEST_CACHE.get(key);
   }
-  const url = parameters ? createURLWithParameters(baseUrl, parameters) : baseUrl;
+  const url = createURLWithParameters(baseUrl, parameters);
   const headers = { ...DEFAULT_HEADERS, ...customHeaders };
   const fetchPromise = url.length > MAX_GET_LENGTH ? fetch(baseUrl, { method: "POST", body: JSON.stringify(parameters), headers }) : fetch(url, { headers });
   let response;
+  let responseJson;
   const jsonPromise = fetchPromise.then((_response) => {
     response = _response;
     return response.json();
   }).then((json) => {
+    responseJson = json;
     if (!response || !response.ok) {
       throw new Error(json.error);
     }
     return json;
   }).catch((error) => {
     REQUEST_CACHE.delete(key);
-    throw new CartoAPIError(error, errorContext, response);
+    throw new CartoAPIError(error, errorContext, response, responseJson);
   });
   REQUEST_CACHE.set(key, jsonPromise);
   return jsonPromise;
@@ -2117,9 +2185,25 @@ function createCacheKey(baseUrl, parameters, headers) {
   const headerEntries = Object.entries(headers).sort(([a], [b]) => a > b ? 1 : -1);
   return JSON.stringify({ baseUrl, parameters: parameterEntries, headers: headerEntries });
 }
-function createURLWithParameters(baseUrl, parameters) {
-  const encodedParameters = Object.entries(parameters).map(([key, value]) => encodeParameter(key, value));
-  return `${baseUrl}?${encodedParameters.join("&")}`;
+function createURLWithParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const [key, value] of Object.entries(parameters)) {
+    if (isPureObject(value) || Array.isArray(value)) {
+      baseUrl.searchParams.set(key, JSON.stringify(value));
+    } else {
+      baseUrl.searchParams.set(key, value.toString());
+    }
+  }
+  return baseUrl.toString();
+}
+function excludeURLParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const param of parameters) {
+    if (baseUrl.searchParams.has(param)) {
+      baseUrl.searchParams.delete(param);
+    }
+  }
+  return baseUrl.toString();
 }
 
 // dist/sources/base-source.js
@@ -2255,8 +2339,11 @@ var h3TilesetSource = async function(options) {
 
 // dist/sources/raster-source.js
 var rasterSource = async function(options) {
-  const { tableName } = options;
+  const { tableName, filters } = options;
   const urlParameters = { name: tableName };
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource("raster", options, urlParameters);
 };
 
@@ -3212,9 +3299,9 @@ var query = async function(options) {
 // dist/index.js
 var CARTO_LAYERS = {
   H3TileLayer,
+  HeatmapTileLayer: heatmap_tile_layer_default,
   _PointLabelLayer: PointLabelLayer,
   QuadbinTileLayer,
-  QuadbinHeatmapTileLayer: quadbin_heatmap_tile_layer_default,
   RasterTileLayer,
   VectorTileLayer
 };