@carto/api-client 0.4.6 → 0.4.7-0

package/src/filters/tileFeaturesGeometries.ts

@@ -0,0 +1,444 @@
+import bboxPolygon from '@turf/bbox-polygon';
+import intersects from '@turf/boolean-intersects';
+import booleanWithin from '@turf/boolean-within';
+import intersect from '@turf/intersect';
+import {transformToTileCoords} from '../utils/transformToTileCoords.js';
+import {transformTileCoordsToWGS84} from '../utils/transformTileCoordsToWGS84.js';
+import {TileFormat} from '../constants.js';
+import {
+  BBox,
+  Feature,
+  Geometry,
+  LineString,
+  MultiPolygon,
+  Point,
+  Polygon,
+  Position,
+} from 'geojson';
+import {SpatialFilter, Tile} from '../types.js';
+import {TileFeatureExtractOptions} from './tileFeatures.js';
+import {featureCollection} from '@turf/helpers';
+import {FeatureData} from '../types-internal.js';
+import {
+  BinaryAttribute,
+  BinaryFeature,
+  BinaryGeometryType,
+  BinaryPointFeature,
+  TypedArrayConstructor,
+} from '@loaders.gl/schema';
+
+export const FEATURE_GEOM_PROPERTY = '__geomValue';
+
+type TileMap = Map<unknown, unknown>;
+
+type TileDataInternal = {
+  uniqueId: string | number | undefined;
+  properties: any;
+  numericProps: Record<string, number>;
+};
+
+export function tileFeaturesGeometries({
+  tiles,
+  tileFormat,
+  spatialFilter,
+  uniqueIdProperty,
+  options,
+}: {
+  tiles: Tile[];
+  tileFormat?: TileFormat;
+  spatialFilter: SpatialFilter;
+  uniqueIdProperty?: string;
+  options?: {storeGeometry?: boolean};
+}): FeatureData[] {
+  const map = new Map();
+
+  for (const tile of tiles) {
+    // Discard if it's not a visible tile (only check false value, not undefined)
+    // or tile has not data
+    if (tile.isVisible === false || !tile.data) {
+      continue;
+    }
+
+    const bbox = [
+      tile.bbox.west,
+      tile.bbox.south,
+      tile.bbox.east,
+      tile.bbox.north,
+    ] as BBox;
+    const bboxToGeom = bboxPolygon(bbox);
+    const tileIsFullyVisible = booleanWithin(bboxToGeom, spatialFilter);
+
+    // Clip the geometry to intersect with the tile
+    const spatialFilterFeature: Feature<Polygon | MultiPolygon> = {
+      type: 'Feature',
+      geometry: spatialFilter,
+      properties: {},
+    };
+    const clippedGeometryToIntersect = intersect(
+      featureCollection([bboxToGeom, spatialFilterFeature])
+    );
+
+    if (!clippedGeometryToIntersect) {
+      continue;
+    }
+
+    // We assume that MVT tileFormat uses local coordinates so we transform the geometry to intersect to tile coordinates [0..1],
+    // while in the case of 'geojson' or binary, the geometries are already in WGS84
+    const transformedGeometryToIntersect =
+      tileFormat === TileFormat.MVT
+        ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox)
+        : clippedGeometryToIntersect.geometry;
+
+    createIndicesForPoints(tile.data.points!);
+
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.points!,
+      type: 'Point',
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options,
+    });
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.lines!,
+      type: 'LineString',
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options,
+    });
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.polygons!,
+      type: 'Polygon',
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options,
+    });
+  }
+  return Array.from(map.values());
+}
+
+function processTileFeatureProperties({
+  map,
+  data,
+  startIndex,
+  endIndex,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  storeGeometry,
+  geometryIntersection,
+}: {
+  map: TileMap;
+  data: BinaryFeature;
+  startIndex: number;
+  endIndex: number;
+  type: BinaryGeometryType;
+  bbox: BBox;
+  tileFormat?: TileFormat;
+  uniqueIdProperty?: string;
+  storeGeometry: boolean;
+  geometryIntersection?: Geometry;
+}) {
+  const tileProps = getPropertiesFromTile(data, startIndex);
+  const uniquePropertyValue = getUniquePropertyValue(
+    tileProps,
+    uniqueIdProperty,
+    map
+  );
+
+  if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
+    return;
+  }
+  let geometry: Geometry | null = null;
+
+  // Only calculate geometry if necessary
+  if (storeGeometry || geometryIntersection) {
+    const {positions} = data;
+    const ringCoordinates = getRingCoordinatesFor(
+      startIndex,
+      endIndex,
+      positions
+    );
+    geometry = getFeatureByType(ringCoordinates, type);
+  }
+
+  // If intersection is required, check before proceeding
+  if (
+    geometry &&
+    geometryIntersection &&
+    !intersects(geometry, geometryIntersection)
+  ) {
+    return;
+  }
+
+  const properties = parseProperties(tileProps);
+
+  // Only save geometry if necessary
+  if (storeGeometry && geometry) {
+    properties[FEATURE_GEOM_PROPERTY] =
+      tileFormat === TileFormat.MVT
+        ? transformTileCoordsToWGS84(geometry, bbox)
+        : geometry;
+  }
+  map.set(uniquePropertyValue, properties);
+}
+
+function addIntersectedFeaturesInTile({
+  map,
+  data,
+  geometryIntersection,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  options,
+}: {
+  map: TileMap;
+  data: BinaryFeature;
+  geometryIntersection: Geometry;
+  type: BinaryGeometryType;
+  bbox: BBox;
+  tileFormat?: TileFormat;
+  uniqueIdProperty?: string;
+  options?: TileFeatureExtractOptions;
+}) {
+  const indices = getIndices(data);
+  const storeGeometry = options?.storeGeometry || false;
+
+  for (let i = 0; i < indices.length - 1; i++) {
+    const startIndex = indices[i];
+    const endIndex = indices[i + 1];
+    processTileFeatureProperties({
+      map,
+      data,
+      startIndex,
+      endIndex,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      storeGeometry,
+      geometryIntersection,
+    });
+  }
+}
+
+function getIndices(data: BinaryFeature) {
+  let indices: BinaryAttribute;
+  switch (data.type) {
+    case 'Point':
+      // @ts-expect-error Missing or changed types?
+      indices = data.pointIndices;
+      break;
+    case 'LineString':
+      indices = data.pathIndices;
+      break;
+    case 'Polygon':
+      indices = data.primitivePolygonIndices;
+      break;
+    default:
+      throw new Error(`Unexpected type, "${(data as BinaryFeature).type}"`);
+  }
+  return indices.value;
+}
+
+function getFeatureId(data: BinaryFeature, startIndex: number) {
+  return data.featureIds.value[startIndex];
+}
+
+function getPropertiesFromTile(data: BinaryFeature, startIndex: number) {
+  const featureId = getFeatureId(data, startIndex);
+  const {properties, numericProps, fields} = data;
+  const result: TileDataInternal = {
+    uniqueId: (fields?.[featureId] as {id: string | number})?.id,
+    properties: properties[featureId],
+    numericProps: {},
+  };
+
+  for (const key in numericProps) {
+    result.numericProps[key] = numericProps[key].value[startIndex];
+  }
+
+  return result;
+}
+
+function parseProperties(tileProps: TileDataInternal) {
+  const {properties, numericProps} = tileProps;
+  return Object.assign({}, properties, numericProps);
+}
+
+function getUniquePropertyValue(
+  tileProps: TileDataInternal,
+  uniqueIdProperty: string | undefined,
+  map: TileMap
+) {
+  if (uniqueIdProperty) {
+    return getValueFromTileProps(tileProps, uniqueIdProperty);
+  }
+
+  if (tileProps.uniqueId) {
+    return tileProps.uniqueId;
+  }
+
+  const artificialId = map.size + 1; // a counter, assumed as a valid new id
+  return (
+    getValueFromTileProps(tileProps, 'cartodb_id') ||
+    getValueFromTileProps(tileProps, 'geoid') ||
+    artificialId
+  );
+}
+
+function getValueFromTileProps(
+  tileProps: TileDataInternal,
+  propertyName: string
+) {
+  const {properties, numericProps} = tileProps;
+  return numericProps[propertyName] || properties[propertyName];
+}
+
+function getFeatureByType(
+  coordinates: Position[],
+  type: BinaryGeometryType
+): Polygon | LineString | Point {
+  switch (type) {
+    case 'Polygon':
+      return {type: 'Polygon', coordinates: [coordinates]};
+    case 'LineString':
+      return {type: 'LineString', coordinates};
+    case 'Point':
+      return {type: 'Point', coordinates: coordinates[0]};
+    default:
+      throw new Error('Invalid geometry type');
+  }
+}
+
+function getRingCoordinatesFor(
+  startIndex: number,
+  endIndex: number,
+  positions: BinaryAttribute
+) {
+  const ringCoordinates = [];
+
+  for (let j = startIndex; j < endIndex; j++) {
+    ringCoordinates.push(
+      Array.from(
+        positions.value.subarray(j * positions.size, (j + 1) * positions.size)
+      )
+    );
+  }
+
+  return ringCoordinates;
+}
+
+function calculateFeatures({
+  map,
+  tileIsFullyVisible,
+  geometryIntersection,
+  data,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  options,
+}: {
+  map: TileMap;
+  tileIsFullyVisible: boolean;
+  geometryIntersection: SpatialFilter;
+  data: BinaryFeature;
+  type: BinaryGeometryType;
+  bbox: BBox;
+  tileFormat?: TileFormat;
+  uniqueIdProperty?: string;
+  options?: TileFeatureExtractOptions;
+}) {
+  if (!data?.properties.length) {
+    return;
+  }
+
+  if (tileIsFullyVisible) {
+    addAllFeaturesInTile({
+      map,
+      data,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options,
+    });
+  } else {
+    addIntersectedFeaturesInTile({
+      map,
+      data,
+      geometryIntersection,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options,
+    });
+  }
+}
+
+function addAllFeaturesInTile({
+  map,
+  data,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  options,
+}: {
+  map: TileMap;
+  data: BinaryFeature;
+  type: BinaryGeometryType;
+  bbox: BBox;
+  tileFormat?: TileFormat;
+  uniqueIdProperty?: string;
+  options?: TileFeatureExtractOptions;
+}) {
+  const indices = getIndices(data);
+  const storeGeometry = options?.storeGeometry || false;
+  for (let i = 0; i < indices.length - 1; i++) {
+    const startIndex = indices[i];
+    const endIndex = indices[i + 1];
+    processTileFeatureProperties({
+      map,
+      data,
+      startIndex,
+      endIndex,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      storeGeometry,
+    });
+  }
+}
+
+function createIndicesForPoints(data: BinaryPointFeature) {
+  const featureIds = data.featureIds.value;
+  const lastFeatureId = featureIds[featureIds.length - 1];
+  const PointIndicesArray = featureIds.constructor as TypedArrayConstructor;
+
+  const pointIndices: BinaryAttribute = {
+    value: new PointIndicesArray(featureIds.length + 1),
+    size: 1,
+  };
+  pointIndices.value.set(featureIds);
+  pointIndices.value.set([lastFeatureId + 1], featureIds.length);
+
+  // @ts-expect-error Missing or changed types?
+  data.pointIndices = pointIndices;
+}

