@loaders.gl/tile-converter 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/i3s-converter/helpers/node-pages.js

@@ -2,204 +2,310 @@ import { join } from 'path';
 import transform from 'json-map-transform';
 import { METADATA as metadataTemplate } from "../json-templates/metadata.js";
 import { isFileExists, openJson } from "../../lib/utils/file-utils.js";
-export default class NodePages {
-  constructor(writeFileFunc, nodesPerPage, converter) {
-    this.nodesPerPage = void 0;
-    this.nodesCounter = void 0;
-    this.writeFile = void 0;
-    this.converter = void 0;
-    this.nodePages = void 0;
-    this.length = 0;
-    this.nodesPerPage = nodesPerPage;
-    this.nodesCounter = 0;
-    this.nodePages = [{}];
-    this.nodePages[0].nodes = [];
-    this.writeFile = writeFileFunc;
-    this.converter = converter;
-    this.length = 0;
-  }
-  useWriteFunction(func) {
-    this.writeFile = func;
-  }
-  getNodePageFileName(nodePageId) {
-    let filePath;
-    let fileName;
-    if (this.converter.options.slpk) {
-      filePath = join(this.converter.layers0Path, 'nodepages');
-      fileName = `${nodePageId.toString()}.json`;
-    } else {
-      filePath = join(this.converter.layers0Path, 'nodepages', nodePageId.toString());
-      fileName = 'index.json';
-    }
-    return {
-      filePath,
-      fileName
-    };
-  }
-  async loadNodePage(nodePageId) {
-    const {
-      filePath,
-      fileName
-    } = this.getNodePageFileName(nodePageId);
-    const fullName = join(filePath, fileName);
-    if (await isFileExists(fullName)) {
-      console.log(`load ${fullName}.`);
-      return await openJson(filePath, fileName);
-    } else {
-      return {
-        nodes: []
-      };
-    }
-  }
-  getPageIndexByNodeId(id) {
-    return Math.floor(id / this.nodesPerPage);
-  }
-  async getPageByNodeId(id) {
-    const pageIndex = this.getPageIndexByNodeId(id);
-    if (this.converter.options.instantNodeWriting) {
-      return await this.loadNodePage(pageIndex);
-    }
-    return this.nodePages[pageIndex];
-  }
-  async getNodeById(id, nodePage) {
-    const nodeIndex = id % this.nodesPerPage;
-    nodePage = nodePage || (await this.getPageByNodeId(id));
-    return nodePage.nodes[nodeIndex];
-  }
-  async addChildRelation(parentId, childId) {
-    var _parentNode$children;
-    if (parentId === null || parentId === undefined) {
-      return;
-    }
-    const parentNode = await this.getNodeById(parentId);
-    (_parentNode$children = parentNode.children) === null || _parentNode$children === void 0 ? void 0 : _parentNode$children.push(childId);
-    await this.saveNode(parentNode);
-  }
-  async push(node, parentId) {
-    node.index = this.nodesCounter++;
-    if (!this.converter.options.instantNodeWriting) {
-      let currentNodePage = this.nodePages[this.nodePages.length - 1];
-      if (currentNodePage.nodes.length === this.nodesPerPage) {
-        currentNodePage = {
-          nodes: []
-        };
-        this.nodePages.push(currentNodePage);
-      }
-      currentNodePage.nodes.push(node);
-    }
-    await this.addChildRelation(parentId, node.index);
-    NodePages.updateResourceInMesh(node);
-    await this.saveNode(node);
-    return node;
-  }
-  async saveNode(node) {
-    if (!this.converter.options.instantNodeWriting) {
-      return;
-    } else {
-      const nodePageIndex = this.getPageIndexByNodeId(node.index);
-      const nodePage = await this.getPageByNodeId(node.index);
-      const {
-        filePath,
-        fileName
-      } = this.getNodePageFileName(nodePageIndex);
-      const nodeToUpdate = await this.getNodeById(node.index, nodePage);
-      if (nodeToUpdate) {
-        NodePages.updateAll(nodeToUpdate, node);
-      } else {
-        nodePage.nodes.push(node);
-      }
-      const nodePageStr = JSON.stringify(nodePage);
-      if (this.converter.options.slpk) {
-        await this.converter.writeQueue.enqueue({
-          archiveKey: `nodePages/${nodePageIndex.toString()}.json.gz`,
-          writePromise: () => this.writeFile(filePath, nodePageStr, fileName, true, this.converter.compressList)
-        }, true);
-      } else {
-        await this.converter.writeQueue.enqueue({
-          writePromise: () => this.writeFile(filePath, nodePageStr)
-        }, true);
-      }
-    }
-  }
-  async saveMetadata() {
-    const metadata = transform({
-      nodeCount: this.nodesCounter
-    }, metadataTemplate());
-    const compress = false;
-    await this.converter.writeQueue.enqueue({
-      archiveKey: 'metadata.json',
-      writePromise: () => this.writeFile(this.converter.layers0Path, JSON.stringify(metadata), 'metadata.json', compress)
+/**
+ * class NodePages - wrapper of nodePages array
+ *
+ * @example
+ * import {writeFile} from './helpers/write-file';
+ *
+ * // create an instance of the class
+ * const nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
+ * ...
+ * // push root node
+ * const parent = await nodePages.push({
+      lodThreshold: HARDCODED_MAX_SCREEN_THRESHOLD_SQ,
+      obb: coordinates.obb,
+      children: []
     });
-  }
-  async save() {
-    if (this.converter.options.instantNodeWriting) {
-      await this.saveMetadata();
-      return;
-    }
-    if (this.converter.options.slpk) {
-      for (const [index, nodePage] of this.nodePages.entries()) {
-        const nodePageStr = JSON.stringify(nodePage);
-        const slpkPath = join(this.converter.layers0Path, 'nodepages');
-        await this.converter.writeQueue.enqueue({
-          archiveKey: `nodePages/${index.toString()}.json.gz`,
-          writePromise: () => this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
-        });
+ * ...
+ * // push node with parent relation
+ * const nodeInPage = {
+      lodThreshold: HARDCODED_MAX_SCREEN_THRESHOLD_SQ,
+      obb: coordinates.obb,
+      children: [],
+      mesh: {
+        geometry: {
+          definition: 0
+        }
       }
-      await this.saveMetadata();
-    } else {
-      for (const [index, nodePage] of this.nodePages.entries()) {
+    };
+ * const node = await this.nodePages.push(nodeInPage, parent.index);
+ * ...
+ * // save all the nodePages in the end of pushing all the nodes
+ * await this.nodePages.save(layers0path);
+ */
+export default class NodePages {
+    nodesPerPage;
+    nodesCounter;
+    writeFile;
+    converter;
+    nodePages;
+    length = 0;
+    /**
+     * @constructs
+     * Create a nodePages instance.
+     * @param writeFileFunc - function to save one nodePage into a file
+     * @param nodesPerPage - length limit for one nodePage. An additional nodePage is created when this limit is met
+     */
+    constructor(writeFileFunc, nodesPerPage, converter) {
+        this.nodesPerPage = nodesPerPage;
+        this.nodesCounter = 0;
+        // @ts-expect-error
+        this.nodePages = [{}];
+        this.nodePages[0].nodes = [];
+        this.writeFile = writeFileFunc;
+        this.converter = converter;
+        this.length = 0;
+    }
+    /**
+     * Setup function to save node pages
+     * @param func - function which should be used to save node pages
+     */
+    useWriteFunction(func) {
+        this.writeFile = func;
+    }
+    /**
+     * Get file path and file name of the node page with the particular id
+     * @param nodePageId - node page id
+     * @returns file path and file name
+     */
+    getNodePageFileName(nodePageId) {
+        let filePath;
+        let fileName;
+        if (this.converter.options.slpk) {
+            filePath = join(this.converter.layers0Path, 'nodepages');
+            fileName = `${nodePageId.toString()}.json`;
+        }
+        else {
+            filePath = join(this.converter.layers0Path, 'nodepages', nodePageId.toString());
+            fileName = 'index.json';
+        }
+        return { filePath, fileName };
+    }
+    /**
+     * Load node page from a file on the disk
+     * @param nodePageId - node page id
+     * @returns - node page data
+     */
+    async loadNodePage(nodePageId) {
+        const { filePath, fileName } = this.getNodePageFileName(nodePageId);
+        const fullName = join(filePath, fileName);
+        if (await isFileExists(fullName)) {
+            console.log(`load ${fullName}.`); // eslint-disable-line
+            return (await openJson(filePath, fileName));
+        }
+        return { nodes: [] };
+    }
+    /**
+     * Get nodepage id by node id
+     * @param id node id
+     * @returns node page id
+     */
+    getPageIndexByNodeId(id) {
+        return Math.floor(id / this.nodesPerPage);
+    }
+    /**
+     * Get node page data by node id
+     * @param id node id
+     * @returns node page data
+     */
+    async getPageByNodeId(id) {
+        const pageIndex = this.getPageIndexByNodeId(id);
+        if (this.converter.options.instantNodeWriting) {
+            return await this.loadNodePage(pageIndex);
+        }
+        return this.nodePages[pageIndex];
+    }
+    /**
+     * Get the node by its end-to-end index
+     * @param id - end-to-end index of the node
+     * @return the node object
+     */
+    async getNodeById(id, nodePage) {
+        const nodeIndex = id % this.nodesPerPage;
+        nodePage = nodePage || (await this.getPageByNodeId(id));
+        return nodePage.nodes[nodeIndex];
+    }
+    /**
+     * Add a child id into the parent node.children array
+     * @param parentId - end-to-end parent node index
+     * @param childId - end-to-end child node index
+     */
+    async addChildRelation(parentId, childId) {
+        if (parentId === null || parentId === undefined) {
+            return;
+        }
+        const parentNode = await this.getNodeById(parentId);
+        parentNode.children?.push(childId);
+        await this.saveNode(parentNode);
+    }
+    /**
+     * Put new node in nodePages array
+     * @param node - node object
+     * @param parentId - index of parent node
+     * @return
+     */
+    async push(node, parentId) {
+        node.index = this.nodesCounter++;
+        if (!this.converter.options.instantNodeWriting) {
+            let currentNodePage = this.nodePages[this.nodePages.length - 1];
+            if (currentNodePage.nodes.length === this.nodesPerPage) {
+                currentNodePage = { nodes: [] };
+                this.nodePages.push(currentNodePage);
+            }
+            currentNodePage.nodes.push(node);
+        }
+        await this.addChildRelation(parentId, node.index);
+        NodePages.updateResourceInMesh(node);
+        await this.saveNode(node);
+        return node;
+    }
+    /**
+     * Save node to the file on the disk
+     * @param node - node data
+     */
+    async saveNode(node) {
+        if (!this.converter.options.instantNodeWriting) {
+            return;
+        }
+        const nodePageIndex = this.getPageIndexByNodeId(node.index);
+        const nodePage = await this.getPageByNodeId(node.index);
+        const { filePath, fileName } = this.getNodePageFileName(nodePageIndex);
+        const nodeToUpdate = await this.getNodeById(node.index, nodePage);
+        if (nodeToUpdate) {
+            NodePages.updateAll(nodeToUpdate, node);
+        }
+        else {
+            nodePage.nodes.push(node);
+        }
         const nodePageStr = JSON.stringify(nodePage);
-        const nodePagePath = join(this.converter.layers0Path, 'nodepages', index.toString());
+        if (this.converter.options.slpk) {
+            await this.converter.writeQueue.enqueue({
+                archiveKey: `nodePages/${nodePageIndex.toString()}.json.gz`,
+                writePromise: () => this.writeFile(filePath, nodePageStr, fileName, true, this.converter.compressList)
+            }, true);
+        }
+        else {
+            await this.converter.writeQueue.enqueue({
+                writePromise: () => this.writeFile(filePath, nodePageStr)
+            }, true);
+        }
+    }
+    /**
+     * Save metadata file (for slpk only)
+     */
+    async saveMetadata() {
+        const metadata = transform({ nodeCount: this.nodesCounter }, metadataTemplate());
+        const compress = false;
         await this.converter.writeQueue.enqueue({
-          writePromise: () => this.writeFile(nodePagePath, nodePageStr)
+            archiveKey: 'metadata.json',
+            writePromise: () => this.writeFile(this.converter.layers0Path, JSON.stringify(metadata), 'metadata.json', compress)
         });
-      }
     }
-  }
-  static updateResourceInMesh(node) {
-    if (node.mesh && isFinite(node.index)) {
-      node.mesh.geometry.resource = node.index;
+    /**
+     * Save all the node pages
+     * Run this method when all nodes is pushed in nodePages
+     */
+    async save() {
+        if (this.converter.options.instantNodeWriting) {
+            await this.saveMetadata();
+            return;
+        }
+        if (this.converter.options.slpk) {
+            for (const [index, nodePage] of this.nodePages.entries()) {
+                const nodePageStr = JSON.stringify(nodePage);
+                const slpkPath = join(this.converter.layers0Path, 'nodepages');
+                await this.converter.writeQueue.enqueue({
+                    archiveKey: `nodePages/${index.toString()}.json.gz`,
+                    writePromise: () => this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
+                });
+            }
+            await this.saveMetadata();
+        }
+        else {
+            for (const [index, nodePage] of this.nodePages.entries()) {
+                const nodePageStr = JSON.stringify(nodePage);
+                const nodePagePath = join(this.converter.layers0Path, 'nodepages', index.toString());
+                await this.converter.writeQueue.enqueue({
+                    writePromise: () => this.writeFile(nodePagePath, nodePageStr)
+                });
+            }
+        }
+    }
+    /**
+     * Update resource index in node.mesh object
+     * @param node - node object
+     */
+    static updateResourceInMesh(node) {
+        if (node.mesh && isFinite(node.index)) {
+            node.mesh.geometry.resource = node.index;
+        }
+    }
+    /**
+     * Update all fields in the node excluding id
+     * @param node - node object
+     * @param data - NodeInPage data to replace original data
+     */
+    static updateAll(node, data) {
+        Object.assign(node, data, { index: node.index });
+        NodePages.updateResourceInMesh(node);
+        return node;
+    }
+    /**
+     * Update material in node.mesh object by node id
+     * @param id - end-to-end index of the node
+     * @param materialId - id from scene layer materialDefinitions
+     */
+    static updateMaterialByNodeId(node, materialId) {
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.material = {
+            definition: materialId,
+            resource: node.index
+        };
+    }
+    /**
+     * Update vertexCount in node.mesh.geometry object by node id
+     * @param id - end-to-end index of the node
+     * @param vertexCount - vertex count for particular node
+     */
+    static updateVertexCountByNodeId(node, vertexCount) {
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.geometry.vertexCount = vertexCount;
+    }
+    /**
+     * Update resource in node.mesh.attribute object by node id
+     * @param node - node object
+     */
+    static updateNodeAttributeByNodeId(node) {
+        if (!node.mesh || !node.index) {
+            return;
+        }
+        node.mesh.attribute.resource = node.index;
+    }
+    /**
+     * Update featureCount in node.mesh.geometry object by node id
+     * @param node - node object
+     * @param featureCount - features count of the node
+     */
+    static updateFeatureCountByNodeId(node, featureCount) {
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.geometry.featureCount = featureCount;
+    }
+    /**
+     * Update texelCountHint in node.mesh.material object by node id
+     * @param node - node object
+     * @param texelCountHint - texelCountHint of particular node
+     */
+    static updateTexelCountHintByNodeId(node, texelCountHint) {
+        if (!node.mesh || !node.mesh.material) {
+            return;
+        }
+        node.mesh.material.texelCountHint = texelCountHint;
     }
-  }
-  static updateAll(node, data) {
-    Object.assign(node, data, {
-      index: node.index
-    });
-    NodePages.updateResourceInMesh(node);
-    return node;
-  }
-  static updateMaterialByNodeId(node, materialId) {
-    if (!node.mesh) {
-      return;
-    }
-    node.mesh.material = {
-      definition: materialId,
-      resource: node.index
-    };
-  }
-  static updateVertexCountByNodeId(node, vertexCount) {
-    if (!node.mesh) {
-      return;
-    }
-    node.mesh.geometry.vertexCount = vertexCount;
-  }
-  static updateNodeAttributeByNodeId(node) {
-    if (!node.mesh || !node.index) {
-      return;
-    }
-    node.mesh.attribute.resource = node.index;
-  }
-  static updateFeatureCountByNodeId(node, featureCount) {
-    if (!node.mesh) {
-      return;
-    }
-    node.mesh.geometry.featureCount = featureCount;
-  }
-  static updateTexelCountHintByNodeId(node, texelCountHint) {
-    if (!node.mesh || !node.mesh.material) {
-      return;
-    }
-    node.mesh.material.texelCountHint = texelCountHint;
-  }
 }
-//# sourceMappingURL=node-pages.js.map

package/dist/i3s-converter/helpers/preprocess-3d-tiles.d.ts

@@ -1,5 +1,5 @@
 import { Tiles3DTileContent } from '@loaders.gl/3d-tiles';
-import { GLTFPrimitiveModeString, PreprocessData } from '../types';
+import { GLTFPrimitiveModeString, PreprocessData } from "../types.js";
 /**
  * glTF primitive modes
  * @see https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#_mesh_primitive_mode

package/dist/i3s-converter/helpers/preprocess-3d-tiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preprocess-3d-tiles.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/preprocess-3d-tiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAC,uBAAuB,EAAE,cAAc,EAAC,MAAM,UAAU,CAAC;AAWjE;;;GAGG;AACH,eAAO,MAAM,oBAAoB,2BAQhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,gBAChB,kBAAkB,GAAG,IAAI,KACrC,QAAQ,cAAc,CAuBxB,CAAC;AAwDF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,YAAa,cAAc,WAAW,cAAc,KAAG,IAUtF,CAAC"}
+{"version":3,"file":"preprocess-3d-tiles.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/preprocess-3d-tiles.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAC,uBAAuB,EAAE,cAAc,EAAC,oBAAiB;AAWjE;;;GAGG;AACH,eAAO,MAAM,oBAAoB,2BAQhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,gBAChB,kBAAkB,GAAG,IAAI,KACrC,QAAQ,cAAc,CAuBxB,CAAC;AAwDF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,YAAa,cAAc,WAAW,cAAc,KAAG,IAUtF,CAAC"}

package/dist/i3s-converter/helpers/preprocess-3d-tiles.js

@@ -2,72 +2,104 @@ import { GLTFPrimitiveModeString } from "../types.js";
 import { EXT_STRUCTURAL_METADATA, GLTFLoader } from '@loaders.gl/gltf';
 import { parse } from '@loaders.gl/core';
 import { EXT_FEATURE_METADATA } from '@loaders.gl/gltf';
-export const GLTF_PRIMITIVE_MODES = [GLTFPrimitiveModeString.POINTS, GLTFPrimitiveModeString.LINES, GLTFPrimitiveModeString.LINE_LOOP, GLTFPrimitiveModeString.LINE_STRIP, GLTFPrimitiveModeString.TRIANGLES, GLTFPrimitiveModeString.TRIANGLE_STRIP, GLTFPrimitiveModeString.TRIANGLE_FAN];
-export const analyzeTileContent = async tileContent => {
-  const defaultResult = {
-    meshTopologyTypes: new Set(),
-    metadataClasses: new Set()
-  };
-  if (!(tileContent !== null && tileContent !== void 0 && tileContent.gltfArrayBuffer)) {
-    return defaultResult;
-  }
-  const gltfData = await parse(tileContent.gltfArrayBuffer, GLTFLoader, {
-    gltf: {
-      normalize: false,
-      loadBuffers: false,
-      loadImages: false,
-      decompressMeshes: false
+/**
+ * glTF primitive modes
+ * @see https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#_mesh_primitive_mode
+ */
+export const GLTF_PRIMITIVE_MODES = [
+    GLTFPrimitiveModeString.POINTS, // 0
+    GLTFPrimitiveModeString.LINES, // 1
+    GLTFPrimitiveModeString.LINE_LOOP, // 2
+    GLTFPrimitiveModeString.LINE_STRIP, // 3
+    GLTFPrimitiveModeString.TRIANGLES, // 4
+    GLTFPrimitiveModeString.TRIANGLE_STRIP, // 5
+    GLTFPrimitiveModeString.TRIANGLE_FAN // 6
+];
+/**
+ * Analyze tile content. This function is used during preprocess stage of
+ * conversion
+ * @param tileContent - 3DTiles tile content ArrayBuffer
+ * @returns
+ */
+export const analyzeTileContent = async (tileContent) => {
+    const defaultResult = {
+        meshTopologyTypes: new Set(),
+        metadataClasses: new Set()
+    };
+    if (!tileContent?.gltfArrayBuffer) {
+        return defaultResult;
     }
-  });
-  const gltf = gltfData.json;
-  if (!gltf) {
-    return defaultResult;
-  }
-  const meshTopologyTypes = getMeshTypesFromGLTF(gltf);
-  const metadataClasses = getMetadataClassesFromGLTF(gltf);
-  return {
-    meshTopologyTypes,
-    metadataClasses
-  };
+    const gltfData = await parse(tileContent.gltfArrayBuffer, GLTFLoader, {
+        gltf: { normalize: false, loadBuffers: false, loadImages: false, decompressMeshes: false }
+    });
+    const gltf = gltfData.json;
+    if (!gltf) {
+        return defaultResult;
+    }
+    const meshTopologyTypes = getMeshTypesFromGLTF(gltf);
+    const metadataClasses = getMetadataClassesFromGLTF(gltf);
+    return {
+        meshTopologyTypes,
+        metadataClasses
+    };
 };
-const getMeshTypesFromGLTF = gltfJson => {
-  const result = new Set();
-  for (const mesh of gltfJson.meshes || []) {
-    for (const primitive of mesh.primitives) {
-      let {
-        mode
-      } = primitive;
-      if (typeof mode !== 'number') {
-        mode = 4;
-      }
-      result.add(GLTF_PRIMITIVE_MODES[mode]);
+/**
+ * Get mesh topology types that the glb content has
+ * @param gltfJson - JSON part of GLB content
+ * @returns array of mesh types found
+ */
+const getMeshTypesFromGLTF = (gltfJson) => {
+    const result = new Set();
+    for (const mesh of gltfJson.meshes || []) {
+        for (const primitive of mesh.primitives) {
+            let { mode } = primitive;
+            if (typeof mode !== 'number') {
+                mode = 4; // Default is 4 - TRIANGLES
+            }
+            result.add(GLTF_PRIMITIVE_MODES[mode]);
+        }
     }
-  }
-  return result;
+    return result;
 };
-const getMetadataClassesFromGLTF = gltfJson => {
-  var _gltfJson$extensions, _gltfJson$extensions$, _gltfJson$extensions$2, _gltfJson$extensions2, _gltfJson$extensions3, _gltfJson$extensions4;
-  const result = new Set();
-  const extFeatureMetadataClasses = (_gltfJson$extensions = gltfJson.extensions) === null || _gltfJson$extensions === void 0 ? void 0 : (_gltfJson$extensions$ = _gltfJson$extensions[EXT_FEATURE_METADATA]) === null || _gltfJson$extensions$ === void 0 ? void 0 : (_gltfJson$extensions$2 = _gltfJson$extensions$.schema) === null || _gltfJson$extensions$2 === void 0 ? void 0 : _gltfJson$extensions$2.classes;
-  if (extFeatureMetadataClasses) {
-    for (const classKey of Object.keys(extFeatureMetadataClasses)) {
-      result.add(classKey);
+/**
+ * Get feature metadata classes from glTF
+ * The tileset might contain multiple metadata classes provided by EXT_feature_metadata and EXT_structural_metadata extensions.
+ * Every class is a set of properties. But I3S can consume only one set of properties.
+ * On the pre-process we collect all classes from the tileset in order to show the prompt to select one class for conversion to I3S.
+ * @param gltfJson - JSON part of GLB content
+ * @returns array of classes
+ */
+const getMetadataClassesFromGLTF = (gltfJson) => {
+    const result = new Set();
+    // Try to parse from EXT_feature_metadata
+    const extFeatureMetadataClasses = gltfJson.extensions?.[EXT_FEATURE_METADATA]?.schema?.classes;
+    if (extFeatureMetadataClasses) {
+        for (const classKey of Object.keys(extFeatureMetadataClasses)) {
+            result.add(classKey);
+        }
     }
-  }
-  const extStructuralMetadataClasses = (_gltfJson$extensions2 = gltfJson.extensions) === null || _gltfJson$extensions2 === void 0 ? void 0 : (_gltfJson$extensions3 = _gltfJson$extensions2[EXT_STRUCTURAL_METADATA]) === null || _gltfJson$extensions3 === void 0 ? void 0 : (_gltfJson$extensions4 = _gltfJson$extensions3.schema) === null || _gltfJson$extensions4 === void 0 ? void 0 : _gltfJson$extensions4.classes;
-  if (extStructuralMetadataClasses) {
-    for (const classKey of Object.keys(extStructuralMetadataClasses)) {
-      result.add(classKey);
+    // Try to parse from EXT_structural_metadata
+    const extStructuralMetadataClasses = gltfJson.extensions?.[EXT_STRUCTURAL_METADATA]?.schema?.classes;
+    if (extStructuralMetadataClasses) {
+        for (const classKey of Object.keys(extStructuralMetadataClasses)) {
+            result.add(classKey);
+        }
     }
-  }
-  return result;
+    return result;
 };
+/**
+ * Merge object2 into object1
+ * @param object1
+ * @param object2
+ * @returns nothing
+ */
 export const mergePreprocessData = (object1, object2) => {
-  for (const type of object2.meshTopologyTypes) {
-    object1.meshTopologyTypes.add(type);
-  }
-  for (const metadataClass of object2.metadataClasses) {
-    object1.metadataClasses.add(metadataClass);
-  }
+    // Merge topology mesh types info
+    for (const type of object2.meshTopologyTypes) {
+        object1.meshTopologyTypes.add(type);
+    }
+    // Merge feature metadata classes
+    for (const metadataClass of object2.metadataClasses) {
+        object1.metadataClasses.add(metadataClass);
+    }
 };
-//# sourceMappingURL=preprocess-3d-tiles.js.map