@deck.gl/geo-layers 9.0.40 → 9.1.0-beta.3

package/dist/index.cjs

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -69,6 +73,7 @@ var defaultProps = {
   layers: { type: "array", compare: true, value: [] },
   onMetadataLoad: { type: "function", value: () => {
   } },
+  // eslint-disable-next-line
   onMetadataLoadError: { type: "function", value: console.error },
   onImageLoadStart: { type: "function", value: () => {
   } },
@@ -77,14 +82,17 @@ var defaultProps = {
   onImageLoadError: {
     type: "function",
     compare: false,
+    // eslint-disable-next-line
     value: (requestId, error) => console.error(error, requestId)
   }
 };
 var WMSLayer = class extends import_core.CompositeLayer {
+  /** Returns true if all async resources are loaded */
   get isLoaded() {
     var _a;
     return ((_a = this.state) == null ? void 0 : _a.loadCounter) === 0 && super.isLoaded;
   }
+  /** Lets deck.gl know that we want viewport change events */
   shouldUpdateState() {
     return true;
   }
@@ -144,6 +152,7 @@ var WMSLayer = class extends import_core.CompositeLayer {
     }
     throw new Error("invalid image source in props.data");
   }
+  /** Run a getMetadata on the image service */
   async _loadMetadata() {
     var _a, _b;
     const { imageSource } = this.state;
@@ -159,6 +168,7 @@ var WMSLayer = class extends import_core.CompositeLayer {
       this.state.loadCounter--;
     }
   }
+  /** Load an image */
   async loadImage(viewport, reason) {
     var _a, _b;
     const { layers, serviceType } = this.props;
@@ -207,9 +217,12 @@ var WMSLayer = class extends import_core.CompositeLayer {
       this.state.loadCounter--;
     }
   }
+  // HELPERS
+  /** Global counter for issuing unique request ids */
   getRequestId() {
     return this.state._nextRequestId++;
   }
+  /** Runs an action in the future, cancels it if the new action is issued before it executes */
   debounce(fn, ms = 500) {
     clearTimeout(this.state._timeoutId);
     this.state._timeoutId = setTimeout(() => fn(), ms);
@@ -237,6 +250,7 @@ var defaultProps3 = {
   ...import_layers3.PolygonLayer.defaultProps
 };
 var GeoCellLayer = class extends import_core2.CompositeLayer {
+  /** Implement to generate props to create geometry. */
   indexToBounds() {
     return null;
   }
@@ -534,9 +548,11 @@ var Tile2DHeader = class {
     this._isCancelled = false;
     this._needsReload = false;
   }
+  /** @deprecated use `boundingBox` instead */
   get bbox() {
     return this._bbox;
   }
+  // TODO - remove in v9
   set bbox(value) {
     if (this._bbox)
       return;
@@ -572,6 +588,7 @@ var Tile2DHeader = class {
     }
     return result;
   }
+  /* eslint-disable max-statements */
   async _loadData({ getData, requestScheduler, onLoad, onError }) {
     const { index, id, bbox, userData, zoom } = this;
     const loaderId = this._loaderId;
@@ -682,6 +699,7 @@ var OSMNode = class {
     }
     return this._children;
   }
+  // eslint-disable-next-line complexity
   update(params) {
     const { viewport, cullingVolume, elevationBounds, minZ, maxZ, bounds, offset, project } = params;
     const boundingVolume = this.getBoundingVolume(elevationBounds, offset, project);
@@ -749,7 +767,10 @@ var OSMNode = class {
   }
 };
 function getOSMTileIndices(viewport, maxZ, zRange, bounds) {
-  const project = viewport instanceof import_core3._GlobeViewport && viewport.resolution ? viewport.projectPosition : null;
+  const project = viewport instanceof import_core3._GlobeViewport && viewport.resolution ? (
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    viewport.projectPosition
+  ) : null;
   const planes = Object.values(viewport.getFrustumPlanes()).map(({ normal, distance }) => new import_culling.Plane(normal.clone().negate(), distance));
   const cullingVolume = new import_culling.CullingVolume(planes);
   const unitsPerMeter = viewport.distanceScales.unitsPerMeter[2];
@@ -771,6 +792,7 @@ function getOSMTileIndices(viewport, maxZ, zRange, bounds) {
     minZ,
     maxZ,
     bounds,
+    // num. of worlds from the center. For repeated maps
     offset: 0
   };
   root.update(traversalParams);
@@ -819,15 +841,23 @@ var urlType = {
 };
 function transformBox(bbox, modelMatrix) {
   const transformedCoords = [
+    // top-left
     modelMatrix.transformAsPoint([bbox[0], bbox[1]]),
+    // top-right
     modelMatrix.transformAsPoint([bbox[2], bbox[1]]),
+    // bottom-left
     modelMatrix.transformAsPoint([bbox[0], bbox[3]]),
+    // bottom-right
     modelMatrix.transformAsPoint([bbox[2], bbox[3]])
   ];
   const transformedBox = [
+    // Minimum x coord
     Math.min(...transformedCoords.map((i) => i[0])),
+    // Minimum y coord
     Math.min(...transformedCoords.map((i) => i[1])),
+    // Max x coord
     Math.max(...transformedCoords.map((i) => i[0])),
+    // Max y coord
     Math.max(...transformedCoords.map((i) => i[1]))
   ];
   return transformedBox;
@@ -871,8 +901,10 @@ function getBoundingBox(viewport, zRange, extent) {
   }
   if (!viewport.isGeospatial) {
     return [
+      // Top corner should not be more then bottom corner in either direction
       Math.max(Math.min(bounds[0], extent[2]), extent[0]),
       Math.max(Math.min(bounds[1], extent[3]), extent[1]),
+      // Bottom corner should not be less then top corner in either direction
       Math.min(Math.max(bounds[2], extent[0]), extent[2]),
       Math.min(Math.max(bounds[3], extent[1]), extent[3])
     ];
@@ -1040,6 +1072,8 @@ var DEFAULT_TILESET2D_PROPS = {
   maxRequests: 6,
   debounceTime: 0,
   zoomOffset: 0,
+  // onTileLoad: (tile: Tile2DHeader) => void,  // onTileUnload: (tile: Tile2DHeader) => void,  // onTileError: (error: any, tile: Tile2DHeader) => void,  /** Called when all tiles in the current viewport are loaded. */
+  // onViewportLoad: ((tiles: Tile2DHeader<DataT>[]) => void) | null,
   onTileLoad: () => {
   },
   onTileUnload: () => {
@@ -1048,6 +1082,10 @@ var DEFAULT_TILESET2D_PROPS = {
   }
 };
 var Tileset2D = class {
+  /**
+   * Takes in a function that returns tile data, a cache size, and a max and a min zoom level.
+   * Cache size defaults to 5 * number of tiles in the current viewport
+   */
   constructor(opts) {
     this._getCullBounds = memoize(getCullBounds);
     this.opts = { ...DEFAULT_TILESET2D_PROPS, ...opts };
@@ -1055,7 +1093,7 @@ var Tileset2D = class {
     this.onTileLoad = (tile) => {
       var _a, _b;
       (_b = (_a = this.opts).onTileLoad) == null ? void 0 : _b.call(_a, tile);
-      if (this.opts.maxCacheByteSize != null) {
+      if (this.opts.maxCacheByteSize !== null) {
         this._cacheByteSize += tile.byteLength;
         this._resizeCache();
       }
@@ -1076,6 +1114,7 @@ var Tileset2D = class {
     this._modelMatrix = new import_core4.Matrix4();
     this._modelMatrixInverse = new import_core4.Matrix4();
   }
+  /* Public API */
   get tiles() {
     return this._tiles;
   }
@@ -1097,6 +1136,7 @@ var Tileset2D = class {
       this._minZoom = Math.ceil(opts.minZoom);
     }
   }
+  // Clean up any outstanding tile requests.
   finalize() {
     for (const tile of this._cache.values()) {
       if (tile.isLoading) {
@@ -1117,6 +1157,9 @@ var Tileset2D = class {
       }
     }
   }
+  /**
+   * Update the cache with the given viewport and model matrix and triggers callback onUpdate.
+   */
   update(viewport, { zRange, modelMatrix } = {
     zRange: null,
     modelMatrix: null
@@ -1155,6 +1198,7 @@ var Tileset2D = class {
     }
     return this._frameNumber;
   }
+  // eslint-disable-next-line complexity
   isTileVisible(tile, cullRect) {
     if (!tile.isVisible) {
       return false;
@@ -1183,6 +1227,8 @@ var Tileset2D = class {
     }
     return true;
   }
+  /* Public interface for subclassing */
+  /** Returns array of tile indices in the current viewport */
   getTileIndices({ viewport, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }) {
     const { tileSize, extent, zoomOffset } = this.opts;
     return getTileIndices({
@@ -1197,22 +1243,27 @@ var Tileset2D = class {
       zoomOffset
     });
   }
+  /** Returns unique string key for a tile index */
   getTileId(index) {
     return `${index.x}-${index.y}-${index.z}`;
   }
+  /** Returns a zoom level for a tile index */
   getTileZoom(index) {
     return index.z;
   }
+  /** Returns additional metadata to add to tile, bbox by default */
   getTileMetadata(index) {
     const { tileSize } = this.opts;
     return { bbox: tileToBoundingBox(this._viewport, index.x, index.y, index.z, tileSize) };
   }
+  /** Returns index of the parent tile */
   getParentIndex(index) {
     const x = Math.floor(index.x / 2);
     const y = Math.floor(index.y / 2);
     const z = index.z - 1;
     return { x, y, z };
   }
+  // Returns true if any tile's visibility changed
   updateTileStates() {
     const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
     const visibilities = new Array(this._cache.size);
@@ -1253,6 +1304,7 @@ var Tileset2D = class {
       ongoingRequestCount--;
     }
   }
+  // This needs to be called every time some tiles have been added/removed from cache
   _rebuildTree() {
     const { _cache } = this;
     for (const tile of _cache.values()) {
@@ -1269,16 +1321,21 @@ var Tileset2D = class {
       }
     }
   }
+  /**
+   * Clear tiles that are not visible when the cache is full
+   */
+  /* eslint-disable complexity */
   _resizeCache() {
     var _a, _b;
     const { _cache, opts } = this;
-    const maxCacheSize = opts.maxCacheSize ?? (opts.maxCacheByteSize != null ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
+    const maxCacheSize = opts.maxCacheSize ?? // @ts-expect-error called only when selectedTiles is initialized
+    (opts.maxCacheByteSize !== null ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
     const maxCacheByteSize = opts.maxCacheByteSize ?? Infinity;
     const overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;
     if (overflown) {
       for (const [id, tile] of _cache) {
         if (!tile.isVisible && !tile.isSelected) {
-          this._cacheByteSize -= opts.maxCacheByteSize != null ? tile.byteLength : 0;
+          this._cacheByteSize -= opts.maxCacheByteSize !== null ? tile.byteLength : 0;
           _cache.delete(id);
           (_b = (_a = this.opts).onTileUnload) == null ? void 0 : _b.call(_a, tile);
         }
@@ -1393,11 +1450,13 @@ var defaultProps6 = {
   dataComparator: urlType.equal,
   renderSubLayers: { type: "function", value: (props) => new import_layers4.GeoJsonLayer(props) },
   getTileData: { type: "function", optional: true, value: null },
+  // TODO - change to onViewportLoad to align with Tile3DLayer
   onViewportLoad: { type: "function", optional: true, value: null },
   onTileLoad: { type: "function", value: (tile) => {
   } },
   onTileUnload: { type: "function", value: (tile) => {
   } },
+  // eslint-disable-next-line
   onTileError: { type: "function", value: (err) => console.error(err) },
   extent: { type: "array", optional: true, value: null, compare: true },
   tileSize: 512,
@@ -1502,6 +1561,7 @@ var TileLayer = class extends import_core5.CompositeLayer {
   _onTileUnload(tile) {
     this.props.onTileUnload(tile);
   }
+  // Methods for subclass to override
   getTileData(tile) {
     const { data, getTileData, fetch } = this.props;
     const { signal } = tile;
@@ -1570,6 +1630,26 @@ var tile_layer_default = TileLayer;
 
 // dist/trips-layer/trips-layer.js
 var import_layers5 = require("@deck.gl/layers");
+
+// dist/trips-layer/trips-layer-uniforms.js
+var uniformBlock = `uniform tripsUniforms {
+  bool fadeTrail;
+  float trailLength;
+  float currentTime;
+} trips;
+`;
+var tripsUniforms = {
+  name: "trips",
+  vs: uniformBlock,
+  fs: uniformBlock,
+  uniformTypes: {
+    fadeTrail: "f32",
+    trailLength: "f32",
+    currentTime: "f32"
+  }
+};
+
+// dist/trips-layer/trips-layer.js
 var defaultProps7 = {
   fadeTrail: true,
   trailLength: { type: "number", value: 120, min: 0 },
@@ -1580,27 +1660,27 @@ var TripsLayer = class extends import_layers5.PathLayer {
   getShaders() {
     const shaders = super.getShaders();
     shaders.inject = {
-      "vs:#decl": `uniform float trailLength;
-in float instanceTimestamps;
+      "vs:#decl": `in float instanceTimestamps;
 in float instanceNextTimestamps;
 out float vTime;
 `,
+      // Timestamp of the vertex
       "vs:#main-end": `vTime = instanceTimestamps + (instanceNextTimestamps - instanceTimestamps) * vPathPosition.y / vPathLength;
 `,
-      "fs:#decl": `uniform bool fadeTrail;
-uniform float trailLength;
-uniform float currentTime;
-in float vTime;
+      "fs:#decl": `in float vTime;
 `,
-      "fs:#main-start": `if(vTime > currentTime || (fadeTrail && (vTime < currentTime - trailLength))) {
+      // Drop the segments outside of the time window
+      "fs:#main-start": `if(vTime > trips.currentTime || (trips.fadeTrail && (vTime < trips.currentTime - trips.trailLength))) {
   discard;
 }
 `,
-      "fs:DECKGL_FILTER_COLOR": `if(fadeTrail) {
-  color.a *= 1.0 - (currentTime - vTime) / trailLength;
+      // Fade the color (currentTime - 100%, end of trail - 0%)
+      "fs:DECKGL_FILTER_COLOR": `if(trips.fadeTrail) {
+  color.a *= 1.0 - (trips.currentTime - vTime) / trips.trailLength;
 }
 `
     };
+    shaders.modules = [...shaders.modules, tripsUniforms];
     return shaders;
   }
   initializeState() {
@@ -1623,12 +1703,9 @@ in float vTime;
   }
   draw(params) {
     const { fadeTrail, trailLength, currentTime } = this.props;
-    params.uniforms = {
-      ...params.uniforms,
-      fadeTrail,
-      trailLength,
-      currentTime
-    };
+    const tripsProps = { fadeTrail, trailLength, currentTime };
+    const model = this.state.model;
+    model.shaderInputs.setProps({ trips: tripsProps });
     super.draw(params);
   }
 };
@@ -1864,6 +1941,7 @@ var H3HexagonLayer = class extends import_core7.CompositeLayer {
     }), {
       data,
       diskResolution: 6,
+      // generate an extruded hexagon as the base geometry
       radius: 1,
       vertices: this.state.vertices,
       getPosition: getHexagonCentroid.bind(null, getHexagon)
@@ -1931,12 +2009,23 @@ var import_shadertools = require("@luma.gl/shadertools");
 var import_engine = require("@luma.gl/engine");
 var import_mesh_layers = require("@deck.gl/mesh-layers");
 
+// dist/mesh-layer/mesh-layer-uniforms.js
+var uniformBlock2 = `uniform meshUniforms {
+  bool pickFeatureIds;
+} mesh;
+`;
+var meshUniforms = {
+  name: "mesh",
+  vs: uniformBlock2,
+  fs: uniformBlock2,
+  uniformTypes: {
+    pickFeatureIds: "f32"
+  }
+};
+
 // dist/mesh-layer/mesh-layer-vertex.glsl.js
 var mesh_layer_vertex_glsl_default = `#version 300 es
 #define SHADER_NAME simple-mesh-layer-vs
-uniform float sizeScale;
-uniform bool composeModelMatrix;
-uniform bool pickFeatureIds;
 in vec3 positions;
 in vec3 normals;
 in vec3 colors;
@@ -1963,16 +2052,16 @@ return uv;
 void main(void) {
 vec2 uv = applyUVRegion(texCoords);
 geometry.uv = uv;
-if (pickFeatureIds) {
+if (mesh.pickFeatureIds) {
 geometry.pickingColor = featureIdsPickingColors;
 } else {
 geometry.pickingColor = instancePickingColors;
 }
 mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);
 vTexCoord = uv;
-cameraPosition = project_uCameraPosition;
+cameraPosition = project.cameraPosition;
 vColor = vec4(colors * instanceColors.rgb, instanceColors.a);
-vec3 pos = (instanceModelMatrix * positions) * sizeScale;
+vec3 pos = (instanceModelMatrix * positions) * simpleMesh.sizeScale;
 vec3 projectedPosition = project_position(positions);
 position_commonspace = vec4(projectedPosition, 1.0);
 gl_Position = project_common_position_to_clipspace(position_commonspace);
@@ -1980,7 +2069,7 @@ geometry.position = position_commonspace;
 normals_commonspace = project_normal(instanceModelMatrix * normals);
 geometry.normal = normals_commonspace;
 DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
-#ifdef MODULE_PBR
+#ifdef MODULE_PBRMATERIAL
 pbr_vPosition = geometry.position.xyz;
 #ifdef HAS_NORMALS
 pbr_vNormal = geometry.normal;
@@ -2000,10 +2089,7 @@ DECKGL_FILTER_COLOR(vColor, geometry);
 var mesh_layer_fragment_glsl_default = `#version 300 es
 #define SHADER_NAME simple-mesh-layer-fs
 precision highp float;
-uniform bool hasTexture;
 uniform sampler2D sampler;
-uniform bool flatShading;
-uniform float opacity;
 in vec2 vTexCoord;
 in vec3 cameraPosition;
 in vec3 normals_commonspace;
@@ -2011,21 +2097,21 @@ in vec4 position_commonspace;
 in vec4 vColor;
 out vec4 fragColor;
 void main(void) {
-#ifdef MODULE_PBR
+#ifdef MODULE_PBRMATERIAL
 fragColor = vColor * pbr_filterColor(vec4(0));
 geometry.uv = pbr_vUV;
-fragColor.a *= opacity;
+fragColor.a *= layer.opacity;
 #else
 geometry.uv = vTexCoord;
 vec3 normal;
-if (flatShading) {
+if (simpleMesh.flatShading) {
 normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
 } else {
 normal = normals_commonspace;
 }
-vec4 color = hasTexture ? texture(sampler, vTexCoord) : vColor;
+vec4 color = simpleMesh.hasTexture ? texture(sampler, vTexCoord) : vColor;
 vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
-fragColor = vec4(lightColor, color.a * opacity);
+fragColor = vec4(lightColor, color.a * layer.opacity);
 #endif
 DECKGL_FILTER_COLOR(fragColor, geometry);
 }
@@ -2052,7 +2138,7 @@ var MeshLayer = class extends import_mesh_layers.SimpleMeshLayer {
   getShaders() {
     const shaders = super.getShaders();
     const modules = shaders.modules;
-    modules.push(import_shadertools.pbr);
+    modules.push(import_shadertools.pbrMaterial, meshUniforms);
     return { ...shaders, vs: mesh_layer_vertex_glsl_default, fs: mesh_layer_fragment_glsl_default };
   }
   initializeState() {
@@ -2065,6 +2151,7 @@ var MeshLayer = class extends import_mesh_layers.SimpleMeshLayer {
           type: "uint8",
           size: 3,
           noAlloc: true,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
           update: this.calculateFeatureIdsPickingColors
         }
       });
@@ -2079,18 +2166,26 @@ var MeshLayer = class extends import_mesh_layers.SimpleMeshLayer {
   }
   draw(opts) {
     const { featureIds } = this.props;
-    if (!this.state.model) {
+    const { model } = this.state;
+    if (!model) {
       return;
     }
-    this.state.model.setUniforms({
-      u_Camera: this.state.model.uniforms.project_uCameraPosition,
+    const meshProps = {
       pickFeatureIds: Boolean(featureIds)
+    };
+    const pbrProjectionProps = {
+      // Needed for PBR (TODO: find better way to get it)
+      camera: model.uniforms.cameraPosition
+    };
+    model.shaderInputs.setProps({
+      pbrProjection: pbrProjectionProps,
+      mesh: meshProps
     });
     super.draw(opts);
   }
   getModel(mesh) {
-    const { id, pbrMaterial } = this.props;
-    const parsedPBRMaterial = this.parseMaterial(pbrMaterial, mesh);
+    const { id } = this.props;
+    const parsedPBRMaterial = this.parseMaterial(this.props.pbrMaterial, mesh);
     this.setState({ parsedPBRMaterial });
     const shaders = this.getShaders();
     validateGeometryAttributes(mesh.attributes);
@@ -2109,19 +2204,28 @@ var MeshLayer = class extends import_mesh_layers.SimpleMeshLayer {
     });
     return model;
   }
-  updatePbrMaterialUniforms(pbrMaterial) {
+  updatePbrMaterialUniforms(material) {
     const { model } = this.state;
     if (model) {
       const { mesh } = this.props;
-      const parsedPBRMaterial = this.parseMaterial(pbrMaterial, mesh);
+      const parsedPBRMaterial = this.parseMaterial(material, mesh);
       this.setState({ parsedPBRMaterial });
-      model.setBindings(parsedPBRMaterial.bindings);
-      model.setUniforms(parsedPBRMaterial.uniforms);
-    }
-  }
-  parseMaterial(pbrMaterial, mesh) {
-    const unlit = Boolean(pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorTexture);
-    return (0, import_gltf.parsePBRMaterial)(this.context.device, { unlit, ...pbrMaterial }, { NORMAL: mesh.attributes.normals, TEXCOORD_0: mesh.attributes.texCoords }, {
+      const { pbr_baseColorSampler } = parsedPBRMaterial.bindings;
+      const { emptyTexture } = this.state;
+      const simpleMeshProps = {
+        sampler: pbr_baseColorSampler || emptyTexture,
+        hasTexture: Boolean(pbr_baseColorSampler)
+      };
+      const { camera, ...pbrMaterialProps } = {
+        ...parsedPBRMaterial.bindings,
+        ...parsedPBRMaterial.uniforms
+      };
+      model.shaderInputs.setProps({ simpleMesh: simpleMeshProps, pbrMaterial: pbrMaterialProps });
+    }
+  }
+  parseMaterial(material, mesh) {
+    const unlit = Boolean(material.pbrMetallicRoughness && material.pbrMetallicRoughness.baseColorTexture);
+    return (0, import_gltf.parsePBRMaterial)(this.context.device, { unlit, ...material }, { NORMAL: mesh.attributes.normals, TEXCOORD_0: mesh.attributes.texCoords }, {
       pbrDebug: false,
       lights: true,
       useTangents: false
@@ -2158,6 +2262,7 @@ var SINGLE_DATA = [0];
 var defaultProps11 = {
   getPointColor: { type: "accessor", value: [0, 0, 0, 255] },
   pointSize: 1,
+  // Disable async data loading (handling it in _loadTileSet)
   data: "",
   loader: import_d_tiles.Tiles3DLoader,
   onTilesetLoad: { type: "function", value: (tileset3d) => {
@@ -2446,11 +2551,17 @@ var import_terrain = require("@loaders.gl/terrain");
 var DUMMY_DATA = [1];
 var defaultProps12 = {
   ...tile_layer_default.defaultProps,
+  // Image url that encodes height data
   elevationData: urlType,
+  // Image url to use as texture
   texture: { ...urlType, optional: true },
+  // Martini error tolerance in meters, smaller number -> more detailed mesh
   meshMaxError: { type: "number", value: 4 },
+  // Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates
   bounds: { type: "array", value: null, optional: true, compare: true },
+  // Color to use if texture is unavailable
   color: { type: "color", value: [255, 255, 255] },
+  // Object to decode height data, from (r, g, b) to height in meters
   elevationDecoder: {
     type: "object",
     value: {
@@ -2460,7 +2571,9 @@ var defaultProps12 = {
       offset: 0
     }
   },
+  // Supply url to local terrain worker bundle. Only required if running offline and cannot access CDN.
   workerUrl: "",
+  // Same as SimpleMeshLayer wireframe
   wireframe: false,
   material: true,
   loaders: [import_terrain.TerrainWorkerLoader]
@@ -2531,7 +2644,10 @@ var TerrainLayer = class extends import_core11.CompositeLayer {
       meshMaxError,
       signal
     });
-    const surface = textureUrl ? fetch(textureUrl, { propName: "texture", layer: this, loaders: [], signal }).catch((_) => null) : Promise.resolve(null);
+    const surface = textureUrl ? (
+      // If surface image fails to load, the tile should still be displayed
+      fetch(textureUrl, { propName: "texture", layer: this, loaders: [], signal }).catch((_) => null)
+    ) : Promise.resolve(null);
     return Promise.all([terrain, surface]);
   }
   renderSubLayers(props) {
@@ -2554,6 +2670,7 @@ var TerrainLayer = class extends import_core11.CompositeLayer {
       material
     });
   }
+  // Update zRange of viewport
   onViewportLoad(tiles) {
     if (!tiles) {
       return;
@@ -2793,6 +2910,7 @@ var MVTLayer = class extends tile_layer_default {
       this.setState({ highlightColor });
     }
   }
+  /* eslint-disable complexity */
   async _updateTileData() {
     let data = this.props.data;
     let tileJSON = null;
@@ -2830,6 +2948,7 @@ var MVTLayer = class extends tile_layer_default {
     }
     return opts;
   }
+  /* eslint-disable complexity */
   renderLayers() {
     var _a;
     if (!((_a = this.state) == null ? void 0 : _a.data))
@@ -2852,6 +2971,10 @@ var MVTLayer = class extends tile_layer_default {
         ...loadOptions == null ? void 0 : loadOptions.mvt,
         coordinates: this.context.viewport.resolution ? "wgs84" : "local",
         tileIndex: index
+        // Local worker debug
+        // workerUrl: `modules/mvt/dist/mvt-loader.worker.js`
+        // Set worker to null to skip web workers
+        // workerUrl: null
       },
       gis: binary ? { format: "binary" } : {}
     };
@@ -2915,6 +3038,7 @@ var MVTLayer = class extends tile_layer_default {
       info.object = transformTileCoordsToWGS84(
         info.object,
         info.tile.bbox,
+        // eslint-disable-line
         this.context.viewport
       );
     }
@@ -2956,6 +3080,7 @@ var MVTLayer = class extends tile_layer_default {
     const layerIds = [this.id];
     return deck.pickObjects({ x, y, width, height, layerIds, maxObjects });
   }
+  /** Get the rendered features in the current viewport. */
   getRenderedFeatures(maxFeatures = null) {
     const features = this._pickObjects(maxFeatures);
     const featureCache = /* @__PURE__ */ new Set();