@deck.gl/carto 9.0.0-beta.2 → 9.0.0-beta.4

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

@@ -0,0 +1,36 @@
+import { TileReader } from "./carto-raster-tile.js";
+import { parsePbf } from "./tile-loader-utils.js";
+import { getWorkerUrl } from "../../utils.js";
+const VERSION = typeof "9.0.0-beta.3" !== 'undefined' ? "9.0.0-beta.3" : 'latest';
+const id = 'cartoRasterTile';
+const DEFAULT_OPTIONS = {
+    cartoRasterTile: {
+        workerUrl: getWorkerUrl(id, VERSION)
+    }
+};
+const CartoRasterTileLoader = {
+    name: 'CARTO Raster Tile',
+    version: VERSION,
+    id,
+    module: 'carto',
+    extensions: ['pbf'],
+    mimeTypes: ['application/vnd.carto-raster-tile'],
+    category: 'geometry',
+    parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
+    parseSync: parseCartoRasterTile,
+    worker: true,
+    options: DEFAULT_OPTIONS
+};
+function parseCartoRasterTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+        return null;
+    const tile = parsePbf(arrayBuffer, TileReader);
+    const { bands, blockHeight, blockWidth } = tile;
+    const numericProps = {};
+    for (let i = 0; i < bands.length; i++) {
+        const { name, data } = bands[i];
+        numericProps[name] = data;
+    }
+    return { blockWidth, blockHeight, cells: { numericProps, properties: [] } };
+}
+export default CartoRasterTileLoader;

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

