@deck.gl-community/experimental 9.0.3

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 - 2021 Uber Technologies, Inc.
+Copyright (c) 2022 - 2023 react-graph-layers contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @deck.gl-community/experimental
+
+This module contains early-stage, experimental, poorly documented, non-official deck.gl layers.
+
+They can sometimes be useful in applications, but use at your own risk.

package/dist/data-driven-tile-3d-layer/data-driven-tile-3d-layer.d.ts

@@ -0,0 +1,65 @@
+import { Tile3DLayer } from '@deck.gl/geo-layers';
+import { UpdateParameters, Viewport } from '@deck.gl/core';
+import { Tile3D, Tileset3D } from '@loaders.gl/tiles';
+type _DataDrivenTile3DLayerProps = {
+    onTraversalComplete?: (selectedTiles: Tile3D[]) => Tile3D[];
+    colorsByAttribute?: ColorsByAttribute | null;
+    customizeColors?: (tile: Tile3D, colorsByAttribute: ColorsByAttribute | null) => Promise<{
+        isColored: boolean;
+        id: string;
+    }>;
+    filtersByAttribute?: FiltersByAttribute | null;
+    filterTile?: (tile: Tile3D, filtersByAttribute: FiltersByAttribute | null) => Promise<{
+        isFiltered: boolean;
+        id: string;
+    }>;
+};
+export type ColorsByAttribute = {
+    /** Feature attribute name */
+    attributeName: string;
+    /** Minimum attribute value */
+    minValue: number;
+    /** Maximum attribute value */
+    maxValue: number;
+    /** Minimum color. 3DObject will be colorized with gradient from `minColor to `maxColor` */
+    minColor: [number, number, number, number];
+    /** Maximum color. 3DObject will be colorized with gradient from `minColor to `maxColor` */
+    maxColor: [number, number, number, number];
+    /** Colorization mode. `replace` - replace vertex colors with a new colors, `multiply` - multiply vertex colors with new colors */
+    mode: string;
+};
+export type FiltersByAttribute = {
+    /** Feature attribute name */
+    attributeName: string;
+    /** Filter value */
+    value: number;
+};
+export declare class DataDrivenTile3DLayer<DataT = any, ExtraProps extends Record<string, unknown> = Record<string, unknown>> extends Tile3DLayer<DataT, Required<_DataDrivenTile3DLayerProps> & ExtraProps> {
+    static layerName: string;
+    static defaultProps: any;
+    state: {
+        activeViewports: any;
+        frameNumber?: number;
+        lastUpdatedViewports: {
+            [viewportId: string]: Viewport;
+        } | null;
+        layerMap: {
+            [layerId: string]: any;
+        };
+        tileset3d: Tileset3D | null;
+        colorsByAttribute: ColorsByAttribute | null;
+        filtersByAttribute: FiltersByAttribute | null;
+        loadingCounter: number;
+    };
+    initializeState(): void;
+    updateState(params: UpdateParameters<this>): void;
+    private _loadTileset;
+    private _onTileLoad;
+    private _onTraversalComplete;
+    private _colorizeTiles;
+    private _colorizeTileset;
+    private _filterTiles;
+    private _filterTileset;
+}
+export {};
+//# sourceMappingURL=data-driven-tile-3d-layer.d.ts.map

package/dist/data-driven-tile-3d-layer/data-driven-tile-3d-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-driven-tile-3d-layer.d.ts","sourceRoot":"","sources":["../../src/data-driven-tile-3d-layer/data-driven-tile-3d-layer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,WAAW,EAAmB,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAC,gBAAgB,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AACvE,OAAO,EAAY,MAAM,EAAE,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAW/D,KAAK,2BAA2B,GAAG;IACjC,mBAAmB,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5D,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC7C,eAAe,CAAC,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,KACxC,OAAO,CAAC;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC/C,kBAAkB,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC/C,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,KAC1C,OAAO,CAAC;QAAC,UAAU,EAAE,OAAO,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,6BAA6B;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,2FAA2F;IAC3F,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,2FAA2F;IAC3F,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,kIAAkI;IAClI,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,6BAA6B;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAGF,qBAAa,qBAAqB,CAChC,KAAK,GAAG,GAAG,EACX,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACpE,SAAQ,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,2BAA2B,CAAC,GAAG,UAAU,CAAC;IAC9E,MAAM,CAAC,SAAS,SAA2B;IAC3C,MAAM,CAAC,YAAY,EAAmB,GAAG,CAAC;IAE1C,KAAK,EAAE;QACL,eAAe,EAAE,GAAG,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,oBAAoB,EAAE;YAAC,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAA;SAAC,GAAG,IAAI,CAAC;QAC9D,QAAQ,EAAE;YAAC,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;SAAC,CAAC;QACnC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;QAE5B,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAC;QAC5C,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,CAAC;QAC9C,cAAc,EAAE,MAAM,CAAC;KACxB,CAAc;IAEf,eAAe;IAUf,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;YA+B1B,YAAY;YA4ClB,WAAW;IAkB5B,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,cAAc;IA8BtB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,YAAY;IA8BpB,OAAO,CAAC,cAAc;CAOvB"}

