@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/components/Kiosk/kiosk-record.js

@@ -0,0 +1,29 @@
+/**
+ * Narrows a saved kiosk field to a usable number.
+ *
+ * Every field of a kiosk record is optional (`KioskSchema`) and the record can
+ * arrive from localStorage, from `config.kiosk` or from the legacy `kiosk_*`
+ * params — so a field can be absent, or present and `NaN` from a bad parse.
+ * Both must read as "not set": feeding `NaN` into a camera move silently parks
+ * the kiosk nowhere.
+ */
+export function toFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/**
+ * The zoom factor that takes the plan renderer from the pt-scale it booted at
+ * to the one the kiosk was saved at, or undefined when the record does not
+ * carry both. Restoring the home framing and integrating the kiosk at load both
+ * need it, and both need the same guard.
+ *
+ * `Partial` rather than `Kiosk`: a QR-shared route hands over the anchor
+ * position alone, with no framing at all — the guard above is what that case
+ * lands in.
+ */
+export function getPtScaleZoomRatio(kiosk) {
+    const initialPtScale = toFiniteNumber(kiosk?.mapInitialPtScale);
+    const ptScale = toFiniteNumber(kiosk?.mapPtScale);
+    if (initialPtScale === undefined || ptScale === undefined || ptScale <= 0)
+        return undefined;
+    return initialPtScale / ptScale;
+}

package/dist/esm/components/Kiosk/kioskApi.d.ts

@@ -0,0 +1,4 @@
+import { type Kiosk } from './SetKiosk';
+export declare function createKiosk(kiosk: Kiosk, originUrlString: string): Promise<string | null>;
+export declare function updateKiosk(kiosk: Kiosk, originUrlString: string): Promise<void>;
+//# sourceMappingURL=kioskApi.d.ts.map

package/dist/esm/components/Kiosk/kioskApi.js

@@ -0,0 +1,47 @@
+import { KIOSK_STATS_ID_STORAGE_KEY } from './SetKiosk/constants';
+const JSON_HEADERS = { 'Content-Type': 'application/json' };
+// Build a `/api/kiosks...` URL scoped to the current event via the `expoKey` query param.
+function kioskApiUrl(path, originUrlString) {
+    const apiUrl = new URL(path, originUrlString);
+    apiUrl.searchParams.set('expoKey', window['__efpEvent']);
+    return apiUrl.toString();
+}
+// Create a kiosk record (`POST /api/kiosks`) and return its backend `key`, used both as the telemetry id
+// and as the path id for subsequent updates.
+export async function createKiosk(kiosk, originUrlString) {
+    try {
+        const response = await fetch(kioskApiUrl('/api/kiosks', originUrlString), {
+            method: 'POST',
+            headers: JSON_HEADERS,
+            body: JSON.stringify(kiosk),
+        });
+        if (!response.ok) {
+            console.error('createKiosk', response.status, response.statusText);
+            return null;
+        }
+        const savedKiosk = await response.json();
+        return savedKiosk.key ?? null;
+    }
+    catch (err) {
+        console.error('createKiosk', err);
+        return null;
+    }
+}
+export async function updateKiosk(kiosk, originUrlString) {
+    const kioskKey = localStorage.getItem(KIOSK_STATS_ID_STORAGE_KEY);
+    if (!kioskKey)
+        return;
+    try {
+        const response = await fetch(kioskApiUrl('/api/kiosks', originUrlString), {
+            method: 'POST',
+            headers: JSON_HEADERS,
+            body: JSON.stringify({ ...kiosk, key: kioskKey }),
+        });
+        if (!response.ok) {
+            console.error('updateKiosk', response.status, response.statusText);
+        }
+    }
+    catch (err) {
+        console.error('updateKiosk', err);
+    }
+}

package/dist/esm/components/Kiosk/kioskUrlParam.d.ts

