@mapvx/web-js 4.0.3-dev.1 → 4.0.3-dev.2

package/dist/es/map/mapInteractionOptions.d.ts

@@ -38,4 +38,3 @@ export declare function buildInteractionOptions(mapConfig: MapConfig): MapIntera
  * @internal
  */
 export declare function shouldDisableTouchRotation(mapConfig: MapConfig): boolean;
-//# sourceMappingURL=mapInteractionOptions.d.ts.map

package/dist/es/map/mapInteractionOptions.js

@@ -1,29 +1,4 @@
-/**
- * Highest pitch MapLibre accepts for `minPitch`/`maxPitch` (it rejects anything
- * above 180); a locked pitch is clamped to it so the lock can never contradict
- * the {@link MapConfig.pitch} the map was built with.
- */
 const MAX_LOCKED_PITCH = 180;
-/**
- * Translates the interaction/rotation flags from {@link MapConfig} into the
- * matching MapLibre constructor options.
- *
- * Only keys that were explicitly provided are returned, so MapLibre's defaults
- * (every interaction enabled) are preserved for any flag left `undefined`. This
- * deliberately avoids writing `undefined` into the options object, which would
- * otherwise override MapLibre defaults with `NaN`/`undefined`.
- *
- * `rotateEnabled: false` disables drag- and pitch-rotation up front. Touch
- * rotation cannot be turned off via the constructor without also killing
- * pinch-to-zoom, so it is handled separately after construction — see
- * {@link shouldDisableTouchRotation}.
- *
- * `pitchEnabled: false` freezes the tilt: the pitch gestures are disabled and
- * `minPitch`/`maxPitch` are pinned to {@link MapConfig.pitch}, so neither the
- * user nor a later camera update can change it.
- *
- * @internal
- */
 export function buildInteractionOptions(mapConfig) {
     var _a;
     const options = {};
@@ -54,16 +29,6 @@ export function buildInteractionOptions(mapConfig) {
     }
     return options;
 }
-/**
- * Whether two-finger touch rotation must be disabled after the map is created.
- *
- * `rotateEnabled: false` should keep pinch-to-zoom working, so the touch
- * rotation is disabled via `map.touchZoomRotate.disableRotation()` once the map
- * instance exists rather than through the constructor.
- *
- * @internal
- */
 export function shouldDisableTouchRotation(mapConfig) {
     return mapConfig.rotateEnabled === false;
 }
-//# sourceMappingURL=mapInteractionOptions.js.map

package/dist/es/map/scene3DController.d.ts

@@ -221,4 +221,3 @@ export declare class Scene3DController {
     private updateDeckOverlay;
     private hideLayers;
 }
-//# sourceMappingURL=scene3DController.d.ts.map

package/dist/es/map/scene3DController.js

@@ -5,58 +5,23 @@ import { loadGlbRoot } from "../utils/loadGlb";
 import { Semaphore } from "../utils/semaphore";
 import { loadDeck, loadThree } from "../utils/three";
 import { addScene3DLights, computeGlbBottomAnchor, disposeMaterialsOnly, disposeObject3D, } from "../utils/threeScene";
