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

package/dist/index.cjs

@@ -33,15 +33,16 @@ __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,
+  PointLabelLayer: () => point_label_layer_default,
   QuadbinTileLayer: () => quadbin_tile_layer_default,
   RasterTileLayer: () => raster_tile_layer_default,
-  SOURCE_DEFAULTS: () => import_api_client3.SOURCE_DEFAULTS,
+  SOURCE_DEFAULTS: () => import_api_client4.SOURCE_DEFAULTS,
   VectorTileLayer: () => vector_tile_layer_default,
   _GOOGLE_BASEMAPS: () => GOOGLE_BASEMAPS,
-  _PointLabelLayer: () => point_label_layer_default,
   _QuadbinLayer: () => quadbin_layer_default,
   _RasterLayer: () => raster_layer_default,
   _STYLE_LAYER_GROUPS: () => STYLE_LAYER_GROUPS,
@@ -49,23 +50,24 @@ __export(dist_exports, {
   _applyLayerGroupFilters: () => applyLayerGroupFilters,
   _fetchStyle: () => fetchStyle,
   _getStyleUrl: () => getStyleUrl,
-  boundaryQuerySource: () => import_api_client3.boundaryQuerySource,
-  boundaryTableSource: () => import_api_client3.boundaryTableSource,
+  boundaryQuerySource: () => import_api_client4.boundaryQuerySource,
+  boundaryTableSource: () => import_api_client4.boundaryTableSource,
   colorBins: () => colorBins,
   colorCategories: () => colorCategories,
   colorContinuous: () => colorContinuous,
   fetchBasemapProps: () => fetchBasemapProps,
   fetchMap: () => fetchMap,
-  h3QuerySource: () => import_api_client3.h3QuerySource,
-  h3TableSource: () => import_api_client3.h3TableSource,
-  h3TilesetSource: () => import_api_client3.h3TilesetSource,
-  quadbinQuerySource: () => import_api_client3.quadbinQuerySource,
-  quadbinTableSource: () => import_api_client3.quadbinTableSource,
-  quadbinTilesetSource: () => import_api_client3.quadbinTilesetSource,
-  rasterSource: () => import_api_client3.rasterSource,
-  vectorQuerySource: () => import_api_client3.vectorQuerySource,
-  vectorTableSource: () => import_api_client3.vectorTableSource,
-  vectorTilesetSource: () => import_api_client3.vectorTilesetSource
+  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
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -251,9 +253,17 @@ function getQuadbinPolygon(quadbin, coverage = 1) {
 }
 
 // dist/layers/schema/fast-pbf.js
-function readPackedTypedArray(TypedArray, pbf, obj) {
+var import_compression = require("@loaders.gl/compression");
+function readPackedTypedArray(TypedArray, pbf, obj, options) {
   const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-  obj.value = new TypedArray(pbf.buf.buffer.slice(pbf.pos, end));
+  const data = pbf.buf.buffer.slice(pbf.pos, end);
+  if ((options == null ? void 0 : options.compression) === "gzip") {
+    const compression = new import_compression.GZipCompression();
+    const decompressedData = compression.decompressSync(data);
+    obj.value = new TypedArray(decompressedData);
+  } else {
+    obj.value = new TypedArray(data);
+  }
   pbf.pos = end;
   return obj.value;
 }
@@ -553,7 +563,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION = true ? "9.1.0-beta.1" : "latest";
+var VERSION = true ? "9.1.0" : "latest";
 var id = "cartoSpatialTile";
 var DEFAULT_OPTIONS = {
   cartoSpatialTile: {
@@ -914,7 +924,8 @@ var BandReader = class {
         throw Error(`Invalid data type: ${obj.type}`);
       }
       obj.data = {};
-      readPackedTypedArray(TypedArray, pbf, obj.data);
+      const { compression } = TileReader3;
+      readPackedTypedArray(TypedArray, pbf, obj.data, { compression });
     }
   }
 };
@@ -931,10 +942,11 @@ var TileReader3 = class {
 };
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION2 = true ? "9.1.0-beta.1" : "latest";
+var VERSION2 = true ? "9.1.0" : "latest";
 var id2 = "cartoRasterTile";
 var DEFAULT_OPTIONS2 = {
   cartoRasterTile: {
+    metadata: null,
     workerUrl: getWorkerUrl(id2, VERSION2)
   }
 };
@@ -952,9 +964,13 @@ var CartoRasterTileLoader = {
   options: DEFAULT_OPTIONS2
 };
 function parseCartoRasterTile(arrayBuffer, options) {
-  if (!arrayBuffer)
+  var _a;
+  const metadata = (_a = options == null ? void 0 : options.cartoRasterTile) == null ? void 0 : _a.metadata;
+  if (!arrayBuffer || !metadata)
     return null;
-  const { bands, blockSize } = parsePbf(arrayBuffer, TileReader3);
+  TileReader3.compression = metadata.compression;
+  const out = parsePbf(arrayBuffer, TileReader3);
+  const { bands, blockSize } = out;
   const numericProps = {};
   for (let i = 0; i < bands.length; i++) {
     const { name, data } = bands[i];
@@ -1249,7 +1265,8 @@ function RTTModifier(BaseLayer) {
         postProcessLayer.disableRTT();
       }
     }
-  }, _a.layerName = `RTT-${BaseLayer.layerName}`, _a;
+  }, // @ts-expect-error typescript doesn't see static property
+  _a.layerName = `RTT-${BaseLayer.layerName}`, _a;
 }
 function PostProcessModifier(BaseLayer, effect) {
   var _a;
@@ -1320,8 +1337,28 @@ function PostProcessModifier(BaseLayer, effect) {
       });
       this.internalState.renderInProgress = false;
     }