@@ -0,0 +1,8 @@
+import { type Kiosk } from './SetKiosk';
+/** The anchor keys, in the order both halves speak them. */
+declare const ANCHOR_KEYS: readonly ['x', 'y', 'z'];
+type KioskAnchor = Partial<Pick<Kiosk, (typeof ANCHOR_KEYS)[number]>>;
+export declare function collectKioskUrlParams(searchParams: URLSearchParams): KioskAnchor;
+export declare function setKioskUrlParams(searchParams: URLSearchParams, kioskData: KioskAnchor | null | undefined): void;
+export {};
+//# sourceMappingURL=kioskUrlParam.d.ts.map

package/dist/esm/components/Kiosk/kioskUrlParam.js

@@ -0,0 +1,46 @@
+// The `kiosk_x/y/z` URL params — the anchor a QR-shared route smuggles to the
+// scanning phone, so the route's missing FROM resolves there. Position only,
+// both halves symmetric; this is the WHOLE legacy kiosk URL channel — the
+// framing/cosmetic keys were dropped when the QR narrowed to the anchor, and
+// new fields are born in the schema-typed `config.kiosk`, never here.
+//
+// The anchor lands in `uiState.kioskData`, the slot the device's own kiosk also
+// uses, but it never makes the scanning device a kiosk: `ShowKiosk` adopts only
+// a kiosk saved on the device or set in its config.
+import { getKioskUrlParamKey } from './SetKiosk';
+/** The anchor keys, in the order both halves speak them. */
+const ANCHOR_KEYS = ['x', 'y', 'z'];
+export function collectKioskUrlParams(searchParams) {
+    const anchor = {};
+    const x = finiteParam(searchParams, 'x');
+    if (x !== null)
+        anchor.x = x;
+    const y = finiteParam(searchParams, 'y');
+    if (y !== null)
+        anchor.y = y;
+    // the floor is a level NAME, so it travels as text
+    const z = searchParams.get(getKioskUrlParamKey('z'));
+    if (z !== null)
+        anchor.z = z;
+    return anchor;
+}
+export function setKioskUrlParams(searchParams, kioskData) {
+    if (!kioskData) {
+        return;
+    }
+    for (const key of ANCHOR_KEYS) {
+        const value = kioskData[key];
+        if (value == null) {
+            continue;
+        }
+        searchParams.set(getKioskUrlParamKey(key), typeof value === 'number' ? value.toFixed(2) : `${value}`);
+    }
+}
+function finiteParam(searchParams, key) {
+    const raw = searchParams.get(getKioskUrlParamKey(key));
+    if (raw === null) {
+        return null;
+    }
+    const parsed = parseFloat(raw);
+    return Number.isNaN(parsed) ? null : parsed;
+}

package/dist/esm/components/Kiosk/recoverKioskFromUrlPrams.d.ts

@@ -0,0 +1,2 @@
+export declare function recoverKioskFromUrlPrams(searchParams: URLSearchParams): void;
+//# sourceMappingURL=recoverKioskFromUrlPrams.d.ts.map

package/dist/esm/components/Kiosk/recoverKioskFromUrlPrams.js

@@ -0,0 +1,9 @@
+import { integrateKioskIntoMap, integrateKioskIntoWf } from './integrateKiosk';
+import { collectKioskUrlParams } from './kioskUrlParam';
+export function recoverKioskFromUrlPrams(searchParams) {
+    const kioskData = collectKioskUrlParams(searchParams);
+    if (Object.values(kioskData).length) {
+        integrateKioskIntoMap(kioskData, false);
+        integrateKioskIntoWf(kioskData);
+    }
+}

package/dist/esm/components/Language.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare const Language: React.FunctionComponent<object>;
+export default Language;
+//# sourceMappingURL=Language.d.ts.map

package/dist/esm/components/Language.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import { observer } from 'mobx-react-lite';
+import { useRef } from 'react';
+import { LANGUAGE_TYPE } from '../constants';
+import data from '../data';
+import { uiState } from '../store';
+import List from './List';
+const Language = observer(() => {
+    const scrollableRef = useRef();
+    return (!data.hideLanguage &&
+        !uiState.details &&
+        uiState.list.type === LANGUAGE_TYPE && _jsx(List, { updatedScrollableRef: scrollableRef }));
+});
+export default Language;

package/dist/esm/components/LanguageRowContainer.d.ts

