@expofp/floorplan 0.0.0-experimental.2d6c681

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

@@ -0,0 +1,41 @@
+declare const ModalContainer: import("react").FunctionComponent<Omit<{
+    title: string;
+    ariaLabel?: string;
+} & {
+    open: boolean;
+    className?: string;
+    variant?: import("@expofp/ui").ModalVariant;
+    maxWidth?: number;
+    children?: React.ReactNode;
+    closeLabel: string;
+    renderTarget?: HTMLElement | null;
+    footerLeft?: {
+        label: string;
+        variant?: import("@expofp/ui").ButtonVariant;
+        disabled?: boolean;
+        onClick: () => void;
+    }[];
+    footerRight?: import("@expofp/ui").ModalButton[];
+    onClose: () => void;
+}, "closeLabel" | "renderTarget"> | Omit<{
+    title?: undefined;
+    ariaLabel: string;
+} & {
+    open: boolean;
+    className?: string;
+    variant?: import("@expofp/ui").ModalVariant;
+    maxWidth?: number;
+    children?: React.ReactNode;
+    closeLabel: string;
+    renderTarget?: HTMLElement | null;
+    footerLeft?: {
+        label: string;
+        variant?: import("@expofp/ui").ButtonVariant;
+        disabled?: boolean;
+        onClick: () => void;
+    }[];
+    footerRight?: import("@expofp/ui").ModalButton[];
+    onClose: () => void;
+}, "closeLabel" | "renderTarget">>;
+export default ModalContainer;
+//# sourceMappingURL=ModalContainer.d.ts.map

package/dist/esm/components/ModalContainer.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Modal } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { t } from '../utils/i18n';
+import { useRenderTarget } from '../utils/useRenderTarget';
+const ModalContainer = observer((props) => {
+    const renderTarget = useRenderTarget();
+    return _jsx(Modal, { ...props, renderTarget: renderTarget, closeLabel: t('Close') });
+});
+export default ModalContainer;

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

@@ -0,0 +1,5 @@
+import { type MultiSelectGroupsProps } from '@expofp/ui';
+type MultiSelectGroupsContainerProps = Omit<MultiSelectGroupsProps, 'selectAllLabel' | 'clearAllLabel' | 'selectedLabel' | 'showMoreLabel' | 'showLessLabel'>;
+declare const MultiSelectGroupsContainer: import("react").FunctionComponent<MultiSelectGroupsContainerProps>;
+export default MultiSelectGroupsContainer;
+//# sourceMappingURL=MultiSelectGroupsContainer.d.ts.map

package/dist/esm/components/MultiSelectGroupsContainer.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MultiSelectGroups } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { t } from '../utils/i18n';
+const MultiSelectGroupsContainer = observer((props) => {
+    return (_jsx(MultiSelectGroups, { ...props, selectAllLabel: t('Select all'), clearAllLabel: t('Clear all'), selectedLabel: t('selected'), showMoreLabel: t('Show more'), showLessLabel: t('Show less') }));
+});
+export default MultiSelectGroupsContainer;

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

@@ -0,0 +1,8 @@
+import { type Consent } from '@expofp/config';
+interface OverlayContainerProps {
+    isGDPR: boolean;
+    consent: Consent;
+}
+declare const OverlayContainer: import("react").FunctionComponent<OverlayContainerProps>;
+export default OverlayContainer;
+//# sourceMappingURL=OverlayContainer.d.ts.map