package/src/filters/tileFeaturesSpatialIndex.ts

@@ -0,0 +1,119 @@
+import {SpatialIndex} from '../constants.js';
+import {getResolution as quadbinGetResolution, geometryToCells} from 'quadbin';
+import bboxClip from '@turf/bbox-clip';
+import {SpatialFilter, SpatialIndexTile} from '../types.js';
+import {BBox, Feature} from 'geojson';
+import {getResolution as h3GetResolution, polygonToCells} from 'h3-js';
+import {FeatureData} from '../types-internal.js';
+import {SpatialDataType} from '../sources/types.js';
+
+export type TileFeaturesSpatialIndexOptions = {
+  tiles: SpatialIndexTile[];
+  spatialFilter: SpatialFilter;
+  spatialDataColumn: string;
+  spatialDataType: SpatialDataType;
+};
+
+export function tileFeaturesSpatialIndex({
+  tiles,
+  spatialFilter,
+  spatialDataColumn,
+  spatialDataType,
+}: TileFeaturesSpatialIndexOptions): FeatureData[] {
+  const map = new Map();
+  const spatialIndex = getSpatialIndex(spatialDataType);
+  const resolution = getResolution(tiles, spatialIndex);
+  const spatialIndexIDName = spatialDataColumn
+    ? spatialDataColumn
+    : spatialIndex;
+
+  if (!resolution) {
+    return [];
+  }
+  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
+
+  if (!cells?.length) {
+    return [];
+  }
+
+  // We transform cells to Set to improve the performace
+  const cellsSet = new Set<bigint | string>(cells);
+
+  for (const tile of tiles) {
+    if (tile.isVisible === false || !tile.data) {
+      continue;
+    }
+
+    tile.data.forEach((d: Feature) => {
+      if (cellsSet.has(d.id as bigint | string)) {
+        map.set(d.id, {...d.properties, [spatialIndexIDName]: d.id});
+      }
+    });
+  }
+  return Array.from(map.values());
+}
+
+function getResolution(
+  tiles: SpatialIndexTile[],
+  spatialIndex: SpatialIndex
+): number | undefined {
+  const data = tiles.find((tile) => tile.data?.length)?.data;
+
+  if (!data) {
+    return;
+  }
+
+  if (spatialIndex === SpatialIndex.QUADBIN) {
+    return Number(quadbinGetResolution(data[0].id));
+  }
+
+  if (spatialIndex === SpatialIndex.H3) {
+    return h3GetResolution(data[0].id);
+  }
+}
+
+const bboxWest: BBox = [-180, -90, 0, 90];
+const bboxEast: BBox = [0, -90, 180, 90];
+
+function getCellsCoverGeometry(
+  geometry: SpatialFilter,
+  spatialIndex: SpatialIndex,
+  resolution: number
+) {
+  if (spatialIndex === SpatialIndex.QUADBIN) {
+    // @ts-expect-error TODO: Probably ought to be stricter about number vs. bigint types in this file.
+    return geometryToCells(geometry, resolution);
+  }
+
+  if (spatialIndex === SpatialIndex.H3) {
+    // The current H3 polyfill algorithm can't deal with polygon segments of greater than 180 degrees longitude
+    // so we clip the geometry to be sure that none of them is greater than 180 degrees
+    // https://github.com/uber/h3-js/issues/24#issuecomment-431893796
+    return polygonToCells(
+      bboxClip(geometry, bboxWest).geometry.coordinates as
+        | number[][]
+        | number[][][],
+      resolution,
+      true
+    ).concat(
+      polygonToCells(
+        bboxClip(geometry, bboxEast).geometry.coordinates as
+          | number[][]
+          | number[][][],
+        resolution,
+        true
+      )
+    );
+  }
+}
+
+function getSpatialIndex(spatialDataType: SpatialDataType): SpatialIndex {
+  switch (spatialDataType) {
+    case 'h3':
+      return SpatialIndex.H3;
+    case 'quadbin':
+      return SpatialIndex.QUADBIN;
+    default:
+      throw new Error('Unexpected spatial data type');
+  }
+}

