@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/floorplan.ready.js

@@ -0,0 +1,1093 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from '@expofp/geometry';
+import { CameraSchema, SessionsFiltersSchema, } from '@expofp/schema';
+import { optimizeWaypointOrder } from '@expofp/wayfinding';
+import { ErrorBoundary as SentryErrorBoundary } from '@sentry/react';
+import debug from 'debug';
+import { reaction, runInAction } from 'mobx';
+import { createRoot } from 'react-dom/client';
+import { install } from 'resize-observer';
+import Layout from './components/Layout';
+import { bindBoothHitTest } from './components/Map/booth-by-xy.js';
+import { MAX_ROUTE_WAYPOINTS } from './constants';
+import data from './data';
+import { getFpGeo } from './data/fpGeo.js';
+import FloorPlanLoader from './floorplan.loader';
+import { shouldLoadIntercom } from './intercom';
+import { registerPlanDisposer } from './plan-lifecycle.js';
+import { BoundsSchema, POISelectorsSchema, ZoomToOptionsSchema } from './schemas/sdk.schemas';
+import { applyDeclarativeConfig, applyParameters, applyPathway, initUrlRouting, } from './services/url-dispatch';
+import store, { uiState } from './store';
+import { bindDetailsEvents } from './store/details-events';
+import { bindRootElement } from './store/init/init-ui.js';
+import { bindJourneyProgress } from './store/journey-plan';
+import { findBooth, Route, separateExternalIds, } from './store/RouteStore';
+import { toPublicVenue } from './store/venue-public';
+import { GaEventActions, initGtag, sendEventToGa, setConsentSettings } from './tools/gtag.js';
+import { queuePositionTelemetry, sendSdkTelemetry } from './tools/sdk-telemetry.js';
+import settings from './tools/settings';
+import trackEvent from './tools/track-event.js';
+import { cameraToMapSettings, mapSettingsToCamera } from './utils/camera-map-settings';
+import { getStorage } from './utils/entity-storage';
+import { getMostFrequent } from './utils/getMostFrequent';
+import { convertLocalToGps, isValidPointCoords } from './utils/gps';
+import { getLocales, hasLocale, setLocale } from './utils/i18n';
+import { mapEntity } from './utils/mapEntity';
+const log = debug('efp:api');
+install();
+export default class FloorPlanReady extends FloorPlanLoader {
+    init() {
+        // First, so anything below that sends a GA event finds the property configured.
+        initGtag();
+        // the declarative config nodes apply in every mode — `ignoreQuery` gates
+        // only the URL parsing and sync (loadConfig already kept the URL slice
+        // out of the config under it)
+        applyDeclarativeConfig();
+        if (!this.ignoreQuery) {
+            initUrlRouting(this.offHistory);
+        }
+        trackEvent('load');
+        sendSdkTelemetry('load');
+        // `initUi` already bound the container the loader created; re-point before
+        // the UI mounts so the measurement is taken against the render target this
+        // instance actually uses.
+        bindRootElement(store);
+        store.fp = this;
+        // The SDK's onDetails event follows the store, not any renderer, so it is bound with the rest
+        // of the instance wiring — it must fire in the MapLibre embed too, where the plan's own map is
+        // unmounted entirely.
+        registerPlanDisposer(bindDetailsEvents());
+        // The pointer seam's geometry hit test follows the stores for as long as the plan lives — in
+        // both map modes, which is why it binds here rather than under either map component.
+        bindBoothHitTest();
+        setConsentSettings(this.consent);
+        sendEventToGa(GaEventActions.Load, ``);
+        this.root = createRoot(this.renderTarget);
+        this.root.render(_jsx(SentryErrorBoundary, { children: _jsx(Layout, { offHistory: this.offHistory, consent: this.consent }) }));
+        sendEventToGa(GaEventActions.Rendered, ``);
+        registerPlanDisposer(reaction(() => store.layerStore.layersLoaded, () => {
+            // The loader's spinner and anything else the host left in the element, cleared here
+            // rather than before `init()`: this is the latest point the SDK knows about, and it is
+            // some 300ms closer to the frame that first draws the plan. Runs before `resolveReady`,
+            // so a caller awaiting `ready` still finds the element holding the plan alone.
+            //
+            // The shadow container is the one child to keep. It is reached through the render target
+            // rather than remembered, because that is where the loader put it: the render target is
+            // the shadow root's only child, and the container's own child when the shadow DOM is off.
+            const root = this.renderTarget.getRootNode();
+            const shadowContainer = root instanceof ShadowRoot ? root.host : this.renderTarget.parentElement;
+            // TODO: legacy, remove in 1/1/2021
+            document.querySelectorAll('.expofp-floorplan-loader').forEach((x) => x.remove());
+            // Guarded: a render target with no parent would make the loop below take the plan's own
+            // container with it.
+            while (shadowContainer &&
+                this.element.firstChild &&
+                this.element.firstChild !== shadowContainer) {
+                this.element.removeChild(this.element.firstChild);
+            }
+            this.resolveReady();
+            if (!store.initialized) {
+                // this._addCustomCss();
+                this.onInit?.(this);
+            }
+            store.initialized = true;
+        }));
+        // a pending toast dismissal would wake up in the dead window and read the
+        // store barrel, which throws there by design
+        registerPlanDisposer(() => clearTimeout(showSdkErrorTimer));
+        // Cross-venue journeys walk the visitor through their legs from here: the
+        // panel and the map only present what this keeps in step.
+        registerPlanDisposer(bindJourneyProgress());
+        const intercomCtx = shouldLoadIntercom(data);
+        if (intercomCtx) {
+            import('./intercom/bootIntercom')
+                .then(({ bootIntercom }) => bootIntercom(intercomCtx))
+                .catch(() => {
+                /* empty */
+            });
+        }
+    }
+    selectBooth(nameOrExternalId) {
+        if (typeof nameOrExternalId !== 'string' && !Array.isArray(nameOrExternalId)) {
+            showSdkError('selectBooth', 'Parameter must be a string or an array of strings.', 'EFP000000');
+            return;
+        }
+        const booths = store.boothStore.booths.filter((b) => {
+            if (typeof nameOrExternalId === 'string') {
+                return b.name === nameOrExternalId || b.externalId === nameOrExternalId;
+            }
+            return nameOrExternalId.includes(b.name) || nameOrExternalId.includes(b.externalId);
+        });
+        store.selectBooth(booths);
+    }
+    selectExhibitor(nameOrExternalId) {
+        if (typeof nameOrExternalId !== 'string' && !Array.isArray(nameOrExternalId)) {
+            showSdkError('selectExhibitor', 'Parameter must be a string or an array of strings.', 'EFP000100');
+            return;
+        }
+        if (!nameOrExternalId?.length) {
+            store.uiState.menu = false;
+            store.searchStore.resetSearchBox();
+            store.uiState.details = null;
+            return;
+        }
+        const exhibitors = store.exhibitorStore.exhibitors.filter((exh) => {
+            if (typeof nameOrExternalId === 'string') {
+                return exh.name === nameOrExternalId || exh.externalId === nameOrExternalId;
+            }
+            return nameOrExternalId.includes(exh.name) || nameOrExternalId.includes(exh.externalId);
+        });
+        if (!exhibitors?.length)
+            return;
+        if (typeof nameOrExternalId === 'string') {
+            store.selectExhibitor(exhibitors[0]);
+            store.moveToList([exhibitors[0]]);
+            return;
+        }
+        const layers = exhibitors.flatMap((exhibitor) => exhibitor.booths.map((booth) => booth.layer));
+        // undefined when every matched exhibitor is booth-less — no floor to switch to
+        const mostFrequent = getMostFrequent(layers.map((layer) => layer.description));
+        if (mostFrequent) {
+            store.layerStore.updateVisibility(mostFrequent, true);
+        }
+        store.uiState.menu = false;
+        store.searchStore.resetSearchBox();
+        store.uiState.details = null;
+        store.uiState.list = {
+            type: 'filter',
+            items: exhibitors,
+            // display names, not external ids — the documented comma-separated
+            // `?exhibitors=` form (the encoded-id form is retired)
+            query: { key: 'exhibitors', value: exhibitors.map((exhibitor) => exhibitor.name).join(',') },
+        };
+        store.moveToList();
+    }
+    highlightExhibitors(externalIds) {
+        if (!Array.isArray(externalIds)) {
+            showSdkError('highlightExhibitors', 'Parameter must be an array of strings.', 'EFP000200');
+        }
+        store.boothStore.highlightedByExternalIds = [];
+        // @ts-expect-error -- the legacy ExhibitorStore (@ts-nocheck) infers this field as never[]
+        store.exhibitorStore.highlightedByExternalIds = [...externalIds];
+    }
+    highlightBooths(externalIds) {
+        if (!Array.isArray(externalIds)) {
+            showSdkError('highlightBooths', 'Parameter must be an array of strings.', 'EFP000300');
+        }
+        store.exhibitorStore.highlightedByExternalIds = [];
+        // @ts-expect-error -- the legacy BoothStore (@ts-nocheck) infers this field as never[]
+        store.boothStore.highlightedByExternalIds = [...externalIds];
+    }
+    highlightEntities(externalIds) {
+        if (!Array.isArray(externalIds)) {
+            showSdkError('highlightEntities', 'Parameter must be an array of strings.', 'EFP000400');
+        }
+        const { boothExternalIds, exhibitorExternalIds } = separateExternalIds(externalIds);
+        // @ts-expect-error -- the legacy BoothStore (@ts-nocheck) infers this field as never[]
+        store.boothStore.highlightedByExternalIds = [...boothExternalIds];
+        // @ts-expect-error -- the legacy ExhibitorStore (@ts-nocheck) infers this field as never[]
+        store.exhibitorStore.highlightedByExternalIds = [...exhibitorExternalIds];
+    }
+    selectRoute(startOrWaypoints, to) {
+        if (Array.isArray(startOrWaypoints)) {
+            const points = [...startOrWaypoints];
+            const from = points.shift();
+            const to = points.pop();
+            if (points.length > MAX_ROUTE_WAYPOINTS) {
+                throw new Error(`The maximum number of waypoints is ${MAX_ROUTE_WAYPOINTS}.`);
+            }
+            if (!from || !to) {
+                showSdkError('selectRoute', 'Invalid route format: When providing an array, it must include at least two points: a start and a destination.', 'EFP000401');
+                return;
+            }
+            const waypointBooths = points.map(getBooth).filter((booth) => booth !== null);
+            store.routeStore.selectRoute(new Route(getBooth(from), getBooth(to), waypointBooths));
+            return;
+        }
+        if (!startOrWaypoints) {
+            showSdkError('selectRoute', 'At a minimum, the starting point must be passed.', 'EFP000402');
+        }
+        store.routeStore.selectRoute(new Route(getBooth(startOrWaypoints), to ? getBooth(to) : null));
+    }
+    getOptimizedRoutes(waypoints) {
+        if (!Array.isArray(waypoints)) {
+            showSdkError('getOptimizedRoutes', 'Parameter must be an array.', 'EFP000500');
+            return [];
+        }
+        if (waypoints.length > MAX_ROUTE_WAYPOINTS) {
+            throw new Error(`The maximum number of waypoints is ${MAX_ROUTE_WAYPOINTS}.`);
+        }
+        const booths = waypoints.map(getBooth).filter((booth) => Boolean(booth));
+        if (!booths.length) {
+            throw new Error('No booths found for the provided waypoints.');
+        }
+        const grouped = new Map();
+        for (const booth of booths) {
+            const key = booth.layer?.name ?? '';
+            const group = grouped.get(key);
+            if (group)
+                group.push(booth);
+            else
+                grouped.set(key, [booth]);
+        }
+        return Array.from(grouped.values()).map((group) => ({
+            waypoints: optimizeWaypointOrder(group.map((b) => [b.name, { x: b.rect.center.x, y: b.rect.center.y }])),
+        }));
+    }
+    selectCurrentPosition(point, focus, icon) {
+        const hasXY = isValidPointCoords(point.x) && isValidPointCoords(point.y);
+        const hasLatLng = isValidPointCoords(point.lng) && isValidPointCoords(point.lat);
+        if (!hasXY && !hasLatLng) {
+            showSdkError('selectCurrentPosition', 'A point must be passed. Either (x,y) or (lat,lng) are required.', 'EFP000600');
+        }
+        // the arguments as the host passed them: the store normalizes the point in place
+        const params = { point: { ...point }, focus, icon };
+        store.routeStore.selectCurrentPosition(point, focus, icon);
+        queuePositionTelemetry({
+            ...params,
+            floor: store.routeStore.currentPosition?.z ?? null,
+            routeFloor: store.routeStore.currentRouteLayer?.name ?? null,
+            placed: !!store.routeStore.currentPosition,
+        });
+        this.onCurrentPositionChanged?.(point);
+    }
+    setBookmarks(bookmarks) {
+        if (!Array.isArray(bookmarks) || !bookmarks.length) {
+            showSdkError('setBookmarks', 'Parameter must be an array.', 'EFP000700');
+        }
+        bookmarks.forEach((b) => {
+            const e = store.exhibitorStore.exhibitors.find((e) => e.name === b.name || e.externalId === b.externalId);
+            if (e)
+                e.bookmarked = b.bookmarked;
+        });
+    }
+    setEntitiesBookmarks(bookmarks) {
+        if (!Array.isArray(bookmarks) || !bookmarks.length) {
+            showSdkError('setEntitiesBookmarks', 'Parameter must be an array.', 'EFP000701');
+            return;
+        }
+        const VALID_TYPES = ['exhibitor', 'event', 'speaker', 'booth'];
+        const invalidBookmark = bookmarks.find((b) => !b.type || !VALID_TYPES.includes(b.type));
+        if (invalidBookmark) {
+            showSdkError('setEntitiesBookmarks', `Invalid entity type: ${invalidBookmark.type}. Must be one of: ${VALID_TYPES.join(', ')}.`, 'EFP000702');
+            return;
+        }
+        const currentBookmarks = getStorage('bookmarked');
+        const entityConfig = {
+            exhibitor: {
+                existingIds: new Set(currentBookmarks.exhibitors || []),
+                finder: (query) => store.exhibitorStore.findExhibitor(query),
+                replacer: (ids) => store.exhibitorStore.replaceBookmarked(ids),
+            },
+            event: {
+                existingIds: new Set(currentBookmarks.events || []),
+                finder: (query) => store.eventStore.findByNameOrSlug(query),
+                replacer: (ids) => store.eventStore.replaceBookmarked(ids),
+            },
+            speaker: {
+                existingIds: new Set(currentBookmarks.speakers || []),
+                finder: (query) => store.speakerStore.speakers.find((s) => s.name === query || s.externalId === query || s.slug === query),
+                replacer: (ids) => store.speakerStore.replaceBookmarked(ids),
+            },
+            booth: {
+                existingIds: new Set(currentBookmarks.booths || []),
+                finder: (query) => {
+                    const booth = store.boothStore.findBooth(query);
+                    return booth?.exhibitors.length === 0 ? booth : undefined;
+                },
+                replacer: (ids) => store.boothStore.replaceBookmarked(ids),
+            },
+        };
+        bookmarks.forEach((b) => {
+            const config = entityConfig[b.type];
+            const query = b.name || b.externalId || '';
+            const entity = config.finder(query);
+            if (entity) {
+                if (b.bookmarked) {
+                    config.existingIds.add(entity.id);
+                }
+                else {
+                    config.existingIds.delete(entity.id);
+                }
+            }
+            else {
+                console.warn(`Entity not found: ${b.type} with query "${query}"`);
+            }
+        });
+        Object.values(entityConfig).forEach((config) => {
+            config.replacer(Array.from(config.existingIds));
+        });
+    }
+    setEntitiesVisited(entities) {
+        if (!Array.isArray(entities) || !entities.length) {
+            showSdkError('setEntitiesVisited', 'Parameter must be an array.', 'EFP000703');
+            return;
+        }
+        const VALID_TYPES = ['exhibitor', 'event'];
+        const invalidEntity = entities.find((e) => !e.type || !VALID_TYPES.includes(e.type));
+        if (invalidEntity) {
+            showSdkError('setEntitiesVisited', `Invalid entity type: ${invalidEntity.type}. Must be one of: ${VALID_TYPES.join(', ')}.`, 'EFP000704');
+            return;
+        }
+        const currentVisited = getStorage('visited');
+        const entityConfig = {
+            exhibitor: {
+                existingIds: new Set(currentVisited.exhibitors || []),
+                finder: (query) => store.exhibitorStore.findExhibitor(query),
+                replacer: (ids) => store.exhibitorStore.replaceVisited(ids),
+            },
+            event: {
+                existingIds: new Set(currentVisited.events || []),
+                finder: (query) => store.eventStore.findByNameOrSlug(query),
+                replacer: (ids) => store.eventStore.replaceVisited(ids),
+            },
+        };
+        entities.forEach((e) => {
+            const config = entityConfig[e.type];
+            const query = e.name || e.externalId || '';
+            const entity = config.finder(query);
+            if (entity) {
+                if (e.visited) {
+                    config.existingIds.add(entity.id);
+                }
+                else {
+                    config.existingIds.delete(entity.id);
+                }
+            }
+            else {
+                console.warn(`Entity not found: ${e.type} with query "${query}"`);
+            }
+        });
+        Object.values(entityConfig).forEach((config) => {
+            config.replacer(Array.from(config.existingIds));
+        });
+    }
+    setMarkers(markersData) {
+        if (!markersData || !Array.isArray(markersData.icons) || !Array.isArray(markersData.markers)) {
+            showSdkError('setMarkers', 'Invalid input.', 'EFP000800');
+            return;
+        }
+        store.routeStore.setMarkers(markersData);
+    }
+    selectMarker(id, focus = true) {
+        if (typeof id !== 'string') {
+            showSdkError('selectMarker', 'The identifier must be passed.', 'EFP000900');
+        }
+        return store.routeStore.selectMarker(id, focus);
+    }
+    drawCircles(circles) {
+        if (!Array.isArray(circles)) {
+            showSdkError('drawCircles', 'Invalid input.', 'EFP000A00');
+        }
+        store.uiState.debugCircles = circles;
+    }
+    checkRoutes() {
+        store.routeStore.checkRoutes();
+    }
+    updateLayerVisibility(layer, visible) {
+        if (typeof layer !== 'string') {
+            showSdkError('updateLayerVisibility', 'The layer name (string) must be passed.', 'EFP000B00');
+        }
+        if (!visible) {
+            showSdkError('updateLayerVisibility', 'Passing a false value to visible will have no effect.', 'EFP000B01');
+        }
+        store.layerStore.updateVisibility(layer, visible);
+    }
+    getCenterCoordinates() {
+        return store.fp.getCenterCoordinates();
+    }
+    exhibitorsList() {
+        return store.exhibitorStore.exhibitors.map((e) => mapEntity(e));
+    }
+    boothsList() {
+        return store.boothStore.booths.map((b) => mapEntity(b));
+    }
+    categoriesList() {
+        return store.categoryStore.categories.map((c) => mapEntity(c));
+    }
+    selectCategory(nameOrSlug) {
+        if (nameOrSlug == null || typeof nameOrSlug !== 'string') {
+            store.searchStore.selectSearch();
+            return;
+        }
+        const str = nameOrSlug?.toLowerCase();
+        const category = store.categoryStore.categories.find(({ name, slug }) => name?.toLowerCase() === str || slug?.toLowerCase() === str);
+        if (!category) {
+            showSdkError('selectCategory', `Category ${nameOrSlug} not found.`, 'EFP000C01');
+            return;
+        }
+        store.selectCategory(category);
+    }
+    select(slugOrExternalId) {
+        if (typeof slugOrExternalId !== 'string') {
+            showSdkError('select', 'Parameter must be a string.', 'EFP001700');
+            return;
+        }
+        // The deep-link resolution chain, in its historical precedence: booths →
+        // schedule sessions → exhibitors → categories → speakers → search text.
+        const slug = slugOrExternalId;
+        const lower = slug?.toLowerCase();
+        const booth = store.boothStore.booths.find((x) => x.slug?.toLowerCase() === lower ||
+            x.externalId?.toLowerCase() === lower ||
+            x.externalId?.toLowerCase()?.replace(/\s+/g, '') === lower);
+        if (booth) {
+            setTimeout(() => store.selectBooth(booth), 250);
+            return;
+        }
+        const eventItem = store.eventStore.eventItems.find((x) => x.slug?.toLowerCase() === lower || x.externalId?.toLowerCase() === lower);
+        if (eventItem) {
+            store.selectEventItem(eventItem, true);
+            return;
+        }
+        const exhibitor = store.exhibitorStore.exhibitors.find((x) => x.slug?.toLowerCase() === lower || x.externalId?.toLowerCase() === lower);
+        if (exhibitor) {
+            setTimeout(() => store.clickExhibitor(exhibitor), 250);
+            return;
+        }
+        const category = store.categoryStore.categories.find((x) => x.slug === slug);
+        if (category) {
+            store.selectCategory(category);
+            return;
+        }
+        const speaker = store.speakerStore.findBySlug(slug);
+        if (speaker) {
+            store.selectSpeaker(speaker, true);
+            return;
+        }
+        // heatmap mode keeps its tokens in the query — never search text
+        if (!slug.includes('heatmap=true')) {
+            store.searchStore.selectSearch(slug);
+        }
+    }
+    showList(list) {
+        const panels = {
+            bookmarks: () => store.selectBookmarks(),
+            visited: () => store.selectVisited(),
+            sessions: () => store.selectSessions(),
+            exhibitors: () => store.selectExhibitors(),
+            speakers: () => store.selectSpeakers(),
+            tours: () => store.selectTours(),
+            language: () => store.selectLanguage(),
+        };
+        const open = panels[list];
+        if (!open) {
+            showSdkError('showList', `Unknown list "${list}". Must be one of: ${Object.keys(panels).join(', ')}.`, 'EFP001800');
+            return;
+        }
+        open();
+    }
+    showSessions(filters = {}) {
+        log('showSessions called with filters=%O', filters);
+        const filtersResult = SessionsFiltersSchema.safeParse(filters);
+        if (!filtersResult.success) {
+            showSdkError('showSessions', filtersResult.error.message, 'EFP001C00');
+            return;
+        }
+        const validFilters = filtersResult.data;
+        const { eventStore, sessionsFilterStore } = store;
+        // one action, so reactions see only the end state
+        runInAction(() => {
+            // browser back from an open session lands here — the list shows only
+            // once its details close
+            uiState.details = null;
+            store.selectSessions();
+            // edits left unapplied in an open filter panel are dropped, not applied
+            sessionsFilterStore.closeFilter();
+            sessionsFilterStore.setPending('selectedTracks', resolveIds(validFilters.tracks, eventStore.tracks, 'track'));
+            sessionsFilterStore.setPending('selectedVenues', resolveIds(validFilters.venues, eventStore.venues, 'venue'));
+            sessionsFilterStore.setPending('date', validFilters.date ?? 'all');
+            sessionsFilterStore.setPending('timeOfDay', validFilters.time ?? 'all');
+            sessionsFilterStore.setPending('showBookmarksOnly', validFilters.bookmarked ?? false);
+            sessionsFilterStore.setPending('showLiveOnly', validFilters.live ?? false);
+            // not `applyFilters`, which also focuses the search box for the filter
+            // panel's Apply: a link, Back or a host call opens the list as
+            // `?sessions` does
+            sessionsFilterStore.commitFilters();
+        });
+    }
+    selectTour(tourId) {
+        if (typeof tourId !== 'string' || !tourId) {
+            showSdkError('selectTour', 'A tour id must be passed.', 'EFP001900');
+            return;
+        }
+        const tour = store.toursStore.getTourById(tourId);
+        if (tour) {
+            store.toursStore.launchTour(tour, tour.name, tour.description);
+        }
+        else {
+            console.warn(`Route with id "${tourId}" not found`);
+            store.selectTours();
+        }
+    }
+    openPlanner(options = {}) {
+        if (typeof options !== 'object' || options === null) {
+            showSdkError('openPlanner', 'An options object must be passed.', 'EFP001A00');
+            return;
+        }
+        const fromBooth = options.from ? findBooth(options.from) : null;
+        if (options.fromBookmarks) {
+            store.routePlannerStore.launchFromBookmarks(fromBooth ?? undefined);
+        }
+        else {
+            store.routePlannerStore.launchFromSlugs(options.items ?? [], fromBooth ?? undefined);
+        }
+    }
+    startBuildRoute() {
+        store.uiState.startBuildRoute();
+    }
+    applyParameters(queryRaw) {
+        if (typeof queryRaw !== 'string') {
+            showSdkError('applyParameters', 'A query string must be passed.', 'EFP000D00');
+        }
+        applyParameters(queryRaw);
+    }
+    getVisibility() {
+        return store.uiState.visibility;
+    }
+    setVisibility(visibility) {
+        if (typeof visibility !== 'object' || !Object.keys(visibility).length) {
+            showSdkError('setVisibility', 'The parameter must be passed.', 'EFP000E00');
+        }
+        store.uiState.setVisibility(visibility);
+    }
+    findLocation() {
+        store.routeStore.findLocation();
+    }
+    zoomIn() {
+        store.uiState.zoomIn();
+    }
+    zoomOut() {
+        store.uiState.zoomOut();
+    }
+    switchView() {
+        store.maplibreStore.activateMaplibre();
+    }
+    setCamera(camera) {
+        log('setCamera called with camera=%O', camera);
+        const cameraResult = CameraSchema.safeParse(camera);
+        if (!cameraResult.success) {
+            showSdkError('setCamera', cameraResult.error.message, 'EFP001B00');
+            return;
+        }
+        // The mapSettings observable is the "apply once the renderer is ready"
+        // mechanism: the Map component reacts to it and drives the renderer.
+        store.uiState.setMapSettings(cameraToMapSettings(cameraResult.data));
+    }
+    getCamera() {
+        return mapSettingsToCamera(store.uiState.mapSettings);
+    }
+    zoomTo(selectors, options) {
+        log('zoomTo called with selectors=%O options=%O', selectors, options);
+        const selectorsResult = POISelectorsSchema.safeParse(selectors);
+        if (!selectorsResult.success) {
+            showSdkError('zoomTo', selectorsResult.error.message, 'EFP001600');
+            return;
+        }
+        const optionsResult = ZoomToOptionsSchema.safeParse(options);
+        if (!optionsResult.success) {
+            showSdkError('zoomTo', optionsResult.error.message, 'EFP001601');
+            return;
+        }
+        const bounds = this.getBounds(selectors);
+        if (bounds)
+            this.fitBounds(bounds, options);
+    }
+    getBounds(selectors) {
+        log('getBounds called with selectors=%O', selectors);
+        const selectorsResult = POISelectorsSchema.safeParse(selectors);
+        if (!selectorsResult.success) {
+            showSdkError('getBounds', selectorsResult.error.message, 'EFP001400');
+            return;
+        }
+        const boxes = [];
+        selectors.booths?.forEach((s) => {
+            let booth;
+            if (s.externalId) {
+                booth = store.boothStore.boothByExternalId.get(s.externalId);
+            }
+            else if (s.name) {
+                booth = store.boothStore.boothByName.get(s.name.toLowerCase());
+            }
+            if (booth?.rect)
+                boxes.push(booth.rect);
+        });
+        selectors.exhibitors?.forEach((s) => {
+            let exh;
+            if (s.externalId) {
+                exh = store.exhibitorStore.exhibitorByExternalId.get(s.externalId);
+            }
+            else if (s.name) {
+                exh = store.exhibitorStore.exhibitorByName.get(s.name.toLowerCase());
+            }
+            exh?.booths?.forEach((b) => {
+                if (b.rect)
+                    boxes.push(b.rect);
+            });
+        });
+        if (boxes.length === 0)
+            return;
+        const combined = Box.fromUnion(...boxes);
+        return {
+            leftTop: { x: combined.min.x, y: combined.min.y },
+            rightBottom: { x: combined.max.x, y: combined.max.y },
+        };
+    }
+    fitBounds(bounds, options) {
+        log('fitBounds called with bounds=%O options=%O', bounds, options);
+        if (!bounds) {
+            store.uiState.fitBounds();
+            return;
+        }
+        const boundsResult = BoundsSchema.safeParse(bounds);
+        if (!boundsResult.success) {
+            showSdkError('fitBounds', boundsResult.error.message, 'EFP001500');
+            return;
+        }
+        const optionsResult = ZoomToOptionsSchema.safeParse(options);
+        if (!optionsResult.success) {
+            showSdkError('fitBounds', optionsResult.error.message, 'EFP001501');
+            return;
+        }
+        const box = Box.fromMinMax({ x: bounds.leftTop.x, y: bounds.leftTop.y }, { x: bounds.rightBottom.x, y: bounds.rightBottom.y });
+        // Positive padding inflates the box outward on every side, reproducing the
+        // legacy `Rect.fromX1y1x2y2(lt.x - p, lt.y - p, rb.x + p, rb.y + p)` semantics.
+        store.uiState.moveToRect = options?.padding ? box.expand(options.padding) : box;
+    }
+    getBoothRect(name) {
+        if (typeof name !== 'string') {
+            showSdkError('getBoothRect', 'A booth name must be passed.', 'EFP000F00');
+        }
+        const box = findBooth(name)?.rect;
+        // @ts-expect-error -- the public type promises a Rect; an unknown booth has always returned undefined
+        return box ? BoothRect.fromBox(box) : undefined;
+    }
+    convertToGeo(x, y) {
+        const gpsConfig = getFpGeo()?.properties?.config;
+        if (!gpsConfig) {
+            showSdkError('convertToGeo', 'The coordinates cannot be converted because the GPS configuration is not defined.', 'EFP001000');
+            // @ts-expect-error -- the public type has no undefined; a failed conversion has always returned it
+            return;
+        }
+        if (!x || !y) {
+            showSdkError('convertToGeo', 'Both coordinates must be passed.', 'EFP001001');
+            // @ts-expect-error -- the public type has no undefined; a failed conversion has always returned it
+            return;
+        }
+        return convertLocalToGps(x, y, gpsConfig);
+    }
+    getGeoConfig() {
+        const config = getFpGeo()?.properties?.config;
+        if (!config) {
+            return null;
+        }
+        return {
+            bearing: config.bearing ?? 0,
+            p0: config.p0,
+            p1: config.p1,
+            p2: config.p2,
+        };
+    }
+    /**
+     * What this instance owns of the teardown — its React root and the store's
+     * window listeners — run by `FloorPlanLoader.destroy()` while the store
+     * barrel is still live. Everything the plan's services own (URL sync, UI
+     * handlers, GA, telemetry, reactions, timers) registered itself with the
+     * plan when it started, and `disposePlan()` — and with it the dead window —
+     * follows this.
+     */
+    releaseResources() {
+        store.maplibreStore.dispose();
+        this.root?.unmount();
+        // Detaches the listeners, empties the container and clears the element's
+        // in-use marker, so the same element can host a later load().
+        super.releaseResources();
+    }
+    search(term) {
+        if (typeof term !== 'string') {
+            showSdkError('search', 'A search string must be passed.', 'EFP001100');
+        }
+        return store.fuzzySearchEngineStore.loadEngine().then(() => {
+            store.searchStore.selectSearch(term);
+            return store.uiState.fuzzySearchItems.map((x) => ({
+                item: mapEntity(x.item),
+                score: x.score,
+            }));
+        });
+    }
+    getFloors() {
+        // Venue-model plans scope the floor API to effective campus context or the
+        // resolved non-MapLibre fallback venue.
+        const venueStore = store.venueStore;
+        if (venueStore.hasVenueModel) {
+            const venue = venueStore.activeVenue;
+            if (!venue)
+                return [];
+            return venue.levels.map((level) => ({
+                name: level.layer.name,
+                shortName: level.layer.shortName,
+                description: level.layer.description,
+                active: level === venue.activeLevel,
+                disabled: false,
+                index: level.layer.floorIndex ?? level.ordinal,
+                venueId: venue.id,
+                ordinal: level.ordinal,
+                displayName: level.displayName,
+            }));
+        }
+        return store.layerStore.floors.map((floor) => ({
+            name: floor.name,
+            shortName: floor.shortName,
+            description: floor.description,
+            active: floor.active,
+            disabled: floor.disabled,
+            index: floor.index,
+        }));
+    }
+    getVenues() {
+        const venueStore = store.venueStore;
+        if (venueStore.venues.length === 0) {
+            // Single-venue plans report one implicit venue so the shape is uniform.
+            return [implicitVenue()];
+        }
+        const activeVenue = venueStore.activeVenue;
+        return venueStore.orderedVenues.map((venue) => toPublicVenue(venue, venue === activeVenue));
+    }
+    getVenueDiagnostics() {
+        return store.venueStore.diagnostics.map((diagnostic) => ({ ...diagnostic }));
+    }
+    activateVenue(venueId) {
+        if (!venueId?.id) {
+            showSdkError('activateVenue', 'Invalid venueId. It must contain an id.', 'EFP001210');
+            return;
+        }
+        const venueStore = store.venueStore;
+        if (venueStore.venues.length === 0) {
+            // Single-venue plans: the implicit venue `getVenues()` hands out is the
+            // only identifier that resolves, and it is already active — accepting it
+            // is a no-op, not an ignored call.
+            if (isImplicitVenueId(venueId.id))
+                return;
+        }
+        else {
+            const venue = venueStore.findVenue(venueId.id);
+            if (venue) {
+                venueStore.enterVenue(venue);
+                return;
+            }
+        }
+        // One report for both shapes: an identifier that was never issued is
+        // not found on a single-venue plan exactly as it is on a multi-venue one,
+        // so a typo is never swallowed by the plan's shape.
+        showSdkError('activateVenue', `Venue "${venueId.id}" not found.`, 'EFP001211');
+    }
+    activateFloor(floorId) {
+        if (!floorId?.name && floorId?.index == null) {
+            showSdkError('activateFloor', 'Invalid floorId. It must contain either a name or an index.', 'EFP001200');
+            return;
+        }
+        const venueStore = store.venueStore;
+        if (venueStore.hasVenueModel) {
+            let target;
+            if (floorId.name) {
+                for (const venue of venueStore.orderedVenues) {
+                    const level = venue.levels.find((candidate) => candidate.layer.name === floorId.name || candidate.layer.shortName === floorId.name);
+                    if (level) {
+                        target = { venue, level };
+                        break;
+                    }
+                }
+                if (!target) {
+                    showSdkError('activateFloor', `Floor with name "${floorId.name}" not found.`, 'EFP001201');
+                    return;
+                }
+            }
+            else {
+                const venue = venueStore.activeVenue;
+                const floor = this.getFloors().find((candidate) => candidate.index === floorId.index);
+                const level = venue?.levels.find((candidate) => candidate.layer.name === floor?.name);
+                if (!venue || !level) {
+                    showSdkError('activateFloor', `Floor at index ${floorId.index} does not exist.`, 'EFP001203');
+                    return;
+                }
+                target = { venue, level };
+            }
+            venueStore.enterVenue(target.venue, { level: target.level });
+            return;
+        }
+        const floors = this.getFloors();
+        if (floorId.name) {
+            const floor = floors.find((floor) => floor.name === floorId.name || floor.shortName === floorId.name);
+            if (!floor) {
+                showSdkError('activateFloor', `Floor with name "${floorId.name}" not found.`, 'EFP001201');
+                return;
+            }
+            if (floor.active)
+                return;
+            this.updateLayerVisibility(floor.name, true);
+            return;
+        }
+        if (floorId.index !== null) {
+            const floor = floors.find((floor) => floor.index === floorId.index);
+            const layerName = floor?.name;
+            if (!layerName) {
+                showSdkError('activateFloor', `Floor at index ${floorId.index} does not exist.`, 'EFP001203');
+                return;
+            }
+            if (floor.active)
+                return;
+            this.updateLayerVisibility(layerName, true);
+            return;
+        }
+    }
+    showPathway(pathwayId, externalIds) {
+        const { boothExternalIds, exhibitorExternalIds } = externalIds?.length
+            ? separateExternalIds(externalIds)
+            : { boothExternalIds: [], exhibitorExternalIds: [] };
+        applyPathway({ pathwayId, boothIds: boothExternalIds, exhibitorIds: exhibitorExternalIds });
+    }
+    showPathwayOnly(pathwayId, floorId) {
+        this.activateFloor({ name: floorId });
+        store.layerStore.showPathWay(pathwayId);
+        store.uiState.setPathwayOnlyMode(true);
+        const pathwayLayer = store.layerStore.findLayer(pathwayId);
+        const floorLayer = store.layerStore.findLayer(floorId);
+        const targetLayer = pathwayLayer?.rect || pathwayLayer?.viewbox ? pathwayLayer : floorLayer;
+        const targetRect = targetLayer?.viewbox ?? targetLayer?.rect;
+        if (targetRect) {
+            store.uiState.moveToRect = targetRect.clone();
+        }
+    }
+    hidePathways() {
+        this.highlightBooths([]);
+        store.layerStore.hidePathways();
+        store.uiState.setPathwayOnlyMode(false);
+    }
+    showSearch() {
+        store.selectSearch('');
+    }
+    changeLanguage(langId) {
+        const id = langId?.toLowerCase?.();
+        if (!hasLocale(id)) {
+            showSdkError('changeLanguage', `Language "${langId}" was not found. Available languages: ${getLocales()
+                .map((lang) => lang.id)
+                .join(',')}`, 'EFP001300');
+            return;
+        }
+        setLocale(id);
+    }
+    isGpsTrackingEnabled() {
+        return store.routeStore.gpsEnabled;
+    }
+    setGpsTrackingEnabled(value) {
+        store.routeStore.setGpsTrackingEnabled(value);
+    }
+    deselectCurrentPosition() {
+        store.routeStore.selectCurrentPosition(null, false);
+    }
+    deselectRoute() {
+        store.routeStore.selectRoute(null);
+        store.routeStore.setOnlyAccessible(false);
+    }
+    reset() {
+        this.selectBooth('');
+        this.selectExhibitor('');
+        this.selectCategory();
+        this.deselectCurrentPosition();
+        this.deselectRoute();
+        this.highlightEntities([]);
+        if (store.uiState.kioskData && store.resetCameraFn) {
+            store.resetCameraFn?.();
+        }
+        else if (store.venueStore.isCampusMode) {
+            // A campus plan opens on the whole campus; Fit would hold the venue in context.
+            store.venueStore.viewAllVenues();
+        }
+        else {
+            this.fitBounds();
+        }
+    }
+    selectAccessibleRoute(waypoints) {
+        store.routeStore.setOnlyAccessible(true);
+        this.selectRoute(waypoints);
+    }
+}
+/**
+ * The ids of the tracks or venues that `values` name — each value by id, else
+ * by external id, else by name or slug, in any case. A value that names none
+ * is dropped with a console warning.
+ */
+function resolveIds(values = [], entities, kind) {
+    const ids = new Set();
+    for (const value of values) {
+        const lower = value.toLowerCase();
+        const entity = entities.find((candidate) => String(candidate.id) === value) ??
+            entities.find((candidate) => candidate.externalId?.toLowerCase() === lower) ??
+            entities.find((candidate) => candidate.name?.toLowerCase() === lower || candidate.slug?.toLowerCase() === lower);
+        if (entity) {
+            ids.add(entity.id);
+        }
+        else {
+            console.warn(`Entity not found: ${kind} with query "${value}"`);
+        }
+    }
+    return [...ids];
+}
+function getBooth(waypoint) {
+    const booth = typeof waypoint === 'string' ? findBooth(waypoint) : store.routeStore.getNearestBooth(waypoint);
+    return booth ?? null;
+}
+/**
+ * The single venue reported on plans without a venue model, so that both halves
+ * of the public venue API have the same shape everywhere. Built here and used
+ * by `getVenues()` and `activateVenue()` alike — the identifier the list hands
+ * out is exactly the one activation resolves.
+ *
+ * Its `id` is **SDK-synthesised** from the event key: no producer emits it, it
+ * has no wire representation, and it is therefore not bound by the contract's
+ * `[a-z0-9_-]+` identifier pattern (multi-venue data contract §1, §9).
+ */
+function implicitVenue() {
+    return { id: settings.EXPO, name: data.title || settings.EXPO, order: 0, active: true };
+}
+/**
+ * Whether an identifier names the implicit venue. Case-insensitive on both
+ * sides — unlike `VenueStore.findVenue`, which folds only its argument because
+ * an authored `id` already matches `[a-z0-9_-]+`; an event key carries no such
+ * guarantee, and folding one side alone could reject the very id `getVenues()`
+ * just handed the caller.
+ */
+function isImplicitVenueId(id) {
+    return id.toLowerCase() === implicitVenue().id.toLowerCase();
+}
+let showSdkErrorTimer = 0;
+function showSdkError(methodName, message, errorCode) {
+    const title = `Error calling "${methodName}" SDK method.`;
+    const text = `${message.endsWith('.') ? message : message + '.'} More information at`;
+    let link = 'https://js-sdk.expofp.com/api/packages';
+    if (errorCode) {
+        link += `#error-${errorCode}`;
+    }
+    console.error(`${title} ${text} ${link}`);
+    if (store.fp.disableRuntimeAlerts) {
+        return;
+    }
+    store.uiState.setGlobalErrorMessage({
+        title,
+        body: (_jsxs(_Fragment, { children: [text, ' ', _jsx("a", { href: link, target: "_blank", rel: "noreferrer", children: link })] })),
+    });
+    clearTimeout(showSdkErrorTimer);
+    const DELAY_MS = 8000;
+    showSdkErrorTimer = window.setTimeout(() => {
+        const fn = async () => {
+            if (store.uiState.globalErrorMessages.length > 0) {
+                store.uiState.popGlobalErrorMessage();
+                await new Promise((resolve) => setTimeout(resolve, DELAY_MS / 2));
+                fn();
+            }
+        };
+        fn();
+    }, DELAY_MS);
+}
+/**
+ * Backward-compatible return shape of the public `getBoothRect()` API.
+ *
+ * Internally booth footprints are now `@expofp/geometry` `Box`es, but external
+ * SDK consumers of `getBoothRect()` rely on the legacy `core/Rect` instance
+ * surface (`x1/y1/x2/y2`, the `cx/cy/w/h` getters, and the full method set).
+ * This class reproduces that surface exactly and is built from a `Box`'s
+ * `min`/`max` corners at the API boundary. It is intentionally NOT exported, so
+ * no other module can import it — the only way to obtain one is `getBoothRect()`.
+ */
+class BoothRect {
+    get h() {
+        return Math.abs(this.y2 - this.y1);
+    }
+    get w() {
+        return Math.abs(this.x2 - this.x1);
+    }
+    get cx() {
+        return (this.x1 + this.x2) / 2;
+    }
+    get cy() {
+        return (this.y1 + this.y2) / 2;
+    }
+    constructor(x1, y1, x2, y2) {
+        if (x1 > x2) {
+            const x1Orig = x1;
+            x1 = x2;
+            x2 = x1Orig;
+        }
+        if (y1 > y2) {
+            const y1Orig = y1;
+            y1 = y2;
+            y2 = y1Orig;
+        }
+        this.x1 = x1;
+        this.y1 = y1;
+        this.x2 = x2;
+        this.y2 = y2;
+    }
+    static fromBox(box) {
+        return new BoothRect(box.min.x, box.min.y, box.max.x, box.max.y);
+    }
+    static fromCxcywh(cx, cy, w, h) {
+        return new BoothRect(cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2);
+    }
+    contains(r) {
+        return r.x1 >= this.x1 && r.x2 <= this.x2 && r.y1 >= this.y1 && r.y2 <= this.y2;
+    }
+    intersects(r) {
+        const x1 = Math.max(this.x1, r.x1);
+        const x2 = Math.min(this.x2, r.x2);
+        const y1 = Math.max(this.y1, r.y1);
+        const y2 = Math.min(this.y2, r.y2);
+        return x2 >= x1 && y2 >= y1;
+    }
+    getIntersection(r) {
+        const x1 = Math.max(this.x1, r.x1);
+        const x2 = Math.min(this.x2, r.x2);
+        const y1 = Math.max(this.y1, r.y1);
+        const y2 = Math.min(this.y2, r.y2);
+        if (x2 >= x1 && y2 >= y1) {
+            return new BoothRect(x1, y1, x2, y2);
+        }
+        else
+            return new BoothRect(0, 0, 0, 0);
+    }
+    getRotated90() {
+        return BoothRect.fromCxcywh(this.cx, this.cy, this.h, this.w);
+    }
+    normalize(width, height) {
+        return new BoothRect(this.x1 / width, this.y1 / height, this.x2 / width, this.y2 / height);
+    }
+    withPadding(x, y = x) {
+        if (this.w < x * 2 || this.h < y * 2)
+            return this;
+        return BoothRect.fromCxcywh(this.cx, this.cy, this.w - x * 2, this.h - y * 2);
+    }
+    scale(s) {
+        return new BoothRect(this.x1 * s, this.y1 * s, this.x2 * s, this.y2 * s);
+    }
+    getArea() {
+        return this.w * this.h;
+    }
+    clone() {
+        return new BoothRect(this.x1, this.y1, this.x2, this.y2);
+    }
+    translate(dx, dy) {
+        this.x1 += dx;
+        this.x2 += dx;
+        this.y1 += dy;
+        this.y2 += dy;
+        return this;
+    }
+    equals(r) {
+        return r.x1 === this.x1 && r.x2 === this.x2 && r.y1 === this.y1 && r.y2 === this.y2;
+    }
+    toString() {
+        return this.x1 + ',' + this.y1 + ',' + this.w + ',' + this.h;
+    }
+    containsPoint(x, y) {
+        return x >= this.x1 && x <= this.x2 && y >= this.y1 && y <= this.y2;
+    }
+}