-/**
- * Owns the experimental 3D scene for a MapLibre map: the deck.gl overlay layers (elevated room
- * outlines, indoor labels, POI icons, store logos) and the declarative GLB custom layer rendered
- * with Three.js.
- *
- * This is the WebGL / deck.gl "glue": creating the `WebGLRenderer`, instantiating deck layers and
- * driving the per-frame render loop all require a real GPU context and a live map, so this module is
- * excluded from unit-test coverage (see `sonar.coverage.exclusions`). The unit-testable logic it
- * relies on lives in `utils/deckLayers.ts`, `utils/threeScene.ts` and `utils/3d.ts`.
- *
- * The map creates one instance only when {@link MapConfig.mode} is `"3D"` and
- * {@link Scene3DConfig.enabled} is not `false`, and forwards its lifecycle to the `on*` methods.
- *
- * @group Map
- */
 export class Scene3DController {
     constructor(map, scene3DConfig, initialCenter, onModelsProgress) {
         var _a, _b, _c;
-        /** Latest known floor key; updated by the floor-change hooks and read when (re)building layers. */
         this.currentFloor = "";
-        // Lazily-loaded Three.js / deck.gl runtime handles (see loadThree()/loadDeck()).
         this.threeMod = undefined;
         this.deckMod = undefined;
         this.deckOverlay = undefined;
         this.scene3DGlbScene = undefined;
-        /** Loaded GLB roots keyed by URL (deduplicated). */
         this.scene3DGlbRootByUrl = new globalThis.Map();
-        /** Per-asset template root and bottom anchor for cloning. */
         this.scene3DGlbTemplateById = new globalThis.Map();
-        /** Number of light objects in `scene3DGlbScene` (kept when clearing meshes). */
         this.scene3DGlbLightCount = 0;
-        /** Container group holding all placed GLB pivots; rebuilt on each floor change. */
         this.scene3DModelsGroup = undefined;
-        /** The GLB custom layer's renderer, stored so {@link dispose} can release it; see `createGlbCustomLayer`. */
         this.glbRenderer = undefined;
-        /**
-         * Route points currently used for GLB route-transparency collision, tagged with the floor on
-         * which each point's route segment is visible. Stored as coordinates (not pivot references) so
-         * they survive `placeScene3DModels` rebuilds on floor change. Only points matching the current
-         * floor participate, so a model only fades when a route is visibly crossing it on that floor.
-         */
         this.scene3DRouteCollisionPoints = [];
         this.spriteIconMapping = {};
         this.spriteAtlasImage = new Image();
-        /** True while the GLB models are unloaded by LOD (camera zoomed out past the threshold). */
         this.modelsUnloadedByLod = false;
-        /**
-         * True while {@link loadScene3DGlbTemplates} is populating `scene3DGlbRootByUrl` /
-         * `scene3DGlbTemplateById` (initial load or an LOD reload). Guards against overlapping reloads
-         * and, in {@link updateLodForZoom}, against an LOD unload running concurrently and clearing
-         * those same maps out from under the in-flight load.
-         */
         this.glbTemplatesLoadInFlight = false;
         this.map = map;
         this.scene3DConfig = scene3DConfig;
@@ -66,11 +31,6 @@ export class Scene3DController {
         this.useTileWorker = (_c = (_b = scene3DConfig.customLayers) === null || _b === void 0 ? void 0 : _b.useTileWorker) !== null && _c !== void 0 ? _c : false;
         this.lodThresholds = resolveModels3DLodThresholds(scene3DConfig.models);
     }
-    // Lifecycle entry points forwarded by the map ---------------------------------------------
-    /**
-     * Sets up the deck.gl overlay and GLB custom layer once the map style has loaded. Awaits the lazy
-     * library load first so the base 2D flow is never blocked by it.
-     */
     async onMapLoad() {
         var _a, _b;
         try {
@@ -82,15 +42,12 @@ export class Scene3DController {
         }
         if (!this.deckMod)
             return;
-        // Load the sprite atlas (icons/logos) before building deck layers so the first
-        // updateDeckOverlay has the atlas available.
         const spriteUrl = (_b = (_a = this.scene3DConfig.customLayers) === null || _a === void 0 ? void 0 : _a.iconLayers) === null || _b === void 0 ? void 0 : _b.spriteUrl;
         if (spriteUrl) {
             await this.loadSpriteAtlas(spriteUrl).catch((err) => console.error("Failed to load sprite atlas", err));
         }
         this.deckOverlay = new this.deckMod.MapboxOverlay({ layers: [] });
         this.map.addControl(this.deckOverlay);
-        // Hide MapLibre icon layers — replaced by deck.gl IconLayer
         this.hideLayers(this.scene3DConfig.hideLayers);
         this.installDebugStatsHook();
         const models = this.scene3DConfig.models;
@@ -98,59 +55,24 @@ export class Scene3DController {
         if (glbModelsActive) {
             this.map.addLayer(this.createGlbCustomLayer());
         }
-        // Populate the overlay for the floor that may already be set: the map's floor hooks
-        // (onFloorChange/refreshOverlay) run during init and early-return while `deckOverlay` is still
-        // undefined during the async library load, so without this the overlay stays empty until the
-        // next floor change (e.g. broken on totem/route views that never change floor after load).
         this.updateDeckOverlay();
     }
-    /**
-     * Re-attaches the style-owned half of the 3D scene after the map style has been fully
-     * replaced (`map.setStyle(..., { diff: false })`).
-     *
-     * A full swap deletes every layer, so MapLibre removes the GLB custom layer and calls
-     * its `onRemove` — which runs {@link dispose} and frees the renderer, the GLB roots and
-     * the templates. `onMapLoad` is the only other place that adds the layer and it never
-     * runs twice, so without this call the models are gone permanently and the MapLibre
-     * icon layers that deck.gl replaced come back on top of the deck icons.
-     *
-     * Only style-owned state is rebuilt. The deck.gl overlay is a map CONTROL, not a style
-     * layer, so it survives the swap untouched — re-adding it here would stack a second
-     * overlay on the map. Its layers are repopulated separately by the map's
-     * `refreshOverlay` call in `whenStyleUpdates`.
-     *
-     * No-op before `onMapLoad` has run (2D mode, or the lazy 3D libraries still loading):
-     * `deckMod` is the same readiness signal `onMapLoad` itself checks, and the initial
-     * `onMapLoad` will add the layer once it completes.
-     */
     reattachToStyle() {
         if (!this.deckMod)
             return;
-        // Hide MapLibre icon layers again — replaced by deck.gl IconLayer. These are layout
-        // properties on the STYLE's layers, so the swap reset them to visible.
         this.hideLayers(this.scene3DConfig.hideLayers);
-        // `dispose()` (via the removed layer's `onRemove`) uninstalled this.
         this.installDebugStatsHook();
         const models = this.scene3DConfig.models;
         const glbModelsActive = models !== undefined && models.enabled !== false && models.assets.length > 0;
-        // `createGlbCustomLayer` rebuilds the scene, its lights and the renderer (in `onAdd`)
-        // and kicks off a fresh template load, so it fully recovers from the dispose.
         if (glbModelsActive) {
             this.map.addLayer(this.createGlbCustomLayer());
         }
         this.updateDeckOverlay();
     }
-    /** Re-applies zoom-based model transparency and evaluates LOD; call on every map `zoom`. */
     onZoom() {
         this.applyModelOpacity();
         this.updateLodForZoom();
     }
-    /**
-     * Evaluates the zoom-based LOD (see {@link Models3DConfig.lod}): unloads the GLB models from
-     * memory when the camera drops below the unload boundary and reloads them when it returns to the
-     * reload boundary. No-op when LOD is disabled. Cheap enough to call on every `zoom` event — it
-     * only acts on a boundary crossing.
-     */
     updateLodForZoom() {
         if (!this.lodThresholds) {
             return;
@@ -158,8 +80,6 @@ export class Scene3DController {
         const action = lodActionForZoom(this.map.getZoom(), this.lodThresholds, this.modelsUnloadedByLod);
         if (action === "unload") {
             if (this.glbTemplatesLoadInFlight) {
-                // A load is already populating the model maps; unloading now would race with it.
-                // reloadScene3DModelsForLod()/the initial load re-evaluate the zoom once they settle.
                 return;
             }
             this.unloadScene3DModelsForLod();
@@ -168,12 +88,6 @@ export class Scene3DController {
             void this.reloadScene3DModelsForLod();
         }
     }
-    /**
-     * Frees the GLB models' GPU resources (placed group's material clones + every cached template's
-     * geometry/textures) while keeping the custom layer, its `WebGLRenderer`, scene and lights alive,
-     * so a later {@link reloadScene3DModelsForLod} can repopulate without recreating the map layer.
-     * Distinct from {@link dispose}, which tears the whole controller down.
-     */
     unloadScene3DModelsForLod() {
         var _a, _b;
         const three = (_a = this.threeMod) === null || _a === void 0 ? void 0 : _a.THREE;
@@ -185,7 +99,6 @@ export class Scene3DController {
             (_b = this.scene3DGlbScene) === null || _b === void 0 ? void 0 : _b.remove(this.scene3DModelsGroup);
             this.scene3DModelsGroup = undefined;
         }
-        // Iterate the deduped-by-URL roots so a shared root is never disposed twice (mirrors dispose()).
         for (const root of this.scene3DGlbRootByUrl.values()) {
             disposeObject3D(three, root);
         }
@@ -194,11 +107,6 @@ export class Scene3DController {
         this.modelsUnloadedByLod = true;
         this.map.triggerRepaint();
     }
-    /**
-     * Reloads the GLB templates from disk/network and re-places them for the current floor after an
-     * LOD unload. Guards against overlapping reloads, and re-evaluates the zoom on completion so a
-     * camera that zoomed back out mid-download ends up unloaded again rather than stuck loaded.
-     */
     async reloadScene3DModelsForLod() {
         if (this.glbTemplatesLoadInFlight) {
             return;
@@ -207,8 +115,6 @@ export class Scene3DController {
         try {
             await this.loadScene3DGlbTemplates();
             this.placeScene3DModels();
-            // Only mark as loaded once placement actually succeeded, so a failed reload leaves
-            // modelsUnloadedByLod = true and the trailing updateLodForZoom() below retries it.
             this.modelsUnloadedByLod = false;
         }
         catch (err) {
@@ -217,26 +123,13 @@ export class Scene3DController {
         finally {
             this.glbTemplatesLoadInFlight = false;
         }
-        // The camera may have moved during the async load; re-evaluate so a zoom back out unloads again.
         this.updateLodForZoom();
     }
-    /**
-     * Sets the route path used for GLB route-transparency collision and re-evaluates which models a
-     * route currently crosses. Points are tagged with the floor on which their route segment is
-     * visible; only points on the current floor participate, so a model never fades unless a route is
-     * visibly crossing it on the displayed floor. Pass an empty array to clear.
-     */
     setRouteCollisionPath(points) {
         this.scene3DRouteCollisionPoints = points;
         this.recomputeRouteAffectedModels();
         this.applyModelOpacity();
     }
-    /**
-     * Rebuilds the deck overlay and GLB placements for the given floor. Host apps call this on every
-     * floor/place-changing navigation, including many that leave the floor unchanged (e.g. re-entering
-     * a screen, tapping the already-active floor selector); a no-op floor is skipped so those don't
-     * trigger a full, wasteful GLB rebuild.
-     */
     onFloorChange(currentFloor) {
         const nextFloor = currentFloor !== null && currentFloor !== void 0 ? currentFloor : "";
         if (nextFloor === this.currentFloor) {
@@ -246,20 +139,10 @@ export class Scene3DController {
         this.updateDeckOverlay();
         this.placeScene3DModels();
     }
-    /** Rebuilds only the deck overlay (no GLB replacement) for the given floor. */
     refreshOverlay(currentFloor) {
         this.currentFloor = currentFloor !== null && currentFloor !== void 0 ? currentFloor : "";
         this.updateDeckOverlay();
     }
-    /**
-     * A point-in-time snapshot of the 3D scene's memory drivers, for profiling. The Three.js
-     * `renderer.info` counters are the best in-page proxy for GLB VRAM (decoded geometries/textures
-     * live on the GPU and are not visible to `performance.memory`, which only reports the JS heap).
-     * The deck tile counts approximate the overlay's parsed-tile working set — the thing the tile-cache
-     * bounds (see {@link DeckTileCacheConfig}) keep from growing without limit as the map pans/zooms.
-     *
-     * @group Map
-     */
     getDebugStats() {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const info = (_a = this.glbRenderer) === null || _a === void 0 ? void 0 : _a.info;
@@ -274,8 +157,6 @@ export class Scene3DController {
             : null;
         let deckTiles = null;
         try {
-            // Best-effort read of each overlay layer's parsed-tile count. deck.gl internals are private,
-            // so this is guarded — it degrades to `null` rather than throwing if the shape changes.
             const overlay = this.deckOverlay;
             const layers = (_e = (_d = overlay === null || overlay === void 0 ? void 0 : overlay._deck) === null || _d === void 0 ? void 0 : _d.layerManager) === null || _e === void 0 ? void 0 : _e.layers;
             if (Array.isArray(layers)) {
@@ -283,7 +164,6 @@ export class Scene3DController {
                 for (const layer of layers) {
                     const size = (_h = (_g = (_f = layer === null || layer === void 0 ? void 0 : layer.state) === null || _f === void 0 ? void 0 : _f.tileset) === null || _g === void 0 ? void 0 : _g._cache) === null || _h === void 0 ? void 0 : _h.size;
                     if (typeof size === "number" && layer.id) {
-                        // Strip deck's per-sublayer suffixes so the four MVT roots aggregate by base id.
                         const baseId = layer.id.split("-sublayer")[0];
                         counts[baseId] = Math.max((_j = counts[baseId]) !== null && _j !== void 0 ? _j : 0, size);
                     }
@@ -307,34 +187,18 @@ export class Scene3DController {
             lodThresholds: this.lodThresholds,
         };
     }
-    /**
-     * Exposes {@link getDebugStats} as `globalThis.__mvxScene3DStats()` when the opt-in flag
-     * `globalThis.__MVX_SCENE3D_DEBUG__` is truthy, so a profiling session can read the scene's memory
-     * drivers from the console/tests without external tooling. No-op (and no global written) otherwise.
-     */
     installDebugStatsHook() {
         const g = globalThis;
         if (g.__MVX_SCENE3D_DEBUG__) {
             g.__mvxScene3DStats = () => this.getDebugStats();
         }
     }
-    /** Removes the debug hook if it points at this controller. Called from {@link dispose}. */
     uninstallDebugStatsHook() {
         const g = globalThis;
         if (g.__mvxScene3DStats) {
             delete g.__mvxScene3DStats;
         }
     }
-    /**
-     * Releases every GPU resource this controller owns: the placed models group's material clones,
-     * the cached GLB templates' geometries/materials/textures, and the `WebGLRenderer` created for the
-     * declarative GLB layer. Idempotent — safe to call more than once (e.g. once via the custom
-     * layer's own `onRemove` and again explicitly).
-     *
-     * Callers must invoke this themselves before tearing down the map: MapLibre's `map.remove()` does
-     * not call a custom layer's `onRemove`, so without an explicit call here nothing ever frees these
-     * resources, and every context-loss recovery cycle (destroy + recreate the map) leaks a full scene.
-     */
     dispose() {
         var _a, _b;
         const three = (_a = this.threeMod) === null || _a === void 0 ? void 0 : _a.THREE;
@@ -343,8 +207,6 @@ export class Scene3DController {
                 disposeMaterialsOnly(three, this.scene3DModelsGroup);
                 this.scene3DModelsGroup = undefined;
             }
-            // Iterate the deduplicated-by-URL roots (not `scene3DGlbTemplateById`, which may map several
-            // asset ids to the same root) so a shared root is never disposed more than once.
             for (const root of this.scene3DGlbRootByUrl.values()) {
                 disposeObject3D(three, root);
             }
@@ -356,11 +218,6 @@ export class Scene3DController {
         this.glbRenderer = undefined;
         this.uninstallDebugStatsHook();
     }
-    // Internal implementation -----------------------------------------------------------------
-    /**
-     * Lazily loads the Three.js / deck.gl runtime handles (dynamic import) and caches them so the
-     * heavy libraries stay out of the base 2D bundle.
-     */
     async ensure3DLibs() {
         var _a, _b;
         (_a = this.threeMod) !== null && _a !== void 0 ? _a : (this.threeMod = await loadThree());
@@ -393,8 +250,6 @@ export class Scene3DController {
         })
             .finally(() => {
             this.glbTemplatesLoadInFlight = false;
-            // Honor LOD from the first frame: if the map opened below the unload threshold, free the
-            // models just loaded (they reload when the user zooms in). No-op when LOD is disabled.
             this.updateLodForZoom();
         });
         let renderer = undefined;
@@ -412,13 +267,9 @@ export class Scene3DController {
                     antialias: true,
                 });
                 renderer.autoClear = false;
-                // MapLibre owns canvas dimensions; only sync the GL viewport on resize.
                 renderer.setSize = function (width, height) {
                     this.setViewport(0, 0, width, height);
                 };
-                // Stored on the controller (not just this closure) so `dispose()` can release it — MapLibre
-                // does not call a custom layer's `onRemove` when the whole map/style is torn down via
-                // `map.remove()`, so callers must dispose this controller explicitly before that happens.
                 this.glbRenderer = renderer;
             },
             onRemove: () => {
@@ -436,7 +287,6 @@ export class Scene3DController {
                 const canvas = this.map.getCanvas();
                 const width = canvas.width;
                 const height = canvas.height;
-                // Skip while the framebuffer has no drawable area (e.g. devtools opening).
                 if (width === 0 || height === 0) {
                     return;
                 }
@@ -461,16 +311,9 @@ export class Scene3DController {
         }
         this.scene3DGlbRootByUrl.clear();
         this.scene3DGlbTemplateById.clear();
-        // Load every distinct URL with bounded concurrency (see GLB_LOAD_CONCURRENCY) instead of one
-        // at a time, and let each load time out (see loadGlbRoot) — a single hung or malformed/truncated
-        // asset is skipped and logged instead of blocking every asset queued behind it. Deduplicating by
-        // URL up front — not inside the concurrent task — means assets sharing a URL never trigger
-        // duplicate loads and never tie up more than one concurrency slot waiting on the same result.
         const uniqueUrls = [...new Set(models.assets.map((asset) => asset.url))];
         const errorByUrl = new globalThis.Map();
         const semaphore = new Semaphore(Scene3DController.GLB_LOAD_CONCURRENCY);
-        // Progress bookkeeping for `onModelsProgress` (e.g. a totem's loading bar). Kept even when no
-        // callback is registered — the cost is a handful of Map writes over at most a few dozen assets.
         const loadedBytesByUrl = new globalThis.Map();
         const totalBytesByUrl = new globalThis.Map();
         let settledAssets = 0;
@@ -496,9 +339,6 @@ export class Scene3DController {
                 });
             }
             catch (err) {
-                // Isolate the SDK's own load bookkeeping from a throwing consumer callback — letting this
-                // escape would reject the `Promise.all` below (or, from the `onProgress` path, break
-                // three.js's internal stream-reading chain) and lose every already-loaded asset.
                 console.error("onScene3DModelsProgress callback threw", err);
             }
         };
@@ -519,10 +359,6 @@ export class Scene3DController {
             }
             finally {
                 settledAssets++;
-                // Once a URL has settled, its total is knowable even if no progress event ever supplied
-                // one (failed before the first byte, or the server omitted Content-Length): fall back to
-                // however many bytes actually arrived. Otherwise a single such asset would force the
-                // whole batch's `totalBytes` to stay `null` forever, even after `done: true`.
                 totalBytesByUrl.set(url, (_b = (_a = totalBytesByUrl.get(url)) !== null && _a !== void 0 ? _a : loadedBytesByUrl.get(url)) !== null && _b !== void 0 ? _b : 0);
                 semaphore.release();
                 reportProgress(false);
@@ -550,9 +386,6 @@ export class Scene3DController {
             return;
         }
         if (this.scene3DModelsGroup) {
-            // Only the per-placement material clones (made below so each placement's zoom-based opacity
-            // is independent) are exclusively owned by this group — geometries/textures come from the
-            // cached templates and stay alive for the next rebuild, so they must not be disposed here.
             disposeMaterialsOnly(three, this.scene3DModelsGroup);
             this.scene3DGlbScene.remove(this.scene3DModelsGroup);
             this.scene3DModelsGroup = undefined;
@@ -586,8 +419,6 @@ export class Scene3DController {
             const [sx3, sy3, sz3] = mergeGlbScale(asset.defaultScale, placement.scale);
             pivot.scale.set(sx3, sy3, sz3);
             const model = template.root.clone(true);
-            // `clone(true)` shares materials between instances; clone them per placement so each
-            // placement's zoom-based opacity is independent and does not bleed into sibling models.
             model.traverse((obj) => {
                 const mesh = obj;
                 if (!mesh.isMesh) {
@@ -598,15 +429,8 @@ export class Scene3DController {
                     : mesh.material.clone();
             });
             model.position.set(-template.center.x, -template.center.y, -template.center.z);
-            // Stash the resolved zoom-transparency config so it can be re-applied on every zoom change.
             pivot.userData.zoomTransparency = resolveZoomTransparency(models, asset, placement);
-            // Stash route-transparency config (may be undefined => feature off for this model) so a
-            // route crossing this model can fade it independently of zoom.
             pivot.userData.routeTransparency = resolveRouteTransparency(models, asset, placement);
-            // Precompute the model footprint in the pivot's local x/z frame while `model` has no parent
-            // (its world matrix equals its local matrix), for cheap point-in-building collision tests.
-            // After `pivot.add(model)` the world matrix would fold in the pivot transform, giving a loose
-            // world-axis box instead; `pivot.worldToLocal` at test time undoes the pivot transform.
             const localBox = new three.Box3().setFromObject(model);
             pivot.userData.footprint = {
                 minX: localBox.min.x,
@@ -619,18 +443,10 @@ export class Scene3DController {
         }
         this.scene3DModelsGroup = modelsGroup;
         this.scene3DGlbScene.add(modelsGroup);
-        // Recompute route collision against the freshly rebuilt pivots (footprints/floor changed),
-        // then apply the combined opacity.
         this.recomputeRouteAffectedModels();
         this.applyModelOpacity();
         this.map.triggerRepaint();
     }
-    /**
-     * Recomputes `pivot.userData.routeAffected` for every placed model by testing the current-floor
-     * route collision points against each model's precomputed footprint. Cheap point-in-box tests in
-     * the pivot's local x/z frame; runs only when the route path or the placed models change, never
-     * per zoom frame.
-     */
     recomputeRouteAffectedModels() {
         var _a;
         const three = (_a = this.threeMod) === null || _a === void 0 ? void 0 : _a.THREE;
@@ -639,10 +455,6 @@ export class Scene3DController {
             return;
         }
         const points = this.scene3DRouteCollisionPoints.filter((p) => p.floorKey === this.currentFloor);
-        // Convert each route point into the models group's local frame (metres relative to
-        // initialCenter), exactly as placements are positioned in `placeScene3DModels`. The group's
-        // own transform (globalOffset) is applied via `localToWorld` at test time, so route points and
-        // model pivots share one frame regardless of the collective offset.
         const refMercator = MercatorCoordinate.fromLngLat(this.initialCenter, 0);
         const meterScale = refMercator.meterInMercatorCoordinateUnits();
         const groupLocalPoints = points.map((p) => {
@@ -656,14 +468,11 @@ export class Scene3DController {
         for (const pivot of modelsGroup.children) {
             const routeCfg = pivot.userData.routeTransparency;
             const footprint = pivot.userData.footprint;
-            // Only models with a route-transparency config participate (feature activation gate).
             if (!routeCfg || !footprint || groupLocalPoints.length === 0) {
                 pivot.userData.routeAffected = false;
                 continue;
             }
             pivot.userData.routeAffected = groupLocalPoints.some((gp) => {
-                // group-local -> world (applies globalOffset) -> pivot-local (undoes position/rotation/
-                // scale), then test its x/z against the footprint. y is ignored (floor-level footprint).
                 local.copy(gp);
                 modelsGroup.localToWorld(local);
                 pivot.worldToLocal(local);
@@ -671,14 +480,6 @@ export class Scene3DController {
             });
         }
     }
-    /**
-     * Applies transparency to placed GLB models, combining zoom-based transparency
-     * ({@link ZoomTransparencyConfig}, a hard threshold: fully opaque below the configured zoom,
-     * configured opacity at/above it) with route-based transparency
-     * ({@link RouteTransparencyConfig}) for models a route currently crosses
-     * (`pivot.userData.routeAffected`). The more transparent of the two wins. Only triggers a
-     * repaint when at least one material actually changed.
-     */
     applyModelOpacity() {
         if (!this.scene3DModelsGroup) {
             return;
@@ -700,7 +501,6 @@ export class Scene3DController {
                     if (material.opacity !== opacity) {
                         material.transparent = opacity < 1;
                         material.opacity = opacity;
-                        // Disable depth writes while transparent to avoid draw-order artifacts.
                         material.depthWrite = opacity >= 1;
                         changed = true;
                     }
@@ -725,17 +525,6 @@ export class Scene3DController {
         this.spriteIconMapping = json;
         this.spriteAtlasImage = img;
     }
-    /**
-     * Props spread onto every deck.gl `MVTLayer`.
-     *
-     * The cache bounds stop the overlays from keeping an unbounded set of parsed tiles in memory;
-     * `maxCacheByteSize` is only included when configured, since deck.gl enforces it only when a
-     * tile's byte size is known.
-     *
-     * `loadOptions.worker` is what keeps the scene off `unpkg.com`: loaders.gl would otherwise fetch
-     * its MVT worker from there the first time a tile is parsed, and that request is not something a
-     * kiosk can rely on. See {@link CustomLayerConfig.useTileWorker}.
-     */
     get deckTileLayerProps() {
         const { maxCacheSize, maxRequests, refinementStrategy, maxCacheByteSize } = this.deckTileCache;
         const props = {
@@ -759,7 +548,6 @@ export class Scene3DController {
                 const paths = buildElevatedPaths((props.data || []), floorKey, (_a = layerConfig.defaultHeight) !== null && _a !== void 0 ? _a : 5);
                 if (!paths.length)
                     return null;
-                // Default color hardcoded to "#cbcbcb" (from the original style) to avoid a type mismatch.
                 return new deck.PathLayer(Object.assign(Object.assign({}, props), { id: `${props.id}-paths`, data: paths, getPath: (d) => d.path, getColor: hexToRgb((_b = layerConfig.lineColor) !== null && _b !== void 0 ? _b : "#cbcbcb"), getWidth: (_c = layerConfig.lineWidth) !== null && _c !== void 0 ? _c : 1.5, widthUnits: (_d = layerConfig.widthUnits) !== null && _d !== void 0 ? _d : "pixels", pickable: false }));
             }, updateTriggers: {
                 renderSubLayers: [floorKey],
@@ -772,8 +560,6 @@ export class Scene3DController {
             return null;
         return new deck.MVTLayer(Object.assign(Object.assign({}, this.deckTileLayerProps), { id: "indoor-labels", data: layerConfig.dataUrl, binary: (_a = layerConfig.binaryData) !== null && _a !== void 0 ? _a : false, minZoom: (_b = layerConfig.minZoom) !== null && _b !== void 0 ? _b : 19.5, maxZoom: (_c = layerConfig.maxZoom) !== null && _c !== void 0 ? _c : 24, renderSubLayers: (props) => {
                 var _a, _b, _c, _d, _e, _f;
-                // Use area_name and poi Point features — unique per tile, no duplicates.
-                // If a logo-{name} image exists in the sprite, the icon takes priority over the text label.
                 const textData = buildLabelData((props.data || []), floorKey, (imageId) => this.map.hasImage(imageId), (_a = layerConfig.defaultHeight) !== null && _a !== void 0 ? _a : 5);
                 if (!textData.length)
                     return null;
@@ -847,11 +633,4 @@ export class Scene3DController {
         }
     }
 }
-/**
- * Bounded concurrency for loading declarative GLB assets in {@link loadScene3DGlbTemplates}.
- * High enough that one slow/broken asset (see {@link loadGlbRoot}'s timeout) does not stall the
- * rest of the batch, low enough to avoid saturating the browser with concurrent Draco/KTX2
- * decodes when a scene declares many assets.
- */
 Scene3DController.GLB_LOAD_CONCURRENCY = 4;
-//# sourceMappingURL=scene3DController.js.map

package/dist/es/repository/repository.d.ts

@@ -90,4 +90,3 @@ export declare class Repository extends Loggeable {
     fetchAndParseCssCustomization(type: string): Promise<CssCustomization>;
     postAndParseHealthPing(healthPingId: string, placeId: string, totemId: string, status: boolean): Promise<HealthResponse>;
 }
-//# sourceMappingURL=repository.d.ts.map