package/dist/esm/components/OverlayContainer.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Overlay } from '@expofp/ui';
+import classNames from 'classnames';
+import { observer } from 'mobx-react-lite';
+import { useCallback, useMemo, useState } from 'react';
+import { overlayStore, uiState } from '../store';
+import { SESSIONS_LIST_TYPE } from '../store/types';
+import { t } from '../utils/i18n';
+import Bookmarks from './Bookmarks';
+import Booth from './Booth/Booth';
+import Category from './Category';
+import Event from './Event';
+import Exhibitor from './Exhibitor';
+import Filter from './Filter';
+import Language from './Language';
+import Menu from './Menu';
+import OverlayParticles from './OverlayParticles';
+import RoutePlanner from './RoutePlanner/RoutePlanner';
+import Search from './Search';
+import Sessions from './Sessions';
+import Speaker from './Speaker';
+import Speakers from './Speakers';
+import TourPoints from './TourPoints';
+import Tours from './Tours';
+import Visited from './Visited';
+import Wayfinding from './Wayfinding';
+const OverlayContainer = observer(({ isGDPR, consent }) => {
+    const handleChangeSize = useCallback((size) => {
+        uiState.desiredOverlaySize = size;
+    }, []);
+    const handleScrollStateChange = useCallback((isScrolled) => {
+        uiState.setOverlayScrolled(isScrolled);
+    }, []);
+    // The store states a size only once one has been chosen, so there is a window with none.
+    // Passed through as is: the sheet reports its snap point back through
+    // `onChangeSize`, and a mapped-down echo would drag it off the point it landed on.
+    const currentSize = uiState.overlaySize;
+    // The overlay scrolls to the top on a key change; kept when details close back to the sessions
+    // list, which restores its saved session (or scrolls to the top itself if it is gone).
+    const [scrollResetKey, setScrollResetKey] = useState({});
+    const [view, setView] = useState({ type: uiState.list.type, details: uiState.details });
+    if (view.type !== uiState.list.type || view.details !== uiState.details) {
+        setView({ type: uiState.list.type, details: uiState.details });
+        const restoresSavedItem = !uiState.details &&
+            uiState.list.type === SESSIONS_LIST_TYPE &&
+            uiState.getListScrollItemId(SESSIONS_LIST_TYPE) != null;
+        if (!restoresSavedItem)
+            setScrollResetKey({});
+    }
+    const overlayClass = useMemo(() => {
+        const classes = {
+            '-backdrop': uiState.canvasStarted &&
+                uiState.shouldUseBackdrop &&
+                !uiState.dimmed &&
+                !uiState.galleryActive,
+            '-no-transition': uiState.dimmed,
+            '-gallery-active': uiState.galleryActive,
+            collapsed: uiState.overlayCollapsed,
+            kiosk: uiState.kiosk,
+            start: uiState.overlayPosition === 'left',
+            bottom: uiState.overlayPosition !== 'left',
+            ...(uiState.overlaySize && { [uiState.overlaySize]: true }),
+        };
+        const baseClasses = classNames(classes);
+        const additionalClasses = uiState.overlayInterfaceClasses.join(' ');
+        return additionalClasses ? `${baseClasses} ${additionalClasses}` : baseClasses;
+    }, [
+        uiState.canvasStarted,
+        uiState.shouldUseBackdrop,
+        uiState.dimmed,
+        uiState.galleryActive,
+        uiState.overlayCollapsed,
+        uiState.kiosk,
+        uiState.inIdle,
+        uiState.setKioskModeEnabled,
+        uiState.overlayPosition,
+        uiState.overlaySize,
+        uiState.overlayInterfaceClasses,
+    ]);
+    return (_jsxs(Overlay, { open: uiState.isOverlayOpen, size: currentSize, particles: uiState.isFeaturedExhibitorActive ? _jsx(OverlayParticles, {}) : null, className: overlayClass, mediumSizeMultiplier: overlayStore.mediumSizeMultiplier, fullSizeOffset: overlayStore.fullSizeOffset, disableDrag: uiState.viewerMode && uiState.menu, forceFull: uiState.viewerMode && uiState.menu, scrollResetKey: scrollResetKey, noContentLabel: t('No content'), withFloatingButton: uiState.shouldShowMobileToggle, onChangeSize: handleChangeSize, onScrollStateChange: handleScrollStateChange, onScrollActivity: () => window['__resett']?.(), children: [_jsx(Menu, { isGDPR: isGDPR, consent: consent }), _jsx(Search, {}), _jsx(Exhibitor, {}), _jsx(Booth, {}), _jsx(Bookmarks, {}), _jsx(Visited, {}), _jsx(Language, {}), _jsx(Category, {}), _jsx(Wayfinding, {}), _jsx(Filter, {}), _jsx(Sessions, { showFilters: true }), _jsx(Speakers, { showFilters: true }), _jsx(Tours, {}), _jsx(TourPoints, {}), _jsx(RoutePlanner, {}), _jsx(Event, {}), _jsx(Speaker, {})] }));
+});
+export default OverlayContainer;

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

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