+    _finalize() {
+      this.internalState.renderBuffers.forEach((fbo) => {
+        fbo.destroy();
+      });
+      this.internalState.renderBuffers = null;
+      this.internalState.postProcess.cleanup();
+    }
   }, _a.layerName = `PostProcess${BaseLayer.layerName}`, _a;
 }
+var fs2 = (
+  /* glsl */
+  `vec4 copy_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return color;
+}
+`
+);
+var copy = {
+  name: "copy",
+  fs: fs2,
+  getUniforms: () => ({}),
+  passes: [{ filter: true }]
+};
 
 // dist/layers/quadbin-tile-layer.js
 var import_core10 = require("@deck.gl/core");
@@ -1770,15 +1807,15 @@ out vec4 vColor;
 out vec4 position_commonspace;
 #endif
 void main(void) {
-vec2 common_position = column.offset.xy;
+vec2 tileOrigin = column.offset.xy;
 float scale = column.widthScale;
 int yIndex = - (gl_InstanceID / BLOCK_WIDTH);
 int xIndex = gl_InstanceID + (yIndex * BLOCK_WIDTH);
-common_position += scale * vec2(float(xIndex), float(yIndex - 1));
+vec2 cellCenter = scale * vec2(float(xIndex) + 0.5, float(yIndex) - 0.5);
 vec4 color = column.isStroke ? instanceLineColors : instanceFillColors;
 float shouldRender = float(color.a > 0.0 && instanceElevations >= 0.0);
 float cellWidth = column.coverage * scale;
-geometry.position = vec4(common_position, 0.0, 1.0);
+geometry.position = vec4(tileOrigin + cellCenter, 0.0, 1.0);
 if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
 geometry.position.xyz -= project.commonOrigin;
 }
@@ -1795,10 +1832,10 @@ strokeOffsetRatio -= halfOffset;
 }
 }
 geometry.pickingColor = instancePickingColors;
-vec2 offset = (vec2(0.5) + positions.xy * strokeOffsetRatio) * cellWidth * shouldRender;
-vec3 pos = vec3(offset, project_size(elevation));
-DECKGL_FILTER_SIZE(pos, geometry);
-geometry.position.xyz += pos;
+vec2 base = positions.xy * scale * strokeOffsetRatio * column.coverage * shouldRender;
+vec3 cell = vec3(base, project_size(elevation));
+DECKGL_FILTER_SIZE(cell, geometry);
+geometry.position.xyz += cell;
 gl_Position = project_common_position_to_clipspace(geometry.position);
 geometry.normal = project_normal(normals);
 DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
@@ -1829,7 +1866,7 @@ var defaultProps8 = {
     [-0.5, 0.5]
   ]
 };