package/dist/data-driven-tile-3d-layer/data-driven-tile-3d-layer.js

@@ -0,0 +1,188 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Tile3DLayer } from '@deck.gl/geo-layers';
+import { TILE_TYPE, Tileset3D } from '@loaders.gl/tiles';
+import { load } from '@loaders.gl/core';
+const defaultProps = {
+    colorsByAttribute: null,
+    filtersByAttribute: null
+};
+// @ts-expect-error call of private method of the base class
+export class DataDrivenTile3DLayer extends Tile3DLayer {
+    static layerName = 'DataDrivenTile3DLayer';
+    static defaultProps = defaultProps;
+    state = undefined;
+    initializeState() {
+        super.initializeState();
+        this.setState({
+            colorsByAttribute: this.props.colorsByAttribute,
+            filtersByAttribute: this.props.filtersByAttribute,
+            loadingCounter: 0
+        });
+    }
+    updateState(params) {
+        const { props, oldProps, changeFlags } = params;
+        if (props.data && props.data !== oldProps.data) {
+            this._loadTileset(props.data);
+        }
+        else if (props.colorsByAttribute !== oldProps.colorsByAttribute) {
+            this.setState({
+                colorsByAttribute: props.colorsByAttribute
+            });
+            this._colorizeTileset();
+        }
+        else if (props.filtersByAttribute !== oldProps.filtersByAttribute) {
+            this.setState({
+                filtersByAttribute: props.filtersByAttribute
+            });
+            this._filterTileset();
+        }
+        else if (changeFlags.viewportChanged) {
+            const { activeViewports } = this.state;
+            const viewportsNumber = Object.keys(activeViewports).length;
+            if (viewportsNumber) {
+                if (!this.state.loadingCounter) {
+                    // @ts-expect-error call of private method of the base class
+                    super._updateTileset(activeViewports);
+                }
+                this.state.lastUpdatedViewports = activeViewports;
+                this.state.activeViewports = {};
+            }
+        }
+        else {
+            super.updateState(params);
+        }
+    }
+    async _loadTileset(tilesetUrl) {
+        const { loadOptions = {} } = this.props;
+        // TODO: deprecate `loader` in v9.0
+        let loader = this.props.loader || this.props.loaders;
+        if (Array.isArray(loader)) {
+            loader = loader[0];
+        }
+        const options = { loadOptions: { ...loadOptions } };
+        if (loader.preload) {
+            const preloadOptions = await loader.preload(tilesetUrl, loadOptions);
+            if (preloadOptions.headers) {
+                options.loadOptions.fetch = {
+                    ...options.loadOptions.fetch,
+                    headers: preloadOptions.headers
+                };
+            }
+            Object.assign(options, preloadOptions);
+        }
+        const tilesetJson = await load(tilesetUrl, loader, options.loadOptions);
+        const tileset3d = new Tileset3D(tilesetJson, {
+            onTileLoad: this._onTileLoad.bind(this),
+            // @ts-expect-error call of private method of the base class
+            onTileUnload: super._onTileUnload.bind(this),
+            onTileError: this.props.onTileError,
+            // New code ------------------
+            onTraversalComplete: this._onTraversalComplete.bind(this),
+            // ---------------------------
+            ...options
+        });
+        this.setState({
+            tileset3d,
+            layerMap: {}
+        });
+        // @ts-expect-error call of private method of the base class
+        super._updateTileset(this.state.activeViewports);
+        this.props.onTilesetLoad(tileset3d);
+    }
+    _onTileLoad(tileHeader) {
+        const { lastUpdatedViewports } = this.state;
+        // New code ------------------
+        this._colorizeTiles([tileHeader]);
+        this._filterTiles([tileHeader]);
+        // ---------------------------
+        this.props.onTileLoad(tileHeader);
+        // New code ------------------ condition is added
+        if (!this.state.colorsByAttribute && !this.state.filtersByAttribute) {
+            // ---------------------------
+            // @ts-expect-error call of private method of the base class
+            super._updateTileset(lastUpdatedViewports);
+            this.setNeedsUpdate();
+            // New code ------------------
+        }
+        // ------------------
+    }
+    _onTraversalComplete(selectedTiles) {
+        this._colorizeTiles(selectedTiles);
+        this._filterTiles(selectedTiles);
+        return this.props.onTraversalComplete
+            ? this.props.onTraversalComplete(selectedTiles)
+            : selectedTiles;
+    }
+    _colorizeTiles(tiles) {
+        if (this.props.customizeColors && tiles[0]?.type === TILE_TYPE.MESH) {
+            const { layerMap, colorsByAttribute } = this.state;
+            const promises = [];
+            for (const tile of tiles) {
+                promises.push(this.props.customizeColors(tile, colorsByAttribute));
+            }
+            this.setState({
+                loadingCounter: this.state.loadingCounter + 1
+            });
+            Promise.allSettled(promises).then((result) => {
+                this.setState({
+                    loadingCounter: this.state.loadingCounter - 1
+                });
+                let isTileChanged = false;
+                for (const item of result) {
+                    if (item.status === 'fulfilled' && item.value.isColored) {
+                        isTileChanged = true;
+                        delete layerMap[item.value.id];
+                    }
+                }
+                if (isTileChanged && !this.state.loadingCounter) {
+                    // @ts-expect-error call of private method of the base class
+                    super._updateTileset(this.state.activeViewports);
+                    this.setNeedsUpdate();
+                }
+            });
+        }
+    }
+    _colorizeTileset() {
+        const { tileset3d } = this.state;
+        if (tileset3d) {
+            this._colorizeTiles(tileset3d.selectedTiles);
+        }
+    }
+    _filterTiles(tiles) {
+        if (this.props.filterTile && tiles[0]?.type === TILE_TYPE.MESH) {
+            const { layerMap, filtersByAttribute } = this.state;
+            const promises = [];
+            for (const tile of tiles) {
+                promises.push(this.props.filterTile(tile, filtersByAttribute));
+            }
+            this.setState({
+                loadingCounter: this.state.loadingCounter + 1
+            });
+            Promise.allSettled(promises).then((result) => {
+                this.setState({
+                    loadingCounter: this.state.loadingCounter - 1
+                });
+                let isTileChanged = false;
+                for (const item of result) {
+                    if (item.status === 'fulfilled' && item.value.isFiltered) {
+                        isTileChanged = true;
+                        delete layerMap[item.value.id];
+                    }
+                }
+                if (isTileChanged && !this.state.loadingCounter) {
+                    // @ts-expect-error call of private method of the base class
+                    super._updateTileset(this.state.activeViewports);
+                    this.setNeedsUpdate();
+                }
+            });
+        }
+    }
+    _filterTileset() {
+        const { tileset3d } = this.state;
+        if (tileset3d) {
+            this._filterTiles(tileset3d.selectedTiles);
+        }
+    }
+}

