@loaders.gl/i3s 4.0.0-beta.2 → 4.0.0-beta.4

package/src/lib/parsers/parse-slpk/parse-slpk.ts

@@ -4,9 +4,8 @@ import {
   cdSignature as cdHeaderSignature,
   parseZipLocalFileHeader,
   searchFromTheEnd,
-  HashElement,
-  parseHashFile,
-  generateHashInfo
+  parseHashTable,
+  makeHashTableFromZipHeaders
 } from '@loaders.gl/zip';
 import {SLPKArchive} from './slpk-archieve';
 
@@ -16,21 +15,22 @@ import {SLPKArchive} from './slpk-archieve';
  * @param cb is called with information message during parsing
  * @returns slpk file handler
  */
-export const parseSLPK = async (
+export async function parseSLPKArchive(
   fileProvider: FileProvider,
   cb?: (msg: string) => void
-): Promise<SLPKArchive> => {
+): Promise<SLPKArchive> {
   const hashCDOffset = await searchFromTheEnd(fileProvider, cdHeaderSignature);
 
   const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
 
-  let hashData: HashElement[];
+  let hashTable: Record<string, bigint>;
   if (cdFileHeader?.fileName !== '@specialIndexFileHASH128@') {
-    cb?.('SLPK doesnt contain hash file');
-    hashData = await generateHashInfo(fileProvider);
-    cb?.('hash info has been composed according to central directory records');
+    hashTable = await makeHashTableFromZipHeaders(fileProvider);
+    cb?.(
+      'SLPK doesnt contain hash file, hash info has been composed according to zip archive headers'
+    );
   } else {
-    cb?.('SLPK contains hash file');
+    // cb?.('SLPK contains hash file');
     const localFileHeader = await parseZipLocalFileHeader(
       cdFileHeader.localHeaderOffset,
       fileProvider
@@ -45,8 +45,8 @@ export const parseSLPK = async (
       fileDataOffset + localFileHeader.compressedSize
     );
 
-    hashData = parseHashFile(hashFile);
+    hashTable = parseHashTable(hashFile);
   }
 
-  return new SLPKArchive(fileProvider, hashData);
-};
+  return new SLPKArchive(fileProvider, hashTable);
+}

package/src/lib/parsers/parse-slpk/slpk-archieve.ts

@@ -1,6 +1,6 @@
-import md5 from 'md5';
+import {MD5Hash} from '@loaders.gl/crypto';
 import {FileProvider} from '@loaders.gl/loader-utils';
-import {parseZipLocalFileHeader, HashElement, findBin} from '@loaders.gl/zip';
+import {parseZipLocalFileHeader} from '@loaders.gl/zip';
 import {GZipCompression} from '@loaders.gl/compression';
 
 /** Description of real paths for different file types */
@@ -43,11 +43,20 @@ const PATH_DESCRIPTIONS: {test: RegExp; extensions: string[]}[] = [
  * Class for handling information about slpk file
  */
 export class SLPKArchive {
+  /** A DataView representation of the archive */
   private slpkArchive: FileProvider;
-  private hashArray: HashElement[];
-  constructor(slpkArchive: FileProvider, hashFile: HashElement[]) {
+  // Maps hex-encoded md5 filename hashes to bigint offsets into the archive
+  private hashTable: Record<string, bigint>;
+  /** Array of hashes and offsets into archive */
+  // hashToOffsetMap: Record<string, number>;
+
+  protected _textEncoder = new TextEncoder();
+  protected _textDecoder = new TextDecoder();
+  protected _md5Hash = new MD5Hash();
+
+  constructor(slpkArchive: FileProvider, hashTable: Record<string, bigint>) {
     this.slpkArchive = slpkArchive;
-    this.hashArray = hashFile;
+    this.hashTable = hashTable;
   }
 
   /**
@@ -56,7 +65,7 @@ export class SLPKArchive {
    * @param mode - currently only raw mode supported
    * @returns buffer with ready to use file
    */
-  async getFile(path: string, mode: 'http' | 'raw' = 'raw'): Promise<Buffer> {
+  async getFile(path: string, mode: 'http' | 'raw' = 'raw'): Promise<ArrayBuffer> {
     if (mode === 'http') {
       const extensions = PATH_DESCRIPTIONS.find((val) => val.test.test(path))?.extensions;
       if (extensions) {
@@ -68,22 +77,22 @@ export class SLPKArchive {
           }
         }
         if (data) {
-          return Buffer.from(data);
+          return data;
         }
       }
     }
     if (mode === 'raw') {
       const decompressedFile = await this.getDataByPath(`${path}.gz`);
       if (decompressedFile) {
-        return Buffer.from(decompressedFile);
+        return decompressedFile;
       }
       const fileWithoutCompression = await this.getFileBytes(path);
       if (fileWithoutCompression) {
-        return Buffer.from(fileWithoutCompression);
+        return fileWithoutCompression;
       }
     }
 
-    throw new Error('No such file in the archieve');
+    throw new Error(`No such file in the archive: ${path}`);
   }
 
   /**
@@ -107,22 +116,24 @@ export class SLPKArchive {
       const decompressedData = await compression.decompress(data);
       return decompressedData;
     }
-    return Buffer.from(data);
+    return data;
   }
 
   /**
-   * Trying to get raw file data by adress
+   * Trying to get raw file data by address
    * @param path - path inside the archive
    * @returns buffer with the raw file data
    */
   private async getFileBytes(path: string): Promise<ArrayBuffer | undefined> {
-    const nameHash = Buffer.from(md5(path), 'hex');
-    const fileInfo = findBin(nameHash, this.hashArray); // implement binary search
-    if (!fileInfo) {
+    const binaryPath = this._textEncoder.encode(path);
+    const nameHash = await this._md5Hash.hash(binaryPath.buffer, 'hex');
+
+    const offset = this.hashTable[nameHash];
+    if (offset === undefined) {
       return undefined;
     }
 
-    const localFileHeader = await parseZipLocalFileHeader(fileInfo.offset, this.slpkArchive);
+    const localFileHeader = await parseZipLocalFileHeader(offset, this.slpkArchive);
     if (!localFileHeader) {
       return undefined;
     }
@@ -134,7 +145,4 @@ export class SLPKArchive {
 
     return compressedFile;
   }
-  findBin(nameHash: Buffer) {
-    throw new Error('Method not implemented.');
-  }
 }

package/src/lib/utils/url-utils.ts

@@ -1,5 +1,22 @@
 import {Node3DIndexDocument, SceneLayer3D} from '../../types';
 
+/**
+ * Return URL seperated from search params
+ * @param url - URL that might have search params
+ * @returns url without search params
+ */
+export function getUrlWithoutParams(url: string): string {
+  let urlWithoutParams;
+
+  try {
+    const urlObj = new URL(url);
+    urlWithoutParams = `${urlObj.origin}${urlObj.pathname}`;
+  } catch (e) {
+    // do nothing
+  }
+  return urlWithoutParams || url;
+}
+
 /**
  * Generates url with token if it is exists.
  * @param url