package/dist/esm/components/OverlayGripContainer.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import { OverlayGrip } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { uiState } from '../store';
+import { t } from '../utils/i18n';
+const OverlayGripContainer = observer(() => {
+    const isFull = uiState.overlaySize === 'full';
+    return (_jsx(OverlayGrip, { isFull: isFull, onToggle: () => uiState.toggleMapOverlay(), ariaLabel: isFull ? t('Collapse overlay') : t('Expand overlay') }));
+});
+export default OverlayGripContainer;

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

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

package/dist/esm/components/OverlayParticles.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable @eslint-react/set-state-in-effect */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @ts-nocheck
+import './OverlayParticles.scss';
+import { observer } from 'mobx-react-lite';
+import { useEffect, useRef, useState } from 'react';
+import { uiState } from '../store';
+import browser from '../utils/browser';
+import { useAutorun } from '../utils/mobx';
+function OverlayParticles() {
+    const [visible, setVisible] = useState(false);
+    const [ParticlesClass, setParticlesClass] = useState();
+    const [canShow, setCanShow] = useState(false);
+    const canvas = useRef();
+    useAutorun(() => setCanShow(uiState.overlayPosition === 'left' && browser.getEngine()?.name !== 'EdgeHTML'));
+    // init ParticlesClass
+    useEffect(() => {
+        // console.log("zz",1);
+        if (canShow && !ParticlesClass) {
+            // console.log("zz");
+            import(/* webpackChunkName: "particlesjs" */ 'particlesjs').then((p) => {
+                setParticlesClass(p.default);
+            });
+            // waitFor(
+            //     () => window["Particles"],
+            //     Particles => setParticlesClass(Particles)
+            // );
+        }
+    }, [canShow, ParticlesClass]);
+    // init/destroy particles
+    useEffect(() => {
+        if (ParticlesClass && canShow) {
+            const particles = ParticlesClass.init({
+                selector: canvas.current,
+                maxParticles: 50,
+                speed: 0.4,
+                sizeVariations: 4,
+                color: '#0C5AB8',
+                connectParticles: true,
+            });
+            setVisible(true);
+            return () => {
+                // try{
+                particles.destroy();
+                // }catch{}
+            };
+        }
+    }, [ParticlesClass, canShow]);
+    if (!canShow)
+        return null;
+    return (_jsx("div", { children: _jsx("canvas", { className: `overlay-particles__canvas ${visible ? '-visible' : ''}`, ref: canvas }) }));
+}
+export default observer(OverlayParticles);

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

@@ -0,0 +1,3 @@
+declare const PlanSelectorContainer: import("react").FunctionComponent<object>;
+export default PlanSelectorContainer;
+//# sourceMappingURL=PlanSelectorContainer.d.ts.map

