@loaders.gl/tile-converter 4.1.0-alpha.1 → 4.1.0-alpha.11

package/dist/index.cjs

@@ -257,7 +257,7 @@ var import_json_map_transform8 = __toESM(require("json-map-transform"), 1);
 var import_md52 = __toESM(require("md5"), 1);
 
 // src/i3s-converter/helpers/node-pages.ts
-var import_path3 = require("path");
+var import_path2 = require("path");
 var import_json_map_transform = __toESM(require("json-map-transform"), 1);
 
 // src/i3s-converter/json-templates/metadata.ts
@@ -287,17 +287,11 @@ var METADATA = () => ({
 var import_core = require("@loaders.gl/core");
 var import_loader_utils = require("@loaders.gl/loader-utils");
 var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_path = require("path");
 
 // src/lib/utils/compress-util.ts
 var import_zlib = require("zlib");
-var import_path = require("path");
 var import_fs = require("fs");
-var import_archiver = __toESM(require("archiver"), 1);
-var import_worker_utils = require("@loaders.gl/worker-utils");
-var import_jszip = __toESM(require("jszip"), 1);
-var import_crypto = require("@loaders.gl/crypto");
-var import_crypt = __toESM(require("crypt"), 1);
 function compressFileWithGzip(pathFile) {
   const compressedPathFile = `${pathFile}.gz`;
   const gzip = (0, import_zlib.createGzip)();
@@ -315,42 +309,6 @@ function compressFileWithGzip(pathFile) {
     input.pipe(gzip).pipe(output);
   });
 }
-async function compressWithChildProcess(inputFolder, outputFile, level, inputFiles, sevenZipExe) {
-  if (process.platform === "win32") {
-    await compressWithChildProcessWindows(inputFolder, outputFile, level, inputFiles, sevenZipExe);
-  } else {
-    await compressWithChildProcessUnix(inputFolder, outputFile, level, inputFiles);
-  }
-}
-async function compressWithChildProcessUnix(inputFolder, outputFile, level = 0, inputFiles = ".") {
-  const fullOutputFile = getAbsoluteFilePath(outputFile);
-  const args = [`-${level}`, "-r", fullOutputFile, inputFiles];
-  const childProcess = new import_worker_utils.ChildProcessProxy();
-  await childProcess.start({
-    command: "zip",
-    arguments: args,
-    spawn: {
-      cwd: inputFolder
-    },
-    wait: 0
-  });
-}
-async function compressWithChildProcessWindows(inputFolder, outputFile, level = 0, inputFiles = (0, import_path.join)(".", "*"), sevenZipExe) {
-  if (inputFiles[0] === "@") {
-    inputFiles = `*${inputFiles.substr(1)}`;
-  }
-  const fullOutputFile = getAbsoluteFilePath(outputFile);
-  const args = ["a", "-tzip", `-mx=${level}`, fullOutputFile, inputFiles];
-  const childProcess = new import_worker_utils.ChildProcessProxy();
-  await childProcess.start({
-    command: sevenZipExe,
-    arguments: args,
-    spawn: {
-      cwd: `${inputFolder}`
-    },
-    wait: 0
-  });
-}
 
 // src/lib/utils/file-utils.ts
 async function writeFile(path, data, fileName = "index.json") {
@@ -363,7 +321,7 @@ async function writeFile(path, data, fileName = "index.json") {
     toWriteData = data;
   }
   await import_fs2.promises.mkdir(path, { recursive: true });
-  const pathFile = (0, import_path2.join)(path, fileName);
+  const pathFile = (0, import_path.join)(path, fileName);
   try {
     await import_fs2.promises.writeFile(pathFile, toWriteData);
   } catch (err) {
@@ -395,7 +353,7 @@ async function openJson(path, fileName) {
     let count = 0;
     console.log(`load ${path}/${fileName}.`);
     const intervalId = setInterval(() => {
-      const pathFile = (0, import_path2.join)(path, fileName);
+      const pathFile = (0, import_path.join)(path, fileName);
       (0, import_core.load)(pathFile, import_loader_utils.JSONLoader).then((result) => {
         clearInterval(intervalId);
         resolve(result);
@@ -424,7 +382,7 @@ function removeFile(path) {
   return import_fs2.promises.unlink(path);
 }
 function getAbsoluteFilePath(filePath) {
-  return (0, import_path2.isAbsolute)(filePath) ? filePath : (0, import_path2.join)(process.cwd(), filePath);
+  return (0, import_path.isAbsolute)(filePath) ? filePath : (0, import_path.join)(process.cwd(), filePath);
 }
 
 // src/i3s-converter/helpers/node-pages.ts
@@ -461,10 +419,10 @@ var NodePages = class {
     let filePath;
     let fileName;
     if (this.converter.options.slpk) {
-      filePath = (0, import_path3.join)(this.converter.layers0Path, "nodepages");
+      filePath = (0, import_path2.join)(this.converter.layers0Path, "nodepages");
       fileName = `${nodePageId.toString()}.json`;
     } else {
-      filePath = (0, import_path3.join)(this.converter.layers0Path, "nodepages", nodePageId.toString());
+      filePath = (0, import_path2.join)(this.converter.layers0Path, "nodepages", nodePageId.toString());
       fileName = "index.json";
     }
     return { filePath, fileName };
@@ -476,7 +434,7 @@ var NodePages = class {
    */
   async loadNodePage(nodePageId) {
     const { filePath, fileName } = this.getNodePageFileName(nodePageId);
-    const fullName = (0, import_path3.join)(filePath, fileName);
+    const fullName = (0, import_path2.join)(filePath, fileName);
     if (await isFileExists(fullName)) {
       console.log(`load ${fullName}.`);
       return await openJson(filePath, fileName);
@@ -613,7 +571,7 @@ var NodePages = class {
     if (this.converter.options.slpk) {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
-        const slpkPath = (0, import_path3.join)(this.converter.layers0Path, "nodepages");
+        const slpkPath = (0, import_path2.join)(this.converter.layers0Path, "nodepages");
         await this.converter.writeQueue.enqueue({
           archiveKey: `nodePages/${index.toString()}.json.gz`,
           writePromise: () => this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
@@ -623,7 +581,7 @@ var NodePages = class {
     } else {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
-        const nodePagePath = (0, import_path3.join)(this.converter.layers0Path, "nodepages", index.toString());
+        const nodePagePath = (0, import_path2.join)(this.converter.layers0Path, "nodepages", index.toString());
         await this.converter.writeQueue.enqueue({
           writePromise: () => this.writeFile(nodePagePath, nodePageStr)
         });
@@ -709,7 +667,7 @@ var NodePages = class {
 };
 
 // src/lib/utils/statistic-utills.ts
-var import_path4 = require("path");
+var import_path3 = require("path");
 var import_fs3 = require("fs");
 function timeConverter(time) {
   if (typeof time === "number") {
@@ -750,11 +708,11 @@ async function calculateFilesSize(params) {
   const fullOutputPath = getAbsoluteFilePath(outputPath);
   try {
     if (slpk) {
-      const slpkPath = (0, import_path4.join)(fullOutputPath, `${tilesetName}.slpk`);
+      const slpkPath = (0, import_path3.join)(fullOutputPath, `${tilesetName}.slpk`);
       const stat = await import_fs3.promises.stat(slpkPath);
       return stat.size;
     }
-    const directoryPath = (0, import_path4.join)(fullOutputPath, tilesetName);
+    const directoryPath = (0, import_path3.join)(fullOutputPath, tilesetName);
     const totalSize = await getTotalFilesSize(directoryPath);
     return totalSize;
   } catch (error) {
@@ -766,9 +724,9 @@ async function getTotalFilesSize(dirPath) {
   let totalFileSize = 0;
   const files = await import_fs3.promises.readdir(dirPath);
   for (const file of files) {
-    const fileStat = await import_fs3.promises.stat((0, import_path4.join)(dirPath, file));
+    const fileStat = await import_fs3.promises.stat((0, import_path3.join)(dirPath, file));
     if (fileStat.isDirectory()) {
-      totalFileSize += await getTotalFilesSize((0, import_path4.join)(dirPath, file));
+      totalFileSize += await getTotalFilesSize((0, import_path3.join)(dirPath, file));
     } else {
       totalFileSize += fileStat.size;
     }
@@ -2436,7 +2394,7 @@ function getPropertyTableExtension(tileContent) {
 // src/i3s-converter/helpers/create-scene-server-path.ts
 var import_uuid2 = require("uuid");
 var import_json_map_transform2 = __toESM(require("json-map-transform"), 1);
-var import_path5 = require("path");
+var import_path4 = require("path");
 
 // src/i3s-converter/json-templates/scene-server.ts
 var SCENE_SERVER = () => ({
@@ -2475,7 +2433,7 @@ async function createSceneServerPath(layerName, layers0, rootPath) {
     layers0
   };
   const sceneServer = (0, import_json_map_transform2.default)(sceneServerData, SCENE_SERVER());
-  const nodePagePath = (0, import_path5.join)(rootPath, "SceneServer");
+  const nodePagePath = (0, import_path4.join)(rootPath, "SceneServer");
   await writeFile(nodePagePath, JSON.stringify(sceneServer));
 }
 
@@ -3135,7 +3093,7 @@ function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
 // src/i3s-converter/i3s-converter.ts
 var import_textures = require("@loaders.gl/textures");
 var import_images = require("@loaders.gl/images");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
+var import_worker_utils = require("@loaders.gl/worker-utils");
 
 // src/lib/utils/queue.ts
 var Queue = class extends Array {
@@ -3157,10 +3115,11 @@ var Queue = class extends Array {
 var import_process = __toESM(require("process"), 1);
 var MEMORY_LIMIT = 4 * 1024 * 1024 * 1024;
 var WriteQueue = class extends Queue {
-  constructor(listeningInterval = 2e3, writeConcurrency = 400) {
+  constructor(conversionDump, listeningInterval = 2e3, writeConcurrency = 400) {
     super();
     this.writePromise = null;
     this.fileMap = {};
+    this.conversionDump = conversionDump;
     this.listeningInterval = listeningInterval;
     this.writeConcurrency = writeConcurrency;
   }
@@ -3201,18 +3160,21 @@ var WriteQueue = class extends Queue {
     while (this.length) {
       const promises = [];
       const archiveKeys = [];
+      const changedRecords = [];
       for (let i = 0; i < this.writeConcurrency; i++) {
         const item = this.dequeue();
         if (!item) {
           break;
         }
-        const { archiveKey, writePromise } = item;
+        const { archiveKey, sourceId, outputId, resourceType, writePromise } = item;
         archiveKeys.push(archiveKey);
+        changedRecords.push({ sourceId, outputId, resourceType });
         const promise = writePromise();
         promises.push(promise);
       }
       const writeResults = await Promise.allSettled(promises);
       this.updateFileMap(archiveKeys, writeResults);
+      await this.conversionDump.updateConvertedTilesDump(changedRecords, writeResults);
     }
   }
   updateFileMap(archiveKeys, writeResults) {
@@ -3227,9 +3189,10 @@ var WriteQueue = class extends Queue {
 
 // src/constants.ts
 var BROWSER_ERROR_MESSAGE = "Tile converter does not work in browser, only in node js environment";
+var DUMP_FILE_SUFFIX = ".dump.json";
 
 // src/i3s-converter/helpers/node-index-document.ts
-var import_path6 = require("path");
+var import_path5 = require("path");
 var import_json_map_transform7 = __toESM(require("json-map-transform"), 1);
 var import_uuid3 = require("uuid");
 
@@ -3432,7 +3395,7 @@ var NodeIndexDocument = class {
    * @param node - Node3DIndexDocument object
    */
   async write(node) {
-    const path = (0, import_path6.join)(this.converter.layers0Path, "nodes", this.id);
+    const path = (0, import_path5.join)(this.converter.layers0Path, "nodes", this.id);
     if (this.converter.options.slpk) {
       await this.converter.writeQueue.enqueue(
         {
@@ -3463,7 +3426,7 @@ var NodeIndexDocument = class {
       return this.data;
     }
     const path = this.id;
-    const parentNodePath = (0, import_path6.join)(this.converter.layers0Path, "nodes", path);
+    const parentNodePath = (0, import_path5.join)(this.converter.layers0Path, "nodes", path);
     let parentNodeFileName = "index.json";
     if (this.converter.options.slpk) {
       parentNodeFileName = "3dNodeIndexDocument.json";
@@ -3902,6 +3865,172 @@ var Progress = class {
   }
 };
 
+// src/i3s-converter/i3s-converter.ts
+var import_zip = require("@loaders.gl/zip");
+
+// src/lib/utils/conversion-dump.ts
+var import_path6 = require("path");
+var ConversionDump = class {
+  constructor() {
+    this.tilesConverted = {};
+  }
+  /**
+   * Create a dump file with convertion options
+   * @param options - converter options
+   */
+  async createDumpFile(options) {
+    const {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      outputPath,
+      draco = true,
+      maxDepth,
+      token,
+      generateTextures,
+      generateBoundingVolumes,
+      mergeMaterials: mergeMaterials2 = true,
+      metadataClass,
+      analyze = false
+    } = options;
+    this.options = {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      outputPath,
+      draco,
+      maxDepth,
+      token,
+      generateTextures,
+      generateBoundingVolumes,
+      mergeMaterials: mergeMaterials2,
+      metadataClass,
+      analyze
+    };
+    try {
+      await writeFile(
+        options.outputPath,
+        JSON.stringify({ options: this.options }),
+        `${options.tilesetName}${DUMP_FILE_SUFFIX}`
+      );
+    } catch (error) {
+      console.log("Can't create dump file", error);
+    }
+  }
+  /**
+   * Update conversion status in the dump file
+   */
+  async updateDumpFile() {
+    var _a2;
+    if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
+      try {
+        await writeFile(
+          this.options.outputPath,
+          JSON.stringify({
+            options: this.options,
+            tilesConverted: this.tilesConverted
+          }),
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+        );
+      } catch (error) {
+        console.log("Can't update dump file", error);
+      }
+    }
+  }
+  /**
+   * Delete a dump file
+   */
+  async deleteDumpFile() {
+    var _a2;
+    if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
+      await removeFile(
+        (0, import_path6.join)(this.options.outputPath, `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`)
+      );
+    }
+  }
+  /**
+   * Get record from the tilesConverted Map
+   * @param fileName - source filename
+   * @returns existing object from the tilesConverted Map
+   */
+  getRecord(fileName) {
+    return this.tilesConverted[fileName];
+  }
+  /**
+   * Set a record for the dump file
+   * @param fileName - key - source filename
+   * @param object - value
+   */
+  setRecord(fileName, object) {
+    this.tilesConverted[fileName] = object;
+  }
+  /**
+   * Add a node into the dump file for the source file record
+   * @param fileName - source filename
+   * @param nodeId - nodeId of the node
+   */
+  async addNode(filename, nodeId) {
+    const { nodes } = this.getRecord(filename) || { nodes: [] };
+    nodes.push({ nodeId, done: false, progress: {} });
+    if (nodes.length === 1) {
+      this.setRecord(filename, { nodes });
+    }
+    await this.updateDumpFile();
+  }
+  /**
+   * Update done status object for the writing resources
+   * @param fileName - key - source filename
+   * @param nodeId - nodeId for the source filename
+   * @param resourceType - resource type to update status
+   * @param value - value
+   */
+  updateDoneStatus(filename, nodeId, resourceType, value) {
+    var _a2;
+    const nodeDump = (_a2 = this.tilesConverted[filename]) == null ? void 0 : _a2.nodes.find(
+      (element) => element.nodeId === nodeId
+    );
+    if (nodeDump) {
+      nodeDump.progress[resourceType] = value;
+      if (!value) {
+        nodeDump.done = false;
+      }
+    }
+  }
+  /**
+   * Update dump file according to writing results
+   * @param changedRecords - array of parameters ids for the written resources
+   * @param writeResults - array of writing resource files results
+   */
+  async updateConvertedTilesDump(changedRecords, writeResults) {
+    for (let i = 0; i < changedRecords.length; i++) {
+      if (changedRecords[i] && "value" in writeResults[i]) {
+        const { sourceId, resourceType, outputId } = changedRecords[i];
+        if (!sourceId || !resourceType || !outputId)
+          continue;
+        for (const node of this.tilesConverted[sourceId].nodes) {
+          if (node.nodeId === outputId) {
+            node.progress[resourceType] = true;
+            let done = false;
+            for (const key in node.progress) {
+              done = node.progress[key];
+              if (!done)
+                break;
+            }
+            node.done = done;
+            if (node.done) {
+              node.progress = {};
+            }
+            break;
+          }
+        }
+      }
+    }
+    await this.updateDumpFile();
+  }
+};
+
 // src/i3s-converter/i3s-converter.ts
 var _a;
 var ION_DEFAULT_TOKEN = (_a = import_process3.default.env) == null ? void 0 : _a.IonToken;
@@ -3934,7 +4063,7 @@ var I3SConverter = class {
     this.geoidHeightModel = null;
     this.Loader = import_d_tiles2.Tiles3DLoader;
     this.workerSource = {};
-    this.writeQueue = new WriteQueue();
+    this.writeQueue = new WriteQueue(new ConversionDump());
     this.compressList = null;
     this.preprocessData = {
       meshTopologyTypes: /* @__PURE__ */ new Set(),
@@ -3961,6 +4090,7 @@ var I3SConverter = class {
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
     this.compressList = null;
+    this.conversionDump = new ConversionDump();
   }
   /**
    * Convert a 3d tileset
@@ -4005,6 +4135,8 @@ var I3SConverter = class {
       analyze = false
     } = options;
     this.options = {
+      outputPath,
+      tilesetName,
       maxDepth,
       slpk,
       sevenZipExe,
@@ -4023,7 +4155,7 @@ var I3SConverter = class {
     this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? import_d_tiles2.CesiumIonLoader : import_d_tiles2.Tiles3DLoader;
     this.generateTextures = Boolean(generateTextures);
     this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
-    this.writeQueue = new WriteQueue();
+    this.writeQueue = new WriteQueue(this.conversionDump);
     this.writeQueue.startListening();
     console.log("Loading egm file...");
     this.geoidHeightModel = await (0, import_core9.load)(egmFilePath, PGMLoader);
@@ -4031,6 +4163,7 @@ var I3SConverter = class {
     if (slpk) {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
+    await this.conversionDump.createDumpFile(options);
     try {
       const preloadOptions = await this._fetchPreloadOptions();
       let tilesetUrl = inputUrl;
@@ -4053,7 +4186,7 @@ var I3SConverter = class {
       throw error;
     } finally {
       await this.writeQueue.finalize();
-      const workerFarm = import_worker_utils2.WorkerFarm.getWorkerFarm({});
+      const workerFarm = import_worker_utils.WorkerFarm.getWorkerFarm({});
       workerFarm.destroy();
     }
     return "success";
@@ -4286,16 +4419,14 @@ var I3SConverter = class {
    * @param tilesetPath - Path to save file
    */
   async _createSlpk(tilesetPath) {
+    await this.conversionDump.deleteDumpFile();
     if (this.options.slpk) {
       const slpkTilesetPath = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
       const slpkFileName = `${tilesetPath}.slpk`;
-      await compressWithChildProcess(
-        slpkTilesetPath,
-        slpkFileName,
-        0,
-        ".",
-        this.options.sevenZipExe
-      );
+      await (0, import_zip.createZip)(slpkTilesetPath, slpkFileName, async (fileList) => ({
+        path: "@specialIndexFileHASH128@",
+        file: await (0, import_zip.composeHashFile)(fileList)
+      }));
       try {
         await removeDir(tilesetPath);
       } catch (e) {
@@ -4436,7 +4567,10 @@ var I3SConverter = class {
       const node = await new NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
       nodes.push(node);
       if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.id);
+        if (sourceTile.id) {
+          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index);
+        }
+        await this._writeResources(resources, node.id, sourceTile);
       }
       if (this.validate) {
         this.boundingVolumeWarnings = validateNodeBoundingVolumes(nodeData);
@@ -4560,9 +4694,11 @@ var I3SConverter = class {
    * @param resources.texture - texture image
    * @param resources.sharedResources - shared resource data object
    * @param resources.attributes - feature attributes
+   * @param nodePath - node path
+   * @param sourceTile - source tile (3DTile)
    * @return {Promise<void>}
    */
-  async _writeResources(resources, nodePath) {
+  async _writeResources(resources, nodePath, sourceTile) {
     const {
       geometry: geometryBuffer,
       compressedGeometry,
@@ -4572,10 +4708,36 @@ var I3SConverter = class {
     } = resources;
     const childPath = (0, import_path7.join)(this.layers0Path, "nodes", nodePath);
     const slpkChildPath = (0, import_path7.join)("nodes", nodePath);
-    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
-    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
-    await this._writeTexture(texture, childPath, slpkChildPath);
-    await this._writeAttributes(attributes, childPath, slpkChildPath);
+    await this._writeGeometries(
+      geometryBuffer,
+      compressedGeometry,
+      childPath,
+      slpkChildPath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
+    await this._writeShared(
+      sharedResources,
+      childPath,
+      slpkChildPath,
+      nodePath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
+    await this._writeTexture(
+      texture,
+      childPath,
+      slpkChildPath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
+    await this._writeAttributes(
+      attributes,
+      childPath,
+      slpkChildPath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
   }
   /**
    * Write non-compressed and compressed geometries in files
@@ -4583,30 +4745,46 @@ var I3SConverter = class {
    * @param compressedGeometry - Uint8Array with compressed (draco) geometry
    * @param childPath - a child path to write resources
    * @param slpkChildPath - resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
+  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath, sourceId, nodeId) {
+    this.conversionDump.updateDoneStatus(sourceId, nodeId, "GEOMETRY" /* GEOMETRY */, false);
     if (this.options.slpk) {
       const slpkGeometryPath = (0, import_path7.join)(childPath, "geometries");
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: "GEOMETRY" /* GEOMETRY */,
         writePromise: () => writeFileForSlpk(slpkGeometryPath, geometryBuffer, "0.bin")
       });
     } else {
       const geometryPath = (0, import_path7.join)(childPath, "geometries/0/");
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: "GEOMETRY" /* GEOMETRY */,
         writePromise: () => writeFile(geometryPath, geometryBuffer, "index.bin")
       });
     }
     if (this.options.draco) {
+      this.conversionDump.updateDoneStatus(sourceId, nodeId, "DRACO_GEOMETRY" /* DRACO_GEOMETRY */, false);
       if (this.options.slpk) {
         const slpkCompressedGeometryPath = (0, import_path7.join)(childPath, "geometries");
         await this.writeQueue.enqueue({
           archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
+          sourceId,
+          outputId: nodeId,
+          resourceType: "DRACO_GEOMETRY" /* DRACO_GEOMETRY */,
           writePromise: () => writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, "1.bin")
         });
       } else {
         const compressedGeometryPath = (0, import_path7.join)(childPath, "geometries/1/");
         await this.writeQueue.enqueue({
+          sourceId,
+          outputId: nodeId,
+          resourceType: "DRACO_GEOMETRY" /* DRACO_GEOMETRY */,
           writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, "index.bin")
         });
       }
@@ -4618,23 +4796,34 @@ var I3SConverter = class {
    * @param childPath - a child path to write resources
    * @param slpkChildPath - resource path inside *slpk file
    * @param nodePath - a node path
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
+  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath, sourceId, nodeId) {
     if (!sharedResources) {
       return;
     }
     sharedResources.nodePath = nodePath;
     const sharedData = (0, import_json_map_transform8.default)(sharedResources, SHARED_RESOURCES());
     const sharedDataStr = JSON.stringify(sharedData);
+    this.conversionDump.updateDoneStatus(sourceId, nodeId, "SHARED" /* SHARED */, false);
     if (this.options.slpk) {
       const slpkSharedPath = (0, import_path7.join)(childPath, "shared");
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: "SHARED" /* SHARED */,
         writePromise: () => writeFileForSlpk(slpkSharedPath, sharedDataStr, "sharedResource.json")
       });
     } else {
       const sharedPath = (0, import_path7.join)(childPath, "shared/");
-      await this.writeQueue.enqueue({ writePromise: () => writeFile(sharedPath, sharedDataStr) });
+      await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: "SHARED" /* SHARED */,
+        writePromise: () => writeFile(sharedPath, sharedDataStr)
+      });
     }
   }
   /**
@@ -4642,8 +4831,10 @@ var I3SConverter = class {
    * @param texture - the texture image
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeTexture(texture, childPath, slpkChildPath) {
+  async _writeTexture(texture, childPath, slpkChildPath, sourceId, nodeId) {
     if (texture) {
       const format = this._getFormatByMimeType(texture == null ? void 0 : texture.mimeType);
       const formats = [];
@@ -4652,13 +4843,28 @@ var I3SConverter = class {
         case "jpg":
         case "png": {
           formats.push({ name: "0", format });
-          await this.writeTextureFile(textureData, "0", format, childPath, slpkChildPath);
+          this.conversionDump.updateDoneStatus(
+            sourceId,
+            nodeId,
+            `${"TEXTURE" /* TEXTURE */}/${format}`,
+            false
+          );
+          await this.writeTextureFile(
+            textureData,
+            "0",
+            format,
+            childPath,
+            slpkChildPath,
+            sourceId,
+            nodeId
+          );
           if (this.generateTextures) {
             formats.push({ name: "1", format: "ktx2" });
             const copyArrayBuffer = texture.image.data.subarray();
             const arrayToEncode = new Uint8Array(copyArrayBuffer);
             const ktx2TextureData = (0, import_core9.encode)(
               { ...texture.image, data: arrayToEncode },
+              // @ts-expect-error - Worker encoder typing is still WIP
               import_textures.KTX2BasisWriterWorker,
               {
                 ...import_textures.KTX2BasisWriterWorker.options,
@@ -4671,22 +4877,58 @@ var I3SConverter = class {
                 useLocalLibraries: true
               }
             );
-            await this.writeTextureFile(ktx2TextureData, "1", "ktx2", childPath, slpkChildPath);
+            this.conversionDump.updateDoneStatus(
+              sourceId,
+              nodeId,
+              `${"TEXTURE" /* TEXTURE */}/ktx2`,
+              false
+            );
+            await this.writeTextureFile(
+              ktx2TextureData,
+              "1",
+              "ktx2",
+              childPath,
+              slpkChildPath,
+              sourceId,
+              nodeId
+            );
           }
           break;
         }
         case "ktx2": {
           formats.push({ name: "1", format });
-          await this.writeTextureFile(textureData, "1", format, childPath, slpkChildPath);
+          this.conversionDump.updateDoneStatus(
+            sourceId,
+            nodeId,
+            `${"TEXTURE" /* TEXTURE */}/${format}`,
+            false
+          );
+          await this.writeTextureFile(
+            textureData,
+            "1",
+            format,
+            childPath,
+            slpkChildPath,
+            sourceId,
+            nodeId
+          );
           if (this.generateTextures) {
             formats.push({ name: "0", format: "jpg" });
             const decodedFromKTX2TextureData = (0, import_core9.encode)(texture.image.data[0], import_images.ImageWriter);
+            this.conversionDump.updateDoneStatus(
+              sourceId,
+              nodeId,
+              `${"TEXTURE" /* TEXTURE */}/jpg`,
+              false
+            );
             await this.writeTextureFile(
               decodedFromKTX2TextureData,
               "0",
               "jpg",
               childPath,
-              slpkChildPath
+              slpkChildPath,
+              sourceId,
+              nodeId
             );
           }
         }
@@ -4704,18 +4946,26 @@ var I3SConverter = class {
    * @param format
    * @param childPath
    * @param slpkChildPath
+   * @param sourceId
+   * @param nodeId
    */
-  async writeTextureFile(textureData, name, format, childPath, slpkChildPath) {
+  async writeTextureFile(textureData, name, format, childPath, slpkChildPath, sourceId, nodeId) {
     if (this.options.slpk) {
       const slpkTexturePath = (0, import_path7.join)(childPath, "textures");
       const compress = false;
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${"TEXTURE" /* TEXTURE */}/${format}`,
         writePromise: () => writeFileForSlpk(slpkTexturePath, textureData, `${name}.${format}`, compress)
       });
     } else {
       const texturePath = (0, import_path7.join)(childPath, `textures/${name}/`);
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${"TEXTURE" /* TEXTURE */}/${format}`,
         writePromise: () => writeFile(texturePath, textureData, `index.${format}`)
       });
     }
@@ -4725,22 +4975,36 @@ var I3SConverter = class {
    * @param attributes - feature attributes
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeAttributes(attributes = [], childPath, slpkChildPath) {
+  async _writeAttributes(attributes = [], childPath, slpkChildPath, sourceId, nodeId) {
     if ((attributes == null ? void 0 : attributes.length) && this.attributeMetadataInfo.attributeStorageInfo.length) {
       const minimumLength = attributes.length < this.attributeMetadataInfo.attributeStorageInfo.length ? attributes.length : this.attributeMetadataInfo.attributeStorageInfo.length;
       for (let index = 0; index < minimumLength; index++) {
         const folderName = this.attributeMetadataInfo.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
+        this.conversionDump.updateDoneStatus(
+          sourceId,
+          nodeId,
+          `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
+          false
+        );
         if (this.options.slpk) {
           const slpkAttributesPath = (0, import_path7.join)(childPath, "attributes", folderName);
           await this.writeQueue.enqueue({
             archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
             writePromise: () => writeFileForSlpk(slpkAttributesPath, fileBuffer, "0.bin")
           });
         } else {
           const attributesPath = (0, import_path7.join)(childPath, `attributes/${folderName}/0`);
           await this.writeQueue.enqueue({
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
             writePromise: () => writeFile(attributesPath, fileBuffer, "index.bin")
           });
         }
@@ -4951,7 +5215,7 @@ var TILESET = () => ({
 });
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
-var import_worker_utils3 = require("@loaders.gl/worker-utils");
+var import_worker_utils2 = require("@loaders.gl/worker-utils");
 
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
 var import_core12 = require("@loaders.gl/core");
@@ -4994,6 +5258,9 @@ function normalizeRegions(regions) {
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
 var Z_UP_TO_Y_UP_MATRIX = new import_core13.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
 var scratchVector2 = new import_core13.Vector3();
+var KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
+var METALLIC_FACTOR_DEFAULT = 1;
+var ROUGHNESS_FACTOR_DEFAULT = 1;
 var B3dmConverter = class {
   /**
    * The starter of content conversion
@@ -5023,6 +5290,11 @@ var B3dmConverter = class {
     const { material, attributes, indices: originalIndices, modelMatrix } = tileContent;
     const gltfBuilder = new import_gltf6.GLTFScenegraph();
     const textureIndex = await this._addI3sTextureToGLTF(tileContent, textureFormat, gltfBuilder);
+    const pbrMetallicRoughness = material == null ? void 0 : material.pbrMetallicRoughness;
+    if (pbrMetallicRoughness && (pbrMetallicRoughness.metallicFactor === void 0 || pbrMetallicRoughness.metallicFactor === METALLIC_FACTOR_DEFAULT) && (pbrMetallicRoughness.roughnessFactor === void 0 || pbrMetallicRoughness.roughnessFactor === ROUGHNESS_FACTOR_DEFAULT)) {
+      gltfBuilder.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
+      gltfBuilder.addExtension(KHR_MATERIALS_UNLIT);
+    }
     const pbrMaterialInfo = this._convertI3sMaterialToGLTFMaterial(material, textureIndex);
     const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
     const positions = attributes.positions;
@@ -5352,7 +5624,7 @@ var Tiles3DConverter = class {
     const tileset = (0, import_json_map_transform10.default)({ root: rootTile }, TILESET());
     await writeFile(this.tilesetPath, JSON.stringify(tileset), "tileset.json");
     this._finishConversion({ slpk: false, outputPath, tilesetName });
-    const workerFarm = import_worker_utils3.WorkerFarm.getWorkerFarm({});
+    const workerFarm = import_worker_utils2.WorkerFarm.getWorkerFarm({});
     workerFarm.destroy();
   }
   /**