@@ -0,0 +1,7 @@
+import './LanguageRowContainer.scss';
+import { type Language } from '../types';
+declare const LanguageRowContainer: import("react").FunctionComponent<{
+    item: Language;
+}>;
+export default LanguageRowContainer;
+//# sourceMappingURL=LanguageRowContainer.d.ts.map

package/dist/esm/components/LanguageRowContainer.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './LanguageRowContainer.scss';
+import { Radio } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { getLocale, setLocale, t } from '../utils/i18n';
+const LanguageRowContainer = observer(({ item }) => {
+    return (_jsx(Radio, { name: "language", label: item.name, value: item.id, checked: item.id === getLocale(), className: "language-row", ariaLabel: t('Change language to {{language}}', { language: item.name }), onChange: () => setLocale(item.id) }));
+});
+export default LanguageRowContainer;

package/dist/esm/components/Layout.d.ts

@@ -0,0 +1,11 @@
+import '@styles/main.scss';
+import './Layout.scss';
+import { type Consent } from '@expofp/config';
+import React from 'react';
+interface LayoutProps {
+    offHistory: boolean;
+    consent: Consent;
+}
+declare const _default: React.FunctionComponent<LayoutProps>;
+export default _default;
+//# sourceMappingURL=Layout.d.ts.map

