@loaders.gl/gltf 4.0.0-alpha.23 → 4.0.0-alpha.25

package/src/lib/extensions/EXT_structural_metadata.ts

@@ -1,4 +1,7 @@
+// GLTF EXTENSION: EXT_structural_metadata
+// https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata
 /* eslint-disable camelcase */
+import type {BigTypedArray, TypedArray} from '@loaders.gl/schema';
 import type {GLTF, GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../types/gltf-json-schema';
 import type {
   GLTF_EXT_structural_metadata_Schema,
@@ -6,22 +9,23 @@ import type {
   GLTF_EXT_structural_metadata_Enum,
   GLTF_EXT_structural_metadata_EnumValue,
   GLTF_EXT_structural_metadata_PropertyTable,
-  GLTF_EXT_structural_metadata,
+  GLTF_EXT_structural_metadata_GLTF,
   GLTF_EXT_structural_metadata_PropertyTexture,
   GLTF_EXT_structural_metadata_PropertyTable_Property,
   GLTF_EXT_structural_metadata_Primitive
 } from '../types/gltf-ext-structural-metadata-schema';
-
-import type {TypedArray} from '@loaders.gl/schema';
 import type {GLTFLoaderOptions} from '../../gltf-loader';
+import type {FeatureTableJson} from '../types/gltf-types';
 
 import {GLTFScenegraph} from '../api/gltf-scenegraph';
 import {
   convertRawBufferToMetadataArray,
   getPrimitiveTextureData,
   primitivePropertyDataToAttributes,
-  getArrayElementByteSize
-} from './data-processing';
+  getArrayElementByteSize,
+  NumericComponentType,
+  getOffsetsForProperty
+} from './utils/3d-tiles-utils';
 
 const EXT_STRUCTURAL_METADATA_NAME = 'EXT_structural_metadata';
 export const name = EXT_STRUCTURAL_METADATA_NAME;
@@ -31,6 +35,52 @@ export async function decode(gltfData: {json: GLTF}, options: GLTFLoaderOptions)
   decodeExtStructuralMetadata(scenegraph, options);
 }
 
