@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/components/Demo.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './Demo.scss';
+import classNames from 'classnames';
+import { useLocalStore, useObserver } from 'mobx-react-lite';
+import { uiState } from '../store';
+import { t } from '../utils/i18n';
+import { useInit } from '../utils/mobx';
+const key = 'note-dismissed5';
+export default function Demo() {
+    const s = useLocalStore(() => ({
+        hidden: true,
+        get top() {
+            return uiState.screenSize.width <= 820;
+        },
+        get classes() {
+            return classNames({
+                demo: true,
+                top: this.top,
+                hidden: this.hidden,
+            });
+        },
+    }));
+    useInit(() => {
+        if (sessionStorage.getItem(key))
+            return;
+        const timer = window.setTimeout(() => {
+            s.hidden = false;
+        }, 2000);
+        return () => window.clearTimeout(timer);
+    });
+    return useObserver(() => (_jsx("div", { className: s.classes, children: _jsxs("section", { children: [_jsx("div", { className: "demo__message", children: _jsxs("span", { children: [t('Get your free floor plan at'), "\u00A0", _jsx("a", { href: "https://expofp.com/", target: "_blank", rel: "noopener noreferrer", children: "ExpoFP.com" })] }) }), _jsx("a", { href: "/", onClick: dismiss, className: "demo__dismiss", children: t('Dismiss') })] }) })));
+    function dismiss(e) {
+        e.preventDefault();
+        s.hidden = true;
+        sessionStorage.setItem(key, '1');
+    }
+}

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

@@ -0,0 +1,5 @@
+import { type DownloadListProps } from '@expofp/ui';
+type DownloadListContainerProps = Omit<DownloadListProps, 'title' | 'downloadLabel'>;
+declare const DownloadListContainer: import("react").FunctionComponent<DownloadListContainerProps>;
+export default DownloadListContainer;
+//# sourceMappingURL=DownloadListContainer.d.ts.map

package/dist/esm/components/DownloadListContainer.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DownloadList } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { t } from '../utils/i18n';
+const DownloadListContainer = observer((props) => {
+    return (_jsx(DownloadList, { ...props, title: t('Read More'), downloadLabel: (fileName) => t('Download {{fileName}}', { fileName }) }));
+});
+export default DownloadListContainer;

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

@@ -0,0 +1,28 @@
+import { type EntityItemAdditionalInfo } from '@expofp/ui';
+import React from 'react';
+export type EntityItemKind = 'booth' | 'exhibitor' | 'event' | 'speaker' | 'category';
+export interface EntityItemContainerProps {
+    id: string;
+    kind: EntityItemKind;
+    title: string;
+    subtitle?: string;
+    image?: string;
+    icon?: string;
+    itemsCount?: number;
+    date?: string;
+    time?: string;
+    additionalInfo?: EntityItemAdditionalInfo[];
+    bookmarked?: boolean;
+    featured?: boolean;
+    visited?: boolean;
+    current?: boolean;
+    heatmapColor?: string;
+    accentBorderColor?: string;
+    hideUserState?: boolean;
+    compactDetails?: boolean;
+    secondaryText?: string;
+    onClick?: (id: string) => void;
+}
+declare const EntityItemContainer: React.FunctionComponent<EntityItemContainerProps>;
+export default EntityItemContainer;
+//# sourceMappingURL=EntityItemContainer.d.ts.map

