@mapvx/web-js 3.6.0-dev.1 → 4.0.0-dev.1

package/dist/cjs/map/map.js

@@ -1,2766 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalMapVXMap = void 0;
-const maplibre_gl_1 = __importStar(require("maplibre-gl"));
-const semaphore_1 = require("../utils/semaphore");
-/** Shared GeoJSON source holding every circle drawn through the circle API. */
-const CIRCLE_SOURCE_ID = "mapvx-circles";
-/** Fill layer rendering the translucent interior of the circles. */
-const CIRCLE_FILL_LAYER_ID = "mapvx-circles-fill";
-/** Line layer rendering the circle outlines. */
-const CIRCLE_LINE_LAYER_ID = "mapvx-circles-line";
-/**
- * Layer-id suffix per circle render order. The default placement keeps the
- * unsuffixed ids so existing consumers referencing them keep working.
- */
-const CIRCLE_LAYER_SUFFIXES = {
-    aboveBasemap: "",
-    belowLabels: "-below-labels",
-    top: "-top",
-};
-/**
- * How many times a failed vector tile is reloaded before it is dropped from the retry
- * queue. Bounded so a permanently unavailable tile stops being requested, while a tile
- * that failed on a transient network error still gets several chances.
- */
-const MAX_TILE_RETRIES = 5;
-/**
- * Base delay for the retry backoff. Attempt N waits `BASE * 2^(N-1)` before it is
- * eligible again — 1s, 2s, 4s, 8s — so a tile that keeps failing is retried ever less
- * often instead of once per timer tick.
- */
-const TILE_RETRY_BASE_DELAY_MS = 1000;
-/**
- * Safety deadline for {@link InternalMapVXMap.setStyle}'s `onStyleReady` callback. The
- * callback normally fires on the map's `idle` event, but `idle` may never arrive (the
- * style request failed, the swap never settles). Callers hide the map behind a loading
- * overlay until the callback arrives, so it must be released no matter what.
- */
-const STYLE_READY_TIMEOUT_MS = 4000;
-/**
- * Frames a floor change waits before it will believe the indoor tiles are
- * already rebuilt (see `updateMarkersWhenFloorSettles`). Genuinely a frame
- * count: the reload is dispatched on the map's next render, so this is how
- * many renders it gets to be observed in.
- */
-const FLOOR_SETTLE_MIN_FRAMES = 3;
-/**
- * Longest a floor change waits for the new floor's tiles before switching the
- * HTML markers anyway, so a stalled source never hides markers for good.
- *
- * A deadline rather than a frame count. The panels this matters on run at
- * 20-30 fps, where a 60-frame cap is two to three seconds — and the wait also
- * gates `addMarker`, so overshooting it is not merely a late marker switch.
- */
-const FLOOR_SETTLE_MAX_MS = 1000;
-/** Fill/line layer ids for one circle render-order bucket. */
-function circleLayerIdsFor(order) {
-    const suffix = CIRCLE_LAYER_SUFFIXES[order];
-    return { fill: CIRCLE_FILL_LAYER_ID + suffix, line: CIRCLE_LINE_LAYER_ID + suffix };
-}
-/** True for the layer ids owned by the circle API, regardless of bucket. */
-function isCircleLayerId(id) {
-    return id.startsWith(CIRCLE_FILL_LAYER_ID) || id.startsWith(CIRCLE_LINE_LAYER_ID);
-}
-// Flag to track if cached-tile protocol has been registered
-let cachedTileProtocolRegistered = false;
-/**
- * Deep clone helper that works in all environments.
- * Uses structuredClone if available, otherwise falls back to JSON serialization.
- * @param obj The object to clone
- * @returns A deep clone of the object
- */
-function deepClone(obj) {
-    if (obj === undefined || obj === null) {
-        return obj;
-    }
-    if (typeof structuredClone === "function") {
-        return structuredClone(obj);
-    }
-    return JSON.parse(JSON.stringify(obj));
-}
-/**
- * Register a custom protocol for cached tiles that routes requests through the main thread.
- * This allows the service worker to intercept and cache tile requests.
- *
- * Wraps fetches in a {@link Semaphore} so tile CDN / WAFs are not hit with
- * unbounded parallel requests (same host as the service worker cache). The
- * semaphore is created once with the limit from the first map's config; later
- * calls are no-ops because the protocol can only be registered once globally
- * on MapLibre.
- *
- * @param maxConcurrentFetches - Maximum number of in-flight tile fetches.
- */
-function registerCachedTileProtocol(maxConcurrentFetches) {
-    if (cachedTileProtocolRegistered)
-        return;
-    const semaphore = new semaphore_1.Semaphore(maxConcurrentFetches);
-    maplibre_gl_1.default.addProtocol("cached-tile", (params, abortController) => {
-        const url = params.url.replace("cached-tile://", "https://");
-        // Pass the abort signal to acquire() so a request cancelled while still
-        // queued (e.g. during rapid zoom) drops out of the FIFO queue instead of
-        // waiting for a slot just to bail. release() runs only inside this chain,
-        // i.e. only after a slot was actually granted.
-        return semaphore.acquire(abortController.signal).then(() => fetch(url, { signal: abortController.signal })
-            .then((response) => {
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            return response.arrayBuffer();
-        })
-            .then((data) => ({ data }))
-            .finally(() => {
-            semaphore.release();
-        }));
-    });
-    cachedTileProtocolRegistered = true;
-}
-/**
- * Converts a PaddingValue to pixels based on the container and viewport dimensions.
- * @param value The padding value (number or string with unit)
- * @param dimension The reference dimension in pixels (container width/height)
- * @returns The padding value in pixels
- */
-function parsePaddingValue(value, dimension) {
-    if (value === undefined) {
-        return 0;
-    }
-    if (typeof value === "number") {
-        return value;
-    }
-    const match = value.match(/^(-?\d*\.?\d+)(px|%|vh|vw)?$/);
-    if (!match) {
-        return 0;
-    }
-    const numericValue = Number.parseFloat(match[1]);
-    const unit = match[2] || "px";
-    switch (unit) {
-        case "px":
-            return numericValue;
-        case "%":
-            return (numericValue / 100) * dimension;
-        case "vh":
-            return (numericValue / 100) * window.innerHeight;
-        case "vw":
-            return (numericValue / 100) * window.innerWidth;
-        default:
-            return numericValue;
-    }
-}
-/**
- * Converts PaddingOptions with mixed units to MapLibre's pixel-based padding format.
- * @param padding The padding options with optional fields and mixed units
- * @param containerWidth The map container width in pixels
- * @param containerHeight The map container height in pixels
- * @returns Padding object with all values in pixels
- */
-function convertPaddingToPixels(padding, containerWidth, containerHeight) {
-    if (!padding) {
-        return { top: 0, bottom: 0, left: 0, right: 0 };
-    }
-    return {
-        top: parsePaddingValue(padding.top, containerHeight),
-        bottom: parsePaddingValue(padding.bottom, containerHeight),
-        left: parsePaddingValue(padding.left, containerWidth),
-        right: parsePaddingValue(padding.right, containerWidth),
-    };
-}
-const icons_1 = require("../assets/icons");
-const markerLayoutController_1 = require("../controllers/markerLayoutController");
-const routeController_1 = require("../controllers/routeController");
-const _rtl_1 = require("../domain/models/_rtl");
-const animation_1 = require("../domain/models/animation");
-const circle_1 = require("../domain/models/circle");
-const loggeable_1 = require("../domain/models/loggeable");
-const mapConfig_1 = require("../domain/models/mapConfig");
-const marker_1 = require("../domain/models/marker");
-const route_1 = require("../domain/models/route");
-const routeConfiguration_1 = require("../domain/models/routeConfiguration");
-const repository_1 = require("../repository/repository");
-const route_utils_1 = require("../utils/route-utils");
-const utils_1 = require("../utils/utils");
-const scene3DController_1 = require("./scene3DController");
-const fitCamera_1 = require("./fitCamera");
-const liveMapFitTransform_1 = require("./liveMapFitTransform");
-const mapInteractionOptions_1 = require("./mapInteractionOptions");
-/**
- * Class to interact with the map.
- * @category Map
- * @hidden
- */
-class InternalMapVXMap extends loggeable_1.Loggeable {
-    /** Whether a floor change is still rebuilding, so markers wait for it. */
-    get floorSettlePending() {
-        return this.floorSettleDeadline != null && this.now() < this.floorSettleDeadline;
-    }
-    /** Wall clock for the settle deadline; `Date.now` where `performance` is absent. */
-    now() {
-        return typeof performance !== "undefined" ? performance.now() : Date.now();
-    }
-    /**
-     * Creates a new map instance with the parameters specified in mapConfig and assigns it to the provided HTML container.
-     * @param mapConfig Configuration parameters for the map.
-     * @param container Container where the assignment of the created map is required.
-     * @param parentPlace Parent place required for map floor mapping, along with the display of subplaces.
-     * @param token The token provided for the creation and fetching of map information.
-     * @returns A new instance of MapVXMap.
-     */
-    constructor(mapConfig, container, token) {
-        var _a, _b, _c, _d;
-        super();
-        /**
-         * Monotonic counter for {@link addLiveRoute} calls. Refreshes overlap (each one
-         * awaits a fetch), so only the call holding the latest ticket may touch the
-         * map — an older response resolving last is discarded instead of clobbering
-         * the newer route.
-         */
-        this.liveRouteTicket = 0;
-        this.potentialParentPlaces = [];
-        this.innerFloors = [];
-        this.subPlaces = [];
-        this.currentFloor = "";
-        this.baseFilters = {};
-        /**
-         * Layer ids whose declared (base) filter has already been resolved — either captured
-         * into {@link baseFilters} or confirmed absent.
-         *
-         * `baseFilters[id] === undefined` cannot carry that information on its own: it means
-         * both "not looked at yet" and "looked at, the layer declares no filter". Without the
-         * distinction, a later pass re-reads the layer's LIVE filter — which by then is the
-         * one this class wrote — and stores our own floor/public-place filter as if it were
-         * the style's, so the layer keeps filtering by a stale floor forever.
-         *
-         * An id lands here the moment its declared filter is read from the style spec, or the
-         * moment this class writes a filter to that layer, whichever happens first. Layers
-         * added asynchronously after a `setStyle` swap are in neither situation, so their
-         * genuinely pristine live filter is still captured on first touch.
-         */
-        this.capturedBaseFilters = new Set();
-        /**
-         * Monotonic id of the most recently STARTED style swap. Every {@link setStyle} call
-         * captures its own value and checks it again in each async continuation, so a
-         * superseded swap can neither touch the shared bookkeeping (`styleReadyTimer`,
-         * `pendingStyleSwapListener`) nor apply its obsolete style to the live map.
-         *
-         * A per-call `readied` flag is not enough: the timer and the listener slot are
-         * single-valued instance state, so two overlapping swaps otherwise clobber each
-         * other's — one caller's overlay is released by the other's failure, or an
-         * abandoned listener re-seeds filters from layer ids the current style lacks.
-         */
-        this.styleSwapGeneration = 0;
-        this.markers = [];
-        this.circles = [];
-        this.enableHover = false;
-        this.hoveredId = "unselected";
-        this.failedTiles = new Set();
-        /**
-         * Retry bookkeeping per failed tile. A WeakMap so it can never outlive the tiles
-         * themselves — entries disappear with the tile objects, which is why none of the
-         * `failedTiles.clear()` paths have to reset it.
-         */
-        this.tileRetryState = new WeakMap();
-        this.geoLocation = navigator.geolocation;
-        /** Floor-change settle bookkeeping (see `updateMarkersWhenFloorSettles`). */
-        this.floorSettleToken = 0;
-        /**
-         * When the floor-change settle stops holding markers back, or `null` when no
-         * change is in flight.
-         *
-         * A deadline rather than a flag, because `addMarker` reads it: the poll that
-         * would clear a flag runs on `requestAnimationFrame`, which does not fire in
-         * a backgrounded tab and does not run at all for a map torn down through
-         * MapLibre's own `remove()` rather than `destroyMap`. A flag left set there
-         * makes every later `addMarker` skip the call that attaches the marker, for
-         * good; a deadline expires on its own.
-         */
-        this.floorSettleDeadline = null;
-        /** Owns the deck.gl overlay + GLB scene; created on style load only when 3D is active. */
-        this.scene3D = undefined;
-        if (_rtl_1.rtlLanguages.includes((_a = mapConfig.lang) !== null && _a !== void 0 ? _a : "")) {
-            this.setRTLSupport();
-        }
-        this.repository = new repository_1.Repository(token, (_b = mapConfig.lang) !== null && _b !== void 0 ? _b : "en", mapConfig.apiUrl, undefined, mapConfig.mapvxRequestContext, {
-            routeApiUrl: mapConfig.routeApiUrl,
-            healthApiUrl: mapConfig.healthApiUrl,
-            legacyApiUrl: mapConfig.legacyApiUrl,
-            portalApiUrl: mapConfig.portalApiUrl,
-        });
-        this.token = token;
-        this.authToken = mapConfig.authToken;
-        this.currentLang = (_c = mapConfig.lang) !== null && _c !== void 0 ? _c : "en";
-        this.parentPlaceId = mapConfig.parentPlaceId;
-        this.routeController = new routeController_1.RouteController(this);
-        this.userLocationMarker = undefined;
-        this.watchPositionID = undefined;
-        this.onFloorChange = mapConfig.onFloorChange;
-        this.onParentPlaceChange = mapConfig.onParentPlaceChange;
-        this.mode = (_d = mapConfig.mode) !== null && _d !== void 0 ? _d : "2D";
-        this.styleRef = mapConfig.styleRef;
-        this.styleTheme = mapConfig.styleTheme;
-        this.scene3DConfig = mapConfig.scene3D;
-        this.initialCenter = mapConfig.center;
-        this.tileCacheConfig = (() => {
-            const merged = Object.assign(Object.assign({}, mapConfig_1.DEFAULT_TILE_CACHE_CONFIG), mapConfig.tileCache);
-            merged.maxTiles = Math.min(merged.maxTiles, mapConfig_1.MAPLIBRE_MAX_TILE_CACHE_HARD_CAP);
-            return merged;
-        })();
-        this.markerLayoutConfig = Object.assign(Object.assign({}, mapConfig_1.DEFAULT_MARKER_LAYOUT_CONFIG), mapConfig.markerLayout);
-        this.markerLayoutController = new markerLayoutController_1.MarkerLayoutController(this, this.markerLayoutConfig);
-        // `container` is the very element handed to MapLibre below, and every
-        // marker is mounted inside it, so publishing the gap/width variables here
-        // covers markers added before the map's "load" event fires.
-        this.markerLayoutController.applyLayoutVariables(container);
-        if (mapConfig.parentPlaceId != null) {
-            this.initialPlaceDetailSetUp(mapConfig.parentPlaceId, mapConfig.authToken);
-        }
-        if (mapConfig.otherPotentialParentPlacesIds &&
-            mapConfig.otherPotentialParentPlacesIds.length > 0) {
-            this.loadOtherPotentialParentPlaces(mapConfig.otherPotentialParentPlacesIds);
-        }
-        this.enableHover = mapConfig.enableHover || false;
-        this.initialMapStyleSetUp(mapConfig, container);
-    }
-    setRTLSupport() {
-        (0, maplibre_gl_1.setRTLTextPlugin)("https://unpkg.com/@mapbox/mapbox-gl-rtl-text@0.3.0/dist/mapbox-gl-rtl-text.js", false).catch(() => {
-            // RTL support may fail in some browsers - this is expected
-        });
-    }
-    /**
-     * Transform style sources to use cached-tile:// protocol for tile URLs.
-     * This enables the service worker to intercept and cache tile requests.
-     * @param style The original style specification
-     * @returns A new style with transformed tile URLs
-     */
-    transformStyleForCaching(style) {
-        if (!style) {
-            return style;
-        }
-        const transformedStyle = deepClone(style);
-        if (transformedStyle === null || transformedStyle === void 0 ? void 0 : transformedStyle.sources) {
-            for (const sourceKey of Object.keys(transformedStyle.sources)) {
-                const source = transformedStyle.sources[sourceKey];
-                // Transform vector and raster tile sources
-                // Only transform source.tiles (actual tile URLs), NOT source.url (TileJSON metadata URL)
-                // source.url points to a TileJSON file that returns JSON, not binary tile data
-                if (source.tiles && Array.isArray(source.tiles)) {
-                    source.tiles = source.tiles.map((tileUrl) => {
-                        if (tileUrl.startsWith("https://")) {
-                            return tileUrl.replace("https://", "cached-tile://");
-                        }
-                        return tileUrl;
-                    });
-                }
-            }
-        }
-        return transformedStyle;
-    }
-    initialPlaceDetailSetUp(parentPlaceId, withBearerToken) {
-        if (withBearerToken) {
-            this.repository
-                .fetchAndParseAnyPlaceDetail({ id: parentPlaceId }, withBearerToken)
-                .then((place) => {
-                this.changeParentPlaceTo(place);
-                this.potentialParentPlaces.push(place);
-            })
-                .catch(console.error);
-            return;
-        }
-        this.repository
-            .fetchAndParsePlaceDetail({ id: parentPlaceId })
-            .then((place) => {
-            this.changeParentPlaceTo(place);
-            this.potentialParentPlaces.push(place);
-        })
-            .catch(console.error);
-    }
-    loadOtherPotentialParentPlaces(ids) {
-        Promise.all(ids.map((id) => this.repository.fetchAndParsePlaceDetail({ id })))
-            .then((places) => {
-            this.potentialParentPlaces.push(...places);
-        })
-            .catch(console.error);
-    }
-    subPlacesLoad(parentPlaceId) {
-        this.repository
-            .fetchAndParseSubPlaces(parentPlaceId)
-            .then((subPlaces) => {
-            this.subPlaces = subPlaces;
-        })
-            .catch(console.error);
-    }
-    initialMapStyleSetUp(mapConfig, container) {
-        if (mapConfig.institutionId && mapConfig.authToken) {
-            this.repository
-                .fetchAndParseAnyMapStyle(mapConfig.institutionId, mapConfig.authToken)
-                .then((style) => {
-                return this.onMapStyleLoaded(mapConfig, container, style);
-            })
-                .catch(console.error);
-            return;
-        }
-        // Through the same helper as `setStyle` and `changeParentPlaceTo`. This PR
-        // forwards `styleRef`/`styleTheme` to the initial load too, and a ref scoped
-        // to the user's client rather than to the api key resolves only over bearer
-        // — fetched over the api-key path it 4xx'd, and since this is the call that
-        // creates the map, the map was never created at all.
-        this.fetchVenueStyle(mapConfig.parentPlaceId, mapConfig.styleRef, mapConfig.styleTheme)
-            .then((style) => {
-            return this.onMapStyleLoaded(mapConfig, container, style);
-        })
-            .catch((error) => {
-            this.logError(error, { functionName: "initialMapStyleSetUp" });
-        });
-    }
-    onMapStyleLoaded(mapConfig, container, style) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        // Determine if service worker caching should be enabled
-        const useServiceWorkerCaching = this.tileCacheConfig.enabled && this.tileCacheConfig.persistToServiceWorker;
-        if (useServiceWorkerCaching) {
-            registerCachedTileProtocol(this.tileCacheConfig.maxConcurrentTileFetches);
-        }
-        // Transform tile URLs only if service worker caching is enabled
-        const finalStyle = useServiceWorkerCaching ? this.transformStyleForCaching(style) : style;
-        const mapOptions = Object.assign({ container, style: finalStyle, center: mapConfig.center, zoom: mapConfig.zoom, pitch: (_a = mapConfig.pitch) !== null && _a !== void 0 ? _a : 0, attributionControl: false, maplibreLogo: false, bearingSnap: (_b = mapConfig.bearingSnap) !== null && _b !== void 0 ? _b : 0, cancelPendingTileRequestsWhileZooming: true, 
-            // Use configured maxTiles for MapLibre's memory cache
-            maxTileCacheSize: this.tileCacheConfig.maxTiles }, (0, mapInteractionOptions_1.buildInteractionOptions)(mapConfig));
-        if (mapConfig.maxZoom)
-            mapOptions.maxZoom = mapConfig.maxZoom;
-        if (mapConfig.minZoom)
-            mapOptions.minZoom = mapConfig.minZoom;
-        // Reduced internal resolution on request (fill-rate relief for low-end GPUs);
-        // MapLibre keeps devicePixelRatio when the option is left out.
-        if (mapConfig.pixelRatio !== undefined)
-            mapOptions.pixelRatio = mapConfig.pixelRatio;
-        // `0` disables the post-gesture fade tail entirely; keep MapLibre's default otherwise.
-        if (mapConfig.fadeDuration !== undefined)
-            mapOptions.fadeDuration = mapConfig.fadeDuration;
-        if (mapConfig.maxBounds && mapConfig.maxBounds.length > 1) {
-            const boundingBox = (0, utils_1.getBoundingBox)(mapConfig.maxBounds);
-            mapOptions.maxBounds = new maplibre_gl_1.LngLatBounds([boundingBox[0].lng, boundingBox[0].lat], [boundingBox[1].lng, boundingBox[1].lat]);
-        }
-        this.map = new maplibre_gl_1.Map(mapOptions);
-        // Create the 3D controller only when the map opts into 3D. All heavy WebGL / deck.gl work is
-        // owned by it; in 2D mode `this.scene3D` stays undefined and every hook below is a no-op.
-        if (this.is3DSceneActive() && this.scene3DConfig) {
-            this.scene3D = new scene3DController_1.Scene3DController(this.map, this.scene3DConfig, this.initialCenter, mapConfig.onScene3DModelsProgress);
-        }
-        // When rotation is disabled we still want pinch-to-zoom to work, so the
-        // two-finger rotation is turned off here instead of via the constructor.
-        if ((0, mapInteractionOptions_1.shouldDisableTouchRotation)(mapConfig)) {
-            (_d = (_c = this.map.touchZoomRotate) === null || _c === void 0 ? void 0 : _c.disableRotation) === null || _d === void 0 ? void 0 : _d.call(_c);
-        }
-        this.map.addControl(new maplibre_gl_1.NavigationControl({
-            showCompass: (_e = mapConfig.showCompass) !== null && _e !== void 0 ? _e : true,
-            showZoom: (_f = mapConfig.showZoom) !== null && _f !== void 0 ? _f : true,
-        }), (_g = mapConfig.navigationPosition) !== null && _g !== void 0 ? _g : "top-right");
-        this.map.on("load", () => {
-            var _a, _b;
-            // 3D libraries load asynchronously; the rest of the load flow does not wait on them.
-            void ((_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.onMapLoad());
-            this.whenStyleUpdates(style);
-            if (mapConfig.lang)
-                this.setLayersForLanguage(mapConfig.lang);
-            (_b = mapConfig.onMapReady) === null || _b === void 0 ? void 0 : _b.call(mapConfig);
-            this.onHover();
-            this.subscribeToFailedTiles();
-            this.markerLayoutController.attach();
-        });
-        // Self-healing for circles: a full style reload wipes custom sources and
-        // layers, and not every restyle path goes through whenStyleUpdates.
-        this.map.on("styledata", () => {
-            if (this.circles.length > 0)
-                this.ensureCircleLayers();
-        });
-        this.map.on("zoom", () => {
-            var _a;
-            (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.onZoom();
-        });
-        this.map.on("zoomend", () => {
-            var _a;
-            (_a = mapConfig.onZoomEnd) === null || _a === void 0 ? void 0 : _a.call(mapConfig, this.getZoomLevel());
-        });
-        this.map.on("rotate", () => {
-            var _a;
-            (_a = mapConfig.onRotate) === null || _a === void 0 ? void 0 : _a.call(mapConfig, this.map.getBearing());
-        });
-        this.defaultClickListener();
-    }
-    setBaseFilters(style) {
-        if (!style)
-            return;
-        const publicPlaceFilter = ["==", ["get", "public_place"], true];
-        style.layers
-            .filter((layer) => layer.id.startsWith("indoor-"))
-            .forEach((layer) => {
-            // Seed from the STYLE SPEC — the only pristine source — and do it BEFORE the
-            // setFilter below overwrites the live filter. Reading it back afterwards would
-            // return our own `publicPlaceFilter` and store it as the layer's declared one,
-            // turning `public_place` from an OR into an AND and hiding every private
-            // feature on the selected floor. Every indoor layer is covered, not just
-            // fill/line/symbol: a `circle` layer is discriminated by its filter just the
-            // same, and dropping it makes the layer repaint every feature.
-            // `filter` is absent from the union member for `background` layers, hence the
-            // structural read rather than `layer.filter`.
-            const declared = layer.filter;
-            this.captureDeclaredBaseFilter(layer.id, declared);
-            const baseFilter = this.baseFilters[layer.id];
-            if (baseFilter != null) {
-                const finalFilter = ["all", baseFilter, publicPlaceFilter];
-                this.map.setFilter(layer.id, finalFilter);
-            }
-            else {
-                this.map.setFilter(layer.id, publicPlaceFilter);
-            }
-        });
-    }
-    /**
-     * Records a layer's declared (base) filter the first time the layer is seen, from an
-     * explicit value (a style-spec `filter`) when one is available, otherwise by reading
-     * the live filter — which is only pristine for layers this class has never written to.
-     *
-     * Marking happens even when no filter exists, so the layer is never revisited: on a
-     * second visit its live filter is one we produced, and storing that as the "declared"
-     * filter is what freezes a layer to a stale floor.
-     *
-     * @param layerId Id of the layer whose base filter should be resolved.
-     * @param declared Declared filter straight from the style spec, when the caller has it.
-     */
-    captureDeclaredBaseFilter(layerId, declared) {
-        if (this.capturedBaseFilters.has(layerId))
-            return;
-        this.capturedBaseFilters.add(layerId);
-        const baseFilter = declared !== null && declared !== void 0 ? declared : this.safeGetFilter(layerId);
-        if (baseFilter != null) {
-            this.baseFilters[layerId] = baseFilter;
-        }
-    }
-    setLayersForLanguage(lang) {
-        var _a, _b;
-        // outdoor layers
-        const layersName = [
-            "aerodrome_label",
-            "mountain_peak",
-            "park",
-            "place",
-            "poi",
-            "transportation_name",
-            "water_name",
-            "waterway",
-        ];
-        const layers = (_b = (_a = this.map.getStyle()) === null || _a === void 0 ? void 0 : _a.layers) !== null && _b !== void 0 ? _b : [];
-        const layersIds = layers
-            .filter((layer) => {
-            var _a;
-            return layer.type === "symbol" &&
-                layer.source === "openmaptiles" &&
-                layersName.includes((_a = layer["source-layer"]) !== null && _a !== void 0 ? _a : "");
-        })
-            .map((layer) => {
-            return layer.id;
-        });
-        layersIds.forEach((id) => {
-            try {
-                const property = this.map.getLayoutProperty(id, "symbol-placement");
-                this.map.setLayoutProperty(id, "text-field", [
-                    "case",
-                    ["has", `name:${lang}`],
-                    ["get", `name:${lang}`],
-                    [
-                        "format",
-                        ["get", "name:latin"],
-                        property === "line" ? " " : "\n",
-                        ["get", "name:nonlatin"],
-                    ],
-                ]);
-            }
-            catch (error) {
-                this.debugLog("Layer language update failed (layer may not exist)", error);
-            }
-        });
-        // indoor layers
-        const indoorLayerIds = layers
-            .filter((layer) => {
-            var _a;
-            return layer.type === "symbol" &&
-                layer.source === "indoorequal" &&
-                ((_a = layer.layout) === null || _a === void 0 ? void 0 : _a["text-field"]) !== undefined;
-        })
-            .map((layer) => {
-            return layer.id;
-        });
-        indoorLayerIds.forEach((id) => {
-            try {
-                this.map.setLayoutProperty(id, "text-field", [
-                    "case",
-                    ["has", `name:${lang}`],
-                    ["get", `name:${lang}`],
-                    ["get", "name"],
-                ]);
-            }
-            catch (error) {
-                this.debugLog("Layer language update failed (layer may not exist)", error);
-            }
-        });
-    }
-    /**
-     * Add values to identify the client.
-     * @param segmentation The pair values to use as segmentation.
-     * @returns The segmentation with the added values.
-     */
-    prepareSegmentation(segmentation) {
-        var _a;
-        return Object.assign(Object.assign({}, segmentation), { token: this.token, parentPlaceId: (_a = this.parentPlaceId) !== null && _a !== void 0 ? _a : "None" });
-    }
-    destroyMap() {
-        var _a;
-        this.circles = [];
-        this.markerLayoutController.destroy();
-        // Drop any in-flight `setStyle` bookkeeping while the map still exists: the
-        // listener has to be detached before `map.remove()`, and the safety timer must not
-        // outlive the map and call `onStyleReady` for a map that is already gone.
-        this.clearPendingStyleSwapListener();
-        if (this.styleReadyTimer) {
-            clearTimeout(this.styleReadyTimer);
-            this.styleReadyTimer = undefined;
-        }
-        // Drop any floor-settle poll in flight: bumping the token makes the next
-        // `requestAnimationFrame` callback return instead of re-queueing itself and
-        // re-attaching markers to a map that has already been removed.
-        this.floorSettleToken++;
-        this.floorSettleDeadline = null;
-        // Dispose the 3D scene's GPU resources before the map (and its shared WebGL context) go away —
-        // MapLibre's own teardown never calls the custom GLB layer's `onRemove`.
-        (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.map.remove();
-        this.unsubscribeFromFailedTiles();
-    }
-    clearTileCache() {
-        try {
-            // Clear the failed tiles tracking set
-            this.failedTiles.clear();
-            // Force MapLibre to reload all visible tiles by triggering a repaint
-            // Note: MapLibre doesn't expose a direct cache clear method, so we
-            // trigger a style refresh which causes tiles to be re-requested
-            if (this.map) {
-                this.map.triggerRepaint();
-            }
-            this.logEvent("clearTileCache");
-        }
-        catch (error) {
-            this.debugLog("Tile cache clear failed (cache may not exist)", error);
-        }
-    }
-    /**
-     * Whether 3D scene features (deck.gl overlay, declarative GLB custom layer, etc.) are active.
-     * Requires {@link MapConfig.mode} `"3D"` and {@link Scene3DConfig.enabled} not `false`.
-     * The heavy WebGL / deck.gl work lives in {@link Scene3DController}; this only decides whether one
-     * is created and wired up. When `scene3D` is omitted, 3D features remain available.
-     */
-    is3DSceneActive() {
-        var _a;
-        return this.mode === "3D" && ((_a = this.scene3DConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
-    }
-    getCurrentFloor() {
-        var _a;
-        return (_a = this.currentFloor) !== null && _a !== void 0 ? _a : "";
-    }
-    /**
-     * Sets the route path used for GLB route-transparency collision, so 3D models a route passes
-     * through fade and reveal the floor plan underneath. Called by {@link RouteController} whenever
-     * the set of drawn routes changes. Points are tagged with the floor their segment is drawn on;
-     * only points on the displayed floor participate. Pass an empty array to clear.
-     *
-     * No-op unless the 3D scene is active.
-     */
-    setRouteCollisionPath(points) {
-        var _a;
-        if (!this.is3DSceneActive()) {
-            return;
-        }
-        (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.setRouteCollisionPath(points);
-    }
-    /**
-     * Performs changes when parent place is updated
-     * @param place new parent place
-     * @param updateStyle defines if new parent place style must be set
-     */
-    changeParentPlaceTo(place, updateStyle = false, onStyleReady) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        this.parentPlace = place;
-        this.parentPlaceId = place === null || place === void 0 ? void 0 : place.mapvxId;
-        this.innerFloors = (_b = (_a = place === null || place === void 0 ? void 0 : place.innerFloors) === null || _a === void 0 ? void 0 : _a.sort((a, b) => a.index - b.index)) !== null && _b !== void 0 ? _b : [];
-        this.currentFloor =
-            (_f = (_d = (_c = this.innerFloors.find((floor) => floor.defaultFloor)) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : (_e = this.innerFloors[0]) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : "";
-        if (place) {
-            this.subPlacesLoad(place.mapvxId);
-        }
-        (_g = this.scene3D) === null || _g === void 0 ? void 0 : _g.onFloorChange(this.currentFloor);
-        if (updateStyle) {
-            this.fetchVenueStyle(place === null || place === void 0 ? void 0 : place.mapvxId, this.styleRef, this.styleTheme)
-                .then((style) => {
-                const useServiceWorkerCaching = this.tileCacheConfig.enabled && this.tileCacheConfig.persistToServiceWorker;
-                const finalStyle = useServiceWorkerCaching ? this.transformStyleForCaching(style) : style;
-                this.map.setStyle(finalStyle);
-                // The new place's style declares its own filters for the same `indoor-*` layer
-                // ids. Without this reset every id is still marked captured from the previous
-                // place, so `captureDeclaredBaseFilter` early-returns for all of them and the
-                // previous place's expressions keep filtering the new style forever. (The
-                // `switch (layer.type)` block that used to re-read them on every style load was
-                // removed when capture became once-per-id, which is what made this necessary.)
-                this.resetBaseFilters();
-                this.whenStyleUpdates(finalStyle);
-                onStyleReady === null || onStyleReady === void 0 ? void 0 : onStyleReady();
-            })
-                .catch((error) => {
-                this.logError(error, { functionName: "changeParentPlaceTo" });
-                // Release the caller either way. `onStyleReady` is what a consumer
-                // hides its loading overlay on, so swallowing the failure here left
-                // the overlay up for good rather than merely unstyled.
-                onStyleReady === null || onStyleReady === void 0 ? void 0 : onStyleReady();
-            });
-        }
-    }
-    /**
-     * Fetch the venue style over whichever endpoint this map is authorized on.
-     *
-     * A bearer token authorizes by the user's client access rather than the api
-     * key's scopes, so a client's branded style resolves without granting that
-     * place to a shared api key; api-key consumers keep the
-     * `/api/sdk/v2/mapStyleJson` path.
-     *
-     * Both callers go through here so they cannot disagree. They used to: once
-     * `setStyle` had stored a `styleRef` it resolved over bearer, the next
-     * parent-place change refetched that same ref over the api-key path, whose
-     * key does not scope it — a non-ok response, a rejected promise, and a style
-     * that was never applied, with `onStyleReady` left unfired under a caller's
-     * loading overlay.
-     */
-    fetchVenueStyle(placeId, styleRef, styleTheme) {
-        return this.authToken
-            ? this.repository.fetchAndParseMapStyleByBearer(placeId, this.authToken, styleRef, styleTheme)
-            : this.repository.fetchAndParseMapStyle(placeId, styleRef, styleTheme);
-    }
-    /**
-     * Update the parent place and the current floor.
-     * Does not update layers, markers, etc.
-     * @param parentPlaceId
-     * @param floorId
-     * @throws A error if the parent place is not one of the allowed places to show.
-     */
-    updatePlaceAndFloor(parentPlaceId, floorId) {
-        var _a, _b, _c, _d, _e, _f;
-        const place = this.potentialParentPlaces.find((place) => place.mapvxId === parentPlaceId);
-        this.parentPlace = place;
-        this.parentPlaceId = place === null || place === void 0 ? void 0 : place.mapvxId;
-        this.innerFloors = (_a = place === null || place === void 0 ? void 0 : place.innerFloors.sort((a, b) => a.index - b.index)) !== null && _a !== void 0 ? _a : [];
-        this.currentFloor =
-            (_e = (_c = floorId !== null && floorId !== void 0 ? floorId : (_b = this.innerFloors.find((floor) => floor.defaultFloor)) === null || _b === void 0 ? void 0 : _b.key) !== null && _c !== void 0 ? _c : (_d = this.innerFloors[0]) === null || _d === void 0 ? void 0 : _d.key) !== null && _e !== void 0 ? _e : "";
-        (_f = this.scene3D) === null || _f === void 0 ? void 0 : _f.onFloorChange(this.currentFloor);
-    }
-    updateParentPlaceAndFloor(parentPlaceId, floorId, options) {
-        var _a, _b, _c, _d;
-        try {
-            this.updatePlaceAndFloor(parentPlaceId, floorId);
-            this.filterByFloorKey(this.currentFloor);
-            (_a = this.onParentPlaceChange) === null || _a === void 0 ? void 0 : _a.call(this, parentPlaceId);
-            (_b = this.onFloorChange) === null || _b === void 0 ? void 0 : _b.call(this, (_c = this.currentFloor) !== null && _c !== void 0 ? _c : "");
-            this.logEvent("updateParentPlaceAndFloor");
-            (_d = options === null || options === void 0 ? void 0 : options.onComplete) === null || _d === void 0 ? void 0 : _d.call(options);
-        }
-        catch (error) {
-            this.debugLog("Parent place/floor update failed", error);
-        }
-    }
-    setLang(lang) {
-        this.repository.setLang(lang);
-        this.currentLang = lang;
-        if (_rtl_1.rtlLanguages.includes(lang)) {
-            this.setRTLSupport();
-        }
-        // setLayersForLanguage reads this.map.getStyle()?.layers, which is empty
-        // until the style finishes loading. If setLang is called right after
-        // createMap (before the "load" event), apply it once the style is ready
-        // so the language change is not silently dropped.
-        if (this.map.isStyleLoaded()) {
-            this.setLayersForLanguage(lang);
-        }
-        else {
-            this.map.once("load", () => this.setLayersForLanguage(lang));
-        }
-    }
-    setParentPlace(place, updateStyle, onStyleReady) {
-        this.changeParentPlaceTo(place, updateStyle, onStyleReady);
-    }
-    setStyle(styleRef, styleTheme, onStyleReady) {
-        // Every swap gets a generation. All shared bookkeeping below is touched only while
-        // this swap is still the current one, so two overlapping calls cannot release each
-        // other's overlay or apply an obsolete style. `readied` stays per-call because each
-        // caller's callback must still fire exactly once.
-        const generation = ++this.styleSwapGeneration;
-        const isCurrent = () => this.styleSwapGeneration === generation;
-        let readied = false;
-        const reportReady = (error) => {
-            if (readied)
-                return;
-            readied = true;
-            // Only the current swap owns the shared timer; a superseded swap clearing it here
-            // would leave the live swap with no safety net (and its caller hidden forever).
-            if (isCurrent() && this.styleReadyTimer) {
-                clearTimeout(this.styleReadyTimer);
-                this.styleReadyTimer = undefined;
-            }
-            onStyleReady === null || onStyleReady === void 0 ? void 0 : onStyleReady(error);
-        };
-        // `onStyleReady` must fire on EVERY path — success, a rejected style request, or a
-        // swap that never settles — because callers keep the map hidden behind a loading
-        // overlay until it arrives. The safety timer is therefore armed before the request
-        // instead of inside `.then()`.
-        if (this.styleReadyTimer)
-            clearTimeout(this.styleReadyTimer);
-        this.styleReadyTimer = setTimeout(reportReady, STYLE_READY_TIMEOUT_MS);
-        // A previous swap may still hold a `styledata` listener whose style never reached the
-        // loaded state. Drop it before starting a new one: it captured an obsolete style and
-        // would otherwise fire on this swap, wiping `baseFilters` and calling `setFilter`
-        // with layer ids the new style does not have.
-        this.clearPendingStyleSwapListener();
-        // `this.map` is created asynchronously (see `onMapStyleLoaded`), so a `setStyle` call
-        // made right after `createMap` can land before it exists. Fail loudly instead of
-        // letting `this.map.setStyle` throw into `.catch`, which reported READY and left the
-        // caller revealing the previous style as if the swap had succeeded.
-        if (!this.map) {
-            const error = new Error("setStyle called before the map finished initializing; wait for the map's load event");
-            this.logError(error, { functionName: "setStyle" });
-            reportReady(error);
-            return;
-        }
-        const stylePromise = this.fetchVenueStyle(this.parentPlaceId, styleRef, styleTheme);
-        stylePromise
-            .then((style) => {
-            // A newer swap started while this style was in flight. Applying this one now
-            // would fight the newer style layer by layer, so drop it and let the newer swap
-            // own the map and its caller's callback.
-            if (!isCurrent())
-                return;
-            // Remember what is actually on screen: `changeParentPlaceTo` refetches the
-            // style with these, so without this an explicitly applied style would be
-            // silently reverted to the constructor's on the next parent-place change.
-            // After the generation check: a superseded swap never reached the map, so it
-            // must not claim to be what is on it.
-            this.styleRef = styleRef;
-            this.styleTheme = styleTheme;
-            const useServiceWorkerCaching = this.tileCacheConfig.enabled && this.tileCacheConfig.persistToServiceWorker;
-            const finalStyle = useServiceWorkerCaching ? this.transformStyleForCaching(style) : style;
-            // Full (non-diff) swap so the previewed style completely replaces the base —
-            // a diff would keep old base layers and reappear on the next floor change.
-            this.map.setStyle(finalStyle, { diff: false });
-            // Drop the previous style's base filters SYNCHRONOUSLY, right where the layers
-            // they describe stop existing. They are keyed by layer id and persist across
-            // swaps, so any code reading them before the apply pass below (the `idle`
-            // handler's `filterByFloorKey`, a floor change racing the swap) would AND the
-            // previous style's discriminator into the new style's layers — the stale-filter
-            // washout this reset exists to prevent. Gating it on `isStyleLoaded` left exactly
-            // that window open. Fresh declared filters are re-captured lazily in
-            // `applyLayerFilters` as each indoor layer is first touched.
-            this.resetBaseFilters();
-            // Re-apply floor filters, route/circle layers and markers ONLY once the new
-            // style's sources/layers have finished loading; running them mid-reload throws
-            // (`getSource` on an undefined style) and the floor filter would not stick.
-            const applyOnceLoaded = () => {
-                // Superseded: detach and leave the map to the newer swap. Without this the
-                // listener stays attached (the slot it was tracked in has been overwritten)
-                // and re-seeds filters from layer ids the current style does not have, which
-                // makes maplibre throw and aborts the newer swap's own listener.
-                if (!isCurrent()) {
-                    this.map.off("styledata", applyOnceLoaded);
-                    return;
-                }
-                if (!this.hasLoadedStyle())
-                    return;
-                this.map.off("styledata", applyOnceLoaded);
-                if (this.pendingStyleSwapListener === applyOnceLoaded) {
-                    this.pendingStyleSwapListener = undefined;
-                }
-                this.whenStyleUpdates(finalStyle);
-                // A non-diff swap replaces every layer, so anything applied ON TOP of the
-                // style — label language, caller-requested place highlights, the 3D scene's
-                // GLB layer and hidden-layer overrides — is gone and has to be replayed.
-                // `whenStyleUpdates` covers only floor filters, routes and circles.
-                this.restoreStyleOverlays();
-                this.logEvent("setStyle");
-            };
-            this.pendingStyleSwapListener = applyOnceLoaded;
-            this.map.on("styledata", applyOnceLoaded);
-            applyOnceLoaded();
-            // Re-apply the floor filter and report ready once the map is idle. This is
-            // intentionally OUTSIDE applyOnceLoaded's `isStyleLoaded` gate: the indoor
-            // polygon layers settle a beat after the swap (so the floor filter in
-            // whenStyleUpdates misses them and the venue paints every floor at once), and
-            // `idle` only fires once the style is loaded and its first tiles rendered — so
-            // filterByFloorKey is safe here and does not depend on the sometimes-flaky
-            // isStyleLoaded check. onStyleReady lets callers reveal the map only once it is
-            // settled; the timer armed above just clears a hanging overlay if idle never fires.
-            this.map.once("idle", () => {
-                // `once` cannot be cancelled, so a superseded swap's handler still fires —
-                // filtering here keeps it from re-filtering the newer style's floors and from
-                // reporting the newer swap's caller ready ahead of time.
-                if (!isCurrent())
-                    return;
-                this.filterByFloorKey(this.currentFloor);
-                reportReady();
-            });
-        })
-            .catch((error) => {
-            // A superseded swap must not tear down the listener the CURRENT swap installed.
-            if (isCurrent()) {
-                this.clearPendingStyleSwapListener();
-            }
-            this.logError(error, { functionName: "setStyle" });
-            // Release the caller immediately instead of making it wait out the safety timer:
-            // the style will never arrive, so the overlay has nothing to wait for. The error
-            // is handed to the callback so a caller can tell a failed swap from an applied
-            // one — the previous style is still on screen either way.
-            reportReady(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-    /**
-     * Forgets every captured base filter so the next style's declared filters are read
-     * fresh from that style instead of inherited from the previous one.
-     *
-     * Both halves must move together: `baseFilters` holds the expressions and
-     * `capturedBaseFilters` records which layer ids have already been resolved, so
-     * clearing only the first would leave every id marked "already captured" and the new
-     * style's filters would never be read at all.
-     */
-    resetBaseFilters() {
-        this.baseFilters = {};
-        this.capturedBaseFilters.clear();
-    }
-    /**
-     * Replays everything that lives ON TOP of the map style after a full (non-diff) swap
-     * has deleted it: label language expressions, caller-requested place highlights and
-     * the 3D scene's GLB layer / hidden-layer overrides.
-     *
-     * These are deliberately not part of `whenStyleUpdates`, which restores only
-     * style-derived state. These are decisions the SDK's callers made through `setLang`,
-     * `setPlacesAsSelected`, `addBorderToPlaces` and the 3D config, and nothing else would
-     * ever restore them.
-     */
-    restoreStyleOverlays() {
-        // Each step is isolated: the style itself has already been applied by the time we get
-        // here, so one failing restore must neither skip the others nor bubble out into
-        // `setStyle`'s `.catch`, which would report the successful swap to `onStyleReady` as
-        // a failure. `setPlacesAsSelected` / `addBorderToPlaces` throw by contract.
-        const restore = (what, step) => {
-            try {
-                step();
-            }
-            catch (error) {
-                this.logError(error, { functionName: "restoreStyleOverlays", step: what });
-            }
-        };
-        restore("language", () => this.setLayersForLanguage(this.currentLang));
-        if (this.coloredPlacesRequest) {
-            const { placeIds, color } = this.coloredPlacesRequest;
-            restore("coloredPlaces", () => this.setPlacesAsSelected(placeIds, color));
-        }
-        if (this.borderedPlacesRequest) {
-            const { placeIds, color, width } = this.borderedPlacesRequest;
-            restore("borderedPlaces", () => this.addBorderToPlaces(placeIds, color, width));
-        }
-        // The swap removed the GLB custom layer, and MapLibre called its `onRemove`, which
-        // disposes the whole three.js scene. Nothing else re-adds it, so without this every
-        // 3D model disappears permanently and `hideLayers` stops being applied.
-        restore("scene3D", () => { var _a; return (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.reattachToStyle(); });
-    }
-    /**
-     * Removes the `styledata` listener left by an in-flight {@link setStyle} swap, if any.
-     * Called before starting a new swap and when one fails, so a listener holding an
-     * obsolete style can never fire against a different style's layers.
-     */
-    clearPendingStyleSwapListener() {
-        var _a;
-        if (!this.pendingStyleSwapListener)
-            return;
-        // `this.map?` — a listener can only have been installed while the map existed, but
-        // this also runs from `destroyMap` and from `setStyle` before the map is created.
-        (_a = this.map) === null || _a === void 0 ? void 0 : _a.off("styledata", this.pendingStyleSwapListener);
-        this.pendingStyleSwapListener = undefined;
-    }
-    /**
-     * Removes current parent place and updates style to default
-     */
-    removeParentPlace() {
-        this.changeParentPlaceTo(undefined, true);
-    }
-    /**
-     * Applies filters and changes to layers according to given style.
-     * Expected to be called every time a new style is loaded
-     * @param newStyle
-     */
-    whenStyleUpdates(newStyle) {
-        var _a;
-        if (newStyle) {
-            this.setBaseFilters(newStyle);
-        }
-        this.routeController.addSourcesAndLayers();
-        this.refreshCircles();
-        this.filterByFloorKey(this.currentFloor);
-        (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.refreshOverlay(this.currentFloor);
-    }
-    /**
-     * Internal accessor for every marker currently on the map, used by
-     * {@link MarkerLayoutController} to compute collision avoidance. Not part
-     * of the public `MapVXMap` interface.
-     *
-     * The user-location marker and the route controller's markers live outside
-     * `this.markers`, but they still occupy screen space — leaving them out
-     * would let labels be placed straight on top of them. They carry no label
-     * of their own, so they only ever act as obstacles.
-     * @internal
-     */
-    getMarkers() {
-        const unmanaged = this.routeController.getRouteMarkers();
-        if (this.userLocationMarker)
-            unmanaged.push(this.userLocationMarker);
-        return unmanaged.length > 0 ? [...this.markers, ...unmanaged] : this.markers;
-    }
-    addMarker(marker) {
-        var _a;
-        try {
-            // Check if a marker with the same ID already exists and remove it
-            if (marker.id) {
-                const existingMarkerIndex = this.markers.findIndex((m) => m.id === marker.id);
-                if (existingMarkerIndex !== -1) {
-                    const existingMarker = this.markers[existingMarkerIndex];
-                    existingMarker.remove();
-                    this.markers.splice(existingMarkerIndex, 1);
-                    this.logEvent("removeMarker", {
-                        markerId: marker.id,
-                        reason: "duplicate",
-                    });
-                }
-            }
-            const markerCreated = new marker_1.MarkerAttribute(Object.assign(Object.assign({}, marker), { maxLabelWidthPx: (_a = marker.maxLabelWidthPx) !== null && _a !== void 0 ? _a : this.markerLayoutConfig.maxLabelWidthPx }));
-            // While a floor change is still being rebuilt, the marker is shown by that
-            // change's settle step, together with the new floor.
-            if (!this.floorSettlePending) {
-                markerCreated.changeFloor(this.currentFloor, this.map, this.isOutdoorFloor(this.currentFloor));
-            }
-            this.markers.push(markerCreated);
-            this.markerLayoutController.scheduleRelayout();
-            this.logEvent("addMarker");
-            return markerCreated.id;
-        }
-        catch (error) {
-            throw new Error("Failed to add marker", { cause: error });
-        }
-    }
-    updateMarker(markerConfig) {
-        var _a;
-        try {
-            const marker = this.markers.find((e) => e.id === markerConfig.id);
-            if (marker !== undefined) {
-                marker.updateIcon(markerConfig);
-                this.markerLayoutController.invalidateMarker(marker);
-                this.markerLayoutController.scheduleRelayout();
-            }
-            this.logEvent("updateMarker");
-            return (_a = marker === null || marker === void 0 ? void 0 : marker.id) !== null && _a !== void 0 ? _a : "";
-        }
-        catch (error) {
-            throw new Error("Failed to update marker", { cause: error });
-        }
-    }
-    updateMarkerPosition(markerId, newPosition) {
-        try {
-            const marker = this.markers.find((e) => e.id === markerId);
-            if (marker !== undefined) {
-                marker.setLngLat(newPosition);
-                this.markerLayoutController.scheduleRelayout();
-            }
-            this.logEvent("updateMarkerPosition");
-        }
-        catch (error) {
-            throw new Error("Failed to update marker position", { cause: error });
-        }
-    }
-    showMarker(markerId) {
-        try {
-            const marker = this.markers.find((e) => e.id === markerId);
-            if (marker !== null && this.map) {
-                marker === null || marker === void 0 ? void 0 : marker.show(this.map);
-                this.markerLayoutController.scheduleRelayout();
-            }
-            this.logEvent("showMarker");
-        }
-        catch (error) {
-            this.debugLog("Show marker failed (marker may not exist)", error);
-        }
-    }
-    hideMarker(markerId) {
-        try {
-            const marker = this.markers.find((e) => e.id === markerId);
-            if (marker !== null) {
-                marker === null || marker === void 0 ? void 0 : marker.hide();
-                this.markerLayoutController.scheduleRelayout();
-            }
-            this.logEvent("hideMarker");
-        }
-        catch (error) {
-            this.debugLog("Hide marker failed (marker may not exist)", error);
-        }
-    }
-    removeMarker(markerId) {
-        try {
-            const marker = this.markers.find((e) => e.id === markerId);
-            if (marker !== null) {
-                marker === null || marker === void 0 ? void 0 : marker.remove();
-                this.markers = this.markers.filter((e) => e.id !== markerId);
-                this.markerLayoutController.scheduleRelayout();
-            }
-            this.logEvent("removeMarker");
-        }
-        catch (error) {
-            throw new Error("Failed to remove marker", { cause: error });
-        }
-    }
-    removeAllMarkers() {
-        try {
-            this.markers.forEach((marker) => {
-                marker.remove();
-            });
-            this.markers = [];
-            this.markerLayoutController.scheduleRelayout();
-            this.logEvent("removeAllMarkers");
-        }
-        catch (error) {
-            throw new Error("Failed to remove all markers", { cause: error });
-        }
-    }
-    addCircle(circle) {
-        try {
-            // Check if a circle with the same ID already exists and replace it
-            if (circle.id) {
-                this.circles = this.circles.filter((c) => c.id !== circle.id);
-            }
-            // resolveCircleConfig validates radiusMeters and coordinates
-            const record = (0, circle_1.resolveCircleConfig)(circle);
-            this.circles.push(record);
-            this.refreshCircles();
-            this.logEvent("addCircle");
-            return record.id;
-        }
-        catch (error) {
-            throw new Error(`Failed to add circle: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    updateCircle(circleConfig) {
-        try {
-            const index = this.circles.findIndex((c) => c.id === circleConfig.id);
-            if (index === -1)
-                return null;
-            // resolveCircleConfig validates radiusMeters and coordinates
-            this.circles[index] = (0, circle_1.resolveCircleConfig)(circleConfig, this.circles[index].hidden);
-            this.refreshCircles();
-            this.logEvent("updateCircle");
-            return this.circles[index].id;
-        }
-        catch (error) {
-            throw new Error(`Failed to update circle: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getCircle(circleId) {
-        const circle = this.circles.find((c) => c.id === circleId);
-        return circle ? (0, circle_1.cloneCircleRecord)(circle) : undefined;
-    }
-    getCircles() {
-        return this.circles.map(circle_1.cloneCircleRecord);
-    }
-    hasCircle(circleId) {
-        return this.circles.some((c) => c.id === circleId);
-    }
-    updateCirclePosition(circleId, center, radiusMeters) {
-        try {
-            const circle = this.circles.find((c) => c.id === circleId);
-            if (circle === undefined)
-                return false;
-            // Validate inputs before modifying
-            if (!center) {
-                throw new Error("Circle center is required");
-            }
-            const { lat, lng } = center;
-            if (!Number.isFinite(lat) || lat < -90 || lat > 90) {
-                throw new Error(`Invalid latitude: ${lat}. Must be between -90 and 90.`);
-            }
-            if (!Number.isFinite(lng) || lng < -180 || lng > 180) {
-                throw new Error(`Invalid longitude: ${lng}. Must be between -180 and 180.`);
-            }
-            if (radiusMeters !== undefined) {
-                if (!Number.isFinite(radiusMeters) || radiusMeters <= 0) {
-                    throw new Error(`Invalid radiusMeters: ${radiusMeters}. Must be a positive finite number.`);
-                }
-            }
-            circle.coordinate = { lat: center.lat, lng: center.lng };
-            if (radiusMeters !== undefined) {
-                circle.radiusMeters = radiusMeters;
-            }
-            this.refreshCircles();
-            this.logEvent("updateCirclePosition");
-            return true;
-        }
-        catch (error) {
-            throw new Error(`Failed to update circle position: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    updateCircleStyle(circleId, style) {
-        try {
-            const circle = this.circles.find((c) => c.id === circleId);
-            if (circle === undefined)
-                return false;
-            // Update only style properties, clamp opacities
-            if (style.fillColor !== undefined)
-                circle.fillColor = style.fillColor;
-            if (style.fillOpacity !== undefined)
-                circle.fillOpacity = Math.max(0, Math.min(1, style.fillOpacity));
-            if (style.strokeColor !== undefined)
-                circle.strokeColor = style.strokeColor;
-            if (style.strokeWidth !== undefined)
-                circle.strokeWidth = style.strokeWidth;
-            if (style.strokeOpacity !== undefined)
-                circle.strokeOpacity = Math.max(0, Math.min(1, style.strokeOpacity));
-            this.refreshCircles();
-            this.logEvent("updateCircleStyle");
-            return true;
-        }
-        catch (error) {
-            throw new Error(`Failed to update circle style: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    removeCircle(circleId) {
-        try {
-            this.circles = this.circles.filter((c) => c.id !== circleId);
-            this.refreshCircles();
-            this.logEvent("removeCircle");
-        }
-        catch (error) {
-            throw new Error("Failed to remove circle", { cause: error });
-        }
-    }
-    removeAllCircles() {
-        try {
-            this.circles = [];
-            this.refreshCircles();
-            this.logEvent("removeAllCircles");
-        }
-        catch (error) {
-            throw new Error("Failed to remove all circles", { cause: error });
-        }
-    }
-    showCircle(circleId) {
-        try {
-            const circle = this.circles.find((c) => c.id === circleId);
-            if (circle === undefined) {
-                return false;
-            }
-            circle.hidden = false;
-            this.refreshCircles();
-            this.logEvent("showCircle");
-            return true;
-        }
-        catch (error) {
-            this.debugLog("Show circle failed", error);
-            return false;
-        }
-    }
-    hideCircle(circleId) {
-        try {
-            const circle = this.circles.find((c) => c.id === circleId);
-            if (circle === undefined) {
-                return false;
-            }
-            circle.hidden = true;
-            this.refreshCircles();
-            this.logEvent("hideCircle");
-            return true;
-        }
-        catch (error) {
-            this.debugLog("Hide circle failed", error);
-            return false;
-        }
-    }
-    /**
-     * Builds the GeoJSON FeatureCollection for every currently visible circle.
-     * Visibility mirrors marker semantics: a circle with a floor is shown only
-     * while that floor is displayed, and a circle without a floor is shown only
-     * in outdoor contexts. Hidden circles are always omitted.
-     */
-    circleFeatureCollection() {
-        var _a;
-        const floorId = (_a = this.currentFloor) !== null && _a !== void 0 ? _a : "";
-        const isOutdoor = this.isOutdoorFloor(floorId);
-        const features = this.circles
-            .filter((circle) => {
-            var _a;
-            if (circle.hidden)
-                return false;
-            const circleFloor = (_a = circle.floorId) !== null && _a !== void 0 ? _a : "";
-            return circleFloor === floorId || (isOutdoor && circleFloor === "");
-        })
-            .map((circle) => ({
-            type: "Feature",
-            properties: {
-                id: circle.id,
-                fillColor: circle.fillColor,
-                fillOpacity: circle.fillOpacity,
-                strokeColor: circle.strokeColor,
-                strokeWidth: circle.strokeWidth,
-                strokeOpacity: circle.strokeOpacity,
-                renderOrder: circle.renderOrder,
-            },
-            geometry: {
-                type: "Polygon",
-                coordinates: [
-                    (0, circle_1.circleRing)(circle.coordinate.lng, circle.coordinate.lat, circle.radiusMeters),
-                ],
-            },
-        }));
-        return { type: "FeatureCollection", features };
-    }
-    /**
-     * Idempotently adds the shared circle source and its fill/line layers.
-     * Layers are inserted below the first symbol layer so place labels and
-     * markers stay readable above the translucent fill. Safe to call at any
-     * time: a style that is still loading simply rejects the calls, and the
-     * styledata listener retries once the style is ready.
-     */
-    /**
-     * Resolves the layer id to insert circle layers before, for one render
-     * order. `undefined` means "append on top".
-     *
-     * `aboveBasemap` finds the topmost non-symbol layer of the style and
-     * inserts before the first symbol layer that follows it. On indoor styles
-     * the floor-plate and building polygons are ordered after the first symbol
-     * layer, so anchoring on the topmost geometry layer — instead of the first
-     * symbol layer — guarantees circles are never occluded by basemap fills
-     * while still rendering below the labels that follow them.
-     */
-    circleBeforeIdFor(order) {
-        var _a, _b, _c, _d;
-        if (order === "top")
-            return undefined;
-        const layers = ((_b = (_a = this.map.getStyle()) === null || _a === void 0 ? void 0 : _a.layers) !== null && _b !== void 0 ? _b : []).filter((layer) => !isCircleLayerId(layer.id));
-        if (order === "belowLabels") {
-            return (_c = layers.find((layer) => layer.type === "symbol")) === null || _c === void 0 ? void 0 : _c.id;
-        }
-        // aboveBasemap
-        let lastNonSymbolIndex = -1;
-        layers.forEach((layer, index) => {
-            if (layer.type !== "symbol")
-                lastNonSymbolIndex = index;
-        });
-        return (_d = layers.slice(lastNonSymbolIndex + 1).find((layer) => layer.type === "symbol")) === null || _d === void 0 ? void 0 : _d.id;
-    }
-    /**
-     * Idempotently ensures the shared circle source and one fill/line layer
-     * pair per render order in use, at the placement that order requires.
-     * Placement is recomputed and re-asserted (via moveLayer) on every call,
-     * so circles regain their correct z-order after any style reload or
-     * floor/parent-place change. Safe to call at any time: a style that is
-     * still loading simply rejects the calls, and the styledata listener
-     * retries once the style is ready.
-     */
-    ensureCircleLayers() {
-        if (!this.map)
-            return;
-        try {
-            if (!this.map.getSource(CIRCLE_SOURCE_ID)) {
-                this.map.addSource(CIRCLE_SOURCE_ID, {
-                    type: "geojson",
-                    data: this.circleFeatureCollection(),
-                });
-            }
-            const ordersInUse = new Set(this.circles.map((c) => c.renderOrder));
-            // Always keep the default bucket alive so an empty map still renders
-            // newly added circles without a layer rebuild
-            ordersInUse.add("aboveBasemap");
-            // Process buckets lowest-first (CIRCLE_RENDER_ORDERS is canonical):
-            // when two buckets resolve to the same anchor, each addLayer/moveLayer
-            // lands immediately before it, so a bucket processed later paints above
-            // the ones processed earlier. Canonical order keeps
-            // belowLabels < aboveBasemap < top regardless of circle insertion order.
-            for (const order of circle_1.CIRCLE_RENDER_ORDERS) {
-                if (!ordersInUse.has(order))
-                    continue;
-                const ids = circleLayerIdsFor(order);
-                const beforeId = this.circleBeforeIdFor(order);
-                const orderFilter = ["==", ["get", "renderOrder"], order];
-                if (!this.map.getLayer(ids.fill)) {
-                    const fillLayer = {
-                        id: ids.fill,
-                        type: "fill",
-                        source: CIRCLE_SOURCE_ID,
-                        filter: orderFilter,
-                        paint: {
-                            "fill-color": ["get", "fillColor"],
-                            "fill-opacity": ["get", "fillOpacity"],
-                        },
-                    };
-                    this.map.addLayer(fillLayer, beforeId);
-                }
-                else {
-                    this.map.moveLayer(ids.fill, beforeId);
-                }
-                if (!this.map.getLayer(ids.line)) {
-                    const lineLayer = {
-                        id: ids.line,
-                        type: "line",
-                        source: CIRCLE_SOURCE_ID,
-                        filter: orderFilter,
-                        paint: {
-                            "line-color": ["get", "strokeColor"],
-                            "line-width": ["get", "strokeWidth"],
-                            "line-opacity": ["get", "strokeOpacity"],
-                        },
-                    };
-                    this.map.addLayer(lineLayer, beforeId);
-                }
-                else {
-                    this.map.moveLayer(ids.line, beforeId);
-                }
-            }
-        }
-        catch (error) {
-            this.debugLog("Layers not added: style not loaded yet, the styledata listener will re-add them", error);
-        }
-    }
-    /**
-     * Re-renders all circles: ensures the source and layers exist, then pushes
-     * the current FeatureCollection. Called after every mutation of the circle
-     * list, on floor changes, and when the map style reloads.
-     */
-    refreshCircles() {
-        if (!this.map)
-            return;
-        if (this.circles.length === 0 && !this.map.getSource(CIRCLE_SOURCE_ID))
-            return;
-        this.ensureCircleLayers();
-        try {
-            const source = this.map.getSource(CIRCLE_SOURCE_ID);
-            source === null || source === void 0 ? void 0 : source.setData(this.circleFeatureCollection());
-        }
-        catch (error) {
-            this.debugLog("Source not found (a new style may still be loading)", error);
-        }
-    }
-    /**
-     * Use it to change the current layer
-     * @param floorKey floor id
-     */
-    filterByFloorKey(floorKey) {
-        this.currentFloor = floorKey;
-        const floorKeyString = floorKey !== null && floorKey !== void 0 ? floorKey : "";
-        if (this.innerFloors.every((floor) => floor.key !== floorKey) && floorKey !== "") {
-            this.logEvent("invalidFloorKey", { floorKey: floorKeyString });
-        }
-        // One style read for the whole floor change. `getStyle()` serializes every
-        // source and layer of the venue style, and the second read is the expensive
-        // one: `updateFiltersTo` writes filters and layout properties in between,
-        // and each write nulls maplibre's `_serializedLayers` cache, so anything
-        // that reads the style afterwards rebuilds it from scratch.
-        const layers = this.safeStyleLayers();
-        this.updateFiltersTo(floorKeyString, layers);
-        this.updateMarkersWhenFloorSettles(floorKeyString, layers);
-        this.refreshCircles();
-        this.routeController.updateRouteLayers(floorKeyString);
-        this.routeController.updateRouteMarkerVisibility(floorKeyString);
-    }
-    /**
-     * Show/hide the HTML markers for `floorId` once the indoor tiles have been
-     * rebuilt with the new floor filters.
-     *
-     * A floor change is a `setFilter` on every indoor layer: MapLibre rebuilds the
-     * tile buckets in its worker, so the new floor appears a few frames later
-     * (hundreds of ms on a low-end panel) while a marker is a DOM element that
-     * would move instantly. Waiting for the source to report loaded makes floor
-     * polygons and markers switch in the same frame. The wait is bounded, is
-     * dropped when a newer floor change arrives, and is skipped outside a
-     * browser (no `requestAnimationFrame`).
-     */
-    updateMarkersWhenFloorSettles(floorId, styleLayers) {
-        const token = ++this.floorSettleToken;
-        // Resolved rather than probed with `hasStyle()`, which is another full
-        // `getStyle()` — and by this point the most expensive kind, because
-        // `updateFiltersTo` has just invalidated the serialized-layer cache.
-        const layers = styleLayers === undefined ? this.safeStyleLayers() : styleLayers;
-        if (typeof requestAnimationFrame !== "function" || layers === null) {
-            // No poll will run for this floor change, so nothing would ever clear the
-            // flag later: leaving it set makes every subsequent `addMarker` skip
-            // `changeFloor` and the marker is never attached to the map.
-            this.floorSettleDeadline = null;
-            this.updateMarkersTo(floorId);
-            return;
-        }
-        const sourceIds = this.floorSettleSourceIds(floorId, layers);
-        const deadline = this.now() + FLOOR_SETTLE_MAX_MS;
-        this.floorSettleDeadline = deadline;
-        let sawReloading = false;
-        let frames = 0;
-        const poll = () => {
-            if (token !== this.floorSettleToken)
-                return;
-            frames++;
-            const loaded = sourceIds.every((id) => this.isSourceSettled(id));
-            if (!loaded)
-                sawReloading = true;
-            // The reload is dispatched on the map's next render, which may run after
-            // this callback within the same frame: give it a couple of frames to be
-            // observed before concluding there was nothing to reload.
-            const settled = loaded && (sawReloading || frames >= FLOOR_SETTLE_MIN_FRAMES);
-            if (settled || this.now() >= deadline) {
-                this.floorSettleDeadline = null;
-                this.updateMarkersTo(floorId);
-                return;
-            }
-            requestAnimationFrame(poll);
-        };
-        requestAnimationFrame(poll);
-    }
-    /**
-     * Sources whose tiles a switch to `floorId` actually reloads, and which the
-     * marker settle therefore has to wait on.
-     *
-     * With a vector basemap that is the source the `indoor-*` layers draw from,
-     * because the floor change is a `setFilter` over those layers. An offline
-     * bundle's raster basemap switches floors by making `raster-floor-<key>`
-     * visible instead, and those tiles only begin loading at that moment — while
-     * its `indoor-*` layers carry labels and hover, are already loaded, and would
-     * report settled at once, letting the markers switch a floor before its image
-     * had painted. That is the configuration this wait exists for, so both are
-     * waited on.
-     */
-    floorSettleSourceIds(floorId, layers) {
-        const ids = new Set();
-        const rasterFloor = layers.find((layer) => layer.id === `raster-floor-${floorId}`);
-        if (rasterFloor && "source" in rasterFloor && typeof rasterFloor.source === "string") {
-            ids.add(rasterFloor.source);
-        }
-        ids.add(this.indoorSourceId(layers));
-        return [...ids];
-    }
-    /** The vector source the `indoor-*` layers draw from (`indoorequal` by default). */
-    indoorSourceId(layers) {
-        for (const layer of layers) {
-            if (layer.id.startsWith("indoor-") && "source" in layer && typeof layer.source === "string") {
-                return layer.source;
-            }
-        }
-        return "indoorequal";
-    }
-    isSourceSettled(sourceId) {
-        try {
-            if (!this.map.getSource(sourceId))
-                return true;
-            return this.map.isSourceLoaded(sourceId) !== false;
-        }
-        catch (_a) {
-            return true;
-        }
-    }
-    getContainer() {
-        return this.map.getContainer();
-    }
-    resize() {
-        try {
-            if (this.map) {
-                this.map.resize();
-                this.logEvent("resize");
-            }
-        }
-        catch (error) {
-            this.debugLog("Resize failed (map/container may not be ready)", error);
-        }
-    }
-    updateMarkersTo(floorId) {
-        const isOutdoor = this.isOutdoorFloor(floorId);
-        this.markers.forEach((e) => {
-            e.changeFloor(floorId, this.map, isOutdoor);
-        });
-        this.markerLayoutController.scheduleRelayout();
-    }
-    updateFiltersTo(floorId, styleLayers) {
-        var _a, _b, _c;
-        if (!this.map)
-            return;
-        // `null` means the caller looked and there was no style; only `undefined`
-        // means it did not look.
-        const layers = (_a = (styleLayers === undefined ? this.safeStyleLayers() : styleLayers)) !== null && _a !== void 0 ? _a : [];
-        // Raster basemap (offline bundles baked with one raster archive per floor):
-        // a floor is switched by showing its `raster-floor-<key>` layer and hiding
-        // the others. The remaining `indoor-*` layers (labels, hover, highlights)
-        // are still vector and keep going through the filter logic below.
-        const rasterFloorPrefix = "raster-floor-";
-        // Only switch the raster basemap when there is a baked layer to switch to.
-        // Hiding every raster floor leaves the basemap blank, and no id can match in
-        // two cases: no floor at all (an outdoor place, or a venue with no floors,
-        // where `currentFloor` is `""`), and a floor the bundle has no raster
-        // archive for — a venue where only some floors are baked, or a floor added
-        // after the bundle was built. Keeping the current one visible is the safe
-        // fallback for both.
-        const rasterFloorLayerIds = layers
-            .filter((l) => l.id.startsWith(rasterFloorPrefix))
-            .map((l) => l.id);
-        const targetRasterFloor = rasterFloorPrefix + floorId;
-        if (floorId && rasterFloorLayerIds.includes(targetRasterFloor)) {
-            rasterFloorLayerIds.forEach((id) => {
-                this.map.setLayoutProperty(id, "visibility", id === targetRasterFloor ? "visible" : "none");
-            });
-        }
-        layers
-            .filter((l) => l.id.startsWith("base-indoor-"))
-            .forEach((l) => {
-            this.map.removeLayer(l.id);
-        });
-        const baseFloorId = (_b = this.innerFloors.find((floor) => floor.key === floorId)) === null || _b === void 0 ? void 0 : _b.baseFloor;
-        const indoorLayers = layers.filter((layer) => layer.id.startsWith("indoor-"));
-        // Resolve each indoor layer's declared (base) filter before we start folding floor
-        // filters into it — and before cloning it into a `base-indoor-*` layer, which copies
-        // the base filter across. Layers added asynchronously after a `setStyle` swap are
-        // missing when `setBaseFilters` runs, so this is where their still-pristine filter
-        // is captured; without it the layer loses its own discrimination and repaints every
-        // feature (the washed-out / blue-outline look after changing floors). Layers already
-        // resolved are skipped, so a filter this class wrote is never mistaken for a
-        // declared one.
-        indoorLayers.forEach((layer) => this.captureDeclaredBaseFilter(layer.id));
-        if (baseFloorId != undefined) {
-            const firstLayerId = (_c = indoorLayers[0]) === null || _c === void 0 ? void 0 : _c.id;
-            indoorLayers
-                .filter((layer) => layer.type !== "fill-extrusion")
-                .forEach((layer) => {
-                const baseLayer = deepClone(layer);
-                baseLayer.id = "base-" + layer.id;
-                this.baseFilters[baseLayer.id] = this.baseFilters[layer.id];
-                this.map.addLayer(baseLayer, firstLayerId);
-                this.applyLayerFilters(baseLayer, baseFloorId);
-            });
-        }
-        indoorLayers.forEach((layer) => {
-            this.applyLayerFilters(layer, floorId);
-        });
-    }
-    /**
-     * Reads a layer's current filter, tolerating the layer having been removed or the
-     * style being mid-swap (maplibre `getFilter` throws in those cases). Returns
-     * `undefined` instead of throwing so base-filter capture never aborts floor filtering.
-     */
-    safeGetFilter(layerId) {
-        try {
-            return this.map.getFilter(layerId);
-        }
-        catch (_a) {
-            return undefined;
-        }
-    }
-    applyLayerFilters(layer, floorId) {
-        var _a;
-        // Resolve the layer's declared (base) filter the first time we touch it. Indoor
-        // layers such as `indoor-polygon-room` share one source and are told apart only by
-        // their own filter (e.g. `["in","room",["get","tags"]]`); we must fold that into the
-        // floor filter or the layer repaints every feature. Some of these layers are added
-        // asynchronously after a `setStyle` swap, so they are absent when `setBaseFilters`
-        // runs — capturing here, while their live filter is still pristine, is what keeps a
-        // floor change from wiping the style (the washed-out, blue-outline look).
-        // `base-indoor-*` clones inherit their base filter from the layer they were cloned
-        // from, so they are never read back.
-        if (!layer.id.startsWith("base-indoor-")) {
-            this.captureDeclaredBaseFilter(layer.id);
-        }
-        let baseFilter = this.baseFilters[layer.id];
-        const floorIdString = floorId !== null && floorId !== void 0 ? floorId : "";
-        const floorFilter = [
-            "any",
-            ["in", floorIdString, ["get", "floor_key"]],
-        ];
-        const publicPlaceFilter = ["==", ["get", "public_place"], true];
-        const subPlaceFilter = [
-            "!",
-            ["in", (_a = this.parentPlaceId) !== null && _a !== void 0 ? _a : "noRef", ["get", "is_subplace"]],
-        ];
-        const showInFloorFilter = [
-            "in",
-            floorIdString,
-            ["get", "show_in_floor"],
-        ];
-        let basicFilters = publicPlaceFilter;
-        if (this.parentPlaceId != null) {
-            basicFilters = ["any", floorFilter, publicPlaceFilter];
-        }
-        const customFilters = [
-            "all",
-            basicFilters,
-            ["any", subPlaceFilter, showInFloorFilter],
-        ];
-        if (layer.id.includes("hover")) {
-            baseFilter = ["in", this.hoveredId, ["get", "ref"]];
-        }
-        else if (!layer.id.includes("colored") &&
-            (layer.type == "fill" || layer.type === "fill-extrusion")) {
-            customFilters.push(["!", ["in", this.hoveredId, ["get", "ref"]]]);
-        }
-        // From here on this layer's live filter is ours, never the style's declared one.
-        // Marking it keeps any later pass from reading it back as a base filter — that is
-        // what used to AND the previous floor into the next one and blank the layer out.
-        this.capturedBaseFilters.add(layer.id);
-        if (baseFilter != null) {
-            const finalFilter = ["all", baseFilter, customFilters];
-            this.map.setFilter(layer.id, finalFilter);
-        }
-        else {
-            this.map.setFilter(layer.id, customFilters);
-        }
-    }
-    /**
-     * Floors of the parent place
-     * @returns Inner floors of the parent place
-     */
-    getInnerFloors() {
-        return this.innerFloors;
-    }
-    /**
-     * Whether `floorId` shows the venue's outdoors, and so whether entities that
-     * carry no floor of their own belong on screen with it.
-     *
-     * A map without a parent place is outdoors throughout; inside one, only a
-     * floor reachable from GPS is. Markers, circles and the route marker all hang
-     * their visibility on this, so they answer it the same way.
-     */
-    isOutdoorFloor(floorId) {
-        var _a, _b;
-        return (!this.parentPlace ||
-            ((_b = (_a = this.innerFloors.find((floor) => floor.key === floorId)) === null || _a === void 0 ? void 0 : _a.reachableFromGPS) !== null && _b !== void 0 ? _b : false));
-    }
-    updateCamera(newCamera, callback) {
-        void this.map.once("moveend", callback);
-        this.map.easeTo(Object.assign({}, newCamera));
-    }
-    setMaxZoom(zoomLvl, options) {
-        var _a;
-        this.map.setMaxZoom(zoomLvl);
-        (_a = options === null || options === void 0 ? void 0 : options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);
-    }
-    setMinZoom(zoomLvl, options) {
-        var _a;
-        this.map.setMinZoom(zoomLvl);
-        (_a = options === null || options === void 0 ? void 0 : options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);
-    }
-    setBearing(degrees, options) {
-        var _a;
-        if (!Number.isFinite(degrees))
-            return;
-        if (options === null || options === void 0 ? void 0 : options.animate) {
-            if (options.onComplete)
-                void this.map.once("moveend", options.onComplete);
-            this.map.rotateTo(degrees, { duration: 600 });
-            return;
-        }
-        this.map.setBearing(degrees);
-        (_a = options === null || options === void 0 ? void 0 : options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);
-    }
-    setRotationEnabled(enabled) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        if (enabled) {
-            (_b = (_a = this.map.dragRotate) === null || _a === void 0 ? void 0 : _a.enable) === null || _b === void 0 ? void 0 : _b.call(_a);
-            (_d = (_c = this.map.touchZoomRotate) === null || _c === void 0 ? void 0 : _c.enableRotation) === null || _d === void 0 ? void 0 : _d.call(_c);
-            (_f = (_e = this.map.keyboard) === null || _e === void 0 ? void 0 : _e.enable) === null || _f === void 0 ? void 0 : _f.call(_e);
-        }
-        else {
-            (_h = (_g = this.map.dragRotate) === null || _g === void 0 ? void 0 : _g.disable) === null || _h === void 0 ? void 0 : _h.call(_g);
-            (_k = (_j = this.map.touchZoomRotate) === null || _j === void 0 ? void 0 : _j.disableRotation) === null || _k === void 0 ? void 0 : _k.call(_j);
-        }
-    }
-    setPanEnabled(enabled) {
-        var _a, _b, _c, _d;
-        if (enabled) {
-            (_b = (_a = this.map.dragPan) === null || _a === void 0 ? void 0 : _a.enable) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
-        else {
-            (_d = (_c = this.map.dragPan) === null || _c === void 0 ? void 0 : _c.disable) === null || _d === void 0 ? void 0 : _d.call(_c);
-        }
-    }
-    setScrollZoomEnabled(enabled) {
-        var _a, _b, _c, _d;
-        if (enabled) {
-            (_b = (_a = this.map.scrollZoom) === null || _a === void 0 ? void 0 : _a.enable) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
-        else {
-            (_d = (_c = this.map.scrollZoom) === null || _c === void 0 ? void 0 : _c.disable) === null || _d === void 0 ? void 0 : _d.call(_c);
-        }
-    }
-    isInsideBounds(point) {
-        const mapBounds = this.map.getMaxBounds();
-        if (mapBounds != null) {
-            return mapBounds.contains(point);
-        }
-        return true;
-    }
-    setMaxBounds(coordinates, options) {
-        var _a;
-        if (coordinates.length > 1) {
-            const boundingBox = (0, utils_1.getBoundingBox)(coordinates);
-            this.map.setMaxBounds(new maplibre_gl_1.LngLatBounds([boundingBox[0].lng, boundingBox[0].lat], [boundingBox[1].lng, boundingBox[1].lat]));
-        }
-        (_a = options === null || options === void 0 ? void 0 : options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);
-    }
-    fitCoordinates(coordinates, options) {
-        var _a, _b;
-        if (coordinates.length === 0) {
-            return;
-        }
-        const onComplete = options === null || options === void 0 ? void 0 : options.onComplete;
-        if (coordinates.length === 1) {
-            const [coord] = coordinates;
-            if (onComplete) {
-                void this.map.once("moveend", onComplete);
-            }
-            this.map.setCenter({
-                lat: coord.lat,
-                lng: coord.lng,
-            });
-        }
-        else {
-            let minLat;
-            let minLng;
-            let maxLat;
-            let maxLng;
-            for (const coord of coordinates) {
-                const { lat, lng } = coord;
-                minLat = minLat === undefined ? lat : Math.min(minLat, lat);
-                minLng = minLng === undefined ? lng : Math.min(minLng, lng);
-                maxLat = maxLat === undefined ? lat : Math.max(maxLat, lat);
-                maxLng = maxLng === undefined ? lng : Math.max(maxLng, lng);
-            }
-            const bounds = [
-                minLng !== null && minLng !== void 0 ? minLng : 0,
-                minLat !== null && minLat !== void 0 ? minLat : 0,
-                maxLng !== null && maxLng !== void 0 ? maxLng : 0,
-                maxLat !== null && maxLat !== void 0 ? maxLat : 0,
-            ];
-            // Get container dimensions for percentage-based padding calculations
-            const container = this.map.getContainer();
-            const containerWidth = container.clientWidth;
-            const containerHeight = container.clientHeight;
-            // Convert padding values with units to pixels
-            const padding = convertPaddingToPixels(options === null || options === void 0 ? void 0 : options.padding, containerWidth, containerHeight);
-            const fitOptions = Object.assign(Object.assign({}, options), { padding });
-            const bearing = this.map.getBearing();
-            const pitch = this.map.getPitch();
-            (_a = fitOptions.bearing) !== null && _a !== void 0 ? _a : (fitOptions.bearing = bearing);
-            (_b = fitOptions.pitch) !== null && _b !== void 0 ? _b : (fitOptions.pitch = pitch);
-            if (onComplete) {
-                void this.map.once("moveend", onComplete);
-            }
-            this.map.fitBounds(bounds, fitOptions);
-        }
-    }
-    easeToCoordinates(coordinates, options) {
-        var _a, _b, _c;
-        if (coordinates.length === 0) {
-            return;
-        }
-        const onComplete = options === null || options === void 0 ? void 0 : options.onComplete;
-        // Get container dimensions for percentage-based padding calculations
-        const container = this.map.getContainer();
-        const containerWidth = container.clientWidth;
-        const containerHeight = container.clientHeight;
-        // Convert padding values with units to pixels
-        const padding = convertPaddingToPixels(options === null || options === void 0 ? void 0 : options.padding, containerWidth, containerHeight);
-        if (coordinates.length === 1) {
-            const [coord] = coordinates;
-            if (onComplete) {
-                void this.map.once("moveend", onComplete);
-            }
-            this.map.easeTo(Object.assign(Object.assign({}, options), { center: { lat: coord.lat, lng: coord.lng }, padding }));
-            return;
-        }
-        const bearing = (_a = options === null || options === void 0 ? void 0 : options.bearing) !== null && _a !== void 0 ? _a : this.map.getBearing();
-        const pitch = (_b = options === null || options === void 0 ? void 0 : options.pitch) !== null && _b !== void 0 ? _b : this.map.getPitch();
-        const cameraParams = {
-            bearing,
-            padding,
-            containerWidth,
-            containerHeight,
-            maxZoom: (_c = options === null || options === void 0 ? void 0 : options.maxZoom) !== null && _c !== void 0 ? _c : this.map.getMaxZoom(),
-            minZoom: this.map.getMinZoom(),
-        };
-        // Orthographic oriented fit (exact for pitch 0). maplibre's fitBounds only
-        // fits a north-up LngLatBounds, which wastes viewport space for diagonal
-        // geometries under a bearing.
-        let camera = (0, fitCamera_1.computeOrientedCamera)(coordinates, cameraParams);
-        // With a tilted camera the orthographic zoom is off due to perspective, so
-        // refine it against maplibre's real projection on a cloned transform.
-        if (pitch > 0) {
-            // Simulated on the live map through its public API rather than on `map.transform.clone()`:
-            // MapLibre v6 removes the internal transform and exposes no replacement. The whole loop is
-            // synchronous and ends in `restore()`, so no intermediate frame is ever painted.
-            // See DEVELOPER_DOCS/MAPLIBRE_V6_MIGRATION.md.
-            const fitTransform = new liveMapFitTransform_1.LiveMapFitTransform(this.map);
-            try {
-                camera = (0, fitCamera_1.refineCameraForPitch)(fitTransform, coordinates, camera, Object.assign(Object.assign({}, cameraParams), { pitch }));
-            }
-            finally {
-                fitTransform.restore();
-            }
-        }
-        if (onComplete) {
-            void this.map.once("moveend", onComplete);
-        }
-        this.map.easeTo(Object.assign(Object.assign({}, options), { center: camera.center, zoom: camera.zoom, bearing,
-            pitch,
-            padding }));
-    }
-    fitRouteByPlace(route, placeId, options) {
-        // Filter steps that belong to the specified place
-        const stepsInPlace = route.steps.filter((step) => step.startInsidePlace === placeId || step.endInsidePlace === placeId);
-        if (stepsInPlace.length === 0) {
-            return;
-        }
-        // Extract all coordinates from the filtered steps
-        const coords = stepsInPlace.flatMap((step) => (0, route_utils_1.extractStepCoordinates)(step));
-        if (coords.length > 0) {
-            this.fitCoordinates(coords, options);
-        }
-    }
-    getZoomLevel() {
-        return this.map.getZoom();
-    }
-    updateFloor(floorId, options) {
-        var _a, _b, _c;
-        try {
-            this.filterByFloorKey(floorId);
-            (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.onFloorChange(this.currentFloor);
-            (_b = this.onFloorChange) === null || _b === void 0 ? void 0 : _b.call(this, floorId);
-            this.logEvent("updateFloor", { floorId });
-            (_c = options === null || options === void 0 ? void 0 : options.onComplete) === null || _c === void 0 ? void 0 : _c.call(options);
-        }
-        catch (error) {
-            this.debugLog("Floor update failed", error);
-        }
-    }
-    updatePlaceAndFloorForRouting(placeId, floorId) {
-        var _a;
-        try {
-            this.updatePlaceAndFloor(placeId, floorId);
-            const layers = this.safeStyleLayers();
-            this.updateFiltersTo(floorId, layers);
-            this.updateMarkersWhenFloorSettles(floorId, layers);
-            (_a = this.onFloorChange) === null || _a === void 0 ? void 0 : _a.call(this, floorId);
-            this.logEvent("updatePlaceAndFloorForRouting", { floorId });
-        }
-        catch (error) {
-            this.debugLog("Place/floor update for routing failed", error);
-        }
-    }
-    async addRoute(config, drawConfig = {}) {
-        try {
-            this.logEvent("addRoute");
-            const fetchRouteConfig = new routeConfiguration_1.InternalGetRouteConfiguration(config);
-            const drawRouteConfig = new routeConfiguration_1.InternalDrawRouteConfiguration(drawConfig);
-            const route = await this.repository.fetchAndParseRoute(fetchRouteConfig);
-            this.routeController.addRoute(route, drawRouteConfig);
-            return route;
-        }
-        catch (error) {
-            throw new Error("Error: Failed to add route", { cause: error });
-        }
-    }
-    async addLiveRoute(config, drawConfig = {}) {
-        try {
-            this.logEvent("addLiveRoute");
-            const fetchRouteConfig = new routeConfiguration_1.InternalGetRouteConfiguration(config);
-            const drawRouteConfig = new routeConfiguration_1.InternalDrawRouteConfiguration(drawConfig);
-            // Take a ticket BEFORE awaiting: refreshes overlap, and an older response
-            // resolving after a newer one must not clobber it (stale route drawn,
-            // liveRouteId pointing at the wrong instance).
-            const ticket = ++this.liveRouteTicket;
-            const route = await this.repository.fetchAndParseLiveRoute(fetchRouteConfig);
-            if (ticket !== this.liveRouteTicket) {
-                // Superseded while in flight — the map shows (or will show) the newer
-                // route. Return the fetched data without drawing it.
-                return route;
-            }
-            // Replace the previous live route so repeated refreshes don't stack paths
-            // on the map. Removal happens AFTER the fetch, so a failed refresh leaves
-            // the current route on screen. Targeted by id, so routes drawn with
-            // addRoute are untouched.
-            if (this.liveRouteId !== undefined && this.liveRouteId !== route.id) {
-                this.routeController.removeRoute(this.liveRouteId);
-            }
-            // Clear any instance already using this id (a same-id refresh, or the same
-            // route previously drawn via addRoute) — the controller derives its
-            // source/layer ids from the route id, so re-adding without removing would
-            // throw "Source already exists".
-            if (this.routeController.getRouteIds().includes(route.id)) {
-                this.routeController.removeRoute(route.id);
-            }
-            this.routeController.addRoute(route, drawRouteConfig);
-            this.liveRouteId = route.id;
-            return route;
-        }
-        catch (error) {
-            const reason = error instanceof Error ? error.message : String(error);
-            throw new Error(`Error: Failed to add route: ${reason}`, { cause: error });
-        }
-    }
-    updateRouteProgress(routeId, position, behindStyle = { type: "Solid", color: "#276EF1" }) {
-        try {
-            const behindConfig = new routeConfiguration_1.InternalDrawRouteConfiguration({
-                routeStyle: behindStyle,
-            });
-            this.routeController.updateRouteProgress(routeId, position, behindConfig);
-        }
-        catch (error) {
-            this.debugLog("Route update failed (route may not exist)", error);
-        }
-    }
-    removeRoute(routeId) {
-        try {
-            this.logEvent("removeRoute");
-            this.routeController.removeRoute(routeId);
-        }
-        catch (error) {
-            this.debugLog("Remove route failed (no route may exist)", error);
-        }
-        this.syncLiveRouteId();
-    }
-    removeRouteById(routeId) {
-        try {
-            this.logEvent("removeRouteById");
-            this.routeController.removeRoute(routeId);
-        }
-        catch (error) {
-            this.debugLog("Remove route failed (route may not exist)", error);
-        }
-        this.syncLiveRouteId();
-    }
-    removeAllRoutes() {
-        try {
-            this.logEvent("removeAllRoutes");
-            this.routeController.removeAllRoutes();
-        }
-        catch (error) {
-            this.debugLog("Remove all routes failed", error);
-        }
-        this.syncLiveRouteId();
-    }
-    /**
-     * Drop {@link liveRouteId} when the instance it points at is no longer on the
-     * map (removed via removeRoute/removeRouteById/removeAllRoutes — including the
-     * no-arg removeRoute, which removes the last-added route). Keeps the live
-     * bookkeeping in sync so a later {@link addLiveRoute} doesn't act on a
-     * dangling id.
-     */
-    syncLiveRouteId() {
-        if (this.liveRouteId !== undefined &&
-            !this.routeController.getRouteIds().includes(this.liveRouteId)) {
-            this.liveRouteId = undefined;
-        }
-    }
-    getActiveRouteIds() {
-        return this.routeController.getRouteIds();
-    }
-    addPopOver(popOverConfig) {
-        const placeId = popOverConfig.placeId;
-        if (placeId !== undefined) {
-            const pointedPlace = this.subPlaces.find((subplace) => {
-                return subplace.clientId === placeId || subplace.mapvxId === placeId;
-            });
-            if (pointedPlace !== undefined) {
-                new maplibre_gl_1.default.Popup()
-                    .setLngLat(pointedPlace.position)
-                    .setText(pointedPlace.title)
-                    .addTo(this.map);
-            }
-        }
-        return "";
-    }
-    removePopOver(id) {
-        throw Error("Not implemented");
-    }
-    startClickListener(callback) {
-        this.clickCallback = callback;
-    }
-    stopClickListener() {
-        this.clickCallback = undefined;
-    }
-    defaultClickListener() {
-        this.map.on("click", async (e) => {
-            var _a, _b;
-            const features = this.map.queryRenderedFeatures(e.point);
-            // Filter room features by current floor
-            const roomFeatures = features.filter((feature) => { var _a; return feature.properties.class === "room" && ((_a = feature.properties) === null || _a === void 0 ? void 0 : _a.floor_key) === this.currentFloor; });
-            const touchedFeature = roomFeatures[0];
-            const ref = touchedFeature === null || touchedFeature === void 0 ? void 0 : touchedFeature.properties.ref;
-            if (ref != null && typeof ref === "string" && ref.length > 0) {
-                console.log("touchedFeature", ref);
-                // First, search in current subPlaces
-                let clickedPlace = this.subPlaces.find((subPlace) => subPlace.mapvxId === ref);
-                // If not found, search in subplaces of potential parent places
-                if (clickedPlace === undefined) {
-                    for (const potentialParentPlace of this.potentialParentPlaces) {
-                        const cachedSubPlaces = this.repository.getCachedSubPlaces(potentialParentPlace.mapvxId);
-                        if (cachedSubPlaces) {
-                            clickedPlace = cachedSubPlaces.find((subPlace) => subPlace.mapvxId === ref);
-                            if (clickedPlace !== undefined) {
-                                break;
-                            }
-                        }
-                    }
-                }
-                // As last resort, search in general cache
-                if (clickedPlace === undefined) {
-                    const cachedPlaces = this.repository.getCachedPlaces([ref]);
-                    if (cachedPlaces.length === 0) {
-                        console.log("fetching place detail from server", ref);
-                        clickedPlace = await this.repository.fetchAndParsePlaceDetail({ id: ref });
-                    }
-                    else {
-                        console.log("using cached place detail", ref);
-                        clickedPlace = cachedPlaces === null || cachedPlaces === void 0 ? void 0 : cachedPlaces[0];
-                    }
-                }
-                console.log("clickedPlace", clickedPlace === null || clickedPlace === void 0 ? void 0 : clickedPlace.title);
-                const clickedPlaceId = (_b = (_a = clickedPlace === null || clickedPlace === void 0 ? void 0 : clickedPlace.mapvxId) !== null && _a !== void 0 ? _a : clickedPlace === null || clickedPlace === void 0 ? void 0 : clickedPlace.clientId) !== null && _b !== void 0 ? _b : "";
-                if (clickedPlace !== undefined && this.clickCallback) {
-                    this.clickCallback(clickedPlaceId);
-                }
-            }
-        });
-    }
-    onHover() {
-        if (!this.enableHover)
-            return;
-        this.map.on("mousemove", "hoverable", (e) => {
-            var _a;
-            const feature = (_a = e.features) === null || _a === void 0 ? void 0 : _a.find((feature) => { var _a, _b; return ((_a = feature.properties.ref) === null || _a === void 0 ? void 0 : _a.length) > 0 && ((_b = feature.properties) === null || _b === void 0 ? void 0 : _b.floor_key) === this.currentFloor; });
-            const ref = feature === null || feature === void 0 ? void 0 : feature.properties.ref;
-            if (ref != null && typeof ref === "string" && ref.length > 0) {
-                this.hoveredId = ref;
-                this.updateFiltersTo(this.currentFloor);
-            }
-            else if (ref === undefined && this.hoveredId !== "unselected") {
-                this.hoveredId = "unselected";
-                this.updateFiltersTo(this.currentFloor);
-            }
-        });
-        // When the mouse leaves the state-fill layer, update the feature state of the
-        // previously hovered feature.
-        this.map.on("mouseleave", "hoverable", () => {
-            this.hoveredId = "unselected";
-            this.updateFiltersTo(this.currentFloor);
-        });
-    }
-    setPlacesAsSelected(placeIds, color) {
-        try {
-            this.coloredPlacesRequest = { placeIds: [...placeIds], color };
-            if (!this.hasLayer("indoor-colored-places")) {
-                this.createColoredPlacesLayer();
-            }
-            const basicFilter = this.createBasicFilters();
-            const coloredPlacesFilters = placeIds.map((id) => {
-                const filter = ["==", ["get", "ref"], id];
-                return filter;
-            });
-            const placeFilter = ["any", ...coloredPlacesFilters];
-            const condition = ["all", placeFilter, basicFilter];
-            this.map.setFilter("indoor-colored-places", condition);
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
-            this.capturedBaseFilters.add("indoor-colored-places");
-            this.baseFilters["indoor-colored-places"] = placeFilter;
-            if (color !== undefined) {
-                const layer = this.map.getLayer("indoor-colored-places");
-                switch (layer === null || layer === void 0 ? void 0 : layer.type) {
-                    case "fill":
-                        this.map.setPaintProperty("indoor-colored-places", "fill-color", color);
-                        break;
-                    case "fill-extrusion":
-                        this.map.setPaintProperty("indoor-colored-places", "fill-extrusion-color", color);
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-        catch (error) {
-            this.debugLog("Place selection failed (layer may not exist)", error);
-        }
-    }
-    is3DStyle() {
-        const layers = this.map.getStyle().layers;
-        return layers.some((layer) => layer.type === "fill-extrusion");
-    }
-    createColoredPlacesLayer() {
-        if (this.is3DStyle()) {
-            const layer = {
-                id: "indoor-colored-places",
-                type: "fill-extrusion",
-                source: "indoorequal",
-                "source-layer": "area",
-                filter: ["all", ["has", "ref"], ["==", ["get", "ref"], "unselected"]],
-                paint: {
-                    "fill-extrusion-height": 2.5,
-                    "fill-extrusion-color": circle_1.MAPVX_BRAND_COLOR,
-                    "fill-extrusion-opacity": 0.8,
-                },
-            };
-            this.map.addLayer(layer);
-        }
-        else {
-            const layer = {
-                id: "indoor-colored-places",
-                type: "fill",
-                source: "indoorequal",
-                "source-layer": "area",
-                filter: ["all", ["has", "ref"], ["==", ["get", "ref"], "unselected"]],
-                paint: {
-                    "fill-color": circle_1.MAPVX_BRAND_COLOR,
-                },
-            };
-            this.map.addLayer(layer);
-        }
-    }
-    createBasicFilters() {
-        var _a, _b;
-        const publicPlaceFilter = ["==", ["get", "public_place"], true];
-        const subPlaceFilter = [
-            "!",
-            ["in", (_a = this.parentPlaceId) !== null && _a !== void 0 ? _a : "noRef", ["get", "is_subplace"]],
-        ];
-        const floorId = (_b = this.currentFloor) !== null && _b !== void 0 ? _b : "noRef";
-        const floorFilter = ["in", floorId, ["get", "floor_key"]];
-        const showInFloorFilter = [
-            "in",
-            floorId,
-            ["get", "show_in_floor"],
-        ];
-        let basicFilters = publicPlaceFilter;
-        if (this.parentPlaceId != null) {
-            basicFilters = ["any", floorFilter, publicPlaceFilter];
-        }
-        const customFilters = [
-            "all",
-            basicFilters,
-            ["any", subPlaceFilter, showInFloorFilter],
-        ];
-        return customFilters;
-    }
-    hasLayer(layerId) {
-        const layer = this.map.getLayer(layerId);
-        return layer !== undefined;
-    }
-    clearColoredPlaces() {
-        this.coloredPlacesRequest = undefined;
-        if (this.hasLayer("indoor-colored-places")) {
-            const condition = ["==", ["get", "ref"], "unselected"];
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
-            this.capturedBaseFilters.add("indoor-colored-places");
-            this.baseFilters["indoor-colored-places"] = condition;
-            this.map.setFilter("indoor-colored-places", condition);
-        }
-    }
-    async startAnimateRoute(routeConfig, drawConfig = {}, animationConfig = {}) {
-        try {
-            let route;
-            if (routeConfig instanceof route_1.MVXRoute) {
-                route = routeConfig;
-            }
-            else {
-                const fetchRouteConfig = new routeConfiguration_1.InternalGetRouteConfiguration(routeConfig);
-                route = await this.repository.fetchAndParseRoute(fetchRouteConfig);
-            }
-            const drawRouteConfig = new animation_1.InternalAnimationDrawingConfig(drawConfig);
-            const animationRouteConfig = new animation_1.InternalAnimationConfig(animationConfig);
-            this.routeController.startAnimating(route, drawRouteConfig, animationRouteConfig);
-            return route;
-        }
-        catch (error) {
-            throw new Error("Error: Failed to start animating route", { cause: error });
-        }
-    }
-    async startAnimateRouteV2(routeConfig, drawConfig = {}, animationConfig = {}) {
-        try {
-            let route;
-            if (routeConfig instanceof route_1.MVXRoute) {
-                route = routeConfig;
-            }
-            else {
-                const fetchRouteConfig = new routeConfiguration_1.InternalGetRouteConfiguration(routeConfig);
-                route = await this.repository.fetchAndParseRouteV2(fetchRouteConfig);
-            }
-            const drawRouteConfig = new animation_1.InternalAnimationDrawingConfig(drawConfig);
-            const animationRouteConfig = new animation_1.InternalAnimationConfig(animationConfig);
-            this.routeController.startAnimating(route, drawRouteConfig, animationRouteConfig);
-            return route;
-        }
-        catch (error) {
-            throw new Error("Error: Failed to start animating route", { cause: error });
-        }
-    }
-    pauseAnimateRoute(routeId) {
-        try {
-            this.routeController.pauseAnimation(routeId);
-            this.logEvent("pauseAnimateRoute");
-        }
-        catch (error) {
-            this.debugLog("Pause animation failed (no animation may be running)", error);
-        }
-    }
-    resumeAnimateRoute(routeId) {
-        try {
-            this.routeController.resumeAnimation(routeId);
-            this.logEvent("resumeAnimateRoute");
-        }
-        catch (error) {
-            this.debugLog("Resume animation failed (no animation may be paused)", error);
-        }
-    }
-    restartAnimateRoute(routeId) {
-        try {
-            this.routeController.restartAnimation(routeId);
-            this.logEvent("restartAnimateRoute");
-        }
-        catch (error) {
-            this.debugLog("Restart animation failed (no animation may exist)", error);
-        }
-    }
-    stopAnimateRoute() {
-        this.logWarning(new Error("Not implemented"), {
-            functionName: "stopAnimateRoute",
-        });
-    }
-    async addStepAnimation(routeConfig, drawConfig = {}, animationConfig = {}) {
-        try {
-            let route;
-            if (routeConfig instanceof route_1.MVXRoute) {
-                route = routeConfig;
-            }
-            else {
-                const fetchRouteConfig = new routeConfiguration_1.InternalGetRouteConfiguration(routeConfig);
-                route = await this.repository.fetchAndParseRoute(fetchRouteConfig);
-            }
-            const drawRouteConfig = new animation_1.InternalAnimationDrawingConfig(drawConfig);
-            const animationRouteConfig = new animation_1.InternalAnimationConfig(animationConfig);
-            this.routeController.addStepAnimation(route, drawRouteConfig, animationRouteConfig);
-            this.logEvent("addStepAnimation");
-            return route;
-        }
-        catch (error) {
-            throw new Error("Error: Failed to add step animation", { cause: error });
-        }
-    }
-    async addStepAnimationV2(routeConfig, drawConfig = {}, animationConfig = {}) {
-        try {
-            let route;
-            if (routeConfig instanceof route_1.MVXRoute) {
-                route = routeConfig;
-            }
-            else {
-                const fetchRouteConfig = new routeConfiguration_1.InternalGetRouteConfiguration(routeConfig);
-                route = await this.repository.fetchAndParseRouteV2(fetchRouteConfig);
-            }
-            const drawRouteConfig = new animation_1.InternalAnimationDrawingConfig(drawConfig);
-            const animationRouteConfig = new animation_1.InternalAnimationConfig(animationConfig);
-            this.routeController.addStepAnimation(route, drawRouteConfig, animationRouteConfig);
-            this.logEvent("addStepAnimationV2");
-            return route;
-        }
-        catch (error) {
-            throw new Error("Error: Failed to add step animation", { cause: error });
-        }
-    }
-    nextStepAnimation(routeId) {
-        try {
-            this.routeController.nextStepAnimation(routeId);
-            this.logEvent("nextStepAnimation");
-        }
-        catch (error) {
-            throw new Error("Error: Failed to animate step", { cause: error });
-        }
-    }
-    previousStepAnimation(routeId) {
-        try {
-            this.routeController.previousStepAnimation(routeId);
-            this.logEvent("previousStepAnimation");
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error("Error: Failed to prepare to animate previous step, " + errorMessage);
-        }
-    }
-    centerOnCurrentStepAnimation(routeId) {
-        try {
-            this.routeController.centerOnCurrentStep(routeId);
-            this.logEvent("centerOnCurrentStepAnimation");
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error("Error: Failed to center on current step animation, " + errorMessage);
-        }
-    }
-    addUserLocationTracking(enableHighAccuracy, geoLocation, icon) {
-        const initialCoordinate = {
-            lat: 0.0,
-            lng: 0.0,
-        };
-        let markerIcon;
-        if (icon != null) {
-            markerIcon = icon;
-        }
-        else {
-            const image = new Image(40, 40);
-            image.src = icons_1.userLocationDataUrl;
-            markerIcon = image;
-        }
-        const markerConfig = {
-            coordinate: initialCoordinate,
-            icon: markerIcon,
-            text: "",
-        };
-        const marker = new marker_1.MarkerAttribute(markerConfig);
-        marker.addToMap(this.map);
-        this.userLocationMarker = marker;
-        this.markerLayoutController.scheduleRelayout();
-        const updateMarker = (position) => {
-            marker.setLngLat([position.coords.longitude, position.coords.latitude]);
-            this.markerLayoutController.scheduleRelayout();
-        };
-        this.geoLocation = geoLocation !== null && geoLocation !== void 0 ? geoLocation : navigator.geolocation;
-        this.watchPositionID = this.geoLocation.watchPosition(updateMarker, (error) => {
-            console.error("Error getting user location:", error);
-        }, {
-            enableHighAccuracy: enableHighAccuracy,
-        });
-    }
-    removeUserLocationTracking() {
-        if (this.userLocationMarker !== undefined) {
-            this.userLocationMarker.remove();
-            this.userLocationMarker = undefined;
-            this.markerLayoutController.scheduleRelayout();
-            // Check if watchPosition ID is valid and stop tracking
-            if (this.watchPositionID) {
-                this.geoLocation.clearWatch(this.watchPositionID);
-                this.watchPositionID = undefined;
-            }
-        }
-    }
-    getBearing() {
-        return this.map.getBearing();
-    }
-    addBorderToPlaces(placeIds, color, width) {
-        try {
-            this.borderedPlacesRequest = { placeIds: [...placeIds], color, width };
-            if (!this.hasLayer("indoor-bordered-places")) {
-                this.createBorderedPlacesLayer();
-            }
-            const basicFilter = this.createBasicFilters();
-            const coloredPlacesFilters = placeIds.map((id) => {
-                const filter = ["==", ["get", "ref"], id];
-                return filter;
-            });
-            const placeFilter = ["any", ...coloredPlacesFilters];
-            const condition = ["all", placeFilter, basicFilter];
-            this.map.setFilter("indoor-bordered-places", condition);
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
-            this.capturedBaseFilters.add("indoor-bordered-places");
-            this.baseFilters["indoor-bordered-places"] = placeFilter;
-            if (color !== undefined && width !== undefined) {
-                this.map.setPaintProperty("indoor-bordered-places", "line-color", color);
-                this.map.setPaintProperty("indoor-bordered-places", "line-width", width);
-            }
-        }
-        catch (error) {
-            throw new Error("Failed to add border to places", { cause: error });
-        }
-    }
-    createBorderedPlacesLayer() {
-        const layer = {
-            id: "indoor-bordered-places",
-            type: "line",
-            source: "indoorequal",
-            "source-layer": "area",
-            filter: ["all", ["has", "ref"], ["==", ["get", "ref"], "unselected"]],
-            paint: {
-                "line-color": circle_1.MAPVX_BRAND_COLOR,
-                "line-width": 4,
-            },
-        };
-        this.map.addLayer(layer);
-    }
-    clearBorderedPlaces() {
-        this.borderedPlacesRequest = undefined;
-        if (this.hasLayer("indoor-bordered-places")) {
-            const condition = ["==", ["get", "ref"], "unselected"];
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
-            this.capturedBaseFilters.add("indoor-bordered-places");
-            this.baseFilters["indoor-bordered-places"] = condition;
-            this.map.setFilter("indoor-bordered-places", condition);
-        }
-    }
-    onWebGLContextLost(e) {
-        var _a, _b;
-        e.originalEvent.preventDefault();
-        console.warn("Contexto WebGL perdido 😢");
-        // Intentar restaurar el contexto automáticamente
-        const canvas = (_a = this === null || this === void 0 ? void 0 : this.map) === null || _a === void 0 ? void 0 : _a.getCanvas();
-        const gl = (canvas === null || canvas === void 0 ? void 0 : canvas.getContext("webgl")) || (canvas === null || canvas === void 0 ? void 0 : canvas.getContext("webgl2"));
-        if (gl && gl.isContextLost()) {
-            canvas.addEventListener("webglcontextrestored", () => {
-                console.debug("Contexto WebGL restaurado, forzando re-render");
-                this.map.triggerRepaint(); // forzar repaint
-                this.failedTiles.clear();
-            }, { once: true });
-            const ext = gl.getExtension("WEBGL_lose_context");
-            (_b = ext === null || ext === void 0 ? void 0 : ext.restoreContext) === null || _b === void 0 ? void 0 : _b.call(ext); // si aplica
-        }
-    }
-    onWebGLContextRestored() {
-        console.debug("Evento webglcontextrestored recibido, haciendo map.redraw()");
-        this.map.redraw(); // fuerza un redraw síncrono  [oai_citation:0‡maplibre.org](https://www.maplibre.org/maplibre-gl-js/docs/API/classes/Map/?utm_source=chatgpt.com)
-        this.failedTiles.clear();
-    }
-    onSourceData(e) {
-        var _a;
-        // Only track tiles that actually failed to load (not aborted or never loaded)
-        if (e.source.type === "vector" && e.sourceId === "indoorequal" && e.tile && !e.isSourceLoaded) {
-            // Check if tile has an error state before adding to retry queue
-            // Access state property safely as it may not always be available
-            const tileState = (_a = e.tile) === null || _a === void 0 ? void 0 : _a.state;
-            if (tileState === "errored" || tileState === "expired") {
-                this.failedTiles.add(e.tile);
-            }
-        }
-    }
-    onSourceDataAbort(e) {
-        // Remove aborted tiles from retry queue as they shouldn't be retried
-        if (e.source.type === "vector" && e.sourceId === "indoorequal" && e.tile) {
-            this.failedTiles.delete(e.tile);
-        }
-    }
-    /**
-     * True when a style object is attached to the map. During a full `setStyle` swap the
-     * map is momentarily style-less and any `getSource`/`getFilter` call throws
-     * ("Cannot read properties of undefined"), so call sites that only need the style to
-     * exist should gate on this rather than on `isStyleLoaded()`.
-     */
-    /**
-     * This style's layers, or `null` when the map has no style right now.
-     *
-     * The one place the style is read for a floor change, so callers can pass the
-     * result on instead of each probing again — `getStyle()` serializes every
-     * source and layer, and `Style._updateLayer` drops the cache behind it on
-     * every filter or layout write.
-     */
-    safeStyleLayers() {
-        var _a, _b, _c;
-        try {
-            return (_c = (_b = (_a = this.map) === null || _a === void 0 ? void 0 : _a.getStyle()) === null || _b === void 0 ? void 0 : _b.layers) !== null && _c !== void 0 ? _c : null;
-        }
-        catch (_d) {
-            return null;
-        }
-    }
-    hasStyle() {
-        var _a;
-        // `map.getStyle()` is the PUBLIC probe: it returns the serialized style, or throws
-        // while the map is momentarily style-less mid-swap. Reading maplibre's internal
-        // `style` field instead (it is absent from the public typings, so it needed a double
-        // cast) would fail closed and silently forever the moment a maplibre upgrade renames
-        // or privatizes it — disabling both the tile-retry loop and `setStyle`'s apply pass
-        // with no throw and no log. `safeGetFilter` already uses this try/catch shape.
-        try {
-            return ((_a = this.map) === null || _a === void 0 ? void 0 : _a.getStyle()) != null;
-        }
-        catch (_b) {
-            return false;
-        }
-    }
-    /**
-     * True when the map has a style object attached and fully loaded. Unlike
-     * `map.isStyleLoaded()`, this does not emit maplibre's "There is no style
-     * added to the map" warning when the style is momentarily absent (e.g. during
-     * a `setStyle` swap), because it checks for the style object first.
-     */
-    hasLoadedStyle() {
-        if (!this.hasStyle())
-            return false;
-        return this.map.isStyleLoaded() === true;
-    }
-    subscribeToFailedTiles() {
-        if (this.retryTimer)
-            return;
-        // Store bound functions for proper cleanup
-        this.boundOnSourceData = this.onSourceData.bind(this);
-        this.boundOnSourceDataAbort = this.onSourceDataAbort.bind(this);
-        this.boundOnWebGLContextLost = this.onWebGLContextLost.bind(this);
-        this.boundOnWebGLContextRestored = this.onWebGLContextRestored.bind(this);
-        this.retryTimer = setInterval(() => {
-            // During a full style swap (`setStyle` with `diff: false`) the map can
-            // momentarily have no style object attached. Calling `getSource` then
-            // throws ("Cannot read properties of undefined (reading 'getSource')").
-            // Only the style's PRESENCE is checked here, never `isStyleLoaded()`:
-            // that is false while any source still has tiles in flight, which is
-            // exactly when tiles fail — gating on it would skip every tick during a
-            // bad-network burst. The queue is left untouched so the tiles queued
-            // mid-swap are still retried on the next tick.
-            if (!this.hasStyle()) {
-                return;
-            }
-            if (!this.map.getSource("indoorequal")) {
-                this.failedTiles.clear();
-                return;
-            }
-            const source = this.map.getSource("indoorequal");
-            if (!source || source.type !== "vector") {
-                this.failedTiles.clear();
-                return;
-            }
-            // Process tiles and remove invalid ones
-            const tilesToRetry = [];
-            const tilesToRemove = [];
-            this.failedTiles.forEach((tile) => {
-                // Check if tile is still valid before attempting reload
-                if (!tile || tile.state === "unloaded" || tile.state === "loading") {
-                    tilesToRemove.push(tile);
-                    return;
-                }
-                // Only retry tiles that are in an error state
-                if (tile.state === "errored" || tile.state === "expired") {
-                    tilesToRetry.push(tile);
-                }
-                else {
-                    // Tile is in a valid state, remove from retry queue
-                    tilesToRemove.push(tile);
-                }
-            });
-            // Remove invalid tiles from the set
-            tilesToRemove.forEach((tile) => this.failedTiles.delete(tile));
-            // Attempt to reload valid failed tiles
-            const now = Date.now();
-            tilesToRetry.forEach((tile) => {
-                var _a;
-                const retry = (_a = this.tileRetryState.get(tile)) !== null && _a !== void 0 ? _a : {
-                    attempts: 0,
-                    nextAttemptAt: 0,
-                    pending: false,
-                };
-                // Skip tiles with a reload still in flight or still inside their backoff window.
-                if (retry.pending || now < retry.nextAttemptAt)
-                    return;
-                const onFailure = (error) => {
-                    const attempts = retry.attempts + 1;
-                    if (attempts >= MAX_TILE_RETRIES) {
-                        this.debugLog(`Tile reload failed ${attempts} times, dropping it from the retry queue`, error);
-                        this.failedTiles.delete(tile);
-                        this.tileRetryState.delete(tile);
-                        return;
-                    }
-                    // Stay in the queue and try again once the backoff has elapsed.
-                    const backoffMs = TILE_RETRY_BASE_DELAY_MS * 2 ** (attempts - 1);
-                    this.debugLog(`Tile reload failed (attempt ${attempts}/${MAX_TILE_RETRIES}), retrying in ${backoffMs}ms`, error);
-                    this.tileRetryState.set(tile, {
-                        attempts,
-                        nextAttemptAt: Date.now() + backoffMs,
-                        pending: false,
-                    });
-                };
-                try {
-                    // Verify tile still exists and is in a retryable state
-                    if (tile && (tile.state === "errored" || tile.state === "expired")) {
-                        this.tileRetryState.set(tile, Object.assign(Object.assign({}, retry), { pending: true }));
-                        // loadTile is async, so a rejection escapes this try/catch and has to be handled
-                        // on the promise itself - otherwise it surfaces as an unhandled rejection and the
-                        // tile is retried on every tick regardless of how often it has already failed.
-                        source
-                            .loadTile(tile)
-                            .then(() => {
-                            // Loaded: forget the attempt history so a later failure starts from zero. The
-                            // tile leaves the queue through the tilesToRemove branch on the next tick,
-                            // once its state is no longer errored/expired.
-                            this.tileRetryState.delete(tile);
-                        })
-                            .catch(onFailure);
-                    }
-                }
-                catch (error) {
-                    onFailure(error);
-                }
-            });
-        }, 1000);
-        this.map.on("sourcedata", this.boundOnSourceData);
-        this.map.on("sourcedataabort", this.boundOnSourceDataAbort);
-        // Escucha el evento de contexto perdido
-        this.map.on("webglcontextlost", this.boundOnWebGLContextLost);
-        // Adicional: escucha evento restauración
-        this.map.on("webglcontextrestored", this.boundOnWebGLContextRestored);
-    }
-    unsubscribeFromFailedTiles() {
-        if (this.retryTimer) {
-            clearInterval(this.retryTimer);
-            this.retryTimer = undefined;
-        }
-        if (this.boundOnSourceData) {
-            this.map.off("sourcedata", this.boundOnSourceData);
-            this.boundOnSourceData = undefined;
-        }
-        if (this.boundOnSourceDataAbort) {
-            this.map.off("sourcedataabort", this.boundOnSourceDataAbort);
-            this.boundOnSourceDataAbort = undefined;
-        }
-        if (this.boundOnWebGLContextLost) {
-            this.map.off("webglcontextlost", this.boundOnWebGLContextLost);
-            this.boundOnWebGLContextLost = undefined;
-        }
-        if (this.boundOnWebGLContextRestored) {
-            this.map.off("webglcontextrestored", this.boundOnWebGLContextRestored);
-            this.boundOnWebGLContextRestored = undefined;
-        }
-        this.failedTiles.clear();
-    }
-}
-exports.InternalMapVXMap = InternalMapVXMap;
-//# sourceMappingURL=map.js.map