@deck.gl/carto 8.9.3 → 8.9.5

package/dist/dist.dev.js

@@ -5441,8 +5441,8 @@ var __exports__ = (() => {
       Pbf.Fixed64 = 1;
       Pbf.Bytes = 2;
       Pbf.Fixed32 = 5;
-      var SHIFT_LEFT_322 = (1 << 16) * (1 << 16);
-      var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_322;
+      var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
+      var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
       var TEXT_DECODER_MIN_LENGTH = 12;
       var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf8");
       Pbf.prototype = {
@@ -5474,12 +5474,12 @@ var __exports__ = (() => {
           return val;
         },
         readFixed64: function() {
-          var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_322;
+          var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
           this.pos += 8;
           return val;
         },
         readSFixed64: function() {
-          var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_322;
+          var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
           this.pos += 8;
           return val;
         },
@@ -5542,7 +5542,7 @@ var __exports__ = (() => {
         readPackedVarint: function(arr, isSigned) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readVarint(isSigned));
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readVarint(isSigned));
@@ -5551,7 +5551,7 @@ var __exports__ = (() => {
         readPackedSVarint: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readSVarint());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readSVarint());
@@ -5560,7 +5560,7 @@ var __exports__ = (() => {
         readPackedBoolean: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readBoolean());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readBoolean());
@@ -5569,7 +5569,7 @@ var __exports__ = (() => {
         readPackedFloat: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readFloat());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readFloat());
@@ -5578,7 +5578,7 @@ var __exports__ = (() => {
         readPackedDouble: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readDouble());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readDouble());
@@ -5587,7 +5587,7 @@ var __exports__ = (() => {
         readPackedFixed32: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readFixed32());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readFixed32());
@@ -5596,7 +5596,7 @@ var __exports__ = (() => {
         readPackedSFixed32: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readSFixed32());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readSFixed32());
@@ -5605,7 +5605,7 @@ var __exports__ = (() => {
         readPackedFixed64: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readFixed64());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readFixed64());
@@ -5614,7 +5614,7 @@ var __exports__ = (() => {
         readPackedSFixed64: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readSFixed64());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readSFixed64());
@@ -5852,7 +5852,7 @@ var __exports__ = (() => {
           return toNum(l, h, s);
         throw new Error("Expected varint not more than 10 bytes");
       }
-      function readPackedEnd2(pbf) {
+      function readPackedEnd(pbf) {
         return pbf.type === Pbf.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
       }
       function toNum(low, high, isSigned) {
@@ -8317,6 +8317,7 @@ var __exports__ = (() => {
     TILE_FORMATS: () => TILE_FORMATS,
     _CartoTileLayer: () => CartoTileLayer,
     _H3TileLayer: () => H3TileLayer,
+    _PointLabelLayer: () => PointLabelLayer,
     _QuadbinTileLayer: () => QuadbinTileLayer,
     _getDataV2: () => getDataV2,
     _mapInstantiation: () => mapInstantiation,
@@ -8436,7 +8437,7 @@ var __exports__ = (() => {
   }
 
   // src/layers/carto-layer.ts
-  var import_core8 = __toESM(require_core());
+  var import_core9 = __toESM(require_core());
   var import_geo_layers8 = __toESM(require_geo_layers());
 
   // src/api/carto-api-error.ts
@@ -11127,6 +11128,20 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/layers/carto-tile-layer.ts
   var import_core = __toESM(require_core2());
 
+  // src/layers/schema/fast-pbf.ts
+  function readPackedDouble(pbf, obj) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new Float64Array(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
+  }
+  function readPackedFixed64(pbf, obj) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new BigUint64Array(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
+  }
+
   // src/layers/schema/carto-tile.ts
   var KeyValueObjectReader = class {
     static read(pbf, end) {
@@ -11144,13 +11159,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
   var PropertiesReader = class {
     static read(pbf, end) {
-      return pbf.readFields(PropertiesReader._readField, {
-        data: []
-      }, end);
+      return pbf.readFields(PropertiesReader._readField, {}, end);
     }
     static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.data.push(KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos));
+      if (tag === 1) {
+        const {
+          key,
+          value
+        } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj[key] = value;
+      }
     }
   };
   var DoublesReader = class {
@@ -11169,7 +11187,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        pbf.readPackedDouble(obj.value);
+        readPackedDouble(pbf, obj);
       else if (tag === 2)
         obj.size = pbf.readVarint(true);
     }
@@ -11214,7 +11232,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        pbf.readPackedDouble(obj.value);
+        readPackedDouble(pbf, obj);
     }
   };
   var NumericPropKeyValueReader = class {
@@ -11349,21 +11367,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const tile = TileReader3.read(pbf);
     return tile;
   }
-  function unpackProperties(properties) {
-    if (!properties || !properties.length) {
-      return [];
-    }
-    return properties.map((item) => {
-      const currentRecord = {};
-      item.data.forEach(({
-        key,
-        value
-      }) => {
-        currentRecord[key] = value;
-      });
-      return currentRecord;
-    });
-  }
 
   // src/layers/schema/carto-vector-tile-loader.ts
   var CartoVectorTileLoader = {
@@ -11383,26 +11386,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (!arrayBuffer)
       return null;
     const tile = parsePbf(arrayBuffer, TileReader);
-    const {
-      points,
-      lines,
-      polygons
-    } = tile;
-    const data = {
-      points: {
-        ...points,
-        properties: unpackProperties(points.properties)
-      },
-      lines: {
-        ...lines,
-        properties: unpackProperties(lines.properties)
-      },
-      polygons: {
-        ...polygons,
-        properties: unpackProperties(polygons.properties)
-      }
-    };
-    return data;
+    return tile;
   }
   var carto_vector_tile_loader_default = CartoVectorTileLoader;
 
@@ -11815,18 +11799,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/layers/schema/carto-spatial-tile.ts
   var IndicesReader = class {
     static read(pbf, end) {
-      const {
-        value
-      } = pbf.readFields(IndicesReader._readField, {
+      return pbf.readFields(IndicesReader._readField, {
         value: []
       }, end);
-      return {
-        value: new BigUint64Array(value)
-      };
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        readPackedFixed64(pbf, obj.value);
+        readPackedFixed64(pbf, obj);
     }
   };
   var CellsReader = class {
@@ -11862,24 +11841,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
     }
   };
-  var SHIFT_LEFT_32 = BigInt((1 << 16) * (1 << 16));
-  function readPackedEnd(pbf) {
-    return pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-  }
-  function readFixed64(pbf) {
-    const a = BigInt(pbf.readFixed32());
-    const b = BigInt(pbf.readFixed32());
-    return a + b * SHIFT_LEFT_32;
-  }
-  function readPackedFixed64(pbf, arr) {
-    if (pbf.type !== 2)
-      return arr.push(readFixed64(pbf));
-    const end = readPackedEnd(pbf);
-    arr = arr || [];
-    while (pbf.pos < end)
-      arr.push(readFixed64(pbf));
-    return arr;
-  }
 
   // ../../node_modules/quadbin/dist/esm/index.js
   var B = [
@@ -11993,10 +11954,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     } = tile;
     const scheme = options?.cartoSpatialTile?.scheme;
     const data = {
-      cells: {
-        ...cells,
-        properties: unpackProperties(cells.properties)
-      },
+      cells,
       scheme
     };
     return binaryToSpatialjson(data);
@@ -12092,11 +12050,28 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       } = this.state;
       const data = tile.content;
       const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
-      if (!isFeatureIdPresent || !Array.isArray(data)) {
+      if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
         return -1;
       }
       return data.findIndex((feature) => feature.id === hoveredFeatureId);
     }
+    _featureInTile(tile, featureId) {
+      const {
+        getTileZoom,
+        getParentIndex
+      } = this.state.tileset;
+      const tileZoom = getTileZoom(tile.index);
+      const KEY = tile.index.q ? "q" : "i";
+      let featureIndex = {
+        [KEY]: featureId
+      };
+      let featureZoom = getTileZoom(featureIndex);
+      while (!(featureZoom <= tileZoom)) {
+        featureIndex = getParentIndex(featureIndex);
+        featureZoom = getTileZoom(featureIndex);
+      }
+      return featureIndex[KEY] === tile.index[KEY];
+    }
   };
   __publicField(SpatialIndexTileLayer, "layerName", "SpatialIndexTileLayer");
   __publicField(SpatialIndexTileLayer, "defaultProps", defaultProps2);
@@ -12448,7 +12423,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function getLayer(type, config, dataset) {
     let basePropMap = sharedPropMap;
-    if (config.visConfig?.customMarkers && !config.textLabel) {
+    if (config.visConfig?.customMarkers) {
       basePropMap = mergePropMaps(sharedPropMap, customMarkersPropsMap);
     }
     if (type === "mvt" || type === "tileset" || type === "h3" || type === "quadbin") {
@@ -12624,10 +12599,30 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function normalizeAccessor(accessor, data) {
     if (data.features || data.tilestats) {
-      return ({
-        properties
-      }) => {
-        return accessor(properties);
+      return (object, info) => {
+        if (object) {
+          return accessor(object.properties || object.__source.object.properties);
+        }
+        const {
+          data: data2,
+          index
+        } = info;
+        const {
+          properties,
+          numericProps
+        } = data2;
+        const proxy = new Proxy(properties[index] || {}, {
+          get(target, property, receiver) {
+            if (property in numericProps) {
+              return numericProps[property].value[index];
+            }
+            return target[property];
+          },
+          has(target, property) {
+            return property in numericProps || property in target;
+          }
+        });
+        return accessor(proxy);
       };
     }
     return accessor;
@@ -12788,23 +12783,195 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     };
     return normalizeAccessor(accessor, data);
   }
-  function getTextPixelOffsetAccessor({
-    alignment,
-    anchor,
-    size
-  }, radius) {
-    const padding = 20;
-    const signX = anchor === "middle" ? 0 : anchor === "start" ? 1 : -1;
-    const signY = alignment === "center" ? 0 : alignment === "bottom" ? 1 : -1;
-    const sizeOffset = alignment === "center" ? 0 : size;
-    const calculateOffset = (r) => [signX * (r + padding), signY * (r + padding + sizeOffset)];
-    return typeof radius === "function" ? (d) => {
-      return calculateOffset(radius(d));
-    } : calculateOffset(radius);
-  }
 
-  // src/api/parseMap.ts
+  // src/layers/point-label-layer.ts
   var import_core6 = __toESM(require_core());
+  var import_layers3 = __toESM(require_layers());
+  var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
+  var EnhancedTextBackgroundLayer = class extends import_layers3._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
+      };
+    }
+  };
+  __publicField(EnhancedTextBackgroundLayer, "layerName", "EnhancedTextBackgroundLayer");
+  var EnhancedTextLayer = class extends import_layers3.TextLayer {
+    filterSubLayer({
+      layer,
+      renderPass
+    }) {
+      const background = layer.id.includes("primary-background");
+      if (renderPass === "collision") {
+        return background;
+      }
+      return !background;
+    }
+  };
+  __publicField(EnhancedTextLayer, "layerName", "EnhancedTextLayer");
+  var defaultProps7 = {
+    ...import_layers3.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(id, {
+      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,
+        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;
+    }
+  };
+  __publicField(PointLabelLayer, "layerName", "PointLabelLayer");
+  __publicField(PointLabelLayer, "defaultProps", defaultProps7);
+
+  // src/api/parseMap.ts
+  var import_core7 = __toESM(require_core());
+  var import_extensions2 = __toESM(require_extensions());
+  var collisionFilterExtension = new import_extensions2.CollisionFilterExtension();
   function parseMap(json) {
     const {
       keplerMapConfig,
@@ -12830,7 +12997,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       initialViewState: mapState,
       mapStyle,
       token,
-      layers: extractTextLayers(layers.reverse()).map(({
+      layers: layers.reverse().map(({
         id,
         type,
         config,
@@ -12849,60 +13016,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           const {
             Layer,
             propMap,
-            defaultProps: defaultProps8
+            defaultProps: defaultProps9
           } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
           return new Layer({
             id,
             data,
-            ...defaultProps8,
-            ...!config.textLabel && createInteractionProps(interactionConfig),
+            ...defaultProps9,
+            ...createInteractionProps(interactionConfig),
             ...styleProps,
-            ...createChannelProps(visualChannels, type, config, data),
+            ...createChannelProps(id, type, config, visualChannels, data),
             ...createParametersProp(layerBlending, styleProps.parameters || {}),
             ...createLoadOptions(token)
           });
         } catch (e) {
-          import_core6.log.error(e.message)();
+          import_core7.log.error(e.message)();
           return void 0;
         }
       })
     };
   }
-  function extractTextLayers(layers) {
-    return (0, import_core6._flatten)(layers.map(({
-      id,
-      config,
-      ...rest
-    }) => {
-      const {
-        textLabel,
-        ...configRest
-      } = config;
-      return [
-        {
-          id,
-          config: configRest,
-          ...rest
-        },
-        ...textLabel.filter((t) => t.field).map((t) => {
-          return {
-            id: `${id}-label-${t.field.name}`,
-            config: {
-              textLabel: t,
-              ...configRest,
-              label: `${config.label}-label-${t.field.name}`,
-              visConfig: {
-                ...configRest.visConfig,
-                opacity: 1
-              }
-            },
-            ...rest
-          };
-        })
-      ];
-    }));
-  }
   function createParametersProp(layerBlending, parameters) {
     if (layerBlending === "additive") {
       parameters.blendFunc = [esm_default.SRC_ALPHA, esm_default.DST_ALPHA];
@@ -12957,7 +13090,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
     return result;
   }
-  function createChannelProps(visualChannels, type, config, data) {
+  function createChannelProps(id, type, config, visualChannels, data) {
     const {
       colorField,
       colorScale,
@@ -12981,7 +13114,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       visConfig
     } = config;
     const result = {};
-    const textLabelField = textLabel && textLabel.field;
     if (type === "grid" || type === "hexagon") {
       result.colorScaleType = colorScale;
       if (colorField) {
@@ -13066,12 +13198,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         data
       );
     }
-    if (textLabelField) {
-      result.getText = getTextAccessor(textLabelField, data);
-      result.pointType = "text";
-      const radius = result.getPointRadius || visConfig.radius;
-      result.getTextPixelOffset = getTextPixelOffsetAccessor(textLabel, radius);
-    } else if (visConfig.customMarkers) {
+    if (visConfig.customMarkers) {
       const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
       const {
         getPointRadius,
@@ -13111,6 +13238,55 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       if (visualChannels.rotationField) {
         result.getIconAngle = negateAccessor(getSizeAccessor(visualChannels.rotationField, void 0, null, void 0, data));
       }
+    } else if (type === "point" || type === "tileset") {
+      result.pointType = "circle";
+    }
+    if (textLabel && textLabel.length && textLabel[0].field) {
+      const [mainLabel, secondaryLabel] = textLabel;
+      const collisionGroup = id;
+      ({
+        alignment: result.getTextAlignmentBaseline,
+        anchor: result.getTextAnchor,
+        color: result.getTextColor,
+        outlineColor: result.textOutlineColor,
+        size: result.textSizeScale
+      } = mainLabel);
+      const {
+        color: getSecondaryColor,
+        field: secondaryField,
+        outlineColor: secondaryOutlineColor,
+        size: secondarySizeScale
+      } = secondaryLabel || {};
+      result.getText = mainLabel.field && getTextAccessor(mainLabel.field, data);
+      const getSecondaryText = secondaryField && getTextAccessor(secondaryField, data);
+      result.pointType = `${result.pointType}+text`;
+      result.textCharacterSet = "auto";
+      result.textFontFamily = "Inter, sans";
+      result.textFontSettings = {
+        sdf: true
+      };
+      result.textFontWeight = 600;
+      result.textOutlineWidth = 3;
+      result._subLayerProps = {
+        ...result._subLayerProps,
+        "points-text": {
+          type: PointLabelLayer,
+          extensions: [collisionFilterExtension],
+          collisionEnabled: true,
+          collisionGroup,
+          ...result.getPointRadius ? {
+            getRadius: result.getPointRadius
+          } : {
+            radiusScale: visConfig.radius
+          },
+          ...secondaryField && {
+            getSecondaryText,
+            getSecondaryColor,
+            secondarySizeScale,
+            secondaryOutlineColor
+          }
+        }
+      };
     }
     return result;
   }
@@ -13127,7 +13303,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/api/maps-v3-client.ts
-  var import_core7 = __toESM(require_core());
+  var import_core8 = __toESM(require_core());
   var MAX_GET_LENGTH = 8192;
   var DEFAULT_CLIENT = "deck-gl-carto";
   var V3_MINOR_VERSION = "3.1";
@@ -13454,7 +13630,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       assert2(url && mapFormat, "Unsupported data formats received from backend.");
     }
     if (format2 === FORMATS.TILEJSON && formatTiles) {
-      import_core7.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
+      import_core8.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
       url += `&${encodeParameter("formatTiles", formatTiles)}`;
     }
     const {
@@ -13666,16 +13842,25 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     });
     await fillInMapDatasets(map2, clientId, localCreds, headers);
     await fillInTileStats(map2, localCreds);
-    return {
+    const out = {
       ...parseMap(map2),
       ...{
         stopAutoRefresh
       }
     };
+    const textLayers = out.layers.filter((layer) => {
+      const pointType = layer.props.pointType || "";
+      return pointType.includes("text");
+    });
+    if (textLayers.length && window.FontFace && !document.fonts.check("12px Inter")) {
+      const font = new FontFace("Inter", "url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)");
+      await font.load().then((f) => document.fonts.add(f));
+    }
+    return out;
   }
 
   // src/layers/carto-layer.ts
-  var defaultProps7 = {
+  var defaultProps8 = {
     data: null,
     type: null,
     onDataLoad: {
@@ -13708,7 +13893,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     aggregationResLevel: null,
     queryParameters: null
   };
-  var CartoLayer = class extends import_core8.CompositeLayer {
+  var CartoLayer = class extends import_core9.CompositeLayer {
     initializeState() {
       this.state = {
         data: null,
@@ -13733,23 +13918,23 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       const {
         apiVersion
       } = localCreds;
-      import_core8.log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
+      import_core9.log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
       if (apiVersion === API_VERSIONS.V1 || apiVersion === API_VERSIONS.V2) {
-        import_core8.log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
-        import_core8.log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
-        import_core8.log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
-        import_core8.log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
+        import_core9.log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
+        import_core9.log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
+        import_core9.log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
+        import_core9.log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
       } else if (apiVersion === API_VERSIONS.V3) {
-        import_core8.log.assert(connection, "Missing mandatory connection parameter");
-        import_core8.log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
+        import_core9.log.assert(connection, "Missing mandatory connection parameter");
+        import_core9.log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
         if (!COLUMNS_SUPPORT.includes(type)) {
-          import_core8.log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
+          import_core9.log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
         }
         if (!GEO_COLUMN_SUPPORT.includes(type)) {
-          import_core8.log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
+          import_core9.log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
         }
         if (columns) {
-          import_core8.log.assert(Array.isArray(columns), "columns prop must be an Array");
+          import_core9.log.assert(Array.isArray(columns), "columns prop must be an Array");
         }
       }
     }
@@ -13827,7 +14012,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       } = this.state;
       const {
         uniqueIdProperty
-      } = defaultProps7;
+      } = defaultProps8;
       const {
         data: _notUsed,
         ...propsNoData
@@ -13880,7 +14065,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(CartoLayer, "layerName", "CartoLayer");
-  __publicField(CartoLayer, "defaultProps", defaultProps7);
+  __publicField(CartoLayer, "defaultProps", defaultProps8);
 
   // src/basemap.ts
   var baseUrl = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
@@ -14006,9 +14191,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
-  var import_layers3 = __toESM(require_layers());
+  var import_layers4 = __toESM(require_layers());
   __reExport(peer_dependency_exports, __toESM(require_layers()));
-  if (!import_layers3.GeoJsonLayer) {
+  if (!import_layers4.GeoJsonLayer) {
     throw new Error("@deck.gl/layers is not found");
   }