@deck.gl/carto 9.0.34 → 9.1.0-beta.1

package/dist/index.cjs

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -29,38 +33,39 @@ __export(dist_exports, {
   BASEMAP: () => basemap_default,
   CARTO_LAYERS: () => CARTO_LAYERS,
   CARTO_SOURCES: () => CARTO_SOURCES,
-  CartoAPIError: () => CartoAPIError,
   ClusterTileLayer: () => cluster_tile_layer_default,
   H3TileLayer: () => h3_tile_layer_default,
   HeatmapTileLayer: () => heatmap_tile_layer_default,
   QuadbinTileLayer: () => quadbin_tile_layer_default,
   RasterTileLayer: () => raster_tile_layer_default,
-  SOURCE_DEFAULTS: () => SOURCE_DEFAULTS,
+  SOURCE_DEFAULTS: () => import_api_client3.SOURCE_DEFAULTS,
   VectorTileLayer: () => vector_tile_layer_default,
   _GOOGLE_BASEMAPS: () => GOOGLE_BASEMAPS,
   _PointLabelLayer: () => point_label_layer_default,
+  _QuadbinLayer: () => quadbin_layer_default,
+  _RasterLayer: () => raster_layer_default,
   _STYLE_LAYER_GROUPS: () => STYLE_LAYER_GROUPS,
+  _SpatialIndexTileLayer: () => spatial_index_tile_layer_default,
   _applyLayerGroupFilters: () => applyLayerGroupFilters,
   _fetchStyle: () => fetchStyle,
   _getStyleUrl: () => getStyleUrl,
-  boundaryQuerySource: () => boundaryQuerySource,
-  boundaryTableSource: () => boundaryTableSource,
+  boundaryQuerySource: () => import_api_client3.boundaryQuerySource,
+  boundaryTableSource: () => import_api_client3.boundaryTableSource,
   colorBins: () => colorBins,
   colorCategories: () => colorCategories,
   colorContinuous: () => colorContinuous,
   fetchBasemapProps: () => fetchBasemapProps,
   fetchMap: () => fetchMap,
-  h3QuerySource: () => h3QuerySource,
-  h3TableSource: () => h3TableSource,
-  h3TilesetSource: () => h3TilesetSource,
-  quadbinQuerySource: () => quadbinQuerySource,
-  quadbinTableSource: () => quadbinTableSource,
-  quadbinTilesetSource: () => quadbinTilesetSource,
-  query: () => query,
-  rasterSource: () => rasterSource,
-  vectorQuerySource: () => vectorQuerySource,
-  vectorTableSource: () => vectorTableSource,
-  vectorTilesetSource: () => vectorTilesetSource
+  h3QuerySource: () => import_api_client3.h3QuerySource,
+  h3TableSource: () => import_api_client3.h3TableSource,
+  h3TilesetSource: () => import_api_client3.h3TilesetSource,
+  quadbinQuerySource: () => import_api_client3.quadbinQuerySource,
+  quadbinTableSource: () => import_api_client3.quadbinTableSource,
+  quadbinTilesetSource: () => import_api_client3.quadbinTilesetSource,
+  rasterSource: () => import_api_client3.rasterSource,
+  vectorQuerySource: () => import_api_client3.vectorQuerySource,
+  vectorTableSource: () => import_api_client3.vectorTableSource,
+  vectorTilesetSource: () => import_api_client3.vectorTilesetSource
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -195,26 +200,28 @@ function clustersToBinary(data) {
 
 // dist/constants.js
 var DEFAULT_TILE_SIZE = 512;
-var DEFAULT_TILE_RESOLUTION = 0.5;
-var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
 
 // dist/layers/quadbin-tileset-2d.js
 var import_geo_layers = require("@deck.gl/geo-layers");
 var import_quadbin2 = require("quadbin");
 var QuadbinTileset2D = class extends import_geo_layers._Tileset2D {
+  // @ts-expect-error for spatial indices, TileSet2d should be parametrized by TileIndexT
   getTileIndices(opts) {
     return super.getTileIndices(opts).map(import_quadbin2.tileToCell).map((q) => ({ q, i: (0, import_quadbin2.bigIntToHex)(q) }));
   }
+  // @ts-expect-error TileIndex must be generic
   getTileId({ q, i }) {
     return i || (0, import_quadbin2.bigIntToHex)(q);
   }
+  // @ts-expect-error TileIndex must be generic
   getTileMetadata({ q }) {
     return super.getTileMetadata((0, import_quadbin2.cellToTile)(q));
   }
+  // @ts-expect-error TileIndex must be generic
   getTileZoom({ q }) {
     return Number((0, import_quadbin2.getResolution)(q));
   }
+  // @ts-expect-error TileIndex must be generic
   getParentIndex({ q }) {
     return { q: (0, import_quadbin2.cellToParent)(q) };
   }
@@ -527,8 +534,6 @@ function scaleIdentity() {
   };
   return scale;
 }
-var isObject = (x) => x !== null && typeof x === "object";
-var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
 
 // dist/layers/schema/spatialjson-utils.js
 var import_quadbin4 = require("quadbin");
@@ -548,7 +553,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION = true ? "9.0.34" : "latest";
+var VERSION = true ? "9.1.0-beta.1" : "latest";
 var id = "cartoSpatialTile";
 var DEFAULT_OPTIONS = {
   cartoSpatialTile: {
@@ -665,6 +670,7 @@ var ClusterGeoJsonLayer = class extends import_geo_layers2.TileLayer {
     super.initializeState();
     this.state.aggregationCache = /* @__PURE__ */ new WeakMap();
   }
+  // eslint-disable-next-line max-statements
   renderLayers() {
     var _a;
     const visibleTiles = (_a = this.state.tileset) == null ? void 0 : _a.tiles.filter((tile) => {
@@ -750,9 +756,11 @@ var ClusterTileLayer = class extends import_core6.CompositeLayer {
       return null;
     const { tiles: data, maxresolution: maxZoom } = tileJSON;
     return [
+      // @ts-ignore
       new ClusterGeoJsonLayer(this.props, {
         id: `cluster-geojson-layer-${this.props.id}`,
         data,
+        // TODO: Tileset2D should be generic over TileIndex type
         TilesetClass: QuadbinTileset2D,
         maxZoom,
         loadOptions: this.getLoadOptions()
@@ -829,6 +837,12 @@ function getHexagonResolution(viewport, tileSize) {
   return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
 }
 var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
+  /**
+   * Returns all tile indices in the current viewport. If the current zoom level is smaller
+   * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
+   * return tiles that are on maxZoom.
+   */
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileIndices({ viewport, minZoom, maxZoom }) {
     if (viewport.latitude === void 0)
       return [];
@@ -849,15 +863,19 @@ var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
     }
     return indices.map((i) => ({ i }));
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileId({ i }) {
     return i;
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileMetadata({ i }) {
     return { bbox: tileToBoundingBox(i) };
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileZoom({ i }) {
     return (0, import_h3_js.getResolution)(i);
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getParentIndex(index) {
     const resolution = (0, import_h3_js.getResolution)(index.i);
     const i = (0, import_h3_js.cellToParent)(index.i, resolution - 1);
@@ -913,7 +931,7 @@ var TileReader3 = class {
 };
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION2 = true ? "9.0.34" : "latest";
+var VERSION2 = true ? "9.1.0-beta.1" : "latest";
 var id2 = "cartoRasterTile";
 var DEFAULT_OPTIONS2 = {
   cartoRasterTile: {
@@ -984,7 +1002,8 @@ var SpatialIndexTileLayer = class extends import_geo_layers4.TileLayer {
     const { hoveredFeatureId } = this.state;
     const data = tile.content;
     const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
-    if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
+    if (!isFeatureIdPresent || !Array.isArray(data) || // Quick check for whether id is within tile. data.findIndex is expensive
+    !this._featureInTile(tile, hoveredFeatureId)) {
       return -1;
     }
     return data.findIndex((feature) => feature.id === hoveredFeatureId);
@@ -1045,17 +1064,18 @@ var H3TileLayer = class extends import_core8.CompositeLayer {
     if (this.props.maxZoom) {
       maxresolution = Math.min(maxresolution, getHexagonResolution({ zoom: this.props.maxZoom, latitude: 0 }, this.props.tileSize));
     }
-    return [
-      new spatial_index_tile_layer_default(this.props, {
-        id: `h3-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: H3Tileset2D,
-        renderSubLayers,
-        minZoom: minresolution,
-        maxZoom: maxresolution,
-        loadOptions: this.getLoadOptions()
-      })
-    ];
+    const SubLayerClass = this.getSubLayerClass("spatial-index-tile", spatial_index_tile_layer_default);
+    return new SubLayerClass(this.props, {
+      id: `h3-tile-layer-${this.props.id}`,
+      data,
+      // TODO: Tileset2D should be generic over TileIndex type
+      TilesetClass: H3Tileset2D,
+      renderSubLayers,
+      // minZoom and maxZoom are H3 resolutions, however we must use this naming as that is what the Tileset2D class expects
+      minZoom: minresolution,
+      maxZoom: maxresolution,
+      loadOptions: this.getLoadOptions()
+    });
   }
 };
 H3TileLayer.layerName = "H3TileLayer";
@@ -1068,137 +1088,121 @@ var import_core11 = require("@deck.gl/core");
 var import_layers2 = require("@deck.gl/layers");
 
 // dist/layers/heatmap.js
-var fs = `uniform heatmapUniforms {
-vec2 delta;
-float radiusPixels;
-vec2 colorDomain;
-vec3 color1;
-vec3 color2;
-vec3 color3;
-vec3 color4;
-vec3 color5;
-vec3 color6;
-float intensity;
-float opacity;
+var fs = (
+  /* glsl */
+  `uniform heatmapUniforms {
+  vec2 colorDomain;
+  vec2 delta;
+  float intensity;
+  float opacity;
+  float radiusPixels;
 } heatmap;
-const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
+
+uniform sampler2D colorTexture;
+
 vec3 colorGradient(float value) {
-vec3 c1;
-vec3 c2;
-vec2 range;
-if (value < STOPS.x) {
-range = vec2(0.0, STOPS.x);
-c1 = heatmap.color1; c2 = heatmap.color2;
-} else if (value < STOPS.y) {
-range = STOPS.xy;
-c1 = heatmap.color2; c2 = heatmap.color3;
-} else if (value < STOPS.z) {
-range = STOPS.yz;
-c1 = heatmap.color3; c2 = heatmap.color4;
-} else if (value < STOPS.w) {
-range = STOPS.zw;
-c1 = heatmap.color4; c2 = heatmap.color5;
-} else {
-range = vec2(STOPS.w, 1.0);
-c1 = heatmap.color5; c2 = heatmap.color6;
-}
-float f = (clamp(value, 0.0, 1.0) - range.x) / (range.y - range.x);
-return mix(c1, c2, f) / 255.0;
+  return texture(colorTexture, vec2(value, 0.5)).rgb;
 }
+
 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;
+  return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
 }
 float unpack(vec3 color) {
-return 255.0 * dot(color, SHIFT);
+  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 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 - 0.5) / SUPPORT;
-vec2 delta = percent * heatmap.radiusPixels / texSize;
-vec4 offsetColor = texture(source, texCoord + delta);
-float value = unpack(offsetColor.rgb);
-float weight = w0 * exp(a * t * t);
-accumulator += value * weight;
-}
-if (firstPass) {
-return pack(accumulator);
-}
-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);
-color.a = pow(color.a, 1.0 / 2.2);
-color.a *= heatmap.opacity;
-return color;
+  bool firstPass = (heatmap.delta.y < 0.5);
+  float accumulator = 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
+  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 - 0.5) / SUPPORT;
+    vec2 delta = percent * heatmap.radiusPixels / texSize;
+    vec4 offsetColor = texture(source, texCoord + delta);
+
+    // Unpack float
+    float value = unpack(offsetColor.rgb);
+
+    // Gaussian
+    float weight = w0 * exp(a * t * t);
+    
+    accumulator += value * weight;
+  }
+
+  if (firstPass) {
+    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 = (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);
+  color.rgb = colorGradient(f);
+
+  color.a = smoothstep(0.0, 0.1, f);
+  color.a = pow(color.a, 1.0 / 2.2);
+  color.a *= heatmap.opacity;
+
+  return color;
 }
-`;
-var defaultColorRange = [
-  [255, 255, 178],
-  [254, 217, 118],
-  [254, 178, 76],
-  [253, 141, 60],
-  [240, 59, 32],
-  [189, 0, 38]
-];
+`
+);
 var heatmap = {
   name: "heatmap",
   uniformPropTypes: {
-    delta: { value: [0, 1] },
-    radiusPixels: { value: 20, min: 0, softMax: 100 },
     colorDomain: { value: [0, 1] },
-    color1: { value: [0, 0, 0] },
-    color2: { value: [0, 0, 0] },
-    color3: { value: [0, 0, 0] },
-    color4: { value: [0, 0, 0] },
-    color5: { value: [0, 0, 0] },
-    color6: { value: [0, 0, 0] },
+    delta: { value: [0, 1] },
     intensity: { value: 1, min: 0.1, max: 10 },
-    opacity: { value: 1, min: 0, max: 1 }
+    opacity: { value: 1, min: 0, max: 1 },
+    radiusPixels: { value: 20, min: 0, softMax: 100 }
   },
   uniformTypes: {
-    delta: "vec2<f32>",
-    radiusPixels: "f32",
     colorDomain: "vec2<f32>",
-    color1: "vec3<f32>",
-    color2: "vec3<f32>",
-    color3: "vec3<f32>",
-    color4: "vec3<f32>",
-    color5: "vec3<f32>",
-    color6: "vec3<f32>",
+    delta: "vec2<f32>",
     intensity: "f32",
-    opacity: "f32"
+    opacity: "f32",
+    radiusPixels: "f32"
   },
+  // @ts-ignore TODO v9.1
   getUniforms: (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;
+    if (!opts)
+      return {};
+    const { colorDomain = [0, 1], colorTexture, delta = [1, 0], intensity = 1, opacity = 1, radiusPixels = 20 } = opts;
     return {
-      delta,
-      color1,
-      color2,
-      color3,
-      color4,
-      color5,
-      color6,
-      radiusPixels,
       colorDomain,
+      colorTexture,
+      delta,
       intensity,
-      opacity
+      opacity,
+      radiusPixels
     };
   },
   fs,
   passes: [
+    // @ts-expect-error Seems typing in luma.gl should be Partial<>
     { sampler: true, uniforms: { delta: [1, 0] } },
+    // @ts-expect-error Seems typing in luma.gl should be Partial<>
     { sampler: true, uniforms: { delta: [0, 1] } }
   ]
 };
@@ -1234,8 +1238,8 @@ function RTTModifier(BaseLayer) {
   var _a;
   return _a = class RTTLayer extends BaseLayer {
     draw(opts) {
-      const { moduleParameters } = opts;
-      const { picking } = moduleParameters;
+      const { shaderModuleProps } = opts;
+      const { picking } = shaderModuleProps;
       const postProcessLayer = getPostProcessLayer(this);
       if (!picking.isActive) {
         postProcessLayer.enableRTT(opts);
@@ -1279,10 +1283,11 @@ function PostProcessModifier(BaseLayer, effect) {
       });
     }
     _resizeBuffers(opts) {
-      const { moduleParameters } = opts;
+      const { shaderModuleProps } = opts;
       const { viewport } = this.context;
-      const width = moduleParameters.devicePixelRatio * viewport.width;
-      const height = moduleParameters.devicePixelRatio * viewport.height;
+      const { devicePixelRatio } = shaderModuleProps.project;
+      const width = devicePixelRatio * viewport.width;
+      const height = devicePixelRatio * viewport.height;
       this.internalState.renderBuffers.forEach((fbo) => fbo.resize({ width, height }));
     }
     enableRTT(opts) {
@@ -1292,6 +1297,7 @@ function PostProcessModifier(BaseLayer, effect) {
       this.internalState.internalRenderPass = this.context.device.beginRenderPass({
         framebuffer,
         parameters: { viewport: [0, 0, framebuffer.width, framebuffer.height] },
+        // Only clear on first render
         clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]
       });
       this.internalState.renderInProgress = true;
@@ -1370,16 +1376,16 @@ var QuadbinTileLayer = class extends import_core10.CompositeLayer {
     if (!tileJSON)
       return null;
     const { tiles: data, maxresolution: maxZoom } = tileJSON;
-    return [
-      new spatial_index_tile_layer_default(this.props, {
-        id: `quadbin-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: QuadbinTileset2D,
-        renderSubLayers: renderSubLayers2,
-        maxZoom,
-        loadOptions: this.getLoadOptions()
-      })
-    ];
+    const SubLayerClass = this.getSubLayerClass("spatial-index-tile", spatial_index_tile_layer_default);
+    return new SubLayerClass(this.props, {
+      id: `quadbin-tile-layer-${this.props.id}`,
+      data,
+      // TODO: Tileset2D should be generic over TileIndex type
+      TilesetClass: QuadbinTileset2D,
+      renderSubLayers: renderSubLayers2,
+      maxZoom,
+      loadOptions: this.getLoadOptions()
+    });
   }
 };
 QuadbinTileLayer.layerName = "QuadbinTileLayer";
@@ -1387,24 +1393,62 @@ QuadbinTileLayer.defaultProps = defaultProps5;
 var quadbin_tile_layer_default = QuadbinTileLayer;
 
 // dist/layers/heatmap-tile-layer.js
+var defaultColorRange = [
+  [255, 255, 178],
+  [254, 217, 118],
+  [254, 178, 76],
+  [253, 141, 60],
+  [240, 59, 32],
+  [189, 0, 38]
+];
+var TEXTURE_PROPS2 = {
+  format: "rgba8unorm",
+  mipmaps: false,
+  sampler: {
+    minFilter: "linear",
+    magFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+  }
+};
 function unitDensityForCell(cell) {
   const cellResolution = Number((0, import_quadbin6.getResolution)(cell));
   return Math.pow(4, cellResolution);
 }
+function colorRangeToFlatArray(colorRange) {
+  const flatArray = new Uint8Array(colorRange.length * 4);
+  let index = 0;
+  for (let i = 0; i < colorRange.length; i++) {
+    const color = colorRange[i];
+    flatArray[index++] = color[0];
+    flatArray[index++] = color[1];
+    flatArray[index++] = color[2];
+    flatArray[index++] = Number.isFinite(color[3]) ? color[3] : 255;
+  }
+  return flatArray;
+}
+var uniformBlock = `uniform densityUniforms {
+  float factor;
+} density;
+`;
+var densityUniforms = {
+  name: "density",
+  vs: uniformBlock,
+  uniformTypes: {
+    factor: "f32"
+  }
+};
 var RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
   getShaders(type) {
     const shaders = super.getShaders(type);
     shaders.inject = {
-      "vs:#decl": `
-uniform float densityFactor;
-`,
       "vs:#main-end": `
       // Value from getWeight accessor
   float weight = elevations;
 
   // Keep "power" delivered to screen constant when tiles update
-  // by outputting normalized density 
-  weight *= densityFactor;
+  // by outputting normalized density
+  weight *= density.factor;
 
   // Pack float into 3 channels to pass to heatmap shader
   // SCALE value important, as we don't want to saturate
@@ -1417,14 +1461,17 @@ uniform float densityFactor;
   vColor = vec4(mod(vec3(weight, floor(weight / SHIFT.yz)), 256.0), 255.0) / 255.0;
 `
     };
+    shaders.modules = [...shaders.modules, densityUniforms];
     return shaders;
   }
   draw(opts) {
     const cell = this.props.data[0];
     const maxDensity = this.props.elevationScale;
-    const densityFactor = unitDensityForCell(cell.id) / maxDensity;
+    const densityProps = {
+      factor: unitDensityForCell(cell.id) / maxDensity
+    };
     for (const model of this.state.models) {
-      model.setUniforms({ densityFactor });
+      model.shaderInputs.setProps({ density: densityProps });
     }
     super.draw(opts);
   }
@@ -1436,6 +1483,7 @@ var defaultProps6 = {
   getWeight: { type: "accessor", value: 1 },
   onMaxDensityChange: { type: "function", optional: true, value: null },
   colorDomain: { type: "array", value: [0, 1] },
+  colorRange: defaultColorRange,
   intensity: { type: "number", value: 1 },
   radiusPixels: { type: "number", min: 0, max: 100, value: 20 }
 };
@@ -1452,9 +1500,16 @@ var HeatmapTileLayer = class extends import_core11.CompositeLayer {
     this.setState({ viewportChanged });
     return changeFlags.somethingChanged;
   }
+  updateState(opts) {
+    const { props, oldProps } = opts;
+    super.updateState(opts);
+    if (props.colorRange !== oldProps.colorRange) {
+      this._updateColorTexture(opts);
+    }
+  }
   renderLayers() {
     var _a, _b, _c;
-    const { data, getWeight, colorDomain, colorRange, intensity, radiusPixels, _subLayerProps, updateTriggers, onMaxDensityChange, onViewportLoad, onTileLoad, onTileUnload, ...tileLayerProps } = this.props;
+    const { data, getWeight, colorDomain, intensity, radiusPixels, _subLayerProps, updateTriggers, onMaxDensityChange, onViewportLoad, onTileLoad, onTileUnload, ...tileLayerProps } = this.props;
     const subLayerProps = {
       ..._subLayerProps,
       cell: {
@@ -1486,20 +1541,24 @@ var HeatmapTileLayer = class extends import_core11.CompositeLayer {
     return new PostProcessQuadbinTileLayer(tileLayerProps, this.getSubLayerProps({
       id: "heatmap",
       data,
+      // Re-use existing props to pass down values to sublayer
+      // TODO replace with custom layer
       getFillColor: 0,
       getElevation: getWeight,
       elevationScale: maxDensity,
       colorDomain,
-      colorRange,
       radiusPixels,
       intensity,
       _subLayerProps: subLayerProps,
       refinementStrategy: "no-overlap",
+      colorTexture: this.state.colorTexture,
+      // Disable line rendering
       extruded: false,
       stroked: false,
       updateTriggers: {
         getElevation: updateTriggers.getWeight
       },
+      // Tile stats
       onViewportLoad: (tiles2) => {
         this.setState({ isLoaded: true });
         if (typeof onViewportLoad === "function") {
@@ -1530,6 +1589,23 @@ var HeatmapTileLayer = class extends import_core11.CompositeLayer {
       transitions: { elevationScale: { type: "spring", stiffness: 0.3, damping: 0.5 } }
     }));
   }
+  _updateColorTexture(opts) {
+    const { colorRange } = opts.props;
+    let { colorTexture } = this.state;
+    const colors = colorRangeToFlatArray(colorRange);
+    if (colorTexture && (colorTexture == null ? void 0 : colorTexture.width) === colorRange.length) {
+      colorTexture.setSubImageData({ data: colors });
+    } else {
+      colorTexture == null ? void 0 : colorTexture.destroy();
+      colorTexture = this.context.device.createTexture({
+        ...TEXTURE_PROPS2,
+        data: colors,
+        width: colorRange.length,
+        height: 1
+      });
+    }
+    this.setState({ colorTexture });
+  }
 };
 HeatmapTileLayer.layerName = "HeatmapTileLayer";
 HeatmapTileLayer.defaultProps = defaultProps6;
@@ -1543,8 +1619,8 @@ var EnhancedTextBackgroundLayer = class extends import_layers3._TextBackgroundLa
   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);");
+    vs = vs.replaceAll("textBackground.padding.", "_padding.");
+    vs = vs.replace("void main(void) {", "void main(void) {\n  vec4 _padding = textBackground.padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);");
     return { ...shaders, vs };
   }
 };
@@ -1647,16 +1723,20 @@ var PointLabelLayer = class extends import_core12.CompositeLayer {
     const getPixelOffset = this.calculatePixelOffset(false);
     const backgroundPadding = this.calculateBackgroundPadding();
     const out = [
+      // Text doesn't update via updateTrigger for some reason
       this.renderTextLayer(`${updateTriggers.getText}-primary`, {
         backgroundPadding,
         getText,
         getPixelOffset,
         background: true
+        // Only use background for primary label for faster collisions
       }),
       Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
         getText: getSecondaryText,
         getPixelOffset: this.calculatePixelOffset(true),
         getAlignmentBaseline: "top",
+        // updateTriggers: {getText: updateTriggers.getSecondaryText},
+        // Optional overrides
         ...getSecondaryColor && { getColor: getSecondaryColor },
         ...secondarySizeScale && { sizeScale: secondarySizeScale },
         ...secondaryOutlineColor && { outlineColor: secondaryOutlineColor }
@@ -1685,38 +1765,30 @@ in float instanceElevations;
 in vec4 instanceFillColors;
 in vec4 instanceLineColors;
 in vec3 instancePickingColors;
-uniform float opacity;
-uniform bool extruded;
-uniform bool stroked;
-uniform bool isStroke;
-uniform float coverage;
-uniform float elevationScale;
-uniform float widthScale;
-uniform vec3 offset;
 out vec4 vColor;
 #ifdef FLAT_SHADING
 out vec4 position_commonspace;
 #endif
 void main(void) {
-vec2 common_position = offset.xy;
-float scale = offset.z;
+vec2 common_position = column.offset.xy;
+float scale = column.widthScale;
 int yIndex = - (gl_InstanceID / BLOCK_WIDTH);
 int xIndex = gl_InstanceID + (yIndex * BLOCK_WIDTH);
-common_position += scale * vec2(float(xIndex), float(yIndex));
-vec4 color = isStroke ? instanceLineColors : instanceFillColors;
+common_position += scale * vec2(float(xIndex), float(yIndex - 1));
+vec4 color = column.isStroke ? instanceLineColors : instanceFillColors;
 float shouldRender = float(color.a > 0.0 && instanceElevations >= 0.0);
-float cellWidth = coverage * scale;
+float cellWidth = column.coverage * scale;
 geometry.position = vec4(common_position, 0.0, 1.0);
-if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
-geometry.position.xyz -= project_uCommonOrigin;
+if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+geometry.position.xyz -= project.commonOrigin;
 }
 float elevation = 0.0;
 float strokeOffsetRatio = 1.0;
-if (extruded) {
-elevation = instanceElevations * (positions.z + 1.0) / 2.0 * elevationScale;
-} else if (stroked) {
-float halfOffset = project_pixel_size(widthScale) / cellWidth;
-if (isStroke) {
+if (column.extruded) {
+elevation = instanceElevations * (positions.z + 1.0) / 2.0 * column.elevationScale;
+} else if (column.stroked) {
+float halfOffset = project_pixel_size(column.widthScale) / cellWidth;
+if (column.isStroke) {
 strokeOffsetRatio -= sign(positions.z) * halfOffset;
 } else {
 strokeOffsetRatio -= halfOffset;
@@ -1730,16 +1802,16 @@ geometry.position.xyz += pos;
 gl_Position = project_common_position_to_clipspace(geometry.position);
 geometry.normal = project_normal(normals);
 DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
-if (extruded && !isStroke) {
+if (column.extruded && !column.isStroke) {
 #ifdef FLAT_SHADING
 position_commonspace = geometry.position;
-vColor = vec4(color.rgb, color.a * opacity);
+vColor = vec4(color.rgb, color.a * layer.opacity);
 #else
-vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);
-vColor = vec4(lightColor, color.a * opacity);
+vec3 lightColor = lighting_getLightColor(color.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+vColor = vec4(lightColor, color.a * layer.opacity);
 #endif
 } else {
-vColor = vec4(color.rgb, color.a * opacity);
+vColor = vec4(color.rgb, color.a * layer.opacity);
 }
 DECKGL_FILTER_COLOR(vColor, geometry);
 }
@@ -1800,7 +1872,8 @@ var RasterLayer = class extends import_core13.CompositeLayer {
       return null;
     const blockSize = data.blockSize ?? 0;
     const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
-    const offset = [xOffset, yOffset, scale / blockSize];
+    const offset = [xOffset, yOffset];
+    const lineWidthScale = scale / blockSize;
     const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
     const { highlightedObjectIndex, highlightColor } = this.state;
     return new CellLayer(this.props, this.getSubLayerProps({
@@ -1813,10 +1886,13 @@ var RasterLayer = class extends import_core13.CompositeLayer {
     }), {
       data: {
         data,
+        // Pass through data for getSubLayerAccessor()
         length: blockSize * blockSize
       },
       dataComparator: wrappedDataComparator,
       offset,
+      lineWidthScale,
+      // Re-use widthScale prop to pass cell scale,
       highlightedObjectIndex,
       highlightColor
     });
@@ -1889,17 +1965,17 @@ var RasterTileLayer = class extends import_core14.CompositeLayer {
     if (!tileJSON)
       return null;
     const { tiles: data, minzoom: minZoom, maxzoom: maxZoom } = tileJSON;
-    return [
-      new import_geo_layers7.TileLayer(this.props, {
-        id: `raster-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: QuadbinTileset2D,
-        renderSubLayers: renderSubLayers3,
-        minZoom,
-        maxZoom,
-        loadOptions: this.getLoadOptions()
-      })
-    ];
+    const SubLayerClass = this.getSubLayerClass("tile", import_geo_layers7.TileLayer);
+    return new SubLayerClass(this.props, {
+      id: `raster-tile-layer-${this.props.id}`,
+      data,
+      // TODO: Tileset2D should be generic over TileIndex type
+      TilesetClass: QuadbinTileset2D,
+      renderSubLayers: renderSubLayers3,
+      minZoom,
+      maxZoom,
+      loadOptions: this.getLoadOptions()
+    });
   }
 };
 RasterTileLayer.layerName = "RasterTileLayer";
@@ -1947,7 +2023,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.34" : "latest";
+var VERSION3 = true ? "9.1.0-beta.1" : "latest";
 var id3 = "cartoVectorTile";
 var DEFAULT_OPTIONS3 = {
   cartoVectorTile: {
@@ -2038,6 +2114,7 @@ var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
     loadOptions.gis = { format: "binary" };
     return loadOptions;
   }
+  /* eslint-disable camelcase */
   async getTileData(tile) {
     const tileJSON = this.props.data;
     const { tiles, properties_tiles } = tileJSON;
@@ -2067,6 +2144,7 @@ var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
       return null;
     return attributes ? mergeBoundaryData(geometry, attributes) : geometry;
   }
+  /* eslint-enable camelcase */
   renderSubLayers(props) {
     if (props.data === null) {
       return null;
@@ -2093,6 +2171,7 @@ var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
     const subLayerProps = {
       ...props,
       autoHighlight: false,
+      // Do not perform clipping on points (#9059)
       _subLayerProps: {
         ...props._subLayerProps,
         ...applyClipExtensionToSublayerProps("polygons-fill"),
@@ -2113,47 +2192,8 @@ VectorTileLayer.layerName = "VectorTileLayer";
 VectorTileLayer.defaultProps = defaultProps10;
 var vector_tile_layer_default = VectorTileLayer;
 
-// dist/api/carto-api-error.js
-var CartoAPIError = class extends Error {
-  constructor(error, errorContext, response, responseJson) {
-    let responseString = "Failed to connect";
-    if (response) {
-      responseString = "Server returned: ";
-      if (response.status === 400) {
-        responseString += "Bad request";
-      } else if (response.status === 401 || response.status === 403) {
-        responseString += "Unauthorized access";
-      } else if (response.status === 404) {
-        responseString += "Not found";
-      } else {
-        responseString += "Error";
-      }
-      responseString += ` (${response.status}):`;
-    }
-    responseString += ` ${error.message || error}`;
-    let message = `${errorContext.requestType} API request failed`;
-    message += `
-${responseString}`;
-    for (const key of Object.keys(errorContext)) {
-      if (key === "requestType")
-        continue;
-      message += `
-${formatErrorKey(key)}: ${errorContext[key]}`;
-    }
-    message += "\n";
-    super(message);
-    this.name = "CartoAPIError";
-    this.response = response;
-    this.responseJson = responseJson;
-    this.error = error;
-    this.errorContext = errorContext;
-  }
-};
-function formatErrorKey(key) {
-  return key.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
-}
-
 // dist/basemap.js
+var import_api_client = require("@carto/api-client");
 var cartoStyleUrlTemplate = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
 var CARTO_MAP_STYLES = ["positron", "dark-matter", "voyager"];
 var GOOGLE_BASEMAPS = {
@@ -2238,7 +2278,7 @@ async function fetchStyle({ styleUrl, errorContext }) {
     response = res;
     return res.json();
   }).catch((error) => {
-    throw new CartoAPIError(error, { ...errorContext, requestType: "Basemap style" }, response);
+    throw new import_api_client.CartoAPIError(error, { ...errorContext, requestType: "Basemap style" }, response);
   });
 }
 var basemap_default = {
@@ -2358,343 +2398,11 @@ function colorContinuous({ attr, domain, colors = DEFAULT_PALETTE, nullColor = N
   };
 }
 
-// dist/api/common.js
-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 DEFAULT_MAX_LENGTH_URL = 7e3;
-
-// dist/api/endpoints.js
-function joinPath(...args) {
-  return args.map((part) => part.endsWith("/") ? part.slice(0, -1) : part).join("/");
-}
-function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
-  return joinPath(apiBaseUrl, version, endpoint, ...rest);
-}
-function buildPublicMapUrl({ apiBaseUrl, cartoMapId }) {
-  return buildV3Path(apiBaseUrl, "v3", "maps", "public", cartoMapId);
-}
-function buildStatsUrl({ attribute, apiBaseUrl, connectionName, source, type }) {
-  if (type === "query") {
-    return buildV3Path(apiBaseUrl, "v3", "stats", connectionName, attribute);
-  }
-  return buildV3Path(apiBaseUrl, "v3", "stats", connectionName, source, attribute);
-}
-function buildSourceUrl({ apiBaseUrl, connectionName, endpoint }) {
-  return buildV3Path(apiBaseUrl, "v3", "maps", connectionName, endpoint);
-}
-function buildQueryUrl({ apiBaseUrl, connectionName }) {
-  return buildV3Path(apiBaseUrl, "v3", "sql", connectionName, "query");
-}
-
-// dist/api/request-with-parameters.js
-var import_core16 = require("@deck.gl/core");
-var DEFAULT_PARAMETERS = {
-  v: V3_MINOR_VERSION,
-  deckglVersion: import_core16.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, maxLengthURL = DEFAULT_MAX_LENGTH_URL }) {
-  parameters = { ...DEFAULT_PARAMETERS, ...parameters };
-  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
-  const key = createCacheKey(baseUrl, parameters, customHeaders);
-  if (REQUEST_CACHE.has(key)) {
-    return REQUEST_CACHE.get(key);
-  }
-  const url = createURLWithParameters(baseUrl, parameters);
-  const headers = { ...DEFAULT_HEADERS, ...customHeaders };
-  const fetchPromise = url.length > maxLengthURL ? 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, responseJson);
-  });
-  REQUEST_CACHE.set(key, jsonPromise);
-  return jsonPromise;
-}
-function createCacheKey(baseUrl, parameters, headers) {
-  const parameterEntries = Object.entries(parameters).sort(([a], [b]) => a > b ? 1 : -1);
-  const headerEntries = Object.entries(headers).sort(([a], [b]) => a > b ? 1 : -1);
-  return JSON.stringify({ baseUrl, parameters: parameterEntries, headers: headerEntries });
-}
-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
-var SOURCE_DEFAULTS = {
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: DEFAULT_CLIENT,
-  format: "tilejson",
-  headers: {},
-  maxLengthURL: DEFAULT_MAX_LENGTH_URL
-};
-async function baseSource(endpoint, options, urlParameters) {
-  const { accessToken, connectionName, cache, ...optionalOptions } = options;
-  const mergedOptions = { ...SOURCE_DEFAULTS, accessToken, connectionName, endpoint };
-  for (const key in optionalOptions) {
-    if (optionalOptions[key]) {
-      mergedOptions[key] = optionalOptions[key];
-    }
-  }
-  const baseUrl = buildSourceUrl(mergedOptions);
-  const { clientId, maxLengthURL, format } = mergedOptions;
-  const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
-  const parameters = { client: clientId, ...urlParameters };
-  const errorContext = {
-    requestType: "Map instantiation",
-    connection: options.connectionName,
-    type: endpoint,
-    source: JSON.stringify(parameters, void 0, 2)
-  };
-  const mapInstantiation = await requestWithParameters({
-    baseUrl,
-    parameters,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-  const dataUrl = mapInstantiation[format].url[0];
-  if (cache) {
-    cache.value = parseInt(new URL(dataUrl).searchParams.get("cache") || "", 10);
-  }
-  errorContext.requestType = "Map data";
-  if (format === "tilejson") {
-    const json = await requestWithParameters({
-      baseUrl: dataUrl,
-      headers,
-      errorContext,
-      maxLengthURL
-    });
-    if (accessToken) {
-      json.accessToken = accessToken;
-    }
-    return json;
-  }
-  return await requestWithParameters({
-    baseUrl: dataUrl,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-}
-
-// dist/sources/boundary-query-source.js
-var boundaryQuerySource = async function(options) {
-  const { columns, filters, tilesetTableName, propertiesSqlQuery, queryParameters } = options;
-  const urlParameters = {
-    tilesetTableName,
-    propertiesSqlQuery
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  return baseSource("boundary", options, urlParameters);
-};
-
-// dist/sources/boundary-table-source.js
-var boundaryTableSource = async function(options) {
-  const { filters, tilesetTableName, columns, propertiesTableName } = options;
-  const urlParameters = {
-    tilesetTableName,
-    propertiesTableName
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("boundary", options, urlParameters);
-};
-
-// dist/sources/h3-query-source.js
-var h3QuerySource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3, sqlQuery, spatialDataColumn = "h3", queryParameters, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    spatialDataColumn,
-    spatialDataType: "h3",
-    q: sqlQuery
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("query", options, urlParameters);
-};
-
-// dist/sources/h3-table-source.js
-var h3TableSource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3, spatialDataColumn = "h3", tableName, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: "h3"
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("table", options, urlParameters);
-};
-
-// dist/sources/h3-tileset-source.js
-var h3TilesetSource = async function(options) {
-  const { tableName } = options;
-  const urlParameters = { name: tableName };
-  return baseSource("tileset", options, urlParameters);
-};
-
-// dist/sources/raster-source.js
-var rasterSource = async function(options) {
-  const { tableName, filters } = options;
-  const urlParameters = { name: tableName };
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("raster", options, urlParameters);
-};
-
-// dist/sources/quadbin-query-source.js
-var quadbinQuerySource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN, sqlQuery, spatialDataColumn = "quadbin", queryParameters, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    q: sqlQuery,
-    spatialDataColumn,
-    spatialDataType: "quadbin"
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("query", options, urlParameters);
-};
-
-// dist/sources/quadbin-table-source.js
-var quadbinTableSource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN, spatialDataColumn = "quadbin", tableName, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: "quadbin"
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("table", options, urlParameters);
-};
-
-// dist/sources/quadbin-tileset-source.js
-var quadbinTilesetSource = async function(options) {
-  const { tableName } = options;
-  const urlParameters = { name: tableName };
-  return baseSource("tileset", options, urlParameters);
-};
-
-// dist/sources/vector-query-source.js
-var vectorQuerySource = async function(options) {
-  const { columns, filters, spatialDataColumn = "geom", sqlQuery, tileResolution = DEFAULT_TILE_RESOLUTION, queryParameters } = options;
-  const urlParameters = {
-    spatialDataColumn,
-    spatialDataType: "geo",
-    tileResolution: tileResolution.toString(),
-    q: sqlQuery
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  return baseSource("query", options, urlParameters);
-};
-
-// dist/sources/vector-table-source.js
-var vectorTableSource = async function(options) {
-  const { columns, filters, spatialDataColumn = "geom", tableName, tileResolution = DEFAULT_TILE_RESOLUTION } = options;
-  const urlParameters = {
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: "geo",
-    tileResolution: tileResolution.toString()
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("table", options, urlParameters);
-};
-
-// dist/sources/vector-tileset-source.js
-var vectorTilesetSource = async function(options) {
-  const { tableName } = options;
-  const urlParameters = { name: tableName };
-  return baseSource("tileset", options, urlParameters);
-};
+// dist/api/fetch-map.js
+var import_api_client2 = require("@carto/api-client");
 
 // dist/api/parse-map.js
-var import_core17 = require("@deck.gl/core");
+var import_core16 = require("@deck.gl/core");
 
 // dist/api/layer-map.js
 var import_d3_array = require("d3-array");
@@ -2734,6 +2442,7 @@ var OPACITY_MAP = {
 var AGGREGATION_FUNC = {
   "count unique": (values, accessor) => (0, import_d3_array.groupSort)(values, (v) => v.length, accessor).length,
   median: import_d3_array.median,
+  // Unfortunately mode() is only available in d3-array@3+ which is ESM only
   mode: (values, accessor) => (0, import_d3_array.groupSort)(values, (v) => v.length, accessor).pop(),
   stddev: import_d3_array.deviation,
   variance: import_d3_array.variance
@@ -2752,12 +2461,14 @@ var hexToRGBA = (c) => {
   return [r, g, b, 255 * opacity];
 };
 var sharedPropMap = {
+  // Apply the value of Kepler `color` prop to the deck `getFillColor` prop
   color: "getFillColor",
   isVisible: "visible",
   label: "cartoLabel",
   textLabel: {
     alignment: "getTextAlignmentBaseline",
     anchor: "getTextAnchor",
+    // Apply the value of Kepler `textLabel.color` prop to the deck `getTextColor` prop
     color: "getTextColor",
     size: "getTextSize"
   },
@@ -2830,7 +2541,7 @@ function getLayer(type, config, dataset) {
       Layer: import_layers6.GeoJsonLayer
     },
     grid: {
-      Layer: import_aggregation_layers.CPUGridLayer,
+      Layer: import_aggregation_layers.GridLayer,
       propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: (x) => ({ cellSize: 1e3 * x }) } },
       defaultProps: { getPosition }
     },
@@ -3069,6 +2780,7 @@ function parseMap(json) {
     createdAt: json.createdAt,
     updatedAt: json.updatedAt,
     initialViewState: mapState,
+    /** @deprecated Use `basemap`. */
     mapStyle,
     token,
     layers: layers.reverse().map(({ id: id4, type, config, visualChannels }) => {
@@ -3087,11 +2799,13 @@ function parseMap(json) {
           ...createInteractionProps(interactionConfig),
           ...styleProps,
           ...createChannelProps(id4, type, config, visualChannels, data),
+          // Must come after style
           ...createParametersProp(layerBlending, styleProps.parameters || {}),
+          // Must come after style
           ...createLoadOptions(token)
         });
       } catch (e) {
-        import_core17.log.error(e.message)();
+        import_core16.log.error(e.message)();
         return void 0;
       }
     })
@@ -3178,6 +2892,7 @@ function createChannelProps(id4, type, config, visualChannels, data) {
     const { colorAggregation: aggregation, colorRange: range } = visConfig;
     result.getFillColor = getColorAccessor(
       colorField,
+      // @ts-ignore
       colorScale,
       { aggregation, range },
       visConfig.opacity,
@@ -3200,7 +2915,9 @@ function createChannelProps(id4, type, config, visualChannels, data) {
   }
   if (radiusField || sizeField) {
     result.getPointRadius = getSizeAccessor(
+      // @ts-ignore
       radiusField || sizeField,
+      // @ts-ignore
       radiusScale || sizeScale,
       visConfig.sizeAggregation,
       visConfig.radiusRange || visConfig.sizeRange,
@@ -3213,7 +2930,9 @@ function createChannelProps(id4, type, config, visualChannels, data) {
     const { strokeColorAggregation: aggregation, strokeColorRange: range } = visConfig;
     result.getLineColor = getColorAccessor(
       strokeColorField,
+      // @ts-ignore
       strokeColorScale,
+      // @ts-ignore
       { aggregation, range },
       opacity,
       data
@@ -3222,6 +2941,7 @@ function createChannelProps(id4, type, config, visualChannels, data) {
   if (heightField && visConfig.enable3d) {
     result.getElevation = getSizeAccessor(
       heightField,
+      // @ts-ignore
       heightScale,
       visConfig.heightAggregation,
       visConfig.heightRange || visConfig.sizeRange,
@@ -3289,6 +3009,7 @@ function createChannelProps(id4, type, config, visualChannels, data) {
         extensions: [collisionFilterExtension],
         collisionEnabled: true,
         collisionGroup,
+        // getPointRadius already has radiusScale baked in, so only pass one or the other
         ...result.getPointRadius ? { getRadius: result.getPointRadius } : { radiusScale: visConfig.radius },
         ...secondaryField && {
           getSecondaryText,
@@ -3377,7 +3098,7 @@ async function fetchBasemapProps({ config, errorContext, applyLayerFilters = tru
 }
 
 // dist/api/fetch-map.js
-async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, headers, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, headers, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
   const { aggregationExp, aggregationResLevel, connectionName, columns, format, geoColumn, source, type, queryParameters } = dataset;
   const cache = {};
   const globalOptions = {
@@ -3391,15 +3112,15 @@ async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, head
     maxLengthURL
   };
   if (type === "tileset") {
-    dataset.data = await vectorTilesetSource({ ...globalOptions, tableName: source });
+    dataset.data = await (0, import_api_client2.vectorTilesetSource)({ ...globalOptions, tableName: source });
   } else {
     const [spatialDataType, spatialDataColumn] = geoColumn ? geoColumn.split(":") : ["geom"];
     if (spatialDataType === "geom") {
       const options = { ...globalOptions, spatialDataColumn };
       if (type === "table") {
-        dataset.data = await vectorTableSource({ ...options, columns, tableName: source });
+        dataset.data = await (0, import_api_client2.vectorTableSource)({ ...options, columns, tableName: source });
       } else if (type === "query") {
-        dataset.data = await vectorQuerySource({
+        dataset.data = await (0, import_api_client2.vectorQuerySource)({
           ...options,
           columns,
           sqlQuery: source,
@@ -3409,16 +3130,16 @@ async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, head
     } else if (spatialDataType === "h3") {
       const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
       if (type === "table") {
-        dataset.data = await h3TableSource({ ...options, tableName: source });
+        dataset.data = await (0, import_api_client2.h3TableSource)({ ...options, tableName: source });
       } else if (type === "query") {
-        dataset.data = await h3QuerySource({ ...options, sqlQuery: source, queryParameters });
+        dataset.data = await (0, import_api_client2.h3QuerySource)({ ...options, sqlQuery: source, queryParameters });
       }
     } else if (spatialDataType === "quadbin") {
       const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
       if (type === "table") {
-        dataset.data = await quadbinTableSource({ ...options, tableName: source });
+        dataset.data = await (0, import_api_client2.quadbinTableSource)({ ...options, tableName: source });
       } else if (type === "query") {
-        dataset.data = await quadbinQuerySource({ ...options, sqlQuery: source, queryParameters });
+        dataset.data = await (0, import_api_client2.quadbinQuerySource)({ ...options, sqlQuery: source, queryParameters });
       }
     }
   }
@@ -3429,7 +3150,7 @@ async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, head
   }
   return cacheChanged;
 }
-async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
   const { connectionName, data, id: id4, source, type, queryParameters } = dataset;
   const errorContext = {
     requestType: "Tile stats",
@@ -3438,9 +3159,9 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
     source
   };
   if (!("tilestats" in data)) {
-    throw new CartoAPIError(new Error(`Invalid dataset for tilestats: ${id4}`), errorContext);
+    throw new import_api_client2.CartoAPIError(new Error(`Invalid dataset for tilestats: ${id4}`), errorContext);
   }
-  const baseUrl = buildStatsUrl({ attribute, apiBaseUrl, ...dataset });
+  const baseUrl = (0, import_api_client2.buildStatsUrl)({ attribute, apiBaseUrl, ...dataset });
   const client = new URLSearchParams(data.tiles[0]).get("client");
   const headers = { Authorization: `Bearer ${accessToken}` };
   const parameters = {};
@@ -3453,7 +3174,7 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
       parameters.queryParameters = JSON.stringify(queryParameters);
     }
   }
-  const stats = await requestWithParameters({
+  const stats = await (0, import_api_client2.requestWithParameters)({
     baseUrl,
     headers,
     parameters,
@@ -3465,11 +3186,11 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
   attributes[index] = stats;
   return true;
 }
-async function fillInMapDatasets({ datasets, token }, clientId, apiBaseUrl, headers, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function fillInMapDatasets({ datasets, token }, clientId, apiBaseUrl, headers, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
   const promises = datasets.map((dataset) => _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers, maxLengthURL));
   return await Promise.all(promises);
 }
-async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
   var _a;
   const attributes = [];
   const { layers } = keplerMapConfig.config.visState;
@@ -3493,7 +3214,7 @@ async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl,
   const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, token, apiBaseUrl, maxLengthURL));
   return await Promise.all(promises);
 }
-async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoMapId, clientId = DEFAULT_CLIENT, headers = {}, autoRefresh, onNewData, maxLengthURL = DEFAULT_MAX_LENGTH_URL }) {
+async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.SOURCE_DEFAULTS.apiBaseUrl, cartoMapId, clientId = import_api_client2.SOURCE_DEFAULTS.clientId, headers = {}, autoRefresh, onNewData, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL }) {
   assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
   assert(apiBaseUrl, "Must define apiBaseUrl");
   if (accessToken) {
@@ -3504,9 +3225,9 @@ async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoM
     assert(typeof onNewData === "function", "`onNewData` must be a function");
     assert(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
   }
-  const baseUrl = buildPublicMapUrl({ apiBaseUrl, cartoMapId });
+  const baseUrl = (0, import_api_client2.buildPublicMapUrl)({ apiBaseUrl, cartoMapId });
   const errorContext = { requestType: "Public map", mapId: cartoMapId };
-  const map = await requestWithParameters({ baseUrl, headers, errorContext, maxLengthURL });
+  const map = await (0, import_api_client2.requestWithParameters)({ baseUrl, headers, errorContext, maxLengthURL });
   let stopAutoRefresh;
   if (autoRefresh) {
     const intervalId = setInterval(async () => {
@@ -3535,6 +3256,7 @@ async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoM
   });
   const [basemap] = await Promise.all([
     fetchBasemapProps({ config: map.keplerMapConfig.config, errorContext }),
+    // Mutates map.datasets so that dataset.data contains data
     fillInMapDatasets(map, clientId, apiBaseUrl, headers, maxLengthURL)
   ]);
   await fillInTileStats(map, apiBaseUrl, maxLengthURL);
@@ -3550,32 +3272,8 @@ async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoM
   return out;
 }
 
-// dist/api/query.js
-var query = async function(options) {
-  const { apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl, clientId = SOURCE_DEFAULTS.clientId, maxLengthURL = SOURCE_DEFAULTS.maxLengthURL, connectionName, sqlQuery, queryParameters } = options;
-  const urlParameters = { q: sqlQuery };
-  if (queryParameters) {
-    urlParameters.queryParameters = JSON.stringify(queryParameters);
-  }
-  const baseUrl = buildQueryUrl({ apiBaseUrl, connectionName });
-  const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
-  const parameters = { client: clientId, ...urlParameters };
-  const errorContext = {
-    requestType: "SQL",
-    connection: options.connectionName,
-    type: "query",
-    source: JSON.stringify(parameters, void 0, 2)
-  };
-  return await requestWithParameters({
-    baseUrl,
-    parameters,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-};
-
 // dist/index.js
+var import_api_client3 = require("@carto/api-client");
 var CARTO_LAYERS = {
   ClusterTileLayer: cluster_tile_layer_default,
   H3TileLayer: h3_tile_layer_default,
@@ -3586,17 +3284,17 @@ var CARTO_LAYERS = {
   VectorTileLayer: vector_tile_layer_default
 };
 var CARTO_SOURCES = {
-  boundaryQuerySource,
-  boundaryTableSource,
-  h3QuerySource,
-  h3TableSource,
-  h3TilesetSource,
-  rasterSource,
-  quadbinQuerySource,
-  quadbinTableSource,
-  quadbinTilesetSource,
-  vectorQuerySource,
-  vectorTableSource,
-  vectorTilesetSource
+  boundaryQuerySource: import_api_client3.boundaryQuerySource,
+  boundaryTableSource: import_api_client3.boundaryTableSource,
+  h3QuerySource: import_api_client3.h3QuerySource,
+  h3TableSource: import_api_client3.h3TableSource,
+  h3TilesetSource: import_api_client3.h3TilesetSource,
+  rasterSource: import_api_client3.rasterSource,
+  quadbinQuerySource: import_api_client3.quadbinQuerySource,
+  quadbinTableSource: import_api_client3.quadbinTableSource,
+  quadbinTilesetSource: import_api_client3.quadbinTilesetSource,
+  vectorQuerySource: import_api_client3.vectorQuerySource,
+  vectorTableSource: import_api_client3.vectorTableSource,
+  vectorTilesetSource: import_api_client3.vectorTilesetSource
 };
 //# sourceMappingURL=index.cjs.map