@loaders.gl/tiles 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/index.cjs

@@ -17,9 +17,9 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   LOD_METRIC_TYPE: () => LOD_METRIC_TYPE,
   TILESET_TYPE: () => TILESET_TYPE,
   TILE_CONTENT_STATE: () => TILE_CONTENT_STATE,
@@ -34,16 +34,19 @@ __export(src_exports, {
   getFrameState: () => getFrameState,
   getLodStatus: () => getLodStatus
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/tileset/tileset-3d.ts
+// dist/tileset/tileset-3d.js
 var import_core10 = require("@math.gl/core");
 var import_geospatial6 = require("@math.gl/geospatial");
 var import_stats = require("@probe.gl/stats");
 var import_loader_utils4 = require("@loaders.gl/loader-utils");
 
-// src/utils/doubly-linked-list-node.ts
+// dist/utils/doubly-linked-list-node.js
 var DoublyLinkedListNode = class {
+  item;
+  previous;
+  next;
   constructor(item, previous, next) {
     this.item = item;
     this.previous = previous;
@@ -51,13 +54,11 @@ var DoublyLinkedListNode = class {
   }
 };
 
-// src/utils/doubly-linked-list.ts
+// dist/utils/doubly-linked-list.js
 var DoublyLinkedList = class {
-  constructor() {
-    this.head = null;
-    this.tail = null;
-    this._length = 0;
-  }
+  head = null;
+  tail = null;
+  _length = 0;
   get length() {
     return this._length;
   }
@@ -129,8 +130,11 @@ var DoublyLinkedList = class {
   }
 };
 
-// src/tileset/tileset-cache.ts
+// dist/tileset/tileset-cache.js
 var TilesetCache = class {
+  _list;
+  _sentinel;
+  _trimTiles;
   constructor() {
     this._list = new DoublyLinkedList();
     this._sentinel = this._list.add("sentinel");
@@ -182,7 +186,7 @@ var TilesetCache = class {
   }
 };
 
-// src/tileset/helpers/transform-utils.ts
+// dist/tileset/helpers/transform-utils.js
 var import_geospatial = require("@math.gl/geospatial");
 var import_core = require("@math.gl/core");
 var import_loader_utils = require("@loaders.gl/loader-utils");
@@ -190,10 +194,7 @@ function calculateTransformProps(tileHeader, tile) {
   (0, import_loader_utils.assert)(tileHeader);
   (0, import_loader_utils.assert)(tile);
   const { rtcCenter, gltfUpAxis } = tile;
-  const {
-    computedTransform,
-    boundingVolume: { center }
-  } = tileHeader;
+  const { computedTransform, boundingVolume: { center } } = tileHeader;
   let modelMatrix = new import_core.Matrix4(computedTransform);
   if (rtcCenter) {
     modelMatrix.translate(rtcCenter);
@@ -218,10 +219,7 @@ function calculateTransformProps(tileHeader, tile) {
   const cartesianOrigin = new import_core.Vector3(center);
   tile.cartesianModelMatrix = modelMatrix;
   tile.cartesianOrigin = cartesianOrigin;
-  const cartographicOrigin = import_geospatial.Ellipsoid.WGS84.cartesianToCartographic(
-    cartesianOrigin,
-    new import_core.Vector3()
-  );
+  const cartographicOrigin = import_geospatial.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new import_core.Vector3());
   const fromFixedFrameMatrix = import_geospatial.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
   const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
   tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
@@ -231,7 +229,7 @@ function calculateTransformProps(tileHeader, tile) {
   }
 }
 
-// src/tileset/helpers/frame-state.ts
+// dist/tileset/helpers/frame-state.js
 var import_core2 = require("@math.gl/core");
 var import_culling = require("@math.gl/culling");
 var import_geospatial2 = require("@math.gl/geospatial");
@@ -251,10 +249,7 @@ function getFrameState(viewport, frameNumber) {
   const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
   const enuToFixedTransform = import_geospatial2.Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
   const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-  const cameraPositionCartesian2 = import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(
-    cameraPositionCartographic,
-    new import_core2.Vector3()
-  );
+  const cameraPositionCartesian2 = import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new import_core2.Vector3());
   const cameraDirectionCartesian = new import_core2.Vector3(
     // @ts-ignore
     enuToFixedTransform.transformAsVector(new import_core2.Vector3(cameraDirection).scale(metersPerUnit))
@@ -321,10 +316,7 @@ function commonSpacePlanesToWGS84(viewport) {
   const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
   const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
   let i = 0;
-  cullingVolume.planes[i++].fromPointNormal(
-    nearCenterCartesian,
-    scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian)
-  );
+  cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
   for (const dir in frustumPlanes) {
     if (dir === "near") {
       continue;
@@ -349,7 +341,7 @@ function worldToCartesian(viewport, point, out = new import_core2.Vector3()) {
   return import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
 }
 
-// src/tileset/helpers/zoom.ts
+// dist/tileset/helpers/zoom.js
 var import_core3 = require("@math.gl/core");
 var import_culling2 = require("@math.gl/culling");
 var import_geospatial3 = require("@math.gl/geospatial");
@@ -374,22 +366,13 @@ function getZoomFromBoundingVolume(boundingVolume, cartorgraphicCenter) {
   return 1;
 }
 function getZoomFromFullExtent(fullExtent, cartorgraphicCenter, cartesianCenter) {
-  import_geospatial3.Ellipsoid.WGS84.cartographicToCartesian(
-    [fullExtent.xmax, fullExtent.ymax, fullExtent.zmax],
-    scratchVector2
-  );
-  const extentSize = Math.sqrt(
-    Math.pow(scratchVector2[0] - cartesianCenter[0], 2) + Math.pow(scratchVector2[1] - cartesianCenter[1], 2) + Math.pow(scratchVector2[2] - cartesianCenter[2], 2)
-  );
+  import_geospatial3.Ellipsoid.WGS84.cartographicToCartesian([fullExtent.xmax, fullExtent.ymax, fullExtent.zmax], scratchVector2);
+  const extentSize = Math.sqrt(Math.pow(scratchVector2[0] - cartesianCenter[0], 2) + Math.pow(scratchVector2[1] - cartesianCenter[1], 2) + Math.pow(scratchVector2[2] - cartesianCenter[2], 2));
   return Math.log2(WGS84_RADIUS_Z / (extentSize + cartorgraphicCenter[2]));
 }
 function getZoomFromExtent(extent, cartorgraphicCenter, cartesianCenter) {
   const [xmin, ymin, xmax, ymax] = extent;
-  return getZoomFromFullExtent(
-    { xmin, xmax, ymin, ymax, zmin: 0, zmax: 0 },
-    cartorgraphicCenter,
-    cartesianCenter
-  );
+  return getZoomFromFullExtent({ xmin, xmax, ymin, ymax, zmin: 0, zmax: 0 }, cartorgraphicCenter, cartesianCenter);
 }
 function getObbSize(halfAxes) {
   halfAxes.getColumn(0, scratchVector2);
@@ -400,12 +383,12 @@ function getObbSize(halfAxes) {
   return size;
 }
 
-// src/tileset/tile-3d.ts
+// dist/tileset/tile-3d.js
 var import_core7 = require("@math.gl/core");
 var import_culling4 = require("@math.gl/culling");
 var import_core8 = require("@loaders.gl/core");
 
-// src/constants.ts
+// dist/constants.js
 var TILE_CONTENT_STATE = {
   UNLOADED: 0,
   // Has never been requested
@@ -420,35 +403,35 @@ var TILE_CONTENT_STATE = {
   FAILED: 5
   // Request failed.
 };
-var TILE_REFINEMENT = /* @__PURE__ */ ((TILE_REFINEMENT2) => {
+var TILE_REFINEMENT;
+(function(TILE_REFINEMENT2) {
   TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
   TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
-  return TILE_REFINEMENT2;
-})(TILE_REFINEMENT || {});
-var TILE_TYPE = /* @__PURE__ */ ((TILE_TYPE2) => {
+})(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
+var TILE_TYPE;
+(function(TILE_TYPE2) {
   TILE_TYPE2["EMPTY"] = "empty";
   TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
   TILE_TYPE2["POINTCLOUD"] = "pointcloud";
   TILE_TYPE2["MESH"] = "mesh";
-  return TILE_TYPE2;
-})(TILE_TYPE || {});
-var TILESET_TYPE = /* @__PURE__ */ ((TILESET_TYPE2) => {
+})(TILE_TYPE || (TILE_TYPE = {}));
+var TILESET_TYPE;
+(function(TILESET_TYPE2) {
   TILESET_TYPE2["I3S"] = "I3S";
   TILESET_TYPE2["TILES3D"] = "TILES3D";
-  return TILESET_TYPE2;
-})(TILESET_TYPE || {});
-var LOD_METRIC_TYPE = /* @__PURE__ */ ((LOD_METRIC_TYPE2) => {
+})(TILESET_TYPE || (TILESET_TYPE = {}));
+var LOD_METRIC_TYPE;
+(function(LOD_METRIC_TYPE2) {
   LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
   LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
-  return LOD_METRIC_TYPE2;
-})(LOD_METRIC_TYPE || {});
+})(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
 var TILE3D_OPTIMIZATION_HINT = {
   NOT_COMPUTED: -1,
   USE_OPTIMIZATION: 1,
   SKIP_OPTIMIZATION: 0
 };
 
-// src/tileset/helpers/bounding-volume.ts
+// dist/tileset/helpers/bounding-volume.js
 var import_core4 = require("@math.gl/core");
 var import_culling3 = require("@math.gl/culling");
 var import_geospatial4 = require("@math.gl/geospatial");
@@ -550,37 +533,19 @@ function createSphere(sphere, transform, result) {
 }
 function createObbFromRegion(region) {
   const [west, south, east, north, minHeight, maxHeight] = region;
-  const northWest = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(
-    [(0, import_core4.degrees)(west), (0, import_core4.degrees)(north), minHeight],
-    scratchNorthWest
-  );
-  const southEast = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(
-    [(0, import_core4.degrees)(east), (0, import_core4.degrees)(south), maxHeight],
-    scratchSouthEast
-  );
+  const northWest = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core4.degrees)(west), (0, import_core4.degrees)(north), minHeight], scratchNorthWest);
+  const southEast = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core4.degrees)(east), (0, import_core4.degrees)(south), maxHeight], scratchSouthEast);
   const centerInCartesian = new import_core4.Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
   import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(
-    [(0, import_core4.degrees)(east), scratchCenter[1], scratchCenter[2]],
-    scratchXAxis
-  );
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(
-    [scratchCenter[0], (0, import_core4.degrees)(north), scratchCenter[2]],
-    scratchYAxis
-  );
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(
-    [scratchCenter[0], scratchCenter[1], maxHeight],
-    scratchZAxis
-  );
-  return createBox(
-    [
-      ...centerInCartesian,
-      ...scratchXAxis.subtract(centerInCartesian),
-      ...scratchYAxis.subtract(centerInCartesian),
-      ...scratchZAxis.subtract(centerInCartesian)
-    ],
-    new import_core4.Matrix4()
-  );
+  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core4.degrees)(east), scratchCenter[1], scratchCenter[2]], scratchXAxis);
+  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter[0], (0, import_core4.degrees)(north), scratchCenter[2]], scratchYAxis);
+  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter[0], scratchCenter[1], maxHeight], scratchZAxis);
+  return createBox([
+    ...centerInCartesian,
+    ...scratchXAxis.subtract(centerInCartesian),
+    ...scratchYAxis.subtract(centerInCartesian),
+    ...scratchZAxis.subtract(centerInCartesian)
+  ], new import_core4.Matrix4());
 }
 function orientedBoundingBoxToCartographicBounds(boundingVolume) {
   const result = emptyCartographicBounds();
@@ -648,7 +613,7 @@ function addToCartographicBounds(target, cartesian) {
   target[1][2] = Math.max(target[1][2], scratchPoint[2]);
 }
 
-// src/tileset/helpers/tiles-3d-lod.ts
+// dist/tileset/helpers/tiles-3d-lod.js
 var import_core5 = require("@math.gl/core");
 var scratchPositionNormal = new import_core5.Vector3();
 var scratchCartographic = new import_core5.Vector3();
@@ -684,7 +649,7 @@ function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {
   return error;
 }
 
-// src/tileset/helpers/i3s-lod.ts
+// dist/tileset/helpers/i3s-lod.js
 var import_core6 = require("@math.gl/core");
 var import_geospatial5 = require("@math.gl/geospatial");
 var cameraPositionCartesian = new import_core6.Vector3();
@@ -722,38 +687,34 @@ function getProjectedRadius(tile, frameState) {
   import_geospatial5.Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);
   cartesianToEnuMatrix.copy(enuToCartesianMatrix).invert();
   cameraPositionEnu.copy(cameraPositionCartesian).transform(cartesianToEnuMatrix);
-  const projection = Math.sqrt(
-    cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]
-  );
+  const projection = Math.sqrt(cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]);
   const extraZ = projection * projection / cameraPositionEnu[2];
   extraVertexEnu.copy([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
   const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);
   const extraVectorCartesian = extraVertexCartesian.subtract(mbsCenterCartesian).normalize();
   const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
   const sphereMbsBorderVertexCartesian = radiusVector.add(mbsCenterCartesian);
-  const sphereMbsBorderVertexCartographic = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(
-    sphereMbsBorderVertexCartesian
-  );
+  const sphereMbsBorderVertexCartographic = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(sphereMbsBorderVertexCartesian);
   const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);
