@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/store/RouteStore.js

@@ -0,0 +1,697 @@
+import { __decorate } from "tslib";
+import { Box, boxContainsPoint, pointDistance } from '@expofp/geometry';
+import { action, computed, observable } from 'mobx';
+import { getName as getKioskName } from '../components/Kiosk/SetKiosk';
+import { mapCamera } from '../components/Map/camera';
+import { DEFAULT_UNITS, ORIENTATION_GRANTED_KEY } from '../constants';
+import data from '../data';
+import { getFpGeo } from '../data/fpGeo.js';
+import { getLayerSvg, getSvgArea } from '../data/svg.js';
+import { GaEventActions, sendEventToGa } from '../tools/gtag';
+import logger from '../tools/logger';
+import { areLayersEnabled } from '../utils/areLayersEnabled';
+import { calcSpeed } from '../utils/calcSpeed';
+import { calcTravelTime } from '../utils/calcTravelTime';
+import { calculateRelativeBearing, convertGpsToLocal, isValidPointCoords, } from '../utils/gps';
+import { boothToEndpoint, buildRoute, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, isWayfindingReady, KIOSK_ANCHOR_POINT_ID, routeSteps, toArbitraryPoint, } from '../wayfinding';
+import store, { layersStore, uiState } from '.';
+import { BoothBase } from './BoothStore';
+import { LayersMode } from './LayerStore';
+import { revealLayer } from './reveal-layer.js';
+/** A coordinate as the SDK may deliver it — `1.5`, or `"1,5"` from a comma locale. */
+function replaceCommasWithDot(value) {
+    if (typeof value === 'string') {
+        return Number(value.replace(',', '.'));
+    }
+    return value;
+}
+export default class RouteStore {
+    constructor(rootStore) {
+        this.routeLines = [];
+        this.routedRouteBox = observable.box(null, { deep: false });
+        /** The layers the route's campus-graph legs run on (see `routeSteps`). */
+        this.campusLayersBox = observable.box(new Set(), {
+            deep: false,
+        });
+        this.routeDistance = null;
+        this.currentPosition = null;
+        this.requestCompass = false;
+        this.iconType = 0;
+        this.tempToBooth = null;
+        this.focusEnabled = true;
+        this.prevZ = null;
+        this.markersData = { icons: [], markers: [] };
+        this.prevMarkers = [];
+        /** Cancels the camera move still waiting for a floor to come on screen (see `revealLayer`). */
+        this.pendingReveal = null;
+        this.showAccessible = false;
+        this.onlyAccessible = false;
+        this.currentRouteLayer = null;
+        this.currentRouteExhibitor = null;
+        this.selectRouteRequest = 0;
+        this.routeUnits = DEFAULT_UNITS;
+        this.isGpsTrackingEnabled = true;
+        this.rootStore = rootStore;
+        // One-shot heuristic (3a406b04f): auto-focus the first blue-dot position only on a clean
+        // entry URL — any query (selection deep-link, camera seed, even unrelated params) means the
+        // entry view wins. Replacing the raw sniff with a selection-based check is a deliberate
+        // follow-up (retirement plan §4.11); kept as-is here.
+        this.focusEnabled = !window.location.search;
+    }
+    get canFindLocation() {
+        return !!uiState.kioskData || !!this.currentPosition;
+    }
+    selectRoute(route, resetList = true, immediate = false) {
+        const selectRouteRequest = ++this.selectRouteRequest;
+        // `immediate=true` skips the 200ms defer — auto-reroute из CP без задержки.
+        if (resetList) {
+            uiState.list = { type: 'search', text: '', focused: false };
+        }
+        // CP / kiosk-anchor as default FROM when caller passes only TO. There is no default TO —
+        // destination always comes from explicit booth selection or a swap action, so we don't fill
+        // the TO slot from kiosk/CP.
+        if (route && !route.from && route.to) {
+            const fallbackFrom = this.resolveFallbackFrom();
+            if (fallbackFrom)
+                route = new Route(fallbackFrom, route.to, route.waypoints);
+        }
+        if (route?.from && route?.to && route.from === route.to)
+            route = null;
+        const toLayer = resolveLayerObject(this.rootStore.layerStore, route?.to);
+        const destinationVenue = this.rootStore.venueStore.hasVenueModel && toLayer
+            ? this.rootStore.venueStore.venueOfLayer(toLayer)
+            : null;
+        const destinationReady = destinationVenue
+            ? this.rootStore.venueStore.enterVenue(destinationVenue, {
+                level: toLayer ?? undefined,
+                fly: false,
+            })
+            : null;
+        const list = [];
+        if (route?.from && route?.to)
+            window.setTimeout(() => {
+                this.rootStore.showMap();
+            }, navigator.userAgent.toLowerCase().indexOf('android') > -1 ? 400 : 50);
+        if (route?.from instanceof BoothBase)
+            list.push(route.from);
+        if (route?.to instanceof BoothBase) {
+            this.tempToBooth = null;
+            list.push(route.to);
+        }
+        if (!route && store.fp.onDirection)
+            store.fp.onDirection(null);
+        // Deferred below, so the observable writes land outside `selectRoute`'s own action.
+        const applyDetails = action(() => {
+            // A newer selectRoute has superseded this one while it waited out the defer.
+            if (selectRouteRequest !== this.selectRouteRequest)
+                return;
+            if (destinationReady) {
+                void destinationReady.then(() => {
+                    if (selectRouteRequest === this.selectRouteRequest) {
+                        this.rootStore.moveToList(list, true);
+                    }
+                });
+            }
+            else {
+                this.rootStore.moveToList(list);
+            }
+            uiState.details = route;
+            // A full-height sheet behind the ~160px planner form is a white screen (#1567).
+            if (route && (!route.from || !route.to) && uiState.overlayBottom) {
+                uiState.desiredOverlaySize = 'medium';
+            }
+            // On a venue-model plan `enterVenue` above already brought the destination's
+            // level up, so forcing the FROM layer visible would fight it.
+            if (route?.to && route?.from && !destinationVenue) {
+                const fromLayerKey = getLayerName(route.from);
+                if (fromLayerKey)
+                    this.rootStore.layerStore.updateVisibility(fromLayerKey, true);
+            }
+            if (!this.currentRouteLayer) {
+                const fromLayer = resolveLayerObject(this.rootStore.layerStore, route?.from);
+                if (fromLayer)
+                    this.currentRouteLayer = fromLayer;
+                else if (toLayer)
+                    this.currentRouteLayer = toLayer;
+            }
+            if (resetList && route?.from && route?.to)
+                sendEventToGa(GaEventActions.ClickDirections, `${route?.from ? 'From ' + route.from.name : ''} ${route?.to ? 'To ' + route.to.name : ''}`);
+        });
+        if (immediate)
+            applyDetails();
+        else
+            setTimeout(applyDetails, 200);
+    }
+    /** Rebuilds the current route with the live position as FROM, applied immediately (no 200ms defer) */
+    rebuildRouteFromPosition(newFrom) {
+        const selectedRoute = uiState.selectedRoute;
+        if (!selectedRoute?.to)
+            return;
+        this.selectRoute(new Route(newFrom, selectedRoute.to, selectedRoute.waypoints), false, true);
+    }
+    /** Default FROM for `selectRoute` when only TO is given. Priority: CP > kiosk anchor > none. */
+    resolveFallbackFrom() {
+        if (this.currentPosition) {
+            return toArbitraryPoint(this.currentPosition, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID);
+        }
+        const kiosk = uiState.kioskData;
+        if (!kiosk)
+            return null;
+        return toArbitraryPoint({ x: kiosk.x, y: kiosk.y, z: kiosk.z ?? undefined }, getKioskName(), KIOSK_ANCHOR_POINT_ID);
+    }
+    setStartPoint(booth) {
+        const currentRoute = uiState.selectedRoute;
+        if (currentRoute?.to && !currentRoute?.from && booth) {
+            const updatedRoute = new Route(booth, currentRoute.to, currentRoute.waypoints);
+            this.selectRoute(updatedRoute);
+        }
+    }
+    get pathLayers() {
+        const layers = store.routeStore.routeLines
+            ?.map((line) => line.p0.layer)
+            ?.filter((name, i, self) => self.indexOf(name) === i);
+        return routeSteps(layers ?? [], this.campusLayersBox.get(), (name) => Boolean(store.layerStore.findLayer(name))).map((name, i) => ({ id: i + 1, layer: store.layerStore.findLayer(name) }));
+    }
+    /**
+     * Used only by the SDK `getBooth(RouteWaypoint)` path for coord-form
+     * waypoints (`floorplan.ready.tsx`). Internal callers prefer
+     * `toArbitraryPoint(currentPosition, ...)` — graph snap happens inside the
+     * engine, no booth proxy needed.
+     */
+    getNearestBooth(position) {
+        if (!position)
+            return null;
+        const layerExists = this.rootStore.layerStore.findLayer(position.z);
+        const gpsConfig = getFpGeo()?.properties.config;
+        const isGpsFix = Boolean(position.lat && position.lng);
+        const localPoint = gpsConfig && isGpsFix ? convertGpsToLocal(position, gpsConfig) : position;
+        // A fix the plan cannot place — invalid coordinates, a GPS pair on a plan without geo
+        // referencing, or one far outside the venue — has no nearest booth to give.
+        if (!localPoint || !isValidPointCoords(localPoint.x) || !isValidPointCoords(localPoint.y)) {
+            return null;
+        }
+        return (this.rootStore.boothStore.booths
+            .filter((b) => {
+            if (layersStore.mode === LayersMode.Default || !layerExists) {
+                return b.visible && b.rect;
+            }
+            else {
+                return (b.rect &&
+                    ((typeof position.z !== 'number' && !position.z && b.visible) ||
+                        layerExists.name === b.layer?.name));
+            }
+        })
+            .sort((b1, b2) => pointDistance(localPoint, b1.rect.center) - pointDistance(localPoint, b2.rect.center))[0] || null);
+    }
+    setMarkers(data) {
+        this.markersData.markers = (data?.markers ?? []).map(normalizeMarker);
+        this.markersData.icons = data?.icons ?? [];
+    }
+    selectMarker(id, focus) {
+        const marker = this.markersData.markers.find((marker) => marker.id === id);
+        this.markersData.markers.forEach((marker) => (marker.active = false));
+        if (marker) {
+            marker.active = true;
+        }
+        const layer = store.layerStore.findLayer(marker?.z);
+        if (focus && marker) {
+            if (layer && !layer?.visible)
+                layersStore.updateVisibility(layer, true);
+            const camera = mapCamera();
+            if (camera) {
+                // NOTE: mobx makes SDK response too long that's why direct engine promise applied here
+                return camera.api.panTo({ x: marker.x, y: marker.y });
+            }
+            logger.warn('Map camera is not mounted. Cannot pan to marker.');
+            return Promise.resolve();
+        }
+        return Promise.resolve();
+    }
+    get selectedMarkers() {
+        return this.markersData.markers.filter((marker) => marker.active);
+    }
+    get layers() {
+        const layers = [];
+        store.routeStore.routeLines
+            ?.map((rl) => rl.p0.layer)
+            .forEach((l) => {
+            if (layers.indexOf(l) === -1)
+                layers.push(l);
+        });
+        return layers
+            .map((l) => store.layerStore.layers.find((layer) => layer.name === l))
+            .filter((layer) => !!layer);
+    }
+    clickRoute(from, to) {
+        if (window['__resett'])
+            window['__resett']();
+        this.rootStore.uiState.menu = false;
+        if (uiState.list.type === 'route-planner') {
+            uiState.list = { type: 'search', text: '', focused: false };
+        }
+        this.selectRoute(new Route(from, to));
+        // if (this.rootStore.uiState.onDirection) {
+        //     const e: FloorPlanDirectionEvent = {
+        //         from: undefined,
+        //         to: undefined,
+        //         lines: [],
+        //         distance: "",
+        //         time: 0,
+        //     };
+        //     this.rootStore.uiState.onDirection(e);
+        // }
+        //this.showMap();
+    }
+    selectCurrentPosition(point, focus = true, icon) {
+        clearTimeout(this.cpTimeout);
+        if (point) {
+            point.x = replaceCommasWithDot(point.x);
+            point.y = replaceCommasWithDot(point.y);
+            if (point.lat !== undefined)
+                point.lat = replaceCommasWithDot(point.lat);
+            if (point.lng !== undefined)
+                point.lng = replaceCommasWithDot(point.lng);
+            // A numeric `z` is a floor index (as `LayerStore.findLayer` reads a number). With
+            // `ignoreUnknownFloorIndex`, one with no floor at it reports no floor, rather than one whose
+            // name merely holds the number (13 → Hall13).
+            const floors = this.rootStore.layerStore.layers.filter((layer) => !layer.rootParent && !layer.frozen);
+            const noFloorAtIndex = typeof point.z === 'number' && !floors[point.z];
+            if ((data.ignoreUnknownFloorIndex === true && noFloorAtIndex) || !areLayersEnabled()) {
+                point.z = undefined;
+            }
+        }
+        // requested in EFP-5062 by SW do not focus on CC position if details is open, but if details is open by route - focus as usual
+        const isDetailsMode = focus && this.rootStore.uiState.details && !(this.rootStore.uiState.details instanceof Route);
+        const effectiveFocus = focus && !isDetailsMode && (this.focusEnabled || this.prevZ != point?.z);
+        if (this.focusEnabled)
+            this.focusEnabled = false;
+        this.prevZ = point?.z?.toString() ?? null;
+        this.iconType = icon ? 1 : 0;
+        const position = point ? mapCurrentPosition(point) : null;
+        if (!point || !position) {
+            this.currentPosition = null;
+            return;
+        }
+        // Floors belong to venues: a fix outside every venue outline stands on none, whatever floor it
+        // reports and whichever floor the route is on. A floor it is not on would scope it to that
+        // hall — read as off a route that is right under it, and start a route from inside the hall.
+        const venueStore = this.rootStore.venueStore;
+        const outdoors = !!venueStore?.hasVenueModel && !venueStore.venueAt(position);
+        const layer = outdoors ? null : store.layerStore.findLayer(point.z);
+        const newPosition = new CurrentPosition(position.x, position.y, outdoors ? undefined : layer?.name || this.currentRouteLayer?.name, calculateRelativeBearing(position), point.lat, point.lng);
+        let isPositionAndRouteOnTheSameLayer = !this.routeLines?.length;
+        if (layer && this.routeLines?.length) {
+            isPositionAndRouteOnTheSameLayer = !!this.routeLines.find((line) => line.p0.layer === layer.name || line.p1.layer === layer.name);
+        }
+        const shouldFocus = effectiveFocus && isPositionAndRouteOnTheSameLayer;
+        // Store the fix before any camera work: the renderer may not be ready to
+        // move yet, but the position (and the re-centre button it enables) must
+        // never be dropped because of that.
+        this.currentPosition = newPosition;
+        if (shouldFocus)
+            this.focusOnPosition(newPosition, layer);
+        // Note: if data send by Crowd Connected (data.enableIPS) position should be reset after 30s of inactivity
+        if (!this.gpsEnabled) {
+            this.cpTimeout = setTimeout(() => {
+                if (this.currentPosition)
+                    this.selectCurrentPosition(null, false);
+            }, 30 * 1000);
+        }
+    }
+    findLocation() {
+        if (!this.canFindLocation)
+            return;
+        const target = this.currentPosition ?? uiState.kioskData;
+        if (!target)
+            return;
+        if (this.currentPosition) {
+            const compassGranted = localStorage.getItem(ORIENTATION_GRANTED_KEY);
+            if (compassGranted === 'false')
+                store.routeStore.requestCompass = true;
+        }
+        // Both renderers: bring the target's floor on screen, then frame the target — the same
+        // rect either way, so re-centre lands on the same close-up whatever the camera was doing.
+        // The MapLibre path used to skip the floor switch and only re-centre the camera, keeping
+        // the zoom, so from a zoomed-out view it left the dot a speck in the middle.
+        this.pendingReveal?.();
+        this.pendingReveal = revealLayer({
+            layer: store.layerStore.findLayer(target.z),
+            show: (layer) => layersStore.updateVisibility(layer, true),
+            then: () => {
+                uiState.moveToRect = this.findLocationRect(target);
+            },
+        });
+    }
+    /** The dot, plus — when it lies outside the drawing — enough of the nearest map edge for context. */
+    findLocationRect(target) {
+        const dotRect = Box.fromCenter(target, { x: 100, y: 100 });
+        const svgArea = getSvgArea();
+        if (dotRect.intersects(svgArea))
+            return dotRect;
+        const nearX = Math.max(svgArea.min.x, Math.min(target.x, svgArea.max.x));
+        const nearY = Math.max(svgArea.min.y, Math.min(target.y, svgArea.max.y));
+        const contextSize = Math.min(svgArea.size.width, svgArea.size.height) * 0.3;
+        const mapSlice = Box.fromCenter({ x: nearX, y: nearY }, { x: contextSize, y: contextSize }).intersection(svgArea);
+        // boxIntersection returns null on a miss (legacy getIntersection returned a
+        // zero rect). The context slice is clamped to the nearest svgArea edge so it
+        // always overlaps; guard the null case so we still union something sensible.
+        return mapSlice ? Box.fromUnion(dotRect, mapSlice) : dotRect;
+    }
+    /**
+     * Focus for a position update (first fix, or the dot changing floor): bring
+     * its floor on screen, then move the camera onto it keeping the zoom —
+     * `panTo` in the floor plan renderer; under MapLibre the renderer camera is
+     * an external-mode no-op stub, so the move goes through the adapter's
+     * `moveToLocation` reaction instead (which zooms in when a venue floor needs
+     * it to show indoor detail). Waits for the floor to be visible first
+     * (see `revealLayer`).
+     */
+    focusOnPosition(position, layer) {
+        this.pendingReveal?.();
+        this.pendingReveal = revealLayer({
+            layer,
+            show: (l) => layersStore.updateVisibility(l, true),
+            then: () => {
+                if (store.maplibreStore.showMaplibre) {
+                    uiState.moveToLocation = true;
+                    return;
+                }
+                const camera = mapCamera();
+                if (camera) {
+                    void camera.api.panTo({ x: position.x, y: position.y });
+                    return;
+                }
+                logger.warn('Map camera is not mounted. Cannot pan to current position.');
+            },
+        });
+    }
+    get routeInfo() {
+        const distance = this.routeDistance;
+        const units = this.routeUnits;
+        if (!distance) {
+            return null;
+        }
+        return {
+            distance: `${distance}${units}`,
+            units,
+            time: calcTravelTime(distance, calcSpeed(units)),
+        };
+    }
+    /**
+     * The route the wayfinding engine last routed — the one `routeLines` describe.
+     * A route is selected before the engine routes it, so until this matches
+     * `uiState.selectedRoute` the lines on hand say nothing about the selected pair.
+     */
+    get routedRoute() {
+        return this.routedRouteBox.get();
+    }
+    markRouted(route) {
+        this.routedRouteBox.set(route);
+    }
+    updateRoute(routeLines, campusLayers = []) {
+        if (!routeLines?.length && !this.routeLines.length)
+            return;
+        this.campusLayersBox.set(new Set(campusLayers));
+        this.routeLines = routeLines;
+        this.updateRoutePoints();
+    }
+    updateRouteDistance(distance) {
+        if (distance == null)
+            return;
+        const l = getLayerSvg();
+        const units = (l.getAttribute('units') || DEFAULT_UNITS).toLowerCase?.().trim();
+        const isNewVersion = l.getAttribute('fp-ver')?.startsWith('5') ?? false;
+        this.routeDistance = Math.round(distance / (isNewVersion ? 1 : 10.0));
+        this.routeUnits = units;
+        this.updateRoutePoints();
+    }
+    updateRoutePoints() {
+        const route = uiState.selectedRoute;
+        const distance = this.routeDistance;
+        const units = this.routeUnits;
+        if (store.fp.onDirection)
+            setTimeout(() => {
+                store.fp.onDirection({
+                    from: getDirectionPoint(route?.from ?? null),
+                    to: getDirectionPoint(route?.to ?? null),
+                    lines: this.routeLines,
+                    distance: distance == null ? '' : `${distance}${units}`,
+                    units,
+                    time: calcTravelTime(distance ?? 0, calcSpeed(units)),
+                });
+            }, 200);
+    }
+    checkRoutes() {
+        if (!isWayfindingReady()) {
+            console.warn('checkRoutes: wayfinding is not initialized — call createWayfinding() first. Skipping route check.');
+            return;
+        }
+        const booths = store.boothStore.booths;
+        console.info(`Route check started  ${booths.length}.... `);
+        for (let i = 0; i < booths.length; i++) {
+            const from = booths[i];
+            for (let j = i + 1; j < booths.length; j++) {
+                const to = booths[j];
+                const route = buildRoute(boothToEndpoint(from), boothToEndpoint(to));
+                if (!route.lines.length) {
+                    console.warn(`No route found from ${from.name} to ${to.name}`);
+                }
+            }
+        }
+        console.info('Route check done....');
+    }
+    setGpsTrackingEnabled(value) {
+        this.isGpsTrackingEnabled = value;
+    }
+    get gpsEnabled() {
+        return data.autoTrackingGps && this.isGpsTrackingEnabled && !data.enableIPS;
+    }
+    setOnlyAccessible(value) {
+        this.onlyAccessible = value;
+    }
+}
+__decorate([
+    observable
+], RouteStore.prototype, "routeLines", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "routeDistance", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "currentPosition", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "requestCompass", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "iconType", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "tempToBooth", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "focusEnabled", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "prevZ", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "markersData", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "prevMarkers", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "showAccessible", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "onlyAccessible", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "currentRouteLayer", void 0);
+__decorate([
+    observable
+], RouteStore.prototype, "currentRouteExhibitor", void 0);
+__decorate([
+    computed
+], RouteStore.prototype, "canFindLocation", null);
+__decorate([
+    action
+], RouteStore.prototype, "selectRoute", null);
+__decorate([
+    action
+], RouteStore.prototype, "rebuildRouteFromPosition", null);
+__decorate([
+    action
+], RouteStore.prototype, "setStartPoint", null);
+__decorate([
+    computed({ keepAlive: true })
+], RouteStore.prototype, "pathLayers", null);
+__decorate([
+    action
+], RouteStore.prototype, "setMarkers", null);
+__decorate([
+    action
+], RouteStore.prototype, "selectMarker", null);
+__decorate([
+    computed({ keepAlive: true })
+], RouteStore.prototype, "selectedMarkers", null);
+__decorate([
+    computed({ keepAlive: true })
+], RouteStore.prototype, "layers", null);
+__decorate([
+    action
+], RouteStore.prototype, "clickRoute", null);
+__decorate([
+    action
+], RouteStore.prototype, "selectCurrentPosition", null);
+__decorate([
+    action
+], RouteStore.prototype, "findLocation", null);
+__decorate([
+    observable
+], RouteStore.prototype, "routeUnits", void 0);
+__decorate([
+    computed
+], RouteStore.prototype, "routeInfo", null);
+__decorate([
+    action
+], RouteStore.prototype, "markRouted", null);
+__decorate([
+    action
+], RouteStore.prototype, "updateRoute", null);
+__decorate([
+    action
+], RouteStore.prototype, "updateRouteDistance", null);
+__decorate([
+    action
+], RouteStore.prototype, "updateRoutePoints", null);
+__decorate([
+    action
+], RouteStore.prototype, "checkRoutes", null);
+__decorate([
+    observable
+], RouteStore.prototype, "isGpsTrackingEnabled", void 0);
+__decorate([
+    action
+], RouteStore.prototype, "setGpsTrackingEnabled", null);
+__decorate([
+    computed({ keepAlive: true })
+], RouteStore.prototype, "gpsEnabled", null);
+__decorate([
+    action
+], RouteStore.prototype, "setOnlyAccessible", null);
+/**
+ * A route endpoint's layer NAME: a booth carries the `Layer` object, an
+ * `ArbitraryPoint` carries the name already.
+ */
+export function getLayerName(endpoint) {
+    if (!endpoint)
+        return undefined;
+    return endpoint instanceof BoothBase ? endpoint.layer?.name : endpoint.layer;
+}
+/** Resolve a route endpoint to its `Layer` object — booth carries it as a
+ *  reference, an `ArbitraryPoint` only has the layer name and needs a lookup. */
+function resolveLayerObject(layerStore, endpoint) {
+    if (!endpoint)
+        return null;
+    if (endpoint instanceof BoothBase)
+        return endpoint.layer ?? null;
+    return layerStore.findLayer(endpoint.layer);
+}
+function normalizeMarker(dot) {
+    return {
+        ...dot,
+        x: replaceCommasWithDot(dot.x),
+        y: replaceCommasWithDot(dot.y),
+        lat: dot.lat === undefined ? undefined : replaceCommasWithDot(dot.lat),
+        lng: dot.lng === undefined ? undefined : replaceCommasWithDot(dot.lng),
+    };
+}
+function mapCurrentPosition(position) {
+    const fpConfig = getFpGeo()?.properties.config ?? null;
+    let point = null;
+    if (fpConfig && boxContainsPoint({ min: fpConfig.p0, max: fpConfig.p2 }, position)) {
+        point = { ...position };
+    }
+    else if (fpConfig && isValidPointCoords(position.lat) && isValidPointCoords(position.lng)) {
+        point = convertGpsToLocal(position, fpConfig);
+    }
+    else if (!fpConfig) {
+        point = position;
+    }
+    if (!point)
+        return null;
+    return point;
+}
+export function findBooth(str) {
+    return store.boothStore.findBooth(str) || store.exhibitorStore.findExhibitor(str)?.booths[0];
+}
+export function findEntityByExternalId(externalId) {
+    const booth = store.boothStore.boothByExternalId.get(externalId);
+    if (booth) {
+        return { type: 'booth', entity: booth };
+    }
+    const exhibitor = store.exhibitorStore.exhibitorByExternalId.get(externalId);
+    if (exhibitor) {
+        return { type: 'exhibitor', entity: exhibitor };
+    }
+    return undefined;
+}
+export function separateExternalIds(externalIds) {
+    const boothExternalIds = [];
+    const exhibitorExternalIds = [];
+    for (const id of externalIds) {
+        const entity = findEntityByExternalId(id);
+        if (entity) {
+            if (entity.type === 'booth') {
+                boothExternalIds.push(id);
+            }
+            else {
+                exhibitorExternalIds.push(id);
+            }
+        }
+    }
+    return { boothExternalIds, exhibitorExternalIds };
+}
+export function extractRoute(from, to, waypoints) {
+    return new Route(findBooth(from) ?? null, findBooth(to) ?? null, waypoints?.map((w) => findBooth(w)).filter((booth) => !!booth));
+}
+export class Route {
+    constructor(from, to, waypoints) {
+        this.from = from;
+        this.to = to;
+        this.waypoints = waypoints;
+        const fromId = from instanceof BoothBase ? from.id : undefined;
+        const toId = to instanceof BoothBase ? to.id : undefined;
+        this.waypoints = waypoints?.filter((wp) => wp && wp.id !== fromId && wp.id !== toId);
+    }
+}
+function getDirectionPoint(value) {
+    if (!value)
+        return null;
+    return value instanceof BoothBase
+        ? {
+            id: value.id,
+            name: value.name,
+            externalId: value.externalId,
+            layer: { name: value.layer?.name, description: value.layer?.description },
+        }
+        : {
+            id: Number.MAX_SAFE_INTEGER,
+            name: value.name,
+            externalId: undefined,
+            layer: { name: value.layer, description: undefined },
+        };
+}
+/** Where the blue dot is: plan coordinates, the floor it sits on, and the bearing it faces. */
+export class CurrentPosition {
+    constructor(x, y, z, angle, lat, lng) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.angle = angle;
+        this.lat = lat;
+        this.lng = lng;
+    }
+}