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

package/dist/cjs/controllers/routeController.js

@@ -1,1549 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteController = void 0;
-const marker_1 = require("../domain/models/marker");
-const routeInstance_1 = require("../domain/models/routeInstance");
-const nav_functions_1 = require("../utils/nav-functions");
-const utils_1 = require("../utils/utils");
-/**
- * Default padding values for auto-fit by place feature.
- * Used when padding is not explicitly provided in the animation configuration.
- */
-const DEFAULT_AUTO_FIT_PADDING = {
-    top: 150,
-    right: 150,
-    bottom: 150,
-    left: 150,
-};
-/**
- * Longest a step waits for its line to be uploaded before animating anyway, so
- * a stalled worker never freezes the route.
- *
- * A deadline rather than a frame count. `animateStep` is handed a `timestamp`
- * already, and a frame count would stretch to three seconds or more on the
- * 20-30 fps panels this wait exists for — the devices where a frozen marker at
- * every step boundary is most visible.
- */
-const MAX_SOURCE_WAIT_MS = 1500;
-/** Fully transparent: the part of a step line the reveal has not reached yet. */
-const TRANSPARENT_COLOR = "rgba(0, 0, 0, 0)";
-/**
- * Width of the reveal cut-off, as a fraction of the step line. One texel of
- * maplibre's 256-sample gradient ramp, i.e. the narrowest edge the ramp can
- * actually resolve.
- */
-const REVEAL_EDGE = 1 / 256;
-/**
- * Longest gap between two frames, in milliseconds, that still counts as
- * animation time.
- *
- * The frame loop charges the marker for however much wall clock has elapsed,
- * which is what makes a step take `stepTime` at any frame rate. A gap larger
- * than any frame rate can explain is not slow rendering, though — it is time
- * the animation did not run at all. `requestAnimationFrame` does not fire in a
- * backgrounded tab, so the first frame after the page comes back carries the
- * entire absence, and charging it advanced the draw by the whole gap: one
- * frame 10 s late at 50 m/s consumed exactly a hundred vertices in a single
- * `setData`, with the camera following the line as it jumped.
- *
- * Such a gap is therefore not charged (see `animateStep`). This is deliberately
- * NOT a clamp on how far one frame may advance: clamping would cap the catch-up
- * and hand back the frame-rate independence this loop exists to provide, and it
- * would still be wrong — the marker would sprint to catch up through time
- * nobody watched. Skipping the gap instead is what a pause does, which is what
- * an absence is.
- *
- * 500 ms is two frames per second. Real rendering does not sustain anything
- * near that low, so the threshold only ever separates absence from rendering,
- * and never shortens the catch-up of a genuinely slow frame.
- */
-const MAX_FRAME_GAP_MS = 500;
-/**
- * Represents the controller for routes on the map.
- * Supports multiple simultaneous routes with independent customizations,
- * animations, and lifecycle management.
- * @group Routes
- */
-class RouteController {
-    constructor(map) {
-        this.routes = new Map();
-        this.mapvxMap = map;
-    }
-    get map() {
-        return this.mapvxMap.map;
-    }
-    /**
-     * Resolve a route instance by ID, or fall back to the last added route.
-     */
-    resolveInstance(routeId) {
-        const id = routeId !== null && routeId !== void 0 ? routeId : this.lastAddedRouteId;
-        return id ? this.routes.get(id) : undefined;
-    }
-    /**
-     * Add MapLibre sources and layers for a single route instance.
-     *
-     * All three sources set `lineMetrics`: maplibre computes `line-progress` only
-     * when a source asks it to. The CURRENT layer needs it to reveal the step
-     * line as the marker advances, and `preparePaintForLayer` emits a
-     * `line-progress` gradient for a GradientStyle on any of the three — without
-     * it, a consumer setting a gradient route style silently got no gradient.
-     */
-    addSourcesAndLayersForRoute(instance) {
-        this.map.addSource(instance.aheadId, {
-            type: "geojson",
-            lineMetrics: true,
-            data: instance.aheadSourceData,
-        });
-        this.map.addLayer({
-            id: instance.aheadId,
-            type: "line",
-            source: instance.aheadId,
-            layout: {
-                "line-join": "round",
-                "line-cap": "round",
-            },
-        });
-        this.map.addSource(instance.behindId, {
-            type: "geojson",
-            lineMetrics: true,
-            data: instance.behindSourceData,
-        });
-        this.map.addLayer({
-            id: instance.behindId,
-            type: "line",
-            source: instance.behindId,
-            layout: {
-                "line-join": "round",
-                "line-cap": "round",
-            },
-        });
-        this.map.addSource(instance.currentId, {
-            type: "geojson",
-            lineMetrics: true,
-            data: instance.currentSourceData,
-        });
-        this.map.addLayer({
-            id: instance.currentId,
-            type: "line",
-            source: instance.currentId,
-            layout: {
-                "line-join": "round",
-                "line-cap": "round",
-            },
-        });
-    }
-    /**
-     * Remove MapLibre sources and layers for a single route instance.
-     */
-    removeSourcesAndLayersForRoute(instance) {
-        const ids = [instance.aheadId, instance.behindId, instance.currentId];
-        for (const id of ids) {
-            try {
-                this.map.removeLayer(id);
-            }
-            catch (_a) {
-                // Layer may not exist
-            }
-            try {
-                this.map.removeSource(id);
-            }
-            catch (_b) {
-                // Source may not exist
-            }
-        }
-    }
-    /**
-     * Re-add sources and layers for all active routes.
-     * Should be called when the map style is reloaded.
-     */
-    addSourcesAndLayers() {
-        for (const instance of this.routes.values()) {
-            this.addSourcesAndLayersForRoute(instance);
-            this.restoreLayerPaint(instance);
-        }
-        this.syncRouteCollision();
-    }
-    /**
-     * Re-apply the paint a style reload dropped.
-     *
-     * {@link addSourcesAndLayersForRoute} re-adds the layers with no paint at all, so
-     * without this the route keeps its geometry but loses its colors — and the CURRENT
-     * layer loses its `line-gradient`, which is the only thing hiding the part of the
-     * step the marker has not reached yet: the whole step would be drawn at once.
-     */
-    restoreLayerPaint(instance) {
-        var _a;
-        for (const [layerId, drawConfig] of Object.entries(instance.layerDrawConfigs)) {
-            this.setLayerPaint(instance, layerId, drawConfig);
-        }
-        // `?? 0`: a step whose geometry was loaded while the style was mid-swap
-        // never got a reveal recorded, because `applyReveal` bails when there is no
-        // layer to paint. Leaving the gradient off entirely then draws the whole
-        // step at once in the traveled color, and the `awaitingSources` hold, the
-        // rotation phase, the floor-change wait and a pause can each postpone the
-        // frame that would correct it — indefinitely, in the case of a pause.
-        // Revealing nothing is the safe default.
-        const reveal = (_a = instance.revealFraction) !== null && _a !== void 0 ? _a : 0;
-        // Force the update: `applyReveal` skips a fraction it believes is already on
-        // the map, and the fresh layer has no gradient at all.
-        instance.revealFraction = undefined;
-        this.applyReveal(instance, reveal);
-    }
-    /**
-     * Recompute the GLB route-transparency collision path from all active routes and push it to the
-     * map. Every polyline point of every step is tagged with the floor its segment is drawn on (same
-     * derivation as the route line's `floor_key`), so a 3D building only fades when a route is visibly
-     * crossing it on the displayed floor. The map ignores this unless the 3D scene is active, so it is
-     * safe to call unconditionally.
-     */
-    syncRouteCollision() {
-        const points = [];
-        for (const instance of this.routes.values()) {
-            for (const step of instance.route.steps) {
-                const floorKey = this.getFloorKeyForStep(step);
-                for (const coord of step.coordinates) {
-                    points.push({ lng: coord.lng, lat: coord.lat, floorKey });
-                }
-            }
-        }
-        this.mapvxMap.setRouteCollisionPath(points);
-    }
-    /**
-     * Add a route to the map.
-     * @param route The route to add.
-     * @param drawConfig The draw configuration for the route.
-     */
-    addRoute(route, drawConfig) {
-        const instance = (0, routeInstance_1.createRouteInstance)(route);
-        this.routes.set(instance.id, instance);
-        this.lastAddedRouteId = instance.id;
-        this.addSourcesAndLayersForRoute(instance);
-        this.setSourceData(instance, instance.aheadId, route.steps);
-        this.setLayerPaint(instance, instance.aheadId, drawConfig);
-        this.updateLayerFilter(instance.aheadId);
-        this.syncRouteCollision();
-    }
-    /**
-     * Update the visual progress of a route based on an external user position.
-     * Splits the route into behind (already traveled) and ahead (remaining) sections
-     * at the point on the route closest to the given position.
-     *
-     * @param routeId The ID of the route to update.
-     * @param position The current user position (will be projected onto the route).
-     * @param behindDrawConfig The draw configuration for the behind (traveled) portion.
-     */
-    updateRouteProgress(routeId, position, behindDrawConfig) {
-        const instance = this.routes.get(routeId);
-        if (!instance)
-            return;
-        const route = instance.route;
-        const steps = route.steps;
-        // Find the closest point on the route to the position
-        let bestDist = Infinity;
-        let bestStepIndex = 0;
-        let bestCoordIndex = 0;
-        let bestFraction = 0;
-        for (let s = 0; s < steps.length; s++) {
-            const coords = steps[s].coordinates;
-            for (let c = 0; c < coords.length - 1; c++) {
-                const a = coords[c];
-                const b = coords[c + 1];
-                const { fraction, dist } = this.projectPointToSegment(position, a, b);
-                if (dist < bestDist) {
-                    bestDist = dist;
-                    bestStepIndex = s;
-                    bestCoordIndex = c;
-                    bestFraction = fraction;
-                }
-            }
-        }
-        // Build behind features: all complete steps before the best step,
-        // plus the partial segment of the current step up to the projected point
-        const behindFeatures = [];
-        for (let s = 0; s < bestStepIndex; s++) {
-            behindFeatures.push({
-                type: "Feature",
-                properties: { floor_key: this.getFloorKeyForStep(steps[s]) },
-                geometry: {
-                    type: "LineString",
-                    coordinates: steps[s].geoJsonCoordinates,
-                },
-            });
-        }
-        // Partial behind feature for the current step (up to projected point)
-        const currentStep = steps[bestStepIndex];
-        const currentCoords = currentStep.coordinates;
-        const partialBehindCoords = [];
-        for (let c = 0; c <= bestCoordIndex; c++) {
-            partialBehindCoords.push([currentCoords[c].lng, currentCoords[c].lat]);
-        }
-        // Add the projected point
-        const a = currentCoords[bestCoordIndex];
-        const b = currentCoords[Math.min(bestCoordIndex + 1, currentCoords.length - 1)];
-        const projLat = a.lat + bestFraction * (b.lat - a.lat);
-        const projLng = a.lng + bestFraction * (b.lng - a.lng);
-        partialBehindCoords.push([projLng, projLat]);
-        if (partialBehindCoords.length >= 2) {
-            behindFeatures.push({
-                type: "Feature",
-                properties: { floor_key: this.getFloorKeyForStep(currentStep) },
-                geometry: { type: "LineString", coordinates: partialBehindCoords },
-            });
-        }
-        // Build ahead features: partial remainder of current step + all remaining steps
-        const aheadFeatures = [];
-        const partialAheadCoords = [[projLng, projLat]];
-        for (let c = bestCoordIndex + 1; c < currentCoords.length; c++) {
-            partialAheadCoords.push([currentCoords[c].lng, currentCoords[c].lat]);
-        }
-        if (partialAheadCoords.length >= 2) {
-            aheadFeatures.push({
-                type: "Feature",
-                properties: { floor_key: this.getFloorKeyForStep(currentStep) },
-                geometry: { type: "LineString", coordinates: partialAheadCoords },
-            });
-        }
-        for (let s = bestStepIndex + 1; s < steps.length; s++) {
-            aheadFeatures.push({
-                type: "Feature",
-                properties: { floor_key: this.getFloorKeyForStep(steps[s]) },
-                geometry: {
-                    type: "LineString",
-                    coordinates: steps[s].geoJsonCoordinates,
-                },
-            });
-        }
-        // Update sources
-        instance.behindSourceData.features = behindFeatures;
-        const behindSource = this.map.getSource(instance.behindId);
-        behindSource === null || behindSource === void 0 ? void 0 : behindSource.setData(instance.behindSourceData);
-        instance.aheadSourceData.features = aheadFeatures;
-        const aheadSource = this.map.getSource(instance.aheadId);
-        aheadSource === null || aheadSource === void 0 ? void 0 : aheadSource.setData(instance.aheadSourceData);
-        // Ensure paint is set on the behind layer
-        this.setLayerPaint(instance, instance.behindId, behindDrawConfig);
-        this.updateLayerFilter(instance.behindId);
-        this.updateLayerFilter(instance.aheadId);
-    }
-    /**
-     * Project a point onto a line segment and return the clamped fraction and squared distance.
-     */
-    projectPointToSegment(p, a, b) {
-        const dx = b.lng - a.lng;
-        const dy = b.lat - a.lat;
-        const lenSq = dx * dx + dy * dy;
-        if (lenSq === 0) {
-            const ddx = p.lng - a.lng;
-            const ddy = p.lat - a.lat;
-            return { fraction: 0, dist: ddx * ddx + ddy * ddy };
-        }
-        let t = ((p.lng - a.lng) * dx + (p.lat - a.lat) * dy) / lenSq;
-        t = Math.max(0, Math.min(1, t));
-        const projLng = a.lng + t * dx;
-        const projLat = a.lat + t * dy;
-        const ddx = p.lng - projLng;
-        const ddy = p.lat - projLat;
-        return { fraction: t, dist: ddx * ddx + ddy * ddy };
-    }
-    setSourceData(instance, id, steps) {
-        const features = this.createFeaturesFrom(steps);
-        const source = this.map.getSource(id);
-        if (id === instance.aheadId) {
-            instance.aheadSourceData.features = features;
-            source === null || source === void 0 ? void 0 : source.setData(instance.aheadSourceData);
-        }
-        else if (id === instance.behindId) {
-            instance.behindSourceData.features = features;
-            source === null || source === void 0 ? void 0 : source.setData(instance.behindSourceData);
-        }
-    }
-    /**
-     * Upload the whole polyline of `step` as the CURRENT feature and reset its
-     * reveal to zero. The line is then drawn progressively by moving a
-     * `line-progress` cut-off (see {@link applyReveal}) instead of re-uploading a
-     * growing geometry every frame: a paint change is applied synchronously, while
-     * a `setData` goes through the worker and lands several frames after the DOM
-     * marker already moved — on a slow device the marker visibly ran ahead of
-     * its line.
-     */
-    loadStepGeometry(instance, step) {
-        var _a;
-        instance.currentSourceData.properties = {
-            floor_key: this.getFloorKeyForStep(step),
-        };
-        const coordinates = (_a = step === null || step === void 0 ? void 0 : step.coordinates) !== null && _a !== void 0 ? _a : [];
-        // A LineString needs at least two positions; anything shorter draws nothing.
-        instance.currentSourceData.geometry.coordinates =
-            coordinates.length >= 2 ? coordinates.map((c) => [c.lng, c.lat]) : [];
-        const cumulative = [0];
-        for (let i = 1; i < coordinates.length; i++) {
-            cumulative.push(cumulative[i - 1] + nav_functions_1.NavFunctions.distance(coordinates[i - 1], coordinates[i]));
-        }
-        instance.stepMetrics = { cumulative, total: cumulative[cumulative.length - 1] };
-        instance.revealFraction = undefined;
-        this.applyReveal(instance, 0);
-        const source = this.map.getSource(instance.currentId);
-        source === null || source === void 0 ? void 0 : source.setData(instance.currentSourceData);
-    }
-    /**
-     * Fraction of the step line up to `coordinatesIndex` plus `extraMeters` along
-     * the following segment.
-     */
-    fractionAlongStep(instance, coordinatesIndex, extraMeters) {
-        var _a;
-        const metrics = instance.stepMetrics;
-        if (!metrics || metrics.total <= 0)
-            return 1;
-        const index = Math.min(coordinatesIndex, metrics.cumulative.length - 1);
-        return (((_a = metrics.cumulative[index]) !== null && _a !== void 0 ? _a : 0) + extraMeters) / metrics.total;
-    }
-    /**
-     * Show the first `fraction` of the CURRENT step line: a `line-gradient` step on
-     * `line-progress` that turns transparent past the cut-off. MapLibre treats it
-     * as a plain paint update (a 256px ramp re-rendered on the next draw), so the
-     * line head and the marker move in the same frame.
-     *
-     * The paint is set with `validate: false`: this runs on every animation frame and
-     * the expression is built here, not taken from a consumer, so re-parsing and
-     * re-validating it 60 times a second is pure overhead on a totem-class device.
-     */
-    applyReveal(instance, fraction) {
-        const color = instance.currentLineColor;
-        if (color === undefined)
-            return;
-        const clamped = Math.max(0, Math.min(1, fraction));
-        if (instance.revealFraction === clamped)
-            return;
-        // A full style swap removes the route's sources and layers and re-adds them a
-        // few frames later. Painting a layer that is not there fires a MapLibre error on
-        // every animation frame; `revealFraction` is deliberately left untouched so
-        // `restoreLayerPaint` re-applies this reveal once the layers are back.
-        if (!this.hasSource(instance.currentId))
-            return;
-        instance.revealFraction = clamped;
-        this.map.setPaintProperty(instance.currentId, "line-gradient", this.revealGradient(color, clamped), { validate: false });
-    }
-    /**
-     * The `line-gradient` that shows the first `fraction` of the step line and
-     * nothing after it.
-     *
-     * Deliberately built on `interpolate` rather than the `step` this reads like.
-     * `LineStyleLayer._handleSpecialPaintPropertyUpdate` sets `stepInterpolant`
-     * for any `step` root, and `stepInterpolant` swaps the gradient ramp from a
-     * fixed 256 texels to
-     * `clamp(nextPowerOfTwo(lineLength * 1024 * potentialOverzoom), 256, maxTextureSize)`
-     * — 4096 to 16384 in practice. Every `setPaintProperty` here bumps
-     * `gradientVersion`, so that ramp would be re-rendered and re-uploaded once
-     * per visible tile per frame, which is the opposite of what this reveal is
-     * for. An `interpolate` root keeps the ramp at 256 texels; the cost is a
-     * one-texel soft edge at the cut-off instead of a hard one.
-     */
-    revealGradient(color, fraction) {
-        if (fraction <= 0)
-            return TRANSPARENT_COLOR;
-        // `line-progress` reaches exactly 1 at the last vertex, so a fully revealed
-        // line is just the line's own color, with no cut-off to express.
-        if (fraction >= 1)
-            return color;
-        return [
-            "interpolate",
-            ["linear"],
-            ["line-progress"],
-            fraction,
-            color,
-            // `interpolate` clamps to its domain, so one texel past the cut-off is
-            // enough to make everything beyond it transparent.
-            Math.min(fraction + REVEAL_EDGE, 1),
-            TRANSPARENT_COLOR,
-        ];
-    }
-    /**
-     * Whether the route's three sources have finished uploading their latest
-     * data, i.e. what is on screen matches what was last set. Maps without
-     * `isSourceLoaded` (test doubles) count as ready.
-     */
-    stepSourcesReady(instance) {
-        try {
-            // CURRENT alone. It carries the step being drawn, which is what has to be
-            // on screen for the line, the floor and the marker to change together.
-            // AHEAD and BEHIND hold the whole route and are rewritten in full at every
-            // boundary, so waiting on them made the freeze at each step scale with the
-            // route's total length rather than the step's — and on a long route that
-            // is the difference between imperceptible and hitting the deadline.
-            if (!this.map.getSource(instance.currentId))
-                return false;
-            return this.map.isSourceLoaded(instance.currentId) !== false;
-        }
-        catch (_a) {
-            // The map is briefly style-less mid-swap and `getSource` throws there. This runs
-            // inside a `requestAnimationFrame` callback, where an exception would kill the
-            // animation loop for good, so treat it as "not ready yet" instead.
-            return false;
-        }
-    }
-    /** Whether `sourceId` is currently on the map (false while a style swap is in flight). */
-    hasSource(sourceId) {
-        try {
-            return this.map.getSource(sourceId) != null;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Apply a floor switch that was deferred until the next step's line was
-     * uploaded, then put the marker where that step starts. Floor, line and
-     * marker change in the same frame.
-     */
-    applyPendingFloor(instance) {
-        var _a;
-        const pending = (_a = instance.conditions) === null || _a === void 0 ? void 0 : _a.pendingFloor;
-        if (!pending || !instance.conditions)
-            return;
-        instance.conditions.pendingFloor = undefined;
-        this.updatePlaceFloorForRouting(instance, pending.placeId, pending.floorKey);
-        this.setMarkerLngLat(instance, pending.location);
-    }
-    setLayerPaint(instance, layerId, drawConfig) {
-        instance.layerDrawConfigs[layerId] = drawConfig;
-        const paintConfig = this.preparePaintForLayer(drawConfig);
-        for (const property in paintConfig) {
-            this.map.setPaintProperty(layerId, property, paintConfig[property]);
-        }
-    }
-    /**
-     * Set the paint the step line is drawn with, resolving its color once.
-     *
-     * See {@link RouteInstance.currentLineColor}: resolving a gradient allocates
-     * and can throw, and the reveal would otherwise redo it on every frame.
-     */
-    setCurrentDrawConfig(instance, drawConfig) {
-        instance.currentDrawConfig = drawConfig;
-        instance.currentLineColor = this.lineColorExpression(drawConfig);
-    }
-    /** The color of a route line: a solid color or a `line-progress` gradient ramp. */
-    lineColorExpression(drawConfig) {
-        if ("color" in drawConfig.routeStyle) {
-            // Check for propriety unique to SolidStyle
-            return drawConfig.routeStyle.color;
-        }
-        // Is GradienteStyle
-        const { colors, positions } = drawConfig.routeStyle;
-        const positionsToUse = positions !== null && positions !== void 0 ? positions : (0, utils_1.createPositionsForStops)(colors.length);
-        if (positionsToUse.length !== colors.length) {
-            throw new Error("Error: position array has different length than colors array");
-        }
-        const stops = (0, utils_1.createStops)(positionsToUse, colors);
-        return ["interpolate", ["linear"], ["line-progress"], ...stops];
-    }
-    preparePaintForLayer(drawConfig) {
-        const color = this.lineColorExpression(drawConfig);
-        if (typeof color === "string") {
-            return {
-                "line-color": color,
-                "line-gradient": null, // null to unset the existing value
-                "line-width": drawConfig.polylineWidth,
-            };
-        }
-        return {
-            "line-color": null,
-            "line-gradient": color,
-            "line-width": drawConfig.polylineWidth,
-        };
-    }
-    /**
-     * Update the filter of the layer referenced with a ID.
-     *
-     * @see {@link https://maplibre.org/maplibre-gl-js/docs/API/classes/Map/#setfilter}
-     * @param layerId The ID for the layer.
-     */
-    updateLayerFilter(layerId, floorId) {
-        const newFloorId = floorId !== null && floorId !== void 0 ? floorId : this.mapvxMap.getCurrentFloor();
-        if (newFloorId === undefined)
-            return;
-        // `getLayer` is a map lookup; `getStyle()` serialises every source and
-        // layer in the style just to answer the same question. This runs three
-        // times per route per floor change, and each preceding `setFilter`
-        // invalidates maplibre's serialised-layer cache, so the later calls used to
-        // re-serialise from scratch.
-        if (this.map.getLayer(layerId) != null) {
-            this.map.setFilter(layerId, ["==", ["get", "floor_key"], newFloorId]);
-        }
-    }
-    /**
-     * Determines the correct floor_key for a route step.
-     * Outdoor steps (without startInsideFloor) should use the outdoor floor key,
-     * not the current floor which might be indoor.
-     * Elevator steps are always drawn on startInsideFloor; floor is updated to endInsideFloor
-     * only when the step completes (see prepareForNextStep / animateStep).
-     * @param step The route step to determine the floor_key for
-     * @returns The floor_key string to use for the step
-     */
-    getFloorKeyForStep(step) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        if (!step) {
-            return this.mapvxMap.getCurrentFloor();
-        }
-        // If step has startInsideFloor, use it (unless it's a non-elevator floor change step)
-        if (((_b = (_a = step.startInsideFloor) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
-            // If step changes floors (different start and end) and is not an elevator step,
-            // use endInsideFloor so the step is drawn on the destination floor.
-            // Elevator steps are drawn on startInsideFloor; floor updates on step completion.
-            if (((_d = (_c = step.endInsideFloor) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0 &&
-                step.startInsideFloor !== step.endInsideFloor &&
-                !step.elevatorStep) {
-                return step.endInsideFloor;
-            }
-            return step.startInsideFloor;
-        }
-        // If step has endInsideFloor but no startInsideFloor (entering building), use endInsideFloor
-        if (((_f = (_e = step.endInsideFloor) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0) > 0) {
-            return step.endInsideFloor;
-        }
-        // If step is outdoor (no startInsideFloor and no endInsideFloor), use outdoor floor key
-        const innerFloors = this.mapvxMap.getInnerFloors();
-        const outdoorFloor = innerFloors.find((floor) => floor.reachableFromGPS === true);
-        return (_g = outdoorFloor === null || outdoorFloor === void 0 ? void 0 : outdoorFloor.key) !== null && _g !== void 0 ? _g : "";
-    }
-    createFeaturesFrom(steps) {
-        const features = steps.map((step) => {
-            return {
-                type: "Feature",
-                properties: { floor_key: this.getFloorKeyForStep(step) },
-                geometry: {
-                    type: "LineString",
-                    coordinates: step.geoJsonCoordinates,
-                },
-            };
-        });
-        return features;
-    }
-    /**
-     * Update the layers for all active routes.
-     * @param floorId The floor ID to update the layers for.
-     */
-    updateRouteLayers(floorId) {
-        for (const instance of this.routes.values()) {
-            this.updateLayerFilter(instance.aheadId, floorId);
-            this.updateLayerFilter(instance.behindId, floorId);
-            this.updateLayerFilter(instance.currentId, floorId);
-        }
-    }
-    /**
-     * Every active route's marker. Used by `MarkerLayoutController` so marker
-     * labels are never placed on top of a route's own marker.
-     * @internal
-     */
-    getRouteMarkers() {
-        const markers = [];
-        for (const instance of this.routes.values()) {
-            if (instance.routeMarker)
-                markers.push(instance.routeMarker);
-        }
-        return markers;
-    }
-    /**
-     * Update the visibility of route markers for all active routes.
-     * @param floorId The floor ID to update the visibility for.
-     */
-    updateRouteMarkerVisibility(floorId) {
-        var _a, _b, _c, _d;
-        // An outdoor step gives its marker an empty floorId, which never equals a
-        // real floor key — so on a venue with buildings the route arrow used to be
-        // hidden the moment the map filtered by one, and only reappeared because
-        // the animation re-attached the marker on its next frame. Outdoors is an
-        // allowance markers and circles already make; the route arrow makes it too.
-        const isOutdoor = this.mapvxMap.isOutdoorFloor(floorId);
-        for (const instance of this.routes.values()) {
-            const markerFloorId = (_b = (_a = instance.routeMarker) === null || _a === void 0 ? void 0 : _a.floorId) !== null && _b !== void 0 ? _b : "";
-            markerFloorId === floorId || (isOutdoor && markerFloorId === "")
-                ? (_c = instance.routeMarker) === null || _c === void 0 ? void 0 : _c.show(this.map)
-                : (_d = instance.routeMarker) === null || _d === void 0 ? void 0 : _d.hide();
-        }
-    }
-    updatePlaceFloorForRouting(instance, placeId, floorKey) {
-        var _a;
-        if (placeId && floorKey) {
-            this.mapvxMap.updatePlaceAndFloorForRouting(placeId, floorKey);
-            this.updateRouteLayers(floorKey);
-            (_a = instance.routeMarker) === null || _a === void 0 ? void 0 : _a.setFloor(floorKey);
-            this.updateRouteMarkerVisibility(floorKey);
-        }
-    }
-    /**
-     * Start the animation of a route.
-     * @param route The route to animate.
-     * @param drawConfig The draw configuration for the route.
-     * @param animationConfig The animation configuration for the route.
-     */
-    startAnimating(route, drawConfig, animationConfig) {
-        var _a, _b, _c;
-        const instance = (0, routeInstance_1.createRouteInstance)(route);
-        this.routes.set(instance.id, instance);
-        this.lastAddedRouteId = instance.id;
-        instance.animationStatus = "STARTED";
-        instance.route = route;
-        const firstStep = route.steps[0];
-        this.addSourcesAndLayersForRoute(instance);
-        this.updatePlaceFloorForRouting(instance, firstStep.startInsidePlace, firstStep.startInsideFloor);
-        this.setSourceData(instance, instance.aheadId, route.steps);
-        this.setSourceData(instance, instance.behindId, []);
-        this.setLayerPaint(instance, instance.aheadId, drawConfig.aheadConfig);
-        this.setLayerPaint(instance, instance.behindId, drawConfig.behindConfig);
-        this.setLayerPaint(instance, instance.currentId, drawConfig.behindConfig);
-        this.setCurrentDrawConfig(instance, drawConfig.behindConfig);
-        this.loadStepGeometry(instance, firstStep);
-        instance.animationConfig = animationConfig;
-        instance.routeMarker = new marker_1.MarkerAttribute({
-            coordinate: firstStep.startLocation,
-            floorId: firstStep.startInsideFloor,
-            icon: drawConfig.routeIcon,
-            rotationAlignment: "map",
-        });
-        instance.routeMarker.addToMap(this.map);
-        // Auto-fit by place if enabled
-        if (((_a = animationConfig.autoFitByPlace) === null || _a === void 0 ? void 0 : _a.enabled) && route.steps.length > 0) {
-            if (firstStep.startInsidePlace) {
-                instance.currentPlaceId = firstStep.startInsidePlace;
-                const fitOptions = {
-                    padding: (_b = animationConfig.autoFitByPlace.padding) !== null && _b !== void 0 ? _b : DEFAULT_AUTO_FIT_PADDING,
-                };
-                this.mapvxMap.fitRouteByPlace(route, firstStep.startInsidePlace, fitOptions);
-            }
-        }
-        // The conditions go in before the consumer hears about the start, for the same reason
-        // `restartAnimation` orders it that way. `animationStatus` is already "STARTED" here, so a
-        // consumer that pauses from inside this callback — showing a modal per step, say — passed
-        // `internalPause`'s status guard and then died on its `instance.conditions == null` check:
-        // the pause was dropped in silence, the loop kept running, and because the status stayed
-        // "STARTED" the matching `resumeAnimation()` bailed out too.
-        instance.conditions = {
-            index: 0,
-            coordinatesIndex: 0,
-            iconRotation: 0,
-            rotatingIcon: true,
-            startTime: undefined,
-            progress: 0,
-            resetTime: false,
-            waitStartTime: undefined,
-            awaitingSources: true,
-            animationId: requestAnimationFrame((time) => this.animateStep(time, instance)),
-            onFinish: (time) => this.prepareForNextStep(time, instance),
-        };
-        (_c = animationConfig.callBack) === null || _c === void 0 ? void 0 : _c.call(animationConfig, { isFinished: false, step: firstStep });
-        this.syncRouteCollision();
-    }
-    /**
-     * Tear one route instance down.
-     *
-     * `applyPendingFloorChange` decides what happens to a floor switch this
-     * instance had decided on but not yet shown. Removing a single route mid-walk
-     * applies it: the consumer may be removing the route from the step callback,
-     * and dropping the switch would leave the map on the floor the route has
-     * already left. Clearing every route does not — a floor switch is a visible
-     * camera and filter change plus an `onFloorChange` to the consumer, and
-     * `removeAllRoutes` is what teardown calls, where moving the map is
-     * a side effect nobody asked for and a consumer that re-enters from
-     * `onFloorChange` re-enters teardown.
-     */
-    clearRouteInstance(instance, applyPendingFloorChange = true) {
-        var _a;
-        if (applyPendingFloorChange) {
-            this.applyPendingFloor(instance);
-        }
-        else if (instance.conditions) {
-            instance.conditions.pendingFloor = undefined;
-        }
-        (_a = instance.routeMarker) === null || _a === void 0 ? void 0 : _a.remove();
-        instance.routeMarker = undefined;
-        this.setSourceData(instance, instance.aheadId, []);
-        this.setSourceData(instance, instance.behindId, []);
-        instance.currentSourceData.geometry.coordinates = [];
-        const source = this.map.getSource(instance.currentId);
-        source === null || source === void 0 ? void 0 : source.setData(instance.currentSourceData);
-        if ((instance.animationStatus === "STARTED" || instance.stepAnimationStatus === "ANIMATING") &&
-            instance.conditions != null) {
-            cancelAnimationFrame(instance.conditions.animationId);
-        }
-        instance.animationStatus = "NO_ROUTE";
-        instance.stepAnimationStatus = "NO_ROUTE";
-        instance.conditions = undefined;
-        instance.animationConfig = undefined;
-        instance.currentPlaceId = undefined;
-    }
-    /**
-     * Remove a route from the map.
-     * @param routeId The ID of the route to remove. If not provided, removes the last added route.
-     */
-    removeRoute(routeId) {
-        const instance = this.resolveInstance(routeId);
-        if (!instance)
-            return;
-        this.clearRouteInstance(instance);
-        this.removeSourcesAndLayersForRoute(instance);
-        this.routes.delete(instance.id);
-        if (this.lastAddedRouteId === instance.id) {
-            const remaining = [...this.routes.keys()];
-            this.lastAddedRouteId = remaining.length > 0 ? remaining[remaining.length - 1] : undefined;
-        }
-        this.syncRouteCollision();
-    }
-    /**
-     * Remove all routes from the map.
-     */
-    removeAllRoutes() {
-        for (const instance of this.routes.values()) {
-            this.clearRouteInstance(instance, false);
-            this.removeSourcesAndLayersForRoute(instance);
-        }
-        this.routes.clear();
-        this.lastAddedRouteId = undefined;
-        this.syncRouteCollision();
-    }
-    /**
-     * Get the IDs of all active routes on the map.
-     * @returns Array of route IDs.
-     */
-    getRouteIds() {
-        return [...this.routes.keys()];
-    }
-    internalPause(instance) {
-        if (instance.animationStatus != "STARTED")
-            return;
-        if (instance.conditions == null)
-            return;
-        cancelAnimationFrame(instance.conditions.animationId);
-        instance.animationStatus = "PAUSED";
-    }
-    /**
-     * Pause the animation of a route.
-     * @param routeId The ID of the route. If not provided, pauses the last added route.
-     */
-    pauseAnimation(routeId) {
-        const instance = this.resolveInstance(routeId);
-        if (!instance)
-            return;
-        this.internalPause(instance);
-    }
-    internalResume(instance) {
-        if (instance.animationStatus != "PAUSED")
-            return;
-        if (instance.conditions == null)
-            return;
-        instance.conditions.resetTime = true;
-        instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-        instance.animationStatus = "STARTED";
-    }
-    /**
-     * Resume the animation of a route.
-     * @param routeId The ID of the route. If not provided, resumes the last added route.
-     */
-    resumeAnimation(routeId) {
-        const instance = this.resolveInstance(routeId);
-        if (!instance)
-            return;
-        this.internalResume(instance);
-    }
-    /**
-     * Restart the animation of a route.
-     * @param routeId The ID of the route. If not provided, restarts the last added route.
-     */
-    restartAnimation(routeId) {
-        var _a, _b, _c, _d, _e;
-        const instance = this.resolveInstance(routeId);
-        if (!instance) {
-            throw new Error("Does not exist animated route to restart");
-        }
-        if (instance.animationStatus === "NO_ROUTE") {
-            throw new Error("Does not exist animated route to restart");
-        }
-        if (instance.conditions == null ||
-            instance.animationConfig == null ||
-            instance.route == null ||
-            instance.routeMarker == null) {
-            throw new Error("Error: conditions and animationConfig should not be null at this point");
-        }
-        if (instance.animationStatus === "STARTED") {
-            cancelAnimationFrame(instance.conditions.animationId);
-        }
-        instance.animationStatus = "STARTED";
-        const firstStep = instance.route.steps[0];
-        this.updatePlaceFloorForRouting(instance, firstStep.startInsidePlace, firstStep.startInsideFloor);
-        this.setSourceData(instance, instance.aheadId, instance.route.steps);
-        this.setSourceData(instance, instance.behindId, []);
-        this.loadStepGeometry(instance, firstStep);
-        (_a = this.setMarkerRotation(instance, 0)) === null || _a === void 0 ? void 0 : _a.setLngLat(firstStep.startLocation).addTo(this.map);
-        // Auto-fit by place if enabled
-        if (((_b = instance.animationConfig.autoFitByPlace) === null || _b === void 0 ? void 0 : _b.enabled) && instance.route.steps.length > 0) {
-            if (firstStep.startInsidePlace) {
-                instance.currentPlaceId = firstStep.startInsidePlace;
-                const fitOptions = {
-                    padding: (_c = instance.animationConfig.autoFitByPlace.padding) !== null && _c !== void 0 ? _c : DEFAULT_AUTO_FIT_PADDING,
-                };
-                this.mapvxMap.fitRouteByPlace(instance.route, firstStep.startInsidePlace, fitOptions);
-            }
-        }
-        // The new conditions go in before the consumer hears about the restart.
-        // Invoking the callback first left `instance.conditions` pointing at the
-        // previous run, so a consumer that pauses from inside it — showing a modal
-        // per step, say — cancelled a frame id that had already fired, marked the
-        // instance PAUSED, and then had a live loop installed underneath it. The
-        // next resume passed the "not paused" guard and started a second loop on
-        // the same instance; each schedules its own successor, so the doubling was
-        // permanent.
-        instance.conditions = {
-            index: 0,
-            coordinatesIndex: 0,
-            iconRotation: 0,
-            rotatingIcon: true,
-            startTime: undefined,
-            progress: 0,
-            resetTime: false,
-            waitStartTime: undefined,
-            awaitingSources: true,
-            animationId: requestAnimationFrame((time) => this.animateStep(time, instance)),
-            onFinish: (time) => this.prepareForNextStep(time, instance),
-        };
-        (_e = (_d = instance.animationConfig).callBack) === null || _e === void 0 ? void 0 : _e.call(_d, { isFinished: false, step: firstStep });
-    }
-    /**
-     * Stop the animation of a route.
-     * @param routeId The ID of the route. If not provided, stops the last added route.
-     */
-    stopAnimation(routeId) {
-        const instance = this.resolveInstance(routeId);
-        if (!instance)
-            return;
-        if (instance.animationStatus == "FINISHED") {
-            return;
-        }
-        // todo hacer cosas para detener animación
-        instance.animationStatus = "FINISHED";
-    }
-    /**
-     * Add a step animation to a route.
-     * @param route The route to animate.
-     * @param drawConfig The draw configuration for the route.
-     * @param animationConfig The animation configuration for the route.
-     */
-    addStepAnimation(route, drawConfig, animationConfig) {
-        var _a, _b, _c;
-        const instance = (0, routeInstance_1.createRouteInstance)(route);
-        this.routes.set(instance.id, instance);
-        this.lastAddedRouteId = instance.id;
-        instance.stepAnimationStatus = "WAITING";
-        instance.route = route;
-        const firstStep = route.steps[0];
-        this.addSourcesAndLayersForRoute(instance);
-        this.updatePlaceFloorForRouting(instance, firstStep.startInsidePlace, firstStep.startInsideFloor);
-        this.setSourceData(instance, instance.aheadId, route.steps);
-        this.setSourceData(instance, instance.behindId, []);
-        this.setLayerPaint(instance, instance.aheadId, drawConfig.aheadConfig);
-        this.setLayerPaint(instance, instance.behindId, drawConfig.behindConfig);
-        this.setLayerPaint(instance, instance.currentId, drawConfig.behindConfig);
-        this.setCurrentDrawConfig(instance, drawConfig.behindConfig);
-        this.loadStepGeometry(instance, firstStep);
-        instance.animationConfig = animationConfig;
-        instance.routeMarker = new marker_1.MarkerAttribute({
-            coordinate: firstStep.startLocation,
-            floorId: firstStep.startInsideFloor,
-            icon: drawConfig.routeIcon,
-            rotationAlignment: "map",
-        });
-        instance.routeMarker.addToMap(this.map);
-        this.cameraFollow(instance, firstStep.startLocation);
-        // Auto-fit by place if enabled
-        if (((_a = animationConfig.autoFitByPlace) === null || _a === void 0 ? void 0 : _a.enabled) && route.steps.length > 0) {
-            if (firstStep.startInsidePlace) {
-                instance.currentPlaceId = firstStep.startInsidePlace;
-                const fitOptions = {
-                    padding: (_b = animationConfig.autoFitByPlace.padding) !== null && _b !== void 0 ? _b : DEFAULT_AUTO_FIT_PADDING,
-                };
-                this.mapvxMap.fitRouteByPlace(route, firstStep.startInsidePlace, fitOptions);
-            }
-        }
-        // The conditions go in before the consumer hears about the route, as they
-        // do in `startAnimating`. Invoking the callback first left `conditions`
-        // undefined, so a consumer advancing the route from it — the step-by-step
-        // integration draws its first step this way — hit `nextStepAnimation`'s
-        // null check and got an exception instead of a step.
-        instance.conditions = {
-            index: 0,
-            coordinatesIndex: 0,
-            iconRotation: 0,
-            rotatingIcon: true,
-            startTime: undefined,
-            progress: 0,
-            resetTime: false,
-            waitStartTime: undefined,
-            animationId: 0,
-            isStepByStep: true,
-            onFinish: () => {
-                var _a, _b, _c, _d;
-                if (instance.conditions == null ||
-                    instance.animationConfig == null ||
-                    instance.route == null) {
-                    throw new Error("Error: conditions, animationConfig or route should not be null at this point");
-                }
-                let { index } = instance.conditions;
-                index++;
-                const behindSteps = instance.route.steps.slice(0, index);
-                const aheadSteps = instance.route.steps.slice(index);
-                const step = instance.route.steps[index];
-                this.setSourceData(instance, instance.behindId, behindSteps);
-                this.setSourceData(instance, instance.aheadId, aheadSteps);
-                this.loadStepGeometry(instance, step);
-                instance.conditions.index = index;
-                // The status settles before either callback, as everywhere else: no frame
-                // is live once `animateStep` hands over to `onFinish`, so "WAITING" is
-                // already true here. Writing it afterwards overwrote the "ANIMATING" of a
-                // consumer that chained the next step from this callback, and the
-                // following `nextStepAnimation` then skipped its cancel and installed a
-                // second self-sustaining loop on the same instance.
-                instance.stepAnimationStatus = "WAITING";
-                if (index < route.steps.length) {
-                    const nextStep = route.steps[index];
-                    // Auto-fit by place if enabled and place changed
-                    if (((_a = animationConfig.autoFitByPlace) === null || _a === void 0 ? void 0 : _a.enabled) && nextStep && instance.route != null) {
-                        const stepPlaceId = nextStep.startInsidePlace || nextStep.endInsidePlace;
-                        if (stepPlaceId && stepPlaceId !== instance.currentPlaceId) {
-                            instance.currentPlaceId = stepPlaceId;
-                            const fitOptions = {
-                                padding: (_b = animationConfig.autoFitByPlace.padding) !== null && _b !== void 0 ? _b : DEFAULT_AUTO_FIT_PADDING,
-                            };
-                            this.mapvxMap.fitRouteByPlace(instance.route, stepPlaceId, fitOptions);
-                        }
-                    }
-                    (_c = animationConfig.callBack) === null || _c === void 0 ? void 0 : _c.call(animationConfig, { isFinished: false, step: nextStep });
-                }
-                else {
-                    (_d = animationConfig.callBack) === null || _d === void 0 ? void 0 : _d.call(animationConfig, { isFinished: true, step: null });
-                }
-            },
-        };
-        (_c = animationConfig.callBack) === null || _c === void 0 ? void 0 : _c.call(animationConfig, { isFinished: false, step: firstStep });
-        this.syncRouteCollision();
-    }
-    /**
-     * Animate the next step of a route.
-     * @param routeId The ID of the route. If not provided, uses the last added route.
-     */
-    nextStepAnimation(routeId) {
-        const instance = this.resolveInstance(routeId);
-        if (!instance) {
-            throw new Error("Error: Does not exist step animation");
-        }
-        if (instance.stepAnimationStatus === "NO_ROUTE") {
-            throw new Error("Error: Does not exist step animation");
-        }
-        if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
-            throw new Error("Error: conditions, animationConfig or route should not be null at this point");
-        }
-        if (instance.stepAnimationStatus === "ANIMATING") {
-            cancelAnimationFrame(instance.conditions.animationId);
-        }
-        instance.stepAnimationStatus = "ANIMATING";
-        const { index } = instance.conditions;
-        if (index < instance.route.steps.length) {
-            instance.conditions.coordinatesIndex = 0;
-            instance.conditions.startTime = undefined;
-            instance.conditions.progress = 0;
-            instance.conditions.rotatingIcon = true;
-            instance.conditions.waitStartTime = undefined;
-            instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-        }
-        else {
-            throw new Error("Error: Does not exist next step to animate");
-        }
-    }
-    /**
-     * Go to the previous step of a route.
-     * @param routeId The ID of the route. If not provided, uses the last added route.
-     */
-    previousStepAnimation(routeId) {
-        var _a, _b, _c, _d;
-        const instance = this.resolveInstance(routeId);
-        if (!instance) {
-            throw new Error("Error: Does not exist step animation");
-        }
-        if (instance.stepAnimationStatus === "NO_ROUTE") {
-            throw new Error("Error: Does not exist step animation");
-        }
-        if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
-            throw new Error("Error: conditions, animationConfig or route should not be null at this point");
-        }
-        if (instance.stepAnimationStatus === "ANIMATING") {
-            cancelAnimationFrame(instance.conditions.animationId);
-        }
-        instance.stepAnimationStatus = "WAITING";
-        let { index } = instance.conditions;
-        if (index > 0) {
-            index--;
-            const behindSteps = instance.route.steps.slice(0, index);
-            const aheadSteps = instance.route.steps.slice(index);
-            const step = instance.route.steps[index];
-            this.setSourceData(instance, instance.behindId, behindSteps);
-            this.setSourceData(instance, instance.aheadId, aheadSteps);
-            this.loadStepGeometry(instance, step);
-            if (step.startInsideFloor != step.endInsideFloor && step.startInsideFloor) {
-                this.updatePlaceFloorForRouting(instance, step.startInsidePlace, step.startInsideFloor);
-            }
-            instance.conditions.index = index;
-            instance.conditions.coordinatesIndex = 0;
-            instance.conditions.startTime = undefined;
-            instance.conditions.progress = 0;
-            instance.conditions.rotatingIcon = true;
-            instance.conditions.waitStartTime = undefined;
-            this.setMarkerLngLat(instance, step.startLocation);
-            const previous = behindSteps[behindSteps.length - 1];
-            if (previous != null) {
-                const coordinates = previous.coordinates.slice(-2);
-                const angle = nav_functions_1.NavFunctions.bearingInDegBetween(coordinates[0], coordinates[1]);
-                this.setMarkerRotation(instance, angle);
-            }
-            else {
-                this.setMarkerRotation(instance, 0);
-            }
-            // Auto-fit by place if enabled and place changed
-            if (((_a = instance.animationConfig.autoFitByPlace) === null || _a === void 0 ? void 0 : _a.enabled) && step && instance.route != null) {
-                const stepPlaceId = step.startInsidePlace || step.endInsidePlace;
-                if (stepPlaceId && stepPlaceId !== instance.currentPlaceId) {
-                    instance.currentPlaceId = stepPlaceId;
-                    const fitOptions = {
-                        padding: (_b = instance.animationConfig.autoFitByPlace.padding) !== null && _b !== void 0 ? _b : DEFAULT_AUTO_FIT_PADDING,
-                    };
-                    this.mapvxMap.fitRouteByPlace(instance.route, stepPlaceId, fitOptions);
-                }
-            }
-            (_d = (_c = instance.animationConfig).callBack) === null || _d === void 0 ? void 0 : _d.call(_c, {
-                isFinished: false,
-                step,
-            });
-        }
-        else {
-            throw new Error("previous step doesn't exists to animate");
-        }
-    }
-    /**
-     * Center on the current step of a route.
-     * @param routeId The ID of the route. If not provided, uses the last added route.
-     */
-    centerOnCurrentStep(routeId) {
-        var _a;
-        const instance = this.resolveInstance(routeId);
-        if (!instance) {
-            throw new Error("Error: Does not exist step animation");
-        }
-        if (instance.stepAnimationStatus === "NO_ROUTE") {
-            throw new Error("Error: Does not exist step animation");
-        }
-        if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
-            throw new Error("Error: conditions, animationConfig or route should not be null at this point");
-        }
-        const currentMarkerPosition = (_a = instance.routeMarker) === null || _a === void 0 ? void 0 : _a.getLngLat();
-        if (currentMarkerPosition) {
-            this.map.panTo(currentMarkerPosition);
-        }
-        else {
-            throw new Error("Error: marker has no position set");
-        }
-    }
-    prepareForNextStep(timestamp, instance) {
-        var _a, _b, _c, _d, _e, _f;
-        if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
-            throw new Error("Error: conditions, animationConfig or route should not be null at this point");
-        }
-        const { index } = instance.conditions;
-        const behindSteps = instance.route.steps.slice(0, index + 1);
-        const aheadSteps = instance.route.steps.slice(index + 1);
-        this.setSourceData(instance, instance.behindId, behindSteps);
-        this.setSourceData(instance, instance.aheadId, aheadSteps);
-        if (index + 1 < instance.route.steps.length) {
-            const step = instance.route.steps[index + 1];
-            this.loadStepGeometry(instance, step);
-            instance.conditions.startTime = timestamp;
-            instance.conditions.index++;
-            instance.conditions.coordinatesIndex = 0;
-            instance.conditions.progress = 0;
-            instance.conditions.rotatingIcon = true;
-            // The step starts once its line (and the updated behind/ahead lines) are
-            // on screen; a floor switch decided by the previous step, or implied by a
-            // step that starts on another floor, is applied at that same moment.
-            instance.conditions.awaitingSources = true;
-            instance.conditions.awaitDeadline = undefined;
-            // Compared against the floor the PREVIOUS step ended on, not the map's current
-            // floor: the route decides its own floor changes, so a user who browsed to
-            // another floor mid-animation is not yanked back at every step boundary.
-            const previousStep = instance.route.steps[index];
-            // Against the previous step's *effective* floor, not its raw
-            // `endInsideFloor`. Venue data routinely carries `startInsideFloor` with
-            // no `endInsideFloor` — `getFloorKeyForStep` exists to resolve exactly
-            // that shape — and comparing against the raw field made every boundary
-            // on such a route look like a floor change: the map moved, the consumer
-            // got an `onFloorChange`, a settle poll ran and the step callback was
-            // deferred a frame, at each step. A user who had browsed to another floor
-            // was yanked back, which is what the deferral above is meant to avoid.
-            const previousFloor = this.getFloorKeyForStep(previousStep);
-            if (!instance.conditions.pendingFloor &&
-                step.startInsideFloor &&
-                step.startInsideFloor !== previousFloor) {
-                instance.conditions.pendingFloor = {
-                    placeId: step.startInsidePlace,
-                    floorKey: step.startInsideFloor,
-                    location: step.startLocation,
-                };
-            }
-            if (!(0, nav_functions_1.compareLatLng)(instance.route.steps[index].endLocation, step.startLocation))
-                instance.conditions.nextFloorFirstStepIndex = index + 2;
-            instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-            // Auto-fit by place if enabled and place changed
-            if (((_a = instance.animationConfig.autoFitByPlace) === null || _a === void 0 ? void 0 : _a.enabled) && step && instance.route != null) {
-                const stepPlaceId = step.startInsidePlace || step.endInsidePlace;
-                if (stepPlaceId && stepPlaceId !== instance.currentPlaceId) {
-                    instance.currentPlaceId = stepPlaceId;
-                    const fitOptions = {
-                        padding: (_b = instance.animationConfig.autoFitByPlace.padding) !== null && _b !== void 0 ? _b : DEFAULT_AUTO_FIT_PADDING,
-                    };
-                    this.mapvxMap.fitRouteByPlace(instance.route, stepPlaceId, fitOptions);
-                }
-            }
-            if (instance.conditions.pendingFloor) {
-                // The switch lands a few frames later, in `animateStep`. Firing the callback
-                // now would report the step while the map is still on the previous floor —
-                // and a consumer that stops the route from it would drop the switch entirely.
-                instance.conditions.pendingStepCallback = step;
-            }
-            else {
-                (_d = (_c = instance.animationConfig).callBack) === null || _d === void 0 ? void 0 : _d.call(_c, { isFinished: false, step });
-            }
-        }
-        else {
-            // finishes animation
-            this.applyPendingFloor(instance);
-            // That reached `onFloorChange`, and a consumer removing the route from it
-            // has already had `clearRouteInstance` null `animationConfig` and settle
-            // the status at "NO_ROUTE". Both lines below write through it — the
-            // `?.` is on `callBack`, not on `animationConfig` — so without this the
-            // branch threw a TypeError out of the rAF callback, and overwrote a
-            // finished instance's status with "FINISHED". `animateStep`'s release
-            // path takes the same guard after the same call.
-            if (instance.conditions == null || instance.animationConfig == null)
-                return;
-            // The status settles before the consumer hears that the route finished,
-            // for the same reason `startAnimating` and `restartAnimation` order it
-            // that way. A consumer that relaunches from this callback — looping a
-            // kiosk demo is the ordinary case — got its fresh "STARTED" overwritten
-            // by the "FINISHED" written afterwards, and was left with a live loop the
-            // controller believed was over: `pauseAnimation` and `stopAnimation` both
-            // bailed on the status guard, and the next `restartAnimation` skipped its
-            // cancel and installed a second self-sustaining loop.
-            instance.animationStatus = "FINISHED";
-            (_f = (_e = instance.animationConfig).callBack) === null || _f === void 0 ? void 0 : _f.call(_e, { isFinished: true, step: null });
-        }
-    }
-    animateStep(timestamp, instance) {
-        var _a, _b, _c, _d;
-        if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
-            throw new Error("Error: conditions and animationConfig should not be null at this point");
-        }
-        let { startTime, resetTime, progress, waitStartTime } = instance.conditions;
-        const { coordinatesIndex, iconRotation, index, onFinish, rotatingIcon } = instance.conditions;
-        const { stepTime, minimumSpeed, iconRotationTime, changeFloorTime } = instance.animationConfig;
-        // How long this frame took to arrive. Recorded before any early return, so
-        // the next frame measures from the last one delivered rather than from the
-        // last one that drew.
-        const previousFrameTime = instance.conditions.lastFrameTime;
-        instance.conditions.lastFrameTime = timestamp;
-        if (startTime == null) {
-            instance.conditions.startTime = timestamp;
-            instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-            return;
-        }
-        if (instance.conditions.awaitingSources) {
-            let deadline = (_a = instance.conditions.awaitDeadline) !== null && _a !== void 0 ? _a : timestamp + MAX_SOURCE_WAIT_MS;
-            // The deadline is wall clock, and this block returns before the frame-gap
-            // branch below can ever run, so it needs that branch's shift applied here
-            // — the same one `waitStartTime` gets, for the same reason. A backgrounded
-            // tab or a pause longer than the deadline would otherwise release the step
-            // on the first frame back without once asking whether its line is on
-            // screen, which is the desync the wait exists to prevent.
-            if (previousFrameTime != null && timestamp - previousFrameTime > MAX_FRAME_GAP_MS) {
-                deadline += timestamp - previousFrameTime;
-            }
-            instance.conditions.awaitDeadline = deadline;
-            if (!this.stepSourcesReady(instance) && timestamp < deadline) {
-                // Hold the clock: the step starts when its line can be seen.
-                instance.conditions.startTime = timestamp;
-                instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                return;
-            }
-            instance.conditions.awaitingSources = false;
-            instance.conditions.awaitDeadline = undefined;
-            instance.conditions.startTime = timestamp;
-            const heldStep = instance.conditions.pendingStepCallback;
-            instance.conditions.pendingStepCallback = undefined;
-            // The frame that releases the wait draws nothing: it queues its successor
-            // and hands control to the consumer, and that successor does the drawing.
-            //
-            // The queue has to come first. Both calls below reach consumer code —
-            // `applyPendingFloor` through the `onFloorChange` handler, and the held
-            // step callback directly — and a `pauseAnimation()` from either one
-            // cancels whatever id sits in `conditions.animationId`. While that id was
-            // the frame already executing, cancelling it did nothing: the loop kept
-            // running under a `PAUSED` status, and the matching `resumeAnimation()`
-            // passed its status guard and installed a second concurrent rAF chain on
-            // the same instance. Queueing first gives that pause a pending frame to
-            // cancel, and returning afterwards means this frame does not queue a
-            // replacement for the one it just cancelled.
-            instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-            this.applyPendingFloor(instance);
-            // `onFloorChange` may have removed the route; everything below reads
-            // `conditions`.
-            if (instance.conditions == null || instance.animationConfig == null)
-                return;
-            if (heldStep) {
-                (_c = (_b = instance.animationConfig).callBack) === null || _c === void 0 ? void 0 : _c.call(_b, { isFinished: false, step: heldStep });
-            }
-            return;
-        }
-        if (resetTime) {
-            startTime = timestamp - progress;
-            instance.conditions.startTime = startTime;
-            resetTime = false;
-            instance.conditions.resetTime = resetTime;
-        }
-        else if (previousFrameTime != null && timestamp - previousFrameTime > MAX_FRAME_GAP_MS) {
-            // Absence, not slow rendering: see MAX_FRAME_GAP_MS. Shift the clock
-            // forward by the gap instead of charging it, exactly as resuming from a
-            // pause does above, so this frame redraws where the last one left off
-            // and the next resumes from there.
-            const gap = timestamp - previousFrameTime;
-            // What the previous frame had charged. Equal to `progress` whenever the
-            // two are in step, but the rotation branches above set `startTime` to
-            // the frame timestamp without resetting `progress`, so reading the
-            // stored value would carry a whole rotation's worth of time into the
-            // first frame back. Recomputed instead, which is 0 in exactly that case.
-            progress = previousFrameTime - startTime;
-            instance.conditions.progress = progress;
-            startTime = timestamp - progress;
-            instance.conditions.startTime = startTime;
-            // The floor-change wait runs on the raw timestamp rather than on
-            // `progress`, so it needs the same shift or an absence would satisfy it
-            // outright.
-            if (waitStartTime != null) {
-                waitStartTime += gap;
-                instance.conditions.waitStartTime = waitStartTime;
-            }
-        }
-        else {
-            progress = timestamp - startTime;
-            instance.conditions.progress = progress;
-        }
-        // Not const: the segment loop below rewinds it as it charges the clock for
-        // each segment it consumes within the frame.
-        let progressInSeconds = progress / 1000;
-        const step = instance.route.steps[index];
-        if (step.coordinates.length <= 0) {
-            onFinish === null || onFinish === void 0 ? void 0 : onFinish(timestamp);
-            return;
-        }
-        const start = step.coordinates[coordinatesIndex];
-        const end = step.coordinates[coordinatesIndex + 1];
-        if (start != null && end != null) {
-            if (rotatingIcon) {
-                const angle = nav_functions_1.NavFunctions.bearingInDegBetween(start, end);
-                if (iconRotationTime === 0 ||
-                    instance.conditions.nextFloorFirstStepIndex === index ||
-                    Math.abs(angle - instance.conditions.iconRotation) < 15) {
-                    instance.conditions.nextFloorFirstStepIndex = undefined;
-                    this.setMarkerRotation(instance, angle);
-                    instance.conditions.startTime = timestamp;
-                    instance.conditions.rotatingIcon = false;
-                    instance.conditions.iconRotation = angle;
-                    instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                    return;
-                }
-                else if (progressInSeconds < iconRotationTime) {
-                    const intermediateAngle = nav_functions_1.NavFunctions.intermediateAngleBetween(iconRotation, angle, progressInSeconds / iconRotationTime);
-                    this.setMarkerRotation(instance, intermediateAngle);
-                    instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                    return;
-                }
-                else {
-                    this.setMarkerRotation(instance, angle);
-                    instance.conditions.startTime = timestamp;
-                    instance.conditions.rotatingIcon = false;
-                    instance.conditions.iconRotation = angle;
-                    instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                    return;
-                }
-            }
-            // There has to be a floor to switch *to*. An absent `startInsideFloor` is
-            // meaningful — that is a step entering the building from outdoors — but an
-            // absent `endInsideFloor` is not: venue data routinely omits it on a step
-            // that does not change floor, and reading that as "different" made every
-            // such step stall for `changeFloorTime` and then queue a switch whose
-            // `floorKey` was `undefined`. `updatePlaceFloorForRouting` drops that
-            // silently, but not before it has occupied the `pendingFloor` slot the
-            // step boundary needed for a real one.
-            if (step.endInsideFloor && step.startInsideFloor !== step.endInsideFloor) {
-                if (waitStartTime == null) {
-                    instance.conditions.waitStartTime = timestamp;
-                    instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                    return;
-                }
-                if (timestamp - waitStartTime < changeFloorTime * 1000) {
-                    instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                    return;
-                }
-                else {
-                    instance.conditions.waitStartTime = undefined;
-                    if (instance.conditions.isStepByStep) {
-                        // Step-by-step mode is user-driven: switch right away, as before.
-                        this.updatePlaceFloorForRouting(instance, step.endInsidePlace, step.endInsideFloor);
-                        this.setMarkerLngLat(instance, step.endLocation);
-                    }
-                    else {
-                        // Defer the switch until the next step's line is uploaded, so floor,
-                        // line and marker change together (see applyPendingFloor).
-                        instance.conditions.pendingFloor = {
-                            placeId: step.endInsidePlace,
-                            floorKey: step.endInsideFloor,
-                            location: step.endLocation,
-                        };
-                    }
-                    onFinish === null || onFinish === void 0 ? void 0 : onFinish(timestamp);
-                    return;
-                }
-            }
-            const speed = Math.max(step.distance / stepTime, minimumSpeed !== null && minimumSpeed !== void 0 ? minimumSpeed : 0);
-            // Consume every whole segment the elapsed time pays for inside this one
-            // frame, carrying the sub-segment remainder into the next.
-            //
-            // Advancing a single vertex per frame — and restarting the clock at each
-            // one, which threw the overshoot away — made a step's duration depend on
-            // the frame rate: it cost `stepTime` plus up to one frame per vertex,
-            // and once `speed * frameInterval` exceeded a segment's length it
-            // ignored `stepTime` altogether and collapsed to `vertexCount / fps`.
-            // Encoded polylines quantise near 1.1 m, so that regime was the common
-            // one, not the corner case.
-            //
-            // The step's whole polyline is already uploaded (see `loadStepGeometry`),
-            // so a frame commits nothing: it only moves the reveal cut-off, which is
-            // the same distance that moves the marker.
-            let segmentStart = start;
-            let segmentEnd = end;
-            let segmentDistance = nav_functions_1.NavFunctions.distance(segmentStart, segmentEnd);
-            while (speed * progressInSeconds > segmentDistance) {
-                if (instance.conditions.coordinatesIndex + 2 >= step.coordinates.length) {
-                    // `segmentEnd` is the step's last vertex: reveal the line in full.
-                    this.applyReveal(instance, this.fractionAlongStep(instance, instance.conditions.coordinatesIndex + 1, 0));
-                    onFinish === null || onFinish === void 0 ? void 0 : onFinish(timestamp);
-                    return;
-                }
-                // Charge the clock exactly what this segment cost instead of
-                // restarting it, so no time is lost at a vertex.
-                const segmentMs = (segmentDistance / speed) * 1000;
-                startTime += segmentMs;
-                progress -= segmentMs;
-                instance.conditions.startTime = startTime;
-                instance.conditions.progress = progress;
-                progressInSeconds = progress / 1000;
-                instance.conditions.coordinatesIndex++;
-                const next = step.coordinates[instance.conditions.coordinatesIndex + 1];
-                if (!(0, nav_functions_1.compareLatLng)(segmentEnd, next)) {
-                    if (instance.conditions.isStepByStep) {
-                        // Step-by-step mode animates the turn itself, on the rotation
-                        // branch of the next frame. Stop consuming segments and let it.
-                        //
-                        // The clock restarts here because the rotation branch measures its
-                        // own progress from `startTime`, and every other transition into it
-                        // resets too (see `prepareForNextStep` and the floor-change hand-off).
-                        // Carrying this frame's leftover sub-segment time over instead
-                        // started the turn already part-way through — or skipped it outright
-                        // once the remainder exceeded `iconRotationTime`. Before the segment
-                        // loop existed the per-vertex path reset it as well.
-                        instance.conditions.rotatingIcon = true;
-                        instance.conditions.startTime = timestamp;
-                        instance.conditions.progress = 0;
-                        // The marker stops on the vertex it turns about, so the line does too.
-                        this.applyReveal(instance, this.fractionAlongStep(instance, instance.conditions.coordinatesIndex, 0));
-                        instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-                        return;
-                    }
-                    const nextAngle = nav_functions_1.NavFunctions.bearingInDegBetween(segmentEnd, next);
-                    instance.conditions.iconRotation = nextAngle;
-                    (_d = instance.routeMarker) === null || _d === void 0 ? void 0 : _d.setRotation(nextAngle);
-                }
-                segmentStart = segmentEnd;
-                segmentEnd = next;
-                segmentDistance = nav_functions_1.NavFunctions.distance(segmentStart, segmentEnd);
-            }
-            const traveled = Math.min(speed * progressInSeconds, segmentDistance);
-            const point = segmentDistance === 0
-                ? segmentEnd
-                : nav_functions_1.NavFunctions.intermediatePointBetween(segmentStart, segmentEnd, traveled / segmentDistance);
-            // The same distance drives the reveal cut-off and the marker, and the
-            // reveal is a synchronous paint update rather than a `setData` that lands
-            // several frames later, so the two cannot drift apart.
-            this.applyReveal(instance, this.fractionAlongStep(instance, instance.conditions.coordinatesIndex, traveled));
-            this.setMarkerLngLat(instance, point);
-            // Only when it has genuinely left the DOM. maplibre's `Marker.addTo`
-            // opens with `remove()`, so re-attaching an attached marker tears down
-            // and rebuilds 13 map listeners and detaches and re-appends the element.
-            // Unconditionally, that ran every frame — and quietly undid
-            // `updateRouteMarkerVisibility` hiding the arrow, which is the bug it was
-            // really covering for.
-            //
-            // `isConnected` alone cannot express that: `hide()` detaches the element
-            // through maplibre's `Marker.remove()`, so a marker hidden by a floor
-            // change reads as disconnected and was re-attached on the very next
-            // frame — the arrow reappeared on the wrong floor. Hidden-ness is an
-            // intent, so it is read from the flag `hide()`/`show()` maintain, and
-            // `isConnected` is left to answer only what it can: whether a marker
-            // nobody hid has fallen out of the DOM (a step transition removing it).
-            if (instance.routeMarker != null &&
-                !instance.routeMarker.hiddenOnPurpose &&
-                !instance.routeMarker.getElement().isConnected) {
-                instance.routeMarker.addTo(this.map);
-            }
-            instance.conditions.animationId = requestAnimationFrame((time) => this.animateStep(time, instance));
-            return;
-        }
-        else {
-            onFinish === null || onFinish === void 0 ? void 0 : onFinish(timestamp);
-            return;
-        }
-    }
-    setMarkerLngLat(instance, point) {
-        var _a, _b;
-        if ((_a = instance.conditions) === null || _a === void 0 ? void 0 : _a.isStepByStep) {
-            this.cameraFollow(instance, point);
-        }
-        (_b = instance.routeMarker) === null || _b === void 0 ? void 0 : _b.setLngLat(point);
-    }
-    setMarkerRotation(instance, angle) {
-        var _a, _b, _c, _d, _e;
-        if (((_a = instance.conditions) === null || _a === void 0 ? void 0 : _a.isStepByStep) && !((_b = instance.animationConfig) === null || _b === void 0 ? void 0 : _b.keepFixedBearing)) {
-            this.mapvxMap.updateCamera({
-                duration: (_c = instance.animationConfig) === null || _c === void 0 ? void 0 : _c.iconRotationTime,
-                animate: true,
-                bearing: angle,
-                center: (_d = instance.routeMarker) === null || _d === void 0 ? void 0 : _d.getLngLat(),
-            });
-        }
-        return (_e = instance.routeMarker) === null || _e === void 0 ? void 0 : _e.setRotation(angle);
-    }
-    setMarkerFloor(floorId, routeId) {
-        var _a;
-        const instance = this.resolveInstance(routeId);
-        (_a = instance === null || instance === void 0 ? void 0 : instance.routeMarker) === null || _a === void 0 ? void 0 : _a.setFloor(floorId);
-    }
-    cameraFollow(instance, point) {
-        var _a, _b, _c, _d;
-        const keepFixedBearing = (_b = (_a = instance.animationConfig) === null || _a === void 0 ? void 0 : _a.keepFixedBearing) !== null && _b !== void 0 ? _b : false;
-        this.mapvxMap.updateCamera(Object.assign({ center: point, animate: true, duration: (_c = instance.animationConfig) === null || _c === void 0 ? void 0 : _c.iconRotationTime }, (keepFixedBearing ? {} : { bearing: (_d = instance.routeMarker) === null || _d === void 0 ? void 0 : _d.getRotation() })));
-    }
-}
-exports.RouteController = RouteController;
-//# sourceMappingURL=routeController.js.map