package/dist/esm/components/PlanSelectorContainer.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LevelSelector, PlanSelector, VenuePicker } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import appData from '../data';
+import store from '../store';
+import { LayersMode } from '../store/LayerStore';
+import settings from '../tools/settings';
+import { t } from '../utils/i18n';
+import { useRenderTarget } from '../utils/useRenderTarget';
+// Force list mode for specific expos (temporary until settings option is available)
+const FORCE_LIST_EXPOS = ['ice-gaming2026'];
+function getDisplayMode(shortLevelName) {
+    if (FORCE_LIST_EXPOS.includes(settings.EXPO)) {
+        return { layout: 'compact-list', useShortNames: shortLevelName };
+    }
+    return {
+        layout: shortLevelName ? 'compact-list' : 'dropdown',
+        useShortNames: shortLevelName,
+    };
+}
+const CampusPlanSelector = observer(() => {
+    const venueStore = store.venueStore;
+    const renderTarget = useRenderTarget();
+    const venues = venueStore.orderedVenues.map((venue) => ({
+        id: venue.id,
+        label: venue.name,
+        active: venue.id === venueStore.focusedVenueId,
+        disabled: false,
+    }));
+    const focusedVenue = venueStore.focusedVenue;
+    // Top-most level first, matching how floor switches read on multi-floor plans.
+    const levels = focusedVenue
+        ? [...focusedVenue.levels].reverse().map((level) => ({
+            id: level.layer.name,
+            label: appData.shortLevelName ? level.layer.shortName : level.displayName,
+            active: level === focusedVenue.activeLevel,
+            disabled: false,
+        }))
+        : [];
+    const handleLevelSelect = (id) => {
+        const level = focusedVenue?.levels.find((candidate) => candidate.layer.name === id);
+        if (level)
+            venueStore.activateLayer(level.layer);
+    };
+    return (_jsxs(PlanSelector, { children: [_jsx(VenuePicker, { venues: venues, labels: {
+                    chooseVenue: t('Choose venue'),
+                    close: t('Close'),
+                    currentVenue: t('Current Venue'),
+                    venueSelection: t('Venue selection'),
+                    viewAllVenues: t('View all venues'),
+                }, renderTarget: renderTarget, onSelect: (id) => venueStore.enterVenue(id), onViewAllVenues: () => venueStore.viewAllVenues() }), venueStore.selectorMode === 'levels' && levels.length > 1 && (_jsx(LevelSelector, { floors: levels, layout: "compact-list", onSelect: handleLevelSelect, floorSelectionLabel: t('Floor selection'), currentFloorLabel: t('Current Floor'), floorLabel: t('Floor') }))] }));
+});
+const PlanSelectorContainer = observer(() => {
+    // Venue-model plans morph the selector between the venue list (overview)
+    // and the focused venue's level list (KTD-5); rendered regardless of the
+    // legacy LayersMode gate.
+    if (store.venueStore.isCampusMode) {
+        return _jsx(CampusPlanSelector, {});
+    }
+    const floors = store.layerStore.floors;
+    const isVisible = store.layerStore.mode === LayersMode.Radio || store.layerStore.mode === LayersMode.CheckBox;
+    if (!isVisible || floors.length === 0)
+        return null;
+    const { layout, useShortNames } = getDisplayMode(appData.shortLevelName);
+    const items = floors.map((floor) => ({
+        id: floor.layer.description,
+        label: useShortNames ? floor.shortName : floor.description,
+        active: floor.active,
+        disabled: floor.disabled,
+    }));
+    const handleFloorSelect = (id) => {
+        const floor = floors.find((f) => f.layer.description === id);
+        if (!floor || floor.disabled)
+            return;
+        store.layerStore.selectFloor(floor.layer);
+    };
+    return (_jsx(PlanSelector, { children: _jsx(LevelSelector, { floors: items, layout: layout, onSelect: handleFloorSelect, floorSelectionLabel: t('Floor selection'), currentFloorLabel: t('Current Floor'), floorLabel: t('Floor') }) }));
+});
+export default PlanSelectorContainer;

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

@@ -0,0 +1,4 @@
+import { type RebookingNotesProps } from '@expofp/ui';
+declare const RebookingNotesContainer: import("react").FunctionComponent<Omit<RebookingNotesProps, "noteLabel" | "saveButtonAriaLabel" | "saveButtonLabel">>;
+export default RebookingNotesContainer;
+//# sourceMappingURL=RebookingNotesContainer.d.ts.map

package/dist/esm/components/RebookingNotesContainer.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RebookingNotes } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { t } from '../utils/i18n';
+const RebookingNotesContainer = observer((props) => {
+    return (_jsx(RebookingNotes, { noteLabel: t('Note'), saveButtonLabel: t('Save note'), saveButtonAriaLabel: t('Save rebooking note'), ...props }));
+});
+export default RebookingNotesContainer;

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