package/dist/data-driven-tile-3d-layer/utils/colorize-tile.d.ts

@@ -0,0 +1,11 @@
+import { Tile3D } from '@loaders.gl/tiles';
+import { ColorsByAttribute } from "../data-driven-tile-3d-layer.js";
+/**
+ * Update tile colors with the custom colors assigned to the I3S Loader
+ * @returns {Promise<{isColored: boolean; id: string}>} Result of the tile colorization - isColored: true/false and tile id
+ */
+export declare const colorizeTile: (tile: Tile3D, colorsByAttribute: ColorsByAttribute | null) => Promise<{
+    isColored: boolean;
+    id: string;
+}>;
+//# sourceMappingURL=colorize-tile.d.ts.map

package/dist/data-driven-tile-3d-layer/utils/colorize-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorize-tile.d.ts","sourceRoot":"","sources":["../../../src/data-driven-tile-3d-layer/utils/colorize-tile.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,iBAAiB,EAAC,wCAAqC;AAE/D;;;GAGG;AACH,eAAO,MAAM,YAAY,SACjB,MAAM,qBACO,iBAAiB,GAAG,IAAI,KAC1C,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAqC1C,CAAC"}

package/dist/data-driven-tile-3d-layer/utils/colorize-tile.js

@@ -0,0 +1,37 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { customizeColors } from '@loaders.gl/i3s';
+/**
+ * Update tile colors with the custom colors assigned to the I3S Loader
+ * @returns {Promise<{isColored: boolean; id: string}>} Result of the tile colorization - isColored: true/false and tile id
+ */
+export const colorizeTile = async (tile, colorsByAttribute) => {
+    const result = { isColored: false, id: tile.id };
+    if (tile.content.customColors !== colorsByAttribute) {
+        if (tile.content && colorsByAttribute) {
+            if (!tile.content.originalColorsAttributes) {
+                tile.content.originalColorsAttributes = {
+                    ...tile.content.attributes.colors,
+                    value: new Uint8Array(tile.content.attributes.colors.value)
+                };
+            }
+            else if (colorsByAttribute.mode === 'multiply') {
+                tile.content.attributes.colors.value.set(tile.content.originalColorsAttributes.value);
+            }
+            tile.content.customColors = colorsByAttribute;
+            const newColors = await customizeColors(tile.content.attributes.colors, tile.content.featureIds, tile.header.attributeUrls, tile.tileset.tileset.fields, tile.tileset.tileset.attributeStorageInfo, colorsByAttribute, tile.tileset.loadOptions.i3s.token);
+            // Make sure custom colors is not changed during async customizeColors execution
+            if (tile.content.customColors === colorsByAttribute) {
+                tile.content.attributes.colors = newColors;
+                result.isColored = true;
+            }
+        }
+        else if (tile.content && tile.content.originalColorsAttributes) {
+            tile.content.attributes.colors.value = tile.content.originalColorsAttributes.value;
+            tile.content.customColors = null;
+            result.isColored = true;
+        }
+    }
+    return result;
+};