package/dist/esm/components/EntityItemContainer.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import { EntityItem } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { uiState } from '../store';
+import { t } from '../utils/i18n';
+import { isNumericLevel } from '../utils/isNumericLevel';
+const KIND_CONFIG = {
+    booth: { typeColor: 'var(--color-booth)' },
+    exhibitor: { typeColor: 'var(--color-exhibitor)' },
+    event: { typeColor: 'var(--color-event)', hasDatetime: true },
+    speaker: { typeColor: 'var(--color-speaker)', variant: 'person' },
+    category: { typeColor: 'var(--color-category)', hasTitleBadge: true, hasSubtitleLabel: true },
+};
+const withDerivedLevelLabel = (info) => info.type === 'location' ? { ...info, showLevelLabel: isNumericLevel(info.level) } : info;
+const EntityItemContainer = observer(({ kind, itemsCount, date, time, additionalInfo, ...rest }) => {
+    const config = KIND_CONFIG[kind];
+    const datetime = config.hasDatetime && (date || time) ? { date, time } : undefined;
+    const highlight = uiState.list.type === 'search' ? uiState.list.text : undefined;
+    const pureProps = {
+        ...rest,
+        additionalInfo: additionalInfo?.map(withDerivedLevelLabel),
+        typeColor: config.typeColor,
+        iconClassName: `icon-${kind}-solid`,
+        variant: config.variant ?? 'default',
+        titleBadge: config.hasTitleBadge ? itemsCount : undefined,
+        datetime,
+        subtitleLabel: config.hasSubtitleLabel ? t('Category') : undefined,
+        highlight,
+        featuredLabel: t('Featured'),
+        hallLabel: t('Hall'),
+        levelLabel: t('Level'),
+    };
+    return _jsx(EntityItem, { ...pureProps });
+});
+export default EntityItemContainer;

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

@@ -0,0 +1,9 @@
+import './EntityList.scss';
+import React, { RefObject } from 'react';
+interface ListProps {
+    updatedScrollableRef: RefObject<HTMLElement | null>;
+    updateScroll?: () => void;
+}
+declare const _default: React.FunctionComponent<ListProps>;
+export default _default;
+//# sourceMappingURL=EntityList.d.ts.map