+/**
+ * Handles EXT_structural_metadata to get property table.
+ * @param extension - Global level of EXT_STRUCTURAL_METADATA extension.
+ * @param metadataClass - User selected feature metadata class name.
+ * @returns {FeatureTableJson | null} Property table or null if the extension can't be handled properly.
+ */
+export function getPropertyTableFromExtStructuralMetadata(
+  extension: GLTF_EXT_structural_metadata_GLTF,
+  metadataClass?: string
+): FeatureTableJson | null {
+  if (extension.propertyTables) {
+    /**
+     * Take only first feature table to generate attributes storage info object.
+     * TODO: Think about getting data from all feature tables?
+     * It can be tricky just because 3dTiles is able to have multiple featureId attributes and multiple feature tables.
+     * In I3S we should decide which featureIds attribute will be passed to geometry data.
+     */
+    const firstPropertyTable = extension?.propertyTables[0];
+    const propertyTableWithData = {};
+
+    for (const propertyName in firstPropertyTable.properties) {
+      propertyTableWithData[propertyName] = firstPropertyTable.properties[propertyName].data;
+    }
+
+    return propertyTableWithData;
+  }
+
+  if (extension.propertyTextures) {
+    // TODO: Think about getting data from all property textures.
+    const firstPropertyTexture = extension?.propertyTextures[0];
+    const propertyTableWithData = {};
+
+    for (const propertyName in firstPropertyTexture.properties) {
+      propertyTableWithData[propertyName] = firstPropertyTexture.properties[propertyName].data;
+    }
+
+    return propertyTableWithData;
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(
+    'Cannot get property table from EXT_structural_metadata extension. There is neither propertyTables, nor propertyTextures in the extension.'
+  );
+  return null;
+}
+
 /*
 // Example of the extension.
 // See more info at https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata
@@ -90,16 +140,16 @@ const extensions = {
 
 /**
  * Returns the property table populated with the data taken according to the extension schema.
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {number} propertyTableIndex - Index of the property table to locate.
- * @returns {GLTF_EXT_structural_metadata_PropertyTable} Property table populated with the data.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param propertyTableIndex - Index of the property table to locate.
+ * @returns Property table populated with the data.
  * Throws an exception if no property table was found for propertyTableIndex provided.
  */
 export function getPropertyTablePopulated(
   scenegraph: GLTFScenegraph,
   propertyTableIndex: number
 ): GLTF_EXT_structural_metadata_PropertyTable {
-  const extension: GLTF_EXT_structural_metadata | null = scenegraph.getExtension(
+  const extension: GLTF_EXT_structural_metadata_GLTF | null = scenegraph.getExtension(
     EXT_STRUCTURAL_METADATA_NAME
   );
   const propertyTable = extension?.propertyTables?.[propertyTableIndex];
@@ -113,21 +163,42 @@ export function getPropertyTablePopulated(
 }
 
 /**
- * Decodes feature metadata from extension
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTFLoaderOptions} options - loader options.
+ * Decodes feature metadata from extension.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param options - GLTFLoader options.
  */
 function decodeExtStructuralMetadata(scenegraph: GLTFScenegraph, options: GLTFLoaderOptions): void {
-  const extension: GLTF_EXT_structural_metadata | null = scenegraph.getExtension(
+  // Decoding metadata involves buffers processing.
+  // So, if buffers have not been loaded, there is no reason to process metadata.
+  if (!options.gltf?.loadBuffers) {
+    return;
+  }
+  const extension: GLTF_EXT_structural_metadata_GLTF | null = scenegraph.getExtension(
     EXT_STRUCTURAL_METADATA_NAME
   );
-  if (!extension?.schema) {
+  if (!extension) {
     return;
   }
 
+  if (options.gltf?.loadImages) {
+    decodePropertyTextures(scenegraph, extension);
+  }
+
+  decodePropertyTables(scenegraph, extension);
+}
+
+/**
+ * Processes the data stored in the textures
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param extension - Top-level extension.
+ */
+function decodePropertyTextures(
+  scenegraph: GLTFScenegraph,
+  extension: GLTF_EXT_structural_metadata_GLTF
+): void {
   const propertyTextures = extension.propertyTextures;
   const json = scenegraph.gltf.json;
-  if (propertyTextures && json.meshes && options?.gltf?.loadImages) {
+  if (propertyTextures && json.meshes) {
     // Iterate through all meshes/primitives.
     for (const mesh of json.meshes) {
       for (const primitive of mesh.primitives) {
@@ -135,31 +206,63 @@ function decodeExtStructuralMetadata(scenegraph: GLTFScenegraph, options: GLTFLo
       }
     }
   }
+}
 
-  const schemaClasses = extension.schema.classes;
+/**
+ * Processes the data stored in the property tables.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param extension - Top-level extension.
+ */
+function decodePropertyTables(
+  scenegraph: GLTFScenegraph,
+  extension: GLTF_EXT_structural_metadata_GLTF
+): void {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
   const propertyTables = extension.propertyTables;
   if (schemaClasses && propertyTables) {
     for (const schemaName in schemaClasses) {
       const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
       if (propertyTable) {
-        processPropertyTable(scenegraph, extension.schema, propertyTable);
+        processPropertyTable(scenegraph, schema, propertyTable);
       }
     }
   }
 }
 
 /**
- * Takes data from property textures reffered by the primitive
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTF_EXT_structural_metadata_PropertyTexture[]} propertyTextures - propertyTexture definition taken from the top-level extention
- * @param {GLTFMeshPrimitive} primitive - Primitive object
- * @param {GLTF_EXT_structural_metadata} extension - top-level extension
+ * Finds the property table by class name.
+ * @param propertyTables - propertyTable definition taken from the top-level extension.
+ * @param schemaClassName - class name in the extension schema.
+ */
+function findPropertyTableByClass(
+  propertyTables: GLTF_EXT_structural_metadata_PropertyTable[],
+  schemaClassName: string
+): GLTF_EXT_structural_metadata_PropertyTable | null {
+  for (const propertyTable of propertyTables) {
+    if (propertyTable.class === schemaClassName) {
+      return propertyTable;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Takes data from property textures reffered by the primitive.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param propertyTextures - propertyTexture definition taken from the top-level extention.
+ * @param primitive - Primitive object.
+ * @param extension - Top-level extension.
  */
 function processPrimitivePropertyTextures(
   scenegraph: GLTFScenegraph,
   propertyTextures: GLTF_EXT_structural_metadata_PropertyTexture[],
   primitive: GLTFMeshPrimitive,
-  extension: GLTF_EXT_structural_metadata
+  extension: GLTF_EXT_structural_metadata_GLTF
 ): void {
   if (!propertyTextures) {
     return;
@@ -179,17 +282,17 @@ function processPrimitivePropertyTextures(
 }
 
 /**
- * Takes property data from the texture pointed by the primitive and appends them to `exension.data`
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTF_EXT_structural_metadata_PropertyTexture} propertyTexture - propertyTexture definition taken from the top-level extension.
- * @param {GLTFMeshPrimitive} primitive - Primitive object
- * @param {GLTF_EXT_structural_metadata} extension - top-level extension
+ * Takes property data from the texture pointed by the primitive and appends them to `exension.data`.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param propertyTexture - propertyTexture definition taken from the top-level extension.
+ * @param primitive - Primitive object.
+ * @param extension - Top-level extension.
  */
 function processPrimitivePropertyTexture(
   scenegraph: GLTFScenegraph,
   propertyTexture: GLTF_EXT_structural_metadata_PropertyTexture,
   primitive: GLTFMeshPrimitive,
-  extension: GLTF_EXT_structural_metadata
+  extension: GLTF_EXT_structural_metadata_GLTF
 ): void {
   if (!propertyTexture.properties) {
     return;
@@ -217,12 +320,12 @@ function processPrimitivePropertyTexture(
     }
   */
   const className = propertyTexture.class;
-  for (const propName in propertyTexture.properties) {
-    // propName has values like "speed", "direction"
+  for (const propertyName in propertyTexture.properties) {
+    // propertyName has values like "speed", "direction"
     // Make attributeName as a combination of the class name and the propertyName like "wind_speed" or "wind_direction"
-    const attributeName = `${className}_${propName}`;
+    const attributeName = `${className}_${propertyName}`;
     const textureInfoTopLevel: GLTFTextureInfoMetadata | undefined =
-      propertyTexture.properties?.[propName];
+      propertyTexture.properties?.[propertyName];
     if (!textureInfoTopLevel) {
       // eslint-disable-next-line no-continue
       continue;
@@ -259,9 +362,9 @@ function processPrimitivePropertyTexture(
 /**
  * Navigates through all properies in the property table, gets properties data,
  * and put the data to `propertyTable.data` as an array.
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTF_EXT_structural_metadata_Schema} schema - schema object
- * @param {GLTF_EXT_structural_metadata_PropertyTable} propertyTable - propertyTable definition taken from the top-level extension
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param schema - schema object.
+ * @param propertyTable - propertyTable definition taken from the top-level extension.
  */
 function processPropertyTable(
   scenegraph: GLTFScenegraph,
@@ -297,56 +400,36 @@ function processPropertyTable(
 }
 
 /**
- * Decodes properties from binary sourse based on property type.
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTF_EXT_structural_metadata_Schema} schema - Schema object
- * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
- * @param {GLTF_EXT_structural_metadata_PropertyTable_Property} propertyTableProperty
- * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * Decodes a propertyTable column from binary source based on property type.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param schema - Schema object.
+ * @param classProperty - class property object.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param propertyTableProperty - propertyTable's property metadata.
  * @returns {string[] | number[] | string[][] | number[][]}
  */
-/* eslint complexity: ["error", 17]*/
 function getPropertyDataFromBinarySource(
   scenegraph: GLTFScenegraph,
   schema: GLTF_EXT_structural_metadata_Schema,
   classProperty: GLTF_EXT_structural_metadata_ClassProperty,
   numberOfElements: number,
   propertyTableProperty: GLTF_EXT_structural_metadata_PropertyTable_Property
-): string[] | number[] | string[][] | number[][] {
-  let data: string[] | number[] | string[][] | number[][] = [];
+): string[] | BigTypedArray | string[][] | BigTypedArray[] {
+  let data: string[] | BigTypedArray | string[][] | BigTypedArray[] = [];
   const valuesBufferView = propertyTableProperty.values;
   const valuesDataBytes: Uint8Array = scenegraph.getTypedArrayForBufferView(valuesBufferView);
 
-  let arrayOffsets: TypedArray | null = null;
-  if (
-    classProperty.array &&
-    // `count` is a number of array elements. May only be defined when `array` is true.
-    typeof classProperty.count === 'undefined' && // If `count` is NOT defined, it's a VARIABLE-length array
-    typeof propertyTableProperty.arrayOffsets !== 'undefined' && // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
-    typeof propertyTableProperty.arrayOffsetType !== 'undefined'
-  ) {
-    // Data are in a VARIABLE-length array
-    arrayOffsets = getOffsetArray(
-      scenegraph,
-      propertyTableProperty.arrayOffsets,
-      propertyTableProperty.arrayOffsetType,
-      numberOfElements
-    );
-  }
-
-  let stringOffsets: TypedArray | null = null;
-  if (
-    typeof propertyTableProperty.stringOffsets !== 'undefined' && // `stringOffsets` is an index of the buffer view containing offsets for strings.
-    typeof propertyTableProperty.stringOffsetType !== 'undefined'
-  ) {
-    // Data are in a FIXED-length array
-    stringOffsets = getOffsetArray(
-      scenegraph,
-      propertyTableProperty.stringOffsets,
-      propertyTableProperty.stringOffsetType,
-      numberOfElements
-    );
-  }
+  const arrayOffsets = getArrayOffsetsForProperty(
+    scenegraph,
+    classProperty,
+    propertyTableProperty,
+    numberOfElements
+  );
+  const stringOffsets = getStringOffsetsForProperty(
+    scenegraph,
+    propertyTableProperty,
+    numberOfElements
+  );
 
   switch (classProperty.type) {
     case 'SCALAR':
@@ -391,59 +474,98 @@ function getPropertyDataFromBinarySource(
 }
 
 /**
- * Gets offset array from `arrayOffsets` or `stringOffsets`.
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {number} offsets - Buffer view index
- * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.
- * @param {number} numberOfElements - The number of elements in each property array.
- * @returns {TypedArray}
+ * Parses propertyTable.property.arrayOffsets that are offsets of sub-arrays in a flatten array of values.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param classProperty - class property object.
+ * @param propertyTableProperty - propertyTable's property metadata.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @returns Typed array with offset values.
+ * @see https://github.com/CesiumGS/glTF/blob/2976f1183343a47a29e4059a70961371cd2fcee8/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTable.property.schema.json#L21
  */
-function getOffsetArray(
+function getArrayOffsetsForProperty(
   scenegraph: GLTFScenegraph,
-  offsets: number,
-  offsetType: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64',
+  classProperty: GLTF_EXT_structural_metadata_ClassProperty,
+  propertyTableProperty: GLTF_EXT_structural_metadata_PropertyTable_Property,
   numberOfElements: number
-): TypedArray {
-  const arrayOffsetsBufferView = offsets;
-  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(arrayOffsetsBufferView);
-
-  const arrayOffsets = convertRawBufferToMetadataArray(
-    arrayOffsetsBytes,
-    'SCALAR', // offsets consist of ONE component
-    offsetType,
-    numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.
-  );
-  return arrayOffsets;
+): TypedArray | null {
+  if (
+    classProperty.array &&
+    // `count` is a number of array elements. May only be defined when `array` is true.
+    // If `count` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.count === 'undefined' &&
+    // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsets !== 'undefined'
+  ) {
+    // Data are in a VARIABLE-length array
+    return getOffsetsForProperty(
+      scenegraph,
+      propertyTableProperty.arrayOffsets,
+      propertyTableProperty.arrayOffsetType || 'UINT32',
+      numberOfElements
+    );
+  }
+  return null;
+}
+
+/**
+ * Parses propertyTable.property.stringOffsets.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param propertyTableProperty - propertyTable's property metadata.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @returns Typed array with offset values.
+ * @see https://github.com/CesiumGS/glTF/blob/2976f1183343a47a29e4059a70961371cd2fcee8/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTable.property.schema.json#L29C10-L29C23
+ */
+function getStringOffsetsForProperty(
+  scenegraph: GLTFScenegraph,
+  propertyTableProperty: GLTF_EXT_structural_metadata_PropertyTable_Property,
+  numberOfElements: number
+): TypedArray | null {
+  if (
+    typeof propertyTableProperty.stringOffsets !== 'undefined' // `stringOffsets` is an index of the buffer view containing offsets for strings.
+  ) {
+    // Data are in a FIXED-length array
+    return getOffsetsForProperty(
+      scenegraph,
+      propertyTableProperty.stringOffsets,
+      propertyTableProperty.stringOffsetType || 'UINT32',
+      numberOfElements
+    );
+  }
+  return null;
 }
 
 /**
  * Decodes properties of SCALAR, VEC-N, MAT-N types from binary sourse.
- * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
- * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
- * @param {Uint8Array} valuesDataBytes - data taken from values property of the property table property.
- * @param {TypedArray | null} arrayOffsets - offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
- * @returns {number[] | number[][]}
+ * @param classProperty - class property object.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param valuesDataBytes - Data taken from values property of the property table property.
+ * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @returns Property values in a typed array or in an array of typed arrays.
  */
 function getPropertyDataNumeric(
   classProperty: GLTF_EXT_structural_metadata_ClassProperty,
   numberOfElements: number,
   valuesDataBytes: Uint8Array,
   arrayOffsets: TypedArray | null
-): number[] | number[][] {
+): BigTypedArray | BigTypedArray[] {
   const isArray = classProperty.array;
   const arrayCount = classProperty.count;
 
   const elementSize = getArrayElementByteSize(classProperty.type, classProperty.componentType);
   const elementCount = valuesDataBytes.byteLength / elementSize;
 
-  let valuesData: TypedArray;
+  let valuesData: BigTypedArray | null;
   if (classProperty.componentType) {
     valuesData = convertRawBufferToMetadataArray(
       valuesDataBytes,
       classProperty.type,
-      classProperty.componentType, // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+      // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+      classProperty.componentType as NumericComponentType,
       elementCount
     );
+    if (!valuesData) {
+      valuesData = valuesDataBytes;
+    }
   } else {
     // The spec doesn't provide any info what to do if componentType is not set.
     valuesData = valuesDataBytes;
@@ -452,7 +574,7 @@ function getPropertyDataNumeric(
   if (isArray) {
     if (arrayOffsets) {
       // VARIABLE-length array
-      return handleVariableLengthArrayNumeric(
+      return parseVariableLengthArrayNumeric(
         valuesData,
         numberOfElements,
         arrayOffsets,
@@ -462,70 +584,76 @@ function getPropertyDataNumeric(
     }
     if (arrayCount) {
       // FIXED-length array
-      return handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+      return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
     }
     return [];
   }
 
-  // Single value (not an array)
-  const attributeValueArray: number[] = [];
-  for (let index = 0; index < numberOfElements; index++) {
-    const value = valuesData[index];
-    attributeValueArray.push(value);
-  }
-  return attributeValueArray;
+  return valuesData;
 }
 
-function handleVariableLengthArrayNumeric(
-  valuesData: TypedArray,
+/**
+ * Parses variable-length array data.
+ * In this case every value of the property in the table will be an array
+ * of arbitrary length.
+ * @param valuesData - Values in a flat typed array.
+ * @param numberOfElements - Number of rows in the property table.
+ * @param arrayOffsets - Offsets of nested arrays in the flat values array.
+ * @param valuesDataBytesLength - Data byte length.
+ * @param valueSize - Value size in bytes.
+ * @returns Array of typed arrays.
+ */
+function parseVariableLengthArrayNumeric(
+  valuesData: BigTypedArray,
   numberOfElements: number,
   arrayOffsets: TypedArray,
   valuesDataBytesLength: number,
-  elementSize: number
-) {
-  const attributeValueArray: number[][] = [];
+  valueSize: number
+): BigTypedArray[] {
+  const attributeValueArray: BigTypedArray[] = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array: number[] = [];
     const arrayOffset = arrayOffsets[index];
     const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      for (let i = 0; i < elementCount; i++) {
-        const value = valuesData[typedArrayOffset + i];
-        array.push(value);
-      }
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
     }
-    attributeValueArray.push(array);
+    const typedArrayOffset = arrayOffset / valueSize;
+    const elementCount = arrayByteSize / valueSize;
+    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
   }
   return attributeValueArray;
 }
 
-function handleFixedLengthArrayNumeric(
-  valuesData: TypedArray,
+/**
+ * Parses fixed-length array data.
+ * In this case every value of the property in the table will be an array
+ * of constant length equal to `arrayCount`.
+ * @param valuesData - Values in a flat typed array.
+ * @param numberOfElements - Number of rows in the property table.
+ * @param arrayCount - Nested arrays length.
+ * @returns Array of typed arrays.
+ */
+function parseFixedLengthArrayNumeric(
+  valuesData: BigTypedArray,
   numberOfElements: number,
   arrayCount: number
-) {
-  const attributeValueArray: number[][] = [];
+): BigTypedArray[] {
+  const attributeValueArray: BigTypedArray[] = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array: number[] = [];
-    for (let i = 0; i < arrayCount; i++) {
-      const value = valuesData[i];
-      array.push(value);
-    }
-    attributeValueArray.push(array);
+    const elementOffset = index * arrayCount;
+    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
   }
   return attributeValueArray;
 }
 
 /**
- * Decodes properties of string type from binary sourse.
- * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
- * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
- * @param {Uint8Array} valuesDataBytes - data taken from values property of the property table property.
- * @param {TypedArray | null} arrayOffsets - offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
- * @param {TypedArray | null} stringOffsets - index of the buffer view containing offsets for strings. It should be available for string type.
- * @returns {string[] | string[][]}
+ * Decodes properties of string type from binary source.
+ * @param classProperty - Class property object.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param valuesDataBytes - Data taken from values property of the property table property.
+ * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @param stringOffsets - Index of the buffer view containing offsets for strings. It should be available for string type.
+ * @returns String property values
  */
 function getPropertyDataString(
   classProperty: GLTF_EXT_structural_metadata_ClassProperty,
@@ -562,13 +690,13 @@ function getPropertyDataString(
 }
 
 /**
- * Decodes properties of enum type from binary sourse.
- * @param {GLTF_EXT_structural_metadata_Schema} schema - schema object
- * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
- * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
- * @param {Uint8Array} valuesDataBytes - data taken from values property of the property table property.
- * @param {TypedArray | null} arrayOffsets - offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
- * @returns {string[] | string[][]}
+ * Decodes properties of enum type from binary source.
+ * @param schema - Schema object.
+ * @param classProperty - Class property object.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param valuesDataBytes - Data taken from values property of the property table property.
+ * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @returns Strings array of nested strings array.
  */
 function getPropertyDataENUM(
   schema: GLTF_EXT_structural_metadata_Schema,
@@ -577,11 +705,6 @@ function getPropertyDataENUM(
   valuesDataBytes: Uint8Array,
   arrayOffsets: TypedArray | null
 ): string[] | string[][] {
-  const data: string[] = [];
-
-  const isArray = classProperty.array;
-  const arrayCount = classProperty.count;
-
   const enumType = classProperty.enumType;
   // Enum ID as declared in the `enums` dictionary. Required when `type` is `ENUM`.
   if (!enumType) {
@@ -600,120 +723,144 @@ function getPropertyDataENUM(
   const enumValueType = enumEntry.valueType || 'UINT16';
   const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
   const elementCount = valuesDataBytes.byteLength / elementSize;
-  const valuesData: TypedArray = convertRawBufferToMetadataArray(
+  let valuesData: BigTypedArray | null = convertRawBufferToMetadataArray(
     valuesDataBytes,
     classProperty.type,
     enumValueType,
     elementCount
   );
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
 
-  if (isArray) {
+  if (classProperty.array) {
     if (arrayOffsets) {
       // VARIABLE-length array
-      return handleVariableLengthArrayENUM(
+      return parseVariableLengthArrayENUM({
         valuesData,
         numberOfElements,
         arrayOffsets,
-        valuesDataBytes.length,
+        valuesDataBytesLength: valuesDataBytes.length,
         elementSize,
         enumEntry
-      );
+      });
     }
+
+    const arrayCount = classProperty.count;
     if (arrayCount) {
       // FIXED-length array
-      return handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+      return parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
     }
     return [];
   }
 
   // Single value (not an array)
-  for (let index = 0; index < numberOfElements; index++) {
-    const enumValue = valuesData[index];
-    const enumObject = getEnumByValue(enumEntry, enumValue);
-    if (enumObject) {
-      data.push(enumObject.name);
-    }
-  }
-
-  return data;
+  return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
 }
 
-/* eslint max-params: ["error", 6]*/
-function handleVariableLengthArrayENUM(
-  valuesData: TypedArray,
-  numberOfElements: number,
-  arrayOffsets: TypedArray,
-  valuesDataBytesLength: number,
-  elementSize: number,
-  enumEntry: GLTF_EXT_structural_metadata_Enum
-) {
+/**
+ * Parses variable length nested ENUM arrays.
+ * @param params.valuesData - Values in a flat typed array.
+ * @param params.numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param params.arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @param params.valuesDataBytesLength - Byte length of values array.
+ * @param params.elementSize - Single element byte size.
+ * @param params.enumEntry - Enums dictionary.
+ * @returns Nested strings array.
+ */
+function parseVariableLengthArrayENUM(params: {
+  valuesData: BigTypedArray;
+  numberOfElements: number;
+  arrayOffsets: TypedArray;
+  valuesDataBytesLength: number;
+  elementSize: number;
+  enumEntry: GLTF_EXT_structural_metadata_Enum;
+}): string[][] {
+  const {
+    valuesData,
+    numberOfElements,
+    arrayOffsets,
+    valuesDataBytesLength,
+    elementSize,
+    enumEntry
+  } = params;
   const attributeValueArray: string[][] = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array: string[] = [];
     const arrayOffset = arrayOffsets[index];
     const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      for (let i = 0; i < elementCount; i++) {
-        const value = valuesData[typedArrayOffset + i];
-
-        const enumObject = getEnumByValue(enumEntry, value);
-        if (enumObject) {
-          array.push(enumObject.name);
-        }
-      }
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
     }
+
+    const typedArrayOffset = arrayOffset / elementSize;
+    const elementCount = arrayByteSize / elementSize;
+    const array: string[] = getEnumsArray(valuesData, typedArrayOffset, elementCount, enumEntry);
     attributeValueArray.push(array);
   }
   return attributeValueArray;
 }
 
-function handleFixedLengthArrayENUM(
-  valuesData: TypedArray,
+/**
+ * Parses fixed length ENUM arrays.
+ * @param valuesData - Values in a flat typed array.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param arrayCount - Nested arrays length.
+ * @param enumEntry - Enums dictionary.
+ * @returns Nested strings array.
+ */
+function parseFixedLengthArrayENUM(
+  valuesData: BigTypedArray,
   numberOfElements: number,
   arrayCount: number,
   enumEntry: GLTF_EXT_structural_metadata_Enum
-) {
+): string[][] {
   const attributeValueArray: string[][] = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array: string[] = [];
-    for (let i = 0; i < arrayCount; i++) {
-      const value = valuesData[i];
-
-      const enumObject = getEnumByValue(enumEntry, value);
-      if (enumObject) {
-        array.push(enumObject.name);
-      }
-    }
+    const elementOffset = arrayCount * index;
+    const array: string[] = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
     attributeValueArray.push(array);
   }
   return attributeValueArray;
 }
+
 /**
- * Find the property table by class name.
- * @param {GLTF_EXT_structural_metadata_PropertyTable[]} propertyTables
- * @param {string} schemaClassName
+ * Parses ENUM values into a string array.
+ * @param valuesData - Values in a flat typed array.
+ * @param offset - Offset to start parse from.
+ * @param count - Values length to parse.
+ * @param enumEntry - Enums dictionary.
+ * @returns Array of strings with parsed ENUM names.
  */
-function findPropertyTableByClass(
-  propertyTables: GLTF_EXT_structural_metadata_PropertyTable[],
-  schemaClassName: string
-): GLTF_EXT_structural_metadata_PropertyTable | null {
-  for (let i = 0, len = propertyTables.length; i < len; i++) {
-    const propertyTable = propertyTables[i];
+function getEnumsArray(
+  valuesData: BigTypedArray,
+  offset: number,
+  count: number,
+  enumEntry: GLTF_EXT_structural_metadata_Enum
+): string[] {
+  const array: string[] = [];
+  for (let i = 0; i < count; i++) {
+    // At the moment we don't support BigInt. It requires additional calculations logic
+    // and might be an issue in Safari
+    if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
+      array.push('');
+    } else {
+      const value = valuesData[offset + i];
 
-    if (propertyTable.class === schemaClassName) {
-      return propertyTable;
+      const enumObject = getEnumByValue(enumEntry, value);
+      if (enumObject) {
+        array.push(enumObject.name);
+      } else {
+        array.push('');
+      }
     }
   }
-
-  return null;
+  return array;
 }
 
 /**
  * Looks up ENUM whose `value` property matches the specified number in the parameter `value`.
  * @param {GLTF_EXT_structural_metadata_Enum} enumEntry - ENUM entry containing the array of possible enums.
- * @param {number} value - the value of the ENUM to locate.
+ * @param {number} value - The value of the ENUM to locate.
  * @returns {GLTF_EXT_structural_metadata_EnumValue | null} ENUM matcihng the specified value or null of no ENUM object was found.
  */
 function getEnumByValue(