@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/store/UIState.js

@@ -0,0 +1,2138 @@
+import { __decorate } from "tslib";
+import { Box, Point } from '@expofp/geometry';
+import { action, computed, observable } from 'mobx';
+import { hasSavedKiosk } from '../components/Kiosk/kiosk-mode.js';
+import { setKioskUrlParams } from '../components/Kiosk/kioskUrlParam';
+import { mapScene } from '../components/Map/scene';
+import { LANGUAGE_TYPE, LEGACY_PREVIEW_MODE_STORAGE_KEY, LEGACY_UI_SCALE_STORAGE_KEY, LEGACY_VIEWER_MODE_STORAGE_KEY, MOBILE_BREAKPOINT, PREVIEW_MODE_STORAGE_KEY, UI_SCALE_STORAGE_KEY, VIEWER_MODE_STORAGE_KEY, VISIBILITY_STORAGE_KEY, } from '../constants';
+import data from '../data';
+import { getSvgArea, isSvgAreaExplicit } from '../data/svg.js';
+import { readFreeBannerDismissed } from '../tools/freeBanner';
+import { hasUserConsent } from '../tools/gtag';
+import { hasHtmlTags } from '../tools/has-html-tags';
+import logger from '../tools/logger';
+import settings from '../tools/settings';
+import { stripHtml } from '../tools/strip-html';
+import { remsToPixels } from '../utils';
+import browser from '../utils/browser';
+import { getLocale, getLocales, t } from '../utils/i18n';
+import isPhone from '../utils/is-phone.js';
+import { isLocalStorageAvailable } from '../utils/localStorage';
+import { getResponsiveClass } from '../utils/responsiveClass';
+import { sanitizeStr } from '../utils/sanitizeText';
+import { fitRectIsFraming, getVenueFitMarginPercent, resolveVenueFitRect, } from '../utils/scene-bounds';
+import { uiState } from '.';
+import { BoothBase, RegularBooth, SpecialBooth } from './BoothStore';
+import { EventItem } from './EventStore';
+import { Exhibitor } from './ExhibitorStore';
+import { findEntityByExternalId, Route } from './RouteStore';
+import { SpeakerItem } from './SpeakerStore';
+/** What one zoom-in step multiplies the zoom factor by — the zoom button and the double-click. */
+export const ZOOM_IN_FACTOR = 1.5;
+/** What one zoom-out step multiplies the zoom factor by. */
+export const ZOOM_OUT_FACTOR = 0.66;
+const PLANS_EXCLUDE_SUBCATEGORIES = ['dimensions25'];
+export default class UIState {
+    setSelectedCategoryFilters(categories) {
+        this.selectedCategoryFilters = categories;
+    }
+    resetCategoryFilter() {
+        this.selectedCategoryFilters = [];
+        this.categoryFilterOpen = false;
+    }
+    setSearchClearMode(value) {
+        this.searchClearMode = value;
+    }
+    setRouteTitle(title) {
+        this.routeTitle = title;
+    }
+    setRouteDescription(description) {
+        this.routeDescription = description;
+    }
+    setIsMultiPointRoute(isMulti) {
+        this.isMultiPointRoute = isMulti;
+    }
+    setTourTitle(title) {
+        this.tourTitle = title;
+    }
+    setTourDescription(description) {
+        this.tourDescription = description;
+    }
+    setIsMultiPointTour(isMulti) {
+        this.isMultiPointTour = isMulti;
+    }
+    setPathwayOnlyMode(value) {
+        this.pathwayOnlyMode = value;
+    }
+    setMultiPointTourList(tourId) {
+        this.list = { type: 'multi-point-tour', tourId };
+    }
+    get activePathwayLayers() {
+        if (this.list?.type === 'multi-point-tour') {
+            const routeItem = this.rootStore.toursStore.getTourById(this.list.tourId);
+            return routeItem?.layers?.map((layerInfo) => layerInfo.id) || [];
+        }
+        return [];
+    }
+    get highlightedBooths() {
+        const exhibitorExternalISet = new Set(this.rootStore.exhibitorStore.highlightedByExternalIds);
+        const boothExternalISet = new Set(this.rootStore.boothStore.highlightedByExternalIds);
+        const booths = new Set([
+            ...this.rootStore.exhibitorStore.exhibitors
+                .filter((e) => exhibitorExternalISet.has(e.externalId))
+                .flatMap((e) => e.booths.filter((b) => b instanceof RegularBooth))
+                .map((b) => b.id.toString()),
+            ...this.rootStore.boothStore.booths
+                .filter((b) => boothExternalISet.has(b.externalId))
+                .map((b) => b.id.toString()),
+        ]);
+        const isSearch = this.list?.type === 'search' && this.list?.text?.trim().length;
+        if (isSearch) {
+            booths.clear();
+            const includesMatchItems = this.fuzzySearchItems
+                .filter((i) => i.score === 0)
+                .map((i) => i.item);
+            if (includesMatchItems.length) {
+                listBooths(includesMatchItems, this.rootStore.boothStore.booths, this.rootStore.eventStore.eventItems).forEach((b) => booths.add(b.id.toString()));
+            }
+            else {
+                this.listBooths.forEach((b) => booths.add(b.id.toString()));
+            }
+        }
+        if (this.list?.type === 'filter') {
+            booths.clear();
+            this.list.items
+                .flatMap((e) => e.booths.filter((b) => b instanceof RegularBooth))
+                .forEach((b) => booths.add(b.id.toString()));
+        }
+        if (this.categoryFilterOpen && this.selectedCategoryFilters.length > 0) {
+            booths.clear();
+            this.selectedCategoryFilters.forEach((category) => {
+                category.exhibitors.flatMap((e) => e.booths).forEach((b) => booths.add(b.id.toString()));
+            });
+        }
+        else if (this.list?.type === 'category') {
+            booths.clear();
+            this.list.category.exhibitors
+                .flatMap((e) => e.booths)
+                .forEach((b) => booths.add(b.id.toString()));
+        }
+        if (this.list?.type === 'bookmarks') {
+            booths.clear();
+            listBooths(this.listItems, this.rootStore.boothStore.booths, this.rootStore.eventStore.eventItems).forEach((b) => booths.add(b.id.toString()));
+        }
+        if (this.list?.type === 'visited') {
+            booths.clear();
+            listBooths(this.listItems, this.rootStore.boothStore.booths, this.rootStore.eventStore.eventItems).forEach((b) => booths.add(b.id.toString()));
+        }
+        if (this.list?.type === 'exhibitors') {
+            booths.clear();
+            const searchText = this.list.text?.toLowerCase().trim();
+            let exhibitors = this.rootStore.exhibitorStore.exhibitors;
+            if (searchText) {
+                exhibitors = exhibitors.filter((e) => e.name.toLowerCase().includes(searchText));
+            }
+            exhibitors
+                .flatMap((e) => e.booths.filter((b) => b instanceof RegularBooth))
+                .forEach((b) => booths.add(b.id.toString()));
+        }
+        if (this.selectedPoiTypeFilters.length > 0) {
+            booths.clear();
+            this.selectedPoiTypeFilters.forEach((poiType) => {
+                this.rootStore.boothStore.booths
+                    .filter((b) => b.poiTypeId === poiType.id)
+                    .forEach((b) => booths.add(b.id.toString()));
+            });
+        }
+        if (this.details instanceof Route) {
+            booths.clear();
+            if (this.details.from instanceof BoothBase)
+                booths.add(this.details.from.id.toString());
+            if (this.details.to instanceof BoothBase)
+                booths.add(this.details.to.id.toString());
+            this.details.waypoints?.forEach((w) => booths.add(w.id.toString()));
+        }
+        if (this.details instanceof BoothBase) {
+            booths.clear();
+            booths.add(this.details.id.toString());
+        }
+        if (this.details instanceof Exhibitor) {
+            booths.clear();
+            this.details.booths
+                .filter((b) => b instanceof RegularBooth)
+                .forEach((b) => booths.add(b.id.toString()));
+        }
+        if (this.details instanceof EventItem) {
+            const eventItem = this.details;
+            if (eventItem.boothId) {
+                booths.clear();
+                const booth = this.rootStore.boothStore.booths.find((b) => b.id === eventItem.boothId);
+                if (booth) {
+                    booths.add(booth.id.toString());
+                }
+            }
+        }
+        return booths;
+    }
+    constructor(rootStore) {
+        this.interfaceMetadata = Object.freeze([
+            {
+                id: 'menu',
+                className: 'efp-overlay-menu',
+                priority: 80,
+                isActive: () => this.menu,
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: t('Menu'),
+                }),
+            },
+            {
+                id: 'exhibitor',
+                className: 'efp-overlay-exhibitor',
+                priority: 70,
+                isActive: () => this.details instanceof Exhibitor,
+                searchBoxConfig: () => {
+                    const exhibitor = this.details;
+                    return {
+                        mode: 'details',
+                        title: exhibitor.name,
+                    };
+                },
+            },
+            {
+                id: 'booth',
+                className: 'efp-overlay-booth',
+                priority: 70,
+                isActive: () => this.details instanceof BoothBase,
+                searchBoxConfig: () => {
+                    const booth = this.details;
+                    return {
+                        mode: 'details',
+                        title: booth.title || booth.name,
+                    };
+                },
+            },
+            {
+                id: 'event',
+                className: 'efp-overlay-event',
+                priority: 70,
+                isActive: () => this.details instanceof EventItem,
+                searchBoxConfig: () => {
+                    const event = this.details;
+                    return {
+                        mode: 'details',
+                        title: event.name,
+                    };
+                },
+            },
+            {
+                id: 'route',
+                className: 'efp-overlay-route',
+                priority: 70,
+                isActive: () => this.details instanceof Route,
+                searchBoxConfig: () => {
+                    return {
+                        mode: 'details',
+                        title: t('Directions'),
+                    };
+                },
+            },
+            {
+                id: 'search',
+                className: 'efp-overlay-search',
+                priority: 60,
+                isActive: () => !this.details &&
+                    !this.menu &&
+                    this.list.type === 'search' &&
+                    ((this.rootStore.fp.alwaysShowSidebar && !this.overlayOnDemand) ||
+                        this.heatmap ||
+                        this.searchFocused ||
+                        this.list.text.length > 0 ||
+                        this.searchClearMode),
+                searchBoxConfig: () => ({
+                    mode: 'search',
+                    title: t('Search'),
+                }),
+            },
+            {
+                id: 'exhibitors',
+                className: 'efp-overlay-exhibitors',
+                priority: 50,
+                isActive: () => this.list.type === 'exhibitors' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'search',
+                    title: t('Exhibitors'),
+                }),
+            },
+            {
+                id: 'filter',
+                className: 'efp-overlay-filter',
+                priority: 50,
+                isActive: () => this.list.type === 'filter' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'search',
+                    title: t('Filter'),
+                }),
+            },
+            {
+                id: 'bookmarks',
+                className: 'efp-overlay-bookmarks',
+                priority: 50,
+                isActive: () => this.list.type === 'bookmarks' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: t('Bookmarks'),
+                    badge: this.rootStore.bookmarksStore.total,
+                }),
+            },
+            {
+                id: 'visited',
+                className: 'efp-overlay-visited',
+                priority: 50,
+                isActive: () => this.list.type === 'visited' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: t('Visited'),
+                    badge: this.rootStore.exhibitorStore.visited.length,
+                }),
+            },
+            {
+                id: LANGUAGE_TYPE,
+                className: 'efp-overlay-language',
+                priority: 50,
+                isActive: () => this.list.type === LANGUAGE_TYPE,
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: t('Language'),
+                }),
+            },
+            {
+                id: 'category',
+                className: 'efp-overlay-category',
+                priority: 50,
+                isActive: () => !uiState.menu && !!uiState.selectedCategory,
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: (this.list.type === 'category' && this.list.category?.name) || t('Categories'),
+                    // badge: this.list.category?.exhibitors.length,
+                }),
+            },
+            {
+                id: 'sessions',
+                className: 'efp-overlay-sessions',
+                priority: 50,
+                isActive: () => this.list.type === 'sessions' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'search',
+                    title: t('Sessions'),
+                    subtitle: this.selectedTrack ? this.selectedTrack.name : undefined,
+                }),
+            },
+            {
+                id: 'speakers',
+                className: 'efp-overlay-speakers',
+                priority: 50,
+                isActive: () => this.list.type === 'speakers' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'search',
+                    title: t('Speakers'),
+                }),
+            },
+            {
+                id: 'speaker',
+                className: 'efp-overlay-speaker',
+                priority: 50,
+                isActive: () => this.details instanceof SpeakerItem,
+                searchBoxConfig: () => {
+                    const speaker = this.details;
+                    return {
+                        mode: 'details',
+                        title: speaker.name,
+                    };
+                },
+            },
+            {
+                id: 'tours',
+                className: 'efp-overlay-tours',
+                priority: 50,
+                isActive: () => this.list.type === 'tours' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'search',
+                    title: t('Guided Tours'),
+                }),
+            },
+            {
+                id: 'multi-point-wayfinding',
+                className: 'efp-overlay-multi-point',
+                priority: 75,
+                isActive: () => Boolean(this.isMultiPointRoute && this.selectedRoute && this.list.type !== 'route-planner'),
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: this.routeTitle || t('Multi-point route'),
+                }),
+            },
+            {
+                id: 'multi-point-tour',
+                className: 'efp-overlay-multi-point-tour',
+                priority: 75,
+                isActive: () => this.list.type === 'multi-point-tour' && !this.details,
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: this.tourTitle || t('Multi-point route'),
+                }),
+            },
+            {
+                id: 'route-planner',
+                className: 'efp-overlay-route-planner',
+                priority: 76,
+                isActive: () => this.list.type === 'route-planner' && (!this.details || this.details instanceof Route),
+                searchBoxConfig: () => ({
+                    mode: 'interface',
+                    title: t('Route planner'),
+                }),
+            },
+        ].sort((a, b) => b.priority - a.priority));
+        this.list = { type: 'search', text: '', focused: false };
+        this.details = null;
+        this.hoveredExhibitor = null;
+        this.hoveredBooth = null;
+        this.zoomBy = null;
+        this.rollReset = false;
+        this.moveToBooths = null;
+        this.moveToRect = null;
+        /**
+         * Breathing room the pending `moveToRect` wants, as a fraction of the framing
+         * region per side — the visible map less the side panel, in both renderers.
+         * `null` leaves it to the adaptive 15%/25% rule, which both renderers apply.
+         * Fit-to-screen sets 0: its rect is the framing itself, so padding it would
+         * zoom past the authored viewbox.
+         */
+        this.moveToRectPaddingPercent = null;
+        this.moveToLocation = false;
+        this.menu = false;
+        this.searchFocused = false;
+        this.searchClearMode = false;
+        this.printingPdf = false;
+        // Measured from the root element by `init-ui`; the viewport stands in until then.
+        this.screenSize = new Point(window.innerWidth, window.innerHeight);
+        this.overlayShowsAll = false;
+        this.centerMap = false;
+        this.zoomAfTransformK = 1;
+        this.activeListIndex = -1;
+        this.devicePixelRatio = window.devicePixelRatio;
+        this.previewExhibitor = null;
+        this.wsStarted = false;
+        this.canvasStarted = false;
+        this.inIdle = false;
+        this.modalActive = { share: false };
+        this.galleryActive = false;
+        this.hideOverlay = false;
+        this.searchButtonsOverride = null;
+        this.hideCookieConsent = Boolean(hasUserConsent());
+        this.hideHeaderLogo = false;
+        this.hideLogoInBooth = false;
+        this.disableBookmarked = false;
+        this.hideLanguage = false;
+        this.monochrome = false;
+        // TODO Consider the use of one variable with different versions
+        this.heatmap = false;
+        this.heatmapYah = false;
+        this.rootElement = null;
+        this.debugCircles = [];
+        this.mapControlsHidden = false;
+        this.floorsControlHidden = false;
+        this.hideFreeOrDemo = false;
+        this.freeBannerDismissed = readFreeBannerDismissed(sessionStorage);
+        this.currentBanner = null;
+        this.sceneDefReady = false;
+        this.categoryFilterOpen = false;
+        this.selectedCategoryFilters = [];
+        this.selectedPoiTypeFilters = [];
+        this.selectedTrack = null;
+        this.subButtonsVisible = false;
+        this.searchBoxMode = 'search';
+        this.searchBoxTitle = '';
+        this.isMultiPointRoute = false;
+        this.isMultiPointTour = false;
+        this.pathwayOnlyMode = false;
+        this.isOverlayScrolled = false;
+        this.listScrollTop = 0;
+        this.listScrollItemId = null;
+        this.listScrollIndex = 0;
+        this.scrollPositions = new Map();
+        this.scrollItemIds = new Map();
+        this._customUIScale = null;
+        this.searchFilterHeightPx = 54;
+        this.searchInputHeightPx = 54;
+        this.overlayUISizePx = 390;
+        this.overlayKioskSizePx = 450;
+        this.overlayMediumHeightRems = 10;
+        ///////////////////////////////////////////////////////////////////////////
+        // positions
+        this.headerHeightRem = 0;
+        this.wsImageHeightPx = 44;
+        this.mapVisibleStart = 0;
+        ///////////////////////////////////////////////////////////////////////////
+        ///////////////////////////////////////////////////////////////////////////
+        // filtering
+        this.forceDim = false;
+        // Empty here and filled by the constructor: `defaultMapSettings` reads `pitchEnabled`, which
+        // reads this field back, and a field initializer would run before it exists.
+        this.mapSettings = {};
+        /**
+         * How far the camera may tilt back from top down, in degrees.
+         *
+         * MapLibre's own default, which both views are held to, so the plan tilts the same amount in
+         * either one. Not a map setting, because a host has no reason to raise or lower it.
+         */
+        this.maxPitch = 60;
+        /** Whether a pitch change eases rather than cuts. Both views read it. */
+        this.animatePitch = true;
+        this.forceShowDetails = false;
+        this.buildRoute = false;
+        this.globalErrorMessages = [];
+        this.minUIScale = 0.8;
+        this.maxUIScale = 1.4;
+        this.kioskEnabled = false;
+        this.setKioskModeEnabled = false;
+        this.kioskData = null;
+        this.rootStore = rootStore;
+        this.mapSettings = { ...this.defaultMapSettings };
+        this.initializeUIScale();
+    }
+    get rtl() {
+        const locale = getLocale();
+        return locale === 'ar' || locale === 'he';
+    }
+    get noOverlay() {
+        return this.rootStore.fp.noOverlay || this.hideOverlay;
+    }
+    get overlayOnDemand() {
+        return this.noOverlay && this.searchButtonsOverride === true;
+    }
+    get overlayHiddenNow() {
+        return this.noOverlay && !(this.overlayOnDemand && this.isOverlayOpen);
+    }
+    get onBoothClick() {
+        return this.rootStore.fp.onBoothClick;
+    }
+    get onMarkerClick() {
+        return this.rootStore.fp.onMarkerClick;
+    }
+    get onBookmarkClick() {
+        return this.rootStore.fp.onBookmarkClick;
+    }
+    get onVisitedClick() {
+        return this.rootStore.fp.onVisitedClick;
+    }
+    get onCategoryClick() {
+        return this.rootStore.fp.onCategoryClick;
+    }
+    get onDirection() {
+        return this.rootStore.fp.onDirection;
+    }
+    get onDetails() {
+        return this.rootStore.fp.onDetails;
+    }
+    get onExhibitorCustomButtonClick() {
+        return this.rootStore.fp.onExhibitorCustomButtonClick;
+    }
+    get onGetCoordsClick() {
+        return this.rootStore.fp.onGetCoordsClick;
+    }
+    get selectedExhibitor() {
+        return this.details instanceof Exhibitor ? this.details : null;
+    }
+    get selectedBooth() {
+        return this.details instanceof BoothBase ? this.details : null;
+    }
+    get selectedCategory() {
+        return this.list.type === 'category' ? this.list.category : null;
+    }
+    get selectedRoute() {
+        return this.details instanceof Route ? this.details : null;
+    }
+    get selectedSpeaker() {
+        return this.details instanceof SpeakerItem ? this.details : null;
+    }
+    get uiScale() {
+        if (this._customUIScale !== null) {
+            return this._customUIScale;
+        }
+        if (this.kiosk) {
+            return 1.2;
+        }
+        return 1.0;
+    }
+    get isGuidedToursActive() {
+        return this.rootStore.toursStore.isActive;
+    }
+    // TODO: move to routeStore
+    get getRouteNextFloor() {
+        const pathLayers = this.rootStore.routeStore.pathLayers;
+        const currentRouteLayerName = this.rootStore.routeStore.currentRouteLayer?.name;
+        if (!currentRouteLayerName)
+            return null;
+        const index = pathLayers.findIndex((l) => l.layer?.name === currentRouteLayerName);
+        if (index === -1)
+            return null;
+        return pathLayers[index + 1]?.layer?.name ?? null;
+    }
+    get headerHeightPx() {
+        return remsToPixels(this.headerHeightRem);
+    }
+    get overlayPosition() {
+        if (this.screenSize.width > MOBILE_BREAKPOINT || this.kiosk)
+            return 'left';
+        return 'bottom';
+    }
+    get overlayCollapsed() {
+        return (this.kiosk &&
+            this.overlayPosition === 'left' &&
+            !this.searchFocused &&
+            !this.menu &&
+            !this.details &&
+            !this.selectedCategory &&
+            !this.selectedExhibitor &&
+            this.list.type !== 'bookmarks' &&
+            this.list.type !== LANGUAGE_TYPE &&
+            !('text' in this.list && this.list.text.length));
+    }
+    get overlaySize() {
+        if (this.overlayLeft)
+            return 'full';
+        return this.desiredOverlaySize;
+    }
+    get overlayBottom() {
+        return this.overlayPosition === 'bottom';
+    }
+    get overlayLeft() {
+        return this.overlayPosition === 'left';
+    }
+    get overlayWidthPx() {
+        return this.overlayHiddenNow
+            ? 0
+            : this.overlayLeft
+                ? this.kiosk
+                    ? this.overlayKioskSizePx
+                    : this.overlayUISizePx
+                : remsToPixels(this.screenSize.width);
+    }
+    get wsPaddingPx() {
+        return remsToPixels(0.25);
+    }
+    get wsOccupiedHeightPx() {
+        return this.wsShown ? this.wsImageHeightPx + this.wsPaddingPx * 2 : 0;
+    }
+    get wsShown() {
+        return !this.hideHeaderLogo && this.rootStore.exhibitorStore.advertised.length > 0;
+    }
+    get wsDesktopPosition() {
+        return settings.EXPO === 'cbresupplypartner' ? 'bottom' : 'top';
+    }
+    get wsPosition() {
+        return this.overlayBottom ? 'top' : this.wsDesktopPosition;
+    }
+    get responsiveClass() {
+        return getResponsiveClass(this.screenSize.width);
+    }
+    // map
+    get mapVisibleTop() {
+        return (this.wsPosition === 'top' ? this.wsOccupiedHeightPx : 0) + this.headerHeightPx;
+    }
+    get mapVisibleBottom() {
+        if (this.overlayLeft || this.overlayHiddenNow) {
+            return this.wsPosition === 'bottom' ? this.wsOccupiedHeightPx : 0;
+        }
+        return remsToPixels(this.overlayMediumHeightRems);
+    }
+    get searchActionsHeightPx() {
+        return this.overlayPosition === 'bottom'
+            ? this.searchInputHeightPx + this.searchFilterHeightPx
+            : this.searchInputHeightPx;
+    }
+    get shouldShowSearchButtons() {
+        return (this.rootStore.searchButtonsStore.hasAnySearchButtons &&
+            !this.details &&
+            !this.menu &&
+            ![LANGUAGE_TYPE, 'filter'].includes(this.list.type));
+    }
+    get shouldShowMobileToggle() {
+        const isPlanner = this.list.type === 'route-planner';
+        return (this.overlayPosition === 'bottom' &&
+            (isPlanner ||
+                (!this.details &&
+                    !this.menu &&
+                    this.list.type !== LANGUAGE_TYPE &&
+                    this.list.type !== 'bookmarks' &&
+                    this.list.type !== 'sessions')));
+    }
+    /**
+     * How far up from the bottom of the map the mobile "List" button reaches, or 0 while it is
+     * hidden. Mirrors the button's `bottom` and `height` in `MobileToggleButton.scss` (`@expofp/ui`);
+     * keep the two in sync.
+     */
+    get mobileToggleTopPx() {
+        return this.shouldShowMobileToggle ? remsToPixels((20 + 38) / 16) : 0;
+    }
+    get mobileToggleIsListMode() {
+        return !this.isOverlayOpen || this.overlaySize !== 'full';
+    }
+    // visible rect
+    get canvasVisibleRectPx() {
+        const s = this.screenSize;
+        return Box.fromMinMax({
+            x: uiState.rtl ? 0 : this.mapVisibleStart,
+            y: this.mapVisibleTop + this.searchActionsHeightPx,
+        }, {
+            x: uiState.rtl ? s.width - this.mapVisibleStart : s.width,
+            y: s.height - this.mapVisibleBottom,
+        });
+    }
+    get shouldShiftMapRect() {
+        return (this.overlayPosition === 'left' &&
+            (this.details || this.hasAppliedFilters || this.selectedRoute));
+    }
+    get hasAppliedFilters() {
+        return this.selectedCategoryFilters.length > 0 || this.selectedPoiTypeFilters.length > 0;
+    }
+    get canvasVisibleRectPt() {
+        // Legacy Rect.scale(dpr) scaled about the origin (0,0); boxScale defaults
+        // to the box center, so the origin is passed explicitly.
+        return this.canvasVisibleRectPx.scale(this.devicePixelRatio, { x: 0, y: 0 });
+    }
+    get canvasSizePt() {
+        return this.screenSize.multiply(this.devicePixelRatio);
+    }
+    // misc
+    get shouldUseBackdrop() {
+        if (uiState.overlayCollapsed)
+            return false;
+        if (isLocalStorageAvailable && localStorage.getItem('forcebackdrop') === '1')
+            return true;
+        if (this.overlayBottom)
+            return false;
+        if (this.selectedExhibitor?.leadingImageUrl && !this.selectedExhibitor?.leadingImageLinkUrl)
+            return false;
+        // if (settings.EXPO !== "aweusa2020" && settings.EXPO !== "expo") return false;
+        // const ua = navigator.userAgent;
+        // const isWebkit = ua.indexOf("AppleWebKit") !== -1 && ua.indexOf("Edge/") === -1;
+        // const isSafari = /^((?!chrome|android).)*safari/i.test(ua);
+        const isSafari = browser.satisfies({ safari: '>=13' });
+        const isChrome = browser.satisfies({ chrome: '>=77' });
+        const isAndroid = /(android)/i.test(navigator.userAgent);
+        if (isAndroid)
+            return false;
+        return (isSafari || (isChrome && uiState.canvasSizePt.height * uiState.canvasSizePt.width < 3000000));
+    }
+    setForceDim(forceDim) {
+        this.forceDim = forceDim;
+    }
+    get dimmed() {
+        if (this.forceDim) {
+            return true;
+        }
+        if (this.pathwayOnlyMode) {
+            return true;
+        }
+        return (this.highlightedBooths.size > 0 ||
+            (this.list?.type === 'search' && this.list?.text?.trim().length > 0) ||
+            this.list?.type === 'exhibitors');
+    }
+    get defaultSearchItems() {
+        const { exhibitorStore, categoryStore, boothStore, heatmapStore } = this.rootStore;
+        let exhibitorsArray = exhibitorStore.exhibitors;
+        const categoriesArray = categoryStore.categories.filter((c) => c.exhibitors.length);
+        const boothsArray = boothStore.booths;
+        if (this.selectedPoiTypeFilters.length > 0) {
+            exhibitorsArray = exhibitorsArray.filter((exhibitor) => exhibitor.booths.some((booth) => this.selectedPoiTypeFilters.some((poiType) => booth.poiTypeId === poiType.id)));
+        }
+        let combinedArray = [];
+        const cats = !this.selectedCategoryFilters.length && data.showCategories
+            ? categoriesArray.filter((category) => {
+                if (PLANS_EXCLUDE_SUBCATEGORIES.includes(settings.EXPO)) {
+                    return !category.name.includes('/');
+                }
+                return true;
+            })
+            : [];
+        const otherSpacesArray = boothsArray.filter((b) => b instanceof SpecialBooth);
+        if (this.selectedCategoryFilters.length > 0) {
+            combinedArray = [...exhibitorsArray];
+        }
+        else {
+            if (data.showCompaniesAndBooths)
+                combinedArray = combinedArray.concat(exhibitorsArray);
+            if (data.showOtherSpaces)
+                combinedArray = combinedArray.concat(otherSpacesArray);
+        }
+        if (this.heatmap) {
+            const allItems = [...exhibitorsArray, ...boothsArray];
+            return allItems.sort((a, b) => heatmapStore.getClicksByType(b) - heatmapStore.getClicksByType(a));
+        }
+        else if (this.heatmapYah) {
+            return (heatmapStore.heatmapData?.yah?.sort((a, b) => heatmapStore.getClicksByType(b) - heatmapStore.getClicksByType(a)) || []);
+        }
+        return exhibitorsArray.length === 0
+            ? boothsArray
+            : [
+                ...cats,
+                ...combinedArray.sort((a, b) => {
+                    const aFeatured = a instanceof Exhibitor && a.featured !== undefined;
+                    const bFeatured = b instanceof Exhibitor && b.featured !== undefined;
+                    if (aFeatured !== bFeatured) {
+                        return aFeatured ? -1 : 1;
+                    }
+                    const aDisplayName = a instanceof SpecialBooth && a.title ? a.title : a.name;
+                    const bDisplayName = b instanceof SpecialBooth && b.title ? b.title : b.name;
+                    return aDisplayName.localeCompare(bDisplayName, undefined, {
+                        sensitivity: 'base',
+                        numeric: true,
+                    });
+                }),
+            ];
+    }
+    get searchItems() {
+        if (this.list.type !== 'search')
+            return [];
+        const text = this.list.text?.trim().toLowerCase() || '';
+        const { exhibitorStore, boothStore, eventStore, speakerStore, heatmapStore } = this.rootStore;
+        let exhibitorsArray = exhibitorStore.exhibitors;
+        const boothsArray = boothStore.booths;
+        const eventsArray = eventStore.eventItems;
+        const speakersArray = speakerStore.speakers;
+        if (this.selectedCategoryFilters.length > 0) {
+            exhibitorsArray = exhibitorsArray.filter((exhibitor) => this.selectedCategoryFilters.some((category) => exhibitor.categories.some((c) => c.id === category.id)));
+        }
+        if (this.selectedPoiTypeFilters.length > 0) {
+            exhibitorsArray = exhibitorsArray.filter((exhibitor) => exhibitor.booths.some((booth) => this.selectedPoiTypeFilters.some((poiType) => booth.poiTypeId === poiType.id)));
+        }
+        if (!text) {
+            return this.defaultSearchItems;
+        }
+        // a&b&foo=1&bar=2 => a&b
+        const splittedTexts = [text.replace(/&[^&=]+=[^&]+/g, '')];
+        if (this.heatmapYah) {
+            // Show all items with views greater than the entered number
+            const result = (heatmapStore.heatmapData.yah ?? []).filter((c) => Number.isNaN(Number(text)) ? c : c.viewCount >= Number(text));
+            return result.sort((a, b) => heatmapStore.getClicksByType(b) - heatmapStore.getClicksByType(a));
+        }
+        const items = [];
+        const matchingExhibitors = new Set();
+        const matchingBooths = new Set();
+        const matchingEvents = new Set();
+        const matchingSpeakers = new Set();
+        function selectLettersSpacesNumbers(input) {
+            // Without & because of names that contain & (e.g. "A&B")
+            if (!input)
+                return '';
+            return input.replace(/[!@#$%^*\-.,()^#$%:?_+'"/]/g, ' ').replace(/\s\s+/g, ' ');
+        }
+        function containsIgnoreCase(str, searchTerm) {
+            if (!str || !searchTerm)
+                return false;
+            return selectLettersSpacesNumbers(str)
+                .toLowerCase()
+                .includes(selectLettersSpacesNumbers(searchTerm).toLowerCase());
+        }
+        function containsLevelIgnoreCase(str, searchTerm) {
+            return !str
+                ? false
+                : containsIgnoreCase(str, searchTerm) ||
+                    containsIgnoreCase(data.levelTerm + ' ' + str, searchTerm);
+        }
+        exhibitorsArray.forEach((e) => {
+            if (splittedTexts.some((text) => containsIgnoreCase(e.name, text) ||
+                e.booths.some((b) => (!text && containsIgnoreCase(b.name, text)) ||
+                    containsLevelIgnoreCase(b.layer?.name ?? null, text)))) {
+                matchingExhibitors.add(e);
+            }
+        });
+        if (this.selectedCategoryFilters.length > 0) {
+            boothsArray.forEach((b) => {
+                const addBoothCondition = this.heatmap
+                    ? true
+                    : !(b instanceof RegularBooth) ||
+                        !Array.from(matchingExhibitors).find((x) => x.booths.includes(b));
+                if (addBoothCondition &&
+                    splittedTexts.some((text) => containsIgnoreCase(b.title || '', text) ||
+                        containsIgnoreCase(b.name, text) ||
+                        containsIgnoreCase(b.fullName, text) ||
+                        containsLevelIgnoreCase(b.layer?.name ?? null, text))) {
+                    matchingBooths.add(b);
+                }
+            });
+        }
+        const searchEvents = eventsArray;
+        const searchSpeakers = speakersArray;
+        searchEvents.forEach((e) => {
+            if (splittedTexts.some((text) => containsIgnoreCase(e.name || '', text) || containsIgnoreCase(e.description || '', text))) {
+                matchingEvents.add(e);
+            }
+        });
+        searchSpeakers.forEach((s) => {
+            if (splittedTexts.some((text) => containsIgnoreCase(s.name, text) ||
+                containsIgnoreCase(s.company, text) ||
+                containsIgnoreCase(s.jobTitle, text))) {
+                matchingSpeakers.add(s);
+            }
+        });
+        items.push(...matchingEvents);
+        items.push(...matchingExhibitors);
+        if (this.heatmap) {
+            return items.sort((a, b) => heatmapStore.getClicksByType(b) - heatmapStore.getClicksByType(a));
+        }
+        const itemsMap = new Map(items.map((item) => [item.id, item]));
+        return (items
+            .map((item) => {
+            if (!item.name)
+                return null;
+            const lowerCaseName = sanitizeStr(item instanceof BoothBase
+                ? item.fullName.toLowerCase() || item.name.toLowerCase()
+                : item.name.toLowerCase());
+            // Find the position of the first occurrence
+            const position = lowerCaseName.indexOf(sanitizeStr(text));
+            if (position === -1)
+                return null;
+            const result = { id: item.id, position, lowerCaseName, featured: false };
+            if (item instanceof Exhibitor) {
+                result.featured = item.featured;
+            }
+            return result;
+        })
+            .filter((entry) => !!entry)
+            // Sort by featured status (featured first),
+            // then by position, and finally lexicographically by name.
+            .sort((a, b) => {
+            if ((a.featured || b.featured) && a.featured !== b.featured) {
+                return a.featured ? -1 : 1;
+            }
+            if (a.position !== b.position) {
+                return a.position - b.position;
+            }
+            return (a.lowerCaseName.localeCompare(b.lowerCaseName) ||
+                String(a.id).localeCompare(String(b.id)) // For stability
+            );
+        })
+            // Every id came out of `items`, so the lookup always hits.
+            .map(({ id }) => itemsMap.get(id))
+            .filter((item) => !!item));
+    }
+    get searchList() {
+        return [
+            ...this.rootStore.eventStore.eventItems,
+            ...this.rootStore.speakerStore.speakers,
+            ...this.rootStore.categoryStore.categories.filter((c) => c.exhibitors.length),
+            ...this.rootStore.exhibitorStore.exhibitors,
+            ...this.rootStore.boothStore.booths,
+        ];
+    }
+    get foundInDescription() {
+        if (this.list?.type !== 'search') {
+            return [];
+        }
+        const text = this.list?.text?.trim().toLowerCase();
+        if (!text) {
+            return [];
+        }
+        const items = this.fuzzySearchItems.map(({ item }) => item);
+        const itemNamesSet = new Set(items.map((i) => i.name));
+        const list = this.categoryFilteredSearchList.filter((x) => !itemNamesSet.has(x.name));
+        const candidates = [];
+        for (const item of list) {
+            const description = descriptionOf(item);
+            if (!description)
+                continue;
+            const searchable = (hasHtmlTags(description) ? stripHtml(description) : description).toLowerCase();
+            const pos = searchable.indexOf(text);
+            if (pos === -1)
+                continue;
+            candidates.push({ item, pos });
+        }
+        candidates.sort((a, b) => a.pos - b.pos);
+        return candidates.map((c) => c.item);
+    }
+    get foundInDescriptionStruct() {
+        const result = {};
+        if (this.list?.type !== 'search') {
+            return result;
+        }
+        const text = this.list?.text?.trim().toLowerCase();
+        this.foundInDescription.forEach((item) => {
+            let description = descriptionOf(item);
+            if (!description) {
+                return;
+            }
+            if (hasHtmlTags(description)) {
+                description = stripHtml(description);
+            }
+            const startIndex = description.toLowerCase().indexOf(text);
+            if (startIndex === -1) {
+                return;
+            }
+            const offset = 3;
+            const index = startIndex > offset ? startIndex - offset : 0;
+            const str = description.substring(index).trim();
+            result[item.id] = startIndex > 0 ? `...${str}` : str;
+        });
+        return result;
+    }
+    get categoryFilteredSearchList() {
+        if (this.selectedCategoryFilters.length === 0) {
+            return this.searchList;
+        }
+        return this.searchList.filter((item) => item instanceof Exhibitor &&
+            this.selectedCategoryFilters.some((category) => item.categories.some((c) => c.id === category.id)));
+    }
+    get fuzzySearchItems() {
+        if (this.list?.type !== 'search') {
+            return [];
+        }
+        const text = this.list?.text?.trim().toLowerCase();
+        if (!text) {
+            return this.defaultSearchItems.map((item) => ({ item, score: 0, matches: [] }));
+        }
+        const scored = this.rootStore.fuzzySearchEngineStore.search(this.categoryFilteredSearchList, text);
+        const match = [];
+        const others = [];
+        for (const result of scored) {
+            const item = result.item;
+            const type = item.entity.type;
+            const booth = type === 'booth' ? item : null;
+            const exhibitor = type === 'exhibitor' ? item : null;
+            const fields = [
+                item.name?.toLowerCase() ?? '',
+                booth?.title?.toLowerCase() ?? '',
+                booth?.fullName?.toLowerCase() ?? '',
+                ...(exhibitor?.booths?.map((b) => b.name?.toLowerCase() ?? '') ?? []),
+            ];
+            let minPos = Infinity;
+            for (const field of fields) {
+                const pos = field.indexOf(text);
+                if (pos !== -1 && pos < minPos)
+                    minPos = pos;
+            }
+            if (minPos !== Infinity) {
+                match.push({ result: { item, score: 0 }, pos: minPos });
+            }
+            else {
+                others.push(result);
+            }
+        }
+        match.sort((a, b) => a.pos - b.pos);
+        return [...match.map((m) => m.result), ...others];
+    }
+    get listItems() {
+        if (this.details instanceof Route && this.list.type !== 'multi-point-tour')
+            return [this.details.from, this.details.to].filter((x) => x instanceof BoothBase);
+        switch (this.list.type) {
+            case 'search': {
+                let items = !(this.heatmap || this.heatmapYah) && this.rootStore.fuzzySearchEngineStore.engine
+                    ? this.fuzzySearchItems.map(({ item }) => item).concat(this.foundInDescription)
+                    : this.searchItems;
+                items = items.filter((item) => item.entity.type === 'booth' ? !item.exhibitors.length : true);
+                if (this.hasAppliedFilters) {
+                    return items.filter((item) => {
+                        if (this.selectedCategoryFilters.length > 0) {
+                            if (item instanceof Exhibitor) {
+                                if (!this.selectedCategoryFilters.some((category) => item.categories.some((c) => c.id === category.id))) {
+                                    return false;
+                                }
+                            }
+                        }
+                        if (this.selectedPoiTypeFilters.length > 0) {
+                            if (item instanceof Exhibitor) {
+                                if (!item.booths.some((booth) => this.selectedPoiTypeFilters.some((poiType) => booth.poiTypeId === poiType.id))) {
+                                    return false;
+                                }
+                            }
+                            if (item instanceof BoothBase) {
+                                if (!this.selectedPoiTypeFilters.some((poiType) => item.poiTypeId === poiType.id)) {
+                                    return false;
+                                }
+                            }
+                            if (item instanceof EventItem && item.boothId) {
+                                const booth = this.rootStore.boothStore.booths.find((b) => b.id === item.boothId);
+                                if (!booth ||
+                                    !this.selectedPoiTypeFilters.some((poiType) => booth.poiTypeId === poiType.id)) {
+                                    return false;
+                                }
+                            }
+                        }
+                        return true;
+                    });
+                }
+                else {
+                    return items;
+                }
+            }
+            case 'bookmarks':
+                return [
+                    ...this.rootStore.exhibitorStore.bookmarked,
+                    ...this.rootStore.eventStore.bookmarked,
+                    ...this.rootStore.speakerStore.bookmarked,
+                    ...this.rootStore.boothStore.booths.filter((b) => b.exhibitors.length === 0 && b.bookmarkedDirectly),
+                ];
+            case 'visited':
+                return [...this.rootStore.exhibitorStore.visited, ...this.rootStore.eventStore.visited];
+            case 'category':
+                return this.list.category.exhibitors;
+            case LANGUAGE_TYPE:
+                return getLocales();
+            case 'filter':
+                return this.list.items;
+            case 'sessions':
+                return this.rootStore.eventStore.eventItems;
+            case 'exhibitors': {
+                const exhibitors = this.rootStore.exhibitorStore.exhibitors;
+                const searchText = this.list.text?.toLowerCase().trim();
+                if (!searchText) {
+                    return exhibitors;
+                }
+                return exhibitors.filter((exhibitor) => exhibitor.name.toLowerCase().includes(searchText));
+            }
+            case 'multi-point-tour': {
+                const routeItem = this.rootStore.toursStore.getTourById(this.list.tourId);
+                if (!routeItem)
+                    return [];
+                if (!routeItem.points || routeItem.points.length === 0)
+                    return [];
+                return routeItem.points
+                    .map((pointId) => {
+                    const numericId = parseInt(pointId);
+                    if (!isNaN(numericId)) {
+                        const booth = this.rootStore.boothStore.boothById.get(numericId);
+                        if (booth)
+                            return booth;
+                    }
+                    const entity = findEntityByExternalId(pointId);
+                    return entity?.entity || null;
+                })
+                    .filter((item) => !!item);
+            }
+            case 'route-planner':
+                return this.rootStore.routePlannerStore.resolvedBooths;
+        }
+        throw new Error('Unknown list.type');
+    }
+    get listBooths() {
+        return listBooths(this.listItems, this.rootStore.boothStore.booths, this.rootStore.eventStore.eventItems);
+    }
+    // @computed get listBoothsIdsSet() {
+    //     return new Set(getters.listBoothsIds);
+    // }
+    get selectedBooths() {
+        let arr = [];
+        if (this.selectedExhibitor)
+            arr = this.selectedExhibitor.booths;
+        else if (this.selectedBooth)
+            arr = [this.selectedBooth];
+        const route = this.selectedRoute;
+        const routeBooths = [route?.from, route?.to, ...(route?.waypoints ?? [])].filter((b) => b instanceof BoothBase);
+        arr.push(...routeBooths);
+        return new Set(arr);
+    }
+    // @computed get selectedBoothIdsSet() {
+    //     return new Set(getters.selectedBoothIds);
+    // }
+    get hoveredBooths() {
+        let arr = [];
+        if (this.hoveredBooth)
+            arr = [this.hoveredBooth];
+        else if (this.hoveredExhibitor)
+            arr = this.hoveredExhibitor.booths;
+        return new Set(arr);
+    }
+    get visibility() {
+        return {
+            controls: !this.mapControlsHidden,
+            levels: !this.floorsControlHidden,
+            header: this.wsShown,
+            overlay: !this.hideOverlay,
+            searchButtons: this.searchButtonsOverride ?? !this.hideOverlay,
+        };
+    }
+    setVisibility(visibility) {
+        const flagKeys = ['controls', 'levels', 'header', 'overlay'];
+        const flags = {
+            ...flagKeys.reduce((acc, key) => ({ ...acc, [key]: true }), {}),
+            ...flagKeys
+                .filter((key) => key in visibility)
+                .reduce((acc, key) => ({ ...acc, [key]: visibility[key] }), {}),
+        };
+        const searchButtons = typeof visibility.searchButtons === 'boolean' ? visibility.searchButtons : null;
+        if (isLocalStorageAvailable) {
+            if (Object.values(flags).every(Boolean) && searchButtons === null) {
+                localStorage.removeItem(VISIBILITY_STORAGE_KEY);
+            }
+            else {
+                localStorage.setItem(VISIBILITY_STORAGE_KEY, JSON.stringify(searchButtons === null ? flags : { ...flags, searchButtons }));
+            }
+        }
+        this.mapControlsHidden = !flags.controls;
+        this.floorsControlHidden = !flags.levels;
+        this.hideHeaderLogo = !flags.header;
+        this.hideFreeOrDemo = !flags.header;
+        this.hideOverlay = !flags.overlay;
+        this.searchButtonsOverride = searchButtons;
+    }
+    ///////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////
+    // actions TODO: move all to root store?
+    toggleMapOverlay() {
+        if (this.overlayPosition === 'bottom' && this.overlaySize === 'full')
+            this.desiredOverlaySize = 'medium';
+        else if (this.overlayPosition === 'bottom' && this.overlaySize !== 'full')
+            this.desiredOverlaySize = 'full';
+    }
+    changeZoom(zoom) {
+        this.zoomBy = zoom;
+    }
+    zoomIn() {
+        this.changeZoom(ZOOM_IN_FACTOR);
+    }
+    zoomOut() {
+        this.changeZoom(ZOOM_OUT_FACTOR);
+    }
+    fitBounds() {
+        // A venue in context is what the user is looking at: fit its active floor,
+        // not the whole campus behind it.
+        if (this.rootStore.venueStore.frameActiveVenue()) {
+            this.rollReset = true;
+            return;
+        }
+        // No venue in context on a campus: the whole campus, which is also what
+        // the map opens on — the ladder below would frame the union of the levels'
+        // authored viewboxes instead, a different rect at a different scale.
+        if (this.rootStore.venueStore.isCampusMode && this.rootStore.venueStore.campusBounds) {
+            this.rootStore.venueStore.viewAllVenues();
+            return;
+        }
+        // Both renderers frame the same rect: the most specific authored reference,
+        // falling back to the scene-derived extent (svgArea alone can span the whole
+        // surrounding map, e.g. a city). Where that rect is already the framing, the
+        // fit adds no padding of its own — that is what makes Fit-to-screen land on
+        // the initial view instead of a looser one.
+        const { rect, source } = resolveVenueFitRect({
+            layerViewbox: this.rootStore.layerStore.viewboxRectangle,
+            explicitArea: isSvgAreaExplicit() ? getSvgArea() : null,
+            layerRectangle: this.rootStore.layerStore.rectangle,
+            sceneDef: mapScene() ?? null,
+            svgArea: getSvgArea(),
+        });
+        this.moveToRect = rect;
+        this.moveToRectPaddingPercent = fitRectIsFraming(source)
+            ? 0
+            : getVenueFitMarginPercent(rect, getSvgArea());
+        this.rollReset = true;
+    }
+    // Both mode getters read localStorage lazily on every access — on purpose:
+    // the legacy URL seeds (`?previewMode=` / `?viewermode=`, applyOneShots in
+    // url-dispatch) run after loadConfig, and only a lazy read makes them
+    // effective within the same load. The legacy `___*` key (value '1') is
+    // consulted only while the schema-typed key is absent, so an explicit
+    // `efp-*` value (e.g. the debug panel's 'false') always wins; 'true' and
+    // '1' are the truthy forms the config codec accepts.
+    get previewMode() {
+        const stored = isLocalStorageAvailable
+            ? (localStorage.getItem(PREVIEW_MODE_STORAGE_KEY) ??
+                localStorage.getItem(LEGACY_PREVIEW_MODE_STORAGE_KEY))
+            : null;
+        return stored === 'true' || stored === '1' || this.rootStore.fp.previewMode;
+    }
+    get viewerMode() {
+        const stored = isLocalStorageAvailable
+            ? (localStorage.getItem(VIEWER_MODE_STORAGE_KEY) ??
+                localStorage.getItem(LEGACY_VIEWER_MODE_STORAGE_KEY))
+            : null;
+        return stored === 'true' || stored === '1' || this.rootStore.fp.viewerMode;
+    }
+    get selectedEventItem() {
+        return this.details instanceof EventItem ? this.details : null;
+    }
+    /**
+     * How the camera moves before a host says otherwise.
+     *
+     * Both views a plan is drawn in read these, so the plan opens at the same angle and takes the
+     * same time to get there whichever view is showing.
+     */
+    get defaultMapSettings() {
+        return {
+            zoomtime: 500,
+            pitchtime: 500,
+            center: undefined,
+            centerxy: undefined,
+            z: undefined,
+            venue: undefined,
+            bearing: 0,
+            roll: 1,
+            pitch: 1,
+            // The angle the plan opens at. Top down for a venue whose tilt gesture is off, so the plan
+            // it draws matches the one it lets you make by hand. A host may still pitch the camera
+            // afterwards: `pitchEnabled` holds the gesture, never a command.
+            pitchdegrees: this.pitchEnabled ? 30 : 0,
+        };
+    }
+    setMapSettings(settings) {
+        const newSettings = {};
+        for (const key of Object.keys(settings)) {
+            const value = settings[key];
+            if (value == null) {
+                continue;
+            }
+            if (key === 'zoomtime' || key === 'pitchtime') {
+                newSettings[key] = Math.min(Math.max(settings[key] || this.mapSettings[key] || 0, 500), 5000);
+            }
+            else {
+                Object.assign(newSettings, { [key]: value });
+            }
+        }
+        this.mapSettings = { ...this.mapSettings, ...newSettings };
+    }
+    resetMapSettings() {
+        this.mapSettings = { ...this.defaultMapSettings };
+    }
+    /**
+     * Whether the venue shows its plan in 3D, which is its `allow3dView` flag and nothing else.
+     *
+     * `MaplibreStore` picks the first view mode from it, and the tilt gesture below hangs off it, so
+     * a venue that never allows a tilted plan cannot be tilted by hand either.
+     *
+     * `hide3dMapDefault` is deliberately not read here. It asks for the flat view on load, which is a
+     * starting camera rather than a venue without 3D, and narrowing this by it takes the tilt gesture
+     * away from a venue that allows one.
+     *
+     * A plain getter, not a computed: the flag is frozen config with nothing to observe, and the map
+     * store reads this from its own constructor.
+     */
+    get is3DView() {
+        return !!data.allow3dView;
+    }
+    /**
+     * Whether the user may tilt the plan by hand.
+     *
+     * The gesture only, exactly as `rollEnabled` is: a camera command still tilts the plan whatever
+     * this says, in either view, so a host may open the plan at an angle with the gesture off. The
+     * venue decides first through `is3DView`, and the `pitch` map parameter a host may pass
+     * through the URL narrows it further.
+     *
+     * `keepAlive`, because `defaultMapSettings` reads it from the constructor, where there is no
+     * reaction to observe it and the store is configured with `computedRequiresReaction`.
+     */
+    get pitchEnabled() {
+        if (!this.is3DView)
+            return false;
+        return this.mapSettings.pitch === undefined || Number(this.mapSettings.pitch) === 1;
+    }
+    /**
+     * Whether the user may turn the plan: the venue's own setting, narrowed by the `roll` map
+     * parameter a host may pass through the URL.
+     */
+    get rollEnabled() {
+        if (!this.rootStore.fp.enableRotation)
+            return false;
+        return this.mapSettings.roll === undefined || Number(this.mapSettings.roll) === 1;
+    }
+    get baseQRCodeUrl() {
+        // The canonical address is only right while the plan is served from it. A
+        // copy running somewhere else — a branch runtime, an offline build, a host
+        // page — says so with `qrCodeBaseUrl`, and every code below then points at
+        // the page the visitor is actually looking at instead of a different one
+        // that happens to share the expo name.
+        return data?.qrCodeBaseUrl || `https://${settings.EXPO}.expofp.com`;
+    }
+    get viewMapOnPhoneQRCodeUrl() {
+        if (data?.customKioskQrCodeUrl) {
+            return data.customKioskQrCodeUrl;
+        }
+        const url = new URL(this.baseQRCodeUrl);
+        // Verbatim copy ON PURPOSE (retirement plan §4.11): the QR hands the phone the address bar
+        // as-is, which can hold what serializeSelection never emits — entry camera seeds, filter
+        // keys, queries frozen by disableUrlWrites (heatmap/offHistory), host-page params.
+        url.search = window.location.search;
+        const result = url.toString();
+        console.log('View Map On Phone QR Code Url', result);
+        return result;
+    }
+    get routeQRCodeUrl() {
+        const url = new URL(this.baseQRCodeUrl);
+        // ArbitraryPoint endpoints have no slug; the kiosk anchor is reconstructed on the receiving side
+        // from the `kiosk_x/y/z` URL params attached below via `setKioskUrlParams`.
+        const from = this.selectedRoute?.from;
+        const to = this.selectedRoute?.to;
+        const fromSlug = from instanceof BoothBase ? from.slug : '';
+        const toSlug = to instanceof BoothBase ? to.slug : '';
+        // Hand-rolled rather than serializeSelection: the receiving parser is positional
+        // (route:<to>:<from>:<accessible>), so an empty slug must keep its `:` slot — the kiosk-anchor
+        // FROM has none. serializeSelection drops empty segments, which would shift `false` into FROM.
+        url.search = `?route%3A${encodeURIComponent(toSlug)}%3A${encodeURIComponent(fromSlug)}%3Afalse`;
+        // We need to shorten the URL because the route QR code is becoming too complex for its small size.
+        setKioskUrlParams(url.searchParams, this.kioskData);
+        const result = url.toString();
+        console.log('Route QR Code Url', result);
+        return result;
+    }
+    get isFeaturedExhibitorActive() {
+        return this.details instanceof Exhibitor && Boolean(this.details.featured);
+    }
+    get activeInterfaceData() {
+        for (const meta of this.interfaceMetadata) {
+            if (meta.isActive()) {
+                return meta;
+            }
+        }
+        return null;
+    }
+    /** Id of the screen the search box heads — lets custom CSS target one header. */
+    get activeInterfaceId() {
+        return this.activeInterfaceData?.id;
+    }
+    get searchBoxConfig() {
+        const activeInterface = this.activeInterfaceData;
+        if (!activeInterface || !activeInterface.searchBoxConfig) {
+            return {
+                mode: 'search',
+                title: '',
+                subtitle: undefined,
+                badge: undefined,
+                icon: undefined,
+            };
+        }
+        return (activeInterface.searchBoxConfig() || {
+            mode: 'search',
+            title: '',
+            subtitle: undefined,
+            badge: undefined,
+            icon: undefined,
+        });
+    }
+    get searchBoxActions() {
+        return this.activeInterfaceData?.actions?.() ?? [];
+    }
+    get overlayInterfaceClasses() {
+        const classes = [];
+        const activeData = this.activeInterfaceData;
+        if (activeData) {
+            classes.push(activeData.className);
+            if (activeData.additionalClasses) {
+                classes.push(...activeData.additionalClasses());
+            }
+        }
+        if (this.details) {
+            classes.push('overlay-has-details');
+        }
+        if (this.list.type) {
+            classes.push(`overlay-list-${this.list.type}`);
+        }
+        if (this.isFeaturedExhibitorActive) {
+            classes.push('overlay-exhibitor-featured');
+        }
+        return classes;
+    }
+    get isOverlayOpen() {
+        if (this.noOverlay && !this.overlayOnDemand)
+            return false;
+        return this.activeInterfaceData !== null;
+    }
+    setOverlayScrolled(isScrolled) {
+        this.isOverlayScrolled = isScrolled;
+    }
+    setListScrollTop(listType, scrollTop) {
+        this.listScrollTop = scrollTop;
+        this.scrollPositions.set(listType, scrollTop);
+    }
+    setListScrollItemId(listType, itemId) {
+        this.listScrollItemId = itemId;
+        this.scrollItemIds.set(listType, itemId);
+    }
+    getListScrollTop(listType) {
+        return this.scrollPositions.get(listType) || 0;
+    }
+    getListScrollItemId(listType) {
+        return this.scrollItemIds.get(listType) || null;
+    }
+    clearListScroll(listType) {
+        this.scrollPositions.delete(listType);
+        this.scrollItemIds.delete(listType);
+        if (this.list.type === listType) {
+            this.listScrollTop = 0;
+            this.listScrollItemId = null;
+        }
+    }
+    get bannerType() {
+        if (this.hideFreeOrDemo || this.heatmap) {
+            return null;
+        }
+        if (settings.EXPO === 'expo') {
+            return 'demo';
+        }
+        else if (data.expoFpAd || data.isTrial) {
+            return 'free';
+        }
+        return null;
+    }
+    setCurrentBanner(banner) {
+        this.currentBanner = banner;
+    }
+    setForceShowDetails(flag) {
+        this.forceShowDetails = flag;
+    }
+    get showRouteInstantly() {
+        return Boolean(this.kiosk && !this.forceShowDetails);
+    }
+    startBuildRoute() {
+        this.rootStore.selectSearch('');
+        this.mapControlsHidden = true;
+        this.floorsControlHidden = true;
+        this.hideHeaderLogo = true;
+        this.hideFreeOrDemo = true;
+        this.hideOverlay = true;
+        this.hideCookieConsent = true;
+        this.buildRoute = true;
+    }
+    setGlobalErrorMessage(message) {
+        this.globalErrorMessages.push(message);
+    }
+    popGlobalErrorMessage() {
+        this.globalErrorMessages.pop();
+    }
+    initializeUIScale() {
+        // `?kiosk=0` explicitly de-kiosks the session, so the persisted scale (typically a
+        // kiosk-provisioning artifact — see KioskStore) must not be restored. Kiosk-semantic
+        // direct read: it migrates with the kiosk config node (retirement plan §4.7).
+        const urlParams = new URLSearchParams(window.location.search);
+        if (urlParams.get('kiosk') === '0') {
+            return;
+        }
+        // Nor on a phone that holds a saved kiosk: kiosk mode stays off there (see `kiosk`), and the
+        // scale stored with that kiosk would enlarge the UI all the same.
+        if (isPhone && hasSavedKiosk()) {
+            return;
+        }
+        if (isLocalStorageAvailable) {
+            const savedScale = localStorage.getItem(UI_SCALE_STORAGE_KEY) ??
+                localStorage.getItem(LEGACY_UI_SCALE_STORAGE_KEY);
+            if (savedScale) {
+                const scaleValue = parseFloat(savedScale);
+                if (!isNaN(scaleValue) && scaleValue >= 0.8 && scaleValue <= 1.4) {
+                    this._customUIScale = scaleValue;
+                }
+            }
+        }
+    }
+    setUIScale(scale, saveToStorage = true) {
+        if (scale === undefined || isNaN(scale) || scale < this.minUIScale || scale > this.maxUIScale) {
+            logger.warn(`Invalid ui-scale value: ${scale}. Must be between ${this.minUIScale} and ${this.maxUIScale}.`);
+            return;
+        }
+        this._customUIScale = scale;
+        if (saveToStorage && isLocalStorageAvailable) {
+            // self-migrating write: the legacy key is superseded on every save
+            localStorage.setItem(UI_SCALE_STORAGE_KEY, scale.toString());
+            localStorage.removeItem(LEGACY_UI_SCALE_STORAGE_KEY);
+        }
+    }
+    /**
+     * Applies the UI scale a kiosk carries. Not on a phone: kiosk mode stays off there (see `kiosk`),
+     * and its scale with it.
+     */
+    setKioskUIScale(scale, saveToStorage) {
+        if (isPhone)
+            return;
+        this.setUIScale(scale, saveToStorage);
+    }
+    resetUIScale() {
+        this._customUIScale = null;
+        if (isLocalStorageAvailable) {
+            localStorage.removeItem(UI_SCALE_STORAGE_KEY);
+            localStorage.removeItem(LEGACY_UI_SCALE_STORAGE_KEY);
+        }
+    }
+    /** Drops a scale applied without saving, back to the stored one (or the default). */
+    restoreUIScale() {
+        this._customUIScale = null;
+        this.initializeUIScale();
+    }
+    /**
+     * Kiosk mode. Never on for a phone ({@link isPhone}), whichever writer asks for it. A phone still
+     * shows the kiosk's marker, which follows `kioskData`.
+     */
+    get kiosk() {
+        return this.kioskEnabled;
+    }
+    set kiosk(enabled) {
+        this.kioskEnabled = enabled && !isPhone;
+    }
+    enableSetKioskMode(enable) {
+        this.setKioskModeEnabled = enable;
+    }
+    setKioskData(kioskData) {
+        this.kioskData = kioskData;
+    }
+}
+__decorate([
+    observable.struct
+], UIState.prototype, "list", void 0);
+__decorate([
+    observable.ref
+], UIState.prototype, "details", void 0);
+__decorate([
+    observable.ref
+], UIState.prototype, "hoveredExhibitor", void 0);
+__decorate([
+    observable.ref
+], UIState.prototype, "hoveredBooth", void 0);
+__decorate([
+    observable
+], UIState.prototype, "zoomBy", void 0);
+__decorate([
+    observable
+], UIState.prototype, "rollReset", void 0);
+__decorate([
+    observable
+], UIState.prototype, "moveToBooths", void 0);
+__decorate([
+    observable
+], UIState.prototype, "moveToRect", void 0);
+__decorate([
+    observable
+], UIState.prototype, "moveToRectPaddingPercent", void 0);
+__decorate([
+    observable
+], UIState.prototype, "moveToLocation", void 0);
+__decorate([
+    observable
+], UIState.prototype, "menu", void 0);
+__decorate([
+    observable
+], UIState.prototype, "searchFocused", void 0);
+__decorate([
+    observable
+], UIState.prototype, "searchClearMode", void 0);
+__decorate([
+    observable
+], UIState.prototype, "printingPdf", void 0);
+__decorate([
+    observable.struct
+], UIState.prototype, "screenSize", void 0);
+__decorate([
+    observable
+], UIState.prototype, "desiredOverlaySize", void 0);
+__decorate([
+    observable
+], UIState.prototype, "overlayShowsAll", void 0);
+__decorate([
+    observable
+], UIState.prototype, "centerMap", void 0);
+__decorate([
+    observable
+], UIState.prototype, "zoomAfTransformK", void 0);
+__decorate([
+    observable
+], UIState.prototype, "activeListIndex", void 0);
+__decorate([
+    observable
+], UIState.prototype, "devicePixelRatio", void 0);
+__decorate([
+    observable
+], UIState.prototype, "wsStarted", void 0);
+__decorate([
+    observable
+], UIState.prototype, "canvasStarted", void 0);
+__decorate([
+    observable
+], UIState.prototype, "inIdle", void 0);
+__decorate([
+    observable
+], UIState.prototype, "modalActive", void 0);
+__decorate([
+    observable
+], UIState.prototype, "galleryActive", void 0);
+__decorate([
+    observable
+], UIState.prototype, "hideOverlay", void 0);
+__decorate([
+    observable
+], UIState.prototype, "searchButtonsOverride", void 0);
+__decorate([
+    observable
+], UIState.prototype, "hideCookieConsent", void 0);
+__decorate([
+    observable
+], UIState.prototype, "hideHeaderLogo", void 0);
+__decorate([
+    observable
+], UIState.prototype, "hideLogoInBooth", void 0);
+__decorate([
+    observable
+], UIState.prototype, "disableBookmarked", void 0);
+__decorate([
+    observable
+], UIState.prototype, "hideLanguage", void 0);
+__decorate([
+    observable
+], UIState.prototype, "monochrome", void 0);
+__decorate([
+    observable
+], UIState.prototype, "heatmap", void 0);
+__decorate([
+    observable
+], UIState.prototype, "heatmapYah", void 0);
+__decorate([
+    observable
+], UIState.prototype, "debugCircles", void 0);
+__decorate([
+    observable
+], UIState.prototype, "mapControlsHidden", void 0);
+__decorate([
+    observable
+], UIState.prototype, "floorsControlHidden", void 0);
+__decorate([
+    observable
+], UIState.prototype, "hideFreeOrDemo", void 0);
+__decorate([
+    observable
+], UIState.prototype, "freeBannerDismissed", void 0);
+__decorate([
+    observable
+], UIState.prototype, "currentBanner", void 0);
+__decorate([
+    observable
+], UIState.prototype, "sceneDefReady", void 0);
+__decorate([
+    observable
+], UIState.prototype, "categoryFilterOpen", void 0);
+__decorate([
+    observable
+], UIState.prototype, "selectedCategoryFilters", void 0);
+__decorate([
+    observable
+], UIState.prototype, "selectedPoiTypeFilters", void 0);
+__decorate([
+    observable
+], UIState.prototype, "selectedTrack", void 0);
+__decorate([
+    observable
+], UIState.prototype, "subButtonsVisible", void 0);
+__decorate([
+    observable
+], UIState.prototype, "searchBoxMode", void 0);
+__decorate([
+    observable
+], UIState.prototype, "searchBoxTitle", void 0);
+__decorate([
+    observable
+], UIState.prototype, "searchBoxSubtitle", void 0);
+__decorate([
+    observable
+], UIState.prototype, "routeTitle", void 0);
+__decorate([
+    observable
+], UIState.prototype, "routeDescription", void 0);
+__decorate([
+    observable
+], UIState.prototype, "isMultiPointRoute", void 0);
+__decorate([
+    observable
+], UIState.prototype, "tourTitle", void 0);
+__decorate([
+    observable
+], UIState.prototype, "tourDescription", void 0);
+__decorate([
+    observable
+], UIState.prototype, "isMultiPointTour", void 0);
+__decorate([
+    observable
+], UIState.prototype, "pathwayOnlyMode", void 0);
+__decorate([
+    observable
+], UIState.prototype, "isOverlayScrolled", void 0);
+__decorate([
+    observable
+], UIState.prototype, "listScrollTop", void 0);
+__decorate([
+    observable
+], UIState.prototype, "listScrollItemId", void 0);
+__decorate([
+    observable
+], UIState.prototype, "listScrollIndex", void 0);
+__decorate([
+    observable
+], UIState.prototype, "_customUIScale", void 0);
+__decorate([
+    action
+], UIState.prototype, "setSelectedCategoryFilters", null);
+__decorate([
+    action
+], UIState.prototype, "resetCategoryFilter", null);
+__decorate([
+    action
+], UIState.prototype, "setSearchClearMode", null);
+__decorate([
+    action
+], UIState.prototype, "setRouteTitle", null);
+__decorate([
+    action
+], UIState.prototype, "setRouteDescription", null);
+__decorate([
+    action
+], UIState.prototype, "setIsMultiPointRoute", null);
+__decorate([
+    action
+], UIState.prototype, "setTourTitle", null);
+__decorate([
+    action
+], UIState.prototype, "setTourDescription", null);
+__decorate([
+    action
+], UIState.prototype, "setIsMultiPointTour", null);
+__decorate([
+    action
+], UIState.prototype, "setPathwayOnlyMode", null);
+__decorate([
+    action
+], UIState.prototype, "setMultiPointTourList", null);
+__decorate([
+    computed
+], UIState.prototype, "activePathwayLayers", null);
+__decorate([
+    computed
+], UIState.prototype, "highlightedBooths", null);
+__decorate([
+    computed
+], UIState.prototype, "rtl", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "noOverlay", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayOnDemand", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayHiddenNow", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedExhibitor", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedBooth", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedCategory", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedRoute", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedSpeaker", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "uiScale", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "isGuidedToursActive", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "getRouteNextFloor", null);
+__decorate([
+    computed
+], UIState.prototype, "headerHeightPx", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayPosition", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayCollapsed", null);
+__decorate([
+    computed
+], UIState.prototype, "overlaySize", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayBottom", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayLeft", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayWidthPx", null);
+__decorate([
+    computed
+], UIState.prototype, "wsPaddingPx", null);
+__decorate([
+    computed
+], UIState.prototype, "wsOccupiedHeightPx", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "wsShown", null);
+__decorate([
+    computed
+], UIState.prototype, "wsDesktopPosition", null);
+__decorate([
+    computed
+], UIState.prototype, "wsPosition", null);
+__decorate([
+    computed
+], UIState.prototype, "responsiveClass", null);
+__decorate([
+    computed
+], UIState.prototype, "mapVisibleTop", null);
+__decorate([
+    computed
+], UIState.prototype, "mapVisibleBottom", null);
+__decorate([
+    computed
+], UIState.prototype, "searchActionsHeightPx", null);
+__decorate([
+    computed
+], UIState.prototype, "shouldShowSearchButtons", null);
+__decorate([
+    computed
+], UIState.prototype, "shouldShowMobileToggle", null);
+__decorate([
+    computed
+], UIState.prototype, "mobileToggleTopPx", null);
+__decorate([
+    computed
+], UIState.prototype, "mobileToggleIsListMode", null);
+__decorate([
+    computed
+], UIState.prototype, "canvasVisibleRectPx", null);
+__decorate([
+    computed
+], UIState.prototype, "shouldShiftMapRect", null);
+__decorate([
+    computed
+], UIState.prototype, "hasAppliedFilters", null);
+__decorate([
+    computed
+], UIState.prototype, "canvasVisibleRectPt", null);
+__decorate([
+    computed
+], UIState.prototype, "canvasSizePt", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "shouldUseBackdrop", null);
+__decorate([
+    observable
+], UIState.prototype, "forceDim", void 0);
+__decorate([
+    action
+], UIState.prototype, "setForceDim", null);
+__decorate([
+    computed
+], UIState.prototype, "dimmed", null);
+__decorate([
+    computed
+], UIState.prototype, "defaultSearchItems", null);
+__decorate([
+    computed
+], UIState.prototype, "searchItems", null);
+__decorate([
+    computed
+], UIState.prototype, "searchList", null);
+__decorate([
+    computed
+], UIState.prototype, "foundInDescription", null);
+__decorate([
+    computed
+], UIState.prototype, "foundInDescriptionStruct", null);
+__decorate([
+    computed
+], UIState.prototype, "categoryFilteredSearchList", null);
+__decorate([
+    computed
+], UIState.prototype, "fuzzySearchItems", null);
+__decorate([
+    computed
+], UIState.prototype, "listItems", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "listBooths", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedBooths", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "hoveredBooths", null);
+__decorate([
+    computed
+], UIState.prototype, "visibility", null);
+__decorate([
+    action
+], UIState.prototype, "setVisibility", null);
+__decorate([
+    action
+], UIState.prototype, "toggleMapOverlay", null);
+__decorate([
+    action
+], UIState.prototype, "changeZoom", null);
+__decorate([
+    action
+], UIState.prototype, "zoomIn", null);
+__decorate([
+    action
+], UIState.prototype, "zoomOut", null);
+__decorate([
+    action
+], UIState.prototype, "fitBounds", null);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "selectedEventItem", null);
+__decorate([
+    observable
+], UIState.prototype, "mapSettings", void 0);
+__decorate([
+    action
+], UIState.prototype, "setMapSettings", null);
+__decorate([
+    action
+], UIState.prototype, "resetMapSettings", null);
+__decorate([
+    observable
+], UIState.prototype, "animatePitch", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], UIState.prototype, "pitchEnabled", null);
+__decorate([
+    computed
+], UIState.prototype, "rollEnabled", null);
+__decorate([
+    computed
+], UIState.prototype, "baseQRCodeUrl", null);
+__decorate([
+    computed
+], UIState.prototype, "viewMapOnPhoneQRCodeUrl", null);
+__decorate([
+    computed
+], UIState.prototype, "routeQRCodeUrl", null);
+__decorate([
+    computed
+], UIState.prototype, "isFeaturedExhibitorActive", null);
+__decorate([
+    computed
+], UIState.prototype, "activeInterfaceData", null);
+__decorate([
+    computed
+], UIState.prototype, "activeInterfaceId", null);
+__decorate([
+    computed
+], UIState.prototype, "searchBoxConfig", null);
+__decorate([
+    computed
+], UIState.prototype, "searchBoxActions", null);
+__decorate([
+    computed
+], UIState.prototype, "overlayInterfaceClasses", null);
+__decorate([
+    computed
+], UIState.prototype, "isOverlayOpen", null);
+__decorate([
+    action
+], UIState.prototype, "setOverlayScrolled", null);
+__decorate([
+    action
+], UIState.prototype, "setListScrollTop", null);
+__decorate([
+    action
+], UIState.prototype, "setListScrollItemId", null);
+__decorate([
+    action
+], UIState.prototype, "getListScrollTop", null);
+__decorate([
+    action
+], UIState.prototype, "getListScrollItemId", null);
+__decorate([
+    action
+], UIState.prototype, "clearListScroll", null);
+__decorate([
+    computed
+], UIState.prototype, "bannerType", null);
+__decorate([
+    action
+], UIState.prototype, "setCurrentBanner", null);
+__decorate([
+    observable
+], UIState.prototype, "forceShowDetails", void 0);
+__decorate([
+    action
+], UIState.prototype, "setForceShowDetails", null);
+__decorate([
+    computed
+], UIState.prototype, "showRouteInstantly", null);
+__decorate([
+    observable
+], UIState.prototype, "buildRoute", void 0);
+__decorate([
+    action
+], UIState.prototype, "startBuildRoute", null);
+__decorate([
+    observable
+], UIState.prototype, "globalErrorMessages", void 0);
+__decorate([
+    action
+], UIState.prototype, "setGlobalErrorMessage", null);
+__decorate([
+    action
+], UIState.prototype, "popGlobalErrorMessage", null);
+__decorate([
+    action
+], UIState.prototype, "initializeUIScale", null);
+__decorate([
+    action
+], UIState.prototype, "setUIScale", null);
+__decorate([
+    action
+], UIState.prototype, "setKioskUIScale", null);
+__decorate([
+    action
+], UIState.prototype, "resetUIScale", null);
+__decorate([
+    action
+], UIState.prototype, "restoreUIScale", null);
+__decorate([
+    observable
+], UIState.prototype, "kioskEnabled", void 0);
+__decorate([
+    observable
+], UIState.prototype, "setKioskModeEnabled", void 0);
+__decorate([
+    action
+], UIState.prototype, "enableSetKioskMode", null);
+__decorate([
+    observable
+], UIState.prototype, "kioskData", void 0);
+__decorate([
+    action
+], UIState.prototype, "setKioskData", null);
+/** The description a list item carries, for the kinds that have one. */
+function descriptionOf(item) {
+    return 'description' in item && typeof item.description === 'string'
+        ? item.description
+        : undefined;
+}
+function listBooths(listItems, boothStoreBooths, eventItems = []) {
+    const arr = [];
+    listItems.forEach((item) => {
+        if (item instanceof Exhibitor) {
+            arr.push(...item.booths);
+        }
+        else if (item instanceof BoothBase) {
+            arr.push(item);
+        }
+        else if (item instanceof EventItem) {
+            const booth = boothStoreBooths.find((b) => b.id === item.boothId);
+            if (item.boothId && booth)
+                arr.push(booth);
+        }
+        else if (item instanceof SpeakerItem) {
+            eventItems
+                .filter((e) => e.speakers.some((s) => s.id === item.id) && e.boothId)
+                .forEach((e) => {
+                const speakerBooth = boothStoreBooths.find((b) => b.id === e.boothId);
+                if (speakerBooth)
+                    arr.push(speakerBooth);
+            });
+        }
+    });
+    return new Set(arr.filter(Boolean));
+}