package/dist/esm/components/EntityList.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable @eslint-react/static-components, @eslint-react/no-nested-component-definitions */
+/* eslint-disable @eslint-react/exhaustive-deps, no-case-declarations, @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import './EntityList.scss';
+import { OverlayScrollContext, Spinner } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { lazy, Suspense, useCallback, useContext, useEffect, useRef, } from 'react';
+import store, { uiState } from '../store';
+import settings from '../tools/settings';
+import { t } from '../utils/i18n';
+import EntityListRow from './EntityListRow';
+import { groupItemsByVenue, isVenueSeparator } from './utils/entity-venue-grouping';
+const importVirtuoso = () => import(/* webpackChunkName: "react-virtuoso-entity-list" */ 'react-virtuoso')
+    .then((mod) => ({ default: mod.Virtuoso }))
+    .catch(() => new Promise((resolve) => setTimeout(() => resolve(importVirtuoso()), 3000)));
+const LazyVirtuoso = lazy(importVirtuoso);
+const EXPOS_WITH_COMPACT_DETAILS = ['ipia2025'];
+const EntityList = ({ updatedScrollableRef, updateScroll }) => {
+    const scrollContainerFromContext = useContext(OverlayScrollContext);
+    const virtuosoRef = useRef(null);
+    const listScrollItemId = uiState.getListScrollItemId(uiState.list.type);
+    const useCompactDetails = EXPOS_WITH_COMPACT_DETAILS.includes(settings.EXPO);
+    // Venue-aware search (R9): focused venue's results first, the rest under a
+    // "results in other venues" separator row. Computed before the scroll-restore
+    // effect because Virtuoso renders these rows — restoring an index against the
+    // ungrouped listItems would scroll to the wrong row on multi-venue plans.
+    const venueIdOfItem = (item) => {
+        const layerName = item?.layer?.name ??
+            item?.booths?.[0]?.layer?.name ??
+            (item?.boothId ? store.boothStore.boothById.get(item.boothId)?.layer?.name : undefined);
+        const venue = layerName ? store.venueStore.venueOfLayer(layerName) : null;
+        return venue ? venue.id : null;
+    };
+    const rows = store.venueStore.hasVenueModel && uiState.list.type === 'search'
+        ? groupItemsByVenue({
+            items: uiState.listItems,
+            venueIdOf: venueIdOfItem,
+            focusedVenueId: store.venueStore.focusedVenueId,
+            venueOrder: store.venueStore.orderedVenues.map((venue) => venue.id),
+            separatorLabel: t('Results in other venues'),
+        })
+        : uiState.listItems;
+    useEffect(() => {
+        const savedScrollTop = uiState.getListScrollTop(uiState.list.type);
+        const savedItemId = uiState.getListScrollItemId(uiState.list.type);
+        if (savedScrollTop > 0 || savedItemId) {
+            setTimeout(() => {
+                if (virtuosoRef.current) {
+                    if (savedItemId) {
+                        const itemIndex = rows.findIndex((item) => !isVenueSeparator(item) && item?.id?.toString() === savedItemId.toString());
+                        if (itemIndex !== -1) {
+                            virtuosoRef.current.scrollToIndex({
+                                index: itemIndex,
+                                align: 'center',
+                                behavior: 'auto',
+                            });
+                            return;
+                        }
+                    }
+                    if (savedScrollTop > 0) {
+                        virtuosoRef.current.scrollTo({
+                            top: savedScrollTop,
+                            behavior: 'auto',
+                        });
+                    }
+                }
+            }, 100);
+        }
+    }, [uiState.list.type]);
+    const showRouteInstantly = uiState.showRouteInstantly;
+    const handleClick = useCallback((type, data) => {
+        const id = parseInt(data, 10);
+        uiState.setListScrollItemId(uiState.list?.type, id);
+        if (virtuosoRef.current) {
+            virtuosoRef.current.getState((state) => {
+                const scrollTop = state?.scrollTop || 0;
+                uiState.setListScrollTop(uiState.list?.type, scrollTop);
+            });
+        }
+        else if (updatedScrollableRef.current) {
+            uiState.setListScrollTop(uiState.list?.type, updatedScrollableRef.current.scrollTop || 0);
+        }
+        switch (type) {
+            case 'exhibitor':
+                const exhibitor = store.exhibitorStore.exhibitors.find((e) => e.id === id);
+                if (showRouteInstantly) {
+                    store.routeStore.clickRoute(null, store.routeStore.tempToBooth || exhibitor.booths[0]);
+                }
+                else {
+                    store.clickExhibitor(exhibitor);
+                }
+                break;
+            case 'booth':
+                const booth = store.boothStore.booths.find((b) => b.id === id);
+                if (showRouteInstantly) {
+                    store.routeStore.clickRoute(null, booth);
+                }
+                else {
+                    store.clickBoothInList2(booth);
+                }
+                break;
+            case 'category':
+                store.clickCategory(store.categoryStore.categories.find((c) => c.id === id));
+                break;
+            case 'event':
+                const event = store.eventStore.eventItems.find((e) => e.id === id);
+                if (event) {
+                    const booth = store.boothStore.booths.find((b) => b.id === event.boothId);
+                    if (showRouteInstantly && booth) {
+                        store.routeStore.clickRoute(null, booth);
+                    }
+                    else {
+                        store.selectEventItem(event, true);
+                    }
+                }
+                break;
+            case 'speaker': {
+                const speaker = store.speakerStore.speakers.find((s) => s.id === id);
+                if (speaker) {
+                    store.selectSpeaker(speaker, true);
+                }
+                break;
+            }
+        }
+    }, [showRouteInstantly, updatedScrollableRef]);
+    const EmptyPlaceholder = () => (_jsx("div", { className: "list-empty", children: uiState.list.type === 'search' ? t('Oops, nothing found') : t('No items to show') }));
+    if (scrollContainerFromContext === null || uiState.setKioskModeEnabled)
+        return null;
+    if (!uiState.listItems.length)
+        return _jsx(EmptyPlaceholder, {});
+    return (_jsx("div", { style: { height: '100%', cursor: 'pointer', resize: 'both', minHeight: 100 }, children: _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: rows, itemContent: (index, data) => {
+                    const item = data;
+                    if (!item) {
+                        return null;
+                    }
+                    if (isVenueSeparator(item)) {
+                        return _jsx("div", { className: "list-venue-separator", children: item.label });
+                    }
+                    const current = listScrollItemId?.toString() === item.id?.toString();
+                    return (_jsx(EntityListRow, { item: item, index: index, current: current, compactDetails: useCompactDetails, onClick: handleClick }, item.id));
+                }, itemsRendered: () => updateScroll && setTimeout(updateScroll), totalListHeightChanged: () => updateScroll && updateScroll(), customScrollParent: scrollContainerFromContext, totalCount: rows.length, overscan: 20, increaseViewportBy: 200, initialItemCount: Math.min(uiState.listScrollIndex + 30, rows.length) }) }) }));
+};
+export default observer(EntityList);

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { ListItem } from '../store/types';
+import { type EntityItemKind } from './EntityItemContainer';
+interface Props {
+    item: ListItem;
+    index: number;
+    current: boolean;
+    compactDetails?: boolean;
+    onClick: (kind: EntityItemKind, id: string) => void;
+}
+declare const _default: React.FunctionComponent<Props>;
+export default _default;
+//# sourceMappingURL=EntityListRow.d.ts.map

