@mapvx/web-js 3.4.0-dev.2 → 3.5.0-dev.1

package/dist/es/map/map.js

@@ -27,6 +27,13 @@ const MAX_TILE_RETRIES = 5;
  * 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;
 /** Fill/line layer ids for one circle render-order bucket. */
 function circleLayerIdsFor(order) {
     const suffix = CIRCLE_LAYER_SUFFIXES[order];
@@ -171,7 +178,7 @@ export class InternalMapVXMap extends Loggeable {
      * @returns A new instance of MapVXMap.
      */
     constructor(mapConfig, container, token) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         super();
         /**
          * Monotonic counter for {@link addLiveRoute} calls. Refreshes overlap (each one
@@ -185,6 +192,34 @@ export class InternalMapVXMap extends Loggeable {
         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;
@@ -206,15 +241,18 @@ export class InternalMapVXMap extends Loggeable {
             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(this);
         this.userLocationMarker = undefined;
         this.watchPositionID = undefined;
         this.onFloorChange = mapConfig.onFloorChange;
         this.onParentPlaceChange = mapConfig.onParentPlaceChange;
-        this.mode = (_c = mapConfig.mode) !== null && _c !== void 0 ? _c : "2D";
+        this.mode = (_d = mapConfig.mode) !== null && _d !== void 0 ? _d : "2D";
         this.scene3DConfig = mapConfig.scene3D;
         this.initialCenter = mapConfig.center;
         this.tileCacheConfig = (() => {
@@ -397,6 +435,17 @@ export class InternalMapVXMap extends Loggeable {
         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];
@@ -405,20 +454,29 @@ export class InternalMapVXMap extends Loggeable {
             else {
                 this.map.setFilter(layer.id, publicPlaceFilter);
             }
-            switch (layer.type) {
-                case "line":
-                case "symbol":
-                case "fill-extrusion":
-                case "fill":
-                    if (layer.filter != null) {
-                        this.baseFilters[layer.id] = layer.filter;
-                    }
-                    break;
-                default:
-                    break;
-            }
         });
     }
+    /**
+     * 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
@@ -500,6 +558,14 @@ export class InternalMapVXMap extends Loggeable {
         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;
+        }
         // 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();
@@ -574,6 +640,13 @@ export class InternalMapVXMap extends Loggeable {
                 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();
             })
@@ -613,6 +686,7 @@ export class InternalMapVXMap extends Loggeable {
     }
     setLang(lang) {
         this.repository.setLang(lang);
+        this.currentLang = lang;
         if (rtlLanguages.includes(lang)) {
             this.setRTLSupport();
         }
@@ -630,6 +704,201 @@ export class InternalMapVXMap extends Loggeable {
     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;
+        }
+        // When a user bearer token is present, the style is resolved through the
+        // bearer-authenticated endpoint, which authorizes by the user's client access
+        // rather than the api key's scopes — so a client's branded style can be
+        // previewed/applied without granting that place to a shared api key.
+        // Api-key consumers keep the `/api/sdk/v2/mapStyleJson` path.
+        const stylePromise = this.authToken
+            ? this.repository.fetchAndParseMapStyleByBearer(this.parentPlaceId, this.authToken, styleRef, styleTheme)
+            : this.repository.fetchAndParseMapStyle(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;
+            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
      */
@@ -1146,6 +1415,15 @@ export class InternalMapVXMap extends Loggeable {
         });
         const baseFloorId = (_c = this.innerFloors.find((floor) => floor.key === floorId)) === null || _c === void 0 ? void 0 : _c.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 = (_d = indoorLayers[0]) === null || _d === void 0 ? void 0 : _d.id;
             indoorLayers
@@ -1162,8 +1440,33 @@ export class InternalMapVXMap extends Loggeable {
             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 = [
@@ -1196,6 +1499,10 @@ export class InternalMapVXMap extends Loggeable {
             (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);
@@ -1622,6 +1929,7 @@ export class InternalMapVXMap extends Loggeable {
     }
     setPlacesAsSelected(placeIds, color) {
         try {
+            this.coloredPlacesRequest = { placeIds: [...placeIds], color };
             if (!this.hasLayer("indoor-colored-places")) {
                 this.createColoredPlacesLayer();
             }
@@ -1633,6 +1941,9 @@ export class InternalMapVXMap extends Loggeable {
             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");
@@ -1716,8 +2027,12 @@ export class InternalMapVXMap extends Loggeable {
         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);
         }
@@ -1912,6 +2227,7 @@ export class InternalMapVXMap extends Loggeable {
     }
     addBorderToPlaces(placeIds, color, width) {
         try {
+            this.borderedPlacesRequest = { placeIds: [...placeIds], color, width };
             if (!this.hasLayer("indoor-bordered-places")) {
                 this.createBorderedPlacesLayer();
             }
@@ -1923,6 +2239,9 @@ export class InternalMapVXMap extends Loggeable {
             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);
@@ -1948,8 +2267,12 @@ export class InternalMapVXMap extends Loggeable {
         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);
         }
@@ -1994,6 +2317,38 @@ export class InternalMapVXMap extends Loggeable {
             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()`.
+     */
+    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;
@@ -2003,6 +2358,17 @@ export class InternalMapVXMap extends Loggeable {
         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;