@loaders.gl/tile-converter 3.2.7 → 3.3.0-alpha.3

package/src/i3s-converter/helpers/geometry-attributes.ts

@@ -47,7 +47,7 @@ function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
 } {
   let rangeIndex = 1;
   let featureIndex = 1;
-  let currentFeatureId = featureIndices[0];
+  let currentFeatureId = getFrequentValue(featureIndices.slice(0, VALUES_PER_VERTEX));
   const faceRangeList: any[] = [];
   const featureIds: any[] = [];
   const uniqueFeatureIds = [currentFeatureId];
@@ -55,20 +55,21 @@ function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
   faceRangeList[0] = 0;
   featureIds[0] = currentFeatureId;
 
-  for (let index = 1; index < featureIndices.length; index++) {
-    if (currentFeatureId !== featureIndices[index]) {
+  for (let index = VALUES_PER_VERTEX; index < featureIndices.length; index += VALUES_PER_VERTEX) {
+    const newFeatureId = getFrequentValue(featureIndices.slice(index, index + VALUES_PER_VERTEX));
+    if (currentFeatureId !== newFeatureId) {
       faceRangeList[rangeIndex] = index / VALUES_PER_VERTEX - 1;
       faceRangeList[rangeIndex + 1] = index / VALUES_PER_VERTEX;
-      featureIds[featureIndex] = featureIndices[index];
+      featureIds[featureIndex] = newFeatureId;
 
-      if (!uniqueFeatureIds.includes(featureIndices[index])) {
-        uniqueFeatureIds.push(featureIndices[index]);
+      if (!uniqueFeatureIds.includes(newFeatureId)) {
+        uniqueFeatureIds.push(newFeatureId);
       }
 
       rangeIndex += 2;
       featureIndex += 1;
     }
-    currentFeatureId = featureIndices[index];
+    currentFeatureId = newFeatureId;
   }
 
   faceRangeList[rangeIndex] = featureIndices.length / VALUES_PER_VERTEX - 1;
@@ -79,6 +80,28 @@ function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
   return {faceRange, featureCount, featureIds};
 }
 
+/**
+ * Find most frequent value to avoid situation where one vertex can be part of multiple features (objects).
+ * @param values
+ */
+function getFrequentValue(values: number[]): number {
+  const map: {[key: number]: number} = {};
+
+  let mostFrequentValue = values[0];
+  let maxCount = 1;
+
+  for (const value of values) {
+    // Save item and it's frequency count to the map.
+    map[value] = (map[value] || 0) + 1;
+    // Find max count of frequency.
+    maxCount = maxCount > map[value] ? maxCount : map[value];
+    // Find the most frequent value.
+    mostFrequentValue = maxCount > map[value] ? mostFrequentValue : value;
+  }
+
+  return mostFrequentValue;
+}
+
 /**
  * Generate list of attribute object grouped by feature ids.
  * @param  attributes

package/src/i3s-converter/helpers/geometry-converter.ts

@@ -1,8 +1,13 @@
+import type {Image, MeshPrimitive} from 'modules/gltf/src/lib/types/gltf-postprocessed-schema';
+import type {B3DMContent, FeatureTableJson} from '@loaders.gl/3d-tiles';
+import type {GLTF_EXT_feature_metadata} from '@loaders.gl/gltf';
+
 import {Vector3, Matrix4, Vector4} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 
 import {DracoWriterWorker} from '@loaders.gl/draco';
 import {assert, encode} from '@loaders.gl/core';
+import {Tile3D} from '@loaders.gl/tiles';
 import {concatenateArrayBuffers, concatenateTypedArrays} from '@loaders.gl/loader-utils';
 import md5 from 'md5';
 import {generateAttributes} from './geometry-attributes';
@@ -13,7 +18,6 @@ import {
   I3SMaterialWithTexture,
   SharedResourcesArrays
 } from '../types';
-import {B3DMContent} from '@loaders.gl/3d-tiles';
 import {GLTFMaterialPostprocessed, GLTFNodePostprocessed} from '@loaders.gl/gltf';
 import {
   AttributeStorageInfo,
@@ -30,6 +34,8 @@ import {
 } from 'modules/gltf/src/lib/types/gltf-types';
 import {B3DMAttributesData /*transformI3SAttributesOnWorker */} from '../../i3s-attributes-worker';
 import {prepareDataForAttributesConversion} from './gltf-attributes';
+import {handleBatchIdsExtensions} from './batch-ids-extensions';
+import {checkPropertiesLength, flattenPropertyTableByFeatureIds} from './feature-attributes';
 
 // Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/pbrMetallicRoughness.cmn.md
 const DEFAULT_ROUGHNESS_FACTOR = 1;
@@ -50,6 +56,9 @@ const OBJECT_ID_TYPE = 'Oid32';
  */
 const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
 
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+const EXT_MESH_FEATURES = 'EXT_mesh_features';
+
 let scratchVector = new Vector3();
 
 /**
@@ -67,6 +76,7 @@ let scratchVector = new Vector3();
 export default async function convertB3dmToI3sGeometry(
   tileContent: B3DMContent,
   nodeId: number,
+  propertyTable: FeatureTableJson | null,
   featuresHashArray: string[],
   attributeStorageInfo: AttributeStorageInfo[] | undefined,
   draco: boolean,
@@ -128,6 +138,7 @@ export default async function convertB3dmToI3sGeometry(
         tileContent,
         nodeId: nodesCounter,
         featuresHashArray,
+        propertyTable,
         attributeStorageInfo,
         draco,
         workerSource
@@ -191,6 +202,7 @@ async function _makeNodeResources({
   tileContent,
   nodeId,
   featuresHashArray,
+  propertyTable,
   attributeStorageInfo,
   draco,
   workerSource
@@ -201,6 +213,7 @@ async function _makeNodeResources({
   tileContent: B3DMContent;
   nodeId: number;
   featuresHashArray: string[];
+  propertyTable: FeatureTableJson | null;
   attributeStorageInfo?: AttributeStorageInfo[];
   draco: boolean;
   workerSource: {[key: string]: string};
@@ -250,11 +263,15 @@ async function _makeNodeResources({
       )
     : null;
 
-  const attributes = convertBatchTableToAttributeBuffers(
-    tileContent.batchTableJson,
-    featureIds,
-    attributeStorageInfo
-  );
+  let attributes: ArrayBuffer[] = [];
+
+  if (attributeStorageInfo && propertyTable) {
+    attributes = convertPropertyTableToAttributeBuffers(
+      featureIds,
+      propertyTable,
+      attributeStorageInfo
+    );
+  }
 
   return {
     geometry: fileBuffer,
@@ -407,9 +424,12 @@ function convertNode(
   const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
 
   const mesh = node.mesh;
+  const images = node.images;
+
   if (mesh) {
     convertMesh(
       mesh,
+      images,
       cartographicOrigin,
       cartesianModelMatrix,
       attributesMap,
@@ -441,6 +461,7 @@ function convertNode(
  */
 function convertMesh(
   mesh: GLTFMeshPostprocessed,
+  images: Image[],
   cartographicOrigin: Vector3,
   cartesianModelMatrix: Matrix4,
   attributesMap: Map<string, ConvertedAttributes>,
@@ -498,7 +519,7 @@ function convertMesh(
 
     outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
     outputAttributes.featureIndicesGroups.push(
-      flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices?.value)
+      flattenBatchIds(getBatchIds(attributes, primitive, images), primitive.indices?.value)
     );
   }
 }
@@ -665,14 +686,23 @@ function flattenBatchIds(batchedIds: number[], indices: Uint8Array): number[] {
 }
 
 /**
- * Return batchIds based on possible attribute names for different kind of maps.
- * @param attributes - the gltf primitive attributes
- * @returns batch ids attribute
+ * Get batchIds for featureIds creation
+ * @param attributes
+ * @param primitive
+ * @param textures
  */
-function getBatchIdsByAttributeName(attributes: {
-  [key: string]: GLTFAccessorPostprocessed;
-}): number[] {
-  let batchIds: number[] = [];
+function getBatchIds(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  primitive: MeshPrimitive,
+  images: Image[]
+): number[] {
+  const batchIds: number[] = handleBatchIdsExtensions(attributes, primitive, images);
+
+  if (batchIds.length) {
+    return batchIds;
+  }
 
   for (let index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
     const possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
@@ -680,12 +710,11 @@ function getBatchIdsByAttributeName(attributes: {
       attributes[possibleBatchIdAttributeName] &&
       attributes[possibleBatchIdAttributeName].value
     ) {
-      batchIds = attributes[possibleBatchIdAttributeName].value;
-      break;
+      return attributes[possibleBatchIdAttributeName].value;
     }
   }
 
-  return batchIds;
+  return [];
 }
 
 /**
@@ -1036,49 +1065,66 @@ function replaceIndicesByUnique(indicesArray, featureMap) {
 }
 
 /**
- * Convert batch table data to attribute buffers.
- * @param {Object} batchTable - table with metadata for particular feature.
+ * Convert property table data to attribute buffers.
+ * @param {Object} propertyTable - table with metadata for particular feature.
  * @param {Array} featureIds
  * @param {Array} attributeStorageInfo
  * @returns {Array} - Array of file buffers.
  */
-function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeStorageInfo) {
+function convertPropertyTableToAttributeBuffers(
+  featureIds: number[],
+  propertyTable: FeatureTableJson,
+  attributeStorageInfo: AttributeStorageInfo[]
+) {
   const attributeBuffers: ArrayBuffer[] = [];
 
-  if (batchTable) {
-    const batchTableWithFeatureIds = {
-      OBJECTID: featureIds,
-      ...batchTable
-    };
+  const needFlattenPropertyTable = checkPropertiesLength(featureIds, propertyTable);
+  const properties = needFlattenPropertyTable
+    ? flattenPropertyTableByFeatureIds(featureIds, propertyTable)
+    : propertyTable;
 
-    for (const key in batchTableWithFeatureIds) {
-      const type = getAttributeType(key, attributeStorageInfo);
-
-      let attributeBuffer: ArrayBuffer | null = null;
-
-      switch (type) {
-        case OBJECT_ID_TYPE:
-        case SHORT_INT_TYPE:
-          attributeBuffer = generateShortIntegerAttributeBuffer(batchTableWithFeatureIds[key]);
-          break;
-        case DOUBLE_TYPE:
-          attributeBuffer = generateDoubleAttributeBuffer(batchTableWithFeatureIds[key]);
-          break;
-        case STRING_TYPE:
-          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
-          break;
-        default:
-          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
-      }
+  const propertyTableWithObjectIds = {
+    OBJECTID: featureIds,
+    ...properties
+  };
 
-      if (attributeBuffer) {
-        attributeBuffers.push(attributeBuffer);
-      }
-    }
+  for (const propertyName in propertyTableWithObjectIds) {
+    const type = getAttributeType(propertyName, attributeStorageInfo);
+    const value = propertyTableWithObjectIds[propertyName];
+    const attributeBuffer = generateAttributeBuffer(type, value);
+
+    attributeBuffers.push(attributeBuffer);
   }
 
   return attributeBuffers;
 }
+
+/**
+ * Generates attribute buffer based on attribute type
+ * @param type
+ * @param value
+ */
+function generateAttributeBuffer(type: string, value: any): ArrayBuffer {
+  let attributeBuffer: ArrayBuffer;
+
+  switch (type) {
+    case OBJECT_ID_TYPE:
+    case SHORT_INT_TYPE:
+      attributeBuffer = generateShortIntegerAttributeBuffer(value);
+      break;
+    case DOUBLE_TYPE:
+      attributeBuffer = generateDoubleAttributeBuffer(value);
+      break;
+    case STRING_TYPE:
+      attributeBuffer = generateStringAttributeBuffer(value);
+      break;
+    default:
+      attributeBuffer = generateStringAttributeBuffer(value);
+  }
+
+  return attributeBuffer;
+}
+
 /**
  * Return attribute type.
  * @param {String} key
@@ -1242,3 +1288,96 @@ function generateFeatureIndexAttribute(featureIndex, faceRange) {
 
   return orderedFeatureIndices;
 }
+
+/**
+ * Find property table in tile
+ * For example it can be batchTable for b3dm files or property table in gLTF extension.
+ * @param sourceTile
+ */
+export function getPropertyTable(sourceTile: Tile3D): FeatureTableJson | null {
+  const batchTableJson = sourceTile?.content?.batchTableJson;
+
+  if (batchTableJson) {
+    return batchTableJson;
+  }
+
+  const {extensionName, extension} = getPropertyTableExtension(sourceTile);
+
+  switch (extensionName) {
+    case EXT_MESH_FEATURES: {
+      console.warn('The I3S converter does not yet support the EXT_mesh_features extension');
+      return null;
+    }
+    case EXT_FEATURE_METADATA: {
+      return getPropertyTableFromExtFeatureMetadata(extension);
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * Check extensions which can be with property table inside.
+ * @param sourceTile
+ */
+function getPropertyTableExtension(sourceTile: Tile3D) {
+  const extensionsWithPropertyTables = [EXT_FEATURE_METADATA, EXT_MESH_FEATURES];
+  const extensionsUsed = sourceTile?.content?.gltf?.extensionsUsed;
+
+  if (!extensionsUsed) {
+    return {extensionName: null, extension: null};
+  }
+
+  let extensionName: string = '';
+
+  for (const extensionItem of sourceTile?.content?.gltf?.extensionsUsed) {
+    if (extensionsWithPropertyTables.includes(extensionItem)) {
+      extensionName = extensionItem;
+      break;
+    }
+  }
+
+  const extension = sourceTile?.content?.gltf?.extensions?.[extensionName];
+
+  return {extensionName, extension};
+}
+
+/**
+ * Handle EXT_feature_metadata to get property table
+ * @param extension
+ * TODO add EXT_feature_metadata feature textures support.
+ */
+function getPropertyTableFromExtFeatureMetadata(
+  extension: GLTF_EXT_feature_metadata
+): FeatureTableJson | null {
+  if (extension?.featureTextures) {
+    console.warn(
+      'The I3S converter does not yet support the EXT_feature_metadata feature textures'
+    );
+    return null;
+  }
+
+  if (extension?.featureTables) {
+    /**
+     * 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 firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
+
+    if (firstFeatureTableName) {
+      const featureTable = extension?.featureTables[firstFeatureTableName];
+      const propertyTable = {};
+
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
+
+      return propertyTable;
+    }
+  }
+
+  console.warn("The I3S converter couldn't handle EXT_feature_metadata extension");
+  return null;
+}

package/src/i3s-converter/helpers/gltf-attributes.ts

@@ -35,6 +35,20 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
     tileContent.gltf?.nodes ||
     [];
 
+  const images =
+    tileContent.gltf?.images?.map((imageObject) => {
+      // Need data only for uncompressed images because we can't get batchIds from compressed textures.
+      const data = imageObject?.image?.compressed ? null : imageObject?.image?.data.subarray();
+      return {
+        data,
+        compressed: Boolean(imageObject?.image?.compressed),
+        height: imageObject.image.height,
+        width: imageObject.image.width,
+        components: imageObject.image.components,
+        mimeType: imageObject.mimeType
+      };
+    }) || [];
+
   const prepearedNodes = nodes.map((node) => {
     if (!node.mesh) {
       return node;
@@ -42,6 +56,7 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
 
     return {
       ...node,
+      images,
       mesh: {
         ...node.mesh,
         primitives: node.mesh?.primitives.map((primitive) => ({

package/src/i3s-converter/i3s-converter.ts

@@ -1,5 +1,5 @@
 import type {Tile3D, Tileset3DProps} from '@loaders.gl/tiles';
-import type {BatchTableJson, B3DMContent} from '@loaders.gl/3d-tiles';
+import type {FeatureTableJson} from '@loaders.gl/3d-tiles';
 import type {WriteQueueItem} from '../lib/utils/write-queue';
 import type {
   AttributeStorageInfo,
@@ -34,7 +34,7 @@ import {
   // addFileToZip
 } from '../lib/utils/compress-util';
 import {calculateFilesSize, timeConverter} from '../lib/utils/statistic-utills';
-import convertB3dmToI3sGeometry from './helpers/geometry-converter';
+import convertB3dmToI3sGeometry, {getPropertyTable} from './helpers/geometry-converter';
 import {
   createBoundingVolumes,
   convertBoundingVolumeToI3SFullExtent
@@ -572,13 +572,13 @@ export default class I3SConverter {
 
     let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel!);
 
-    const batchTable = sourceTile?.content?.batchTableJson;
+    const propertyTable = getPropertyTable(sourceTile);
 
-    if (batchTable) {
-      this._convertAttributeStorageInfo(sourceTile.content);
+    if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
+      this._convertPropertyTableToNodeAttributes(propertyTable);
     }
 
-    const resourcesData = await this._convertResources(sourceTile);
+    const resourcesData = await this._convertResources(sourceTile, propertyTable);
 
     const nodes: Node3DIndexDocument[] = [];
     const nodesInPage: NodeInPage[] = [];
@@ -648,20 +648,6 @@ export default class I3SConverter {
     return nodes;
   }
 
-  /**
-   * Convert attributesStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
-   * from B3DM batch table
-   * @param sourceTileContent - tile content of 3DTile
-   * @return {void}
-   */
-  private _convertAttributeStorageInfo(sourceTileContent: B3DMContent): void {
-    // In legacy b3dm files sometimes sourceTileContent is null.
-    const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
-    if (batchTable && !this.layers0?.attributeStorageInfo?.length) {
-      this._convertBatchTableInfoToNodeAttributes(batchTable);
-    }
-  }
-
   /**
    * Convert tile to one or more I3S nodes
    * @param sourceTile - source tile (3DTile)
@@ -674,13 +660,17 @@ export default class I3SConverter {
    * result.attributes - feature attributes
    * result.featureCount - number of features
    */
-  private async _convertResources(sourceTile: TileHeader): Promise<I3SConvertedResources[] | null> {
+  private async _convertResources(
+    sourceTile: TileHeader,
+    propertyTable: FeatureTableJson | null
+  ): Promise<I3SConvertedResources[] | null> {
     if (!this.isContentSupported(sourceTile)) {
       return null;
     }
     const resourcesData = await convertB3dmToI3sGeometry(
       sourceTile.content,
       Number(this.nodePages.nodesCounter),
+      propertyTable,
       this.featuresHashArray,
       this.layers0?.attributeStorageInfo,
       this.options.draco,
@@ -938,12 +928,19 @@ export default class I3SConverter {
 
           if (this.generateTextures) {
             formats.push({name: '1', format: 'ktx2'});
-            const ktx2TextureData = encode(texture.image, KTX2BasisWriterWorker, {
-              ...KTX2BasisWriterWorker.options,
-              source: this.workerSource.ktx2,
-              reuseWorkers: true,
-              _nodeWorkers: true
-            });
+            // For Node.js texture.image.data is type of Buffer
+            const copyArrayBuffer = texture.image.data.subarray();
+            const arrayToEncode = new Uint8Array(copyArrayBuffer);
+            const ktx2TextureData = encode(
+              {...texture.image, data: arrayToEncode},
+              KTX2BasisWriterWorker,
+              {
+                ...KTX2BasisWriterWorker.options,
+                source: this.workerSource.ktx2,
+                reuseWorkers: true,
+                _nodeWorkers: true
+              }
+            );
 
             await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
           }
@@ -1073,7 +1070,7 @@ export default class I3SConverter {
   /**
    * Generate storage attribute for map segmentation.
    * @param attributeIndex - order index of attribute (f_0, f_1 ...).
-   * @param key - attribute key from batch table.\
+   * @param key - attribute key from propertyTable.
    * @param attributeType - attribute type.
    * @return Updated storageAttribute.
    */
@@ -1112,7 +1109,7 @@ export default class I3SConverter {
   /**
    * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
    * @param key - attribute's key
-   * @param attribute - attribute's type in batchTable
+   * @param attribute - attribute's type in propertyTable
    */
   private getAttributeType(key: string, attribute: string): string {
     if (key === OBJECT_ID_TYPE) {
@@ -1180,24 +1177,24 @@ export default class I3SConverter {
   }
 
   /**
-   * Do conversion of 3DTiles batch table to I3s node attributes.
-   * @param batchTable - Table with layer meta data.
+   * Do conversion of 3DTiles property table to I3s node attributes.
+   * @param propertyTable - Table with layer meta data.
    */
-  private _convertBatchTableInfoToNodeAttributes(batchTable: BatchTableJson): void {
+  private _convertPropertyTableToNodeAttributes(propertyTable: FeatureTableJson): void {
     let attributeIndex = 0;
-    const batchTableWithObjectId = {
+    const propertyTableWithObjectId = {
       OBJECTID: [0],
-      ...batchTable
+      ...propertyTable
     };
 
-    for (const key in batchTableWithObjectId) {
-      const firstAttribute = batchTableWithObjectId[key][0];
+    for (const key in propertyTableWithObjectId) {
+      const firstAttribute = propertyTableWithObjectId[key][0];
       const attributeType = this.getAttributeType(key, firstAttribute);
 
       const storageAttribute = this._createdStorageAttribute(attributeIndex, key, attributeType);
       const fieldAttributeType = this._getFieldAttributeType(attributeType);
       const fieldAttribute = this._createFieldAttribute(key, fieldAttributeType);
-      const popupInfo = this._createPopupInfo(batchTableWithObjectId);
+      const popupInfo = this._createPopupInfo(propertyTableWithObjectId);
 
       this.layers0!.attributeStorageInfo!.push(storageAttribute);
       this.layers0!.fields!.push(fieldAttribute);
@@ -1209,7 +1206,7 @@ export default class I3SConverter {
   }
 
   /**
-   * Find and return attribute type based on key form Batch table.
+   * Find and return attribute type based on key form propertyTable.
    * @param attributeType
    */
   private _getFieldAttributeType(attributeType: Attribute): ESRIField {
@@ -1229,10 +1226,10 @@ export default class I3SConverter {
 
   /**
    * Generate popup info to show metadata on the map.
-   * @param batchTable - Batch table data with OBJECTID.
+   * @param propertyTable - table data with OBJECTID.
    * @return data for correct rendering of popup.
    */
-  private _createPopupInfo(batchTable: BatchTableJson): PopupInfo {
+  private _createPopupInfo(propertyTable: FeatureTableJson): PopupInfo {
     const title = '{OBJECTID}';
     const mediaInfos = [];
     const fieldInfos: FieldInfo[] = [];
@@ -1242,7 +1239,7 @@ export default class I3SConverter {
     }[] = [];
     const expressionInfos = [];
 
-    for (const key in batchTable) {
+    for (const key in propertyTable) {
       fieldInfos.push({
         fieldName: key,
         visible: true,

package/src/lib/utils/write-queue.ts

@@ -69,19 +69,21 @@ export default class WriteQueue<T extends WriteQueueItem> extends Queue<T> {
         archiveKeys.push(archiveKey);
         promises.push(writePromise);
       }
-      const writeResults = await Promise.all(promises);
+      const writeResults = await Promise.allSettled(promises);
       this.updateFileMap(archiveKeys, writeResults);
     }
     this.writePromise = null;
   }
 
-  private updateFileMap(archiveKeys: (string | undefined)[], writeResults: string[]) {
+  private updateFileMap(
+    archiveKeys: (string | undefined)[],
+    writeResults: PromiseSettledResult<string>[]
+  ) {
     for (let i = 0; i < archiveKeys.length; i++) {
       const archiveKey = archiveKeys[i];
-      if (!archiveKey) {
-        continue;
+      if (archiveKey && 'value' in writeResults[i]) {
+        this.fileMap[archiveKey] = (writeResults[i] as PromiseFulfilledResult<string>).value;
       }
-      this.fileMap[archiveKey] = writeResults[i];
     }
   }
 }