@@ -0,0 +1,6 @@
+import { type RebookingRadioGroupProps } from '@expofp/ui';
+declare const RebookingRadioGroupContainer: import("react").FunctionComponent<Omit<RebookingRadioGroupProps, "options" | "title"> & {
+    showTitle?: boolean;
+}>;
+export default RebookingRadioGroupContainer;
+//# sourceMappingURL=RebookingRadioGroupContainer.d.ts.map

package/dist/esm/components/RebookingRadioGroupContainer.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RebookingRadioGroup, } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { RebookingState } from '../store/ExhibitorStore';
+import { rebookingStateConfig } from '../tools/rebooking-config';
+import { t } from '../utils/i18n';
+const labelKeys = {
+    [RebookingState.Unasked]: 'Unasked',
+    [RebookingState.Accepted]: 'Accepted',
+    [RebookingState.Rejected]: 'Rejected',
+    [RebookingState.Undecided]: 'Undecided',
+};
+const buildOptions = () => Object.entries(rebookingStateConfig).map(([state, config]) => ({
+    value: state,
+    label: t(labelKeys[Number(state)]),
+    iconName: config.iconName,
+    color: config.color.primary,
+}));
+const RebookingRadioGroupContainer = observer((props) => {
+    const { showTitle, ...rest } = props;
+    return (_jsx(RebookingRadioGroup, { options: buildOptions(), title: showTitle ? t('Choose Rebooking offer') : undefined, ...rest }));
+});
+export default RebookingRadioGroupContainer;

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

@@ -0,0 +1,5 @@
+import './RoutePlanner.scss';
+import React from 'react';
+declare function RoutePlanner(): React.JSX.Element | null;
+export default RoutePlanner;
+//# sourceMappingURL=RoutePlanner.d.ts.map

package/dist/esm/components/RoutePlanner/RoutePlanner.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+import './RoutePlanner.scss';
+import { useObserver } from 'mobx-react-lite';
+import store, { uiState } from '../../store';
+import { Route } from '../../store/RouteStore';
+import { t } from '../../utils/i18n';
+import WayfindingFloorSelector from '../WayfindingFloorSelectorContainer';
+import RoutePlannerHeader from './RoutePlannerHeader';
+import RoutePlannerStartPoint from './RoutePlannerStartPoint';
+import RoutePlannerStopItem from './RoutePlannerStopItem';
+function RoutePlannerContent() {
+    return useObserver(() => {
+        const planner = store.routePlannerStore;
+        const items = planner.items;
+        return (_jsxs("div", { className: "efp-planner", children: [items.length > 0 && _jsx(RoutePlannerHeader, {}), items.length > 0 && planner.routeFloors.length > 1 && planner.currentRouteFloor && (_jsx(WayfindingFloorSelector, { floors: planner.routeFloors, value: planner.currentRouteFloor, onSelect: (floor) => planner.setRouteFloor(floor) })), _jsxs("div", { className: "efp-planner__stops", children: [items.length > 0 && (_jsx(RoutePlannerStartPoint, { startPoint: planner.startPoint, onSelectStartPoint: (booth) => planner.setStartPoint(booth) })), items.map((item, index) => (_jsx(RoutePlannerStopItem, { item: item, isLast: index === items.length - 1 }, `${item.type}-${item.entity.id}-${index}`)))] }), items.length === 0 && (_jsx("div", { className: "efp-planner__empty", children: t('Add stops to build a route') }))] }));
+    });
+}
+function RoutePlanner() {
+    return useObserver(() => {
+        const hasEntityDetails = uiState.details && !(uiState.details instanceof Route);
+        return uiState.list.type === 'route-planner' && !uiState.menu && !hasEntityDetails ? (_jsx(RoutePlannerContent, {})) : null;
+    });
+}
+export default RoutePlanner;

package/dist/esm/components/RoutePlanner/RoutePlannerHeader.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare const RoutePlannerHeader: React.FC;
+export default RoutePlannerHeader;
+//# sourceMappingURL=RoutePlannerHeader.d.ts.map