package/src/filters.ts

@@ -1,6 +1,6 @@
-import {FilterType} from './constants';
-import {Filter} from './types';
-import {isEmptyObject} from './utils';
+import {FilterType} from './constants.js';
+import {Filter} from './types.js';
+import {isEmptyObject} from './utils.js';
 
 type FilterTypeOptions<T extends FilterType> = {
   type: T;
@@ -121,7 +121,7 @@ export function getFilter<T extends FilterType>(
     return null;
   }
 
-  if (!owner || owner === filter[type as FilterType]?.owner) {
+  if (!owner || owner === filter[type]?.owner) {
     return filter[type] || null;
   }
 

package/src/geo.ts

@@ -4,7 +4,7 @@ import union from '@turf/union';
 import {getType} from '@turf/invariant';
 import {polygon, multiPolygon, feature, featureCollection} from '@turf/helpers';
 import type {BBox, Geometry, MultiPolygon, Polygon, Position} from 'geojson';
-import {SpatialFilter} from './types';
+import {SpatialFilter} from './types.js';
 
 /**
  * Returns a {@link SpatialFilter} for a given viewport, typically obtained
@@ -40,7 +40,7 @@ export function createPolygonSpatialFilter(
  * Check if a viewport is large enough to represent a global coverage.
  * In this case the spatial filter parameter for widget calculation is removed.
  *
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function _isGlobalViewport(viewport: BBox) {
   const [minx, miny, maxx, maxy] = viewport;
@@ -54,7 +54,7 @@ function _isGlobalViewport(viewport: BBox) {
  *
  * It results in a Polygon or MultiPolygon strictly inside the validity range.
  *
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function _normalizeGeometry(
   geometry: Polygon | MultiPolygon
@@ -100,19 +100,19 @@ function _normalizeGeometry(
   return result;
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _cleanPolygonCoords(cc: Position[][]) {
   const coords = cc.filter((c) => c.length > 0);
   return coords.length > 0 ? coords : null;
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _cleanMultiPolygonCoords(ccc: Position[][][]) {
   const coords = ccc.map(_cleanPolygonCoords).filter((cc) => cc);
   return coords.length > 0 ? coords : null;
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _clean(
   geometry: Polygon | MultiPolygon | null
 ): Polygon | MultiPolygon | null {
@@ -121,36 +121,34 @@ function _clean(
   }
 
   if (_isPolygon(geometry)) {
-    const coords = _cleanPolygonCoords((geometry as Polygon).coordinates);
+    const coords = _cleanPolygonCoords(geometry.coordinates);
     return coords ? polygon(coords).geometry : null;
   }
 
   if (_isMultiPolygon(geometry)) {
-    const coords = _cleanMultiPolygonCoords(
-      (geometry as MultiPolygon).coordinates
-    );
+    const coords = _cleanMultiPolygonCoords(geometry.coordinates);
     return coords ? multiPolygon(coords as Position[][][]).geometry : null;
   }
 
   return null;
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _txContourCoords(cc: Position[], distance: number) {
   return cc.map((c) => [c[0] + distance, c[1]]);
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _txPolygonCoords(ccc: Position[][], distance: number) {
   return ccc.map((cc) => _txContourCoords(cc, distance));
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _txMultiPolygonCoords(cccc: Position[][][], distance: number) {
   return cccc.map((ccc) => _txPolygonCoords(ccc, distance));
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _tx(geometry: Polygon | MultiPolygon, distance: number) {
   if (geometry && getType(geometry) === 'Polygon') {
     const coords = _txPolygonCoords(

package/src/global.d.ts

@@ -1,10 +1,5 @@
-/**
- * Injected by microbundle, with:
- * ```
- * --define __CARTO_API_CLIENT_VERSION=$npm_package_version
- * ```
- */
-declare const __CARTO_API_CLIENT_VERSION: string;
-
 /** Defined by @deck.gl/core. */
 declare const deck: {VERSION: string | undefined} | undefined;
+
+/** Defined by tsup. */
+declare const TSUP_FORMAT: 'esm' | 'cjs';

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './client.js';
 export * from './constants.js';
+export * from './deck/index.js';
 export * from './filters.js';
 export * from './geo.js';
 export * from './sources/index.js';
@@ -18,3 +19,9 @@ export {
 } from './api/index.js';
 
 export {_getHexagonResolution} from './spatial-index.js';
+
+// For unit testing only.
+export * from './filters/index.js';
+export * from './operations/index.js';
+export * from './utils/makeIntervalComplete.js';
+export * from './utils/transformToTileCoords.js';