@loaders.gl/i3s 4.0.0-beta.7 → 4.0.0

package/dist/dist.dev.js

@@ -4270,6 +4270,7 @@ var __exports__ = (() => {
     I3SLoader: () => I3SLoader,
     I3SNodePageLoader: () => I3SNodePageLoader,
     SLPKLoader: () => SLPKLoader,
+    customizeColors: () => customizeColors,
     loadFeatureAttributes: () => loadFeatureAttributes,
     parseSLPKArchive: () => parseSLPKArchive
   });
@@ -8747,10 +8748,10 @@ var __exports__ = (() => {
   }({});
 
   // src/i3s-loader.ts
-  var import_core20 = __toESM(require_core(), 1);
+  var import_core18 = __toESM(require_core(), 1);
 
   // src/lib/parsers/parse-i3s-tile-content.ts
-  var import_core7 = __toESM(require_core(), 1);
+  var import_core5 = __toESM(require_core(), 1);
 
   // ../../node_modules/@math.gl/geospatial/dist/constants.js
   var WGS84_RADIUS_X = 6378137;
@@ -11052,267 +11053,6 @@ var __exports__ = (() => {
     return attributeUrls;
   }
 
-  // src/lib/utils/customize-сolors.ts
-  var import_core6 = __toESM(require_core(), 1);
-
-  // src/i3s-attribute-loader.ts
-  var import_core5 = __toESM(require_core(), 1);
-
-  // src/lib/parsers/parse-i3s-attribute.ts
-  function parseI3STileAttribute(arrayBuffer, options) {
-    const {
-      attributeName,
-      attributeType
-    } = options;
-    if (!attributeName) {
-      return {};
-    }
-    return {
-      [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer) : null
-    };
-  }
-  function parseAttribute(attributeType, arrayBuffer) {
-    switch (attributeType) {
-      case STRING_ATTRIBUTE_TYPE:
-        return parseStringsAttribute(arrayBuffer);
-      case OBJECT_ID_ATTRIBUTE_TYPE:
-        return parseShortNumberAttribute(arrayBuffer);
-      case FLOAT_64_TYPE:
-        return parseFloatAttribute(arrayBuffer);
-      case INT_16_ATTRIBUTE_TYPE:
-        return parseInt16ShortNumberAttribute(arrayBuffer);
-      default:
-        return parseShortNumberAttribute(arrayBuffer);
-    }
-  }
-  function parseShortNumberAttribute(arrayBuffer) {
-    const countOffset = 4;
-    return new Uint32Array(arrayBuffer, countOffset);
-  }
-  function parseInt16ShortNumberAttribute(arrayBuffer) {
-    const countOffset = 4;
-    return new Int16Array(arrayBuffer, countOffset);
-  }
-  function parseFloatAttribute(arrayBuffer) {
-    const countOffset = 8;
-    return new Float64Array(arrayBuffer, countOffset);
-  }
-  function parseStringsAttribute(arrayBuffer) {
-    const stringsCountOffset = 0;
-    const dataOffset = 8;
-    const bytesPerStringSize = 4;
-    const stringsArray = [];
-    try {
-      const stringsCount = new DataView(arrayBuffer, stringsCountOffset, bytesPerStringSize).getUint32(stringsCountOffset, true);
-      const stringSizes = new Uint32Array(arrayBuffer, dataOffset, stringsCount);
-      let stringOffset = dataOffset + stringsCount * bytesPerStringSize;
-      for (const stringByteSize of stringSizes) {
-        const textDecoder = new TextDecoder("utf-8");
-        const stringAttribute = new Uint8Array(arrayBuffer, stringOffset, stringByteSize);
-        stringsArray.push(textDecoder.decode(stringAttribute));
-        stringOffset += stringByteSize;
-      }
-    } catch (error) {
-      console.error("Parse string attribute error: ", error.message);
-    }
-    return stringsArray;
-  }
-
-  // src/i3s-attribute-loader.ts
-  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var EMPTY_VALUE = "";
-  var REJECTED_STATUS = "rejected";
-  var I3SAttributeLoader = {
-    name: "I3S Attribute",
-    id: "i3s-attribute",
-    module: "i3s",
-    version: VERSION5,
-    mimeTypes: ["application/binary"],
-    parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
-    extensions: ["bin"],
-    options: {},
-    binary: true
-  };
-  async function loadFeatureAttributes(tile, featureId, options = {}) {
-    const {
-      attributeStorageInfo,
-      attributeUrls,
-      tilesetFields
-    } = getAttributesData(tile);
-    if (!attributeStorageInfo || !attributeUrls || featureId < 0) {
-      return null;
-    }
-    let attributes = [];
-    const attributeLoadPromises = [];
-    for (let index = 0; index < attributeStorageInfo.length; index++) {
-      const url = getUrlWithToken(attributeUrls[index], options.i3s?.token);
-      const attributeName = attributeStorageInfo[index].name;
-      const attributeType = getAttributeValueType(attributeStorageInfo[index]);
-      const loadOptions = {
-        ...options,
-        attributeName,
-        attributeType
-      };
-      const promise = (0, import_core5.load)(url, I3SAttributeLoader, loadOptions);
-      attributeLoadPromises.push(promise);
-    }
-    try {
-      attributes = await Promise.allSettled(attributeLoadPromises);
-    } catch (error) {
-    }
-    if (!attributes.length) {
-      return null;
-    }
-    return generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields);
-  }
-  function getAttributesData(tile) {
-    const attributeStorageInfo = tile.tileset?.tileset?.attributeStorageInfo;
-    const attributeUrls = tile.header?.attributeUrls;
-    const tilesetFields = tile.tileset?.tileset?.fields || [];
-    return {
-      attributeStorageInfo,
-      attributeUrls,
-      tilesetFields
-    };
-  }
-  function getAttributeValueType(attribute) {
-    if (attribute.hasOwnProperty("objectIds")) {
-      return "Oid32";
-    } else if (attribute.hasOwnProperty("attributeValues")) {
-      return attribute.attributeValues.valueType;
-    }
-    return "";
-  }
-  function getFeatureIdsAttributeName(attributeStorageInfo) {
-    const objectIdsAttribute = attributeStorageInfo.find((attribute) => attribute.name.includes("OBJECTID"));
-    return objectIdsAttribute?.name;
-  }
-  function generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields) {
-    const objectIdsAttributeName = getFeatureIdsAttributeName(attributeStorageInfo);
-    const objectIds = attributes.find((attribute) => attribute.value[objectIdsAttributeName]);
-    if (!objectIds) {
-      return null;
-    }
-    const attributeIndex = objectIds.value[objectIdsAttributeName].indexOf(featureId);
-    if (attributeIndex < 0) {
-      return null;
-    }
-    return getFeatureAttributesByIndex(attributes, attributeIndex, attributeStorageInfo, tilesetFields);
-  }
-  function getFeatureAttributesByIndex(attributes, featureIdIndex, attributeStorageInfo, tilesetFields) {
-    const attributesObject = {};
-    for (let index = 0; index < attributeStorageInfo.length; index++) {
-      const attributeName = attributeStorageInfo[index].name;
-      const codedValues = getAttributeCodedValues(attributeName, tilesetFields);
-      const attribute = getAttributeByIndexAndAttributeName(attributes, index, attributeName);
-      attributesObject[attributeName] = formatAttributeValue(attribute, featureIdIndex, codedValues);
-    }
-    return attributesObject;
-  }
-  function getAttributeCodedValues(attributeName, tilesetFields) {
-    const attributeField = tilesetFields.find((field) => field.name === attributeName || field.alias === attributeName);
-    return attributeField?.domain?.codedValues || [];
-  }
-  function getAttributeByIndexAndAttributeName(attributes, index, attributesName) {
-    const attributeObject = attributes[index];
-    if (attributeObject.status === REJECTED_STATUS) {
-      return null;
-    }
-    return attributeObject.value[attributesName];
-  }
-  function formatAttributeValue(attribute, featureIdIndex, codedValues) {
-    let value = EMPTY_VALUE;
-    if (attribute && featureIdIndex in attribute) {
-      value = String(attribute[featureIdIndex]).replace(/\u0000|NaN/g, "").trim();
-    }
-    if (codedValues.length) {
-      const codeValue = codedValues.find((codedValue) => codedValue.code === Number(value));
-      value = codeValue?.name || EMPTY_VALUE;
-    }
-    return value;
-  }
-
-  // src/lib/utils/customize-сolors.ts
-  async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
-    if (!options?.i3s?.colorsByAttribute) {
-      return colors;
-    }
-    const colorizeAttributeField = tilesetOptions.fields.find(({
-      name
-    }) => name === options?.i3s?.colorsByAttribute?.attributeName);
-    if (!colorizeAttributeField || !["esriFieldTypeDouble", "esriFieldTypeInteger", "esriFieldTypeSmallInteger"].includes(colorizeAttributeField.type)) {
-      return colors;
-    }
-    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, tileOptions, tilesetOptions, options);
-    if (!colorizeAttributeData) {
-      return colors;
-    }
-    const objectIdField = tilesetOptions.fields.find(({
-      type
-    }) => type === "esriFieldTypeOID");
-    if (!objectIdField) {
-      return colors;
-    }
-    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, tileOptions, tilesetOptions, options);
-    if (!objectIdAttributeData) {
-      return colors;
-    }
-    const attributeValuesMap = {};
-    for (let i2 = 0; i2 < objectIdAttributeData[objectIdField.name].length; i2++) {
-      attributeValuesMap[objectIdAttributeData[objectIdField.name][i2]] = calculateColorForAttribute(colorizeAttributeData[colorizeAttributeField.name][i2], options);
-    }
-    for (let i2 = 0; i2 < featureIds.value.length; i2++) {
-      const color = attributeValuesMap[featureIds.value[i2]];
-      if (!color) {
-        continue;
-      }
-      if (options.i3s.colorsByAttribute.mode === "multiply") {
-        color.forEach((colorItem, index) => {
-          colors.value[i2 * 4 + index] = colors.value[i2 * 4 + index] * colorItem / 255;
-        });
-      } else {
-        colors.value.set(color, i2 * 4);
-      }
-    }
-    return colors;
-  }
-  function calculateColorForAttribute(attributeValue, options) {
-    if (!options?.i3s?.colorsByAttribute) {
-      return [255, 255, 255, 255];
-    }
-    const {
-      minValue,
-      maxValue,
-      minColor,
-      maxColor
-    } = options.i3s.colorsByAttribute;
-    const rate = (attributeValue - minValue) / (maxValue - minValue);
-    const color = [255, 255, 255, 255];
-    for (let i2 = 0; i2 < minColor.length; i2++) {
-      color[i2] = Math.round((maxColor[i2] - minColor[i2]) * rate + minColor[i2]);
-    }
-    return color;
-  }
-  async function loadFeatureAttributeData(attributeName, {
-    attributeUrls
-  }, {
-    attributeStorageInfo
-  }, options) {
-    const attributeIndex = attributeStorageInfo.findIndex(({
-      name
-    }) => attributeName === name);
-    if (attributeIndex === -1) {
-      return null;
-    }
-    const objectIdAttributeUrl = getUrlWithToken(attributeUrls[attributeIndex], options?.i3s?.token);
-    const attributeType = getAttributeValueType(attributeStorageInfo[attributeIndex]);
-    const objectIdAttributeData = await (0, import_core6.load)(objectIdAttributeUrl, I3SAttributeLoader, {
-      attributeName,
-      attributeType
-    });
-    return objectIdAttributeData;
-  }
-
   // src/lib/parsers/parse-i3s-tile-content.ts
   var scratchVector6 = new Vector3([0, 0, 0]);
   function getLoaderForTextureFormat(textureFormat) {
@@ -11358,11 +11098,11 @@ var __exports__ = (() => {
             const texture = await parseFromContext(arrayBuffer2, [], options2, context);
             content.texture = texture;
           } catch (e2) {
-            const texture = await (0, import_core7.parse)(arrayBuffer2, loader, options2, context);
+            const texture = await (0, import_core5.parse)(arrayBuffer2, loader, options2, context);
             content.texture = texture;
           }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-          let texture = await (0, import_core7.load)(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
+          let texture = await (0, import_core5.load)(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
           if (loader === BasisLoader) {
             texture = texture[0];
           }
@@ -11392,7 +11132,7 @@ var __exports__ = (() => {
     let featureCount = 0;
     let indices;
     if (tileOptions.isDracoGeometry) {
-      const decompressedGeometry = await (0, import_core7.parse)(arrayBuffer, DracoLoader2, {
+      const decompressedGeometry = await (0, import_core5.parse)(arrayBuffer, DracoLoader2, {
         draco: {
           attributeNameEntry: I3S_ATTRIBUTE_TYPE
         }
@@ -11449,7 +11189,6 @@ var __exports__ = (() => {
       content.modelMatrix = getModelMatrix(attributes.position);
       content.coordinateSystem = COORDINATE_SYSTEM.LNGLAT_OFFSETS;
     }
-    attributes.color = await customizeColors(attributes.color, attributes.id, tileOptions, tilesetOptions, options);
     content.attributes = {
       positions: attributes.position,
       normals: attributes.normal,
@@ -11736,13 +11475,13 @@ var __exports__ = (() => {
   }
 
   // src/i3s-content-loader.ts
-  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
     module: "i3s",
     worker: true,
-    version: VERSION6,
+    version: VERSION5,
     mimeTypes: ["application/octet-stream"],
     parse: parse3,
     extensions: ["bin"],
@@ -12216,7 +11955,7 @@ var __exports__ = (() => {
   };
 
   // src/lib/parsers/parse-i3s.ts
-  var import_core19 = __toESM(require_core(), 1);
+  var import_core17 = __toESM(require_core(), 1);
 
   // ../tiles/src/constants.ts
   var TILE_REFINEMENT = function(TILE_REFINEMENT2) {
@@ -12243,15 +11982,15 @@ var __exports__ = (() => {
   }({});
 
   // src/lib/helpers/i3s-nodepages-tiles.ts
-  var import_core18 = __toESM(require_core(), 1);
+  var import_core16 = __toESM(require_core(), 1);
 
   // src/i3s-node-page-loader.ts
-  var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var I3SNodePageLoader = {
     name: "I3S Node Page",
     id: "i3s-node-page",
     module: "i3s",
-    version: VERSION7,
+    version: VERSION6,
     mimeTypes: ["application/json"],
     parse: parseNodePage,
     extensions: ["json"],
@@ -12286,7 +12025,7 @@ var __exports__ = (() => {
         const nodePageUrl = getUrlWithToken(`${this.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
         this.pendingNodePages[pageIndex] = {
           status: "Pending",
-          promise: (0, import_core18.load)(nodePageUrl, I3SNodePageLoader, this.options)
+          promise: (0, import_core16.load)(nodePageUrl, I3SNodePageLoader, this.options)
         };
         this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
         this.nodesInNodePages += this.nodePages[pageIndex].nodes.length;
@@ -12512,7 +12251,7 @@ var __exports__ = (() => {
     } else {
       const parseOptions = options.i3s;
       const rootNodeUrl = getUrlWithToken(`${url}/nodes/root`, parseOptions.token);
-      root = await (0, import_core19.load)(rootNodeUrl, I3SLoader, {
+      root = await (0, import_core17.load)(rootNodeUrl, I3SLoader, {
         ...options,
         i3s: {
           ...options.i3s,
@@ -12536,7 +12275,7 @@ var __exports__ = (() => {
   }
 
   // src/i3s-loader.ts
-  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TILESET_REGEX = /layers\/[0-9]+$/;
   var TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
   var SLPK_HEX = "504b0304";
@@ -12545,7 +12284,7 @@ var __exports__ = (() => {
     name: "I3S (Indexed Scene Layers)",
     id: "i3s",
     module: "i3s",
-    version: VERSION8,
+    version: VERSION7,
     mimeTypes: ["application/octet-stream"],
     parse: parseI3S,
     extensions: ["bin"],
@@ -12561,8 +12300,7 @@ var __exports__ = (() => {
         useDracoGeometry: true,
         useCompressedTextures: true,
         decodeTextures: true,
-        coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
-        colorsByAttribute: null
+        coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
       }
     }
   };
@@ -12596,7 +12334,7 @@ var __exports__ = (() => {
     return data;
   }
   async function parseTileContent(arrayBuffer, options) {
-    return await (0, import_core20.parse)(arrayBuffer, I3SContentLoader, options);
+    return await (0, import_core18.parse)(arrayBuffer, I3SContentLoader, options);
   }
   async function parseTileset(data, options, context) {
     const tilesetJson = JSON.parse(new TextDecoder().decode(data));
@@ -13590,12 +13328,12 @@ var __exports__ = (() => {
   }
 
   // src/i3s-slpk-loader.ts
-  var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var SLPKLoader = {
     name: "I3S SLPK (Scene Layer Package)",
     id: "slpk",
     module: "i3s",
-    version: VERSION9,
+    version: VERSION8,
     mimeTypes: ["application/octet-stream"],
     extensions: ["slpk"],
     options: {},
@@ -13605,6 +13343,183 @@ var __exports__ = (() => {
     }
   };
 
+  // src/i3s-attribute-loader.ts
+  var import_core19 = __toESM(require_core(), 1);
+
+  // src/lib/parsers/parse-i3s-attribute.ts
+  function parseI3STileAttribute(arrayBuffer, options) {
+    const {
+      attributeName,
+      attributeType
+    } = options;
+    if (!attributeName) {
+      return {};
+    }
+    return {
+      [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer) : null
+    };
+  }
+  function parseAttribute(attributeType, arrayBuffer) {
+    switch (attributeType) {
+      case STRING_ATTRIBUTE_TYPE:
+        return parseStringsAttribute(arrayBuffer);
+      case OBJECT_ID_ATTRIBUTE_TYPE:
+        return parseShortNumberAttribute(arrayBuffer);
+      case FLOAT_64_TYPE:
+        return parseFloatAttribute(arrayBuffer);
+      case INT_16_ATTRIBUTE_TYPE:
+        return parseInt16ShortNumberAttribute(arrayBuffer);
+      default:
+        return parseShortNumberAttribute(arrayBuffer);
+    }
+  }
+  function parseShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Uint32Array(arrayBuffer, countOffset);
+  }
+  function parseInt16ShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Int16Array(arrayBuffer, countOffset);
+  }
+  function parseFloatAttribute(arrayBuffer) {
+    const countOffset = 8;
+    return new Float64Array(arrayBuffer, countOffset);
+  }
+  function parseStringsAttribute(arrayBuffer) {
+    const stringsCountOffset = 0;
+    const dataOffset = 8;
+    const bytesPerStringSize = 4;
+    const stringsArray = [];
+    try {
+      const stringsCount = new DataView(arrayBuffer, stringsCountOffset, bytesPerStringSize).getUint32(stringsCountOffset, true);
+      const stringSizes = new Uint32Array(arrayBuffer, dataOffset, stringsCount);
+      let stringOffset = dataOffset + stringsCount * bytesPerStringSize;
+      for (const stringByteSize of stringSizes) {
+        const textDecoder = new TextDecoder("utf-8");
+        const stringAttribute = new Uint8Array(arrayBuffer, stringOffset, stringByteSize);
+        stringsArray.push(textDecoder.decode(stringAttribute));
+        stringOffset += stringByteSize;
+      }
+    } catch (error) {
+      console.error("Parse string attribute error: ", error.message);
+    }
+    return stringsArray;
+  }
+
+  // src/i3s-attribute-loader.ts
+  var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var EMPTY_VALUE = "";
+  var REJECTED_STATUS = "rejected";
+  var I3SAttributeLoader = {
+    name: "I3S Attribute",
+    id: "i3s-attribute",
+    module: "i3s",
+    version: VERSION9,
+    mimeTypes: ["application/binary"],
+    parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
+    extensions: ["bin"],
+    options: {},
+    binary: true
+  };
+  async function loadFeatureAttributes(tile, featureId, options = {}) {
+    const {
+      attributeStorageInfo,
+      attributeUrls,
+      tilesetFields
+    } = getAttributesData(tile);
+    if (!attributeStorageInfo || !attributeUrls || featureId < 0) {
+      return null;
+    }
+    let attributes = [];
+    const attributeLoadPromises = [];
+    for (let index = 0; index < attributeStorageInfo.length; index++) {
+      const url = getUrlWithToken(attributeUrls[index], options.i3s?.token);
+      const attributeName = attributeStorageInfo[index].name;
+      const attributeType = getAttributeValueType(attributeStorageInfo[index]);
+      const loadOptions = {
+        ...options,
+        attributeName,
+        attributeType
+      };
+      const promise = (0, import_core19.load)(url, I3SAttributeLoader, loadOptions);
+      attributeLoadPromises.push(promise);
+    }
+    try {
+      attributes = await Promise.allSettled(attributeLoadPromises);
+    } catch (error) {
+    }
+    if (!attributes.length) {
+      return null;
+    }
+    return generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields);
+  }
+  function getAttributesData(tile) {
+    const attributeStorageInfo = tile.tileset?.tileset?.attributeStorageInfo;
+    const attributeUrls = tile.header?.attributeUrls;
+    const tilesetFields = tile.tileset?.tileset?.fields || [];
+    return {
+      attributeStorageInfo,
+      attributeUrls,
+      tilesetFields
+    };
+  }
+  function getAttributeValueType(attribute) {
+    if (attribute.hasOwnProperty("objectIds")) {
+      return "Oid32";
+    } else if (attribute.hasOwnProperty("attributeValues")) {
+      return attribute.attributeValues.valueType;
+    }
+    return "";
+  }
+  function getFeatureIdsAttributeName(attributeStorageInfo) {
+    const objectIdsAttribute = attributeStorageInfo.find((attribute) => attribute.name.includes("OBJECTID"));
+    return objectIdsAttribute?.name;
+  }
+  function generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields) {
+    const objectIdsAttributeName = getFeatureIdsAttributeName(attributeStorageInfo);
+    const objectIds = attributes.find((attribute) => attribute.value[objectIdsAttributeName]);
+    if (!objectIds) {
+      return null;
+    }
+    const attributeIndex = objectIds.value[objectIdsAttributeName].indexOf(featureId);
+    if (attributeIndex < 0) {
+      return null;
+    }
+    return getFeatureAttributesByIndex(attributes, attributeIndex, attributeStorageInfo, tilesetFields);
+  }
+  function getFeatureAttributesByIndex(attributes, featureIdIndex, attributeStorageInfo, tilesetFields) {
+    const attributesObject = {};
+    for (let index = 0; index < attributeStorageInfo.length; index++) {
+      const attributeName = attributeStorageInfo[index].name;
+      const codedValues = getAttributeCodedValues(attributeName, tilesetFields);
+      const attribute = getAttributeByIndexAndAttributeName(attributes, index, attributeName);
+      attributesObject[attributeName] = formatAttributeValue(attribute, featureIdIndex, codedValues);
+    }
+    return attributesObject;
+  }
+  function getAttributeCodedValues(attributeName, tilesetFields) {
+    const attributeField = tilesetFields.find((field) => field.name === attributeName || field.alias === attributeName);
+    return attributeField?.domain?.codedValues || [];
+  }
+  function getAttributeByIndexAndAttributeName(attributes, index, attributesName) {
+    const attributeObject = attributes[index];
+    if (attributeObject.status === REJECTED_STATUS) {
+      return null;
+    }
+    return attributeObject.value[attributesName];
+  }
+  function formatAttributeValue(attribute, featureIdIndex, codedValues) {
+    let value = EMPTY_VALUE;
+    if (attribute && featureIdIndex in attribute) {
+      value = String(attribute[featureIdIndex]).replace(/\u0000|NaN/g, "").trim();
+    }
+    if (codedValues.length) {
+      const codeValue = codedValues.find((codedValue) => codedValue.code === Number(value));
+      value = codeValue?.name || EMPTY_VALUE;
+    }
+    return value;
+  }
+
   // src/lib/parsers/parse-i3s-building-scene-layer.ts
   var OBJECT_3D_LAYER_TYPE = "3DObject";
   async function parseBuildingSceneLayer(data, url) {
@@ -13664,7 +13579,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/parsers/parse-arcgis-webscene.ts
-  var import_core21 = __toESM(require_core(), 1);
+  var import_core20 = __toESM(require_core(), 1);
   var SUPPORTED_WKID = 4326;
   var ARCGIS_SCENE_SERVER_LAYER_TYPE = "ArcGISSceneServiceLayer";
   var BUILDING_SCENE_LAYER = "BuildingSceneLayer";
@@ -13722,7 +13637,7 @@ var __exports__ = (() => {
   }
   async function checkSupportedIndexCRS(layer) {
     try {
-      const layerJson = await (0, import_core21.load)(layer.url, import_core21.JSONLoader);
+      const layerJson = await (0, import_core20.load)(layer.url, import_core20.JSONLoader);
       const wkid = layerJson?.spatialReference?.wkid;
       if (wkid !== SUPPORTED_WKID) {
         throw new Error(NOT_SUPPORTED_CRS_ERROR);
@@ -13747,6 +13662,88 @@ var __exports__ = (() => {
   async function parse6(data) {
     return parseWebscene(data);
   }
+
+  // src/lib/utils/customize-colors.ts
+  var import_core21 = __toESM(require_core(), 1);
+  async function customizeColors(colors, featureIds, attributeUrls, fields, attributeStorageInfo, colorsByAttribute, token) {
+    if (!colorsByAttribute) {
+      return colors;
+    }
+    const resultColors = {
+      ...colors,
+      value: new Uint8Array(colors.value)
+    };
+    const colorizeAttributeField = fields.find(({
+      name
+    }) => name === colorsByAttribute?.attributeName);
+    if (!colorizeAttributeField || !["esriFieldTypeDouble", "esriFieldTypeInteger", "esriFieldTypeSmallInteger"].includes(colorizeAttributeField.type)) {
+      return colors;
+    }
+    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, attributeUrls, attributeStorageInfo, token);
+    if (!colorizeAttributeData) {
+      return colors;
+    }
+    const objectIdField = fields.find(({
+      type
+    }) => type === "esriFieldTypeOID");
+    if (!objectIdField) {
+      return colors;
+    }
+    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, attributeUrls, attributeStorageInfo, token);
+    if (!objectIdAttributeData) {
+      return colors;
+    }
+    const attributeValuesMap = {};
+    for (let i2 = 0; i2 < objectIdAttributeData[objectIdField.name].length; i2++) {
+      attributeValuesMap[objectIdAttributeData[objectIdField.name][i2]] = calculateColorForAttribute(colorizeAttributeData[colorizeAttributeField.name][i2], colorsByAttribute);
+    }
+    for (let i2 = 0; i2 < featureIds.length; i2++) {
+      const color = attributeValuesMap[featureIds[i2]];
+      if (!color) {
+        continue;
+      }
+      if (colorsByAttribute.mode === "multiply") {
+        color.forEach((colorItem, index) => {
+          resultColors.value[i2 * 4 + index] = resultColors.value[i2 * 4 + index] * colorItem / 255;
+        });
+      } else {
+        resultColors.value.set(color, i2 * 4);
+      }
+    }
+    return resultColors;
+  }
+  function calculateColorForAttribute(attributeValue, colorsByAttribute) {
+    if (!colorsByAttribute) {
+      return [255, 255, 255, 255];
+    }
+    const {
+      minValue,
+      maxValue,
+      minColor,
+      maxColor
+    } = colorsByAttribute;
+    const rate = (attributeValue - minValue) / (maxValue - minValue);
+    const color = [255, 255, 255, 255];
+    for (let i2 = 0; i2 < minColor.length; i2++) {
+      color[i2] = Math.round((maxColor[i2] - minColor[i2]) * rate + minColor[i2]);
+    }
+    return color;
+  }
+  async function loadFeatureAttributeData(attributeName, attributeUrls, attributeStorageInfo, token) {
+    const attributeIndex = attributeStorageInfo.findIndex(({
+      name
+    }) => attributeName === name);
+    if (attributeIndex === -1) {
+      return null;
+    }
+    const objectIdAttributeUrl = getUrlWithToken(attributeUrls[attributeIndex], token);
+    const attributeType = getAttributeValueType(attributeStorageInfo[attributeIndex]);
+    const objectIdAttributeData = await (0, import_core21.load)(objectIdAttributeUrl, I3SAttributeLoader, {
+      attributeName,
+      attributeType
+    });
+    return objectIdAttributeData;
+  }
   return __toCommonJS(src_exports);
 })();
       return __exports__;