package/dist/esm/components/EntityListRow.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable @eslint-react/rules-of-hooks */
+// @ts-nocheck
+import dateFormat from 'dateformat';
+import { observer } from 'mobx-react-lite';
+import data from '../data';
+import store, { boothStore, uiState } from '../store';
+import { BoothBase } from '../store/BoothStore';
+import { Category } from '../store/CategoryStore';
+import { EventItem } from '../store/EventStore';
+import { Exhibitor } from '../store/ExhibitorStore';
+import { HeatmapYah } from '../store/HeatmapStore';
+import { SpeakerItem } from '../store/SpeakerStore';
+import { rebookingStateConfig } from '../tools/rebooking-config';
+import useHeatmapData from '../utils/useHeatmapData';
+import EntityItemContainer from './EntityItemContainer';
+import { formatVenueLevelLabel } from './utils/entity-venue-grouping';
+import YahRow from './YahRow';
+// Venue-model plans prefix the level with its venue name ("North Hall - 2");
+// single-level venues read as just the venue name (R9 row context).
+const locationLevel = (layer) => {
+    const venue = store.venueStore.hasVenueModel ? store.venueStore.venueOfLayer(layer?.name) : null;
+    const venueLevel = venue?.levels.find((level) => level.layer.name === layer?.name);
+    const levelName = venueLevel?.displayName ?? layer?.description ?? '';
+    if (!venue)
+        return data.shortLevelName ? layer?.shortName || levelName : levelName;
+    return venue.levels.length > 1 && levelName
+        ? formatVenueLevelLabel(venue.name, levelName)
+        : venue.name;
+};
+const EntityListRow = ({ item, index, current, compactDetails, onClick }) => {
+    let heatmap = { background: undefined, clicks: undefined };
+    if (uiState.heatmap &&
+        (item instanceof Exhibitor || item instanceof BoothBase || item instanceof HeatmapYah)) {
+        heatmap = useHeatmapData(item);
+    }
+    const foundInDescription = uiState.foundInDescriptionStruct[item.id];
+    if (item instanceof Exhibitor) {
+        const kind = 'exhibitor';
+        return (_jsx(EntityItemContainer, { onClick: (id) => onClick(kind, id), id: item.id.toString(), featured: item.featured, kind: kind, image: item.logo?.url, title: item.name, bookmarked: item.bookmarked, visited: item.visited, additionalInfo: item.booths.map((booth) => ({
+                type: 'location',
+                locationName: booth.name,
+                level: locationLevel(booth.layer),
+            })), current: current, compactDetails: compactDetails, heatmapColor: heatmap.background, accentBorderColor: data.isRebooking
+                ? rebookingStateConfig[item.rebookingState]?.color.primary
+                : undefined, hideUserState: uiState.kiosk, secondaryText: foundInDescription }));
+    }
+    if ('rect' in item) {
+        return (_jsx(EntityItemContainer, { onClick: (id) => onClick('booth', id), id: item.id.toString(), kind: "booth", title: item.name, icon: item.poiIcon, bookmarked: item.bookmarked, current: current, heatmapColor: heatmap.background, secondaryText: foundInDescription }));
+    }
+    if (item instanceof Category) {
+        return (_jsx(EntityItemContainer, { onClick: (id) => onClick('category', id), id: item.id.toString(), itemsCount: item.exhibitors.length, kind: "category", title: item.name, current: current, secondaryText: foundInDescription }));
+    }
+    if (item instanceof SpeakerItem) {
+        const additionalInfo = [];
+        if (item.jobTitle) {
+            additionalInfo.push({ type: 'text', text: item.jobTitle });
+        }
+        return (_jsx(EntityItemContainer, { id: item.id.toString(), kind: "speaker", title: item.name, subtitle: item.company, image: item.photoFile, additionalInfo: additionalInfo, bookmarked: item.bookmarked, onClick: () => store.selectSpeaker(item, true), secondaryText: foundInDescription }, item.id));
+    }
+    if (item instanceof EventItem) {
+        const booth = item.boothId ? boothStore.booths.find((b) => b.id === item.boothId) : null;
+        return (_jsx(EntityItemContainer, { id: item.id.toString(), onClick: (id) => onClick('event', id), kind: "event", title: item.name, date: dateFormat(item.startDate, 'dd mmm ddd'), time: `${dateFormat(item.startDate, 'h:MM')} - ${dateFormat(item.endDate, 'h:MM')}`, additionalInfo: booth
+                ? [
+                    {
+                        type: 'location',
+                        locationName: booth.name,
+                        level: locationLevel(booth.layer),
+                    },
+                ]
+                : [], bookmarked: item.bookmarked, visited: item.visited, current: current, hideUserState: uiState.kiosk, secondaryText: foundInDescription }));
+    }
+    if (item instanceof HeatmapYah) {
+        return _jsx(YahRow, { yah: item, active: index === uiState.activeListIndex });
+    }
+    return null;
+};
+export default observer(EntityListRow);

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

