@loaders.gl/3d-tiles 3.1.0-alpha.4 → 3.1.0-beta.5

package/dist/tile-3d-subtree-loader.d.ts

@@ -0,0 +1,7 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Loader for 3D Tiles Subtree
+ *
+ */
+export declare const Tile3DSubtreeLoader: LoaderWithParser;
+//# sourceMappingURL=tile-3d-subtree-loader.d.ts.map

package/dist/tile-3d-subtree-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-subtree-loader.d.ts","sourceRoot":"","sources":["../src/tile-3d-subtree-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAI/D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAUjC,CAAC"}

package/dist/tile-3d-subtree-loader.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tile3DSubtreeLoader = void 0;
+const parse_3d_tile_subtree_1 = __importDefault(require("./lib/parsers/helpers/parse-3d-tile-subtree"));
+const version_1 = require("./lib/utils/version");
+/**
+ * Loader for 3D Tiles Subtree
+ *
+ */
+exports.Tile3DSubtreeLoader = {
+    id: '3d-tiles-subtree',
+    name: '3D Tiles Subtree',
+    module: '3d-tiles',
+    version: version_1.VERSION,
+    extensions: ['subtree'],
+    mimeTypes: ['application/octet-stream'],
+    tests: ['subtree'],
+    parse: parse_3d_tile_subtree_1.default,
+    options: {}
+};

package/dist/tile-3d-writer.d.ts

@@ -0,0 +1,6 @@
+import type { Writer } from '@loaders.gl/loader-utils';
+/**
+ * Exporter for 3D Tiles
+ */
+export declare const Tile3DWriter: Writer;
+//# sourceMappingURL=tile-3d-writer.d.ts.map

package/dist/tile-3d-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-writer.d.ts","sourceRoot":"","sources":["../src/tile-3d-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAY1B,CAAC"}

package/dist/tile-3d-writer.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tile3DWriter = void 0;
+const version_1 = require("./lib/utils/version");
+const encode_3d_tile_1 = __importDefault(require("./lib/encoders/encode-3d-tile"));
+/**
+ * Exporter for 3D Tiles
+ */
+exports.Tile3DWriter = {
+    name: '3D Tile',
+    id: '3d-tiles',
+    module: '3d-tiles',
+    version: version_1.VERSION,
+    extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
+    mimeTypes: ['application/octet-stream'],
+    encodeSync,
+    binary: true,
+    options: {
+        ['3d-tiles']: {}
+    }
+};
+function encodeSync(tile, options) {
+    return (0, encode_3d_tile_1.default)(tile, options);
+}

package/dist/tiles-3d-loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Loader for 3D Tiles
+ */
+export declare const Tiles3DLoader: LoaderWithParser;
+//# sourceMappingURL=tiles-3d-loader.d.ts.map

package/dist/tiles-3d-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiles-3d-loader.d.ts","sourceRoot":"","sources":["../src/tiles-3d-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAO/D;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,gBAiB3B,CAAC"}