package/dist/esm/components/RoutePlanner/RoutePlannerHeader.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { observer } from 'mobx-react-lite';
+import store from '../../store';
+import { t } from '../../utils/i18n';
+import Alert from '../AlertContainer';
+const RoutePlannerHeader = observer(() => {
+    const planner = store.routePlannerStore;
+    const { from, stops, distance, travelTime } = planner.subtitleParts;
+    return (_jsxs("div", { className: "efp-planner__header", children: [_jsx("div", { className: "efp-planner__title", children: planner.title }), _jsxs("div", { className: "efp-planner__details", children: [from && _jsx("span", { children: from }), _jsx("span", { children: stops }), distance && _jsx("span", { children: distance }), travelTime && _jsx("span", { children: travelTime })] }), planner.excludedVisitedCount > 0 && (_jsx("div", { className: "efp-planner__alert", children: _jsx(Alert, { variant: "warning", inline: true, showIcon: false, size: "sm", children: t('{{count}} visited bookmarks excluded', { count: planner.excludedVisitedCount }) }) }))] }));
+});
+export default RoutePlannerHeader;

package/dist/esm/components/RoutePlanner/RoutePlannerStartPoint.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Booth } from '../../store/BoothStore';
+interface RoutePlannerStartPointProps {
+    startPoint: Booth | null;
+    onSelectStartPoint: (booth: Booth | null) => void;
+}
+declare const RoutePlannerStartPoint: React.FC<RoutePlannerStartPointProps>;
+export default RoutePlannerStartPoint;
+//# sourceMappingURL=RoutePlannerStartPoint.d.ts.map

package/dist/esm/components/RoutePlanner/RoutePlannerStartPoint.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+import { observer } from 'mobx-react-lite';
+import store from '../../store';
+import { t } from '../../utils/i18n';
+import Autocomplete from '../AutocompleteContainer';
+const StartPointIcon = () => (_jsxs("svg", { width: "22", height: "22", viewBox: "0 0 22 22", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [_jsx("rect", { width: "22", height: "22", rx: "11", fill: "#2382F4" }), _jsx("path", { d: "M16 11C16 13.7614 13.7614 16 11 16C8.23858 16 6 13.7614 6 11C6 8.23858 8.23858 6 11 6C13.7614 6 16 8.23858 16 11Z", fill: "white" })] }));
+const RoutePlannerStartPoint = observer(({ startPoint, onSelectStartPoint }) => {
+    const planner = store.routePlannerStore;
+    const allBooths = planner.startPointBoothOptions;
+    const options = planner.startPointAutocompleteOptions;
+    const handleSelect = (option) => {
+        const selected = allBooths.find((b) => b.id.toString() === option?.value) || null;
+        onSelectStartPoint(selected);
+    };
+    const value = startPoint
+        ? options.find((o) => o.value === startPoint.id.toString())
+        : undefined;
+    return (_jsxs("div", { className: "efp-planner__stop is-start", children: [_jsx("div", { className: "efp-planner__stop-timeline", children: _jsx(StartPointIcon, {}) }), _jsx("div", { className: "efp-planner__stop-content", children: _jsx(Autocomplete, { placeholder: t('Select starting point'), options: options, value: value, onChange: handleSelect }) })] }));
+});
+export default RoutePlannerStartPoint;

package/dist/esm/components/RoutePlanner/RoutePlannerStopItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type PlannerItem } from '../../store/RoutePlannerStore';
+interface RoutePlannerStopItemProps {
+    item: PlannerItem;
+    isLast: boolean;
+}
+declare const RoutePlannerStopItem: React.FC<RoutePlannerStopItemProps>;
+export default RoutePlannerStopItem;
+//# sourceMappingURL=RoutePlannerStopItem.d.ts.map

package/dist/esm/components/RoutePlanner/RoutePlannerStopItem.js

