@deck.gl/carto 9.0.0-beta.1 → 9.0.0-beta.3

package/dist/layers/schema/carto-spatial-tile.js

@@ -0,0 +1,38 @@
+import { readPackedTypedArray } from "./fast-pbf.js";
+import { NumericPropKeyValueReader, PropertiesReader } from "./carto-tile.js";
+// Indices =====================================
+export class IndicesReader {
+    static read(pbf, end) {
+        return pbf.readFields(IndicesReader._readField, { value: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            readPackedTypedArray(BigUint64Array, pbf, obj);
+    }
+}
+class CellsReader {
+    static read(pbf, end) {
+        return pbf.readFields(CellsReader._readField, { indices: null, properties: [], numericProps: {} }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.indices = IndicesReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 2)
+            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+        else if (tag === 3) {
+            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+            obj.numericProps[entry.key] = entry.value;
+        }
+    }
+}
+export class TileReader {
+    static read(pbf, end) {
+        return pbf.readFields(TileReader._readField, { scheme: 0, cells: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.scheme = pbf.readVarint();
+        else if (tag === 2)
+            obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+}

package/dist/layers/schema/carto-tile.js

@@ -0,0 +1,187 @@
+import { readPackedTypedArray } from "./fast-pbf.js";
+class KeyValueObjectReader {
+    static read(pbf, end) {
+        return pbf.readFields(KeyValueObjectReader._readField, { key: '', value: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.key = pbf.readString();
+        else if (tag === 2)
+            obj.value = pbf.readString();
+    }
+}
+// Properties ========================================
+export class PropertiesReader {
+    static read(pbf, end) {
+        return pbf.readFields(PropertiesReader._readField, {}, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1) {
+            const { key, value } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
+            obj[key] = value;
+        }
+    }
+}
+class DoublesReader {
+    static read(pbf, end) {
+        const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
+        return { value: new Float32Array(value), size };
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            readPackedTypedArray(Float64Array, pbf, obj);
+        else if (tag === 2)
+            obj.size = pbf.readVarint(true);
+    }
+}
+class IntsReader {
+    static read(pbf, end) {
+        const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
+        return { value: new Uint32Array(value), size };
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            pbf.readPackedVarint(obj.value);
+        else if (tag === 2)
+            obj.size = pbf.readVarint(true);
+    }
+}
+class FieldsReader {
+    static read(pbf, end) {
+        return pbf.readFields(FieldsReader._readField, { id: 0 }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.id = pbf.readVarint();
+    }
+}
+class NumericPropReader {
+    static read(pbf, end) {
+        return pbf.readFields(NumericPropReader._readField, { value: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            readPackedTypedArray(Float64Array, pbf, obj);
+    }
+}
+export class NumericPropKeyValueReader {
+    static read(pbf, end) {
+        return pbf.readFields(NumericPropKeyValueReader._readField, { key: '', value: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.key = pbf.readString();
+        else if (tag === 2)
+            obj.value = NumericPropReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+}
+class PointsReader {
+    static read(pbf, end) {
+        return pbf.readFields(PointsReader._readField, {
+            positions: null,
+            globalFeatureIds: null,
+            featureIds: null,
+            properties: [],
+            numericProps: {},
+            fields: []
+        }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 2)
+            obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 3)
+            obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 4)
+            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+        else if (tag === 5) {
+            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+            obj.numericProps[entry.key] = entry.value;
+        }
+        else if (tag === 6)
+            obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+}
+// Lines ========================================
+class LinesReader {
+    static read(pbf, end) {
+        return pbf.readFields(LinesReader._readField, {
+            positions: null,
+            pathIndices: null,
+            globalFeatureIds: null,
+            featureIds: null,
+            properties: [],
+            numericProps: {},
+            fields: []
+        }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 2)
+            obj.pathIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 3)
+            obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 4)
+            obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 5)
+            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+        else if (tag === 6) {
+            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+            obj.numericProps[entry.key] = entry.value;
+        }
+        else if (tag === 7)
+            obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+}
+class PolygonsReader {
+    static read(pbf, end) {
+        return pbf.readFields(PolygonsReader._readField, {
+            positions: null,
+            polygonIndices: null,
+            globalFeatureIds: null,
+            featureIds: null,
+            primitivePolygonIndices: null,
+            triangles: null,
+            properties: [],
+            numericProps: {},
+            fields: []
+        }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 2)
+            obj.polygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 3)
+            obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 4)
+            obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 5)
+            obj.primitivePolygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 6)
+            obj.triangles = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 7)
+            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+        else if (tag === 8) {
+            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+            obj.numericProps[entry.key] = entry.value;
+        }
+        else if (tag === 9)
+            obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+}
+export class TileReader {
+    static read(pbf, end) {
+        return pbf.readFields(TileReader._readField, { points: null, lines: null, polygons: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.points = PointsReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 2)
+            obj.lines = LinesReader.read(pbf, pbf.readVarint() + pbf.pos);
+        else if (tag === 3)
+            obj.polygons = PolygonsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+}

package/dist/layers/schema/carto-vector-tile-loader.js

@@ -0,0 +1,65 @@
+import earcut from 'earcut';
+import { TileReader } from "./carto-tile.js";
+import { parsePbf } from "./tile-loader-utils.js";
+import { getWorkerUrl } from "../../utils.js";
+const VERSION = typeof "9.0.0-beta.2" !== 'undefined' ? "9.0.0-beta.2" : 'latest';
+const id = 'cartoVectorTile';
+const DEFAULT_OPTIONS = {
+    cartoVectorTile: {
+        workerUrl: getWorkerUrl(id, VERSION)
+    }
+};
+const CartoVectorTileLoader = {
+    name: 'CARTO Vector Tile',
+    version: VERSION,
+    id,
+    module: 'carto',
+    extensions: ['pbf'],
+    mimeTypes: ['application/vnd.carto-vector-tile'],
+    category: 'geometry',
+    parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
+    parseSync: parseCartoVectorTile,
+    worker: true,
+    options: DEFAULT_OPTIONS
+};
+function triangulatePolygon(polygons, target, { startPosition, endPosition, indices }) {
+    const coordLength = polygons.positions.size;
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    // Extract positions and holes for just this polygon
+    const polygonPositions = polygons.positions.value.subarray(start, end);
+    // Holes are referenced relative to outer polygon
+    const holes = indices.slice(1).map((n) => n - startPosition);
+    // Compute triangulation
+    const triangles = earcut(polygonPositions, holes, coordLength);
+    // Indices returned by triangulation are relative to start
+    // of polygon, so we need to offset
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+        target.push(startPosition + triangles[t]);
+    }
+}
+function triangulate(polygons) {
+    const { polygonIndices, primitivePolygonIndices } = polygons;
+    const triangles = [];
+    let rangeStart = 0;
+    for (let i = 0; i < polygonIndices.value.length - 1; i++) {
+        const startPosition = polygonIndices.value[i];
+        const endPosition = polygonIndices.value[i + 1];
+        // Extract hole indices between start & end position
+        const rangeEnd = primitivePolygonIndices.value.indexOf(endPosition);
+        const indices = primitivePolygonIndices.value.subarray(rangeStart, rangeEnd);
+        rangeStart = rangeEnd;
+        triangulatePolygon(polygons, triangles, { startPosition, endPosition, indices });
+    }
+    polygons.triangles = { value: new Uint32Array(triangles), size: 1 };
+}
+function parseCartoVectorTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+        return null;
+    const tile = parsePbf(arrayBuffer, TileReader);
+    if (tile.polygons && !tile.polygons.triangles) {
+        triangulate(tile.polygons);
+    }
+    return tile;
+}
+export default CartoVectorTileLoader;

package/dist/layers/schema/fast-pbf.js

@@ -0,0 +1,7 @@
+// Optimized (100X speed improvement) reading function for binary data
+export function readPackedTypedArray(TypedArray, pbf, obj) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new TypedArray(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
+}

package/dist/layers/schema/spatialjson-utils.js

@@ -0,0 +1,15 @@
+import { bigIntToHex } from 'quadbin';
+export function binaryToSpatialjson(binary) {
+    const { cells, scheme } = binary;
+    const count = cells.indices.value.length;
+    const spatial = [];
+    for (let i = 0; i < count; i++) {
+        const id = scheme === 'h3' ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
+        const properties = { ...cells.properties[i] };
+        for (const key of Object.keys(cells.numericProps)) {
+            properties[key] = cells.numericProps[key].value[i];
+        }
+        spatial.push({ id, properties });
+    }
+    return spatial;
+}

package/dist/layers/schema/tile-loader-utils.js

@@ -0,0 +1,6 @@
+import Protobuf from 'pbf';
+export function parsePbf(buffer, TileReader) {
+    const pbf = new Protobuf(buffer);
+    const tile = TileReader.read(pbf);
+    return tile;
+}

package/{typed → dist}/layers/spatial-index-tile-layer.d.ts

@@ -9,7 +9,7 @@ export default class SpatialIndexTileLayer<DataT = any, ExtraProps extends {} =
     static layerName: string;
     static defaultProps: DefaultProps<SpatialIndexTileLayerProps<unknown>>;
     state: TileLayer<DataT>['state'] & {
-        hoveredFeatureId: number | null;
+        hoveredFeatureId: BigInt | number | null;
         highlightColor: number[];
     };
     protected _updateAutoHighlight(info: PickingInfo): void;

package/{typed → dist}/layers/spatial-index-tile-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial-index-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/spatial-index-tile-layer.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAK3C,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,SAAS,EAAE,aAAa,IAAI,YAAY,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAQ7F,yDAAyD;AACzD,MAAM,MAAM,0BAA0B,CAAC,KAAK,GAAG,OAAO,IAAI,2BAA2B,GACnF,cAAc,CAAC,KAAK,CAAC,CAAC;AAExB,iDAAiD;AACjD,KAAK,2BAA2B,GAAG,EAAE,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,qBAAqB,CACxC,KAAK,GAAG,GAAG,EACX,UAAU,SAAS,EAAE,GAAG,EAAE,CAC1B,SAAQ,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,2BAA2B,CAAC,CAAC;IAC5E,MAAM,CAAC,SAAS,SAA2B;IAC3C,MAAM,CAAC,YAAY,oDAAgB;IAEnC,KAAK,EAAG,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG;QAClC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,cAAc,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;IAEF,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAsBvD,sBAAsB,CAAC,IAAI,EAAE,YAAY;;;;IAOzC,yBAAyB,CAAC,IAAI,EAAE,YAAY;IAiB5C,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;CAe9D"}
+{"version":3,"file":"spatial-index-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/spatial-index-tile-layer.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAK3C,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,SAAS,EAAE,aAAa,IAAI,YAAY,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAQ7F,yDAAyD;AACzD,MAAM,MAAM,0BAA0B,CAAC,KAAK,GAAG,OAAO,IAAI,2BAA2B,GACnF,cAAc,CAAC,KAAK,CAAC,CAAC;AAExB,iDAAiD;AACjD,KAAK,2BAA2B,GAAG,EAAE,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,qBAAqB,CACxC,KAAK,GAAG,GAAG,EACX,UAAU,SAAS,EAAE,GAAG,EAAE,CAC1B,SAAQ,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,2BAA2B,CAAC,CAAC;IAC5E,MAAM,CAAC,SAAS,SAA2B;IAC3C,MAAM,CAAC,YAAY,oDAAgB;IAEnC,KAAK,EAAG,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG;QAClC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;QACzC,cAAc,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;IAEF,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAsBvD,sBAAsB,CAAC,IAAI,EAAE,YAAY;;;;IAOzC,yBAAyB,CAAC,IAAI,EAAE,YAAY;IAiB5C,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;CAgB9D"}

package/dist/layers/spatial-index-tile-layer.js

@@ -0,0 +1,64 @@
+import { registerLoaders } from '@loaders.gl/core';
+import CartoRasterTileLoader from "./schema/carto-raster-tile-loader.js";
+import CartoSpatialTileLoader from "./schema/carto-spatial-tile-loader.js";
+registerLoaders([CartoRasterTileLoader, CartoSpatialTileLoader]);
+import { TileLayer } from '@deck.gl/geo-layers';
+function isFeatureIdDefined(value) {
+    return value !== undefined && value !== null && value !== '';
+}
+const defaultProps = {};
+export default class SpatialIndexTileLayer extends TileLayer {
+    static { this.layerName = 'SpatialIndexTileLayer'; }
+    static { this.defaultProps = defaultProps; }
+    _updateAutoHighlight(info) {
+        const { hoveredFeatureId } = this.state;
+        const hoveredFeature = info.object;
+        let newHoveredFeatureId = null;
+        if (hoveredFeature) {
+            newHoveredFeatureId = hoveredFeature.id;
+        }
+        if (hoveredFeatureId !== newHoveredFeatureId) {
+            let { highlightColor } = this.props;
+            if (typeof highlightColor === 'function') {
+                highlightColor = highlightColor(info);
+            }
+            this.setState({
+                highlightColor,
+                hoveredFeatureId: newHoveredFeatureId
+            });
+        }
+    }
+    getSubLayerPropsByTile(tile) {
+        return {
+            highlightedObjectIndex: this.getHighlightedObjectIndex(tile),
+            highlightColor: this.state.highlightColor
+        };
+    }
+    getHighlightedObjectIndex(tile) {
+        const { hoveredFeatureId } = this.state;
+        const data = tile.content;
+        const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
+        if (!isFeatureIdPresent ||
+            !Array.isArray(data) ||
+            // Quick check for whether id is within tile. data.findIndex is expensive
+            !this._featureInTile(tile, hoveredFeatureId)) {
+            return -1;
+        }
+        return data.findIndex(feature => feature.id === hoveredFeatureId);
+    }
+    _featureInTile(tile, featureId) {
+        // TODO: Tile2DHeader index should be generic for H3TileIndex or QuadbinTileIndex
+        const tileset = this.state.tileset;
+        const tileZoom = tileset.getTileZoom(tile.index);
+        // @ts-ignore
+        const KEY = tile.index.q ? 'q' : 'i';
+        // TODO - Tileset2D methods expect tile index in the shape of {x, y, z}
+        let featureIndex = { [KEY]: featureId };
+        let featureZoom = tileset.getTileZoom(featureIndex);
+        while (!(featureZoom <= tileZoom)) {
+            featureIndex = tileset.getParentIndex(featureIndex);
+            featureZoom = tileset.getTileZoom(featureIndex);
+        }
+        return featureIndex[KEY] === tile.index[KEY];
+    }
+}

package/dist/layers/utils.js

@@ -0,0 +1,74 @@
+import { log } from '@deck.gl/core';
+import { _deepEqual as deepEqual } from '@deck.gl/core';
+/**
+ * Adds access token to Authorization header in loadOptions
+ */
+export function injectAccessToken(loadOptions, accessToken) {
+    if (!loadOptions?.fetch?.headers?.Authorization) {
+        loadOptions.fetch = {
+            ...loadOptions.fetch,
+            headers: { ...loadOptions.fetch?.headers, Authorization: `Bearer ${accessToken}` }
+        };
+    }
+}
+export function mergeBoundaryData(geometry, properties) {
+    const mapping = {};
+    for (const { geoid, ...rest } of properties.properties) {
+        if (geoid in mapping) {
+            log.warn('Duplicate geoid key in boundary mapping, using first occurance')();
+        }
+        else {
+            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 = 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;
+            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',
+    value: null,
+    validate: (value, 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
+};

package/dist/layers/vector-tile-layer.js

@@ -0,0 +1,98 @@
+import { registerLoaders } from '@loaders.gl/core';
+import CartoPropertiesTileLoader from "./schema/carto-properties-tile-loader.js";
+import CartoVectorTileLoader from "./schema/carto-vector-tile-loader.js";
+registerLoaders([CartoPropertiesTileLoader, CartoVectorTileLoader]);
+import { ClipExtension } from '@deck.gl/extensions';
+import { MVTLayer, _getURLFromTemplate } from '@deck.gl/geo-layers';
+import { GeoJsonLayer } from '@deck.gl/layers';
+import { binaryToGeojson } from '@loaders.gl/gis';
+import { TilejsonPropType, injectAccessToken, mergeBoundaryData } from "./utils.js";
+const defaultProps = {
+    ...MVTLayer.defaultProps,
+    data: TilejsonPropType,
+    dataComparator: TilejsonPropType.equal
+};
+// TODO Perhaps we can't subclass MVTLayer and keep types. Better to subclass TileLayer instead?
+// @ts-ignore
+export default class VectorTileLayer extends MVTLayer {
+    static { this.layerName = 'VectorTileLayer'; }
+    static { this.defaultProps = defaultProps; }
+    initializeState() {
+        super.initializeState();
+        this.setState({ binary: true });
+    }
+    updateState(parameters) {
+        const { props } = parameters;
+        if (props.data) {
+            super.updateState(parameters);
+            const formatTiles = new URL(props.data.tiles[0]).searchParams.get('formatTiles');
+            const mvt = formatTiles === 'mvt';
+            this.setState({ mvt });
+        }
+    }
+    getLoadOptions() {
+        const loadOptions = super.getLoadOptions() || {};
+        const tileJSON = this.props.data;
+        injectAccessToken(loadOptions, tileJSON.accessToken);
+        loadOptions.gis = { format: 'binary' }; // Use binary for MVT loading
+        return loadOptions;
+    }
+    async getTileData(tile) {
+        const tileJSON = this.props.data;
+        const { tiles, properties_tiles } = tileJSON;
+        const url = _getURLFromTemplate(tiles, tile);
+        if (!url) {
+            return Promise.reject('Invalid URL');
+        }
+        const loadOptions = this.getLoadOptions();
+        const { fetch } = this.props;
+        const { signal } = tile;
+        // Fetch geometry and attributes separately
+        const geometryFetch = fetch(url, { propName: 'data', layer: this, loadOptions, signal });
+        if (!properties_tiles) {
+            return await geometryFetch;
+        }
+        const propertiesUrl = _getURLFromTemplate(properties_tiles, tile);
+        if (!propertiesUrl) {
+            return Promise.reject('Invalid properties URL');
+        }
+        const attributesFetch = fetch(propertiesUrl, {
+            propName: 'data',
+            layer: this,
+            loadOptions,
+            signal
+        });
+        const [geometry, attributes] = await Promise.all([geometryFetch, attributesFetch]);
+        if (!geometry)
+            return null;
+        return attributes ? mergeBoundaryData(geometry, attributes) : geometry;
+    }
+    renderSubLayers(props) {
+        if (props.data === null) {
+            return null;
+        }
+        if (this.state.mvt) {
+            return super.renderSubLayers(props);
+        }
+        const tileBbox = props.tile.bbox;
+        const { west, south, east, north } = tileBbox;
+        const subLayerProps = {
+            ...props,
+            autoHighlight: false,
+            extensions: [new ClipExtension(), ...(props.extensions || [])],
+            clipBounds: [west, south, east, north]
+        };
+        const subLayer = new GeoJsonLayer(subLayerProps);
+        return subLayer;
+    }
+    getPickingInfo(params) {
+        const info = super.getPickingInfo(params);
+        if (this.state.binary && info.index !== -1) {
+            const { data } = params.sourceLayer.props;
+            info.object = binaryToGeojson(data, {
+                globalFeatureId: info.index
+            });
+        }
+        return info;
+    }
+}

package/dist/sources/base-source.js

@@ -0,0 +1,52 @@
+/* eslint-disable camelcase */
+import { DEFAULT_API_BASE_URL, DEFAULT_CLIENT } from "../api/common.js";
+import { buildSourceUrl } from "../api/endpoints.js";
+import { requestWithParameters } from "../api/request-with-parameters.js";
+export const SOURCE_DEFAULTS = {
+    apiBaseUrl: DEFAULT_API_BASE_URL,
+    clientId: DEFAULT_CLIENT,
+    format: 'tilejson',
+    headers: {}
+};
+export async function baseSource(endpoint, options, urlParameters) {
+    const { accessToken, connectionName, cache, ...optionalOptions } = options;
+    const mergedOptions = { ...SOURCE_DEFAULTS, accessToken, connectionName, endpoint };
+    for (const key in optionalOptions) {
+        if (optionalOptions[key]) {
+            mergedOptions[key] = optionalOptions[key];
+        }
+    }
+    const baseUrl = buildSourceUrl(mergedOptions);
+    const { format } = mergedOptions;
+    const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
+    const errorContext = {
+        requestType: 'Map instantiation',
+        connection: options.connectionName,
+        type: endpoint,
+        source: JSON.stringify(urlParameters, undefined, 2)
+    };
+    const mapInstantiation = await requestWithParameters({
+        baseUrl,
+        parameters: urlParameters,
+        headers,
+        errorContext
+    });
+    const dataUrl = mapInstantiation[format].url[0];
+    if (cache) {
+        cache.value = parseInt(new URL(dataUrl).searchParams.get('cache') || '', 10);
+    }
+    errorContext.requestType = 'Map data';
+    if (format === 'tilejson') {
+        return await requestWithParameters({
+            accessToken,
+            baseUrl: dataUrl,
+            headers,
+            errorContext
+        });
+    }
+    return await requestWithParameters({
+        baseUrl: dataUrl,
+        headers,
+        errorContext
+    });
+}

package/{typed → dist}/sources/boundary-query-source.d.ts

@@ -1,4 +1,4 @@
-import { QueryParameters } from '../api';
+import { QueryParameters } from '../api/index';
 import type { SourceOptions, TilejsonResult } from './types';
 export type BoundaryQuerySourceOptions = SourceOptions & {
     tilesetTableName: string;

package/{typed → dist}/sources/boundary-query-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary-query-source.d.ts","sourceRoot":"","sources":["../../src/sources/boundary-query-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,SAAS,CAAC;AAE3D,MAAM,MAAM,0BAA0B,GAAG,aAAa,GAAG;IACvD,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AAQF,eAAO,MAAM,mBAAmB,YACrB,0BAA0B,KAClC,QAAQ,cAAc,CAWxB,CAAC"}
+{"version":3,"file":"boundary-query-source.d.ts","sourceRoot":"","sources":["../../src/sources/boundary-query-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,SAAS,CAAC;AAE3D,MAAM,MAAM,0BAA0B,GAAG,aAAa,GAAG;IACvD,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AAQF,eAAO,MAAM,mBAAmB,YACrB,0BAA0B,KAClC,QAAQ,cAAc,CAWxB,CAAC"}

package/dist/sources/boundary-query-source.js

@@ -0,0 +1,13 @@
+import { baseSource } from "./base-source.js";
+export const boundaryQuerySource = async function (options) {
+    const { tilesetTableName, matchingColumn = 'id', propertiesSqlQuery, queryParameters } = options;
+    const urlParameters = {
+        tilesetTableName,
+        matchingColumn,
+        propertiesSqlQuery
+    };
+    if (queryParameters) {
+        urlParameters.queryParameters = JSON.stringify(queryParameters);
+    }
+    return baseSource('boundary', options, urlParameters);
+};

package/dist/sources/boundary-table-source.js

@@ -0,0 +1,13 @@
+import { baseSource } from "./base-source.js";
+export const boundaryTableSource = async function (options) {
+    const { tilesetTableName, columns, matchingColumn = 'id', propertiesTableName } = options;
+    const urlParameters = {
+        tilesetTableName,
+        matchingColumn,
+        propertiesTableName
+    };
+    if (columns) {
+        urlParameters.columns = columns.join(',');
+    }
+    return baseSource('boundary', options, urlParameters);
+};