@loaders.gl/i3s 4.2.0-alpha.1 → 4.2.0-alpha.2

package/dist/arcgis-webscene-loader.js

@@ -1,5 +1,5 @@
 import { parseWebscene } from "./lib/parsers/parse-arcgis-webscene.js";
-const VERSION = typeof "4.2.0-alpha.1" !== 'undefined' ? "4.2.0-alpha.1" : 'latest';
+const VERSION = typeof "4.2.0-alpha.2" !== 'undefined' ? "4.2.0-alpha.2" : 'latest';
 export const ArcGISWebSceneLoader = {
   name: 'ArcGIS Web Scene Loader',
   id: 'arcgis-web-scene',

package/dist/dist.dev.js

@@ -4270,6 +4270,7 @@ var __exports__ = (() => {
     I3SLoader: () => I3SLoader,
     I3SNodePageLoader: () => I3SNodePageLoader,
     LayerError: () => LayerError,
+    SLPKArchive: () => SLPKArchive,
     SLPKLoader: () => SLPKLoader,
     customizeColors: () => customizeColors,
     loadFeatureAttributes: () => loadFeatureAttributes,
@@ -4336,7 +4337,7 @@ var __exports__ = (() => {
         console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
         globalThis._loadersgl_.version = NPM_TAG;
       } else {
-        globalThis._loadersgl_.version = "4.2.0-alpha.1";
+        globalThis._loadersgl_.version = "4.2.0-alpha.2";
       }
     }
     return globalThis._loadersgl_.version;
@@ -4572,6 +4573,104 @@ var __exports__ = (() => {
     return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
   }
 
+  // ../loader-utils/src/lib/files/node-file-facade.ts
+  var NOT_IMPLEMENTED = new Error("Not implemented");
+  var NodeFileFacade = class {
+    size = 0;
+    bigsize = 0n;
+    url = "";
+    constructor(url, flags, mode) {
+      if (globalThis.loaders?.NodeFile) {
+        return new globalThis.loaders.NodeFile(url, flags, mode);
+      }
+      if (isBrowser) {
+        throw new Error("Can't instantiate NodeFile in browser.");
+      }
+      throw new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+    }
+    async read(start, end) {
+      throw NOT_IMPLEMENTED;
+    }
+    async write(arrayBuffer, offset, length4) {
+      throw NOT_IMPLEMENTED;
+    }
+    async stat() {
+      throw NOT_IMPLEMENTED;
+    }
+    async truncate(length4) {
+      throw NOT_IMPLEMENTED;
+    }
+    async append(data) {
+      throw NOT_IMPLEMENTED;
+    }
+    async close() {
+    }
+  };
+
+  // ../loader-utils/src/lib/file-provider/file-provider.ts
+  var isFileProvider = (fileProvider) => {
+    return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
+  };
+
+  // ../loader-utils/src/lib/file-provider/file-handle-file.ts
+  var FileHandleFile = class {
+    constructor(path, append = false) {
+      this.file = new NodeFileFacade(path, append ? "a+" : "r");
+    }
+    async truncate(length4) {
+      await this.file.truncate(length4);
+    }
+    async append(buffer) {
+      await this.file.append(buffer);
+    }
+    async destroy() {
+      await this.file.close();
+    }
+    async getUint8(offset) {
+      const arrayBuffer = await this.file.read(offset, 1);
+      const val = new Uint8Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
+    }
+    async getUint16(offset) {
+      const arrayBuffer = await this.file.read(offset, 2);
+      const val = new Uint16Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
+    }
+    async getUint32(offset) {
+      const arrayBuffer = await this.file.read(offset, 4);
+      const val = new Uint32Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
+    }
+    async getBigUint64(offset) {
+      const arrayBuffer = await this.file.read(offset, 8);
+      const val = new BigInt64Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
+    }
+    async slice(startOffset, endOffset) {
+      const bigLength = endOffset - startOffset;
+      if (bigLength > Number.MAX_SAFE_INTEGER) {
+        throw new Error("too big slice");
+      }
+      const length4 = Number(bigLength);
+      return await this.file.read(startOffset, length4);
+    }
+    get length() {
+      return this.file.bigsize;
+    }
+  };
+
   // ../loader-utils/src/lib/file-provider/data-view-file.ts
   var toNumber = (bigint) => {
     if (bigint > Number.MAX_SAFE_INTEGER) {
@@ -9112,7 +9211,7 @@ var __exports__ = (() => {
   _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
 
   // ../images/src/lib/utils/version.ts
-  var VERSION2 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION2 = true ? "4.2.0-alpha.2" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -9501,7 +9600,7 @@ var __exports__ = (() => {
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION3 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION3 = true ? "4.2.0-alpha.2" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DracoLoader = {
@@ -10076,7 +10175,7 @@ var __exports__ = (() => {
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION4 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION4 = true ? "4.2.0-alpha.2" : "latest";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
   var BASIS_EXTERNAL_LIBRARIES = {
@@ -11086,7 +11185,7 @@ var __exports__ = (() => {
       texture: null
     };
     if (tileOptions.textureUrl) {
-      const url = getUrlWithToken(tileOptions.textureUrl, options?.i3s?.token);
+      const url = getUrlWithToken(getInternalPathFromUrl(tileOptions.textureUrl), options?.i3s?.token);
       const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
       const fetchFunc = context?.fetch || fetch;
       const response = await fetchFunc(url);
@@ -11129,6 +11228,18 @@ var __exports__ = (() => {
     }
     return await parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options);
   }
+  function getInternalPathFromUrl(url) {
+    const slpkUrlParts = url.split(".slpk");
+    let filename;
+    if (slpkUrlParts.length === 1) {
+      filename = url;
+    } else if (slpkUrlParts.length === 2) {
+      filename = slpkUrlParts[1].slice(1);
+    } else {
+      filename = url;
+    }
+    return filename;
+  }
   async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options) {
     const contentByteLength = arrayBuffer.byteLength;
     let attributes;
@@ -11480,7 +11591,7 @@ var __exports__ = (() => {
   }
 
   // src/i3s-content-loader.ts
-  var VERSION5 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION5 = true ? "4.2.0-alpha.2" : "latest";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
@@ -11990,7 +12101,7 @@ var __exports__ = (() => {
   var import_core16 = __toESM(require_core(), 1);
 
   // src/i3s-node-page-loader.ts
-  var VERSION6 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION6 = true ? "4.2.0-alpha.2" : "latest";
   var I3SNodePageLoader = {
     name: "I3S Node Page",
     id: "i3s-node-page",
@@ -12027,7 +12138,7 @@ var __exports__ = (() => {
     async getNodeById(id) {
       const pageIndex = Math.floor(id / this.nodesPerPage);
       if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
-        const nodePageUrl = getUrlWithToken(`${this.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
+        const nodePageUrl = getUrlWithToken(this.url.indexOf(".slpk") !== -1 ? `nodepages/${pageIndex}` : `${this.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
         this.pendingNodePages[pageIndex] = {
           status: "Pending",
           promise: (0, import_core16.load)(nodePageUrl, I3SNodePageLoader, this.options)
@@ -12280,7 +12391,7 @@ var __exports__ = (() => {
   }
 
   // src/i3s-loader.ts
-  var VERSION7 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION7 = true ? "4.2.0-alpha.2" : "latest";
   var TILESET_REGEX = /layers\/[0-9]+$/;
   var TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
   var SLPK_HEX = "504b0304";
@@ -13281,37 +13392,6 @@ var __exports__ = (() => {
     }
   };
 
-  // ../zip/src/hash-file-utility.ts
-  function parseHashTable(arrayBuffer) {
-    const dataView = new DataView(arrayBuffer);
-    const hashMap = {};
-    for (let i2 = 0; i2 < arrayBuffer.byteLength; i2 = i2 + 24) {
-      const offset = dataView.getBigUint64(i2 + 16, true);
-      const hash = bufferToHex(arrayBuffer, i2, 16);
-      hashMap[hash] = offset;
-    }
-    return hashMap;
-  }
-  function bufferToHex(buffer, start, length4) {
-    return [...new Uint8Array(buffer, start, length4)].map((x) => x.toString(16).padStart(2, "0")).join("");
-  }
-  async function makeHashTableFromZipHeaders(fileProvider) {
-    const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
-    return getHashTable(zipCDIterator);
-  }
-  async function getHashTable(zipCDIterator) {
-    const md5Hash = new MD5Hash();
-    const textEncoder = new TextEncoder();
-    const hashTable = {};
-    for await (const cdHeader of zipCDIterator) {
-      const filename = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
-      const arrayBuffer = textEncoder.encode(filename).buffer;
-      const md5 = await md5Hash.hash(arrayBuffer, "hex");
-      hashTable[md5] = cdHeader.localHeaderOffset;
-    }
-    return hashTable;
-  }
-
   // ../compression/src/lib/compression.ts
   var Compression = class {
     constructor(options) {
@@ -13476,6 +13556,148 @@ var __exports__ = (() => {
     }
   };
 
+  // ../zip/src/filesystems/zip-filesystem.ts
+  var ZIP_COMPRESSION_HANDLERS = {
+    0: async (compressedFile) => compressedFile,
+    8: async (compressedFile) => {
+      const compression = new DeflateCompression({
+        raw: true
+      });
+      const decompressedData = await compression.decompress(compressedFile);
+      return decompressedData;
+    }
+  };
+  var ZipFileSystem = class {
+    fileProvider = null;
+    archive = null;
+    constructor(file) {
+      if (typeof file === "string") {
+        this.fileName = file;
+        if (!isBrowser) {
+          this.fileProvider = new FileHandleFile(file);
+        } else {
+          throw new Error("Cannot open file for random access in a WEB browser");
+        }
+      } else if (file instanceof IndexedArchive) {
+        this.fileProvider = file.fileProvider;
+        this.archive = file;
+        this.fileName = file.fileName;
+      } else if (isFileProvider(file)) {
+        this.fileProvider = file;
+      }
+    }
+    async destroy() {
+      if (this.fileProvider) {
+        await this.fileProvider.destroy();
+      }
+    }
+    async readdir() {
+      if (!this.fileProvider) {
+        throw new Error("No data detected in the zip archive");
+      }
+      const fileNames = [];
+      const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
+      for await (const cdHeader of zipCDIterator) {
+        fileNames.push(cdHeader.fileName);
+      }
+      return fileNames;
+    }
+    async stat(filename) {
+      const cdFileHeader = await this.getCDFileHeader(filename);
+      return {
+        ...cdFileHeader,
+        size: Number(cdFileHeader.uncompressedSize)
+      };
+    }
+    async fetch(filename) {
+      let uncompressedFile;
+      if (this.archive) {
+        uncompressedFile = await this.archive.getFile(filename, "http");
+      } else {
+        if (!this.fileProvider) {
+          throw new Error("No data detected in the zip archive");
+        }
+        const cdFileHeader = await this.getCDFileHeader(filename);
+        const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, this.fileProvider);
+        if (!localFileHeader) {
+          throw new Error("Local file header has not been found in the zip archive`");
+        }
+        const compressionHandler = ZIP_COMPRESSION_HANDLERS[localFileHeader.compressionMethod.toString()];
+        if (!compressionHandler) {
+          throw Error("Only Deflation compression is supported");
+        }
+        const compressedFile = await this.fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+        uncompressedFile = await compressionHandler(compressedFile);
+      }
+      const response = new Response(uncompressedFile);
+      Object.defineProperty(response, "url", {
+        value: filename ? `${this.fileName || ""}/${filename}` : this.fileName || ""
+      });
+      return response;
+    }
+    async getCDFileHeader(filename) {
+      if (!this.fileProvider) {
+        throw new Error("No data detected in the zip archive");
+      }
+      const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
+      let result = null;
+      for await (const cdHeader of zipCDIterator) {
+        if (cdHeader.fileName === filename) {
+          result = cdHeader;
+          break;
+        }
+      }
+      if (!result) {
+        throw new Error("File has not been found in the zip archive");
+      }
+      return result;
+    }
+  };
+
+  // ../zip/src/filesystems/IndexedArchive.ts
+  var IndexedArchive = class {
+    constructor(fileProvider, hashTable, fileName) {
+      this.fileProvider = fileProvider;
+      this.fileName = fileName;
+    }
+    async getFileWithoutHash(filename) {
+      const zipFS = new ZipFileSystem(this.fileProvider);
+      const response = await zipFS.fetch(filename);
+      return await response.arrayBuffer();
+    }
+  };
+
+  // ../zip/src/hash-file-utility.ts
+  function parseHashTable(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    const hashMap = {};
+    for (let i2 = 0; i2 < arrayBuffer.byteLength; i2 = i2 + 24) {
+      const offset = dataView.getBigUint64(i2 + 16, true);
+      const hash = bufferToHex(arrayBuffer, i2, 16);
+      hashMap[hash] = offset;
+    }
+    return hashMap;
+  }
+  function bufferToHex(buffer, start, length4) {
+    return [...new Uint8Array(buffer, start, length4)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  }
+  async function makeHashTableFromZipHeaders(fileProvider) {
+    const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
+    return getHashTable(zipCDIterator);
+  }
+  async function getHashTable(zipCDIterator) {
+    const md5Hash = new MD5Hash();
+    const textEncoder = new TextEncoder();
+    const hashTable = {};
+    for await (const cdHeader of zipCDIterator) {
+      const filename = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
+      const arrayBuffer = textEncoder.encode(filename).buffer;
+      const md5 = await md5Hash.hash(arrayBuffer, "hex");
+      hashTable[md5] = cdHeader.localHeaderOffset;
+    }
+    return hashTable;
+  }
+
   // src/lib/parsers/parse-slpk/slpk-archieve.ts
   var PATH_DESCRIPTIONS = [{
     test: /^$/,
@@ -13502,12 +13724,12 @@ var __exports__ = (() => {
     test: /^nodes\/\d+\/shared$/,
     extensions: ["/sharedResource.json.gz"]
   }];
-  var SLPKArchive = class {
+  var SLPKArchive = class extends IndexedArchive {
     _textEncoder = new TextEncoder();
     _textDecoder = new TextDecoder();
     _md5Hash = new MD5Hash();
-    constructor(slpkArchive, hashTable) {
-      this.slpkArchive = slpkArchive;
+    constructor(fileProvider, hashTable, fileName) {
+      super(fileProvider, hashTable, fileName);
       this.hashTable = hashTable;
     }
     async getFile(path, mode = "raw") {
@@ -13554,23 +13776,32 @@ var __exports__ = (() => {
       return data;
     }
     async getFileBytes(path) {
-      const binaryPath = this._textEncoder.encode(path);
-      const nameHash = await this._md5Hash.hash(binaryPath.buffer, "hex");
-      const offset = this.hashTable[nameHash];
-      if (offset === void 0) {
-        return void 0;
-      }
-      const localFileHeader = await parseZipLocalFileHeader(offset, this.slpkArchive);
-      if (!localFileHeader) {
-        return void 0;
+      let compressedFile;
+      if (this.hashTable) {
+        const binaryPath = this._textEncoder.encode(path);
+        const nameHash = await this._md5Hash.hash(binaryPath.buffer, "hex");
+        const offset = this.hashTable[nameHash];
+        if (offset === void 0) {
+          return void 0;
+        }
+        const localFileHeader = await parseZipLocalFileHeader(offset, this.fileProvider);
+        if (!localFileHeader) {
+          return void 0;
+        }
+        compressedFile = await this.fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+      } else {
+        try {
+          compressedFile = await this.getFileWithoutHash(path);
+        } catch {
+          compressedFile = void 0;
+        }
       }
-      const compressedFile = this.slpkArchive.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
       return compressedFile;
     }
   };
 
   // src/lib/parsers/parse-slpk/parse-slpk.ts
-  async function parseSLPKArchive(fileProvider, cb) {
+  async function parseSLPKArchive(fileProvider, cb, fileName) {
     const hashCDOffset = await searchFromTheEnd(fileProvider, signature);
     const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
     let hashTable;
@@ -13586,11 +13817,11 @@ var __exports__ = (() => {
       const hashFile = await fileProvider.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
       hashTable = parseHashTable(hashFile);
     }
-    return new SLPKArchive(fileProvider, hashTable);
+    return new SLPKArchive(fileProvider, hashTable, fileName);
   }
 
   // src/i3s-slpk-loader.ts
-  var VERSION8 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION8 = true ? "4.2.0-alpha.2" : "latest";
   var SLPKLoader = {
     name: "I3S SLPK (Scene Layer Package)",
     id: "slpk",
@@ -13669,7 +13900,7 @@ var __exports__ = (() => {
   }
 
   // src/i3s-attribute-loader.ts
-  var VERSION9 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION9 = true ? "4.2.0-alpha.2" : "latest";
   var EMPTY_VALUE = "";
   var REJECTED_STATUS = "rejected";
   var I3SAttributeLoader = {
@@ -13822,7 +14053,7 @@ var __exports__ = (() => {
   }
 
   // src/i3s-building-scene-layer-loader.ts
-  var VERSION10 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION10 = true ? "4.2.0-alpha.2" : "latest";
   var I3SBuildingSceneLayerLoader = {
     name: "I3S Building Scene Layer",
     id: "i3s-building-scene-layer",
@@ -13917,7 +14148,7 @@ var __exports__ = (() => {
   }
 
   // src/arcgis-webscene-loader.ts
-  var VERSION11 = true ? "4.2.0-alpha.1" : "latest";
+  var VERSION11 = true ? "4.2.0-alpha.2" : "latest";
   var ArcGISWebSceneLoader = {
     name: "ArcGIS Web Scene Loader",
     id: "arcgis-web-scene",

package/dist/i3s-attribute-loader.js

@@ -1,7 +1,7 @@
 import { load } from '@loaders.gl/core';
 import { parseI3STileAttribute } from "./lib/parsers/parse-i3s-attribute.js";
 import { getUrlWithToken } from "./lib/utils/url-utils.js";
-const VERSION = typeof "4.2.0-alpha.1" !== 'undefined' ? "4.2.0-alpha.1" : 'latest';
+const VERSION = typeof "4.2.0-alpha.2" !== 'undefined' ? "4.2.0-alpha.2" : 'latest';
 const EMPTY_VALUE = '';
 const REJECTED_STATUS = 'rejected';
 export const I3SAttributeLoader = {

package/dist/i3s-building-scene-layer-loader.js

@@ -1,5 +1,5 @@
 import { parseBuildingSceneLayer } from "./lib/parsers/parse-i3s-building-scene-layer.js";
-const VERSION = typeof "4.2.0-alpha.1" !== 'undefined' ? "4.2.0-alpha.1" : 'latest';
+const VERSION = typeof "4.2.0-alpha.2" !== 'undefined' ? "4.2.0-alpha.2" : 'latest';
 export const I3SBuildingSceneLayerLoader = {
   name: 'I3S Building Scene Layer',
   id: 'i3s-building-scene-layer',

package/dist/i3s-content-loader.js

@@ -1,5 +1,5 @@
 import { parseI3STileContent } from "./lib/parsers/parse-i3s-tile-content.js";
-const VERSION = typeof "4.2.0-alpha.1" !== 'undefined' ? "4.2.0-alpha.1" : 'latest';
+const VERSION = typeof "4.2.0-alpha.2" !== 'undefined' ? "4.2.0-alpha.2" : 'latest';
 export const I3SContentLoader = {
   name: 'I3S Content (Indexed Scene Layers)',
   id: 'i3s-content',