@@ -0,0 +1,15 @@
+import React from 'react';
+interface ErrorBoundaryProps {
+    children: React.ReactNode;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+}
+export default class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined> | null | undefined;
+}
+export {};
+//# sourceMappingURL=ErrorBoundary.d.ts.map

package/dist/esm/components/ErrorBoundary.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { captureException } from '@sentry/react';
+import React from 'react';
+export default class ErrorBoundary extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.state = { hasError: false };
+    }
+    static getDerivedStateFromError() {
+        // Update state so the next render will show the fallback UI.
+        return { hasError: true };
+    }
+    componentDidCatch(error, errorInfo) {
+        captureException(error, {
+            contexts: {
+                react: {
+                    componentStack: errorInfo.componentStack,
+                },
+            },
+        });
+    }
+    render() {
+        if (this.state.hasError) {
+            // You can render any custom fallback UI
+            return _jsx("h4", { style: { textAlign: 'center' }, children: "Not available offline." });
+        }
+        return this.props.children;
+    }
+}

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

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

package/dist/esm/components/Event.js

@@ -0,0 +1,167 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @ts-nocheck
+import './Event.scss';
+import { Button } from '@expofp/ui';
+import classNames from 'classnames';
+import dateFormat from 'dateformat';
+import { observer, useLocalStore, useObserver } from 'mobx-react-lite';
+import { useEffect, useRef, useState } from 'react';
+import data from '../data';
+import store, { uiState } from '../store';
+import { GaEventActions, sendEventToGa } from '../tools/gtag';
+import settings from '../tools/settings';
+import trackEvent from '../tools/track-event';
+import { useReaction } from '../utils/mobx';
+import sanitizeHTML from '../utils/sanitizeHtml';
+import EventBadgeContainer from './EventBadgeContainer';
+import ShowMoreButton from './ShowMoreButtonContainer';
+import SidebarActions from './SidebarActionsContainer';
+import { getDescription } from './utils/getDescription';
+function EventComponent() {
+    const el = useRef(null);
+    const s = useLocalStore(() => ({
+        collapsed: true,
+        updateOverlayContent: null,
+        get event() {
+            return uiState.selectedEventItem;
+        },
+        get booth() {
+            return this.event?.boothId ? store.boothStore.boothById.get(this.event.boothId) : null;
+        },
+        get disableCollapse() {
+            return !data.collapseDescriptions || (this.event?.description || '').length < 800;
+        },
+    }));
+    const [isContentOverflowing, setIsContentOverflowing] = useState(false);
+    const [showKioskDetails, setShowKioskDetails] = useState(false);
+    const detailsRef = useRef(null);
+    useEffect(() => {
+        const checkHeight = () => {
+            if (detailsRef.current) {
+                const height = detailsRef.current.offsetHeight;
+                setIsContentOverflowing(height > 300);
+            }
+        };
+        checkHeight();
+    }, []);
+    useReaction(() => s.event, () => {
+        if (el.current && el.current.parentElement) {
+            el.current.parentElement.scrollTop = 0;
+        }
+        s.collapsed = true;
+        setShowKioskDetails(false);
+    });
+    function handleClick(e, action) {
+        itemClick(action);
+        if (uiState.kiosk)
+            return e.preventDefault();
+    }
+    function itemClick(action) {
+        if (s.event) {
+            sendEventToGa(action, s.event.name);
+        }
+    }
+    const formatTime = (date) => {
+        const use24hFormat = store.sessionsFilterStore.state.filters.use24hFormat.value;
+        const d = new Date(date);
+        return dateFormat(d, use24hFormat ? 'HH:MM' : 'h:MMtt');
+    };
+    const formatDate = (date) => {
+        const d = new Date(date);
+        return dateFormat(d, 'dddd, mmmm d, yyyy');
+    };
+    return useObserver(() => {
+        const event = s.event;
+        if (!event)
+            return null;
+        const bar = (_jsxs(_Fragment, { children: [_jsx("div", { className: "efp-event__bar", children: _jsx("span", { onClick: () => store.toggleMapOverlay(), children: _jsxs("div", { className: "efp-event__bar-name", children: [_jsx("div", { className: "efp-event__bar-icon", children: _jsx("i", { className: "icon-event-solid" }) }), _jsxs("span", { dir: "auto", children: [event.name, _jsx(EventBadgeContainer, { event: event })] })] }) }) }), _jsx("div", { className: "efp-event__bar-booth", onClick: () => store.toggleMapOverlay(), children: data.boothTerm })] }));
+        const expandDescription = () => {
+            s.collapsed = false;
+            setTimeout(s.updateOverlayContent);
+        };
+        function renderButton(title, url) {
+            if (!title || !url || uiState.kiosk || uiState.previewMode)
+                return null;
+            return (_jsx("div", { className: "event-custom-button", children: _jsx(Button, { link: url, inline: true, onClick: (e) => {
+                        e.preventDefault();
+                        itemClick(GaEventActions.ClickCustomButton);
+                        window.open(url, '_blank', 'noopener,noreferrer');
+                    }, target: "_blank", children: title }) }));
+        }
+        const cls = classNames({
+            'efp-event': true,
+            [uiState.responsiveClass]: true,
+        });
+        return (_jsxs("div", { className: cls, children: [_jsxs("div", { className: "efp-event__header", children: [_jsxs("div", { className: "efp-event__header-name", children: [_jsx("div", { className: "efp-event__header-icon", children: _jsx("i", { className: "icon-event-solid" }) }), _jsxs("span", { dir: "auto", children: [event.name, _jsx(EventBadgeContainer, { event: event })] })] }), _jsx("button", { type: "button", onClick: () => store.searchStore.handleBackAction(), className: "efp-event__header-close", children: _jsx("i", { className: "icon-close" }) })] }), _jsx("div", { className: "efp-event__buttons", children: !uiState.isGuidedToursActive && (_jsx(SidebarActions, { showBookmark: !uiState.disableBookmarked && !data.hideBookmarks && !uiState.kiosk, showDirections: s.booth && settings.wayfinding, inBookmark: s.event?.bookmarked || false, showShare: true, showVisited: !uiState.kiosk, visited: s.event?.visited || false, onClickBookmark: bookmark, onClickShare: handleShare, onClickDirections: () => {
+                            if (s.booth) {
+                                store.routeStore.clickRoute(null, s.booth);
+                            }
+                        }, onClickVisited: handleVisited })) }), _jsxs("div", { className: classNames('efp-event__details', {
+                        'details-hidden': uiState.kiosk &&
+                            data.collapseDescriptions &&
+                            isContentOverflowing &&
+                            !showKioskDetails,
+                    }), ref: detailsRef, children: [_jsxs("div", { className: classNames('efp-event-booths', {
+                                'is-links-disabled': uiState.isGuidedToursActive,
+                            }), children: [s.booth && (_jsxs("a", { href: `?${s.booth.slug}`, onClick: (e) => {
+                                        e.preventDefault();
+                                        store.toggleMapOverlay();
+                                        store.selectBooth(s.booth);
+                                    }, className: "efp-event-booths__booth", children: [_jsx("div", { className: "efp-event-booths__booth-name", children: s.booth.name }), s.booth.layer && (_jsx("div", { className: "efp-event-categories__booth-level", children: data.shortLevelName ? s.booth.layer.shortName : s.booth.layer.description }))] })), event.hasTracks &&
+                                    event.tracks.map((track) => (_jsx("div", { className: "efp-event-booths__track", children: track.name }, track.id)))] }), _jsxs("div", { className: "efp-event-list", children: [_jsxs("div", { className: "efp-event-list__block", children: [_jsx("div", { className: "efp-event-list__block-icon", children: _jsx("i", { className: "icon-event-solid" }) }), _jsx("div", { className: "efp-event-list__block-content", children: _jsx("div", { className: "efp-event-list__block-item", children: _jsxs("div", { className: "efp-event-list__block-info", children: [_jsx("div", { className: "efp-event-list__block-title", children: formatDate(event.startDate) }), _jsxs("div", { className: "efp-event-list__block-description", children: [formatTime(event.startDate), " to", ' ', event.endDate ? formatTime(event.endDate) : '-'] })] }) }) })] }), event.hasSpeakers && (_jsxs("div", { className: "efp-event-list__block", children: [_jsx("div", { className: "efp-event-list__block-icon", children: _jsx("i", { className: "icon-speaker-solid" }) }), _jsx("div", { className: "efp-event-list__block-content", children: event.speakers.map((speaker) => (_jsxs("a", { href: `?${speaker.slug}`, onClick: (e) => {
+                                                    e.preventDefault();
+                                                    store.selectSpeaker(speaker, true);
+                                                }, className: "efp-event-list__block-item efp-event-list__block-item--clickable", children: [speaker.photoFile && (_jsx("div", { className: "efp-event-list__block-avatar", children: _jsx("img", { src: speaker.photoFile, alt: speaker.name }) })), _jsxs("div", { className: "efp-event-list__block-info", children: [_jsx("div", { className: "efp-event-list__block-title", children: speaker.name }), _jsxs("div", { className: "efp-event-list__block-description", children: [speaker.company && _jsx("strong", { children: speaker.company }), speaker.jobTitle && _jsx("span", { children: speaker.jobTitle })] })] })] }, speaker.id))) })] }))] }), (event.description || event.logoFile) && (_jsxs("div", { className: classNames('efp-event-description', {
+                                collapsed: s.collapsed && !s.disableCollapse && !uiState.kiosk,
+                            }), children: [event.logoFile && (_jsx("div", { className: classNames('efp-event-description__logo', {
+                                        'efp-event-description__logo--left': !event.description,
+                                    }), children: _jsx("img", { src: event.logoFile, alt: event.name, crossOrigin: "anonymous" }) })), event.description && (_jsx("span", { className: "event-description__content", dir: "auto", dangerouslySetInnerHTML: {
+                                        __html: sanitizeHTML(getDescription(event.description)),
+                                    }, onClick: expandDescription }))] }))] }), uiState.kiosk && data.collapseDescriptions && isContentOverflowing && (_jsx(ShowMoreButton, { className: classNames('efp-event__show-more', { 'is-sticky': showKioskDetails }), expanded: showKioskDetails, onClick: () => setShowKioskDetails((current) => !current) }))] }));
+    });
+}
+function handleShare() {
+    const event = uiState.selectedEventItem;
+    if (!event)
+        return;
+    sendEventToGa(GaEventActions.ClickCustomButton, event.name);
+    store.toggleModal('share');
+}
+function bookmark() {
+    const event = uiState.selectedEventItem;
+    if (!event)
+        return;
+    event.bookmarked = !event.bookmarked;
+    if (uiState.onBookmarkClick) {
+        uiState.onBookmarkClick({
+            name: event.name,
+            bookmarked: event.bookmarked,
+            externalId: event.externalId,
+        });
+    }
+    sendEventToGa(GaEventActions.ClickBookmark, event.name);
+    if (event.bookmarked) {
+        trackEvent('bookmark', event.name, 'session');
+    }
+}
+function handleVisited() {
+    const event = uiState.selectedEventItem;
+    if (!event)
+        return;
+    event.visited = !event.visited;
+    if (uiState.onVisitedClick) {
+        uiState.onVisitedClick({
+            name: event.name,
+            visited: event.visited,
+            externalId: event.externalId,
+        });
+    }
+    sendEventToGa(GaEventActions.ClickCustomButton, event.name);
+}
+const EventWrapper = observer(() => {
+    if (!uiState.selectedEventItem)
+        return null;
+    return _jsx(EventComponent, {});
+});
+export default EventWrapper;

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