package/dist/tiles-3d-loader.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tiles3DLoader = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const tiles_1 = require("@loaders.gl/tiles");
+const version_1 = require("./lib/utils/version");
+const parse_3d_tile_1 = require("./lib/parsers/parse-3d-tile");
+const parse_3d_tile_header_1 = require("./lib/parsers/parse-3d-tile-header");
+/**
+ * Loader for 3D Tiles
+ */
+exports.Tiles3DLoader = {
+    id: '3d-tiles',
+    name: '3D Tiles',
+    module: '3d-tiles',
+    version: version_1.VERSION,
+    extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
+    mimeTypes: ['application/octet-stream'],
+    tests: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
+    parse,
+    options: {
+        '3d-tiles': {
+            loadGLTF: true,
+            decodeQuantizedPositions: false,
+            isTileset: 'auto',
+            assetGltfUpAxis: null
+        }
+    }
+};
+function getBaseUri(tileset) {
+    return loader_utils_1.path.dirname(tileset.url);
+}
+async function parseTile(arrayBuffer, options, context) {
+    const tile = {
+        content: {
+            featureIds: null
+        }
+    };
+    const byteOffset = 0;
+    await (0, parse_3d_tile_1.parse3DTile)(arrayBuffer, byteOffset, options, context, tile.content);
+    return tile.content;
+}
+async function parseTileset(data, options, context) {
+    const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+    // eslint-disable-next-line no-use-before-define
+    tilesetJson.loader = options.loader || exports.Tiles3DLoader;
+    tilesetJson.url = context.url;
+    // base path that non-absolute paths in tileset are relative to.
+    tilesetJson.basePath = getBaseUri(tilesetJson);
+    tilesetJson.root = (0, parse_3d_tile_header_1.normalizeTileHeaders)(tilesetJson);
+    tilesetJson.type = tiles_1.TILESET_TYPE.TILES3D;
+    tilesetJson.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+    tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
+    return tilesetJson;
+}
+async function parse(data, options, context) {
+    // auto detect file type
+    const loaderOptions = options['3d-tiles'] || {};
+    let isTileset;
+    if (loaderOptions.isTileset === 'auto') {
+        isTileset = context.url && context.url.indexOf('.json') !== -1;
+    }
+    else {
+        isTileset = loaderOptions.isTileset;
+    }
+    if (isTileset) {
+        data = await parseTileset(data, options, context);
+    }
+    else {
+        data = await parseTile(data, options, context);
+    }
+    return data;
+}

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+import type { GLTFObject } from '@loaders.gl/gltf';
+import { Matrix4, Vector3 } from '@math.gl/core';
+export declare type BatchTableJson = {
+    [key: string]: any[];
+};
+export declare type B3DMContent = {
+    batchTableJson?: BatchTableJson;
+    byteLength: number;
+    byteOffset: number;
+    cartesianModelMatrix: Matrix4;
+    cartesianOrigin: Vector3;
+    cartographicModelMatrix: Matrix4;
+    cartographicOrigin: Vector3;
+    featureIds?: number[] | null;
+    featureTableBinary?: Uint8Array;
+    featureTableJson?: BatchTableJson;
+    gltf?: GLTFObject;
+    gltfUpAxis: string;
+    header: GLTFHeader;
+    magic: number;
+    modelMatrix: Matrix4;
+    rotateYtoZ: boolean;
+    rtcCenter: [number, number, number];
+    type: string;
+    version: number;
+};
+export declare type GLTFHeader = {
+    batchLength?: number;
+    batchTableBinaryByteLength: number;
+    batchTableJsonByteLength: number;
+    featureTableBinaryByteLength: number;
+    featureTableJsonByteLength: number;
+};
+export declare type Node3D = {
+    boundingVolume: BoundingVolume;
+    children: any;
+    geometricError: number;
+    content?: {
+        uri: string;
+        boundingVolume: BoundingVolume;
+    };
+};
+declare type BoundingVolume = {
+    box?: number[];
+    sphere?: number[];
+};
+/**
+ * 3DTILES_implicit_tiling types
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ */
+export declare type SubtreeAvailability = {
+    buffers: Buffer[];
+    bufferViews: BufferView[];
+    tileAvailability: Availability;
+    contentAvailability: Availability;
+    childSubtreeAvailability: Availability;
+};
+declare type Availability = {
+    constant?: 0 | 1;
+    bufferView?: number;
+    explicitBitstream?: ExplicitBitstream;
+};
+export declare type ExplicitBitstream = Uint8Array;
+declare type Buffer = {
+    name: string;
+    uri?: string;
+    byteLength: number;
+};
+declare type BufferView = {
+    buffer: number;
+    byteOffset: number;
+    byteLength: number;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAE/C,oBAAY,cAAc,GAAG;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;CACtB,CAAC;AAEF,oBAAY,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,uBAAuB,EAAE,OAAO,CAAC;IACjC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC7B,kBAAkB,CAAC,EAAE,UAAU,CAAC;IAChC,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,oBAAY,UAAU,GAAG;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B,EAAE,MAAM,CAAC;IACnC,wBAAwB,EAAE,MAAM,CAAC;IACjC,4BAA4B,EAAE,MAAM,CAAC;IACrC,0BAA0B,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,oBAAY,MAAM,GAAG;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,GAAG,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE;QACR,GAAG,EAAE,MAAM,CAAC;QACZ,cAAc,EAAE,cAAc,CAAC;KAChC,CAAC;CACH,CAAC;AAEF,aAAK,cAAc,GAAG;IACpB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,oBAAY,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,gBAAgB,EAAE,YAAY,CAAC;IAC/B,mBAAmB,EAAE,YAAY,CAAC;IAClC,wBAAwB,EAAE,YAAY,CAAC;CACxC,CAAC;AAEF,aAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC,CAAC;AAEF,oBAAY,iBAAiB,GAAG,UAAU,CAAC;AAE3C,aAAK,MAAM,GAAG;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,aAAK,UAAU,GAAG;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/3d-tiles",
-  "version": "3.1.0-alpha.4",
+  "version": "3.1.0-beta.5",
   "description": "3D Tiles, an open standard for streaming massive heterogeneous 3D geospatial datasets.",
   "license": "MIT",
   "publishConfig": {
@@ -20,7 +20,7 @@
     "point cloud",
     "pointcloud"
   ],
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
@@ -31,17 +31,19 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/webpack/bundle.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js"
   },
   "dependencies": {
-    "@loaders.gl/core": "3.1.0-alpha.4",
-    "@loaders.gl/draco": "3.1.0-alpha.4",
-    "@loaders.gl/gltf": "3.1.0-alpha.4",
-    "@loaders.gl/loader-utils": "3.1.0-alpha.4",
-    "@loaders.gl/math": "3.1.0-alpha.4",
-    "@loaders.gl/tiles": "3.1.0-alpha.4",
+    "@loaders.gl/draco": "3.1.0-beta.5",
+    "@loaders.gl/gltf": "3.1.0-beta.5",
+    "@loaders.gl/loader-utils": "3.1.0-beta.5",
+    "@loaders.gl/math": "3.1.0-beta.5",
+    "@loaders.gl/tiles": "3.1.0-beta.5",
     "@math.gl/core": "^3.5.1",
     "@math.gl/geospatial": "^3.5.1"
   },
