@deck.gl/carto 8.10.0-alpha.6 → 9.0.0-alpha.3

package/src/api/types.ts

@@ -1,8 +1,57 @@
 import {SCALE_TYPE} from './layer-map';
 
+export type Format = 'json' | 'geojson' | 'tilejson';
+export type MapType = 'boundary' | 'query' | 'table' | 'tileset' | 'raster';
+export type RequestType = 'Map data' | 'Map instantiation' | 'Public map' | 'Tile stats' | 'SQL';
+export type APIErrorContext = {
+  requestType: RequestType;
+  mapId?: string;
+  connection?: string;
+  source?: string;
+  type?: MapType;
+};
+
+export enum SchemaFieldType {
+  Number = 'number',
+  Bigint = 'bigint',
+  String = 'string',
+  Geometry = 'geometry',
+  Timestamp = 'timestamp',
+  Object = 'object',
+  Boolean = 'boolean',
+  Variant = 'variant',
+  Unknown = 'unknown'
+}
+export interface SchemaField {
+  name: string;
+  type: SchemaFieldType; // Field type in the CARTO stack, common for all providers
+}
+
+export interface MapInstantiation extends MapInstantiationFormats {
+  nrows: number;
+  size?: number;
+  schema: SchemaField[];
+}
+
+type MapInstantiationFormats = Record<
+  Format,
+  {
+    url: string[];
+    error?: any;
+  }
+>;
+
+export type QueryParameterValue = string | number | boolean | Array<QueryParameterValue> | object;
+
+export type NamedQueryParameter = Record<string, QueryParameterValue>;
+
+export type PositionalQueryParameter = QueryParameterValue[];
+
+export type QueryParameters = NamedQueryParameter | PositionalQueryParameter;
 export type VisualChannelField = {
   name: string;
   type: string;
+  colorColumn?: string;
 };
 
 export type VisualChannels = {

package/src/index.ts

@@ -1,53 +1,105 @@
-export {getDefaultCredentials, setDefaultCredentials} from './config';
-export {default as CartoLayer} from './layers/carto-layer'; // <-- REMOVE in v9
-export {default as VectorTileLayer} from './layers/vector-tile-layer';
-export {default as H3TileLayer} from './layers/h3-tile-layer';
-export {default as _PointLabelLayer} from './layers/point-label-layer';
-export {default as QuadbinTileLayer} from './layers/quadbin-tile-layer';
-export {default as RasterTileLayer} from './layers/raster-tile-layer';
+import {default as H3TileLayer} from './layers/h3-tile-layer';
+import {default as _PointLabelLayer} from './layers/point-label-layer';
+import {default as QuadbinTileLayer} from './layers/quadbin-tile-layer';
+import {default as RasterTileLayer} from './layers/raster-tile-layer';
+import {default as VectorTileLayer} from './layers/vector-tile-layer';
+const CARTO_LAYERS = {
+  H3TileLayer,
+  _PointLabelLayer,
+  QuadbinTileLayer,
+  RasterTileLayer,
+  VectorTileLayer
+};
+export {
+  CARTO_LAYERS,
+  H3TileLayer,
+  _PointLabelLayer,
+  QuadbinTileLayer,
+  RasterTileLayer,
+  VectorTileLayer
+};
+
 export {default as BASEMAP} from './basemap';
 export {default as colorBins} from './style/color-bins-style';
 export {default as colorCategories} from './style/color-categories-style';
 export {default as colorContinuous} from './style/color-continuous-style';
-export {
-  FORMATS,
-  TILE_FORMATS,
-  MAP_TYPES,
-  API_VERSIONS,
-  CartoAPIError,
-  fetchLayerData,
-  fetchMap,
-  getDataV2 as _getDataV2,
-  mapInstantiation as _mapInstantiation
+export {CartoAPIError, fetchMap, query} from './api';
+export type {
+  APIErrorContext,
+  FetchMapOptions,
+  Format,
+  MapType,
+  RequestType,
+  QueryParameters,
+  QueryOptions
 } from './api';
-export type {APIErrorContext, QueryParameters} from './api';
-export type {CartoLayerProps} from './layers/carto-layer';
 
-export {
-  cartoH3QuerySource,
-  cartoH3TableSource,
-  cartoH3TilesetSource,
-  cartoRasterSource,
-  cartoQuadbinQuerySource,
-  cartoQuadbinTableSource,
-  cartoQuadbinTilesetSource,
-  cartoVectorQuerySource,
-  cartoVectorTableSource,
-  cartoVectorTilesetSource,
+import {
+  boundaryQuerySource,
+  boundaryTableSource,
+  boundaryTilesetSource,
+  h3QuerySource,
+  h3TableSource,
+  h3TilesetSource,
+  rasterSource,
+  quadbinQuerySource,
+  quadbinTableSource,
+  quadbinTilesetSource,
+  vectorQuerySource,
+  vectorTableSource,
+  vectorTilesetSource,
   SOURCE_DEFAULTS
 } from './sources';
+
+const CARTO_SOURCES = {
+  boundaryQuerySource,
+  boundaryTableSource,
+  boundaryTilesetSource,
+  h3QuerySource,
+  h3TableSource,
+  h3TilesetSource,
+  rasterSource,
+  quadbinQuerySource,
+  quadbinTableSource,
+  quadbinTilesetSource,
+  vectorQuerySource,
+  vectorTableSource,
+  vectorTilesetSource
+};
+
+export {
+  boundaryQuerySource,
+  boundaryTableSource,
+  boundaryTilesetSource,
+  h3QuerySource,
+  h3TableSource,
+  h3TilesetSource,
+  rasterSource,
+  quadbinQuerySource,
+  quadbinTableSource,
+  quadbinTilesetSource,
+  vectorQuerySource,
+  vectorTableSource,
+  vectorTilesetSource,
+  CARTO_SOURCES,
+  SOURCE_DEFAULTS
+};
+
 export type {
-  CartoTilejsonResult,
-  CartoH3QuerySourceOptions,
-  CartoH3TableSourceOptions,
-  CartoH3TilesetSourceOptions,
-  CartoRasterSourceOptions,
-  CartoQuadbinQuerySourceOptions,
-  CartoQuadbinTableSourceOptions,
-  CartoQuadbinTilesetSourceOptions,
-  CartoVectorQuerySourceOptions,
-  CartoVectorTableSourceOptions,
-  CartoVectorTilesetSourceOptions,
+  TilejsonResult,
+  BoundaryQuerySourceOptions,
+  BoundaryTableSourceOptions,
+  BoundaryTilesetSourceOptions,
+  H3QuerySourceOptions,
+  H3TableSourceOptions,
+  H3TilesetSourceOptions,
+  RasterSourceOptions,
+  QuadbinQuerySourceOptions,
+  QuadbinTableSourceOptions,
+  QuadbinTilesetSourceOptions,
+  VectorQuerySourceOptions,
+  VectorTableSourceOptions,
+  VectorTilesetSourceOptions,
   GeojsonResult,
   JsonResult
 } from './sources';

package/src/layers/h3-tile-layer.ts

@@ -1,11 +1,11 @@
 import {CompositeLayer, CompositeLayerProps, Layer, LayersList, DefaultProps} from '@deck.gl/core';
-import {H3HexagonLayer} from '@deck.gl/geo-layers';
+import {H3HexagonLayer, H3HexagonLayerProps} from '@deck.gl/geo-layers';
 import H3Tileset2D, {getHexagonResolution} from './h3-tileset-2d';
-import SpatialIndexTileLayer from './spatial-index-tile-layer';
-import {TilejsonPropType, CartoTilejsonResult} from '../sources/common';
-import {injectAccessToken} from './utils';
+import SpatialIndexTileLayer, {SpatialIndexTileLayerProps} from './spatial-index-tile-layer';
+import type {TilejsonResult} from '../sources/types';
+import {injectAccessToken, TilejsonPropType} from './utils';
 
-const renderSubLayers = (props: H3HexagonLayerProps) => {
+export const renderSubLayers = props => {
   const {data} = props;
   const {index} = props.tile;
   if (!data || !data.length) return null;
@@ -17,23 +17,18 @@ const renderSubLayers = (props: H3HexagonLayerProps) => {
   });
 };
 
-const defaultProps: DefaultProps<H3HexagonLayerProps> = {
-  aggregationResLevel: 4,
+const defaultProps: DefaultProps<H3TileLayerProps> = {
   data: TilejsonPropType
 };
 
 /** All properties supported by H3TileLayer. */
-export type H3TileLayerProps<DataT = any> = _H3TileLayerProps<DataT> & CompositeLayerProps;
-
-// TODO: use type from h3-hexagon-layer when available
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type H3HexagonLayerProps<DataT = any> = Record<string, any>;
+export type H3TileLayerProps<DataT = unknown> = _H3TileLayerProps<DataT> & CompositeLayerProps;
 
 /** Properties added by H3TileLayer. */
-type _H3TileLayerProps<DataT> = Omit<H3HexagonLayerProps<DataT>, 'data'> & {
-  data: null | CartoTilejsonResult | Promise<CartoTilejsonResult>;
-  aggregationResLevel?: number;
-};
+type _H3TileLayerProps<DataT> = Omit<H3HexagonLayerProps<DataT>, 'data'> &
+  Omit<SpatialIndexTileLayerProps<DataT>, 'data'> & {
+    data: null | TilejsonResult | Promise<TilejsonResult>;
+  };
 
 export default class H3TileLayer<DataT = any, ExtraPropsT extends {} = {}> extends CompositeLayer<
   ExtraPropsT & Required<_H3TileLayerProps<DataT>>
@@ -47,14 +42,14 @@ export default class H3TileLayer<DataT = any, ExtraPropsT extends {} = {}> exten
 
   getLoadOptions(): any {
     const loadOptions = super.getLoadOptions() || {};
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     injectAccessToken(loadOptions, tileJSON.accessToken);
     loadOptions.cartoSpatialTile = {...loadOptions.cartoSpatialTile, scheme: 'h3'};
     return loadOptions;
   }
 
   renderLayers(): Layer | null | LayersList {
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     if (!tileJSON) return null;
 
     const {tiles: data} = tileJSON;

package/src/layers/point-label-layer.ts

@@ -56,7 +56,7 @@ const defaultProps: DefaultProps<PointLabelLayerProps> = {
 };
 
 /** All properties supported by PointLabelLayer. */
-export type PointLabelLayerProps<DataT = any> = _PointLabelLayerProps<DataT> &
+export type PointLabelLayerProps<DataT = unknown> = _PointLabelLayerProps<DataT> &
   TextLayerProps &
   CompositeLayerProps;
 

package/src/layers/quadbin-layer.ts

@@ -6,11 +6,12 @@ import {
 import {getQuadbinPolygon} from './quadbin-utils';
 
 const defaultProps: DefaultProps<QuadbinLayerProps> = {
-  getQuadbin: {type: 'accessor', value: d => d.quadbin}
+  getQuadbin: {type: 'accessor', value: (d: any) => d.quadbin}
 };
 
 /** All properties supported by QuadbinLayer. */
-export type QuadbinLayerProps<DataT = any> = _QuadbinLayerProps<DataT> & GeoCellLayerProps<DataT>;
+export type QuadbinLayerProps<DataT = unknown> = _QuadbinLayerProps<DataT> &
+  GeoCellLayerProps<DataT>;
 
 /** Properties added by QuadbinLayer. */
 type _QuadbinLayerProps<DataT> = {

package/src/layers/quadbin-tile-layer.ts

@@ -1,10 +1,10 @@
 import {CompositeLayer, CompositeLayerProps, Layer, LayersList, DefaultProps} from '@deck.gl/core';
 import QuadbinLayer, {QuadbinLayerProps} from './quadbin-layer';
 import QuadbinTileset2D from './quadbin-tileset-2d';
-import SpatialIndexTileLayer from './spatial-index-tile-layer';
+import SpatialIndexTileLayer, {SpatialIndexTileLayerProps} from './spatial-index-tile-layer';
 import {hexToBigInt} from 'quadbin';
-import {TilejsonPropType, CartoTilejsonResult} from '../sources/common';
-import {injectAccessToken} from './utils';
+import type {TilejsonResult} from '../sources/types';
+import {injectAccessToken, TilejsonPropType} from './utils';
 
 export const renderSubLayers = props => {
   const {data} = props;
@@ -16,19 +16,18 @@ export const renderSubLayers = props => {
 };
 
 const defaultProps: DefaultProps<QuadbinTileLayerProps> = {
-  aggregationResLevel: 6,
   data: TilejsonPropType
 };
 
 /** All properties supported by QuadbinTileLayer. */
-export type QuadbinTileLayerProps<DataT = any> = _QuadbinTileLayerProps<DataT> &
+export type QuadbinTileLayerProps<DataT = unknown> = _QuadbinTileLayerProps<DataT> &
   CompositeLayerProps;
 
 /** Properties added by QuadbinTileLayer. */
-type _QuadbinTileLayerProps<DataT> = Omit<QuadbinLayerProps<DataT>, 'data'> & {
-  data: null | CartoTilejsonResult | Promise<CartoTilejsonResult>;
-  aggregationResLevel?: number;
-};
+type _QuadbinTileLayerProps<DataT> = Omit<QuadbinLayerProps<DataT>, 'data'> &
+  Omit<SpatialIndexTileLayerProps<DataT>, 'data'> & {
+    data: null | TilejsonResult | Promise<TilejsonResult>;
+  };
 
 export default class QuadbinTileLayer<
   DataT = any,
@@ -39,14 +38,14 @@ export default class QuadbinTileLayer<
 
   getLoadOptions(): any {
     const loadOptions = super.getLoadOptions() || {};
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     injectAccessToken(loadOptions, tileJSON.accessToken);
     loadOptions.cartoSpatialTile = {...loadOptions.cartoSpatialTile, scheme: 'quadbin'};
     return loadOptions;
   }
 
   renderLayers(): Layer | null | LayersList {
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     if (!tileJSON) return null;
 
     const {tiles: data, maxresolution: maxZoom} = tileJSON;

package/src/layers/raster-layer.ts

@@ -1,4 +1,4 @@
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 import {
   Accessor,
   CompositeLayer,
@@ -65,7 +65,7 @@ class RasterColumnLayer extends ColumnLayer {
 }
 
 /** All properties supported by RasterLayer. */
-export type RasterLayerProps<DataT = any> = _RasterLayerProps &
+export type RasterLayerProps<DataT = unknown> = _RasterLayerProps &
   ColumnLayerProps<DataT> &
   CompositeLayerProps;
 

package/src/layers/raster-tile-layer.ts

@@ -1,9 +1,9 @@
 import {CompositeLayer, CompositeLayerProps, DefaultProps, Layer, LayersList} from '@deck.gl/core';
 import RasterLayer, {RasterLayerProps} from './raster-layer';
 import QuadbinTileset2D from './quadbin-tileset-2d';
-import SpatialIndexTileLayer from './spatial-index-tile-layer';
-import {TilejsonPropType, CartoTilejsonResult} from '../sources/common';
-import {injectAccessToken} from './utils';
+import SpatialIndexTileLayer, {SpatialIndexTileLayerProps} from './spatial-index-tile-layer';
+import type {TilejsonResult} from '../sources/types';
+import {injectAccessToken, TilejsonPropType} from './utils';
 
 export const renderSubLayers = props => {
   const tileIndex = props.tile?.index?.q;
@@ -16,12 +16,14 @@ const defaultProps: DefaultProps<RasterTileLayerProps> = {
 };
 
 /** All properties supported by RasterTileLayer. */
-export type RasterTileLayerProps<DataT = any> = _RasterTileLayerProps<DataT> & CompositeLayerProps;
+export type RasterTileLayerProps<DataT = unknown> = _RasterTileLayerProps<DataT> &
+  CompositeLayerProps;
 
 /** Properties added by RasterTileLayer. */
-type _RasterTileLayerProps<DataT> = Omit<RasterLayerProps<DataT>, 'data'> & {
-  data: null | CartoTilejsonResult | Promise<CartoTilejsonResult>;
-};
+type _RasterTileLayerProps<DataT> = Omit<RasterLayerProps<DataT>, 'data'> &
+  Omit<SpatialIndexTileLayerProps<DataT>, 'data'> & {
+    data: null | TilejsonResult | Promise<TilejsonResult>;
+  };
 
 export default class RasterTileLayer<
   DataT = any,
@@ -32,13 +34,13 @@ export default class RasterTileLayer<
 
   getLoadOptions(): any {
     const loadOptions = super.getLoadOptions() || {};
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     injectAccessToken(loadOptions, tileJSON.accessToken);
     return loadOptions;
   }
 
   renderLayers(): Layer | null | LayersList {
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     if (!tileJSON) return null;
 
     const {tiles: data, minzoom: minZoom, maxzoom: maxZoom} = tileJSON;

package/src/layers/schema/carto-properties-tile-loader.ts

@@ -0,0 +1,25 @@
+import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+
+import {Tile, TileReader} from './carto-properties-tile';
+import {parsePbf} from './tile-loader-utils';
+
+const CartoPropertiesTileLoader: LoaderWithParser = {
+  name: 'CARTO Properties Tile',
+  version: '1',
+  id: 'cartoPropertiesTile',
+  module: 'carto',
+  extensions: ['pbf'],
+  mimeTypes: ['application/vnd.carto-properties-tile'],
+  category: 'geometry',
+  worker: false,
+  parse: async (arrayBuffer, options) => parseCartoPropertiesTile(arrayBuffer, options),
+  parseSync: parseCartoPropertiesTile,
+  options: {}
+};
+
+function parseCartoPropertiesTile(arrayBuffer: ArrayBuffer, options?: LoaderOptions): Tile | null {
+  if (!arrayBuffer) return null;
+  return parsePbf(arrayBuffer, TileReader);
+}
+
+export default CartoPropertiesTileLoader;

package/src/layers/schema/carto-properties-tile.ts

@@ -0,0 +1,21 @@
+import {NumericProp, NumericPropKeyValueReader, PropertiesReader} from './carto-tile';
+
+// Tile ========================================
+
+export interface Tile {
+  properties: Record<string, string>[];
+  numericProps: Record<string, NumericProp>;
+}
+
+export class TileReader {
+  static read(pbf, end?: number): Tile {
+    return pbf.readFields(TileReader._readField, {properties: [], numericProps: {}}, end);
+  }
+  static _readField(this: void, tag: number, obj: Tile, pbf) {
+    if (tag === 1) obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 2) {
+      const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.numericProps[entry.key] = entry.value;
+    }
+  }
+}

package/src/layers/schema/carto-vector-tile-loader.ts

@@ -1,6 +1,6 @@
 import earcut from 'earcut';
 import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
-import type {BinaryFeatures, BinaryPolygonFeatures, TypedArray} from '@loaders.gl/schema';
+import type {BinaryFeatureCollection, BinaryPolygonFeature, TypedArray} from '@loaders.gl/schema';
 
 import {TileReader} from './carto-tile';
 import {parsePbf} from './tile-loader-utils';
@@ -37,7 +37,7 @@ const CartoVectorTileLoader: LoaderWithParser = {
 };
 
 function triangulatePolygon(
-  polygons: BinaryPolygonFeatures,
+  polygons: BinaryPolygonFeature,
   target: number[],
   {
     startPosition,
@@ -65,8 +65,8 @@ function triangulatePolygon(
   }
 }
 
-function triangulate(polygons: BinaryPolygonFeatures) {
-  const {polygonIndices, positions, primitivePolygonIndices} = polygons;
+function triangulate(polygons: BinaryPolygonFeature) {
+  const {polygonIndices, primitivePolygonIndices} = polygons;
   const triangles = [];
 
   let rangeStart = 0;
@@ -88,7 +88,7 @@ function triangulate(polygons: BinaryPolygonFeatures) {
 function parseCartoVectorTile(
   arrayBuffer: ArrayBuffer,
   options?: CartoVectorTileLoaderOptions
-): BinaryFeatures | null {
+): BinaryFeatureCollection | null {
   if (!arrayBuffer) return null;
   const tile = parsePbf(arrayBuffer, TileReader);
 

package/src/layers/spatial-index-tile-layer.ts

@@ -1,28 +1,24 @@
 import {registerLoaders} from '@loaders.gl/core';
-import {DefaultProps, UpdateParameters} from '@deck.gl/core';
+import {DefaultProps} from '@deck.gl/core';
 import CartoRasterTileLoader from './schema/carto-raster-tile-loader';
 import CartoSpatialTileLoader from './schema/carto-spatial-tile-loader';
 registerLoaders([CartoRasterTileLoader, CartoSpatialTileLoader]);
 
 import {PickingInfo} from '@deck.gl/core';
-import {TileLayer, _Tile2DHeader as Tile2DHeader} from '@deck.gl/geo-layers';
+import {TileLayer, _Tile2DHeader as Tile2DHeader, TileLayerProps} from '@deck.gl/geo-layers';
 
 function isFeatureIdDefined(value: unknown): boolean {
   return value !== undefined && value !== null && value !== '';
 }
 
-const defaultProps: DefaultProps<SpatialIndexTileLayerProps> = {
-  aggregationResLevel: 4
-};
+const defaultProps: DefaultProps<SpatialIndexTileLayerProps> = {};
 
 /** All properties supported by SpatialIndexTileLayer. */
-export type SpatialIndexTileLayerProps<DataT = any> = _SpatialIndexTileLayerProps &
-  TileLayer<DataT>;
+export type SpatialIndexTileLayerProps<DataT = unknown> = _SpatialIndexTileLayerProps &
+  TileLayerProps<DataT>;
 
 /** Properties added by SpatialIndexTileLayer. */
-type _SpatialIndexTileLayerProps = {
-  aggregationResLevel?: number;
-};
+type _SpatialIndexTileLayerProps = {};
 
 export default class SpatialIndexTileLayer<
   DataT = any,
@@ -31,15 +27,10 @@ export default class SpatialIndexTileLayer<
   static layerName = 'SpatialIndexTileLayer';
   static defaultProps = defaultProps;
 
-  updateState(params: UpdateParameters<this>) {
-    const {props, oldProps} = params;
-    if (props.aggregationResLevel !== oldProps.aggregationResLevel) {
-      // Tileset cache is invalid when resLevel changes
-      this.setState({tileset: null});
-    }
-
-    super.updateState(params);
-  }
+  state!: TileLayer<DataT>['state'] & {
+    hoveredFeatureId: number | null;
+    highlightColor: number[];
+  };
 
   protected _updateAutoHighlight(info: PickingInfo): void {
     const {hoveredFeatureId} = this.state;
@@ -79,7 +70,7 @@ export default class SpatialIndexTileLayer<
       !isFeatureIdPresent ||
       !Array.isArray(data) ||
       // Quick check for whether id is within tile. data.findIndex is expensive
-      !this._featureInTile(tile, hoveredFeatureId)
+      !this._featureInTile(tile, hoveredFeatureId!)
     ) {
       return -1;
     }
@@ -88,15 +79,16 @@ export default class SpatialIndexTileLayer<
   }
 
   _featureInTile(tile: Tile2DHeader, featureId: BigInt | number) {
-    const {getTileZoom, getParentIndex} = this.state.tileset;
-    const tileZoom = getTileZoom(tile.index);
+    const tileset = this.state.tileset!;
+    const tileZoom = tileset.getTileZoom(tile.index);
     // @ts-ignore
     const KEY = tile.index.q ? 'q' : 'i';
-    let featureIndex = {[KEY]: featureId};
-    let featureZoom = getTileZoom(featureIndex);
+    // TODO - Tileset2D methods expect tile index in the shape of {x, y, z}
+    let featureIndex: any = {[KEY]: featureId};
+    let featureZoom = tileset.getTileZoom(featureIndex);
     while (!(featureZoom <= tileZoom)) {
-      featureIndex = getParentIndex(featureIndex);
-      featureZoom = getTileZoom(featureIndex);
+      featureIndex = tileset.getParentIndex(featureIndex);
+      featureZoom = tileset.getTileZoom(featureIndex);
     }
 
     return featureIndex[KEY] === tile.index[KEY];

package/src/layers/utils.ts

@@ -1,3 +1,8 @@
+import {Tile as PropertiesTile} from './schema/carto-properties-tile';
+import {Tile as VectorTile} from './schema/carto-tile';
+import {_deepEqual as deepEqual} from '@deck.gl/core';
+import type {TilejsonResult} from '../sources/types';
+
 /**
  * Adds access token to Authorization header in loadOptions
  */
@@ -9,3 +14,69 @@ export function injectAccessToken(loadOptions: any, accessToken: string): void {
     };
   }
 }
+
+export function mergeBoundaryData(geometry: VectorTile, properties: PropertiesTile): VectorTile {
+  const mapping = {};
+  for (const {geoid, ...rest} of properties.properties) {
+    if (geoid in mapping) {
+      throw new Error(`Duplicate geoid key in mapping: ${geoid}`);
+    }
+    mapping[geoid] = rest;
+  }
+
+  for (const type of ['points', 'lines', 'polygons']) {
+    const geom = geometry[type];
+    if (geom.positions.value.length === 0) {
+      continue;
+    }
+
+    geom.properties = geom.properties.map(({geoid}) => mapping[geoid]);
+
+    // numericProps need to be filled to match length of positions buffer
+    const {positions, globalFeatureIds} = geom;
+    let indices: Uint16Array | Uint32Array | null = null;
+    if (type === 'lines') indices = geom.pathIndices.value;
+    if (type === 'polygons') indices = geom.polygonIndices.value;
+    const length = positions.value.length / positions.size;
+    for (const key in properties.numericProps) {
+      const sourceProp = properties.numericProps[key].value;
+      const TypedArray = sourceProp.constructor as
+        | Float32ArrayConstructor
+        | Float64ArrayConstructor;
+      const destProp = new TypedArray(length);
+      geom.numericProps[key] = {value: destProp, size: 1};
+
+      if (!indices) {
+        for (let i = 0; i < length; i++) {
+          // points
+          const featureId = globalFeatureIds.value[i];
+          destProp[i] = sourceProp[featureId];
+        }
+      } else {
+        // lines|polygons
+        for (let i = 0; i < indices.length - 1; i++) {
+          const startIndex = indices[i];
+          const endIndex = indices[i + 1];
+          const featureId = globalFeatureIds.value[startIndex];
+          destProp.fill(sourceProp[featureId], startIndex, endIndex);
+        }
+      }
+    }
+  }
+
+  return geometry;
+}
+
+export const TilejsonPropType = {
+  type: 'object' as const,
+  value: null as null | TilejsonResult,
+  validate: (value: TilejsonResult, propType) =>
+    (propType.optional && value === null) ||
+    (typeof value === 'object' &&
+      Array.isArray(value.tiles) &&
+      value.tiles.every(url => typeof url === 'string')),
+  equal: (value1, value2) => {
+    return deepEqual(value1, value2, 2);
+  },
+  async: true
+};