@@ -0,0 +1,8 @@
+import { type EventBadgeProps } from '@expofp/ui';
+import type { EventItem } from '../store/EventStore';
+interface EventBadgeContainerProps extends Omit<EventBadgeProps, 'status' | 'statusLabel' | 'showFullBadge' | 'fullLabel' | 'isUrgent'> {
+    event: EventItem;
+}
+declare const EventBadgeContainer: import("react").FunctionComponent<EventBadgeContainerProps>;
+export default EventBadgeContainer;
+//# sourceMappingURL=EventBadgeContainer.d.ts.map

package/dist/esm/components/EventBadgeContainer.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EventBadge } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { useEffect, useState } from 'react';
+import { shouldShowEventFullBadge } from '../utils/eventFullBadge';
+import { calculateTimeUntilStart, getEventStatus, getEventStatusLabel, } from '../utils/eventTime';
+import { t } from '../utils/i18n';
+function useEventStatus(event) {
+    const [now, setNow] = useState(() => Date.now());
+    const timeUntil = calculateTimeUntilStart(event.startDate, now);
+    const status = getEventStatus(event, now, timeUntil);
+    const needsTimer = status !== 'past' && status !== 'none';
+    useEffect(() => {
+        if (!needsTimer)
+            return;
+        const interval = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(interval);
+    }, [needsTimer]);
+    return {
+        status,
+        statusLabel: getEventStatusLabel(status, timeUntil),
+        isUrgent: status === 'starting-soon' && timeUntil.isLessThan10Minutes,
+    };
+}
+const EventBadgeContainer = observer(({ event, ...restProps }) => {
+    const { status, statusLabel, isUrgent } = useEventStatus(event);
+    return (_jsx(EventBadge, { status: status, statusLabel: statusLabel, showFullBadge: shouldShowEventFullBadge(event), fullLabel: t('EVENT IS FULL'), isUrgent: isUrgent, ...restProps }));
+});
+export default EventBadgeContainer;

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

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