package/dist/esm/components/Layout.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import '@styles/main.scss';
+import './Layout.scss';
+import { Spinner } from '@expofp/ui';
+import cn from 'classnames';
+import { observer } from 'mobx-react-lite';
+import React, { Suspense, useEffect, useState } from 'react';
+import { RUNTIME_LOADER_SPINNER_CLASS } from '../constants.js';
+import store, { layersStore, uiState } from '../store';
+import { LayersMode } from '../store/LayerStore';
+import { checkUserIsGDPR, GaEventActions, hasUserConsent, sendEventToGa, setConsentSettings, setCookieConsent, } from '../tools/gtag';
+import settings from '../tools/settings';
+import trackEvent from '../tools/track-event';
+import { isWebGlSupported } from '../utils';
+import { t } from '../utils/i18n';
+import isDebug from '../utils/is-debug';
+import { useReaction } from '../utils/mobx';
+import { CategoryFilterModal } from './CategoryFilterModal';
+import ErrorBoundary from './ErrorBoundary';
+import GlobalErrorMessage from './GlobalErrorMessage';
+import HeatmapLegendContainer from './HeatmapLegendContainer';
+import IntercomLauncher from './IntercomLauncher';
+import LogoOverlay from './LogoOverlay';
+import Map from './Map/Map';
+import MapControlsContainer from './MapControlsContainer';
+import MobileToggleButton from './MobileToggleButtonContainer';
+import OverlayContainer from './OverlayContainer';
+import PlanSelectorContainer from './PlanSelectorContainer';
+import SearchBox from './SearchBox';
+import SearchButtons from './SearchButtons/SearchButtons';
+import SessionsFiltersModal from './SessionsFiltersModal';
+import ShareContainer from './ShareContainer';
+import SpeakersFiltersModal from './SpeakersFiltersModal';
+import Ws from './Ws';
+const Demo = React.lazy(() => import(/* webpackChunkName: "demo" */ './Demo'));
+const Free = React.lazy(() => import(/* webpackChunkName: "free" */ './Free'));
+const Debug = React.lazy(() => import(/* webpackChunkName: "debug" */ './Debug'));
+const MaplibreAdapter = React.lazy(() => import(/* webpackChunkName: "maplibre" */ './Maplibre/MaplibreAdapter'));
+const Modal = React.lazy(() => import('./ModalContainer'));
+const CookieConsent = React.lazy(() => import(/* webpackChunkName: "cc-script" */ './CookieConsent'));
+const GpsLoader = React.lazy(() => import(/* webpackChunkName: "cc-script" */ './GpsLoader'));
+// document.body.addEventListener("touchstart", x => {
+//     console.log("body touchstart")
+// });
+const SetKioskMode = React.lazy(() => import(/* webpackChunkName: "set-kiosk-mode" */ './Kiosk/SetKioskMode'));
+const ShowKiosk = React.lazy(() => import(/* webpackChunkName: "show-kiosk" */ './Kiosk/ShowKiosk'));
+export default observer(function Layout({ offHistory, consent }) {
+    const [isGDPR, setIsGDPR] = useState(false);
+    const [overlayDemanded, setOverlayDemanded] = useState(false);
+    const showMaplibre = store.maplibreStore.showMaplibre;
+    // While the loader that `load()` draws in a host element it created itself is still there, the
+    // Layout's spinner would be a second one on screen; with no such loader it is the only one.
+    const spinnerActive = !layersStore.layersLoaded &&
+        !store.fp.element.querySelector(`.${RUNTIME_LOADER_SPINNER_CLASS}`);
+    const overlayChromeMounted = uiState.searchButtonsOverride !== false && (!uiState.noOverlay || uiState.overlayOnDemand);
+    const overlayMounted = !uiState.noOverlay || (uiState.overlayOnDemand && (overlayDemanded || uiState.isOverlayOpen));
+    // Single source of truth: SearchButtons bails out on `shouldShow` itself, and
+    // `--search-buttons-height` must reserve space only while they are mounted.
+    const searchButtonsMounted = overlayChromeMounted && store.initialized && store.searchButtonsStore.shouldShow;
+    let freeOrDemo = null;
+    if (uiState.bannerType === 'demo')
+        freeOrDemo = _jsx(Demo, {});
+    else if (uiState.bannerType === 'free')
+        freeOrDemo = _jsx(Free, {});
+    const acceptConsent = () => {
+        setCookieConsent(true);
+        setConsentSettings();
+        store.uiState.hideCookieConsent = true;
+    };
+    const rejectConsent = () => {
+        setCookieConsent(false);
+        setConsentSettings();
+        store.uiState.hideCookieConsent = true;
+    };
+    useEffect(() => {
+        async function checkConsent() {
+            const consentResult = await checkUserIsGDPR();
+            if (consentResult || consentResult === null) {
+                setIsGDPR(true);
+            }
+            else {
+                setIsGDPR(false);
+            }
+        }
+        if (!hasUserConsent(consent)) {
+            checkConsent();
+        }
+        else {
+            setIsGDPR(true);
+        }
+    }, [consent]);
+    useReaction(() => uiState.isOverlayOpen, (open) => open && setOverlayDemanded(true));
+    useReaction(() => uiState.selectedExhibitor, (exhibitor) => {
+        // always consumed, honoured only for the selection it was parked for:
+        // an entry naming a different exhibitor comes from a booth click that
+        // changed nothing, and this selection is the ordinary exhibitor view
+        const forced = store.heatmapStore.forceTrack;
+        store.heatmapStore.forceTrack = null;
+        if (forced && forced.exhibitor === exhibitor) {
+            sendEventToGa(forced.action, forced.label);
+            return;
+        }
+        if (exhibitor) {
+            trackEvent('exview', exhibitor.id);
+            sendEventToGa(GaEventActions.ViewExhibitor, exhibitor.name);
+        }
+    });
+    useReaction(() => uiState.selectedBooth, (booth) => booth?.name && sendEventToGa(GaEventActions.ViewBooth, booth.name));
+    useReaction(() => uiState.selectedCategory, (category) => category?.name && sendEventToGa(GaEventActions.ViewCategory, category?.name));
+    // `url`/`referrer` on these two events come from `window.location`, so they
+    // are only right if `syncUrl` has already written the new URL. It has: a
+    // selection change also flips `selectedExhibitor`, whose reaction is
+    // registered above — ahead of `syncUrl` — while these are registered after
+    // it, and MobX schedules in that order. Moving either of these above the
+    // `selectedExhibitor` reaction would silently start stamping the PREVIOUS
+    // selection's URL, which is what `exview` above does today.
+    useReaction(() => uiState.selectedEventItem, (eventItem) => {
+        if (eventItem?.name) {
+            trackEvent('sesview', eventItem.name);
+            sendEventToGa(GaEventActions.ViewExhibitor, eventItem.name);
+        }
+    });
+    // A reaction, not a call inside `selectSpeaker`: it runs only when the
+    // selection actually changes, so re-opening the speaker already on screen —
+    // from the list, a deep link or `fp.select()` — is not counted twice.
+    useReaction(() => uiState.selectedSpeaker, (speaker) => {
+        if (speaker?.name) {
+            trackEvent('spkview', speaker.name);
+        }
+    });
+    const displayCookieConsent = !uiState.hideCookieConsent && !uiState.kiosk && isGDPR && consent === 'ask';
+    return (_jsx("div", { id: "efp-layout", className: cn('layout', {
+            'efp-kiosk': uiState.kiosk,
+            'efp-kiosk-route-active': uiState.kiosk && uiState.selectedRoute?.from && uiState.selectedRoute?.to,
+            'efp-layers-mode': store.layerStore.mode,
+            'efp-no-search-buttons': !searchButtonsMounted,
+            'efp-ws-mode': uiState.wsShown,
+            'efp-no-overlay': uiState.overlayHiddenNow,
+            'efp-overlay-on-demand': uiState.overlayOnDemand,
+            'efp-top-banner': uiState.bannerType === 'free' && !uiState.freeBannerDismissed,
+            'efp-viewer-mode': uiState.viewerMode,
+        }), dir: uiState.rtl ? 'rtl' : 'ltr', style: {
+            '--ui-scale': uiState.uiScale.toString(),
+        }, children: _jsxs("div", { className: `layout__fixed expo-${settings.EXPO} overlay-${store.uiState.overlayPosition}`, children: [(layersStore.mode === LayersMode.Radio || layersStore.mode === LayersMode.CheckBox) &&
+                    !uiState.floorsControlHidden &&
+                    store.initialized && _jsx(PlanSelectorContainer, {}), overlayMounted && store.initialized && (_jsx(OverlayContainer, { isGDPR: isGDPR, consent: consent })), store.initialized && _jsx(LogoOverlay, {}), (!uiState.noOverlay || (uiState.overlayOnDemand && uiState.isOverlayOpen)) &&
+                    store.initialized &&
+                    !(uiState.viewerMode && uiState.menu) && _jsx(SearchBox, {}), searchButtonsMounted && _jsx(SearchButtons, {}), !uiState.noOverlay && store.initialized && _jsx(MobileToggleButton, {}), !uiState.mapControlsHidden && store.initialized && _jsx(MapControlsContainer, {}), _jsx(IntercomLauncher, {}), !uiState.hideHeaderLogo && store.initialized && _jsx(Ws, {}), store.routeStore.gpsEnabled && _jsx(GpsLoader, { requestCompassAllowed: !displayCookieConsent }), isWebGlSupported && !showMaplibre && _jsx(Map, {}), showMaplibre && (_jsx(ErrorBoundary, { children: _jsx(Suspense, { fallback: _jsx("div", {}), children: _jsx(MaplibreAdapter, { viewMode: store.maplibreStore.mapViewMode }) }) })), freeOrDemo && !uiState.hideFreeOrDemo && !uiState.heatmap ? (_jsx(Suspense, { fallback: null, children: freeOrDemo })) : null, displayCookieConsent && (_jsx(Suspense, { fallback: null, children: _jsx(CookieConsent, { link: "https://expofp.com/pages/viewer-cookie-consent", onAccept: acceptConsent, onReject: rejectConsent }) })), isDebug ? (_jsx(Suspense, { fallback: null, children: _jsx(Debug, {}) })) : null, uiState.modalActive.share ? (_jsx(Suspense, { fallback: null, children: _jsx(Modal, { variant: "share", ariaLabel: t('Share'), open: uiState.modalActive.share, onClose: () => store.toggleModal('share'), children: _jsx(ShareContainer, { title: uiState.selectedExhibitor?.name || uiState.selectedEventItem?.name || '', 
+                            // Shares the address bar itself — with URL sync on it IS the deep link;
+                            // offHistory embeds carry no state in their URL, so build a minimal
+                            // origin+slug link instead. A legitimate boundary read (plan §4.11).
+                            url: offHistory
+                                ? `${window.location.origin}?${encodeURI(
+                                // A share opened from a speaker has neither slug: `String()` keeps the
+                                // `?undefined` such a link has always ended in.
+                                String(uiState.selectedExhibitor?.slug || uiState.selectedEventItem?.slug))}`
+                                : window.location.href }) }) })) : null, uiState.heatmap || uiState.heatmapYah ? (_jsx(HeatmapLegendContainer, { style: {
+                        left: `calc(50% + ${store.uiState.mapVisibleStart / 2}px)`,
+                    }, className: uiState.responsiveClass })) : null, _jsx(Spinner, { active: spinnerActive }), _jsx("div", { id: "fps" }), store.initialized && _jsx(CategoryFilterModal, {}), store.initialized && _jsx(SessionsFiltersModal, { store: store.sessionsFilterStore }), store.initialized && _jsx(SpeakersFiltersModal, { store: store.speakerFilterStore }), _jsx(GlobalErrorMessage, {}), store.initialized && uiState.setKioskModeEnabled && (_jsx(Suspense, { fallback: null, children: _jsx(SetKioskMode, {}) })), store.initialized && !uiState.setKioskModeEnabled && (_jsx(Suspense, { fallback: null, children: _jsx(ShowKiosk, {}) }))] }) }));
+});

