@deck.gl/carto 9.1.12 → 9.2.0-alpha.2

package/dist/index.cjs

@@ -32,15 +32,13 @@ var dist_exports = {};
 __export(dist_exports, {
   BASEMAP: () => basemap_default,
   CARTO_LAYERS: () => CARTO_LAYERS,
-  CARTO_SOURCES: () => CARTO_SOURCES,
-  CartoAPIError: () => import_api_client4.CartoAPIError,
   ClusterTileLayer: () => cluster_tile_layer_default,
   H3TileLayer: () => h3_tile_layer_default,
   HeatmapTileLayer: () => heatmap_tile_layer_default,
+  LayerFactory: () => LayerFactory,
   PointLabelLayer: () => point_label_layer_default,
   QuadbinTileLayer: () => quadbin_tile_layer_default,
   RasterTileLayer: () => raster_tile_layer_default,
-  SOURCE_DEFAULTS: () => import_api_client4.SOURCE_DEFAULTS,
   VectorTileLayer: () => vector_tile_layer_default,
   _GOOGLE_BASEMAPS: () => GOOGLE_BASEMAPS,
   _QuadbinLayer: () => quadbin_layer_default,
@@ -50,24 +48,11 @@ __export(dist_exports, {
   _applyLayerGroupFilters: () => applyLayerGroupFilters,
   _fetchStyle: () => fetchStyle,
   _getStyleUrl: () => getStyleUrl,
-  boundaryQuerySource: () => import_api_client4.boundaryQuerySource,
-  boundaryTableSource: () => import_api_client4.boundaryTableSource,
   colorBins: () => colorBins,
   colorCategories: () => colorCategories,
   colorContinuous: () => colorContinuous,
   fetchBasemapProps: () => fetchBasemapProps,
-  fetchMap: () => fetchMap,
-  h3QuerySource: () => import_api_client4.h3QuerySource,
-  h3TableSource: () => import_api_client4.h3TableSource,
-  h3TilesetSource: () => import_api_client4.h3TilesetSource,
-  quadbinQuerySource: () => import_api_client4.quadbinQuerySource,
-  quadbinTableSource: () => import_api_client4.quadbinTableSource,
-  quadbinTilesetSource: () => import_api_client4.quadbinTilesetSource,
-  query: () => import_api_client4.query,
-  rasterSource: () => import_api_client4.rasterSource,
-  vectorQuerySource: () => import_api_client4.vectorQuerySource,
-  vectorTableSource: () => import_api_client4.vectorTableSource,
-  vectorTilesetSource: () => import_api_client4.vectorTilesetSource
+  fetchMap: () => fetchMap
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -110,26 +95,6 @@ function createBinaryProxy(data, index) {
 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 },
@@ -591,7 +556,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION = true ? "9.1.12" : "latest";
+var VERSION = true ? "9.2.0-alpha.2" : "latest";
 var id = "cartoSpatialTile";
 var DEFAULT_OPTIONS = {
   cartoSpatialTile: {
@@ -2002,7 +1967,7 @@ var TileReader3 = class {
 };
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION2 = true ? "9.1.12" : "latest";
+var VERSION2 = true ? "9.2.0-alpha.2" : "latest";
 var id2 = "cartoRasterTile";
 var DEFAULT_OPTIONS2 = {
   cartoRasterTile: {
@@ -2114,7 +2079,7 @@ var TileReader4 = class {
 };
 
 // dist/layers/schema/carto-properties-tile-loader.js
-var VERSION3 = true ? "9.1.12" : "latest";
+var VERSION3 = true ? "9.2.0-alpha.2" : "latest";
 var id3 = "cartoPropertiesTile";
 var DEFAULT_OPTIONS3 = {
   cartoPropertiesTile: {
@@ -2143,7 +2108,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut = __toESM(require("earcut"), 1);
-var VERSION4 = true ? "9.1.12" : "latest";
+var VERSION4 = true ? "9.2.0-alpha.2" : "latest";
 var id4 = "cartoVectorTile";
 var DEFAULT_OPTIONS4 = {
   cartoVectorTile: {
@@ -2769,54 +2734,7 @@ function colorContinuous({ attr, domain, colors = DEFAULT_PALETTE, nullColor = N
 
 // dist/api/fetch-map.js
 var import_api_client2 = require("@carto/api-client");
-
-// dist/api/parse-map.js
-var import_core17 = require("@deck.gl/core");
-
-// dist/api/layer-map.js
-var import_d3_array = require("d3-array");
-var import_d3_color = require("d3-color");
-var import_d3_scale3 = require("d3-scale");
-var import_d3_format = require("d3-format");
-var import_moment_timezone = __toESM(require("moment-timezone"), 1);
-var import_aggregation_layers = require("@deck.gl/aggregation-layers");
-var import_layers6 = require("@deck.gl/layers");
-var import_geo_layers9 = require("@deck.gl/geo-layers");
-var SCALE_FUNCS = {
-  linear: import_d3_scale3.scaleLinear,
-  ordinal: import_d3_scale3.scaleOrdinal,
-  log: import_d3_scale3.scaleLog,
-  point: import_d3_scale3.scalePoint,
-  quantile: import_d3_scale3.scaleQuantile,
-  quantize: import_d3_scale3.scaleQuantize,
-  sqrt: import_d3_scale3.scaleSqrt,
-  custom: import_d3_scale3.scaleThreshold,
-  identity: scaleIdentity
-};
-function identity(v) {
-  return v;
-}
-var UNKNOWN_COLOR = "#868d91";
-var AGGREGATION = {
-  average: "MEAN",
-  maximum: "MAX",
-  minimum: "MIN",
-  sum: "SUM"
-};
-var OPACITY_MAP = {
-  getFillColor: "opacity",
-  getLineColor: "strokeOpacity",
-  getTextColor: "opacity"
-};
-var AGGREGATION_FUNC = {
-  "count unique": (values, accessor) => (0, import_d3_array.groupSort)(values, (v) => v.length, accessor).length,
-  median: import_d3_array.median,
-  // Unfortunately mode() is only available in d3-array@3+ which is ESM only
-  mode: (values, accessor) => (0, import_d3_array.groupSort)(values, (v) => v.length, accessor).pop(),
-  stddev: import_d3_array.deviation,
-  variance: import_d3_array.variance
-};
-var TILE_LAYER_TYPE_TO_LAYER = {
+var layerClasses = {
   clusterTile: cluster_tile_layer_default,
   h3: h3_tile_layer_default,
   heatmapTile: heatmap_tile_layer_default,
@@ -2825,576 +2743,31 @@ var TILE_LAYER_TYPE_TO_LAYER = {
   raster: raster_tile_layer_default,
   tileset: vector_tile_layer_default
 };
-var hexToRGBA = (c) => {
-  const { r, g, b, opacity } = (0, import_d3_color.rgb)(c);
-  return [r, g, b, 255 * opacity];
-};
-var sharedPropMap = {
-  // Apply the value of Kepler `color` prop to the deck `getFillColor` prop
-  color: "getFillColor",
-  isVisible: "visible",
-  label: "cartoLabel",
-  textLabel: {
-    alignment: "getTextAlignmentBaseline",
-    anchor: "getTextAnchor",
-    // Apply the value of Kepler `textLabel.color` prop to the deck `getTextColor` prop
-    color: "getTextColor",
-    size: "getTextSize"
-  },
-  visConfig: {
-    enable3d: "extruded",
-    elevationScale: "elevationScale",
-    filled: "filled",
-    strokeColor: "getLineColor",
-    stroked: "stroked",
-    thickness: "getLineWidth",
-    radius: "getPointRadius",
-    wireframe: "wireframe"
-  }
-};
-var customMarkersPropsMap = {
-  color: "getIconColor",
-  visConfig: {
-    radius: "getIconSize"
-  }
-};
-var heatmapTilePropsMap = {
-  visConfig: {
-    colorRange: (x) => ({ colorRange: x.colors.map(hexToRGBA) }),
-    radius: "radiusPixels"
-  }
-};
-var aggregationVisConfig = {
-  colorAggregation: (x) => ({ colorAggregation: AGGREGATION[x] || AGGREGATION.sum }),
-  colorRange: (x) => ({ colorRange: x.colors.map(hexToRGBA) }),
-  coverage: "coverage",
-  elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
-  percentile: ["lowerPercentile", "upperPercentile"]
-};
-var defaultProps11 = {
-  lineMiterLimit: 2,
-  lineWidthUnits: "pixels",
-  pointRadiusUnits: "pixels",
-  rounded: true,
-  wrapLongitude: false
-};
-function mergePropMaps(a = {}, b = {}) {
-  return { ...a, ...b, visConfig: { ...a.visConfig, ...b.visConfig } };
-}
-function getLayer(type, config, dataset) {
-  var _a, _b;
-  let basePropMap = sharedPropMap;
-  if ((_a = config.visConfig) == null ? void 0 : _a.customMarkers) {
-    basePropMap = mergePropMaps(basePropMap, customMarkersPropsMap);
-  }
-  if (type === "heatmapTile") {
-    basePropMap = mergePropMaps(basePropMap, heatmapTilePropsMap);
-  }
-  if (TILE_LAYER_TYPE_TO_LAYER[type]) {
-    return getTileLayer(dataset, basePropMap, type);
-  }
-  const geoColumn = dataset == null ? void 0 : dataset.geoColumn;
-  const getPosition = (d) => d[geoColumn].coordinates;
-  const hexagonId = (_b = config.columns) == null ? void 0 : _b.hex_id;
-  const layerTypeDefs = {
-    point: {
-      Layer: import_layers6.GeoJsonLayer,
-      propMap: {
-        columns: {
-          altitude: (x) => ({ parameters: { depthWriteEnabled: Boolean(x) } })
-        },
-        visConfig: { outline: "stroked" }
-      }
-    },
-    geojson: {
-      Layer: import_layers6.GeoJsonLayer
-    },
-    grid: {
-      Layer: import_aggregation_layers.GridLayer,
-      propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: (x) => ({ cellSize: 1e3 * x }) } },
-      defaultProps: { getPosition }
-    },
-    heatmap: {
-      Layer: import_aggregation_layers.HeatmapLayer,
-      propMap: { visConfig: { ...aggregationVisConfig, radius: "radiusPixels" } },
-      defaultProps: { getPosition }
-    },
-    hexagon: {
-      Layer: import_aggregation_layers.HexagonLayer,
-      propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: (x) => ({ radius: 1e3 * x }) } },
-      defaultProps: { getPosition }
-    },
-    hexagonId: {
-      Layer: import_geo_layers9.H3HexagonLayer,
-      propMap: { visConfig: { coverage: "coverage" } },
-      defaultProps: { getHexagon: (d) => d[hexagonId], stroked: false }
-    }
-  };
-  const layer = layerTypeDefs[type];
-  assert(layer, `Unsupported layer type: ${type}`);
-  return {
-    ...layer,
-    propMap: mergePropMaps(basePropMap, layer.propMap),
-    defaultProps: { ...defaultProps11, ...layer.defaultProps }
-  };
-}
-function getTileLayer(dataset, basePropMap, type) {
-  const { aggregationExp, aggregationResLevel } = dataset;
-  return {
-    Layer: TILE_LAYER_TYPE_TO_LAYER[type] || vector_tile_layer_default,
-    propMap: basePropMap,
-    defaultProps: {
-      ...defaultProps11,
-      ...aggregationExp && { aggregationExp },
-      ...aggregationResLevel && { aggregationResLevel },
-      uniqueIdProperty: "geoid"
-    }
-  };
-}
-function domainFromAttribute(attribute, scaleType, scaleLength) {
-  if (scaleType === "ordinal" || scaleType === "point") {
-    return attribute.categories.map((c) => c.category).filter((c) => c !== void 0 && c !== null);
-  }
-  if (scaleType === "quantile" && attribute.quantiles) {
-    return attribute.quantiles.global ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
-  }
-  let { min } = attribute;
-  if (scaleType === "log" && min === 0) {
-    min = 1e-5;
-  }
-  return [min, attribute.max];
-}
-function domainFromValues(values, scaleType) {
-  if (scaleType === "ordinal" || scaleType === "point") {
-    return (0, import_d3_array.groupSort)(values, (g) => -g.length, (d) => d);
-  } else if (scaleType === "quantile") {
-    return values.sort((a, b) => a - b);
-  } else if (scaleType === "log") {
-    const [d0, d1] = (0, import_d3_array.extent)(values);
-    return [d0 === 0 ? 1e-5 : d0, d1];
-  }
-  return (0, import_d3_array.extent)(values);
-}
-function calculateDomain(data, name, scaleType, scaleLength) {
-  if (data.tilestats) {
-    const { attributes } = data.tilestats.layers[0];
-    const attribute = attributes.find((a) => a.attribute === name);
-    return domainFromAttribute(attribute, scaleType, scaleLength);
-  } else if (data.features) {
-    const values = data.features.map(({ properties }) => properties[name]);
-    return domainFromValues(values, scaleType);
-  } else if (Array.isArray(data) && data[0][name] !== void 0) {
-    const values = data.map((properties) => properties[name]);
-    return domainFromValues(values, scaleType);
-  }
-  return [0, 1];
-}
-function normalizeAccessor(accessor, data) {
-  if (data.features || data.tilestats) {
-    return (object, info) => {
-      if (object) {
-        return accessor(object.properties || object.__source.object.properties);
-      }
-      const { data: data2, index } = info;
-      const proxy = createBinaryProxy(data2, index);
-      return accessor(proxy);
-    };
+function LayerFactory(descriptor) {
+  const LayerClass = layerClasses[descriptor.type];
+  if (!LayerClass) {
+    throw new Error(`No layer class found for type: ${descriptor.type}`);
   }
-  return accessor;
+  return new LayerClass(descriptor.props);
 }
-function opacityToAlpha(opacity) {
-  return opacity !== void 0 ? Math.round(255 * Math.pow(opacity, 1 / 2.2)) : 255;
-}
-function getAccessorKeys(name, aggregation) {
-  let keys = [name];
-  if (aggregation) {
-    keys = keys.concat([aggregation, aggregation.toUpperCase()].map((a) => `${name}_${a}`));
-  }
-  return keys;
-}
-function findAccessorKey(keys, properties) {
-  for (const key of keys) {
-    if (key in properties) {
-      return [key];
-    }
-  }
-  throw new Error(`Could not find property for any accessor key: ${keys}`);
-}
-function getColorValueAccessor({ name }, colorAggregation, data) {
-  const aggregator = AGGREGATION_FUNC[colorAggregation];
-  const accessor = (values) => aggregator(values, (p) => p[name]);
-  return normalizeAccessor(accessor, data);
-}
-function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range }, opacity, data) {
-  const scale = calculateLayerScale(colorColumn || name, scaleType, range, data);
-  const alpha = opacityToAlpha(opacity);
-  let accessorKeys = getAccessorKeys(name, aggregation);
-  const accessor = (properties) => {
-    if (!(accessorKeys[0] in properties)) {
-      accessorKeys = findAccessorKey(accessorKeys, properties);
-    }
-    const propertyValue = properties[accessorKeys[0]];
-    const { r, g, b } = (0, import_d3_color.rgb)(scale(propertyValue));
-    return [r, g, b, propertyValue === null ? 0 : alpha];
-  };
-  return normalizeAccessor(accessor, data);
-}
-function calculateLayerScale(name, scaleType, range, data) {
-  const scale = SCALE_FUNCS[scaleType]();
-  let domain = [];
-  let scaleColor = [];
-  if (scaleType !== "identity") {
-    const { colorMap, colors } = range;
-    if (Array.isArray(colorMap)) {
-      colorMap.forEach(([value, color]) => {
-        domain.push(value);
-        scaleColor.push(color);
-      });
-    } else {
-      domain = calculateDomain(data, name, scaleType, colors.length);
-      scaleColor = colors;
-    }
-    if (scaleType === "ordinal") {
-      domain = domain.slice(0, scaleColor.length);
-    }
-  }
-  scale.domain(domain);
-  scale.range(scaleColor);
-  scale.unknown(UNKNOWN_COLOR);
-  return scale;
-}
-var FALLBACK_ICON = "data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==";
-function getIconUrlAccessor(field, range, { fallbackUrl, maxIconSize, useMaskedIcons }, data) {
-  const urlToUnpackedIcon = (url) => ({
-    id: `${url}@@${maxIconSize}`,
-    url,
-    width: maxIconSize,
-    height: maxIconSize,
-    mask: useMaskedIcons
-  });
-  let unknownValue = fallbackUrl || FALLBACK_ICON;
-  if (range == null ? void 0 : range.othersMarker) {
-    unknownValue = range.othersMarker;
-  }
-  const unknownIcon = urlToUnpackedIcon(unknownValue);
-  if (!range || !field) {
-    return () => unknownIcon;
-  }
-  const mapping = {};
-  for (const { value, markerUrl } of range.markerMap) {
-    if (markerUrl) {
-      mapping[value] = urlToUnpackedIcon(markerUrl);
-    }
-  }
-  const accessor = (properties) => {
-    const propertyValue = properties[field.name];
-    return mapping[propertyValue] || unknownIcon;
-  };
-  return normalizeAccessor(accessor, data);
-}
-function getMaxMarkerSize(visConfig, visualChannels) {
-  const { radiusRange, radius } = visConfig;
-  const { radiusField, sizeField } = visualChannels;
-  const field = radiusField || sizeField;
-  return Math.ceil(radiusRange && field ? radiusRange[1] : radius);
-}
-function negateAccessor(accessor) {
-  return typeof accessor === "function" ? (d, i) => -accessor(d, i) : -accessor;
-}
-function getSizeAccessor({ name }, scaleType, aggregation, range, data) {
-  const scale = scaleType ? SCALE_FUNCS[scaleType]() : identity;
-  if (scaleType) {
-    if (aggregation !== "count") {
-      scale.domain(calculateDomain(data, name, scaleType));
-    }
-    scale.range(range);
-  }
-  let accessorKeys = getAccessorKeys(name, aggregation);
-  const accessor = (properties) => {
-    if (!(accessorKeys[0] in properties)) {
-      accessorKeys = findAccessorKey(accessorKeys, properties);
-    }
-    const propertyValue = properties[accessorKeys[0]];
-    return scale(propertyValue);
-  };
-  return normalizeAccessor(accessor, data);
-}
-var FORMATS = {
-  date: (s) => import_moment_timezone.default.utc(s).format("MM/DD/YY HH:mm:ssa"),
-  integer: (0, import_d3_format.format)("i"),
-  float: (0, import_d3_format.format)(".5f"),
-  timestamp: (s) => import_moment_timezone.default.utc(s).format("X"),
-  default: String
-};
-function getTextAccessor({ name, type }, data) {
-  const format = FORMATS[type] || FORMATS.default;
-  const accessor = (properties) => {
-    return format(properties[name]);
-  };
-  return normalizeAccessor(accessor, data);
-}
-
-// dist/api/parse-map.js
-function parseMap(json) {
-  const { keplerMapConfig, datasets, token } = json;
-  assert(keplerMapConfig.version === "v1", "Only support Kepler v1");
-  const { mapState, mapStyle } = keplerMapConfig.config;
-  const { layers, layerBlending, interactionConfig } = keplerMapConfig.config.visState;
+function createResult(result) {
   return {
-    id: json.id,
-    title: json.title,
-    description: json.description,
-    createdAt: json.createdAt,
-    updatedAt: json.updatedAt,
-    initialViewState: mapState,
-    /** @deprecated Use `basemap`. */
-    mapStyle,
-    token,
-    layers: layers.reverse().map(({ id: id5, type, config, visualChannels }) => {
-      try {
-        const { dataId } = config;
-        const dataset = datasets.find((d) => d.id === dataId);
-        assert(dataset, `No dataset matching dataId: ${dataId}`);
-        const { data } = dataset;
-        assert(data, `No data loaded for dataId: ${dataId}`);
-        const { Layer: Layer2, propMap, defaultProps: defaultProps12 } = getLayer(type, config, dataset);
-        const styleProps = createStyleProps(config, propMap);
-        return new Layer2({
-          id: id5,
-          data,
-          ...defaultProps12,
-          ...createInteractionProps(interactionConfig),
-          ...styleProps,
-          ...createChannelProps(id5, type, config, visualChannels, data),
-          // Must come after style
-          ...createParametersProp(layerBlending, styleProps.parameters || {}),
-          // Must come after style
-          ...createLoadOptions(token)
-        });
-      } catch (e) {
-        import_core17.log.error(e.message)();
-        return void 0;
-      }
-    })
+    ...result,
+    layers: result.layers.map((descriptor) => LayerFactory(descriptor))
   };
 }
-function createParametersProp(layerBlending, parameters) {
-  if (layerBlending === "additive") {
-    parameters.blendColorSrcFactor = parameters.blendAlphaSrcFactor = "src-alpha";
-    parameters.blendColorDstFactor = parameters.blendAlphaDstFactor = "dst-alpha";
-    parameters.blendColorOperation = parameters.blendAlphaOperation = "add";
-  } else if (layerBlending === "subtractive") {
-    parameters.blendColorSrcFactor = "one";
-    parameters.blendColorDstFactor = "one-minus-dst-color";
-    parameters.blendAlphaSrcFactor = "src-alpha";
-    parameters.blendAlphaDstFactor = "dst-alpha";
-    parameters.blendColorOperation = "subtract";
-    parameters.blendAlphaOperation = "add";
-  }
-  return Object.keys(parameters).length ? { parameters } : {};
-}
-function createInteractionProps(interactionConfig) {
-  const pickable = interactionConfig && interactionConfig.tooltip.enabled;
-  return {
-    autoHighlight: pickable,
-    pickable
+async function fetchMap(options) {
+  const { onNewData, ...rest } = options;
+  const _options = {
+    ...rest,
+    onNewData: typeof onNewData === "function" ? (result2) => {
+      onNewData(createResult(result2));
+    } : void 0
   };
-}
-function mapProps(source, target, mapping) {
-  for (const sourceKey in mapping) {
-    const sourceValue = source[sourceKey];
-    const targetKey = mapping[sourceKey];
-    if (sourceValue === void 0) {
-      continue;
-    }
-    if (typeof targetKey === "string") {
-      target[targetKey] = sourceValue;
-    } else if (typeof targetKey === "function") {
-      const [key, value] = Object.entries(targetKey(sourceValue))[0];
-      target[key] = value;
-    } else if (typeof targetKey === "object") {
-      mapProps(sourceValue, target, targetKey);
-    }
-  }
-}
-function createStyleProps(config, mapping) {
-  const result = {};
-  mapProps(config, result, mapping);
-  if (result.stroked && !result.getLineColor) {
-    result.getLineColor = result.getFillColor;
-  }
-  for (const colorAccessor in OPACITY_MAP) {
-    if (Array.isArray(result[colorAccessor])) {
-      const color = [...result[colorAccessor]];
-      const opacityKey = OPACITY_MAP[colorAccessor];
-      const opacity = config.visConfig[opacityKey];
-      color[3] = opacityToAlpha(opacity);
-      result[colorAccessor] = color;
-    }
-  }
-  result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
-  return result;
-}
-function createChannelProps(id5, type, config, visualChannels, data) {
-  var _a;
-  const { colorField, colorScale, radiusField, radiusScale, sizeField, sizeScale, strokeColorField, strokeColorScale, weightField } = visualChannels;
-  let { heightField, heightScale } = visualChannels;
-  if (type === "hexagonId") {
-    heightField = sizeField;
-    heightScale = sizeScale;
-  }
-  const { textLabel, visConfig } = config;
-  const result = {};
-  if (type === "grid" || type === "hexagon") {
-    result.colorScaleType = colorScale;
-    if (colorField) {
-      const { colorAggregation } = config.visConfig;
-      if (!AGGREGATION[colorAggregation]) {
-        result.getColorValue = getColorValueAccessor(colorField, colorAggregation, data);
-      } else {
-        result.getColorWeight = (d) => d[colorField.name];
-      }
-    }
-  } else if (colorField) {
-    const { colorAggregation: aggregation, colorRange: range } = visConfig;
-    result.getFillColor = getColorAccessor(
-      colorField,
-      // @ts-ignore
-      colorScale,
-      { aggregation, range },
-      visConfig.opacity,
-      data
-    );
-  }
-  if (type === "point") {
-    const altitude = (_a = config.columns) == null ? void 0 : _a.altitude;
-    if (altitude) {
-      result.dataTransform = (data2) => {
-        data2.features.forEach(({ geometry, properties }) => {
-          const { type: type2, coordinates } = geometry;
-          if (type2 === "Point") {
-            coordinates[2] = properties[altitude];
-          }
-        });
-        return data2;
-      };
-    }
-  }
-  if (radiusField || sizeField) {
-    result.getPointRadius = getSizeAccessor(
-      // @ts-ignore
-      radiusField || sizeField,
-      // @ts-ignore
-      radiusScale || sizeScale,
-      visConfig.sizeAggregation,
-      visConfig.radiusRange || visConfig.sizeRange,
-      data
-    );
-  }
-  if (strokeColorField) {
-    const fallbackOpacity = type === "point" ? visConfig.opacity : 1;
-    const opacity = visConfig.strokeOpacity !== void 0 ? visConfig.strokeOpacity : fallbackOpacity;
-    const { strokeColorAggregation: aggregation, strokeColorRange: range } = visConfig;
-    result.getLineColor = getColorAccessor(
-      strokeColorField,
-      // @ts-ignore
-      strokeColorScale,
-      // @ts-ignore
-      { aggregation, range },
-      opacity,
-      data
-    );
-  }
-  if (heightField && visConfig.enable3d) {
-    result.getElevation = getSizeAccessor(
-      heightField,
-      // @ts-ignore
-      heightScale,
-      visConfig.heightAggregation,
-      visConfig.heightRange || visConfig.sizeRange,
-      data
-    );
-  }
-  if (weightField) {
-    result.getWeight = getSizeAccessor(weightField, void 0, visConfig.weightAggregation, void 0, data);
-  }
-  if (visConfig.customMarkers) {
-    const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
-    const { getPointRadius, getFillColor } = result;
-    const { customMarkersUrl, customMarkersRange, filled: useMaskedIcons } = visConfig;
-    result.pointType = "icon";
-    result.getIcon = getIconUrlAccessor(visualChannels.customMarkersField, customMarkersRange, { fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons }, data);
-    result._subLayerProps = {
-      "points-icon": {
-        loadOptions: {
-          image: {
-            type: "imagebitmap"
-          },
-          imagebitmap: {
-            resizeWidth: maxIconSize,
-            resizeHeight: maxIconSize,
-            resizeQuality: "high"
-          }
-        }
-      }
-    };
-    if (getFillColor && useMaskedIcons) {
-      result.getIconColor = getFillColor;
-    }
-    if (getPointRadius) {
-      result.getIconSize = getPointRadius;
-    }
-    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 = id5;
-    ({
-      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": {
-        // The following props are injected by default by VectorTileLayer:
-        // type: PointLabelLayer,
-        // extensions: [new CollisionFilterExtension()],
-        collisionEnabled: true,
-        collisionGroup,
-        // getPointRadius already has radiusScale baked in, so only pass one or the other
-        ...result.getPointRadius ? { getRadius: result.getPointRadius } : { radiusScale: visConfig.radius },
-        ...secondaryField && {
-          getSecondaryText,
-          getSecondaryColor,
-          secondarySizeScale,
-          secondaryOutlineColor
-        }
-      }
-    };
-  }
+  const _result = await (0, import_api_client2.fetchMap)(_options);
+  const result = createResult(_result);
   return result;
 }
-function createLoadOptions(accessToken) {
-  return {
-    loadOptions: { fetch: { headers: { Authorization: `Bearer ${accessToken}` } } }
-  };
-}
 
 // dist/api/basemap.js
 var CUSTOM_STYLE_ID_PREFIX = "custom:";
@@ -3465,190 +2838,7 @@ async function fetchBasemapProps({ config, errorContext, applyLayerFilters = tru
   };
 }
 
-// dist/api/fetch-map.js
-async function _fetchMapDataset(dataset, context) {
-  const { aggregationExp, aggregationResLevel, connectionName, columns, format, geoColumn, source, type, queryParameters } = dataset;
-  const cache = {};
-  const globalOptions = {
-    ...context,
-    cache,
-    connectionName,
-    format
-  };
-  if (type === "tileset") {
-    dataset.data = await (0, import_api_client2.vectorTilesetSource)({ ...globalOptions, tableName: source });
-  } else {
-    const [spatialDataType, spatialDataColumn] = geoColumn ? geoColumn.split(":") : ["geom"];
-    if (spatialDataType === "geom") {
-      const options = { ...globalOptions, spatialDataColumn };
-      if (type === "table") {
-        dataset.data = await (0, import_api_client2.vectorTableSource)({ ...options, columns, tableName: source });
-      } else if (type === "query") {
-        dataset.data = await (0, import_api_client2.vectorQuerySource)({
-          ...options,
-          columns,
-          sqlQuery: source,
-          queryParameters
-        });
-      }
-    } else if (spatialDataType === "h3") {
-      const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
-      if (type === "table") {
-        dataset.data = await (0, import_api_client2.h3TableSource)({ ...options, tableName: source });
-      } else if (type === "query") {
-        dataset.data = await (0, import_api_client2.h3QuerySource)({ ...options, sqlQuery: source, queryParameters });
-      }
-    } else if (spatialDataType === "quadbin") {
-      const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
-      if (type === "table") {
-        dataset.data = await (0, import_api_client2.quadbinTableSource)({ ...options, tableName: source });
-      } else if (type === "query") {
-        dataset.data = await (0, import_api_client2.quadbinQuerySource)({ ...options, sqlQuery: source, queryParameters });
-      }
-    }
-  }
-  let cacheChanged = true;
-  if (cache.value) {
-    cacheChanged = dataset.cache !== cache.value;
-    dataset.cache = cache.value;
-  }
-  return cacheChanged;
-}
-async function _fetchTilestats(attribute, dataset, context) {
-  const { connectionName, data, id: id5, source, type, queryParameters } = dataset;
-  const { apiBaseUrl } = context;
-  const errorContext = {
-    requestType: "Tile stats",
-    connection: connectionName,
-    type,
-    source
-  };
-  if (!("tilestats" in data)) {
-    throw new import_api_client2.CartoAPIError(new Error(`Invalid dataset for tilestats: ${id5}`), errorContext);
-  }
-  const baseUrl = (0, import_api_client2.buildStatsUrl)({ attribute, apiBaseUrl, ...dataset });
-  const client = new URLSearchParams(data.tiles[0]).get("client");
-  const headers = { Authorization: `Bearer ${context.accessToken}` };
-  const parameters = {};
-  if (client) {
-    parameters.client = client;
-  }
-  if (type === "query") {
-    parameters.q = source;
-    if (queryParameters) {
-      parameters.queryParameters = JSON.stringify(queryParameters);
-    }
-  }
-  const stats = await (0, import_api_client2.requestWithParameters)({
-    baseUrl,
-    headers,
-    parameters,
-    errorContext,
-    maxLengthURL: context.maxLengthURL
-  });
-  const { attributes } = data.tilestats.layers[0];
-  const index = attributes.findIndex((d) => d.attribute === attribute);
-  attributes[index] = stats;
-  return true;
-}
-async function fillInMapDatasets({ datasets }, context) {
-  const promises = datasets.map((dataset) => _fetchMapDataset(dataset, context));
-  return await Promise.all(promises);
-}
-async function fillInTileStats({ datasets, keplerMapConfig }, context) {
-  var _a;
-  const attributes = [];
-  const { layers } = keplerMapConfig.config.visState;
-  for (const layer of layers) {
-    for (const channel of Object.keys(layer.visualChannels)) {
-      const attribute = (_a = layer.visualChannels[channel]) == null ? void 0 : _a.name;
-      if (attribute) {
-        const dataset = datasets.find((d) => d.id === layer.config.dataId);
-        if (dataset && dataset.type !== "tileset" && dataset.data.tilestats) {
-          attributes.push({ attribute, dataset });
-        }
-      }
-    }
-  }
-  const filteredAttributes = [];
-  for (const a of attributes) {
-    if (!filteredAttributes.find(({ attribute, dataset }) => attribute === a.attribute && dataset === a.dataset)) {
-      filteredAttributes.push(a);
-    }
-  }
-  const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, context));
-  return await Promise.all(promises);
-}
-async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.DEFAULT_API_BASE_URL, cartoMapId, clientId, headers, autoRefresh, onNewData, maxLengthURL }) {
-  assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
-  if (accessToken) {
-    headers = { Authorization: `Bearer ${accessToken}`, ...headers };
-  }
-  if (autoRefresh || onNewData) {
-    assert(onNewData, "Must define `onNewData` when using autoRefresh");
-    assert(typeof onNewData === "function", "`onNewData` must be a function");
-    assert(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
-  }
-  const baseUrl = (0, import_api_client2.buildPublicMapUrl)({ apiBaseUrl, cartoMapId });
-  const errorContext = { requestType: "Public map", mapId: cartoMapId };
-  const map = await (0, import_api_client2.requestWithParameters)({ baseUrl, headers, errorContext, maxLengthURL });
-  const context = {
-    accessToken: map.token || accessToken,
-    apiBaseUrl,
-    clientId,
-    headers,
-    maxLengthURL
-  };
-  let stopAutoRefresh;
-  if (autoRefresh) {
-    const intervalId = setInterval(async () => {
-      const changed = await fillInMapDatasets(map, {
-        ...context,
-        headers: {
-          ...headers,
-          "If-Modified-Since": new Date().toUTCString()
-        }
-      });
-      if (onNewData && changed.some((v) => v === true)) {
-        onNewData(parseMap(map));
-      }
-    }, autoRefresh * 1e3);
-    stopAutoRefresh = () => {
-      clearInterval(intervalId);
-    };
-  }
-  const geojsonLayers = map.keplerMapConfig.config.visState.layers.filter(({ type }) => type === "geojson" || type === "point");
-  const geojsonDatasetIds = geojsonLayers.map(({ config }) => config.dataId);
-  map.datasets.forEach((dataset) => {
-    if (geojsonDatasetIds.includes(dataset.id)) {
-      const { config } = geojsonLayers.find(({ config: config2 }) => config2.dataId === dataset.id);
-      dataset.format = "geojson";
-      if (!dataset.geoColumn && config.columns.geojson) {
-        dataset.geoColumn = config.columns.geojson;
-      }
-    }
-  });
-  const [basemap] = await Promise.all([
-    fetchBasemapProps({ config: map.keplerMapConfig.config, errorContext }),
-    // Mutates map.datasets so that dataset.data contains data
-    fillInMapDatasets(map, context)
-  ]);
-  await fillInTileStats(map, context);
-  const out = { ...parseMap(map), basemap, ...{ 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;
-}
-
 // dist/index.js
-var import_api_client3 = require("@carto/api-client");
-var import_api_client4 = require("@carto/api-client");
 var CARTO_LAYERS = {
   ClusterTileLayer: cluster_tile_layer_default,
   H3TileLayer: h3_tile_layer_default,
@@ -3658,18 +2848,4 @@ var CARTO_LAYERS = {
   RasterTileLayer: raster_tile_layer_default,
   VectorTileLayer: vector_tile_layer_default
 };
-var CARTO_SOURCES = {
-  boundaryQuerySource: import_api_client3.boundaryQuerySource,
-  boundaryTableSource: import_api_client3.boundaryTableSource,
-  h3QuerySource: import_api_client3.h3QuerySource,
-  h3TableSource: import_api_client3.h3TableSource,
-  h3TilesetSource: import_api_client3.h3TilesetSource,
-  rasterSource: import_api_client3.rasterSource,
-  quadbinQuerySource: import_api_client3.quadbinQuerySource,
-  quadbinTableSource: import_api_client3.quadbinTableSource,
-  quadbinTilesetSource: import_api_client3.quadbinTilesetSource,
-  vectorQuerySource: import_api_client3.vectorQuerySource,
-  vectorTableSource: import_api_client3.vectorTableSource,
-  vectorTilesetSource: import_api_client3.vectorTilesetSource
-};
 //# sourceMappingURL=index.cjs.map