-var RasterColumnLayer = class extends import_layers4.ColumnLayer {
+var RasterColumnLayer = class extends RTTModifier(import_layers4.ColumnLayer) {
   getShaders() {
     const shaders = super.getShaders();
     const data = this.props.data;
@@ -1894,7 +1931,17 @@ var RasterLayer = class extends import_core13.CompositeLayer {
       lineWidthScale,
       // Re-use widthScale prop to pass cell scale,
       highlightedObjectIndex,
-      highlightColor
+      highlightColor,
+      // RTT requires blending otherwise opacity < 1 blends with black
+      // render target
+      parameters: {
+        blendColorSrcFactor: "one",
+        blendAlphaSrcFactor: "one",
+        blendColorDstFactor: "zero",
+        blendAlphaDstFactor: "zero",
+        blendColorOperation: "add",
+        blendAlphaOperation: "add"
+      }
     });
   }
   getSubLayerAccessor(accessor) {
@@ -1951,8 +1998,17 @@ var renderSubLayers3 = (props) => {
 };
 var defaultProps9 = {
   data: TilejsonPropType,
+  refinementStrategy: "no-overlap",
   tileSize: DEFAULT_TILE_SIZE
 };
+var PostProcessTileLayer = class extends PostProcessModifier(import_geo_layers7.TileLayer, copy) {
+  filterSubLayer(context) {
+    const { tile } = context.layer.props;
+    if (!tile)
+      return true;
+    return super.filterSubLayer(context);
+  }
+};
 var RasterTileLayer = class extends import_core14.CompositeLayer {
   getLoadOptions() {
     const loadOptions = super.getLoadOptions() || {};
@@ -1964,8 +2020,8 @@ var RasterTileLayer = class extends import_core14.CompositeLayer {
     const tileJSON = this.props.data;
     if (!tileJSON)
       return null;
-    const { tiles: data, minzoom: minZoom, maxzoom: maxZoom } = tileJSON;
-    const SubLayerClass = this.getSubLayerClass("tile", import_geo_layers7.TileLayer);
+    const { tiles: data, minzoom: minZoom, maxzoom: maxZoom, raster_metadata: metadata } = tileJSON;
+    const SubLayerClass = this.getSubLayerClass("tile", PostProcessTileLayer);
     return new SubLayerClass(this.props, {
       id: `raster-tile-layer-${this.props.id}`,
       data,
@@ -1974,7 +2030,10 @@ var RasterTileLayer = class extends import_core14.CompositeLayer {
       renderSubLayers: renderSubLayers3,
       minZoom,
       maxZoom,
-      loadOptions: this.getLoadOptions()
+      loadOptions: {
+        cartoRasterTile: { metadata },
+        ...this.getLoadOptions()
+      }
     });
   }
 };
@@ -2009,7 +2068,7 @@ var CartoPropertiesTileLoader = {
   extensions: ["pbf"],
   mimeTypes: ["application/vnd.carto-properties-tile"],
   category: "geometry",
-  worker: false,
+  worker: true,
   parse: async (arrayBuffer, options) => parseCartoPropertiesTile(arrayBuffer, options),
   parseSync: parseCartoPropertiesTile,
   options: {}
@@ -2023,7 +2082,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut = __toESM(require("earcut"), 1);
-var VERSION3 = true ? "9.1.0-beta.1" : "latest";
+var VERSION3 = true ? "9.1.0" : "latest";
 var id3 = "cartoVectorTile";
 var DEFAULT_OPTIONS3 = {
   cartoVectorTile: {
@@ -2532,7 +2591,7 @@ function getLayer(type, config, dataset) {
       Layer: import_layers6.GeoJsonLayer,
       propMap: {
         columns: {
-          altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
+          altitude: (x) => ({ parameters: { depthWriteEnabled: Boolean(x) } })
         },
         visConfig: { outline: "stroked" }
       }
@@ -3098,18 +3157,14 @@ async function fetchBasemapProps({ config, errorContext, applyLayerFilters = tru
 }
 
 // dist/api/fetch-map.js
-async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, headers, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
+async function _fetchMapDataset(dataset, context) {
   const { aggregationExp, aggregationResLevel, connectionName, columns, format, geoColumn, source, type, queryParameters } = dataset;
   const cache = {};
   const globalOptions = {
-    accessToken,
-    apiBaseUrl,
+    ...context,
     cache,
-    clientId,
     connectionName,
-    format,
-    headers,
-    maxLengthURL
+    format
   };
   if (type === "tileset") {
     dataset.data = await (0, import_api_client2.vectorTilesetSource)({ ...globalOptions, tableName: source });
@@ -3150,8 +3205,9 @@ async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, head
   }
   return cacheChanged;
 }
-async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
+async function _fetchTilestats(attribute, dataset, context) {
   const { connectionName, data, id: id4, source, type, queryParameters } = dataset;
+  const { apiBaseUrl } = context;
   const errorContext = {
     requestType: "Tile stats",
     connection: connectionName,
@@ -3163,7 +3219,7 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
   }
   const baseUrl = (0, import_api_client2.buildStatsUrl)({ attribute, apiBaseUrl, ...dataset });
   const client = new URLSearchParams(data.tiles[0]).get("client");
-  const headers = { Authorization: `Bearer ${accessToken}` };
+  const headers = { Authorization: `Bearer ${context.accessToken}` };
   const parameters = {};
   if (client) {
     parameters.client = client;
@@ -3179,18 +3235,18 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
     headers,
     parameters,
     errorContext,
-    maxLengthURL
+    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, token }, clientId, apiBaseUrl, headers, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
-  const promises = datasets.map((dataset) => _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers, maxLengthURL));
+async function fillInMapDatasets({ datasets }, context) {
+  const promises = datasets.map((dataset) => _fetchMapDataset(dataset, context));
   return await Promise.all(promises);
 }
-async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL) {
+async function fillInTileStats({ datasets, keplerMapConfig }, context) {
   var _a;
   const attributes = [];
   const { layers } = keplerMapConfig.config.visState;
@@ -3211,12 +3267,11 @@ async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl,
       filteredAttributes.push(a);
     }
   }
-  const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, token, apiBaseUrl, maxLengthURL));
+  const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, context));
   return await Promise.all(promises);
 }
-async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.SOURCE_DEFAULTS.apiBaseUrl, cartoMapId, clientId = import_api_client2.SOURCE_DEFAULTS.clientId, headers = {}, autoRefresh, onNewData, maxLengthURL = import_api_client2.SOURCE_DEFAULTS.maxLengthURL }) {
+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"})');
-  assert(apiBaseUrl, "Must define apiBaseUrl");
   if (accessToken) {
     headers = { Authorization: `Bearer ${accessToken}`, ...headers };
   }
@@ -3228,13 +3283,23 @@ async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.SOURCE_DE
   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, clientId, apiBaseUrl, {
-        ...headers,
-        "If-Modified-Since": new Date().toUTCString()
-      }, maxLengthURL);
+      const changed = await fillInMapDatasets(map, {
+        ...context,
+        headers: {
+          ...headers,
+          "If-Modified-Since": new Date().toUTCString()
+        }
+      });
       if (onNewData && changed.some((v) => v === true)) {
         onNewData(parseMap(map));
       }
@@ -3257,9 +3322,9 @@ async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.SOURCE_DE
   const [basemap] = await Promise.all([
     fetchBasemapProps({ config: map.keplerMapConfig.config, errorContext }),
     // Mutates map.datasets so that dataset.data contains data
-    fillInMapDatasets(map, clientId, apiBaseUrl, headers, maxLengthURL)
+    fillInMapDatasets(map, context)
   ]);
-  await fillInTileStats(map, apiBaseUrl, maxLengthURL);
+  await fillInTileStats(map, context);
   const out = { ...parseMap(map), basemap, ...{ stopAutoRefresh } };
   const textLayers = out.layers.filter((layer) => {
     const pointType = layer.props.pointType || "";
@@ -3274,11 +3339,12 @@ async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.SOURCE_DE
 
 // 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,
   HeatmapTileLayer: heatmap_tile_layer_default,
-  _PointLabelLayer: point_label_layer_default,
+  PointLabelLayer: point_label_layer_default,
   QuadbinTileLayer: quadbin_tile_layer_default,
   RasterTileLayer: raster_tile_layer_default,
   VectorTileLayer: vector_tile_layer_default