package/dist/data-driven-tile-3d-layer/utils/filter-tile.d.ts

@@ -0,0 +1,13 @@
+import { Tile3D } from '@loaders.gl/tiles';
+import { FiltersByAttribute } from "../data-driven-tile-3d-layer.js";
+/**
+ * Filter tile indices by attribute value
+ * @param tile - tile to be filtered
+ * @param filtersByAttribute - custom filters patameters
+ * @returns {Promise<{isFiltered: boolean; id: string}>} Result of the tile filtering - isFiltered: true/false and tile id
+ */
+export declare const filterTile: (tile: Tile3D, filtersByAttribute: FiltersByAttribute | null) => Promise<{
+    isFiltered: boolean;
+    id: string;
+}>;
+//# sourceMappingURL=filter-tile.d.ts.map

package/dist/data-driven-tile-3d-layer/utils/filter-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-tile.d.ts","sourceRoot":"","sources":["../../../src/data-driven-tile-3d-layer/utils/filter-tile.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,kBAAkB,EAAC,wCAAqC;AAOhE;;;;;GAKG;AACH,eAAO,MAAM,UAAU,SACf,MAAM,sBACQ,kBAAkB,GAAG,IAAI,KAC5C,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CA8B3C,CAAC"}

package/dist/data-driven-tile-3d-layer/utils/filter-tile.js