-  const projectedMbsBorderVertex = viewport.project(
-    sphereMbsBorderVertexCartographic
-  );
+  const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);
   const projectedRadius = projectedOriginVector.copy(projectedOrigin).subtract(projectedMbsBorderVertex).magnitude();
   return projectedRadius;
 }
 
-// src/tileset/helpers/3d-tiles-options.ts
+// dist/tileset/helpers/3d-tiles-options.js
 function get3dTilesOptions(tileset) {
   return {
     assetGltfUpAxis: tileset.asset && tileset.asset.gltfUpAxis || "Y"
   };
 }
 
-// src/utils/managed-array.ts
+// dist/utils/managed-array.js
 var import_loader_utils3 = require("@loaders.gl/loader-utils");
 var ManagedArray = class {
+  _map = /* @__PURE__ */ new Map();
+  _array;
+  _length;
   constructor(length = 0) {
-    this._map = /* @__PURE__ */ new Map();
     this._array = new Array(length);
     this._length = length;
   }
@@ -888,7 +849,7 @@ var ManagedArray = class {
   }
 };
 
-// src/tileset/tileset-traverser.ts
+// dist/tileset/tileset-traverser.js
 var DEFAULT_PROPS = {
   loadSiblings: false,
   skipLevelOfDetail: false,
@@ -899,29 +860,30 @@ var DEFAULT_PROPS = {
   basePath: ""
 };
 var TilesetTraverser = class {
-  // TODO nested props
-  constructor(options) {
-    // fulfill in traverse call
-    this.root = null;
-    // tiles should be rendered
-    this.selectedTiles = {};
-    // tiles should be loaded from server
-    this.requestedTiles = {};
-    // tiles does not have render content
-    this.emptyTiles = {};
-    this.lastUpdate = new Date().getTime();
-    this.updateDebounceTime = 1e3;
-    /** temporary storage to hold the traversed tiles during a traversal */
-    this._traversalStack = new ManagedArray();
-    this._emptyTraversalStack = new ManagedArray();
-    /** set in every traverse cycle */
-    this._frameNumber = null;
-    this.options = { ...DEFAULT_PROPS, ...options };
-  }
+  options;
+  // fulfill in traverse call
+  root = null;
+  // tiles should be rendered
+  selectedTiles = {};
+  // tiles should be loaded from server
+  requestedTiles = {};
+  // tiles does not have render content
+  emptyTiles = {};
+  lastUpdate = new Date().getTime();
+  updateDebounceTime = 1e3;
+  /** temporary storage to hold the traversed tiles during a traversal */
+  _traversalStack = new ManagedArray();
+  _emptyTraversalStack = new ManagedArray();
+  /** set in every traverse cycle */
+  _frameNumber = null;
   // RESULT
   traversalFinished(frameState) {
     return true;
   }
+  // TODO nested props
+  constructor(options) {
+    this.options = { ...DEFAULT_PROPS, ...options };
+  }
   // tiles should be visible
   traverse(root, frameState, options) {
     this.root = root;
@@ -957,12 +919,7 @@ var TilesetTraverser = class {
       let shouldRefine = false;
       if (this.canTraverse(tile, frameState)) {
         this.updateChildTiles(tile, frameState);
-        shouldRefine = this.updateAndPushChildren(
-          tile,
-          frameState,
-          stack,
-          tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth
-        );
+        shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
       }
       const parent = tile.parent;
       const parentRefines = Boolean(!parent || parent._shouldRefine);
@@ -973,10 +930,10 @@ var TilesetTraverser = class {
         if (stoppedRefining) {
           this.selectTile(tile, frameState);
         }
-      } else if (tile.refine === 1 /* ADD */) {
+      } else if (tile.refine === TILE_REFINEMENT.ADD) {
         this.loadTile(tile, frameState);
         this.selectTile(tile, frameState);
-      } else if (tile.refine === 2 /* REPLACE */) {
+      } else if (tile.refine === TILE_REFINEMENT.REPLACE) {
         this.loadTile(tile, frameState);
         if (stoppedRefining) {
           this.selectTile(tile, frameState);
@@ -1002,7 +959,7 @@ var TilesetTraverser = class {
     const { loadSiblings, skipLevelOfDetail } = this.options;
     const children = tile.children;
     children.sort(this.compareDistanceToCamera.bind(this));
-    const checkRefines = tile.refine === 2 /* REPLACE */ && tile.hasRenderContent && !skipLevelOfDetail;
+    const checkRefines = tile.refine === TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;
     let hasVisibleChild = false;
     let refines = true;
     for (const child of children) {
@@ -1145,12 +1102,75 @@ var TilesetTraverser = class {
   }
 };
 
-// src/tileset/tile-3d.ts
+// dist/tileset/tile-3d.js
 var scratchVector3 = new import_core7.Vector3();
 function defined2(x) {
   return x !== void 0 && x !== null;
 }
 var Tile3D = class {
+  tileset;
+  header;
+  id;
+  url;
+  parent;
+  /* Specifies the type of refine that is used when traversing this tile for rendering. */
+  refine;
+  type;
+  contentUrl;
+  /** Different refinement algorithms used by I3S and 3D tiles */
+  lodMetricType = "geometricError";
+  /** The error, in meters, introduced if this tile is rendered and its children are not. */
+  lodMetricValue = 0;
+  /** @todo math.gl is not exporting BoundingVolume base type? */
+  boundingVolume = null;
+  /**
+   * The tile's content.  This represents the actual tile's payload,
+   * not the content's metadata in the tileset JSON file.
+   */
+  content = null;
+  contentState = TILE_CONTENT_STATE.UNLOADED;
+  gpuMemoryUsageInBytes = 0;
+  /** The tile's children - an array of Tile3D objects. */
+  children = [];
+  depth = 0;
+  viewportIds = [];
+  transform = new import_core7.Matrix4();
+  extensions = null;
+  /** TODO Cesium 3d tiles specific */
+  implicitTiling = null;
+  /** Container to store application specific data */
+  userData = {};
+  computedTransform;
+  hasEmptyContent = false;
+  hasTilesetContent = false;
+  traverser = new TilesetTraverser({});
+  /** Used by TilesetCache */
+  _cacheNode = null;
+  _frameNumber = null;
+  // TODO Cesium 3d tiles specific
+  _expireDate = null;
+  _expiredContent = null;
+  _boundingBox = void 0;
+  /** updated every frame for tree traversal and rendering optimizations: */
+  _distanceToCamera = 0;
+  _screenSpaceError = 0;
+  _visibilityPlaneMask;
+  _visible = void 0;
+  _contentBoundingVolume;
+  _viewerRequestVolume;
+  _initialTransform = new import_core7.Matrix4();
+  // Used by traverser, cannot be marked private
+  _priority = 0;
+  _selectedFrame = 0;
+  _requestedFrame = 0;
+  _selectionDepth = 0;
+  _touchedFrame = 0;
+  _centerZDepth = 0;
+  _shouldRefine = false;
+  _stackLength = 0;
+  _visitedFrame = 0;
+  _inRequestVolume = false;
+  _lodJudge = null;
   // TODO i3s specific, needs to remove
   /**
    * @constructs
@@ -1163,56 +1183,6 @@ var Tile3D = class {
    */
   // eslint-disable-next-line max-statements
   constructor(tileset, header, parentHeader, extendedId = "") {
-    /** Different refinement algorithms used by I3S and 3D tiles */
-    this.lodMetricType = "geometricError";
-    /** The error, in meters, introduced if this tile is rendered and its children are not. */
-    this.lodMetricValue = 0;
-    /** @todo math.gl is not exporting BoundingVolume base type? */
-    this.boundingVolume = null;
-    /**
-     * The tile's content.  This represents the actual tile's payload,
-     * not the content's metadata in the tileset JSON file.
-     */
-    this.content = null;
-    this.contentState = TILE_CONTENT_STATE.UNLOADED;
-    this.gpuMemoryUsageInBytes = 0;
-    /** The tile's children - an array of Tile3D objects. */
-    this.children = [];
-    this.depth = 0;
-    this.viewportIds = [];
-    this.transform = new import_core7.Matrix4();
-    this.extensions = null;
-    /** TODO Cesium 3d tiles specific */
-    this.implicitTiling = null;
-    /** Container to store application specific data */
-    this.userData = {};
-    this.hasEmptyContent = false;
-    this.hasTilesetContent = false;
-    this.traverser = new TilesetTraverser({});
-    /** Used by TilesetCache */
-    this._cacheNode = null;
-    this._frameNumber = null;
-    // TODO Cesium 3d tiles specific
-    this._expireDate = null;
-    this._expiredContent = null;
-    this._boundingBox = void 0;
-    /** updated every frame for tree traversal and rendering optimizations: */
-    this._distanceToCamera = 0;
-    this._screenSpaceError = 0;
-    this._visible = void 0;
-    this._initialTransform = new import_core7.Matrix4();
-    // Used by traverser, cannot be marked private
-    this._priority = 0;
-    this._selectedFrame = 0;
-    this._requestedFrame = 0;
-    this._selectionDepth = 0;
-    this._touchedFrame = 0;
-    this._centerZDepth = 0;
-    this._shouldRefine = false;
-    this._stackLength = 0;
-    this._visitedFrame = 0;
-    this._inRequestVolume = false;
-    this._lodJudge = null;
     this.header = header;
     this.tileset = tileset;
     this.id = extendedId || header.id;
@@ -1263,9 +1233,7 @@ var Tile3D = class {
    * content is ready or if it has expired content this renders while new content loads; otherwise,
    */
   get contentAvailable() {
-    return Boolean(
-      this.contentReady && this.hasRenderContent || this._expiredContent && !this.contentFailed
-    );
+    return Boolean(this.contentReady && this.hasRenderContent || this._expiredContent && !this.contentFailed);
   }
   /** Returns true if tile has renderable content but it's unloaded */
   get hasUnloadedContent() {
@@ -1315,9 +1283,9 @@ var Tile3D = class {
   /** Get the tile's screen space error. */
   getScreenSpaceError(frameState, useParentLodMetric) {
     switch (this.tileset.type) {
-      case "I3S" /* I3S */:
+      case TILESET_TYPE.I3S:
         return getProjectedRadius(this, frameState);
-      case "TILES3D" /* TILES3D */:
+      case TILESET_TYPE.TILES3D:
         return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);
       default:
         throw new Error("Unsupported tileset type");
@@ -1344,7 +1312,7 @@ var Tile3D = class {
   _getPriority() {
     const traverser = this.tileset._traverser;
     const { skipLevelOfDetail } = traverser.options;
-    const maySkipTile = this.refine === 1 /* ADD */ || skipLevelOfDetail;
+    const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;
     if (maySkipTile && !this.isVisible && this._visible !== void 0) {
       return -1;
     }
@@ -1377,10 +1345,7 @@ var Tile3D = class {
       this._expireDate = null;
     }
     this.contentState = TILE_CONTENT_STATE.LOADING;
-    const requestToken = await this.tileset._requestScheduler.scheduleRequest(
-      this.id,
-      this._getPriority.bind(this)
-    );
+    const requestToken = await this.tileset._requestScheduler.scheduleRequest(this.id, this._getPriority.bind(this));
     if (!requestToken) {
       this.contentState = TILE_CONTENT_STATE.UNLOADED;
       return false;
@@ -1521,9 +1486,7 @@ var Tile3D = class {
       this.lodMetricValue = header.lodMetricValue;
     } else {
       this.lodMetricValue = this.parent && this.parent.lodMetricValue || this.tileset.lodMetricValue;
-      console.warn(
-        "3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue"
-      );
+      console.warn("3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue");
     }
   }
   _initializeTransforms(tileHeader) {
@@ -1570,7 +1533,7 @@ var Tile3D = class {
     this._priority = 0;
   }
   _getRefine(refine) {
-    return refine || this.parent && this.parent.refine || 2 /* REPLACE */;
+    return refine || this.parent && this.parent.refine || TILE_REFINEMENT.REPLACE;
   }
   _isTileset() {
     return this.contentUrl.indexOf(".json") !== -1;
@@ -1590,28 +1553,16 @@ var Tile3D = class {
     }
   }
   _updateBoundingVolume(header) {
-    this.boundingVolume = createBoundingVolume(
-      header.boundingVolume,
-      this.computedTransform,
-      this.boundingVolume
-    );
+    this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume);
     const content = header.content;
     if (!content) {
       return;
     }
     if (content.boundingVolume) {
-      this._contentBoundingVolume = createBoundingVolume(
-        content.boundingVolume,
-        this.computedTransform,
-        this._contentBoundingVolume
-      );
+      this._contentBoundingVolume = createBoundingVolume(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
     }
     if (header.viewerRequestVolume) {
-      this._viewerRequestVolume = createBoundingVolume(
-        header.viewerRequestVolume,
-        this.computedTransform,
-        this._viewerRequestVolume
-      );
+      this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
     }
   }
   // Update the tile's transform. The transform is applied to the tile's bounding volumes.
@@ -1654,7 +1605,7 @@ var Tile3D = class {
   }
 };
 
-// src/tileset/format-3d-tiles/tileset-3d-traverser.ts
+// dist/tileset/format-3d-tiles/tileset-3d-traverser.js
 var Tileset3DTraverser = class extends TilesetTraverser {
   compareDistanceToCamera(a, b) {
     return b._distanceToCamera === 0 && a._distanceToCamera === 0 ? b._centerZDepth - a._centerZDepth : b._distanceToCamera - a._distanceToCamera;
@@ -1675,7 +1626,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
       tile._visible = false;
       return;
     }
-    const replace = tile.refine === 2 /* REPLACE */;
+    const replace = tile.refine === TILE_REFINEMENT.REPLACE;
     const useOptimization = tile._optimChildrenWithinParent === TILE3D_OPTIMIZATION_HINT.USE_OPTIMIZATION;
     if (replace && useOptimization && hasChildren) {
       if (!this.anyChildrenVisible(tile, frameState)) {
@@ -1686,21 +1637,19 @@ var Tileset3DTraverser = class extends TilesetTraverser {
   }
   meetsScreenSpaceErrorEarly(tile, frameState) {
     const { parent } = tile;
-    if (!parent || parent.hasTilesetContent || parent.refine !== 1 /* ADD */) {
+    if (!parent || parent.hasTilesetContent || parent.refine !== TILE_REFINEMENT.ADD) {
       return false;
     }
     return !this.shouldRefine(tile, frameState, true);
   }
 };
 
-// src/tileset/format-i3s/i3s-tileset-traverser.ts
+// dist/tileset/format-i3s/i3s-tileset-traverser.js
 var import_core9 = require("@loaders.gl/core");
 
-// src/tileset/format-i3s/i3s-pending-tiles-register.ts
+// dist/tileset/format-i3s/i3s-pending-tiles-register.js
 var I3SPendingTilesRegister = class {
-  constructor() {
-    this.frameNumberMap = /* @__PURE__ */ new Map();
-  }
+  frameNumberMap = /* @__PURE__ */ new Map();
   /**
    * Register a new pending tile header for the particular frameNumber
    * @param viewportId
@@ -1738,15 +1687,16 @@ var I3SPendingTilesRegister = class {
   }
 };
 
-// src/tileset/format-i3s/i3s-tile-manager.ts
+// dist/tileset/format-i3s/i3s-tile-manager.js
 var STATUS = {
   REQUESTED: "REQUESTED",
   COMPLETED: "COMPLETED",
   ERROR: "ERROR"
 };
 var I3STileManager = class {
+  _statusMap;
+  pendingTilesRegister = new I3SPendingTilesRegister();
   constructor() {
-    this.pendingTilesRegister = new I3SPendingTilesRegister();
     this._statusMap = {};
   }
   /**
@@ -1758,26 +1708,17 @@ var I3STileManager = class {
    */
   add(request, key, callback, frameState) {
     if (!this._statusMap[key]) {
-      const {
-        frameNumber,
-        viewport: { id }
-      } = frameState;
+      const { frameNumber, viewport: { id } } = frameState;
       this._statusMap[key] = { request, callback, key, frameState, status: STATUS.REQUESTED };
       this.pendingTilesRegister.register(id, frameNumber);
       request().then((data) => {
         this._statusMap[key].status = STATUS.COMPLETED;
-        const {
-          frameNumber: actualFrameNumber,
-          viewport: { id: id2 }
-        } = this._statusMap[key].frameState;
+        const { frameNumber: actualFrameNumber, viewport: { id: id2 } } = this._statusMap[key].frameState;
         this.pendingTilesRegister.deregister(id2, actualFrameNumber);
         this._statusMap[key].callback(data, frameState);
       }).catch((error) => {
         this._statusMap[key].status = STATUS.ERROR;
-        const {
-          frameNumber: actualFrameNumber,
-          viewport: { id: id2 }
-        } = this._statusMap[key].frameState;
+        const { frameNumber: actualFrameNumber, viewport: { id: id2 } } = this._statusMap[key].frameState;
         this.pendingTilesRegister.deregister(id2, actualFrameNumber);
         callback(error);
       });
@@ -1790,15 +1731,9 @@ var I3STileManager = class {
    */
   update(key, frameState) {
     if (this._statusMap[key]) {
-      const {
-        frameNumber,
-        viewport: { id }
-      } = this._statusMap[key].frameState;
+      const { frameNumber, viewport: { id } } = this._statusMap[key].frameState;
       this.pendingTilesRegister.deregister(id, frameNumber);
-      const {
-        frameNumber: newFrameNumber,
-        viewport: { id: newViewportId }
-      } = frameState;
+      const { frameNumber: newFrameNumber, viewport: { id: newViewportId } } = frameState;
       this.pendingTilesRegister.register(newViewportId, newFrameNumber);
       this._statusMap[key].frameState = frameState;
     }
@@ -1822,8 +1757,9 @@ var I3STileManager = class {
   }
 };
 
-// src/tileset/format-i3s/i3s-tileset-traverser.ts
+// dist/tileset/format-i3s/i3s-tileset-traverser.js
 var I3STilesetTraverser = class extends TilesetTraverser {
+  _tileManager;
   constructor(options) {
     super(options);
     this._tileManager = new I3STileManager();
@@ -1854,12 +1790,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
           if (tileset.tileset.nodePages) {
             request = () => tileset.tileset.nodePagesTile.formTileFromNodePages(child.id);
           }
-          this._tileManager.add(
-            request,
-            extendedId,
-            (header) => this._onTileLoad(header, tile, extendedId),
-            frameState
-          );
+          this._tileManager.add(request, extendedId, (header) => this._onTileLoad(header, tile, extendedId), frameState);
         } else {
           this._tileManager.update(extendedId, frameState);
         }
@@ -1900,7 +1831,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
   }
 };
 
-// src/tileset/tileset-3d.ts
+// dist/tileset/tileset-3d.js
 var DEFAULT_PROPS2 = {
   description: "",
   ellipsoid: import_geospatial6.Ellipsoid.WGS84,
@@ -1943,6 +1874,78 @@ var POINTS_COUNT = "Points/Vertices";
 var TILES_GPU_MEMORY = "Tile Memory Use";
 var MAXIMUM_SSE = "Maximum Screen Space Error";
 var Tileset3D = class {
+  // props: Tileset3DProps;
+  options;
+  loadOptions;
+  type;
+  tileset;
+  loader;
+  url;
+  basePath;
+  modelMatrix;
+  ellipsoid;
+  lodMetricType;
+  lodMetricValue;
+  refine;
+  root = null;
+  roots = {};
+  /** @todo any->unknown */
+  asset = {};
+  // Metadata for the entire tileset
+  description = "";
+  properties;
+  extras = null;
+  attributions = {};
+  credits = {};
+  stats;
+  /** flags that contain information about data types in nested tiles */
+  contentFormats = { draco: false, meshopt: false, dds: false, ktx2: false };
+  // view props
+  cartographicCenter = null;
+  cartesianCenter = null;
+  zoom = 1;
+  boundingVolume = null;
+  /** Updated based on the camera position and direction */
+  dynamicScreenSpaceErrorComputedDensity = 0;
+  // METRICS
+  /**
+   * The maximum amount of GPU memory (in MB) that may be used to cache tiles
+   * Tiles not in view are unloaded to enforce private
+   */
+  maximumMemoryUsage = 32;
+  /** The total amount of GPU memory in bytes used by the tileset. */
+  gpuMemoryUsageInBytes = 0;
+  /**
+   * If loading the level of detail required by maximumScreenSpaceError
+   * results in the memory usage exceeding maximumMemoryUsage (GPU), level of detail refinement
+   * will instead use this (larger) adjusted screen space error to achieve the
+   * best possible visual quality within the available memory.
+   */
+  memoryAdjustedScreenSpaceError = 0;
+  _cacheBytes = 0;
+  _cacheOverflowBytes = 0;
+  /** Update tracker. increase in each update cycle. */
+  _frameNumber = 0;
+  _queryParams = {};
+  _extensionsUsed = [];
+  _tiles = {};
+  /** counter for tracking tiles requests */
+  _pendingCount = 0;
+  /** Hold traversal results */
+  selectedTiles = [];
+  // TRAVERSAL
+  traverseCounter = 0;
+  geometricError = 0;
+  lastUpdatedVieports = null;
+  _requestedTiles = [];
+  _emptyTiles = [];
+  frameStateData = {};
+  _traverser;
+  _cache = new TilesetCache();
+  _requestScheduler;
+  // Promise tracking
+  updatePromise = null;
+  tilesetInitializationPromise;
   /**
    * Create a new Tileset3D
    * @param json
@@ -1950,60 +1953,6 @@ var Tileset3D = class {
    */
   // eslint-disable-next-line max-statements
   constructor(tileset, options) {
-    this.root = null;
-    this.roots = {};
-    /** @todo any->unknown */
-    this.asset = {};
-    // Metadata for the entire tileset
-    this.description = "";
-    this.extras = null;
-    this.attributions = {};
-    this.credits = {};
-    /** flags that contain information about data types in nested tiles */
-    this.contentFormats = { draco: false, meshopt: false, dds: false, ktx2: false };
-    // view props
-    this.cartographicCenter = null;
-    this.cartesianCenter = null;
-    this.zoom = 1;
-    this.boundingVolume = null;
-    /** Updated based on the camera position and direction */
-    this.dynamicScreenSpaceErrorComputedDensity = 0;
-    // METRICS
-    /**
-     * The maximum amount of GPU memory (in MB) that may be used to cache tiles
-     * Tiles not in view are unloaded to enforce private
-     */
-    this.maximumMemoryUsage = 32;
-    /** The total amount of GPU memory in bytes used by the tileset. */
-    this.gpuMemoryUsageInBytes = 0;
-    /**
-     * If loading the level of detail required by maximumScreenSpaceError
-     * results in the memory usage exceeding maximumMemoryUsage (GPU), level of detail refinement
-     * will instead use this (larger) adjusted screen space error to achieve the
-     * best possible visual quality within the available memory.
-     */
-    this.memoryAdjustedScreenSpaceError = 0;
-    this._cacheBytes = 0;
-    this._cacheOverflowBytes = 0;
-    /** Update tracker. increase in each update cycle. */
-    this._frameNumber = 0;
-    this._queryParams = {};
-    this._extensionsUsed = [];
-    this._tiles = {};
-    /** counter for tracking tiles requests */
-    this._pendingCount = 0;
-    /** Hold traversal results */
-    this.selectedTiles = [];
-    // TRAVERSAL
-    this.traverseCounter = 0;
-    this.geometricError = 0;
-    this.lastUpdatedVieports = null;
-    this._requestedTiles = [];
-    this._emptyTiles = [];
-    this.frameStateData = {};
-    this._cache = new TilesetCache();
-    // Promise tracking
-    this.updatePromise = null;
     this.options = { ...DEFAULT_PROPS2, ...options };
     this.tileset = tileset;
     this.loader = tileset.loader;
@@ -2114,10 +2063,7 @@ var Tileset3D = class {
   }
   adjustScreenSpaceError() {
     if (this.gpuMemoryUsageInBytes < this._cacheBytes) {
-      this.memoryAdjustedScreenSpaceError = Math.max(
-        this.memoryAdjustedScreenSpaceError / 1.02,
-        this.options.maximumScreenSpaceError
-      );
+      this.memoryAdjustedScreenSpaceError = Math.max(this.memoryAdjustedScreenSpaceError / 1.02, this.options.maximumScreenSpaceError);
     } else if (this.gpuMemoryUsageInBytes > this._cacheBytes + this._cacheOverflowBytes) {
       this.memoryAdjustedScreenSpaceError *= 1.02;
     }
@@ -2185,11 +2131,7 @@ var Tileset3D = class {
     }
     const currentFrameStateData = this.frameStateData[id];
     const selectedTiles = Object.values(this._traverser.selectedTiles);
-    const [filteredSelectedTiles, unselectedTiles] = limitSelectedTiles(
-      selectedTiles,
-      frameState,
-      this.options.maximumTilesSelected
-    );
+    const [filteredSelectedTiles, unselectedTiles] = limitSelectedTiles(selectedTiles, frameState, this.options.maximumTilesSelected);
     currentFrameStateData.selectedTiles = filteredSelectedTiles;
     for (const tile of unselectedTiles) {
       tile.unselect();
@@ -2262,16 +2204,16 @@ var Tileset3D = class {
     this.stats.get(MAXIMUM_SSE).count = this.memoryAdjustedScreenSpaceError;
   }
   async _initializeTileSet(tilesetJson) {
-    if (this.type === "I3S" /* I3S */) {
+    if (this.type === TILESET_TYPE.I3S) {
       this.calculateViewPropsI3S();
       tilesetJson.root = await tilesetJson.root;
     }
     this.root = this._initializeTileHeaders(tilesetJson, null);
-    if (this.type === "TILES3D" /* TILES3D */) {
+    if (this.type === TILESET_TYPE.TILES3D) {
       this._initializeTiles3DTileset(tilesetJson);
       this.calculateViewPropsTiles3D();
     }
-    if (this.type === "I3S" /* I3S */) {
+    if (this.type === TILESET_TYPE.I3S) {
       this._initializeI3STileset();
     }
   }
@@ -2286,11 +2228,7 @@ var Tileset3D = class {
     const fullExtent = this.tileset.fullExtent;
     if (fullExtent) {
       const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
-      this.cartographicCenter = new import_core10.Vector3(
-        xmin + (xmax - xmin) / 2,
-        ymin + (ymax - ymin) / 2,
-        zmin + (zmax - zmin) / 2
-      );
+      this.cartographicCenter = new import_core10.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
       this.cartesianCenter = new import_core10.Vector3();
       import_geospatial6.Ellipsoid.WGS84.cartographicToCartesian(this.cartographicCenter, this.cartesianCenter);
       this.zoom = getZoomFromFullExtent(fullExtent, this.cartographicCenter, this.cartesianCenter);
@@ -2356,7 +2294,7 @@ var Tileset3D = class {
       parentTileHeader.children.push(rootTile);
       rootTile.depth = parentTileHeader.depth + 1;
     }
-    if (this.type === "TILES3D" /* TILES3D */) {
+    if (this.type === TILESET_TYPE.TILES3D) {
       const stack = [];
       stack.push(rootTile);
       while (stack.length > 0) {
@@ -2384,10 +2322,10 @@ var Tileset3D = class {
     let TraverserClass;
     const type = this.type;
     switch (type) {
-      case "TILES3D" /* TILES3D */:
+      case TILESET_TYPE.TILES3D:
         TraverserClass = Tileset3DTraverser;
         break;
-      case "I3S" /* I3S */:
+      case TILESET_TYPE.I3S:
         TraverserClass = I3STilesetTraverser;
         break;
       default:
@@ -2425,7 +2363,7 @@ var Tileset3D = class {
     if (!loaded) {
       return;
     }
-    if (this.type === "I3S" /* I3S */) {
+    if (this.type === TILESET_TYPE.I3S) {
       const nodesInNodePages = ((_b = (_a = this.tileset) == null ? void 0 : _a.nodePagesTile) == null ? void 0 : _b.nodesInNodePages) || 0;
       this.stats.get(TILES_TOTAL).reset();
       this.stats.get(TILES_TOTAL).addCount(nodesInNodePages);
@@ -2443,7 +2381,7 @@ var Tileset3D = class {
    */
   updateContentTypes(tile) {
     var _a;
-    if (this.type === "I3S" /* I3S */) {
+    if (this.type === TILESET_TYPE.I3S) {
       if (tile.header.isDracoGeometry) {
         this.contentFormats.draco = true;
       }
@@ -2456,7 +2394,7 @@ var Tileset3D = class {
           break;
         default:
       }
-    } else if (this.type === "TILES3D" /* TILES3D */) {
+    } else if (this.type === TILESET_TYPE.TILES3D) {
       const { extensionsRemoved = [] } = ((_a = tile.content) == null ? void 0 : _a.gltf) || {};
       if (extensionsRemoved.includes("KHR_draco_mesh_compression")) {
         this.contentFormats.draco = true;
@@ -2564,3 +2502,4 @@ var Tileset3D = class {
     }
   }
 };
+//# sourceMappingURL=index.cjs.map