@deck.gl-community/basemap-layers 9.3.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,947 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  BasemapLayer: () => BasemapLayer,
+  getBasemapLayers: () => getBasemapLayers,
+  getGlobeBaseLayers: () => getGlobeBaseLayers,
+  getGlobeTopLayers: () => getGlobeTopLayers
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/basemap-layer.js
+var import_core3 = require("@deck.gl/core");
+var import_core4 = require("@loaders.gl/core");
+
+// dist/globe-layers.js
+var import_core2 = require("@deck.gl/core");
+var import_geo_layers = require("@deck.gl/geo-layers");
+var import_layers2 = require("@deck.gl/layers");
+var import_mvt = require("@loaders.gl/mvt");
+
+// dist/atmosphere-layer.js
+function getGlobeAtmosphereLayer() {
+  return null;
+}
+function getGlobeAtmosphereSkyLayer() {
+  return null;
+}
+
+// dist/mvt-label-layer.js
+var import_core = require("@deck.gl/core");
+var import_extensions = require("@deck.gl/extensions");
+var import_layers = require("@deck.gl/layers");
+function evaluateStyleValue(value, zoom) {
+  var _a;
+  if (typeof value === "number" || typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object" && Array.isArray(value.stops)) {
+    let resolved = (_a = value.stops[0]) == null ? void 0 : _a[1];
+    for (const stop of value.stops) {
+      if (zoom >= stop[0]) {
+        resolved = stop[1];
+      }
+    }
+    return resolved;
+  }
+  return value;
+}
+function resolveTokenString(template, properties) {
+  if (typeof template !== "string") {
+    return null;
+  }
+  return template.replace(/\{([^}]+)\}/g, (_, token) => {
+    const value = properties == null ? void 0 : properties[token];
+    return value === null || value === void 0 ? "" : String(value);
+  });
+}
+function getLineMidpoint(coordinates) {
+  if (!Array.isArray(coordinates) || coordinates.length === 0) {
+    return null;
+  }
+  return coordinates[Math.floor(coordinates.length / 2)] || coordinates[0] || null;
+}
+function getCollisionPriority(feature) {
+  const properties = (feature == null ? void 0 : feature.properties) || {};
+  if (properties.capital > 0 || properties.class === "country") {
+    return 1e3;
+  }
+  if (properties.class === "state" || properties.class === "city") {
+    return 750;
+  }
+  if (properties.layerName === "water_name" || properties.layerName === "waterway") {
+    return 400;
+  }
+  return 100;
+}
+var MVTLabelLayer = class extends import_core.CompositeLayer {
+  /** Current label-row state. */
+  state = void 0;
+  /**
+   * Extracts the visible label text for a decoded feature.
+   */
+  getLabel(feature) {
+    var _a, _b;
+    const { styleLayer, zoom = 0 } = this.props;
+    const textField = evaluateStyleValue((_a = styleLayer == null ? void 0 : styleLayer.layout) == null ? void 0 : _a["text-field"], zoom);
+    const label = (_b = resolveTokenString(textField, feature.properties)) == null ? void 0 : _b.trim();
+    return label || void 0;
+  }
+  /**
+   * Returns the font size for a decoded feature label.
+   */
+  getLabelSize(_feature) {
+    var _a;
+    const { styleLayer, zoom = 0 } = this.props;
+    return Number(evaluateStyleValue((_a = styleLayer == null ? void 0 : styleLayer.layout) == null ? void 0 : _a["text-size"], zoom) || 14);
+  }
+  /**
+   * Returns the text color for a decoded feature label.
+   */
+  getLabelColor(_feature) {
+    return this.props.textColor || [255, 255, 255];
+  }
+  /**
+   * Extracts candidate label anchor positions from a feature geometry.
+   */
+  getLabelAnchors(feature) {
+    const { type, coordinates } = feature.geometry;
+    switch (type) {
+      case "Point":
+        return [coordinates];
+      case "MultiPoint":
+        return coordinates;
+      case "LineString": {
+        const midpoint = getLineMidpoint(coordinates);
+        return midpoint ? [midpoint] : [];
+      }
+      case "MultiLineString": {
+        const midpoint = getLineMidpoint(coordinates[0]);
+        return midpoint ? [midpoint] : [];
+      }
+      default:
+        return [];
+    }
+  }
+  /**
+   * Recomputes label anchor rows when the source tile data changes.
+   */
+  updateState({ changeFlags }) {
+    const { data } = this.props;
+    if (changeFlags.dataChanged && data) {
+      const features = Array.isArray(data) ? data : data.features || [];
+      const labelData = features.flatMap((feature, index) => {
+        const labelAnchors = this.getLabelAnchors(feature);
+        return labelAnchors.map((position) => this.getSubLayerRow({ position }, feature, index));
+      });
+      this.setState({ labelData });
+    }
+  }
+  /**
+   * Renders the optional debug geometry and the text labels.
+   */
+  renderLayers() {
+    const { config, labelSizeUnits, labelBackground, billboard, renderGeometry } = this.props;
+    const layers = [];
+    if (renderGeometry) {
+      layers.push(new import_layers.GeoJsonLayer({
+        ...this.props,
+        ...this.getSubLayerProps({ id: "geojson" }),
+        data: this.props.data
+      }));
+    }
+    if (config.labels) {
+      const hasBackground = Array.isArray(labelBackground) && labelBackground.length >= 3;
+      layers.push(new import_layers.TextLayer({
+        ...this.getSubLayerProps({ id: "text" }),
+        data: this.state.labelData,
+        extensions: [...this.props.extensions || [], new import_extensions.CollisionFilterExtension()],
+        parameters: {
+          depthTest: false
+        },
+        billboard,
+        characterSet: "auto",
+        collisionEnabled: true,
+        collisionGroup: "basemap-labels",
+        getCollisionPriority: this.getSubLayerAccessor((feature) => getCollisionPriority(feature)),
+        fontFamily: this.props.fontFamily,
+        sizeUnits: labelSizeUnits,
+        background: hasBackground,
+        getBackgroundColor: hasBackground ? labelBackground : [0, 0, 0, 0],
+        getPosition: (d) => d.position,
+        getText: this.getSubLayerAccessor((feature) => this.getLabel(feature)),
+        getSize: this.getSubLayerAccessor((feature) => this.getLabelSize(feature)),
+        getColor: this.getSubLayerAccessor((feature) => this.getLabelColor(feature))
+      }));
+    }
+    return layers;
+  }
+};
+/** Deck.gl layer name. */
+__publicField(MVTLabelLayer, "layerName", "MVTLabelLayer");
+/** Default props for {@link MVTLabelLayer}. */
+__publicField(MVTLabelLayer, "defaultProps", {
+  ...import_layers.GeoJsonLayer.defaultProps,
+  billboard: true,
+  renderGeometry: false,
+  labelSizeUnits: "pixels",
+  labelBackground: { type: "color", value: null, optional: true },
+  fontFamily: "Monaco, monospace"
+});
+
+// dist/mapbox-style.js
+var import_mapbox_gl_style_spec = require("@mapbox/mapbox-gl-style-spec");
+var GEOM_TYPES = {
+  Point: 1,
+  MultiPoint: 1,
+  LineString: 2,
+  MultiLineString: 2,
+  Polygon: 3,
+  MultiPolygon: 3
+};
+function filterFeatures({ features, filter, globalProperties = {} }) {
+  if (!features || features.length === 0) {
+    return [];
+  }
+  const filterFn = (0, import_mapbox_gl_style_spec.featureFilter)(filter).filter;
+  return features.filter((feature) => {
+    var _a;
+    if (![1, 2, 3].includes(Number(feature.type))) {
+      feature.type = GEOM_TYPES[((_a = feature.geometry) == null ? void 0 : _a.type) || ""] ?? feature.type;
+    }
+    return filterFn(globalProperties, feature);
+  });
+}
+function parseProperties(layer, globalProperties) {
+  const layerProperties = [];
+  visitProperties(layer, { paint: true }, (property) => {
+    layerProperties.push(parseProperty(property, globalProperties));
+  });
+  return layerProperties;
+}
+function visitProperties(layer, options, callback) {
+  function inner(targetLayer, propertyType) {
+    const properties = targetLayer[propertyType];
+    if (!properties) {
+      return;
+    }
+    Object.keys(properties).forEach((key) => {
+      callback({
+        layer: targetLayer,
+        path: [targetLayer.id, propertyType, key],
+        key,
+        value: properties[key],
+        reference: getPropertyReference(key),
+        set(value) {
+          properties[key] = value;
+        }
+      });
+    });
+  }
+  if (options.paint) {
+    inner(layer, "paint");
+  }
+  if (options.layout) {
+    inner(layer, "layout");
+  }
+}
+function getPropertyReference(propertyName) {
+  for (let i = 0; i < import_mapbox_gl_style_spec.latest.layout.length; i++) {
+    for (const key in import_mapbox_gl_style_spec.latest[import_mapbox_gl_style_spec.latest.layout[i]]) {
+      if (key === propertyName) {
+        return import_mapbox_gl_style_spec.latest[import_mapbox_gl_style_spec.latest.layout[i]][key];
+      }
+    }
+  }
+  for (let i = 0; i < import_mapbox_gl_style_spec.latest.paint.length; i++) {
+    for (const key in import_mapbox_gl_style_spec.latest[import_mapbox_gl_style_spec.latest.paint[i]]) {
+      if (key === propertyName) {
+        return import_mapbox_gl_style_spec.latest[import_mapbox_gl_style_spec.latest.paint[i]][key];
+      }
+    }
+  }
+  return null;
+}
+function parseProperty(property, globalProperties) {
+  const exp = import_mapbox_gl_style_spec.expression.normalizePropertyExpression(property.value, property.reference);
+  const result = exp.evaluate(globalProperties);
+  if (result instanceof import_mapbox_gl_style_spec.Color) {
+    return { [property.key]: result.toArray() };
+  }
+  return { [property.key]: result };
+}
+
+// dist/map-style-schema.js
+var import_zod = require("zod");
+var BasemapSourceSchema = import_zod.z.object({
+  type: import_zod.z.string().optional(),
+  url: import_zod.z.string().optional(),
+  tiles: import_zod.z.array(import_zod.z.string()).optional(),
+  minzoom: import_zod.z.number().optional(),
+  maxzoom: import_zod.z.number().optional(),
+  tileSize: import_zod.z.number().optional()
+}).catchall(import_zod.z.unknown());
+var BasemapStyleLayerSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.string(),
+  source: import_zod.z.string().optional(),
+  "source-layer": import_zod.z.string().optional(),
+  minzoom: import_zod.z.number().optional(),
+  maxzoom: import_zod.z.number().optional(),
+  filter: import_zod.z.array(import_zod.z.unknown()).optional(),
+  paint: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  layout: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+}).catchall(import_zod.z.unknown());
+var BasemapStyleSchema = import_zod.z.object({
+  version: import_zod.z.number().optional(),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  sources: import_zod.z.record(import_zod.z.string(), BasemapSourceSchema).optional(),
+  layers: import_zod.z.array(BasemapStyleLayerSchema).optional()
+}).catchall(import_zod.z.unknown());
+var ResolvedBasemapStyleSchema = import_zod.z.object({
+  version: import_zod.z.number().optional(),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  sources: import_zod.z.record(import_zod.z.string(), BasemapSourceSchema),
+  layers: import_zod.z.array(BasemapStyleLayerSchema)
+}).catchall(import_zod.z.unknown());
+
+// dist/style-resolver.js
+function normalizeUrl(url, baseUrl) {
+  if (!url) {
+    return url;
+  }
+  try {
+    return decodeURI(new URL(url, baseUrl).toString());
+  } catch {
+    return url;
+  }
+}
+function normalizeTiles(tiles, baseUrl) {
+  return Array.isArray(tiles) ? tiles.map((tile) => normalizeUrl(tile, baseUrl) || tile) : tiles;
+}
+async function fetchJson(url, loadOptions) {
+  const fetchFn = (loadOptions == null ? void 0 : loadOptions.fetch) || fetch;
+  const response = await fetchFn(url, loadOptions == null ? void 0 : loadOptions.fetchOptions);
+  if (!response.ok) {
+    throw new Error(`Failed to load basemap resource: ${url} (${response.status})`);
+  }
+  return await response.json();
+}
+async function resolveSource(source, baseUrl, loadOptions) {
+  if (!source) {
+    return source;
+  }
+  const resolvedSource = { ...source };
+  let sourceBaseUrl = baseUrl;
+  if (resolvedSource.url) {
+    const tileJsonUrl = normalizeUrl(resolvedSource.url, baseUrl);
+    const tileJson = await fetchJson(tileJsonUrl || resolvedSource.url, loadOptions);
+    Object.assign(resolvedSource, tileJson);
+    resolvedSource.url = tileJsonUrl;
+    sourceBaseUrl = tileJsonUrl;
+  }
+  if (resolvedSource.tiles) {
+    resolvedSource.tiles = normalizeTiles(resolvedSource.tiles, sourceBaseUrl);
+  }
+  return resolvedSource;
+}
+async function resolveBasemapStyle(style, loadOptions) {
+  const styleDefinition = BasemapStyleSchema.parse(typeof style === "string" ? await fetchJson(style, loadOptions) : structuredClone(style));
+  const baseUrl = typeof style === "string" ? style : loadOptions == null ? void 0 : loadOptions.baseUrl;
+  const resolvedSources = {};
+  await Promise.all(Object.entries(styleDefinition.sources || {}).map(async ([sourceId, source]) => {
+    resolvedSources[sourceId] = await resolveSource(source, baseUrl, loadOptions) || {};
+  }));
+  return ResolvedBasemapStyleSchema.parse({
+    ...styleDefinition,
+    sources: resolvedSources,
+    layers: [...styleDefinition.layers || []]
+  });
+}
+
+// dist/map-style-loader.js
+var VERSION = true ? "9.3.0-beta.2" : "latest";
+function getMapStyleLoadOptions(options, context) {
+  var _a, _b;
+  return {
+    ...options == null ? void 0 : options.mapStyle,
+    baseUrl: ((_a = options == null ? void 0 : options.mapStyle) == null ? void 0 : _a.baseUrl) || (context == null ? void 0 : context.url) || (context == null ? void 0 : context.baseUrl),
+    fetch: ((_b = options == null ? void 0 : options.mapStyle) == null ? void 0 : _b.fetch) || (context == null ? void 0 : context.fetch)
+  };
+}
+var MapStyleLoader = {
+  dataType: null,
+  batchType: null,
+  name: "Map Style",
+  id: "map-style",
+  module: "basemap-layers",
+  version: VERSION,
+  worker: false,
+  extensions: ["json"],
+  mimeTypes: ["application/json", "application/vnd.mapbox.style+json"],
+  text: true,
+  options: {
+    mapStyle: {}
+  },
+  parse: async (data, options, context) => {
+    const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+    const style = JSON.parse(text);
+    const resolved = await resolveBasemapStyle(style, getMapStyleLoadOptions(options, context));
+    return ResolvedBasemapStyleSchema.parse(resolved);
+  }
+};
+
+// dist/globe-layers.js
+function logBasemapRuntimeEvent(message, details) {
+  import_core2.log.info(`[BasemapLayer] ${message}`, details ?? "")();
+}
+function logBasemapRuntimeError(message, error, details) {
+  import_core2.log.error(`[BasemapLayer] ${message}`, details || "", error)();
+}
+function getBackgroundParameters(mode) {
+  return mode === "globe" ? { depthTest: true, depthWriteEnabled: true, depthCompare: "less-equal", cullMode: "back" } : { depthTest: false, cullMode: "none" };
+}
+function getTileParameters(mode) {
+  return mode === "globe" ? { depthTest: true, depthWriteEnabled: true, depthCompare: "less-equal", cullMode: "back" } : { depthTest: false, cullMode: "none" };
+}
+var BACKGROUND_DATA = [
+  [
+    [-180, 90],
+    [0, 90],
+    [180, 90],
+    [180, -90],
+    [0, -90],
+    [-180, -90]
+  ]
+];
+var BACKGROUND_NORTH_POLE_DATA = [
+  [
+    [-180, 90],
+    [0, 90],
+    [180, 90],
+    [180, 85],
+    [0, 85],
+    [-180, 85]
+  ]
+];
+var SUPPORTED_TYPES = /* @__PURE__ */ new Set(["background", "fill", "line", "symbol", "raster"]);
+var DEFAULT_CONFIG = { atmosphere: false, basemap: true, labels: true };
+function withOpacity(color, opacity = 1) {
+  if (!color) {
+    return [0, 0, 0, 0];
+  }
+  const alpha = color.length > 3 ? color[3] <= 1 ? color[3] * 255 : color[3] : 255;
+  return [color[0], color[1], color[2], Math.round(alpha * opacity)];
+}
+function getPaint(layer, zoom) {
+  const properties = parseProperties(layer, { zoom });
+  return Object.fromEntries(properties.map((entry) => [Object.keys(entry)[0], Object.values(entry)[0]]));
+}
+function filterTileFeatures(features, styleLayer, zoom) {
+  const sourceLayer = styleLayer["source-layer"];
+  const sourceFeatures = sourceLayer ? features.filter((feature) => {
+    var _a;
+    return ((_a = feature.properties) == null ? void 0 : _a.layerName) === sourceLayer;
+  }) : features;
+  if (!styleLayer.filter) {
+    return sourceFeatures;
+  }
+  return filterFeatures({
+    features: sourceFeatures,
+    filter: styleLayer.filter,
+    globalProperties: { zoom }
+  });
+}
+function isStyleLayerVisibleAtZoom(styleLayer, zoom, source) {
+  const minZoom = styleLayer.minzoom ?? (source == null ? void 0 : source.minzoom) ?? 0;
+  const maxZoom = styleLayer.maxzoom ?? (source == null ? void 0 : source.maxzoom) ?? 22;
+  return zoom >= minZoom && zoom < maxZoom;
+}
+function getTileFeatures(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object" && Array.isArray(data.features)) {
+    return data.features;
+  }
+  return [];
+}
+function getSubLayerBaseProps(props) {
+  const { pickable, visible, opacity, modelMatrix, coordinateSystem, coordinateOrigin, extensions, highlightedObjectIndex, highlightColor, parameters, wrapLongitude } = props;
+  return {
+    pickable,
+    visible,
+    opacity,
+    modelMatrix,
+    coordinateSystem,
+    coordinateOrigin,
+    extensions,
+    highlightedObjectIndex,
+    highlightColor,
+    parameters,
+    wrapLongitude
+  };
+}
+function getLineWidthScale(styleLayer) {
+  const sourceLayer = styleLayer["source-layer"] || "";
+  const id = styleLayer.id || "";
+  if (sourceLayer === "transportation" || sourceLayer === "boundary" || id.includes("road-")) {
+    return 0.55;
+  }
+  if (sourceLayer === "waterway" || sourceLayer === "aeroway") {
+    return 0.75;
+  }
+  return 1;
+}
+function getGlobeFillColor(color, mode) {
+  if (mode !== "globe") {
+    return color;
+  }
+  return [color[0], color[1], color[2], 255];
+}
+function getConfig(globe) {
+  return { ...DEFAULT_CONFIG, ...(globe == null ? void 0 : globe.config) || {} };
+}
+function createBackgroundLayer({ idPrefix, layer, zoom, mode }) {
+  const paint = getPaint(layer, zoom);
+  return new import_layers2.SolidPolygonLayer({
+    id: `${idPrefix}-${layer.id}`,
+    data: BACKGROUND_DATA,
+    getPolygon: (d) => d,
+    stroked: false,
+    filled: true,
+    getFillColor: withOpacity(paint["background-color"], paint["background-opacity"] ?? 1),
+    parameters: getBackgroundParameters(mode)
+  });
+}
+function createRasterLayer({ idPrefix, layer, source, mode }) {
+  return new import_geo_layers.TileLayer({
+    id: `${idPrefix}-${layer.id}`,
+    data: source.tiles,
+    minZoom: layer.minzoom ?? source.minzoom ?? 0,
+    maxZoom: layer.maxzoom ?? source.maxzoom ?? 22,
+    tileSize: source.tileSize || 512,
+    renderSubLayers: (props) => {
+      var _a;
+      const { west, south, east, north } = ((_a = props.tile) == null ? void 0 : _a.bbox) || {};
+      return new import_layers2.BitmapLayer({
+        ...props,
+        _imageCoordinateSystem: import_core2.COORDINATE_SYSTEM.CARTESIAN,
+        data: null,
+        image: props.data,
+        bounds: [west, south, east, north],
+        parameters: getTileParameters(mode)
+      });
+    },
+    onTileError: (error) => {
+      logBasemapRuntimeError("Raster tile failed to load", error, {
+        layerId: layer.id,
+        sourceId: layer.source
+      });
+    },
+    parameters: getTileParameters(mode)
+  });
+}
+var StyledMVTLayer = class extends import_geo_layers.MVTLayer {
+  getTileData(loadProps) {
+    const data = this.props.data;
+    const url = (0, import_geo_layers._getURLFromTemplate)(data, loadProps);
+    if (!url) {
+      return Promise.reject(new Error("Invalid URL"));
+    }
+    const loadOptions = this.getLoadOptions();
+    const coordinates = this.context.viewport.resolution ? "wgs84" : "local";
+    return this.props.fetch(url, {
+      propName: "data",
+      layer: this,
+      signal: loadProps.signal,
+      loadOptions: {
+        ...loadOptions,
+        mimeType: "application/x-protobuf",
+        mvt: {
+          ...(loadOptions == null ? void 0 : loadOptions.mvt) || {},
+          shape: "geojson",
+          coordinates,
+          tileIndex: loadProps.index
+        }
+      }
+    });
+  }
+};
+StyledMVTLayer.layerName = "StyledMVTLayer";
+StyledMVTLayer.defaultProps = {
+  ...import_geo_layers.MVTLayer.defaultProps,
+  binary: false,
+  loaders: [import_mvt.MVTWorkerLoader]
+};
+function createStyledVectorSubLayer({ idPrefix, sourceId, styleLayer, features, props, zoom, config, mode }) {
+  if (features.length === 0) {
+    return null;
+  }
+  const paint = getPaint(styleLayer, zoom);
+  const opacity = paint[`${styleLayer.type}-opacity`] ?? (styleLayer.type === "fill" ? paint["fill-opacity"] : paint["line-opacity"]) ?? 1;
+  const fillColor = withOpacity(paint["fill-color"], opacity);
+  const lineColor = withOpacity(paint["line-color"] || paint["fill-outline-color"] || [0, 0, 0, 0], opacity);
+  if (styleLayer.type === "symbol") {
+    return createSymbolSubLayer({ props, styleLayer, features, config, mode, zoom, opacity, paint });
+  }
+  return createGeometrySubLayer({ props, styleLayer, features, mode, fillColor, lineColor, paint });
+}
+function createVectorLayerGroup({ idPrefix, sourceId, source, styleLayers, zoom, config, loadOptions, mode }) {
+  const minZoom = Math.min(...styleLayers.map((layer) => layer.minzoom ?? source.minzoom ?? 0));
+  const maxZoom = Math.max(...styleLayers.map((layer) => layer.maxzoom ?? source.maxzoom ?? 22));
+  return new StyledMVTLayer({
+    id: `${idPrefix}-${sourceId}`,
+    data: source.tiles,
+    binary: false,
+    minZoom,
+    maxZoom,
+    tileSize: source.tileSize || 512,
+    loadOptions: {
+      ...loadOptions || {},
+      mvt: {
+        ...(loadOptions == null ? void 0 : loadOptions.mvt) || {},
+        shape: "geojson"
+      }
+    },
+    onTileError: (error) => {
+      logBasemapRuntimeError("Vector tile layer failed", error, {
+        sourceId
+      });
+    },
+    onTileLoad: (tile) => {
+      const features = Array.isArray(tile.content) ? tile.content : [];
+      if (features.length === 0) {
+        logBasemapRuntimeEvent("Loaded empty vector tile", {
+          sourceId,
+          tileIndex: tile.index
+        });
+      }
+    },
+    parameters: getTileParameters(mode),
+    renderSubLayers: (props) => {
+      const features = getTileFeatures(props.data);
+      const layers = styleLayers.map((styleLayer) => {
+        var _a;
+        if (!isStyleLayerVisibleAtZoom(styleLayer, zoom, source)) {
+          return null;
+        }
+        const filteredData = filterTileFeatures(features, styleLayer, zoom);
+        if (features.length > 0 && filteredData.length === 0) {
+          logBasemapRuntimeEvent("Vector tile rendered no matching features", {
+            sourceId,
+            layerId: styleLayer.id,
+            sourceLayer: styleLayer["source-layer"],
+            tileIndex: (_a = props.tile) == null ? void 0 : _a.index
+          });
+        }
+        return createStyledVectorSubLayer({
+          idPrefix,
+          sourceId,
+          styleLayer,
+          features: filteredData,
+          props,
+          zoom,
+          config,
+          mode
+        });
+      }).filter((layer) => Boolean(layer));
+      return layers;
+    }
+  });
+}
+function inferWaterColor(styleLayers, zoom) {
+  const waterLayer = styleLayers.find((layer) => layer.type === "fill" && `${layer["source-layer"] || ""}`.includes("water"));
+  if (!waterLayer) {
+    return [20, 40, 68, 255];
+  }
+  const paint = getPaint(waterLayer, zoom);
+  return withOpacity(paint["fill-color"], paint["fill-opacity"] ?? 1);
+}
+function getVectorSourceGroups(styleLayers, styleDefinition) {
+  var _a;
+  const groups = /* @__PURE__ */ new Map();
+  for (const layer of styleLayers) {
+    const sourceId = layer.source;
+    const source = sourceId ? (_a = styleDefinition.sources) == null ? void 0 : _a[sourceId] : null;
+    if (sourceId && (source == null ? void 0 : source.tiles) && source.type === "vector") {
+      appendVectorSourceGroup(groups, sourceId, source, layer);
+    }
+  }
+  return [...groups.values()];
+}
+function getBasemapLayers({ idPrefix = "basemap", mode = "map", globe, styleDefinition, zoom = 0, loadOptions }) {
+  const config = getConfig(globe);
+  const styleLayers = (styleDefinition.layers || []).filter((layer) => SUPPORTED_TYPES.has(layer.type));
+  const layers = [];
+  logBasemapRuntimeEvent("Generating basemap layers", {
+    mode,
+    styleLayerCount: styleLayers.length,
+    sourceCount: Object.keys(styleDefinition.sources || {}).length
+  });
+  layers.push(...getGlobePreLayers({ idPrefix, mode, config, styleLayers }));
+  if (config.basemap) {
+    layers.push(...getBackgroundLayers({ idPrefix, styleLayers, zoom, mode }));
+    layers.push(...getVectorLayers({ idPrefix, styleLayers, styleDefinition, zoom, config, loadOptions, mode }));
+    layers.push(...getRasterLayers({ idPrefix, styleLayers, styleDefinition, zoom, mode }));
+  }
+  layers.push(...getGlobePostLayers({ idPrefix, mode, config, styleLayers, zoom }));
+  return layers.filter((layer) => Boolean(layer));
+}
+function getGlobeBaseLayers({ globe, styleDefinition, idPrefix = "globe-basemap", zoom = 0, loadOptions }) {
+  return getBasemapLayers({ idPrefix, mode: "globe", globe, styleDefinition, zoom, loadOptions });
+}
+function getGlobeTopLayers({ globe }) {
+  const { config } = globe;
+  return config.atmosphere ? [getGlobeAtmosphereLayer()] : [];
+}
+function createSymbolSubLayer({ props, styleLayer, features, config, mode, zoom, opacity, paint }) {
+  return new MVTLabelLayer({
+    ...getSubLayerBaseProps(props),
+    id: `${props.id}-${styleLayer.id}`,
+    data: features,
+    config,
+    mode,
+    styleLayer,
+    zoom,
+    textColor: withOpacity(paint["text-color"], opacity),
+    labelBackground: paint["text-halo-color"] ? withOpacity(paint["text-halo-color"], paint["text-halo-width"] ? 255 : opacity) : null,
+    billboard: true
+  });
+}
+function createGeometrySubLayer({ props, styleLayer, features, mode, fillColor, lineColor, paint }) {
+  const isLine = styleLayer.type === "line";
+  const isFill = styleLayer.type === "fill";
+  return new import_layers2.GeoJsonLayer({
+    ...getSubLayerBaseProps(props),
+    id: `${props.id}-${styleLayer.id}`,
+    data: features,
+    stroked: isLine,
+    filled: isFill,
+    getFillColor: isFill ? getGlobeFillColor(fillColor, mode) : [0, 0, 0, 0],
+    getLineColor: lineColor,
+    getLineWidth: isLine ? Math.max(0.25, Number(paint["line-width"] ?? 1) * getLineWidthScale(styleLayer)) : 0,
+    lineWidthUnits: "pixels",
+    lineWidthMinPixels: 0,
+    lineWidthMaxPixels: 20,
+    lineCapRounded: isLine,
+    lineJointRounded: isLine,
+    getPointRadius: 0,
+    pointRadiusMinPixels: 0,
+    parameters: getTileParameters(mode)
+  });
+}
+function getBackgroundLayers({ idPrefix, styleLayers, zoom, mode }) {
+  return styleLayers.filter((layer) => layer.type === "background" && isStyleLayerVisibleAtZoom(layer, zoom)).map((layer) => createBackgroundLayer({ idPrefix, layer, zoom, mode }));
+}
+function getVectorLayers({ idPrefix, styleLayers, styleDefinition, zoom, config, loadOptions, mode }) {
+  const visibleVectorLayers = styleLayers.filter((layer) => {
+    var _a;
+    if (!isStyleLayerVisibleAtZoom(layer, zoom, (_a = styleDefinition.sources) == null ? void 0 : _a[layer.source || ""])) {
+      return false;
+    }
+    if (layer.type === "symbol") {
+      return config.labels;
+    }
+    return layer.type === "fill" || layer.type === "line";
+  });
+  return getVectorSourceGroups(visibleVectorLayers, styleDefinition).map((group) => createVectorLayerGroup({
+    idPrefix,
+    sourceId: group.sourceId,
+    source: group.source,
+    styleLayers: group.styleLayers,
+    zoom,
+    config,
+    loadOptions,
+    mode
+  }));
+}
+function getRasterLayers({ idPrefix, styleLayers, styleDefinition, zoom, mode }) {
+  var _a, _b;
+  const rasterLayers = [];
+  for (const layer of styleLayers) {
+    if (layer.type === "raster" && isStyleLayerVisibleAtZoom(layer, zoom, (_a = styleDefinition.sources) == null ? void 0 : _a[layer.source || ""])) {
+      const source = (_b = styleDefinition.sources) == null ? void 0 : _b[layer.source];
+      if (!(source == null ? void 0 : source.tiles)) {
+        logBasemapRuntimeEvent("Skipping style layer without resolved tiles", {
+          layerId: layer.id,
+          sourceId: layer.source
+        });
+      } else {
+        rasterLayers.push(createRasterLayer({ idPrefix, layer, source, mode }));
+      }
+    }
+  }
+  return rasterLayers;
+}
+function appendVectorSourceGroup(groups, sourceId, source, layer) {
+  const group = groups.get(sourceId);
+  if (group) {
+    group.styleLayers.push(layer);
+    return;
+  }
+  groups.set(sourceId, {
+    sourceId,
+    source,
+    styleLayers: [layer]
+  });
+}
+function getGlobePreLayers({ idPrefix, mode, config, styleLayers }) {
+  const layers = [];
+  if (mode === "globe" && config.atmosphere) {
+    layers.push(getGlobeAtmosphereSkyLayer());
+  }
+  const hasBackground = styleLayers.some((layer) => layer.type === "background");
+  if (mode === "globe" && !hasBackground) {
+    layers.push(new import_layers2.SolidPolygonLayer({
+      id: `${idPrefix}-background-fallback`,
+      data: BACKGROUND_DATA,
+      getPolygon: (d) => d,
+      stroked: false,
+      filled: true,
+      getFillColor: [10, 24, 46, 255],
+      parameters: getBackgroundParameters(mode)
+    }));
+  }
+  return layers;
+}
+function getGlobePostLayers({ idPrefix, mode, config, styleLayers, zoom }) {
+  const layers = [];
+  if (mode === "globe" && config.basemap) {
+    layers.push(new import_layers2.SolidPolygonLayer({
+      id: `${idPrefix}-background-north-pole`,
+      data: BACKGROUND_NORTH_POLE_DATA,
+      getPolygon: (d) => d,
+      stroked: false,
+      filled: true,
+      getFillColor: inferWaterColor(styleLayers, zoom),
+      parameters: getBackgroundParameters(mode)
+    }));
+  }
+  if (mode === "globe" && config.atmosphere) {
+    layers.push(getGlobeAtmosphereLayer());
+  }
+  return layers;
+}
+
+// dist/basemap-layer.js
+function logBasemapLayerEvent(message, details) {
+  import_core3.log.info(message, details ?? "")();
+}
+function logBasemapLayerError(message, error) {
+  import_core3.log.error(`${message}: ${error.message}`)();
+}
+function getMapStyleLoaderOptions(loadOptions) {
+  return {
+    mapStyle: loadOptions || void 0
+  };
+}
+var BasemapLayer = class extends import_core3.CompositeLayer {
+  /** Current layer state. */
+  state = void 0;
+  /** Initializes the asynchronous style-loading state. */
+  initializeState() {
+    this.state = {
+      resolvedStyle: null,
+      loadError: null,
+      loadToken: 0
+    };
+  }
+  /** Reacts to changes in the input style definition. */
+  updateState({ props, oldProps, changeFlags }) {
+    if (changeFlags.dataChanged || props.style !== oldProps.style || props.loadOptions !== oldProps.loadOptions) {
+      this.loadStyle(props.style, props.loadOptions);
+    }
+  }
+  /**
+   * Resolves the configured style input and stores the latest successful result
+   * in layer state.
+   */
+  loadStyle(style, loadOptions) {
+    if (!style) {
+      const loadToken2 = this.state.loadToken + 1;
+      logBasemapLayerEvent("Clearing basemap style");
+      this.setState({ resolvedStyle: null, loadError: null, loadToken: loadToken2 });
+      return;
+    }
+    const loadToken = this.state.loadToken + 1;
+    this.setState({ loadToken });
+    logBasemapLayerEvent("Resolving basemap style", {
+      style: typeof style === "string" ? style : "inline-style-object",
+      loadToken
+    });
+    Promise.resolve(typeof style === "string" ? (0, import_core4.load)(style, MapStyleLoader, getMapStyleLoaderOptions(loadOptions)) : MapStyleLoader.parse(new TextEncoder().encode(JSON.stringify(style)).buffer, getMapStyleLoaderOptions(loadOptions))).then((resolvedStyle) => {
+      var _a;
+      if (this.state.loadToken === loadToken) {
+        logBasemapLayerEvent("Resolved basemap style", {
+          loadToken,
+          sources: Object.keys(resolvedStyle.sources || {}),
+          layers: ((_a = resolvedStyle.layers) == null ? void 0 : _a.length) || 0
+        });
+        this.setState({ resolvedStyle, loadError: null });
+      }
+    }).catch((error) => {
+      if (this.state.loadToken === loadToken) {
+        logBasemapLayerError("Failed to resolve basemap style", error);
+        this.setState({ resolvedStyle: null, loadError: error });
+      }
+    });
+  }
+  /** Renders the sublayers generated from the resolved style definition. */
+  renderLayers() {
+    var _a;
+    if (!this.state.resolvedStyle) {
+      return [];
+    }
+    return getBasemapLayers({
+      idPrefix: this.props.id,
+      mode: this.props.mode,
+      globe: this.props.globe,
+      styleDefinition: this.state.resolvedStyle,
+      zoom: ((_a = this.context.viewport) == null ? void 0 : _a.zoom) || 0,
+      loadOptions: this.props.loadOptions
+    });
+  }
+};
+/** Deck.gl layer name. */
+__publicField(BasemapLayer, "layerName", "BasemapLayer");
+/** Default props for {@link BasemapLayer}. */
+__publicField(BasemapLayer, "defaultProps", {
+  mode: "map",
+  globe: {
+    type: "object",
+    value: {
+      config: {
+        atmosphere: false,
+        basemap: true,
+        labels: true
+      }
+    }
+  },
+  style: null,
+  loadOptions: null
+});
+//# sourceMappingURL=index.cjs.map