@@ -0,0 +1,120 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { I3SAttributeLoader } from '@loaders.gl/i3s';
+import { load } from '@loaders.gl/core';
+/**
+ * Filter tile indices by attribute value
+ * @param tile - tile to be filtered
+ * @param filtersByAttribute - custom filters patameters
+ * @returns {Promise<{isFiltered: boolean; id: string}>} Result of the tile filtering - isFiltered: true/false and tile id
+ */
+export const filterTile = async (tile, filtersByAttribute) => {
+    const result = { isFiltered: false, id: tile.id };
+    if (tile.content.userData?.customFilters !== filtersByAttribute) {
+        if (tile.content && filtersByAttribute) {
+            if (tile.content.userData?.originalIndices === undefined) {
+                tile.content.userData = {};
+                // save original indices for filtring cancellation
+                tile.content.userData.originalIndices = tile.content.indices;
+            }
+            tile.content.indices = tile.content.userData?.originalIndices;
+            tile.content.userData.customFilters = filtersByAttribute;
+            const { indices } = await filterTileIndices(tile, filtersByAttribute, tile.tileset.loadOptions.i3s.token);
+            // Make sure custom filters is not changed during async filtring execution
+            if (indices && tile.content.userData.customFilters === filtersByAttribute) {
+                tile.content.indices = indices;
+                result.isFiltered = true;
+            }
+        }
+        else if (tile.content && tile.content.userData?.originalIndices !== undefined) {
+            tile.content.indices = tile.content.userData.originalIndices;
+            tile.content.userData.customFilters = null;
+            result.isFiltered = true;
+        }
+    }
+    return result;
+};
+// eslint-disable-next-line max-statements, complexity
+async function filterTileIndices(tile, filtersByAttribute, token) {
+    if (!filtersByAttribute.attributeName.length) {
+        return { success: false };
+    }
+    const filterAttributeField = tile.tileset.tileset.fields.find(({ name }) => name === filtersByAttribute?.attributeName);
+    if (!filterAttributeField ||
+        !['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSmallInteger'].includes(filterAttributeField.type)) {
+        return { success: false };
+    }
+    const tileFilterAttributeData = await loadFeatureAttributeData(filterAttributeField.name, tile.header.attributeUrls, tile.tileset.tileset.attributeStorageInfo, token);
+    if (!tileFilterAttributeData) {
+        return { success: false };
+    }
+    const objectIdField = tile.tileset.tileset.fields.find(({ type }) => type === 'esriFieldTypeOID');
+    if (!objectIdField) {
+        return { success: false };
+    }
+    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, tile.header.attributeUrls, tile.tileset.tileset.attributeStorageInfo, token);
+    if (!objectIdAttributeData) {
+        return { success: false };
+    }
+    const attributeValuesMap = {};
+    objectIdAttributeData[objectIdField.name]?.forEach((elem, index) => {
+        attributeValuesMap[elem] = tileFilterAttributeData[filterAttributeField.name][index];
+    });
+    if (!tile.content.indices) {
+        const triangles = [];
+        for (let i = 0; i < tile.content.featureIds.length; i += 3) {
+            if (attributeValuesMap[tile.content.featureIds[i]] === filtersByAttribute.value) {
+                triangles.push(i);
+            }
+        }
+        const indices = new Uint32Array(3 * triangles.length);
+        triangles.forEach((vertex, index) => {
+            indices[index * 3] = vertex;
+            indices[index * 3 + 1] = vertex + 1;
+            indices[index * 3 + 2] = vertex + 2;
+        });
+        return { success: true, indices };
+    }
+    const triangles = [];
+    for (let i = 0; i < tile.content.indices.length; i += 3) {
+        if (attributeValuesMap[tile.content.featureIds[tile.content.indices[i]]] ===
+            filtersByAttribute.value) {
+            triangles.push(i);
+        }
+    }
+    const indices = new Uint32Array(3 * triangles.length);
+    triangles.forEach((vertex, index) => {
+        indices[index * 3] = tile.content.indices[vertex];
+        indices[index * 3 + 1] = tile.content.indices[vertex + 1];
+        indices[index * 3 + 2] = tile.content.indices[vertex + 2];
+    });
+    return { success: true, indices };
+}
+async function loadFeatureAttributeData(attributeName, attributeUrls, attributesStorageInfo, token) {
+    const attributeIndex = attributesStorageInfo.findIndex(({ name }) => attributeName === name);
+    if (attributeIndex === -1) {
+        return null;
+    }
+    const objectIdAttributeUrl = getUrlWithToken(attributeUrls[attributeIndex], token);
+    const attributeType = getAttributeValueType(attributesStorageInfo[attributeIndex]);
+    const objectIdAttributeData = await load(objectIdAttributeUrl, I3SAttributeLoader, {
+        attributeName,
+        attributeType
+    });
+    return objectIdAttributeData;
+}
+function getUrlWithToken(url, token = null) {
+    return token ? `${url}?token=${token}` : url;
+}
+function getAttributeValueType(attribute) {
+    // eslint-disable-next-line no-prototype-builtins
+    if (attribute.hasOwnProperty('objectIds')) {
+        return 'Oid32';
+        // eslint-disable-next-line no-prototype-builtins
+    }
+    else if (attribute.hasOwnProperty('attributeValues')) {
+        return attribute.attributeValues?.valueType;
+    }
+    return '';
+}