@deck.gl/carto 9.1.9 → 9.1.11

package/dist/dist.dev.js

@@ -11519,7 +11519,110 @@ var __exports__ = (() => {
   }
 
   // src/layers/cluster-utils.ts
+  var import_core2 = __toESM(require_core2(), 1);
+
+  // src/utils.ts
   var import_core = __toESM(require_core2(), 1);
+  function assert2(condition, message) {
+    import_core.log.assert(condition, message);
+  }
+  function createBinaryProxy(data, index2) {
+    const { properties, numericProps } = data;
+    return new Proxy(properties[index2] || {}, {
+      get(target, property) {
+        if (property in numericProps) {
+          return numericProps[property].value[index2];
+        }
+        return target[property];
+      },
+      has(target, property) {
+        return property in numericProps || property in target;
+      },
+      ownKeys(target) {
+        return [...Object.keys(numericProps), ...Reflect.ownKeys(target)];
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return { enumerable: true, configurable: true };
+      }
+    });
+  }
+  function getWorkerUrl(id5, version) {
+    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id5}-worker.js`;
+  }
+  function scaleIdentity() {
+    let unknown;
+    function scale(x) {
+      return x === null ? unknown : x;
+    }
+    scale.invert = scale;
+    scale.domain = scale.range = (d) => d;
+    scale.unknown = (u) => {
+      if (u) {
+        unknown = u;
+      }
+      return unknown;
+    };
+    scale.copy = () => {
+      const scaleCopy = scaleIdentity();
+      scaleCopy.unknown(unknown);
+      return scaleCopy;
+    };
+    return scale;
+  }
+  var EMPTY_UINT16ARRAY = new Uint16Array();
+  var EMPTY_BINARY_PROPS = {
+    positions: { value: new Float32Array(), size: 2 },
+    properties: [],
+    numericProps: {},
+    featureIds: { value: EMPTY_UINT16ARRAY, size: 1 },
+    globalFeatureIds: { value: EMPTY_UINT16ARRAY, size: 1 }
+  };
+  function createEmptyBinary() {
+    return {
+      shape: "binary-feature-collection",
+      points: {
+        type: "Point",
+        ...EMPTY_BINARY_PROPS
+      },
+      lines: {
+        type: "LineString",
+        pathIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+        ...EMPTY_BINARY_PROPS
+      },
+      polygons: {
+        type: "Polygon",
+        polygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+        primitivePolygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+        ...EMPTY_BINARY_PROPS
+      }
+    };
+  }
+  function createBinaryPointFeature(positions, featureIds, globalFeatureIds, numericProps, properties, size = 2) {
+    return {
+      type: "Point",
+      positions: { value: new Float32Array(positions), size },
+      featureIds: { value: new Uint16Array(featureIds), size: 1 },
+      globalFeatureIds: { value: new Uint32Array(globalFeatureIds), size: 1 },
+      numericProps,
+      properties
+    };
+  }
+  function initializeNumericProps(numPoints, sourceProps) {
+    const numericProps = {};
+    if (sourceProps) {
+      Object.keys(sourceProps).forEach((prop) => {
+        numericProps[prop] = { value: new Float32Array(numPoints), size: 1 };
+      });
+    }
+    return numericProps;
+  }
+  function copyNumericProps(sourceProps, targetProps, sourceIndex, targetIndex) {
+    Object.keys(sourceProps).forEach((prop) => {
+      targetProps[prop].value[targetIndex] = sourceProps[prop].value[sourceIndex];
+    });
+  }
+
+  // src/layers/cluster-utils.ts
   function aggregateTile(tile, tileAggregationCache, aggregationLevels, properties = [], getPosition, getWeight) {
     if (!tile.content)
       return false;
@@ -11579,7 +11682,7 @@ var __exports__ = (() => {
     for (const name of Object.keys(tile.content[0].properties)) {
       let aggregation = name.split("_").pop().toLowerCase();
       if (!validAggregations.includes(aggregation)) {
-        import_core.log.warn(`No valid aggregation present in ${name} property`)();
+        import_core2.log.warn(`No valid aggregation present in ${name} property`)();
         aggregation = "any";
       }
       properties.push({ name, aggregation });
@@ -11599,14 +11702,6 @@ var __exports__ = (() => {
     }
     return stats;
   }
-  var EMPTY_UINT16ARRAY = new Uint16Array();
-  var EMPTY_BINARY_PROPS = {
-    positions: { value: new Float32Array(), size: 2 },
-    properties: [],
-    numericProps: {},
-    featureIds: { value: EMPTY_UINT16ARRAY, size: 1 },
-    globalFeatureIds: { value: EMPTY_UINT16ARRAY, size: 1 }
-  };
   function clustersToBinary(data) {
     const positions = new Float32Array(data.length * 2);
     const featureIds = new Uint16Array(data.length);
@@ -11615,26 +11710,8 @@ var __exports__ = (() => {
       featureIds[i] = i;
     }
     return {
-      shape: "binary-feature-collection",
-      points: {
-        type: "Point",
-        positions: { value: positions, size: 2 },
-        properties: data,
-        numericProps: {},
-        featureIds: { value: featureIds, size: 1 },
-        globalFeatureIds: { value: featureIds, size: 1 }
-      },
-      lines: {
-        type: "LineString",
-        pathIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
-        ...EMPTY_BINARY_PROPS
-      },
-      polygons: {
-        type: "Polygon",
-        polygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
-        primitivePolygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
-        ...EMPTY_BINARY_PROPS
-      }
+      ...createEmptyBinary(),
+      points: createBinaryPointFeature(positions, featureIds, featureIds, {}, data)
     };
   }
 
@@ -12212,55 +12289,6 @@ var __exports__ = (() => {
     return tile;
   }
 
-  // src/utils.ts
-  var import_core2 = __toESM(require_core2(), 1);
-  function assert2(condition, message) {
-    import_core2.log.assert(condition, message);
-  }
-  function createBinaryProxy(data, index2) {
-    const { properties, numericProps } = data;
-    return new Proxy(properties[index2] || {}, {
-      get(target, property) {
-        if (property in numericProps) {
-          return numericProps[property].value[index2];
-        }
-        return target[property];
-      },
-      has(target, property) {
-        return property in numericProps || property in target;
-      },
-      ownKeys(target) {
-        return [...Object.keys(numericProps), ...Reflect.ownKeys(target)];
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        return { enumerable: true, configurable: true };
-      }
-    });
-  }
-  function getWorkerUrl(id5, version) {
-    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id5}-worker.js`;
-  }
-  function scaleIdentity() {
-    let unknown;
-    function scale(x) {
-      return x === null ? unknown : x;
-    }
-    scale.invert = scale;
-    scale.domain = scale.range = (d) => d;
-    scale.unknown = (u) => {
-      if (u) {
-        unknown = u;
-      }
-      return unknown;
-    };
-    scale.copy = () => {
-      const scaleCopy = scaleIdentity();
-      scaleCopy.unknown(unknown);
-      return scaleCopy;
-    };
-    return scale;
-  }
-
   // src/layers/schema/spatialjson-utils.ts
   function binaryToSpatialjson(binary) {
     const { cells, scheme } = binary;
@@ -12313,13 +12341,29 @@ var __exports__ = (() => {
   // src/layers/utils.ts
   var import_core3 = __toESM(require_core2(), 1);
   var import_core4 = __toESM(require_core2(), 1);
-  function injectAccessToken(loadOptions, accessToken) {
-    if (!loadOptions?.fetch?.headers?.Authorization) {
-      loadOptions.fetch = {
-        ...loadOptions.fetch,
-        headers: { ...loadOptions.fetch?.headers, Authorization: `Bearer ${accessToken}` }
-      };
+  function mergeLoadOptions(loadOptions, additionalOptions, depth = 0) {
+    if (!loadOptions) {
+      return additionalOptions;
+    }
+    if (!additionalOptions) {
+      return loadOptions;
+    }
+    if (depth > 10) {
+      return additionalOptions;
+    }
+    const result = { ...loadOptions };
+    for (const key in additionalOptions) {
+      const value = additionalOptions[key];
+      if (value === loadOptions || value === additionalOptions) {
+        continue;
+      }
+      if (typeof value === "object" && value !== null) {
+        result[key] = mergeLoadOptions(loadOptions[key], value, depth + 1);
+      } else {
+        result[key] = value;
+      }
     }
+    return result;
   }
   function mergeBoundaryData(geometry, properties) {
     const mapping = {};
@@ -12472,11 +12516,11 @@ var __exports__ = (() => {
   ClusterGeoJsonLayer.defaultProps = defaultProps;
   var ClusterTileLayer = class extends import_core6.CompositeLayer {
     getLoadOptions() {
-      const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
-      injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
-      return loadOptions;
+      return mergeLoadOptions(super.getLoadOptions(), {
+        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
+        cartoSpatialTile: { scheme: "quadbin" }
+      });
     }
     renderLayers() {
       const tileJSON = this.props.data;
@@ -12696,11 +12740,11 @@ var __exports__ = (() => {
       import_geo_layers5.H3HexagonLayer._checkH3Lib();
     }
     getLoadOptions() {
-      const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
-      injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "h3" };
-      return loadOptions;
+      return mergeLoadOptions(super.getLoadOptions(), {
+        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
+        cartoSpatialTile: { scheme: "h3" }
+      });
     }
     renderLayers() {
       const tileJSON = this.props.data;
@@ -13045,11 +13089,11 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
   var QuadbinTileLayer = class extends import_core10.CompositeLayer {
     getLoadOptions() {
-      const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
-      injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
-      return loadOptions;
+      return mergeLoadOptions(super.getLoadOptions(), {
+        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
+        cartoSpatialTile: { scheme: "quadbin" }
+      });
     }
     renderLayers() {
       const tileJSON = this.props.data;
@@ -13410,6 +13454,12 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
         getTextAnchor,
         updateTriggers
       } = this.props;
+      if (sizeScale < 2) {
+        const propName = this.parent?.props?.textSizeScale ? "textSizeScale" : "sizeScale";
+        import_core12.log.warn(
+          `${propName} has small value (${sizeScale}). Note getTextSize is not supported on PointLabelLayer`
+        )();
+      }
       return new EnhancedTextLayer(
         this.getSubLayerProps({
           id: id5,
@@ -13837,10 +13887,10 @@ void main(void) {
   };
   var RasterTileLayer = class extends import_core14.CompositeLayer {
     getLoadOptions() {
-      const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
-      injectAccessToken(loadOptions, tileJSON.accessToken);
-      return loadOptions;
+      return mergeLoadOptions(super.getLoadOptions(), {
+        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } }
+      });
     }
     renderLayers() {
       const tileJSON = this.props.data;
@@ -13979,9 +14029,247 @@ void main(void) {
   var import_extensions = __toESM(require_extensions(), 1);
   var import_geo_layers8 = __toESM(require_geo_layers(), 1);
   var import_layers5 = __toESM(require_layers(), 1);
+
+  // src/layers/label-utils.ts
+  function createPointsFromLines(lines, uniqueIdProperty) {
+    const hasNumericUniqueId = uniqueIdProperty ? uniqueIdProperty in lines.numericProps : false;
+    const idToLineInfo = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lines.pathIndices.value.length - 1; i++) {
+      const pathIndex = lines.pathIndices.value[i];
+      const featureId = lines.featureIds.value[pathIndex];
+      let uniqueId;
+      if (uniqueIdProperty === void 0) {
+        uniqueId = featureId;
+      } else if (hasNumericUniqueId) {
+        uniqueId = lines.numericProps[uniqueIdProperty].value[pathIndex];
+      } else if (lines.properties[featureId] && uniqueIdProperty in lines.properties[featureId]) {
+        uniqueId = lines.properties[featureId][uniqueIdProperty];
+      } else {
+        uniqueId = void 0;
+      }
+      const length = getLineLength(lines, i);
+      if (!idToLineInfo.has(uniqueId) || length > idToLineInfo.get(uniqueId).length) {
+        idToLineInfo.set(uniqueId, { index: i, length });
+      }
+    }
+    const positions = [];
+    const properties = [];
+    const featureIds = [];
+    const globalFeatureIds = [];
+    const numericProps = initializeNumericProps(idToLineInfo.size, lines.numericProps);
+    let pointIndex = 0;
+    for (const [_, { index: index2 }] of idToLineInfo) {
+      const midpoint = getLineMidpoint(lines, index2);
+      positions.push(...midpoint);
+      const pathIndex = lines.pathIndices.value[index2];
+      const featureId = lines.featureIds.value[pathIndex];
+      featureIds.push(pointIndex);
+      properties.push(lines.properties[featureId]);
+      globalFeatureIds.push(lines.globalFeatureIds.value[pathIndex]);
+      copyNumericProps(lines.numericProps, numericProps, pathIndex, pointIndex);
+      pointIndex++;
+    }
+    return createBinaryPointFeature(
+      positions,
+      featureIds,
+      globalFeatureIds,
+      numericProps,
+      properties
+    );
+  }
+  function createPointsFromPolygons(polygons, tileBbox, props) {
+    const { west, south, east, north } = tileBbox;
+    const tileArea = (east - west) * (north - south);
+    const minPolygonArea = tileArea * 1e-4;
+    const positions = [];
+    const properties = [];
+    const featureIds = [];
+    const globalFeatureIds = [];
+    const numericProps = initializeNumericProps(
+      polygons.polygonIndices.value.length - 1,
+      polygons.numericProps
+    );
+    let pointIndex = 0;
+    let triangleIndex = 0;
+    const { extruded } = props;
+    for (let i = 0; i < polygons.polygonIndices.value.length - 1; i++) {
+      const startIndex = polygons.polygonIndices.value[i];
+      const endIndex = polygons.polygonIndices.value[i + 1];
+      if (getPolygonArea(polygons, i) < minPolygonArea) {
+        continue;
+      }
+      const centroid = getPolygonCentroid(polygons, i);
+      let maxArea = -1;
+      let largestTriangleCenter = [0, 0];
+      let centroidIsInside = false;
+      while (triangleIndex < polygons.triangles.value.length) {
+        const i1 = polygons.triangles.value[triangleIndex];
+        if (i1 >= endIndex) {
+          break;
+        }
+        if (centroidIsInside) {
+          triangleIndex += 3;
+          continue;
+        }
+        const i2 = polygons.triangles.value[triangleIndex + 1];
+        const i3 = polygons.triangles.value[triangleIndex + 2];
+        const v1 = polygons.positions.value.subarray(
+          i1 * polygons.positions.size,
+          i1 * polygons.positions.size + polygons.positions.size
+        );
+        const v2 = polygons.positions.value.subarray(
+          i2 * polygons.positions.size,
+          i2 * polygons.positions.size + polygons.positions.size
+        );
+        const v3 = polygons.positions.value.subarray(
+          i3 * polygons.positions.size,
+          i3 * polygons.positions.size + polygons.positions.size
+        );
+        if (isPointInTriangle(centroid, v1, v2, v3)) {
+          centroidIsInside = true;
+        } else {
+          const area = getTriangleArea(v1, v2, v3);
+          if (area > maxArea) {
+            maxArea = area;
+            largestTriangleCenter = [(v1[0] + v2[0] + v3[0]) / 3, (v1[1] + v2[1] + v3[1]) / 3];
+          }
+        }
+        triangleIndex += 3;
+      }
+      const labelPoint = centroidIsInside ? centroid : largestTriangleCenter;
+      if (isPointInBounds(labelPoint, tileBbox)) {
+        positions.push(...labelPoint);
+        const featureId = polygons.featureIds.value[startIndex];
+        if (extruded) {
+          const elevation = props.getElevation(void 0, {
+            data: polygons,
+            index: featureId
+          });
+          positions.push(elevation * props.elevationScale);
+        }
+        properties.push(polygons.properties[featureId]);
+        featureIds.push(pointIndex);
+        globalFeatureIds.push(polygons.globalFeatureIds.value[startIndex]);
+        copyNumericProps(polygons.numericProps, numericProps, startIndex, pointIndex);
+        pointIndex++;
+      }
+    }
+    if (polygons.numericProps) {
+      Object.keys(numericProps).forEach((prop) => {
+        numericProps[prop].value = numericProps[prop].value.slice(0, pointIndex);
+      });
+    }
+    return createBinaryPointFeature(
+      positions,
+      featureIds,
+      globalFeatureIds,
+      numericProps,
+      properties,
+      extruded ? 3 : 2
+    );
+  }
+  function getPolygonArea(polygons, index2) {
+    const {
+      positions: { value: positions, size },
+      polygonIndices: { value: indices },
+      triangles: { value: triangles }
+    } = polygons;
+    const startIndex = indices[index2];
+    const endIndex = indices[index2 + 1];
+    let area = 0;
+    let triangleIndex = 0;
+    while (triangleIndex < triangles.length) {
+      const i1 = triangles[triangleIndex];
+      if (i1 >= startIndex)
+        break;
+      triangleIndex += 3;
+    }
+    while (triangleIndex < triangles.length) {
+      const i1 = triangles[triangleIndex];
+      if (i1 >= endIndex)
+        break;
+      const i2 = triangles[triangleIndex + 1];
+      const i3 = triangles[triangleIndex + 2];
+      const v1 = positions.subarray(i1 * size, i1 * size + size);
+      const v2 = positions.subarray(i2 * size, i2 * size + size);
+      const v3 = positions.subarray(i3 * size, i3 * size + size);
+      area += getTriangleArea(v1, v2, v3);
+      triangleIndex += 3;
+    }
+    return area;
+  }
+  function isPointInBounds([x, y], { west, east, south, north }) {
+    return x >= west && x < east && y >= south && y < north;
+  }
+  function isPointInTriangle(p, v1, v2, v3) {
+    const area = Math.abs((v2[0] - v1[0]) * (v3[1] - v1[1]) - (v3[0] - v1[0]) * (v2[1] - v1[1])) / 2;
+    const area1 = Math.abs((v1[0] - p[0]) * (v2[1] - p[1]) - (v2[0] - p[0]) * (v1[1] - p[1])) / 2;
+    const area2 = Math.abs((v2[0] - p[0]) * (v3[1] - p[1]) - (v3[0] - p[0]) * (v2[1] - p[1])) / 2;
+    const area3 = Math.abs((v3[0] - p[0]) * (v1[1] - p[1]) - (v1[0] - p[0]) * (v3[1] - p[1])) / 2;
+    return Math.abs(area - (area1 + area2 + area3)) < 1e-10;
+  }
+  function getTriangleArea([x1, y1], [x2, y2], [x3, y3]) {
+    return Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2);
+  }
+  function getPolygonCentroid(polygons, index2) {
+    const {
+      positions: { value: positions, size }
+    } = polygons;
+    const startIndex = size * polygons.polygonIndices.value[index2];
+    const endIndex = size * polygons.polygonIndices.value[index2 + 1];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = startIndex; i < endIndex; i += size) {
+      const [x, y] = positions.subarray(i, i + 2);
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+    return [(minX + maxX) / 2, (minY + maxY) / 2];
+  }
+  function getSegmentLength(lines, index2) {
+    const {
+      positions: { value }
+    } = lines;
+    const [x1, y1, x2, y2] = value.subarray(index2, index2 + 4);
+    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+  }
+  function getLineLength(lines, index2) {
+    const {
+      positions: { size }
+    } = lines;
+    const startIndex = size * lines.pathIndices.value[index2];
+    const endIndex = size * lines.pathIndices.value[index2 + 1];
+    let length = 0;
+    for (let j = startIndex; j < endIndex; j += size) {
+      length += getSegmentLength(lines, j);
+    }
+    return length;
+  }
+  function getLineMidpoint(lines, index2) {
+    const {
+      positions: { value: positions },
+      pathIndices: { value: pathIndices }
+    } = lines;
+    const startIndex = pathIndices[index2] * 2;
+    const endIndex = pathIndices[index2 + 1] * 2;
+    const numPoints = (endIndex - startIndex) / 2;
+    if (numPoints === 2) {
+      const [x1, y1, x2, y2] = positions.subarray(startIndex, startIndex + 4);
+      return [(x1 + x2) / 2, (y1 + y2) / 2];
+    }
+    const midPointIndex = startIndex + Math.floor(numPoints / 2) * 2;
+    return [positions[midPointIndex], positions[midPointIndex + 1]];
+  }
+
+  // src/layers/vector-tile-layer.ts
   (0, import_core16.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
   var defaultProps10 = {
     ...import_geo_layers8.MVTLayer.defaultProps,
+    autoLabels: false,
     data: TilejsonPropType,
     dataComparator: TilejsonPropType.equal,
     tileSize: DEFAULT_TILE_SIZE
@@ -14004,11 +14292,12 @@ void main(void) {
       }
     }
     getLoadOptions() {
-      const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
-      injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.gis = { format: "binary" };
-      return loadOptions;
+      return mergeLoadOptions(super.getLoadOptions(), {
+        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
+        gis: { format: "binary" }
+        // Use binary for MVT loading
+      });
     }
     /* eslint-disable camelcase */
     async getTileData(tile) {
@@ -14045,24 +14334,8 @@ void main(void) {
       if (props.data === null) {
         return null;
       }
-      if (this.state.mvt) {
-        return super.renderSubLayers(props);
-      }
       const tileBbox = props.tile.bbox;
-      const { west, south, east, north } = tileBbox;
-      const extensions = [new import_extensions.ClipExtension(), ...props.extensions || []];
-      const clipProps = {
-        clipBounds: [west, south, east, north]
-      };
-      const applyClipExtensionToSublayerProps = (subLayerId) => {
-        return {
-          [subLayerId]: {
-            ...clipProps,
-            ...props?._subLayerProps?.[subLayerId],
-            extensions: [...extensions, ...props?._subLayerProps?.[subLayerId]?.extensions || []]
-          }
-        };
-      };
+      const subLayers = [];
       const defaultToPointLabelLayer = {
         "points-text": {
           type: PointLabelLayer,
@@ -14074,20 +14347,78 @@ void main(void) {
           ]
         }
       };
-      const subLayerProps = {
-        ...props,
-        autoHighlight: false,
-        // Do not perform clipping on points (#9059)
-        _subLayerProps: {
-          ...props._subLayerProps,
-          ...defaultToPointLabelLayer,
-          ...applyClipExtensionToSublayerProps("polygons-fill"),
-          ...applyClipExtensionToSublayerProps("polygons-stroke"),
-          ...applyClipExtensionToSublayerProps("linestrings")
+      if (this.state.mvt) {
+        subLayers.push(super.renderSubLayers(props));
+      } else {
+        const { west, south, east, north } = tileBbox;
+        const extensions = [new import_extensions.ClipExtension(), ...props.extensions || []];
+        const clipProps = {
+          clipBounds: [west, south, east, north]
+        };
+        const applyClipExtensionToSublayerProps = (subLayerId) => {
+          return {
+            [subLayerId]: {
+              ...clipProps,
+              ...props?._subLayerProps?.[subLayerId],
+              extensions: [...extensions, ...props?._subLayerProps?.[subLayerId]?.extensions || []]
+            }
+          };
+        };
+        const subLayerProps = {
+          ...props,
+          data: { ...props.data, tileBbox },
+          autoHighlight: false,
+          // Do not perform clipping on points (#9059)
+          _subLayerProps: {
+            ...props._subLayerProps,
+            ...defaultToPointLabelLayer,
+            ...applyClipExtensionToSublayerProps("polygons-fill"),
+            ...applyClipExtensionToSublayerProps("polygons-stroke"),
+            ...applyClipExtensionToSublayerProps("linestrings")
+          }
+        };
+        subLayers.push(new import_layers5.GeoJsonLayer(subLayerProps));
+      }
+      if (subLayers[0] && props.autoLabels) {
+        const labelData = createEmptyBinary();
+        if (props.data.lines && props.data.lines.positions.value.length > 0) {
+          labelData.points = createPointsFromLines(
+            props.data.lines,
+            typeof props.autoLabels === "object" ? props.autoLabels.uniqueIdProperty : void 0
+          );
         }
-      };
-      const subLayer = new import_layers5.GeoJsonLayer(subLayerProps);
-      return subLayer;
+        if (props.data.polygons && props.data.polygons.positions.value.length > 0) {
+          labelData.points = createPointsFromPolygons(props.data.polygons, tileBbox, props);
+        }
+        subLayers.push(
+          subLayers[0].clone({
+            id: `${props.id}-labels`,
+            data: labelData,
+            pickable: false,
+            autoHighlight: false
+          })
+        );
+      }
+      return subLayers;
+    }
+    renderLayers() {
+      const layers = super.renderLayers();
+      if (!this.props.autoLabels) {
+        return layers;
+      }
+      const validLayers = layers.flat().filter(Boolean);
+      validLayers.sort((a, b) => {
+        const aHasLabel = a.id.includes("labels");
+        const bHasLabel = b.id.includes("labels");
+        if (aHasLabel && !bHasLabel)
+          return 1;
+        if (!aHasLabel && bHasLabel)
+          return -1;
+        return 0;
+      });
+      return validLayers.map(
+        (l) => l.id.includes("labels") ? l.clone({ highlightedObjectIndex: -1 }) : l
+      );
     }
     _isWGS84() {
       if (this.state.mvt)
@@ -17232,9 +17563,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     };
     return scale;
   }
-  function log5() {
+  function log6() {
     const scale = loggish(transformer()).domain([1, 10]);
-    scale.copy = () => copy2(scale, log5()).base(scale.base());
+    scale.copy = () => copy2(scale, log6()).base(scale.base());
     initRange.apply(scale, arguments);
     return scale;
   }
@@ -18896,7 +19227,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var SCALE_FUNCS = {
     linear: linear2,
     ordinal,
-    log: log5,
+    log: log6,
     point,
     quantile: quantile2,
     quantize,
@@ -19271,9 +19602,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           assert2(dataset, `No dataset matching dataId: ${dataId}`);
           const { data } = dataset;
           assert2(data, `No data loaded for dataId: ${dataId}`);
-          const { Layer: Layer10, propMap, defaultProps: defaultProps12 } = getLayer(type, config, dataset);
+          const { Layer: Layer8, propMap, defaultProps: defaultProps12 } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
-          return new Layer10({
+          return new Layer8({
             id: id5,
             data,
             ...defaultProps12,