-  "gitHead": "e309784af37ef9f3640c7733c7851124c72e1fa3"
+  "peerDependencies": {
+    "@loaders.gl/core": "3.1.0-beta.1"
+  },
+  "gitHead": "5d66468457cc878d2dbff3d7807d737ceb181c9a"
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 // LOADERS
 export {Tiles3DLoader} from './tiles-3d-loader';
 export {CesiumIonLoader} from './cesium-ion-loader';
+export {Tile3DSubtreeLoader} from './tile-3d-subtree-loader';
 
 // WRITERS
 export {Tile3DWriter} from './tile-3d-writer';

package/src/lib/classes/{tile-3d-batch-table.js → tile-3d-batch-table.ts}

@@ -21,6 +21,16 @@ const IGNORED_PROPERTY_FIELDS = {
 
 // The size of this array equals the maximum instance count among all loaded tiles, which has the potential to be large.
 export default class Tile3DBatchTableParser {
+  json;
+  binary;
+  featureCount;
+  _extensions;
+  // Copy all top-level property fields from the json object, ignoring special fields
+  _properties;
+  _binaryProperties;
+  // TODO: hierarchy support is only partially implemented and not tested
+  _hierarchy;
+
   constructor(json, binary, featureCount, options = {}) {
     assert(featureCount >= 0);
     this.json = json || {};
@@ -49,11 +59,11 @@ export default class Tile3DBatchTableParser {
     return this.json && this.json.extensions && this.json.extensions[extensionName];
   }
 
-  memorySizeInBytes() {
+  memorySizeInBytes(): number {
     return 0;
   }
 
-  isClass(batchId, className) {
+  isClass(batchId, className: string): boolean {
     this._checkBatchId(batchId);
     assert(typeof className === 'string', className);
 
@@ -178,7 +188,7 @@ export default class Tile3DBatchTableParser {
   _checkBatchId(batchId) {
     const valid = batchId >= 0 && batchId < this.featureCount;
     if (!valid) {
-      throw new Error(`batchId not in range [0, featureCount - 1].`);
+      throw new Error('batchId not in range [0, featureCount - 1].');
     }
   }
 
@@ -191,7 +201,7 @@ export default class Tile3DBatchTableParser {
   }
 
   _initializeBinaryProperties() {
-    let binaryProperties = null;
+    let binaryProperties: Record<string, any> | null = null;
     for (const name in this._properties) {
       const property = this._properties[name];
       const binaryProperty = this._initializeBinaryProperty(name, property);

package/src/lib/classes/{tile-3d-feature-table.js → tile-3d-feature-table.ts}

@@ -6,11 +6,14 @@ import {GL, GLType} from '@loaders.gl/math';
 // Reference:
 // https://github.com/AnalyticalGraphicsInc/cesium/blob/1de96d087f0b17575eb1a3f736407b348c765d59/Source/Scene/Cesium3DTileFeatureTable.js
 export default class Tile3DFeatureTable {
+  json;
+  buffer;
+  featuresLength = 0;
+  _cachedTypedArrays = {};
+
   constructor(featureTableJson, featureTableBinary) {
     this.json = featureTableJson;
     this.buffer = featureTableBinary;
-    this.featuresLength = 0;
-    this._cachedTypedArrays = {};
   }
 
   getExtension(extensionName) {

package/src/lib/parsers/helpers/{normalize-3d-tile-colors.js → normalize-3d-tile-colors.ts}

@@ -1,7 +1,7 @@
 import {decodeRGB565, GL} from '@loaders.gl/math';
 
 /* eslint-disable complexity*/
-export function normalize3DTileColorAttribute(tile, colors, batchTable) {
+export function normalize3DTileColorAttribute(tile, colors, batchTable?) {
   // no colors defined
   if (!colors && (!tile || !tile.batchIds || !batchTable)) {
     return null;

package/src/lib/parsers/helpers/{parse-3d-tile-gltf-view.js → parse-3d-tile-gltf-view.ts}

@@ -90,6 +90,6 @@ function extractGLTFBufferOrURL(tile, gltfFormat, options) {
     case GLTF_FORMAT.EMBEDDED:
       break;
     default:
-      throw new Error(`b3dm: Illegal glTF format field`);
+      throw new Error('b3dm: Illegal glTF format field');
   }
 }

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

@@ -0,0 +1,104 @@
+import type {SubtreeAvailability, ExplicitBitstream} from '../../../types';
+import {fetchFile} from '@loaders.gl/core';
+
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+
+/**
+ * Parse subtree file
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ * @param data
+ * @returns
+ */
+export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<SubtreeAvailability> {
+  const magic = new Uint32Array(data.slice(0, 4));
+
+  if (magic[0] !== SUBTREE_FILE_MAGIC) {
+    throw new Error('Wrong subtree file magic number');
+  }
+
+  const version = new Uint32Array(data.slice(4, 8));
+
+  if (version[0] !== SUBTREE_FILE_VERSION) {
+    throw new Error('Wrong subtree file verson, must be 1');
+  }
+
+  const jsonByteLength = parseUint64Value(data.slice(8, 16));
+  const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
+
+  const textDecoder = new TextDecoder('utf8');
+  const string = textDecoder.decode(stringAttribute);
+  const subtree = JSON.parse(string);
+
+  const binaryByteLength = parseUint64Value(data.slice(16, 24));
+  let internalBinaryBuffer = new ArrayBuffer(0);
+
+  if (binaryByteLength) {
+    internalBinaryBuffer = data.slice(24 + jsonByteLength);
+  }
+
+  if ('bufferView' in subtree.tileAvailability) {
+    subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'tileAvailability',
+      internalBinaryBuffer
+    );
+  }
+
+  if ('bufferView' in subtree.contentAvailability) {
+    subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'contentAvailability',
+      internalBinaryBuffer
+    );
+  }
+
+  if ('bufferView' in subtree.childSubtreeAvailability) {
+    subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'childSubtreeAvailability',
+      internalBinaryBuffer
+    );
+  }
+
+  return subtree;
+}
+
+/**
+ * Get explicit bitstream for subtree availability data.
+ * @param subtree
+ * @param name
+ * @param internalBinaryBuffer
+ */
+async function getExplicitBitstream(
+  subtree: SubtreeAvailability,
+  name: string,
+  internalBinaryBuffer: ArrayBuffer
+): Promise<ExplicitBitstream> {
+  const bufferViewIndex = subtree[name].bufferView;
+  const bufferView = subtree.bufferViews[bufferViewIndex];
+  const buffer = subtree.buffers[bufferView.buffer];
+
+  // External bitstream loading
+  if (buffer.uri) {
+    const response = await fetchFile(buffer.uri);
+    const data = await response.arrayBuffer();
+    // Return view of bitstream.
+    return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+  }
+  // Return view of bitstream.
+  return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+}
+
+/**
+ * Parse buffer to return uint64 value
+ * @param buffer
+ * @returns 64-bit value until precision is lost after Number.MAX_SAFE_INTEGER
+ */
+function parseUint64Value(buffer: ArrayBuffer): number {
+  const dataView = new DataView(buffer);
+  const left = dataView.getUint32(0, true);
+  const right = dataView.getUint32(4, true);
+  // combine the two 32-bit values
+  return left + 2 ** 32 * right;
+}

package/src/lib/parsers/helpers/{parse-3d-tile-tables.js → parse-3d-tile-tables.ts}

@@ -4,7 +4,7 @@
 import {getStringFromArrayBuffer} from './parse-utils';
 
 const SIZEOF_UINT32 = 4;
-const DEPRECATION_WARNING = `b3dm tile in legacy format.`;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
 
 // eslint-disable-next-line max-statements
 export function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {

package/src/lib/parsers/{parse-3d-tile-header.js → parse-3d-tile-header.ts}

@@ -53,7 +53,7 @@ export function normalizeTileHeaders(tileset) {
   const basePath = tileset.basePath;
   const root = normalizeTileData(tileset.root, tileset);
 
-  const stack = [];
+  const stack: any[] = [];
   stack.push(root);
 
   while (stack.length > 0) {

package/src/lib/parsers/{parse-3d-tile-instanced-model.js → parse-3d-tile-instanced-model.ts}

@@ -146,6 +146,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instancePosition.copy(position);
+    // @ts-expect-error
     instanceTranslationRotationScale.translation = instancePosition;
 
     // Get the instance rotation
@@ -203,6 +204,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instanceQuaternion.fromMatrix3(instanceRotation);
+    // @ts-expect-error
     instanceTranslationRotationScale.rotation = instanceQuaternion;
 
     // Get the instance scale
@@ -216,6 +218,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       instanceScale.scale(nonUniformScale);
     }
 
+    // @ts-expect-error
     instanceTranslationRotationScale.scale = instanceScale;
 
     // Get the batchId
@@ -225,12 +228,15 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       batchId = i;
     }
 
+    // @ts-expect-error
     const rotationMatrix = new Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);
 
     // Create the model matrix and the instance
     instanceTransform.identity();
+    // @ts-expect-error
     instanceTransform.translate(instanceTranslationRotationScale.translation);
     instanceTransform.multiplyRight(rotationMatrix);
+    // @ts-expect-error
     instanceTransform.scale(instanceTranslationRotationScale.scale);
 
     const modelMatrix = instanceTransform.clone();

package/src/lib/parsers/{parse-3d-tile-point-cloud.js → parse-3d-tile-point-cloud.ts}

@@ -137,7 +137,7 @@ function parseNormals(tile, featureTable) {
 }
 
 function parseBatchIds(tile, featureTable) {
-  let batchTable = null;
+  let batchTable: Tile3DBatchTable | null = null;
   if (!tile.batchIds && featureTable.hasProperty('BATCH_ID')) {
     tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);
 
@@ -250,7 +250,7 @@ export async function loadDraco(tile, dracoData, options, context) {
 
   tile.attributes = {
     positions: decodedPositions,
-    colors: normalize3DTileColorAttribute(tile, decodedColors),
+    colors: normalize3DTileColorAttribute(tile, decodedColors, undefined),
     normals: decodedNormals,
     batchIds: decodedBatchIds,
     ...batchTableAttributes

package/src/lib/parsers/{parse-3d-tile.js → parse-3d-tile.ts}

@@ -11,9 +11,12 @@ import {parseComposite3DTile} from './parse-3d-tile-composite';
 
 // Extracts
 export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {
+  // @ts-expect-error
   tile.byteOffset = byteOffset;
+  // @ts-expect-error
   tile.type = getMagicString(arrayBuffer, byteOffset);
 
+  // @ts-expect-error
   switch (tile.type) {
     case TILE3D_TYPE.COMPOSITE:
       // Note: We pass this function as argument so that embedded tiles can be parsed recursively
@@ -36,6 +39,7 @@ export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context,
       return await parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context);
 
     default:
+      // @ts-expect-error
       throw new Error(`3DTileLoader: unknown type ${tile.type}`); // eslint-disable-line
   }
 }

package/src/tile-3d-subtree-loader.ts

@@ -0,0 +1,19 @@
+import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import parse3DTilesSubtree from './lib/parsers/helpers/parse-3d-tile-subtree';
+import {VERSION} from './lib/utils/version';
+
+/**
+ * Loader for 3D Tiles Subtree
+ *
+ */
+export const Tile3DSubtreeLoader: LoaderWithParser = {
+  id: '3d-tiles-subtree',
+  name: '3D Tiles Subtree',
+  module: '3d-tiles',
+  version: VERSION,
+  extensions: ['subtree'],
+  mimeTypes: ['application/octet-stream'],
+  tests: ['subtree'],
+  parse: parse3DTilesSubtree,
+  options: {}
+};