@@ -0,0 +1,46 @@
+import { readPackedTypedArray } from "./fast-pbf.js";
+const ARRAY_TYPES = {
+    uint8: Uint8Array,
+    uint16: Uint16Array,
+    uint32: Uint32Array,
+    uint64: BigUint64Array,
+    int8: Int8Array,
+    int16: Int16Array,
+    int32: Int32Array,
+    int64: BigInt64Array,
+    float32: Float32Array,
+    float64: Float64Array
+};
+// Band ========================================
+export class BandReader {
+    static read(pbf, end) {
+        return pbf.readFields(BandReader._readField, { name: '', type: '', data: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.name = pbf.readString();
+        else if (tag === 2)
+            obj.type = pbf.readString();
+        else if (tag === 3) {
+            const TypedArray = ARRAY_TYPES[obj.type];
+            if (!TypedArray) {
+                throw Error(`Invalid data type: ${obj.type}`);
+            }
+            obj.data = {};
+            readPackedTypedArray(TypedArray, pbf, obj.data);
+        }
+    }
+}
+export class TileReader {
+    static read(pbf, end) {
+        return pbf.readFields(TileReader._readField, { blockWidth: 0, blockHeight: 0, bands: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+        if (tag === 1)
+            obj.blockWidth = pbf.readVarint();
+        else if (tag === 2)
+            obj.blockHeight = pbf.readVarint();
+        else if (tag === 3)
+            obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+}

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

@@ -0,0 +1,35 @@
+import { TileReader } from "./carto-spatial-tile.js";
+import { parsePbf } from "./tile-loader-utils.js";
+import { getWorkerUrl } from "../../utils.js";
+import { binaryToSpatialjson } from "./spatialjson-utils.js";
+const VERSION = typeof "9.0.0-beta.3" !== 'undefined' ? "9.0.0-beta.3" : 'latest';
+const id = 'cartoSpatialTile';
+const DEFAULT_OPTIONS = {
+    cartoSpatialTile: {
+        scheme: 'quadbin',
+        workerUrl: getWorkerUrl(id, VERSION)
+    }
+};
+const CartoSpatialTileLoader = {
+    name: 'CARTO Spatial Tile',
+    version: VERSION,
+    id,
+    module: 'carto',
+    extensions: ['pbf'],
+    mimeTypes: ['application/vnd.carto-spatial-tile'],
+    category: 'geometry',
+    parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
+    parseSync: parseCartoSpatialTile,
+    worker: true,
+    options: DEFAULT_OPTIONS
+};
+function parseCartoSpatialTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+        return null;
+    const tile = parsePbf(arrayBuffer, TileReader);
+    const { cells } = tile;
+    const scheme = options?.cartoSpatialTile?.scheme;
+    const data = { cells, scheme };
+    return binaryToSpatialjson(data);
+}
+export default CartoSpatialTileLoader;

package/{typed → dist}/layers/schema/carto-spatial-tile.d.ts

@@ -1,5 +1,5 @@
-import { Indices, IndexScheme } from './spatialjson-utils';
-import { NumericProp } from './carto-tile';
+import { Indices, IndexScheme } from "./spatialjson-utils.js";
+import { NumericProp } from "./carto-tile.js";
 export declare class IndicesReader {
     static read(pbf: any, end?: number): Indices;
     static _readField(this: void, tag: number, obj: any, pbf: any): void;

package/dist/layers/schema/carto-spatial-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carto-spatial-tile.d.ts","sourceRoot":"","sources":["../../../src/layers/schema/carto-spatial-tile.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,OAAO,EAAE,WAAW,EAAC,+BAA4B;AACzD,OAAO,EAAC,WAAW,EAA8C,wBAAqB;AAItF,qBAAa,aAAa;IACxB,MAAM,CAAC,IAAI,CAAC,GAAG,KAAA,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO;IAGvC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAA,EAAE,GAAG,KAAA;CAGpD;AAID,UAAU,KAAK;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAC3C;AAuBD,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;CACd;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,IAAI,CAAC,GAAG,KAAA,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAGpC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAA;CAI1D"}

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.3" !== 'undefined' ? "9.0.0-beta.3" : '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/{typed → dist}/layers/utils.d.ts

@@ -1,6 +1,6 @@
-import { Tile as PropertiesTile } from './schema/carto-properties-tile';
-import { Tile as VectorTile } from './schema/carto-tile';
-import type { TilejsonResult } from '../sources/types';
+import { Tile as PropertiesTile } from "./schema/carto-properties-tile.js";
+import { Tile as VectorTile } from "./schema/carto-tile.js";
+import type { TilejsonResult } from "../sources/types.js";
 /**
  * Adds access token to Authorization header in loadOptions
  */

package/dist/layers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/layers/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,IAAI,cAAc,EAAC,0CAAuC;AACtE,OAAO,EAAC,IAAI,IAAI,UAAU,EAAC,+BAA4B;AAEvD,OAAO,KAAK,EAAC,cAAc,EAAC,4BAAyB;AAErD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAO7E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,cAAc,GAAG,UAAU,CAmD9F;AAED,eAAO,MAAM,gBAAgB;;;sBAGT,cAAc;;;CASjC,CAAC"}

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/{typed → dist}/layers/vector-tile-layer.d.ts

@@ -1,7 +1,7 @@
 import { DefaultProps } from '@deck.gl/core';
 import { MVTLayer, MVTLayerProps, TileLayer, _Tile2DHeader, _TileLoadProps as TileLoadProps } from '@deck.gl/geo-layers';
 import { GeoJsonLayer } from '@deck.gl/layers';
-import type { TilejsonResult } from '../sources/types';
+import type { TilejsonResult } from "../sources/types.js";
 /** All properties supported by VectorTileLayer. */
 export type VectorTileLayerProps = _VectorTileLayerProps & Omit<MVTLayerProps, 'data'>;
 /** Properties added by VectorTileLayer. */
@@ -14,6 +14,7 @@ export default class VectorTileLayer<ExtraProps extends {} = {}> extends MVTLaye
     state: MVTLayer['state'] & {
         mvt: boolean;
     };
+    constructor(...propObjects: VectorTileLayerProps[]);
     initializeState(): void;
     updateState(parameters: any): void;
     getLoadOptions(): any;

package/dist/layers/vector-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/vector-tile-layer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAE3C,OAAO,EACL,QAAQ,EACR,aAAa,EACb,SAAS,EAET,aAAa,EACb,cAAc,IAAI,aAAa,EAChC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAK7C,OAAO,KAAK,EAAC,cAAc,EAAC,4BAAyB;AASrD,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;AAEvF,2CAA2C;AAC3C,KAAK,qBAAqB,GAAG;IAC3B,IAAI,EAAE,IAAI,GAAG,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACvD,CAAC;AAGF,MAAM,CAAC,OAAO,OAAO,eAAe,CAAC,UAAU,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,QAAQ,CAC/E,QAAQ,CAAC,qBAAqB,CAAC,GAAG,UAAU,CAC7C;IACC,MAAM,CAAC,SAAS,SAAqB;IACrC,MAAM,CAAC,YAAY,qCAAgB;IAEnC,KAAK,EAAG,QAAQ,CAAC,OAAO,CAAC,GAAG;QAC1B,GAAG,EAAE,OAAO,CAAC;KACd,CAAC;gBAEU,GAAG,WAAW,EAAE,oBAAoB,EAAE;IAMlD,eAAe,IAAI,IAAI;IAKvB,WAAW,CAAC,UAAU,KAAA;IAWtB,cAAc,IAAI,GAAG;IAQf,WAAW,CAAC,IAAI,EAAE,aAAa;IAoCrC,eAAe,CACb,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG;QAC1B,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,GAAG,CAAC;QACV,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,aAAa,CAAC;KACrB,GACA,YAAY,GAAG,IAAI;IAuBtB,cAAc,CAAC,MAAM,KAAA;CAYtB"}