@@ -0,0 +1,41 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge } from '@expofp/ui';
+import cn from 'classnames';
+import store from '../../store';
+const TYPE_TO_ICON = {
+    exhibitor: 'icon-exhibitor-solid',
+    event: 'icon-event-solid',
+    booth: 'icon-booth-solid',
+};
+const shouldShowLevelPrefix = (value) => /^\d+$/.test(value);
+const RoutePlannerStopItem = ({ item, isLast }) => {
+    const { type, entity, booth } = item;
+    const iconClass = TYPE_TO_ICON[type] || 'icon-booth-solid';
+    const name = entity.name ?? '';
+    const boothName = (type === 'exhibitor' || type === 'event') && booth ? booth.name : null;
+    const level = booth?.layer?.shortName ?? null;
+    const hasDetails = boothName || level;
+    const ariaLabel = [
+        name,
+        boothName,
+        level ? (shouldShowLevelPrefix(level) ? `Level ${level}` : level) : null,
+    ]
+        .filter(Boolean)
+        .join(', ');
+    const handleClick = () => {
+        if (type === 'exhibitor') {
+            store.selectExhibitor(entity);
+        }
+        else if (booth) {
+            store.selectBooth(booth);
+        }
+        store.showMap();
+    };
+    return (_jsxs("div", { className: cn('efp-planner__stop', { 'is-last': isLast }), children: [_jsx("div", { className: "efp-planner__stop-timeline", children: _jsx("div", { className: "efp-planner__stop-icon", style: { '--dot-color': `var(--color-${type})` }, children: _jsx("i", { className: iconClass }) }) }), _jsxs("div", { className: "efp-planner__stop-content", role: "button", tabIndex: 0, "aria-label": ariaLabel, onClick: handleClick, onKeyDown: (e) => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        handleClick();
+                    }
+                }, children: [_jsx("strong", { children: name }), hasDetails && (_jsxs(Badge, { variant: "location", size: "xs", inline: true, noMargins: true, children: [boothName && _jsx("span", { children: boothName }), level && (_jsxs("span", { children: [shouldShowLevelPrefix(level) && _jsx(_Fragment, { children: "Level\u00A0" }), level] }))] }))] })] }));
+};
+export default RoutePlannerStopItem;

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

@@ -0,0 +1,12 @@
+import './RouteQR.scss';
+import React from 'react';
+export interface RouteQRProps {
+    url?: string;
+    /** Caption under the code. Defaults to the route wording the kiosk shows. */
+    label?: string;
+    /** Screen-reader name for the code. Defaults to the route wording. */
+    ariaLabel?: string;
+}
+declare const _default: React.FunctionComponent<RouteQRProps>;
+export default _default;
+//# sourceMappingURL=RouteQR.d.ts.map

package/dist/esm/components/RouteQR.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './RouteQR.scss';
+import { observer } from 'mobx-react-lite';
+import { Suspense } from 'react';
+import { t } from '../utils/i18n';
+import QrCode from '../utils/lazy-qr-code';
+const RouteQR = ({ url, label, ariaLabel }) => {
+    return (_jsx(Suspense, { fallback: null, children: _jsx("div", { className: "route-qr", children: _jsxs("div", { className: "route-qr__body", children: [_jsx("div", { className: "route-qr__code", role: "img", "aria-label": ariaLabel ?? t('QR code to open the route on your phone'), children: _jsx(QrCode, { value: url ?? '', size: 80 }) }), _jsx("div", { className: "route-qr__label", children: label ?? t('Scan to see route on your phone') })] }) }) }));
+};
+export default observer(RouteQR);

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

@@ -0,0 +1,13 @@
+import './Schedule.scss';
+import React from 'react';
+import { type EventItem } from '../store/EventStore';
+export interface ScheduleProps {
+    events: EventItem[];
+    descriptionMaxLength?: number;
+    showBooths?: boolean;
+    isSessions?: boolean;
+    onEventClick?: (event: EventItem) => void;
+}
+declare const Schedule: React.FC<ScheduleProps>;
+export default Schedule;
+//# sourceMappingURL=Schedule.d.ts.map