package/dist/esm/components/LevelBadgeContainer.d.ts

@@ -0,0 +1,6 @@
+import { LevelBadgeProps } from '@expofp/ui';
+import React from 'react';
+type LevelBadgeContainerProps = Omit<LevelBadgeProps, 'levelLabel'>;
+declare const LevelBadgeContainer: React.FunctionComponent<LevelBadgeContainerProps>;
+export default LevelBadgeContainer;
+//# sourceMappingURL=LevelBadgeContainer.d.ts.map

package/dist/esm/components/LevelBadgeContainer.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+import { LevelBadge } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { t } from '../utils/i18n';
+const LevelBadgeContainer = observer((props) => {
+    return _jsx(LevelBadge, { ...props, levelLabel: t('Level') });
+});
+export default LevelBadgeContainer;

package/dist/esm/components/List.d.ts

@@ -0,0 +1,9 @@
+import './List.scss';
+import React, { RefObject } from 'react';
+interface ListProps {
+    updatedScrollableRef: RefObject<HTMLElement>;
+    updateScroll?: () => void;
+}
+export default function List({ updatedScrollableRef, updateScroll }: ListProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=List.d.ts.map

package/dist/esm/components/List.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable @eslint-react/set-state-in-effect, @eslint-react/no-nested-component-definitions */
+/* eslint-disable @eslint-react/exhaustive-deps, @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import './List.scss';
+import { Spinner } from '@expofp/ui';
+import { useObserver } from 'mobx-react-lite';
+import { lazy, Suspense, useCallback, useEffect, useRef, useState } from 'react';
+import { LANGUAGE_TYPE } from '../constants';
+import { uiState } from '../store';
+import { getLocale } from '../utils/i18n';
+import LanguageRowContainer from './LanguageRowContainer';
+const importVirtuoso = () => import(/* webpackChunkName: "react-virtuoso-list" */ 'react-virtuoso')
+    .then((mod) => ({ default: mod.Virtuoso }))
+    .catch(() => new Promise((resolve) => setTimeout(() => resolve(importVirtuoso()), 3000)));
+const LazyVirtuoso = lazy(importVirtuoso);
+export default function List({ updatedScrollableRef, updateScroll }) {
+    const [scrollableRef, setScrollableRef] = useState(null);
+    const virtuosoRef = useRef(null);
+    useEffect(() => {
+        setScrollableRef(updatedScrollableRef ?? null);
+    }, [updatedScrollableRef]);
+    useEffect(() => {
+        const savedScrollTop = uiState.getListScrollTop(uiState.list.type);
+        if (savedScrollTop > 0) {
+            const t = setTimeout(() => {
+                if (virtuosoRef.current) {
+                    virtuosoRef.current.scrollTo({
+                        top: savedScrollTop,
+                        behavior: 'auto',
+                    });
+                }
+            }, 100);
+            return () => clearTimeout(t);
+        }
+    }, [uiState.list.type]);
+    const persistScrollTop = useCallback(() => {
+        if (virtuosoRef.current) {
+            virtuosoRef.current.getState((state) => {
+                const scrollTop = state?.scrollTop || 0;
+                uiState.setListScrollTop(uiState.list?.type, scrollTop);
+            });
+        }
+        else if (scrollableRef?.current) {
+            uiState.setListScrollTop(uiState.list?.type, scrollableRef.current.scrollTop || 0);
+        }
+    }, [scrollableRef]);
+    useEffect(() => {
+        return () => {
+            persistScrollTop();
+        };
+    }, []);
+    const mapItem = ({ index }) => {
+        const item = uiState.listItems[index];
+        if (item.entity.type === LANGUAGE_TYPE) {
+            return _jsx(LanguageRowContainer, { item: item }, item.id);
+        }
+        else {
+            console.error('Invalid item type');
+            return null;
+        }
+    };
+    const handleItemsRendered = () => {
+        if (updateScroll)
+            setTimeout(updateScroll);
+    };
+    const handleTotalListHeightChanged = () => {
+        if (updateScroll)
+            updateScroll();
+    };
+    return useObserver(() => {
+        const selectedIndex = uiState.listItems.findIndex((i) => i.id === getLocale());
+        return (_jsx("div", { style: { height: '100%', cursor: 'pointer', resize: 'both', minHeight: 100 }, children: scrollableRef && (_jsx(Suspense, { fallback: _jsx(Spinner, { active: true, isCenter: true }), children: _jsx(LazyVirtuoso, { ref: virtuosoRef, className: "list-virtual", style: { minHeight: uiState.listItems.length ? '1px' : 0 }, data: uiState.listItems, itemContent: (index) => mapItem({ index }), itemsRendered: handleItemsRendered, totalListHeightChanged: handleTotalListHeightChanged, customScrollParent: scrollableRef.current, totalCount: uiState.listItems.length, overscan: 20, increaseViewportBy: 200, initialTopMostItemIndex: selectedIndex !== -1 ? selectedIndex : 0, components: {
+                        EmptyPlaceholder: () => _jsx("div", { className: "list-empty", children: "No items to show" }),
+                    } }) })) }));
+    });
+}

