@loaders.gl/3d-tiles 4.0.0-alpha.20 → 4.0.0-alpha.22

package/dist/lib/parsers/parse-3d-tile-gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-gltf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,eAAe,CACnC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAsBf"}
+{"version":3,"file":"parse-3d-tile-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-gltf.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,eAAe,CACnC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/lib/parsers/parse-3d-tile-gltf.js

@@ -1,6 +1,8 @@
 "use strict";
+// loaders.gl, MIT license
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGltf3DTile = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
 const gltf_1 = require("@loaders.gl/gltf");
 async function parseGltf3DTile(tile, arrayBuffer, options, context) {
     // Set flags
@@ -8,16 +10,14 @@ async function parseGltf3DTile(tile, arrayBuffer, options, context) {
     // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
     tile.rotateYtoZ = true;
     // Save gltf up axis
-    tile.gltfUpAxis =
-        options?.['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
-            ? options['3d-tiles'].assetGltfUpAxis
-            : 'Y';
+    tile.gltfUpAxis = options?.['3d-tiles']?.assetGltfUpAxis
+        ? options['3d-tiles'].assetGltfUpAxis
+        : 'Y';
     if (options?.['3d-tiles']?.loadGLTF) {
         if (!context) {
             return;
         }
-        const { parse } = context;
-        const gltfWithBuffers = await parse(arrayBuffer, gltf_1.GLTFLoader, options, context);
+        const gltfWithBuffers = await (0, loader_utils_1.parseFromContext)(arrayBuffer, gltf_1.GLTFLoader, options, context);
         tile.gltf = (0, gltf_1.postProcessGLTF)(gltfWithBuffers);
         tile.gpuMemoryUsageInBytes = (0, gltf_1._getMemoryUsageGLTF)(tile.gltf);
     }

package/dist/lib/parsers/parse-3d-tile-header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-header.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EACL,0BAA0B,EAC1B,OAAO,EACP,oBAAoB,EAEpB,eAAe,EACf,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAMrB,sDAAsD;AACtD,MAAM,MAAM,eAAe,GAAG;IAC5B,uDAAuD;IACvD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kCAAkC;IAClC,iBAAiB,EAAE,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;IAClD,yBAAyB;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,kDAAkD;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wBAAwB;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,aAAa,EAAE,eAAe,CAAC,eAAe,CAAC;IAC/C,kEAAkE;IAClE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,uEAAuE;IACvE,WAAW,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,KAAK,SAAS,GAAG,MAAM,CAAC;IACpF,gEAAgE;IAChE,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,eAAe,GAAG,MAAM,GAAG,SAAS,CAAC;CACtE,CAAC;AAiDF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,GAAG,IAAI,EAC5B,QAAQ,EAAE,MAAM,GACf,4BAA4B,GAAG,IAAI,CAqBrC;AAGD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA+C9C;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAChB,uBAAuB,EAAE,0BAA0B,EACnD,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA0C9C;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,OAAO,EACpB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,oBAAoB,GAClC,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA+B9C"}
+{"version":3,"file":"parse-3d-tile-header.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAI5D,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EACL,0BAA0B,EAC1B,OAAO,EACP,oBAAoB,EAEpB,eAAe,EACf,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAMrB,sDAAsD;AACtD,MAAM,MAAM,eAAe,GAAG;IAC5B,uDAAuD;IACvD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kCAAkC;IAClC,iBAAiB,EAAE,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;IAClD,yBAAyB;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,kDAAkD;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wBAAwB;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,aAAa,EAAE,eAAe,CAAC,eAAe,CAAC;IAC/C,kEAAkE;IAClE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,uEAAuE;IACvE,WAAW,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,KAAK,SAAS,GAAG,MAAM,CAAC;IACpF,gEAAgE;IAChE,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,eAAe,GAAG,MAAM,GAAG,SAAS,CAAC;CACtE,CAAC;AAiDF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,GAAG,IAAI,EAC5B,QAAQ,EAAE,MAAM,GACf,4BAA4B,GAAG,IAAI,CAqBrC;AAGD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA+C9C;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAChB,uBAAuB,EAAE,0BAA0B,EACnD,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA0C9C;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,OAAO,EACpB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,oBAAoB,GAClC,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA+B9C"}

package/dist/lib/parsers/parse-3d-tile-header.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeImplicitTileData = exports.normalizeImplicitTileHeaders = exports.normalizeTileHeaders = exports.normalizeTileData = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
 const tile_3d_subtree_loader_1 = require("../../tile-3d-subtree-loader");
 const core_1 = require("@loaders.gl/core");
 const tiles_1 = require("@loaders.gl/tiles");
@@ -46,7 +47,7 @@ function resolveUri(uri = '', basePath) {
     else if (uri.startsWith('/')) {
         return uri;
     }
-    return `${basePath}/${uri}`;
+    return loader_utils_1.path.resolve(basePath, uri);
 }
 function normalizeTileData(tile, basePath) {
     if (!tile) {

package/dist/lib/parsers/parse-3d-tile-point-cloud.d.ts

@@ -1,5 +1,5 @@
-import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
 import { LoaderContext } from '@loaders.gl/loader-utils';
+import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
 import { Tiles3DTileContent } from '../../types';
 export declare function parsePointCloud3DTile(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<number>;
 export declare function loadDraco(tile: Tiles3DTileContent, dracoData: any, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<void>;

package/dist/lib/parsers/parse-3d-tile-point-cloud.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-point-cloud.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-point-cloud.ts"],"names":[],"mappings":"AAcA,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC,CAgBjB;AAuND,wBAAsB,SAAS,CAC7B,IAAI,EAAE,kBAAkB,EACxB,SAAS,KAAA,EACT,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAwDf"}
+{"version":3,"file":"parse-3d-tile-point-cloud.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-point-cloud.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,aAAa,EAAmB,MAAM,0BAA0B,CAAC;AAWzE,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC,CAgBjB;AAuND,wBAAsB,SAAS,CAC7B,IAAI,EAAE,kBAAkB,EACxB,SAAS,KAAA,EACT,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CA+Df"}

package/dist/lib/parsers/parse-3d-tile-point-cloud.js

@@ -7,6 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadDraco = exports.parsePointCloud3DTile = void 0;
 const draco_1 = require("@loaders.gl/draco");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
 const math_1 = require("@loaders.gl/math");
 const core_1 = require("@math.gl/core");
 const tile_3d_feature_table_1 = __importDefault(require("../classes/tile-3d-feature-table"));
@@ -192,7 +193,6 @@ async function loadDraco(tile, dracoData, options, context) {
     if (!context) {
         return;
     }
-    const { parse } = context;
     const dracoOptions = {
         ...options,
         draco: {
@@ -202,16 +202,19 @@ async function loadDraco(tile, dracoData, options, context) {
     };
     // The entire tileset might be included, too expensive to serialize
     delete dracoOptions['3d-tiles'];
-    const data = await parse(dracoData.buffer, draco_1.DracoLoader, dracoOptions);
+    const data = await (0, loader_utils_1.parseFromContext)(dracoData.buffer, draco_1.DracoLoader, dracoOptions, context);
     const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;
     const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;
     const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;
     const decodedBatchIds = data.attributes.BATCH_ID && data.attributes.BATCH_ID.value;
+    // @ts-expect-error
     const isQuantizedDraco = decodedPositions && data.attributes.POSITION.value.quantization;
+    // @ts-expect-error
     const isOctEncodedDraco = decodedNormals && data.attributes.NORMAL.value.quantization;
     if (isQuantizedDraco) {
         // Draco quantization range == quantized volume scale - size in meters of the quantized volume
         // Internal quantized range is the range of values of the quantized data, e.g. 255 for 8-bit, 1023 for 10-bit, etc
+        // @ts-expect-error This doesn't look right
         const quantization = data.POSITION.data.quantization;
         const range = quantization.range;
         tile.quantizedVolumeScale = new core_1.Vector3(range, range, range);
@@ -220,6 +223,7 @@ async function loadDraco(tile, dracoData, options, context) {
         tile.isQuantizedDraco = true;
     }
     if (isOctEncodedDraco) {
+        // @ts-expect-error This doesn't look right
         tile.octEncodedRange = (1 << data.NORMAL.data.quantization.quantizationBits) - 1.0;
         tile.isOctEncodedDraco = true;
     }
@@ -233,9 +237,13 @@ async function loadDraco(tile, dracoData, options, context) {
         }
     }
     tile.attributes = {
+        // @ts-expect-error
         positions: decodedPositions,
+        // @ts-expect-error
         colors: (0, normalize_3d_tile_colors_1.normalize3DTileColorAttribute)(tile, decodedColors, undefined),
+        // @ts-expect-error
         normals: decodedNormals,
+        // @ts-expect-error
         batchIds: decodedBatchIds,
         ...batchTableAttributes
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/3d-tiles",
-  "version": "4.0.0-alpha.20",
+  "version": "4.0.0-alpha.22",
   "description": "3D Tiles, an open standard for streaming massive heterogeneous 3D geospatial datasets.",
   "license": "MIT",
   "publishConfig": {
@@ -34,11 +34,12 @@
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
-    "@loaders.gl/draco": "4.0.0-alpha.20",
-    "@loaders.gl/gltf": "4.0.0-alpha.20",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.20",
-    "@loaders.gl/math": "4.0.0-alpha.20",
-    "@loaders.gl/tiles": "4.0.0-alpha.20",
+    "@loaders.gl/draco": "4.0.0-alpha.22",
+    "@loaders.gl/gltf": "4.0.0-alpha.22",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.22",
+    "@loaders.gl/math": "4.0.0-alpha.22",
+    "@loaders.gl/tiles": "4.0.0-alpha.22",
+    "@loaders.gl/zip": "4.0.0-alpha.22",
     "@math.gl/core": "^3.5.1",
     "@math.gl/geospatial": "^3.5.1",
     "@probe.gl/log": "^4.0.4",
@@ -47,5 +48,5 @@
   "peerDependencies": {
     "@loaders.gl/core": "^4.0.0-alpha.8"
   },
-  "gitHead": "ac122e83102657c38207d59c631a5ce4e7aa46bd"
+  "gitHead": "0da838c506d1275383f2fd3d244d9c72b25397d2"
 }

package/src/3d-tiles-archive/3d-tiles-archive-archive.ts

@@ -0,0 +1,84 @@
+import md5 from 'md5';
+import {FileProvider, parseZipLocalFileHeader, HashElement, findBin} from '@loaders.gl/zip';
+import {DeflateCompression, NoCompression} from '@loaders.gl/compression';
+
+type CompressionHandler = (compressedFile: ArrayBuffer) => Promise<ArrayBuffer>;
+
+/**
+ * Handling different compression types in zip
+ */
+const COMPRESSION_METHODS: {[key: number]: CompressionHandler} = {
+  /** No compression */
+  0: (data) => new NoCompression().decompress(data),
+  /** Deflation */
+  8: (data) => new DeflateCompression({raw: true}).decompress(data)
+};
+
+/**
+ * Class for handling information about 3tz file
+ */
+export class Tiles3DArchive {
+  /** FileProvider with whe whole file */
+  private fileProvider: FileProvider;
+  /** hash info */
+  private hashArray: HashElement[];
+
+  /**
+   * creates Tiles3DArchive handler
+   * @param fileProvider - FileProvider with the whole file
+   * @param hashFile - hash info
+   */
+  constructor(fileProvider: FileProvider, hashFile: HashElement[]) {
+    this.fileProvider = fileProvider;
+    this.hashArray = hashFile;
+  }
+
+  /**
+   * Returns file with the given path from 3tz archive
+   * @param path - path inside the 3tz
+   * @returns buffer with ready to use file
+   */
+  async getFile(path: string): Promise<ArrayBuffer> {
+    // sometimes paths are not in lower case when hash file is created,
+    // so first we're looking for lower case file name and then for original one
+    let data = await this.getFileBytes(path.toLocaleLowerCase());
+    if (!data) {
+      data = await this.getFileBytes(path);
+    }
+    if (!data) {
+      throw new Error('No such file in the archive');
+    }
+
+    return data;
+  }
+
+  /**
+   * Trying to get raw file data by adress
+   * @param path - path inside the archive
+   * @returns buffer with the raw file data
+   */
+  private async getFileBytes(path: string): Promise<ArrayBuffer | null> {
+    const nameHash = Buffer.from(md5(path), 'hex');
+    const fileInfo = findBin(nameHash, this.hashArray); // implement binary search
+    if (!fileInfo) {
+      return null;
+    }
+
+    const localFileHeader = await parseZipLocalFileHeader(fileInfo.offset, this.fileProvider);
+    if (!localFileHeader) {
+      return null;
+    }
+
+    const compressedFile = await this.fileProvider.slice(
+      localFileHeader.fileDataOffset,
+      localFileHeader.fileDataOffset + localFileHeader.compressedSize
+    );
+
+    const compressionMethod = COMPRESSION_METHODS[localFileHeader.compressionMethod];
+    if (!compressionMethod) {
+      throw Error('Only Deflation compression is supported');
+    }
+
+    return compressionMethod(compressedFile);
+  }
+}

package/src/3d-tiles-archive/3d-tiles-archive-parser.ts

@@ -0,0 +1,52 @@
+import {
+  FileProvider,
+  HashElement,
+  cdSignature as cdHeaderSignature,
+  generateHashInfo,
+  parseHashFile,
+  parseZipCDFileHeader,
+  parseZipLocalFileHeader,
+  searchFromTheEnd
+} from '@loaders.gl/zip';
+import {Tiles3DArchive} from './3d-tiles-archive-archive';
+
+/**
+ * Creates 3tz file handler from raw file
+ * @param fileProvider raw file data
+ * @param cb is called with information message during parsing
+ * @returns 3tz file handler
+ */
+export const parse3DTilesArchive = async (
+  fileProvider: FileProvider,
+  cb?: (msg: string) => void
+): Promise<Tiles3DArchive> => {
+  const hashCDOffset = await searchFromTheEnd(fileProvider, cdHeaderSignature);
+
+  const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
+
+  let hashData: HashElement[];
+  if (cdFileHeader?.fileName !== '@3dtilesIndex1@') {
+    cb?.('3tz doesnt contain hash file');
+    hashData = await generateHashInfo(fileProvider);
+    cb?.('hash info has been composed according to central directory records');
+  } else {
+    cb?.('3tz contains hash file');
+    const localFileHeader = await parseZipLocalFileHeader(
+      cdFileHeader.localHeaderOffset,
+      fileProvider
+    );
+    if (!localFileHeader) {
+      throw new Error('corrupted 3tz');
+    }
+
+    const fileDataOffset = localFileHeader.fileDataOffset;
+    const hashFile = await fileProvider.slice(
+      fileDataOffset,
+      fileDataOffset + localFileHeader.compressedSize
+    );
+
+    hashData = parseHashFile(hashFile);
+  }
+
+  return new Tiles3DArchive(fileProvider, hashData);
+};

package/src/3d-tiles-archive-loader.ts

@@ -0,0 +1,47 @@
+import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import {DataViewFile} from '@loaders.gl/zip';
+import {parse3DTilesArchive as parse3DTilesArchiveFromProvider} from './3d-tiles-archive/3d-tiles-archive-parser';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** options to load data from 3tz */
+export type Tiles3DArchiveFileLoaderOptions = LoaderOptions & {
+  '3d-tiles-archive'?: {
+    /** path inside the 3tz archive */
+    path?: string;
+  };
+};
+
+/**
+ * Loader for 3tz packages
+ */
+export const Tiles3DArchiveFileLoader: LoaderWithParser<
+  ArrayBuffer,
+  never,
+  Tiles3DArchiveFileLoaderOptions
+> = {
+  name: '3tz',
+  id: '3tz',
+  module: '3d-tiles',
+  version: VERSION,
+  mimeTypes: ['application/octet-stream', 'application/vnd.maxar.archive.3tz+zip'],
+  parse: parse3DTilesArchive,
+  extensions: ['3tz'],
+  options: {}
+};
+
+/**
+ * returns a single file from the 3tz archive
+ * @param data 3tz archive data
+ * @param options options
+ * @returns requested file
+ */
+async function parse3DTilesArchive(
+  data: ArrayBuffer,
+  options: Tiles3DArchiveFileLoaderOptions = {}
+): Promise<ArrayBuffer> {
+  const archive = await parse3DTilesArchiveFromProvider(new DataViewFile(new DataView(data)));
+  return archive.getFile(options['3d-tiles-archive']?.path ?? '');
+}

package/src/index.ts

@@ -2,6 +2,9 @@
 export {Tiles3DLoader} from './tiles-3d-loader';
 export {CesiumIonLoader} from './cesium-ion-loader';
 export {Tile3DSubtreeLoader} from './tile-3d-subtree-loader';
+export type {Tiles3DArchiveFileLoaderOptions} from './3d-tiles-archive-loader';
+export {Tiles3DArchiveFileLoader} from './3d-tiles-archive-loader';
+export {Tiles3DArchiveFileSystem} from './lib/filesystems/tiles-3d-archive-file-system';
 
 // WRITERS
 export {Tile3DWriter} from './tile-3d-writer';

package/src/lib/filesystems/tiles-3d-archive-file-system.ts

@@ -0,0 +1,97 @@
+import {
+  FileProvider,
+  ZipFileSystem,
+  cdSignature as cdHeaderSignature,
+  searchFromTheEnd,
+  parseZipCDFileHeader,
+  HashElement,
+  parseHashFile,
+  parseZipLocalFileHeader
+} from '@loaders.gl/zip';
+import {Tiles3DArchive} from '../../3d-tiles-archive/3d-tiles-archive-archive';
+
+/**
+ * FileSystem adapter for a 3tz (3D tiles archive format) file
+ * Holds FileProvider object that provides random access to archived files.
+ * The difference from ZipFileSystem is usage of `@3dtilesIndex1@` index file that increases
+ * access speed to archived files
+ * @see https://github.com/erikdahlstrom/3tz-specification/blob/master/Specification.md
+ */
+export class Tiles3DArchiveFileSystem extends ZipFileSystem {
+  hashData?: HashElement[] | null;
+
+  /**
+   * Constructor
+   * @param file - instance of FileProvider or file path string
+   */
+  constructor(file: FileProvider | string) {
+    super(file);
+  }
+
+  /**
+   * Implementation of fetch against this file system.
+   * It tries to take `@3dtilesIndex1@` file from the archive and use it
+   * for faster access to archived files
+   * @param filename - name of a file
+   * @returns - Response with file data
+   */
+  async fetch(filename: string): Promise<Response> {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+    await this.parseHashFile();
+    if (this.hashData) {
+      const archive = new Tiles3DArchive(fileProvider, this.hashData);
+
+      const fileData = await archive.getFile(filename);
+      const response = new Response(fileData);
+      Object.defineProperty(response, 'url', {value: `${this.fileName || ''}/${filename}`});
+      return response;
+    }
+    return super.fetch(filename);
+  }
+
+  /**
+   * Try to get and parse '@3dtilesIndex1@' file, that allows to get direct access
+   * to files inside the archive
+   * @returns void
+   */
+  private async parseHashFile(): Promise<void> {
+    if (this.hashData !== undefined) {
+      return;
+    }
+
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+
+    const hashCDOffset = await searchFromTheEnd(fileProvider, cdHeaderSignature);
+
+    const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
+
+    // '@3dtilesIndex1@' is index file that must be the last in the archive. It allows
+    // to improve load and read performance when the archive contains a very large number
+    // of files.
+    if (cdFileHeader?.fileName === '@3dtilesIndex1@') {
+      const localFileHeader = await parseZipLocalFileHeader(
+        cdFileHeader.localHeaderOffset,
+        fileProvider
+      );
+      if (!localFileHeader) {
+        throw new Error('corrupted 3tz');
+      }
+
+      const fileDataOffset = localFileHeader.fileDataOffset;
+      const hashFile = await fileProvider.slice(
+        fileDataOffset,
+        fileDataOffset + localFileHeader.compressedSize
+      );
+
+      this.hashData = parseHashFile(hashFile);
+    } else {
+      this.hashData = null;
+    }
+  }
+}

package/src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts

@@ -8,7 +8,7 @@
 // - Also, should we have hard dependency on gltf module or use injection or auto-discovery for gltf parser?
 
 import {GLTFLoader, postProcessGLTF, _getMemoryUsageGLTF} from '@loaders.gl/gltf';
-import {LoaderContext, sliceArrayBuffer} from '@loaders.gl/loader-utils';
+import {LoaderContext, sliceArrayBuffer, parseFromContext} from '@loaders.gl/loader-utils';
 import {Tiles3DTileContent} from '../../../types';
 import {Tiles3DLoaderOptions} from '../../../tiles-3d-loader';
 
@@ -74,15 +74,20 @@ export async function extractGLTF(
     if (!context) {
       return;
     }
-    const {parse, fetch} = context;
     if (tile.gltfUrl) {
+      const {fetch} = context;
       const response = await fetch(tile.gltfUrl, options);
       tile.gltfArrayBuffer = await response.arrayBuffer();
       tile.gltfByteOffset = 0;
     }
     if (tile.gltfArrayBuffer) {
       // TODO - Should handle byteOffset... However, not used now...
-      const gltfWithBuffers = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      const gltfWithBuffers = await parseFromContext(
+        tile.gltfArrayBuffer,
+        GLTFLoader,
+        options,
+        context
+      );
       tile.gltf = postProcessGLTF(gltfWithBuffers);
       tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
       delete tile.gltfArrayBuffer;

package/src/lib/parsers/parse-3d-tile-gltf.ts

@@ -1,6 +1,8 @@
-import type {LoaderContext} from '@loaders.gl/loader-utils';
-import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+// loaders.gl, MIT license
+
+import {parseFromContext, LoaderContext} from '@loaders.gl/loader-utils';
 import {_getMemoryUsageGLTF, GLTFLoader, postProcessGLTF} from '@loaders.gl/gltf';
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
 import {Tiles3DTileContent} from '../../types';
 
 export async function parseGltf3DTile(
@@ -14,17 +16,15 @@ export async function parseGltf3DTile(
   // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
   tile.rotateYtoZ = true;
   // Save gltf up axis
-  tile.gltfUpAxis =
-    options?.['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
-      ? options['3d-tiles'].assetGltfUpAxis
-      : 'Y';
+  tile.gltfUpAxis = options?.['3d-tiles']?.assetGltfUpAxis
+    ? options['3d-tiles'].assetGltfUpAxis
+    : 'Y';
 
   if (options?.['3d-tiles']?.loadGLTF) {
     if (!context) {
       return;
     }
-    const {parse} = context;
-    const gltfWithBuffers = await parse(arrayBuffer, GLTFLoader, options, context);
+    const gltfWithBuffers = await parseFromContext(arrayBuffer, GLTFLoader, options, context);
     tile.gltf = postProcessGLTF(gltfWithBuffers);
     tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
   } else {

package/src/lib/parsers/parse-3d-tile-header.ts

@@ -1,5 +1,6 @@
 import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
 import type {LoaderOptions} from '@loaders.gl/loader-utils';
+import {path} from '@loaders.gl/loader-utils';
 import {Tile3DSubtreeLoader} from '../../tile-3d-subtree-loader';
 import {load} from '@loaders.gl/core';
 import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE} from '@loaders.gl/tiles';
@@ -89,7 +90,7 @@ function resolveUri(uri: string = '', basePath: string): string {
     return uri;
   }
 
-  return `${basePath}/${uri}`;
+  return path.resolve(basePath, uri);
 }
 
 export function normalizeTileData(

package/src/lib/parsers/parse-3d-tile-point-cloud.ts

@@ -2,6 +2,7 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 import {DracoLoader} from '@loaders.gl/draco';
+import {LoaderContext, parseFromContext} from '@loaders.gl/loader-utils';
 import {GL} from '@loaders.gl/math';
 import {Vector3} from '@math.gl/core';
 
@@ -13,7 +14,6 @@ import {normalize3DTileColorAttribute} from './helpers/normalize-3d-tile-colors'
 import {normalize3DTileNormalAttribute} from './helpers/normalize-3d-tile-normals';
 import {normalize3DTilePositionAttribute} from './helpers/normalize-3d-tile-positions';
 import {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
-import {LoaderContext} from '@loaders.gl/loader-utils';
 import {Tiles3DTileContent} from '../../types';
 
 export async function parsePointCloud3DTile(
@@ -262,7 +262,6 @@ export async function loadDraco(
   if (!context) {
     return;
   }
-  const {parse} = context;
   const dracoOptions = {
     ...options,
     draco: {
@@ -274,17 +273,20 @@ export async function loadDraco(
   // The entire tileset might be included, too expensive to serialize
   delete dracoOptions['3d-tiles'];
 
-  const data = await parse(dracoData.buffer, DracoLoader, dracoOptions);
+  const data = await parseFromContext(dracoData.buffer, DracoLoader, dracoOptions, context);
 
   const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;
   const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;
   const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;
   const decodedBatchIds = data.attributes.BATCH_ID && data.attributes.BATCH_ID.value;
+  // @ts-expect-error
   const isQuantizedDraco = decodedPositions && data.attributes.POSITION.value.quantization;
+  // @ts-expect-error
   const isOctEncodedDraco = decodedNormals && data.attributes.NORMAL.value.quantization;
   if (isQuantizedDraco) {
     // Draco quantization range == quantized volume scale - size in meters of the quantized volume
     // Internal quantized range is the range of values of the quantized data, e.g. 255 for 8-bit, 1023 for 10-bit, etc
+    // @ts-expect-error This doesn't look right
     const quantization = data.POSITION.data.quantization;
     const range = quantization.range;
     tile.quantizedVolumeScale = new Vector3(range, range, range);
@@ -293,6 +295,7 @@ export async function loadDraco(
     tile.isQuantizedDraco = true;
   }
   if (isOctEncodedDraco) {
+    // @ts-expect-error This doesn't look right
     tile.octEncodedRange = (1 << data.NORMAL.data.quantization.quantizationBits) - 1.0;
     tile.isOctEncodedDraco = true;
   }
@@ -308,9 +311,13 @@ export async function loadDraco(
   }
 
   tile.attributes = {
+    // @ts-expect-error
     positions: decodedPositions,
+    // @ts-expect-error
     colors: normalize3DTileColorAttribute(tile, decodedColors, undefined),
+    // @ts-expect-error
     normals: decodedNormals,
+    // @ts-expect-error
     batchIds: decodedBatchIds,
     ...batchTableAttributes
   };