@loaders.gl/tile-converter 4.2.0-alpha.1 → 4.2.0-alpha.3

package/dist/index.cjs

@@ -261,7 +261,7 @@ var import_core9 = require("@loaders.gl/core");
 var import_d_tiles2 = require("@loaders.gl/3d-tiles");
 var import_path7 = require("path");
 var import_uuid4 = require("uuid");
-var import_process3 = __toESM(require("process"), 1);
+var import_process4 = __toESM(require("process"), 1);
 var import_json_map_transform8 = __toESM(require("json-map-transform"), 1);
 var import_md52 = __toESM(require("md5"), 1);
 
@@ -393,6 +393,13 @@ function removeFile(path) {
 function getAbsoluteFilePath(filePath) {
   return (0, import_path.isAbsolute)(filePath) ? filePath : (0, import_path.join)(process.cwd(), filePath);
 }
+async function renameFile(oldPath, newPath) {
+  try {
+    await import_fs2.promises.rename(oldPath, newPath);
+  } catch (err) {
+    console.log("Can't rename file", err);
+  }
+}
 
 // src/i3s-converter/helpers/node-pages.ts
 var NodePages = class {
@@ -3559,6 +3566,8 @@ var NodeIndexDocument = class {
 // src/i3s-converter/helpers/load-3d-tiles.ts
 var import_d_tiles = require("@loaders.gl/3d-tiles");
 var import_core7 = require("@loaders.gl/core");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_zip = require("@loaders.gl/zip");
 var loadNestedTileset = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
   const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
@@ -3616,7 +3625,10 @@ async function loadFromArchive(url, loader, loadOptions) {
   }
   if (filename) {
     const tz3Path = `${tz3UrlParts[0]}.3tz`;
-    const fileSystem = new import_d_tiles.Tiles3DArchiveFileSystem(tz3Path);
+    const fileProvider = new import_loader_utils4.FileHandleFile(tz3Path);
+    const hashTable = await loadHashTable(fileProvider);
+    const archive = new import_d_tiles.Tiles3DArchive(fileProvider, hashTable, tz3Path);
+    const fileSystem = new import_zip.ZipFileSystem(archive);
     const content = await (0, import_core7.load)(filename, loader, {
       ...loadOptions,
       fetch: fileSystem.fetch.bind(fileSystem)
@@ -3629,6 +3641,27 @@ async function loadFromArchive(url, loader, loadOptions) {
 function isNestedTileset(tile) {
   return (tile == null ? void 0 : tile.type) === "json" || (tile == null ? void 0 : tile.type) === "3tz";
 }
+async function loadHashTable(fileProvider) {
+  let hashTable;
+  const hashCDOffset = await (0, import_zip.searchFromTheEnd)(fileProvider, import_zip.CD_HEADER_SIGNATURE);
+  const cdFileHeader = await (0, import_zip.parseZipCDFileHeader)(hashCDOffset, fileProvider);
+  if ((cdFileHeader == null ? void 0 : cdFileHeader.fileName) === "@3dtilesIndex1@") {
+    const localFileHeader = await (0, import_zip.parseZipLocalFileHeader)(
+      cdFileHeader.localHeaderOffset,
+      fileProvider
+    );
+    if (!localFileHeader) {
+      throw new Error("corrupted 3tz");
+    }
+    const fileDataOffset = localFileHeader.fileDataOffset;
+    const hashFile = await fileProvider.slice(
+      fileDataOffset,
+      fileDataOffset + localFileHeader.compressedSize
+    );
+    hashTable = (0, import_zip.parseHashTable)(hashFile);
+  }
+  return hashTable;
+}
 
 // src/i3s-converter/i3s-converter.ts
 var import_core10 = require("@math.gl/core");
@@ -3875,17 +3908,306 @@ var Progress = class {
 };
 
 // src/i3s-converter/i3s-converter.ts
-var import_zip = require("@loaders.gl/zip");
+var import_zip2 = require("@loaders.gl/zip");
 
 // src/lib/utils/conversion-dump.ts
 var import_util = require("util");
 var import_path6 = require("path");
+var import_process3 = __toESM(require("process"), 1);
+var import_ajv = __toESM(require("ajv"), 1);
+
+// src/lib/json-schemas/conversion-dump-json-schema.ts
+var dumpJsonSchema = {
+  type: "object",
+  properties: {
+    options: {
+      type: "object",
+      properties: {
+        inputUrl: { type: "string" },
+        outputPath: { type: "string" },
+        tilesetName: { type: "string" },
+        maxDepth: { type: "number" },
+        slpk: { type: "boolean" },
+        egmFilePath: { type: "string" },
+        token: { type: "string" },
+        draco: { type: "boolean" },
+        mergeMaterials: { type: "boolean" },
+        generateTextures: { type: "boolean" },
+        generateBoundingVolumes: { type: "boolean" },
+        metadataClass: { type: "string" },
+        analyze: { type: "boolean" }
+      },
+      required: ["inputUrl", "outputPath", "tilesetName"]
+    },
+    tilesConverted: {
+      type: "object",
+      patternProperties: {
+        ".*": {
+          type: "object",
+          properties: {
+            nodes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  nodeId: { type: ["number", "string"] },
+                  done: { type: "boolean" },
+                  progress: { type: "object", patternProperties: { ".*": { type: "boolean" } } },
+                  dumpMetadata: {
+                    type: "object",
+                    properties: {
+                      boundingVolumes: {
+                        type: ["object", "null"],
+                        properties: {
+                          mbs: {
+                            type: "array",
+                            minItems: 4,
+                            maxItems: 4,
+                            items: { type: "number" }
+                          },
+                          obb: {
+                            type: "object",
+                            properties: {
+                              center: {
+                                type: "array",
+                                minItems: 3,
+                                maxItems: 3,
+                                items: { type: "number" }
+                              },
+                              halfSize: {
+                                type: "array",
+                                minItems: 3,
+                                maxItems: 3,
+                                items: { type: "number" }
+                              },
+                              quaternion: {
+                                type: "array",
+                                minItems: 4,
+                                maxItems: 4,
+                                items: { type: "number" }
+                              }
+                            },
+                            required: ["center", "halfSize", "quaternion"]
+                          }
+                        },
+                        required: ["mbs", "obb"]
+                      },
+                      attributesCount: { type: "number" },
+                      featureCount: { type: "number" },
+                      geometry: { type: "boolean" },
+                      hasUvRegions: { type: "boolean" },
+                      materialId: { type: "number" },
+                      texelCountHint: { type: "number" },
+                      vertexCount: { type: "number" }
+                    },
+                    required: [
+                      "boundingVolumes",
+                      "featureCount",
+                      "geometry",
+                      "hasUvRegions",
+                      "materialId",
+                      "vertexCount"
+                    ]
+                  }
+                },
+                required: ["nodeId", "done"]
+              }
+            }
+          },
+          required: ["nodes"]
+        }
+      }
+    },
+    textureSetDefinitions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          formats: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                format: { enum: ["jpg", "png", "ktx-etc2", "dds", "ktx2"] }
+              },
+              required: ["name", "format"]
+            }
+          },
+          atlas: { type: "boolean" }
+        },
+        required: ["formats"]
+      }
+    },
+    attributeMetadataInfo: {
+      type: "object",
+      properties: {
+        attributeStorageInfo: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              key: { type: "string" },
+              name: { type: "string" },
+              header: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: { property: { type: "string" }, valueType: { type: "string" } },
+                  required: ["property", "valueType"]
+                }
+              },
+              ordering: { type: "array", items: { type: "string" } },
+              attributeValues: { $ref: "#/$defs/AttributeValue" },
+              attributeByteCounts: { $ref: "#/$defs/AttributeValue" },
+              objectIds: { $ref: "#/$defs/AttributeValue" }
+            },
+            required: ["key", "name", "header"]
+          }
+        },
+        fields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { $ref: "#/$defs/ESRIField" },
+              alias: { type: "string" },
+              domain: { $ref: "#/$defs/Domain" }
+            },
+            required: ["name", "type"]
+          }
+        },
+        popupInfo: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            description: { type: "string" },
+            expressionInfos: { type: "array", items: {} },
+            fieldInfos: { type: "array", items: { $ref: "#/$defs/FieldInfo" } },
+            mediaInfos: { type: "array", items: {} },
+            popupElements: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  text: { type: "string" },
+                  type: { type: "string" },
+                  fieldInfos: { type: "array", items: { $ref: "#/$defs/FieldInfo" } }
+                }
+              }
+            }
+          }
+        }
+      },
+      required: ["attributeStorageInfo", "fields"]
+    },
+    materialDefinitions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          pbrMetallicRoughness: {
+            type: "object",
+            properties: {
+              baseColorFactor: {
+                type: "array",
+                minItems: 4,
+                maxItems: 4,
+                items: { type: "number" }
+              },
+              baseColorTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+              metallicFactor: { type: "number" },
+              roughnessFactor: { type: "number" },
+              metallicRoughnessTexture: { $ref: "#/$defs/I3SMaterialTexture" }
+            },
+            required: ["metallicFactor", "roughnessFactor"]
+          },
+          normalTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+          occlusionTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+          emissiveTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+          emissiveFactor: { type: "array", minItems: 3, maxItems: 3, items: { type: "number" } },
+          alphaMode: { enum: ["opaque", "mask", "blend"] },
+          alphaCutoff: { type: "number" },
+          doubleSided: { type: "boolean" },
+          cullFace: { enum: ["none", "front", "back"] }
+        },
+        required: ["pbrMetallicRoughness", "alphaMode"]
+      }
+    }
+  },
+  required: ["options", "tilesConverted"],
+  $defs: {
+    AttributeValue: {
+      type: "object",
+      properties: {
+        valueType: { type: "string" },
+        encoding: { type: "string" },
+        valuesPerElement: { type: "number" }
+      },
+      required: ["valueType"]
+    },
+    ESRIField: {
+      enum: [
+        "esriFieldTypeDate",
+        "esriFieldTypeSingle",
+        "esriFieldTypeDouble",
+        "esriFieldTypeGUID",
+        "esriFieldTypeGlobalID",
+        "esriFieldTypeInteger",
+        "esriFieldTypeOID",
+        "esriFieldTypeSmallInteger",
+        "esriFieldTypeString"
+      ]
+    },
+    Domain: {
+      type: "object",
+      properties: {
+        type: { type: "string" },
+        name: { type: "string" },
+        description: { type: "string" },
+        fieldType: { type: "string" },
+        range: { type: "array", items: { type: "number" } },
+        codedValues: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { name: { type: "string" }, code: { type: ["string", "number"] } },
+            required: ["name", "code"]
+          }
+        },
+        mergePolicy: { type: "string" },
+        splitPolicy: { type: "string" }
+      },
+      required: ["type", "name"]
+    },
+    FieldInfo: {
+      type: "object",
+      properties: {
+        fieldName: { type: "string" },
+        visible: { type: "boolean" },
+        isEditable: { type: "boolean" },
+        label: { type: "string" }
+      },
+      required: ["fieldName", "visible", "isEditable", "label"]
+    },
+    I3SMaterialTexture: {
+      type: "object",
+      properties: {
+        textureSetDefinitionId: { type: "number" },
+        texCoord: { type: "number" },
+        factor: { type: "number" }
+      },
+      required: ["textureSetDefinitionId"]
+    }
+  }
+};
+
+// src/lib/utils/conversion-dump.ts
 var ConversionDump = class {
   constructor() {
     /**Restored/resumed dump indicator */
     this.restored = false;
-    /** Array of materials definitions */
-    this.materialDefinitions = [];
     this.tilesConverted = {};
   }
   /**
@@ -3929,23 +4251,31 @@ var ConversionDump = class {
       `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
     );
     if (await isFileExists(dumpFilename)) {
-      const {
-        options,
-        tilesConverted,
-        textureSetDefinitions,
-        attributeMetadataInfo,
-        materialDefinitions
-      } = await openJson(
-        (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
-        `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
-      );
-      if ((0, import_util.isDeepStrictEqual)(options, JSON.parse(JSON.stringify(this.options)))) {
-        this.tilesConverted = tilesConverted;
-        this.textureSetDefinitions = textureSetDefinitions;
-        this.attributeMetadataInfo = attributeMetadataInfo;
-        this.materialDefinitions = materialDefinitions;
-        this.restored = true;
-        return;
+      try {
+        const dump = await openJson(
+          (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+        );
+        const {
+          options,
+          tilesConverted,
+          textureSetDefinitions,
+          attributeMetadataInfo,
+          materialDefinitions
+        } = dump;
+        const ajv = new import_ajv.default();
+        const dumpJsonValidate = ajv.compile(dumpJsonSchema);
+        const isDumpValid = dumpJsonValidate(dump);
+        if (isDumpValid && (0, import_util.isDeepStrictEqual)(options, JSON.parse(JSON.stringify(this.options)))) {
+          this.tilesConverted = tilesConverted;
+          this.textureSetDefinitions = textureSetDefinitions;
+          this.attributeMetadataInfo = attributeMetadataInfo;
+          this.materialDefinitions = materialDefinitions;
+          this.restored = true;
+          return;
+        }
+      } catch (error) {
+        console.log("Can't open dump file", error);
       }
     }
     await this.deleteDumpFile();
@@ -3962,8 +4292,8 @@ var ConversionDump = class {
     if (this.attributeMetadataInfo) {
       delete this.attributeMetadataInfo;
     }
-    if (this.materialDefinitions.length > 0) {
-      this.materialDefinitions = [];
+    if (this.materialDefinitions) {
+      delete this.materialDefinitions;
     }
   }
   /**
@@ -3973,6 +4303,7 @@ var ConversionDump = class {
     var _a2;
     if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
       try {
+        const time = import_process3.default.hrtime();
         await writeFile(
           (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
           JSON.stringify({
@@ -3982,7 +4313,19 @@ var ConversionDump = class {
             attributeMetadataInfo: this.attributeMetadataInfo,
             materialDefinitions: this.materialDefinitions
           }),
-          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}.${time[0]}.${time[1]}`
+        );
+        await renameFile(
+          (0, import_path6.join)(
+            this.options.outputPath,
+            this.options.tilesetName,
+            `${this.options.tilesetName}${DUMP_FILE_SUFFIX}.${time[0]}.${time[1]}`
+          ),
+          (0, import_path6.join)(
+            this.options.outputPath,
+            this.options.tilesetName,
+            `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+          )
         );
       } catch (error) {
         console.log("Can't update dump file", error);
@@ -4033,7 +4376,7 @@ var ConversionDump = class {
    */
   async addNode(filename, nodeId, dumpMetadata) {
     const { nodes } = this.getRecord(filename) || { nodes: [] };
-    nodes.push({ nodeId, done: false, progress: {}, dumpMetadata });
+    nodes.push({ nodeId, done: false, dumpMetadata });
     if (nodes.length === 1) {
       this.setRecord(filename, { nodes });
     }
@@ -4106,6 +4449,22 @@ var ConversionDump = class {
     }
     await this.updateDumpFile();
   }
+  /**
+   * Update 3d-tiles-converter dump file
+   * @param filename - source filename
+   * @param nodeId - nodeId
+   * @param done - conversion status
+   */
+  async updateConvertedNodesDumpFile(filename, nodeId, done) {
+    var _a2;
+    const nodeDump = (_a2 = this.tilesConverted[filename]) == null ? void 0 : _a2.nodes.find(
+      (element) => element.nodeId === nodeId
+    );
+    if (nodeDump) {
+      nodeDump.done = done;
+      await this.updateDumpFile();
+    }
+  }
   /**
    * Check is source file conversion complete
    * @param filename - source filename
@@ -4133,7 +4492,7 @@ var ConversionDump = class {
 
 // src/i3s-converter/i3s-converter.ts
 var _a;
-var ION_DEFAULT_TOKEN = (_a = import_process3.default.env) == null ? void 0 : _a.IonToken;
+var ION_DEFAULT_TOKEN = (_a = import_process4.default.env) == null ? void 0 : _a.IonToken;
 var HARDCODED_NODES_PER_PAGE = 64;
 var _3D_TILES = "3DTILES";
 var _3D_OBJECT_LAYER_TYPE = "3DObject";
@@ -4214,7 +4573,7 @@ var I3SConverter = class {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-    this.conversionStartTime = import_process3.default.hrtime();
+    this.conversionStartTime = import_process4.default.hrtime();
     const {
       tilesetName,
       slpk,
@@ -4317,7 +4676,6 @@ var I3SConverter = class {
     } else {
       console.log("Feature metadata classes have not been found");
     }
-    console.log(`------------------------------------------------`);
     if (!meshTopologyTypes.has("TRIANGLES" /* TRIANGLES */) && !meshTopologyTypes.has("TRIANGLE_STRIP" /* TRIANGLE_STRIP */)) {
       console.log(
         "The tileset is of unsupported mesh topology types. The conversion will be interrupted."
@@ -4325,6 +4683,7 @@ var I3SConverter = class {
       console.log(`------------------------------------------------`);
       return false;
     }
+    console.log(`------------------------------------------------`);
     return true;
   }
   /**
@@ -4549,9 +4908,9 @@ var I3SConverter = class {
     if (this.options.slpk) {
       const slpkTilesetPath = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
       const slpkFileName = `${tilesetPath}.slpk`;
-      await (0, import_zip.createZip)(slpkTilesetPath, slpkFileName, async (fileList) => ({
+      await (0, import_zip2.createZip)(slpkTilesetPath, slpkFileName, async (fileList) => ({
         path: "@specialIndexFileHASH128@",
-        file: await (0, import_zip.composeHashFile)(fileList)
+        file: await (0, import_zip2.composeHashFile)(fileList)
       }));
       try {
         await removeDir(tilesetPath);
@@ -5315,7 +5674,7 @@ var I3SConverter = class {
     const { tilesCount, tilesWithAddRefineCount } = this.refinementCounter;
     const addRefinementPercentage = tilesWithAddRefineCount ? tilesWithAddRefineCount / tilesCount * 100 : 0;
     const filesSize = await calculateFilesSize(params);
-    const diff = import_process3.default.hrtime(this.conversionStartTime);
+    const diff = import_process4.default.hrtime(this.conversionStartTime);
     const conversionTime = timeConverter(diff);
     console.log(`------------------------------------------------`);
     console.log(`Finishing conversion of ${_3D_TILES}`);
@@ -5336,18 +5695,18 @@ var I3SConverter = class {
       "cesium-ion": { accessToken: this.options.token || ION_DEFAULT_TOKEN }
     };
     const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
-    this.refreshTokenTime = import_process3.default.hrtime();
+    this.refreshTokenTime = import_process4.default.hrtime();
     return { ...options, ...preloadOptions };
   }
   /**
    * Update options of source tileset
    */
   async _updateTilesetOptions() {
-    const diff = import_process3.default.hrtime(this.refreshTokenTime);
+    const diff = import_process4.default.hrtime(this.refreshTokenTime);
     if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
       return;
     }
-    this.refreshTokenTime = import_process3.default.hrtime();
+    this.refreshTokenTime = import_process4.default.hrtime();
     const preloadOptions = await this._fetchPreloadOptions();
     if (preloadOptions.headers) {
       this.loadOptions.fetch = {
@@ -5380,7 +5739,7 @@ var I3SConverter = class {
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
 var import_path8 = require("path");
-var import_process4 = __toESM(require("process"), 1);
+var import_process5 = __toESM(require("process"), 1);
 var import_json_map_transform10 = __toESM(require("json-map-transform"), 1);
 var import_core15 = require("@loaders.gl/core");
 var import_i3s2 = require("@loaders.gl/i3s");
@@ -5756,7 +6115,9 @@ var B3dmConverter = class {
 // src/3d-tiles-converter/helpers/load-i3s.ts
 var import_core14 = require("@loaders.gl/core");
 var import_i3s = require("@loaders.gl/i3s");
-var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_zip3 = require("@loaders.gl/zip");
+var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions, slpkFilesystem) => {
   if (!sourceTileset || !sourceTile.contentUrl) {
     return null;
   }
@@ -5764,10 +6125,12 @@ var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
     ...tilesetLoadOptions,
     i3s: {
       ...tilesetLoadOptions.i3s,
+      // @ts-expect-error
       isTileset: false,
+      // @ts-expect-error
       isTileHeader: false,
       _tileOptions: {
-        attributeUrls: sourceTile.attributeUrls,
+        attributeUrls: sourceTile.attributeUrls || [],
         textureUrl: sourceTile.textureUrl,
         textureFormat: sourceTile.textureFormat,
         textureLoaderOptions: sourceTile.textureLoaderOptions,
@@ -5777,20 +6140,78 @@ var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
       },
       _tilesetOptions: {
         store: sourceTileset.store,
+        // @ts-expect-error
         attributeStorageInfo: sourceTileset.attributeStorageInfo,
+        // @ts-expect-error
         fields: sourceTileset.fields
       }
     }
   };
-  const tileContent = await (0, import_core14.load)(sourceTile.contentUrl, import_i3s.I3SLoader, loadOptions);
+  const tileContent = await loadFromArchive2(
+    sourceTile.contentUrl,
+    import_i3s.I3SLoader,
+    loadOptions,
+    slpkFilesystem
+  );
   return tileContent;
 };
+async function openSLPK(url) {
+  const slpkUrlParts = url.split(".slpk");
+  const { slpkFileName } = getSlpkUrlParts(url) || {};
+  if (slpkFileName) {
+    const slpkFileName2 = `${slpkUrlParts[0]}.slpk`;
+    const fileProvider = new import_loader_utils5.FileHandleFile(slpkFileName2);
+    const archive = await (0, import_i3s.parseSLPKArchive)(fileProvider, void 0, slpkFileName2);
+    const fileSystem = new import_zip3.ZipFileSystem(archive);
+    return fileSystem;
+  }
+  return null;
+}
+async function loadFromArchive2(url, loader, loadOptions, fileSystem) {
+  const slpkUrlParts = getSlpkUrlParts(url);
+  if (fileSystem !== null && slpkUrlParts !== null) {
+    const { internalFileName } = slpkUrlParts;
+    const content = await (0, import_core14.load)(internalFileName, loader, {
+      ...loadOptions,
+      fetch: fileSystem.fetch.bind(fileSystem)
+    });
+    return content;
+  }
+  return await (0, import_core14.load)(url, loader, loadOptions);
+}
+function getSlpkUrlParts(url) {
+  const slpkUrlParts = url.split(".slpk");
+  let result;
+  if (slpkUrlParts.length === 1) {
+    result = null;
+  } else if (slpkUrlParts.length === 2) {
+    result = { slpkFileName: `${slpkUrlParts[0]}.slpk`, internalFileName: slpkUrlParts[1].slice(1) };
+  } else {
+    throw new Error("Unexpected URL format");
+  }
+  return result;
+}
+async function getNodeCount(fileSystem) {
+  if (!(fileSystem == null ? void 0 : fileSystem.fileProvider)) {
+    return 0;
+  }
+  let count = 0;
+  const filesIterator = (0, import_zip3.makeZipCDHeaderIterator)(fileSystem.fileProvider);
+  for await (const file of filesIterator) {
+    const filename = file.fileName;
+    if (filename.indexOf("3dNodeIndexDocument.json.gz") >= 0) {
+      count++;
+    }
+  }
+  return count;
+}
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
 var I3S = "I3S";
 var Tiles3DConverter = class {
   constructor() {
     this.workerSource = {};
+    this.slpkFilesystem = null;
     this.loaderOptions = {
       _nodeWorkers: true,
       reuseWorkers: true,
@@ -5810,6 +6231,8 @@ var Tiles3DConverter = class {
     this.sourceTileset = null;
     this.attributeStorageInfo = null;
     this.workerSource = {};
+    this.conversionDump = new ConversionDump();
+    this.progress = new Progress();
   }
   /**
    * Convert i3s format data to 3dTiles
@@ -5826,13 +6249,31 @@ var Tiles3DConverter = class {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-    const { inputUrl, outputPath, tilesetName, maxDepth, egmFilePath } = options;
-    this.conversionStartTime = import_process4.default.hrtime();
-    this.options = { maxDepth };
+    const { inputUrl, outputPath, tilesetName, maxDepth, egmFilePath, inquirer, analyze } = options;
+    this.conversionStartTime = import_process5.default.hrtime();
+    this.options = { maxDepth, inquirer };
     console.log("Loading egm file...");
     this.geoidHeightModel = await (0, import_core15.load)(egmFilePath, PGMLoader);
     console.log("Loading egm file completed!");
-    this.sourceTileset = await (0, import_core15.load)(inputUrl, import_i3s2.I3SLoader, this.loaderOptions);
+    this.slpkFilesystem = await openSLPK(inputUrl);
+    let preprocessResult = true;
+    if (analyze || this.slpkFilesystem) {
+      preprocessResult = await this.preprocessConversion();
+      if (!preprocessResult || analyze) {
+        return;
+      }
+    }
+    this.progress.startMonitoring();
+    this.sourceTileset = await loadFromArchive2(
+      inputUrl,
+      import_i3s2.I3SLoader,
+      {
+        ...this.loaderOptions,
+        // @ts-expect-error `isTileset` can be boolean of 'auto' but TS expects a string
+        i3s: { ...this.loaderOptions.i3s, isTileset: true }
+      },
+      this.slpkFilesystem
+    );
     if (!this.sourceTileset) {
       return;
     }
@@ -5842,9 +6283,24 @@ var Tiles3DConverter = class {
     }
     this.tilesetPath = (0, import_path8.join)(`${outputPath}`, `${tilesetName}`);
     this.attributeStorageInfo = this.sourceTileset.attributeStorageInfo;
-    try {
-      await removeDir(this.tilesetPath);
-    } catch (e) {
+    await this.conversionDump.createDump(options);
+    if (this.conversionDump.restored && this.options.inquirer) {
+      const result = await this.options.inquirer.prompt([
+        {
+          name: "resumeConversion",
+          type: "confirm",
+          message: "Dump file of the previous conversion exists, do you want to resume that conversion?"
+        }
+      ]);
+      if (!result.resumeConversion) {
+        this.conversionDump.reset();
+      }
+    }
+    if (!this.conversionDump.restored) {
+      try {
+        await removeDir(this.tilesetPath);
+      } catch (e) {
+      }
     }
     const rootTile = {
       boundingVolume: {
@@ -5857,10 +6313,38 @@ var Tiles3DConverter = class {
     await this._addChildren(rootNode, rootTile, 1);
     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 });
+    await this.conversionDump.deleteDumpFile();
+    this.progress.stopMonitoring();
+    await this._finishConversion({ slpk: false, outputPath, tilesetName });
+    if (this.slpkFilesystem) {
+      this.slpkFilesystem.destroy();
+    }
     const workerFarm = import_worker_utils2.WorkerFarm.getWorkerFarm({});
     workerFarm.destroy();
   }
+  /**
+   * Preprocess stage of the tile converter. Calculate number of nodes
+   * @returns true - the conversion is possible, false - the tileset's content is not supported
+   */
+  async preprocessConversion() {
+    console.log(`Analyze source layer`);
+    const nodesCount = await getNodeCount(this.slpkFilesystem);
+    this.progress.stepsTotal = nodesCount;
+    console.log(`------------------------------------------------`);
+    console.log(`Preprocess results:`);
+    if (this.slpkFilesystem) {
+      console.log(`Node count: ${nodesCount}`);
+      if (nodesCount === 0) {
+        console.log("Node count is 0. The conversion will be interrupted.");
+        console.log(`------------------------------------------------`);
+        return false;
+      }
+    } else {
+      console.log(`Node count cannot be calculated for the remote dataset`);
+    }
+    console.log(`------------------------------------------------`);
+    return true;
+  }
   /**
    * Convert particular I3S Node
    * @param parentSourceNode the parent node tile object (@loaders.gl/tiles/Tile3D)
@@ -5869,9 +6353,21 @@ var Tiles3DConverter = class {
    * @param childNodeInfo child node to convert
    */
   async convertChildNode(parentSourceNode, parentNode, level, childNodeInfo) {
+    let nextParentNode = parentNode;
     const sourceChild = await this._loadChildNode(parentSourceNode, childNodeInfo);
     if (sourceChild.contentUrl) {
-      const content = await loadI3SContent(this.sourceTileset, sourceChild, this.loaderOptions);
+      if (this.conversionDump.restored && this.conversionDump.isFileConversionComplete(`${sourceChild.id}.b3dm`) && (sourceChild.obb || sourceChild.mbs)) {
+        const { child: child2 } = this._createChildAndBoundingVolume(sourceChild);
+        parentNode.children.push(child2);
+        await this._addChildren(sourceChild, child2, level + 1);
+        return;
+      }
+      const content = await loadI3SContent(
+        this.sourceTileset,
+        sourceChild,
+        this.loaderOptions,
+        this.slpkFilesystem
+      );
       if (!content) {
         await this._addChildren(sourceChild, parentNode, level + 1);
         return;
@@ -5881,34 +6377,34 @@ var Tiles3DConverter = class {
       if (this.attributeStorageInfo) {
         featureAttributes = await this._loadChildAttributes(sourceChild, this.attributeStorageInfo);
       }
-      if (!sourceChild.obb) {
-        sourceChild.obb = createObbFromMbs(sourceChild.mbs);
-      }
-      const boundingVolume = {
-        box: i3sObbTo3dTilesObb(sourceChild.obb, this.geoidHeightModel)
-      };
-      const child = {
-        boundingVolume,
-        geometricError: convertScreenThresholdToGeometricError(sourceChild),
-        children: []
-      };
+      const { child, boundingVolume } = this._createChildAndBoundingVolume(sourceChild);
       const i3sAttributesData = {
         tileContent: content,
-        box: boundingVolume.box,
+        box: boundingVolume.box || [],
         textureFormat: sourceChild.textureFormat
       };
       const b3dmConverter = new B3dmConverter();
       const b3dm = await b3dmConverter.convert(i3sAttributesData, featureAttributes);
-      child.content = {
-        uri: `${sourceChild.id}.b3dm`,
-        boundingVolume
-      };
+      await this.conversionDump.addNode(`${sourceChild.id}.b3dm`, sourceChild.id);
       await writeFile(this.tilesetPath, new Uint8Array(b3dm), `${sourceChild.id}.b3dm`);
+      await this.conversionDump.updateConvertedNodesDumpFile(
+        `${sourceChild.id}.b3dm`,
+        sourceChild.id,
+        true
+      );
       parentNode.children.push(child);
-      await this._addChildren(sourceChild, child, level + 1);
-    } else {
-      await this._addChildren(sourceChild, parentNode, level + 1);
+      nextParentNode = child;
+    }
+    this.progress.stepsDone += 1;
+    let timeRemainingString = "Calculating time left...";
+    const timeRemaining = this.progress.getTimeRemainingString();
+    if (timeRemaining) {
+      timeRemainingString = `${timeRemaining} left`;
     }
+    const percentString = this.progress.getPercentString();
+    const progressString = percentString ? ` ${percentString}%, ${timeRemainingString}` : "";
+    console.log(`[converted${progressString}]: ${childNodeInfo.id}`);
+    await this._addChildren(sourceChild, nextParentNode, level + 1);
   }
   /**
    * The recursive function of traversal of a nodes tree
@@ -5943,15 +6439,39 @@ var Tiles3DConverter = class {
       const options = {
         i3s: {
           ...this.loaderOptions,
+          // @ts-expect-error
           isTileHeader: true,
           loadContent: false
         }
       };
       console.log(`Node conversion: ${nodeUrl}`);
-      header = await (0, import_core15.load)(nodeUrl, import_i3s2.I3SLoader, options);
+      header = await loadFromArchive2(nodeUrl, import_i3s2.I3SLoader, options, this.slpkFilesystem);
     }
     return header;
   }
+  /**
+   * Create child and child's boundingVolume for the converted node
+   * @param sourceChild
+   * @returns child and child's boundingVolume
+   */
+  _createChildAndBoundingVolume(sourceChild) {
+    if (!sourceChild.obb) {
+      sourceChild.obb = createObbFromMbs(sourceChild.mbs);
+    }
+    const boundingVolume = {
+      box: i3sObbTo3dTilesObb(sourceChild.obb, this.geoidHeightModel)
+    };
+    const child = {
+      boundingVolume,
+      geometricError: convertScreenThresholdToGeometricError(sourceChild),
+      children: [],
+      content: {
+        uri: `${sourceChild.id}.b3dm`,
+        boundingVolume
+      }
+    };
+    return { boundingVolume, child };
+  }
   /**
    * Make an url of a resource from its relative url having the base url
    * @param baseUrl the base url. A resulting url will be related from this url
@@ -5989,7 +6509,7 @@ var Tiles3DConverter = class {
         attributeName: attribute.name,
         attributeType: this._getAttributeType(attribute)
       };
-      promises.push((0, import_core15.load)(inputUrl, import_i3s2.I3SAttributeLoader, options));
+      promises.push(loadFromArchive2(inputUrl, import_i3s2.I3SAttributeLoader, options, this.slpkFilesystem));
     }
     const attributesList = await Promise.all(promises);
     this._replaceNestedArrays(attributesList);
@@ -6028,7 +6548,7 @@ var Tiles3DConverter = class {
    */
   async _finishConversion(params) {
     const filesSize = await calculateFilesSize(params);
-    const diff = import_process4.default.hrtime(this.conversionStartTime);
+    const diff = import_process5.default.hrtime(this.conversionStartTime);
     const conversionTime = timeConverter(diff);
     console.log(`------------------------------------------------`);
     console.log(`Finish conversion of ${I3S}`);