package/dist/esm/components/LogoOverlay.d.ts

@@ -0,0 +1,3 @@
+import './LogoOverlay.scss';
+export default function LogoOverlay(): import("react").JSX.Element;
+//# sourceMappingURL=LogoOverlay.d.ts.map

package/dist/esm/components/LogoOverlay.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './LogoOverlay.scss';
+import classNames from 'classnames';
+import Color from 'color';
+import { useLocalStore, useObserver } from 'mobx-react-lite';
+import { Suspense } from 'react';
+import data from '../data';
+import { getFpSvgJs } from '../data/fp-payloads';
+import { getFpGeo } from '../data/fpGeo.js';
+import store, { uiState } from '../store';
+import baseRuntimeUrl from '../tools/base-runtime-url';
+import { eventScopedValue } from '../tools/event-scoped-cache.js';
+import { buildExpofpUrl, UTM_CAMPAIGNS } from '../tools/expofpUrl';
+import settings from '../tools/settings';
+import { remsToPixels } from '../utils';
+import { t } from '../utils/i18n';
+import isFromDesigner from '../utils/is-from-designer';
+import QrCode from '../utils/lazy-qr-code';
+import Alert from './AlertContainer';
+/** Two expos that park the badge on the opposite side. */
+const RIGHT_ALIGNED_EXPOS = ['info-techlive2025', 'metstrade-superyacht2023'];
+function isExpoRightAligned() {
+    return RIGHT_ALIGNED_EXPOS.includes(settings.EXPO);
+}
+// Both inputs are fixed for the lifetime of one plan (`settings` is built once
+// per event and never written back, `fpGeo` is the event's own document), so the
+// color parse belongs on the plan rather than on every render of the badge.
+const isDarkMode = eventScopedValue(() => {
+    const fpGeoStyle = getFpGeo()?.properties?.style;
+    return ((settings.backgroundColor !== 'none' && Color(settings.backgroundColor).isDark()) ||
+        (typeof fpGeoStyle === 'string' && fpGeoStyle.includes('dark')));
+});
+export default function LogoOverlay() {
+    const s = useLocalStore(() => {
+        const getPositionStyle = (topBottom, side, offset, width) => ({
+            // [topBottom]: offset + "px",
+            // [side]: remsToPixels(1) + "px",
+            width,
+            opacity: uiState.wsStarted ? 1 : 0,
+        });
+        const side = isExpoRightAligned() || uiState.rtl ? 'left' : 'right';
+        return {
+            get style() {
+                const pad = remsToPixels(uiState.overlayPosition === 'left' ? 1 : 1);
+                if (uiState.overlayPosition === 'left') {
+                    const bottom = uiState.mapVisibleBottom + pad;
+                    return getPositionStyle('bottom', side, bottom, '5rem');
+                }
+                else {
+                    return getPositionStyle('bottom', side, 20, '4.5rem');
+                }
+            },
+            get warningStyle() {
+                const pad = remsToPixels(uiState.overlayPosition === 'left' ? 1 : 0.5);
+                if (uiState.overlayPosition === 'left') {
+                    const bottom = uiState.mapVisibleBottom + 2 * pad;
+                    return getPositionStyle('bottom', side, bottom, '3rem');
+                }
+                else {
+                    let top = uiState.mapVisibleTop + 2 * pad;
+                    if (store.maplibreStore.showMaplibre)
+                        top = remsToPixels(0.5);
+                    return getPositionStyle('top', side, top, '2rem');
+                }
+            },
+        };
+    });
+    const dataSize = Math.round((getFpSvgJs().__fpStat?.dataSize ?? 0) / 1024 / 1024);
+    const showWarning = isFromDesigner && dataSize >= 10;
+    const showMaplibreWarning = isFromDesigner && !getFpGeo() && data.allow3dView && !uiState.kiosk && !uiState.heatmap;
+    const showQR = uiState.kiosk && !uiState.selectedRoute?.to && !uiState.selectedRoute?.from;
+    const qrClassName = classNames('efp-qr', {
+        'is-right': isExpoRightAligned() || uiState.rtl,
+    });
+    return useObserver(() => (_jsxs("div", { children: [!store.maplibreStore.showMaplibre && (_jsx("a", { href: buildExpofpUrl(UTM_CAMPAIGNS.SUBDOMAIN_LOGO), target: "_blank", rel: "noopener noreferrer", className: classNames('logo-overlay', { invert: isDarkMode() }), style: s.style, children: _jsx("img", { src: `${baseRuntimeUrl}expofp-overlay.png`, alt: t('Made with ExpoFP'), crossOrigin: "anonymous" }) })), showWarning && (_jsx(Alert, { title: t('This floor plan is too big'), variant: "warning", showIcon: true, position: "bottom-right", children: _jsx("a", { rel: "noopener noreferrer", target: "_blank", href: "https://expofp.com/pages/huge-fp-warning", children: t('Read how to optimize it') }) })), showMaplibreWarning && (_jsx(Alert, { title: t('3D view is hidden'), variant: "warning", showIcon: true, position: "bottom-right", children: _jsx("a", { rel: "noopener noreferrer", target: "_blank", href: "https://expofp.com/pages/expofp-mapbox-integration", children: t('Setup mapbox first') }) })), showQR && (_jsx(Suspense, { fallback: null, children: _jsxs("div", { className: classNames(qrClassName, {
+                        'efp-semi-transparent': uiState.setKioskModeEnabled,
+                    }), children: [_jsx("div", { children: t('View Map on Phone') }), _jsx(QrCode, { value: uiState.viewMapOnPhoneQRCodeUrl, size: 100 })] }) }))] })));
+}

package/dist/esm/components/Map/Map.d.ts

@@ -0,0 +1,2 @@
+export default function Map(): import("react").JSX.Element | null;
+//# sourceMappingURL=Map.d.ts.map