@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/components/Sessions.js

@@ -0,0 +1,128 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './Sessions.scss';
+import { OverlayHeaderContext } from '@expofp/ui';
+import Fuse from 'fuse.js';
+import { observer } from 'mobx-react-lite';
+import { use, useMemo } from 'react';
+import { createPortal } from 'react-dom';
+import store, { searchStore, uiState } from '../store';
+import { SESSIONS_LIST_TYPE } from '../store/types';
+import { t } from '../utils/i18n';
+import SessionsList from './SessionsList';
+import { ShortcutsToolbar } from './Shortcuts';
+const Sessions = observer(({ showFilters = true }) => {
+    const header = use(OverlayHeaderContext);
+    const events = store.eventStore.eventItems;
+    const { filters: { date: { value: dateFilter }, timeOfDay: { value: timeOfDayFilter }, sortOrder: { value: sortOrder }, showBookmarksOnly: { value: showBookmarksOnly }, showLiveOnly: { value: showLiveOnly }, selectedTracks: { value: selectedTracks }, selectedVenues: { value: selectedVenues }, }, } = store.sessionsFilterStore.state;
+    const { searchText } = searchStore;
+    const { selectedTrack } = uiState;
+    // Keys the memo: bookmark flags change inside `events`, which the memo can't see.
+    const bookmarkedEvents = showBookmarksOnly ? store.eventStore.bookmarked : null;
+    const filteredEvents = useMemo(() => {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const tomorrow = new Date(today);
+        tomorrow.setDate(today.getDate() + 1);
+        let filtered = events;
+        if (dateFilter !== 'all') {
+            filtered = filtered.filter((event) => {
+                const eventDate = new Date(event.startDate);
+                eventDate.setHours(0, 0, 0, 0);
+                if (dateFilter === 'today') {
+                    return eventDate.getTime() === today.getTime();
+                }
+                if (dateFilter === 'tomorrow') {
+                    return eventDate.getTime() === tomorrow.getTime();
+                }
+                if (dateFilter === 'past') {
+                    const now = new Date();
+                    const eventEnd = new Date(event.endDate);
+                    return eventEnd < now;
+                }
+                return true;
+            });
+        }
+        if (timeOfDayFilter !== 'all' && dateFilter === 'today') {
+            filtered = filtered.filter((event) => {
+                const eventTime = new Date(event.startDate);
+                const hour = eventTime.getHours();
+                switch (timeOfDayFilter) {
+                    case 'morning':
+                        return hour >= 6 && hour < 12;
+                    case 'midday':
+                        return hour >= 12 && hour < 18;
+                    case 'afternoon':
+                        return hour >= 18 && hour <= 23;
+                    default:
+                        return true;
+                }
+            });
+        }
+        if (selectedTrack) {
+            filtered = filtered.filter((event) => event.tracks.some((track) => track.id === selectedTrack.id));
+        }
+        if (bookmarkedEvents) {
+            const bookmarked = new Set(bookmarkedEvents);
+            filtered = filtered.filter((event) => bookmarked.has(event));
+        }
+        if (showLiveOnly) {
+            const now = new Date();
+            filtered = filtered.filter((event) => {
+                const start = new Date(event.startDate);
+                const end = new Date(event.endDate);
+                return start <= now && now <= end;
+            });
+        }
+        if (selectedTracks.length > 0) {
+            filtered = filtered.filter((event) => event.tracks.some((track) => selectedTracks.includes(track.id)));
+        }
+        if (selectedVenues.length > 0) {
+            filtered = filtered.filter((event) => event.boothId && selectedVenues.includes(event.boothId));
+        }
+        if (searchText) {
+            const fuseOptions = {
+                keys: ['name'],
+                threshold: 0.3,
+                ignoreLocation: true,
+                includeScore: true,
+            };
+            const fuse = new Fuse(filtered, fuseOptions);
+            const searchResults = fuse.search(searchText);
+            filtered = searchResults.map((result) => result.item);
+        }
+        return filtered;
+    }, [
+        events,
+        searchText,
+        dateFilter,
+        timeOfDayFilter,
+        selectedTrack,
+        bookmarkedEvents,
+        showLiveOnly,
+        selectedTracks,
+        selectedVenues,
+    ]);
+    const sortedEvents = useMemo(() => {
+        return [...filteredEvents].sort((a, b) => {
+            const dateA = new Date(a.startDate).getTime();
+            const dateB = new Date(b.startDate).getTime();
+            return sortOrder === 'asc' ? dateB - dateA : dateA - dateB;
+        });
+    }, [filteredEvents, sortOrder]);
+    const handleEventClick = (event) => {
+        uiState.setListScrollItemId(SESSIONS_LIST_TYPE, event.id);
+        store.selectEventItem(event, true);
+    };
+    return (_jsxs("div", { className: "efp-sessions-content", children: [showFilters &&
+                (header ? (createPortal(_jsx(ShortcutsToolbar, { interfaceId: "sessions" }), header)) : (_jsx(ShortcutsToolbar, { interfaceId: "sessions" }))), sortedEvents.length > 0 ? (_jsx(SessionsList, { events: sortedEvents, onEventClick: handleEventClick })) : (_jsx("div", { className: "efp-sessions-empty", children: store.sessionsFilterStore.activeFiltersCount > 0 || searchText || selectedTrack
+                    ? showBookmarksOnly
+                        ? t('No bookmarked events found. Try adjusting your filters.')
+                        : t('No events found. Try adjusting your filters.')
+                    : t('No events found') }))] }));
+});
+const SessionsWrapper = observer((props) => {
+    if (uiState.list.type !== 'sessions' || uiState.details)
+        return null;
+    return _jsx(Sessions, { ...props });
+});
+export default SessionsWrapper;

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

@@ -0,0 +1,11 @@
+import './SessionsFiltersModal.scss';
+import React from 'react';
+export interface SessionsFiltersModalProps {
+    store: any;
+    visibleSections?: ('tracks' | 'venues' | 'date' | 'time' | 'sort' | 'settings')[];
+    open?: boolean;
+    onClose?: () => void;
+}
+declare const SessionsFiltersModal: React.FC<SessionsFiltersModalProps>;
+export default SessionsFiltersModal;
+//# sourceMappingURL=SessionsFiltersModal.d.ts.map

package/dist/esm/components/SessionsFiltersModal.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/no-explicit-any, @eslint-react/exhaustive-deps */
+// @ts-nocheck
+import './SessionsFiltersModal.scss';
+import cn from 'classnames';
+import { observer } from 'mobx-react-lite';
+import { useMemo } from 'react';
+import { t } from '../utils/i18n';
+import { ModalContainer, ToggleSwitch } from './';
+import MultiSelectGroups from './MultiSelectGroupsContainer';
+const SessionsFiltersModal = observer(({ store, visibleSections, open, onClose }) => {
+    const pending = store.state.filters;
+    const hasActiveFilters = pending.date.pending !== 'all' ||
+        pending.sortOrder.pending !== 'desc' ||
+        pending.use24hFormat.pending !== false ||
+        pending.showBookmarksOnly.pending !== false ||
+        pending.selectedTracks.pending.length > 0 ||
+        pending.selectedVenues.pending.length > 0;
+    const futureEventsCount = useMemo(() => {
+        return store.rootStore.eventStore.futureEvents.length;
+    }, [store.rootStore.eventStore.futureEvents]);
+    const trackGroups = useMemo(() => {
+        const tracks = store.rootStore.eventStore.tracks;
+        if (!tracks.length)
+            return [];
+        return [
+            {
+                groupName: 'Tracks',
+                items: tracks.map((track) => ({
+                    id: track.id,
+                    name: track.name,
+                    countProvider: () => store.rootStore.eventStore.getEventsByTrack(track.id).length,
+                })),
+                showGroupActions: true,
+                fullWidth: true,
+            },
+        ];
+    }, [store.rootStore.eventStore.tracks]);
+    const venueGroups = useMemo(() => {
+        const venues = store.rootStore.eventStore.venues;
+        if (!venues.length)
+            return [];
+        return [
+            {
+                groupName: 'Venues',
+                items: venues.map((venue) => ({
+                    id: venue.id,
+                    name: venue.name,
+                    countProvider: () => store.rootStore.eventStore.getEventsByVenue(venue.id).length,
+                })),
+                showGroupActions: true,
+                fullWidth: true,
+            },
+        ];
+    }, [store.rootStore.eventStore.venues]);
+    const handleTrackChange = (selectedIds) => {
+        const trackIds = selectedIds.map((id) => Number(id));
+        store.setPending('selectedTracks', trackIds);
+    };
+    const handleVenueChange = (selectedIds) => {
+        const venueIds = selectedIds.map((id) => Number(id));
+        store.setPending('selectedVenues', venueIds);
+    };
+    const isOpen = open !== undefined ? open : store.state.isOpen;
+    const handleClose = onClose || (() => store.closeFilter());
+    const sections = visibleSections || store.state.visibleSections;
+    return (_jsx(ModalContainer, { open: isOpen, title: t('Sessions Filters'), maxWidth: 800, footerLeft: [
+            {
+                label: t('Clear all'),
+                variant: 'gray',
+                disabled: pending.selectedTracks.pending.length === 0 &&
+                    pending.selectedVenues.pending.length === 0,
+                onClick: () => {
+                    store.resetFilters();
+                    if (onClose) {
+                        onClose();
+                    }
+                },
+            },
+        ], footerRight: [
+            {
+                label: t('Apply'),
+                variant: 'primary',
+                onClick: () => {
+                    store.applyFilters();
+                    if (onClose) {
+                        onClose();
+                    }
+                },
+            },
+        ], onClose: handleClose, children: _jsxs("div", { className: "efp-sessions-filters-modal", children: [sections.includes('tracks') && trackGroups.length > 0 && (_jsx("div", { className: "efp-sessions-filters-modal__section", children: _jsx(MultiSelectGroups, { groups: trackGroups, selectedIds: pending.selectedTracks.pending, onChange: handleTrackChange, showItemCounts: true }) })), sections.includes('venues') && venueGroups.length > 0 && (_jsx("div", { className: "efp-sessions-filters-modal__section", children: _jsx(MultiSelectGroups, { groups: venueGroups, selectedIds: pending.selectedVenues.pending, onChange: handleVenueChange, showItemCounts: true }) })), sections.includes('date') && (_jsxs("div", { className: "efp-sessions-filters-modal__section", children: [_jsx("h3", { children: t('Date') }), _jsx("div", { className: "efp-sessions-filters-modal__buttons", children: ['all', 'today', 'tomorrow'].map((option) => (_jsx("button", { className: cn('efp-sessions-filters-modal__btn', {
+                                    'is-active': pending.date.pending === option,
+                                }), onClick: () => store.setPending('date', option), children: t(option === 'all'
+                                    ? 'All dates'
+                                    : option.charAt(0).toUpperCase() + option.slice(1)) }, option))) })] })), sections.includes('time') && futureEventsCount >= 30 && (_jsxs("div", { className: "efp-sessions-filters-modal__section", children: [_jsx("h3", { children: t('Session time') }), _jsx("div", { className: "efp-sessions-filters-modal__buttons", children: ['all', 'morning', 'midday', 'afternoon'].map((option) => (_jsx("button", { className: cn('efp-sessions-filters-modal__btn', {
+                                    'is-active': pending.timeOfDay.pending === option,
+                                }), onClick: () => store.setPending('timeOfDay', option), children: t(option === 'all'
+                                    ? 'All times'
+                                    : option.charAt(0).toUpperCase() + option.slice(1)) }, option))) })] })), sections.includes('sort') && (_jsxs("div", { className: "efp-sessions-filters-modal__section", children: [_jsx("h3", { children: t('Sort order') }), _jsxs("div", { className: "efp-sessions-filters-modal__buttons", children: [_jsx("button", { className: cn('efp-sessions-filters-modal__btn', {
+                                        'is-active': pending.sortOrder.pending === 'desc',
+                                    }), onClick: () => store.setPending('sortOrder', 'desc'), children: t('Earliest first') }), _jsx("button", { className: cn('efp-sessions-filters-modal__btn', {
+                                        'is-active': pending.sortOrder.pending === 'asc',
+                                    }), onClick: () => store.setPending('sortOrder', 'asc'), children: t('Latest first') })] })] })), sections.includes('settings') && (_jsxs("div", { className: "efp-sessions-filters-modal__section", children: [_jsx("h3", { children: t('Additional settings') }), _jsx("div", { className: "efp-sessions-filters-modal__toggle", children: _jsx(ToggleSwitch, { name: "showBookmarksOnly", label: t('Show bookmarks only'), value: pending.showBookmarksOnly.pending, onChange: (value) => store.setPending('showBookmarksOnly', value) }) }), _jsx("div", { className: "efp-sessions-filters-modal__toggle", children: _jsx(ToggleSwitch, { name: "use24hFormat", label: t('Show time in 24h format'), value: pending.use24hFormat.pending, onChange: (value) => store.setPending('use24hFormat', value) }) })] }))] }) }));
+});
+export default SessionsFiltersModal;

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

@@ -0,0 +1,12 @@
+import './Schedule.scss';
+import './SessionsList.scss';
+import React from 'react';
+import type { EventItem } from '../store/EventStore';
+export interface SessionsListProps {
+    events: EventItem[];
+    onEventClick: (event: EventItem) => void;
+}
+/** Virtualized sessions list; returning from details scrolls back to the session. */
+declare const SessionsList: React.FunctionComponent<SessionsListProps>;
+export default SessionsList;
+//# sourceMappingURL=SessionsList.d.ts.map

package/dist/esm/components/SessionsList.js

@@ -0,0 +1,212 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './Schedule.scss';
+import './SessionsList.scss';
+import { OverlayScrollContext, Spinner } from '@expofp/ui';
+import classNames from 'classnames';
+import dateFormat from 'dateformat';
+import { observer } from 'mobx-react-lite';
+import { lazy, Suspense, use, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
+import store, { boothStore, uiState } from '../store';
+import { SESSIONS_LIST_TYPE } from '../store/types';
+import { t } from '../utils/i18n';
+import EventBadgeContainer from './EventBadgeContainer';
+const importGroupedVirtuoso = () => import('react-virtuoso')
+    .then((mod) => ({
+    default: mod.GroupedVirtuoso,
+}))
+    .catch(() => new Promise((resolve) => setTimeout(() => resolve(importGroupedVirtuoso()), 3000)));
+const LazyGroupedVirtuoso = lazy(importGroupedVirtuoso);
+function endOf(event) {
+    return new Date(event.endDate || event.startDate);
+}
+/** One group per day: upcoming days, then a "Past Sessions" title group and the past days. */
+function buildLayout(events) {
+    const now = new Date();
+    const upcoming = events.filter((event) => endOf(event) > now);
+    const past = events.filter((event) => endOf(event) <= now);
+    const layout = { groups: [], groupCounts: [], rows: [] };
+    const addDays = (list) => {
+        const byDate = new Map();
+        for (const event of list) {
+            const [date] = event.startDate.split('T');
+            const day = byDate.get(date);
+            if (day)
+                day.push(event);
+            else
+                byDate.set(date, [event]);
+        }
+        for (const [date, dayEvents] of byDate) {
+            layout.groups.push({ kind: 'day', date });
+            layout.groupCounts.push(dayEvents.length);
+            dayEvents.forEach((event, i) => layout.rows.push({
+                kind: 'event',
+                event,
+                first: i === 0,
+                last: i === dayEvents.length - 1,
+                only: dayEvents.length === 1,
+            }));
+        }
+    };
+    addDays(upcoming);
+    if (past.length > 0) {
+        layout.groups.push({ kind: 'past-title' });
+        layout.groupCounts.push(1);
+        layout.rows.push({ kind: 'past-title' });
+        addDays(past);
+    }
+    return layout;
+}
+function formatDay(date) {
+    const [year, month, day] = date.split('-');
+    const d = new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10));
+    return {
+        day,
+        month: dateFormat(d, 'mmm'),
+        weekday: dateFormat(d, 'ddd'),
+        full: dateFormat(d, 'dddd, mmmm d'),
+    };
+}
+function formatTime(date) {
+    const use24hFormat = store.sessionsFilterStore.state.filters.use24hFormat.value;
+    return dateFormat(new Date(date), use24hFormat ? 'HH:MM' : 'h:MMtt');
+}
+// Virtuoso keeps the header stuck; the date hangs below it, beside the day's rows.
+function DayHeader({ group, index, dateRef }) {
+    if (group.kind !== 'day') {
+        // Registered without a date so "Past Sessions" pushes the stuck date up too.
+        return (_jsx("div", { className: "efp-sessions-list__group", children: _jsx("div", { ref: dateRef, "data-group-index": index }) }));
+    }
+    const day = formatDay(group.date);
+    return (_jsx("div", { className: "efp-sessions-list__group", children: _jsxs("div", { ref: dateRef, className: classNames('efp-schedule__date-sticky', 'efp-sessions-list__date', {
+                'efp-sessions-list__date--first': index === 0,
+            }), "data-group-index": index, children: [_jsx("div", { children: day.day }), _jsx("div", { children: day.month }), _jsx("div", { children: day.weekday })] }) }));
+}
+const SessionRow = observer(({ row, groupIndex, selected, onClick }) => {
+    const { event } = row;
+    const booth = event.boothId ? boothStore.boothById.get(Number(event.boothId)) : null;
+    return (_jsxs("div", { className: classNames('efp-sessions-list__row', {
+            'efp-sessions-list__row--first': row.first && groupIndex > 0,
+            'efp-sessions-list__row--last': row.last,
+            'efp-sessions-list__row--only': row.only,
+        }), "data-event-id": event.id, children: [row.first && (_jsx("span", { className: "efp-sessions-list__date-label", children: formatDay(event.startDate.split('T')[0]).full })), _jsxs("div", { className: classNames('efp-schedule__event', {
+                    ended: event.isEnded || endOf(event) < new Date(),
+                    selected,
+                }), role: "button", tabIndex: 0, "aria-current": selected || undefined, onClick: () => onClick(event), onKeyDown: (e) => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        onClick(event);
+                    }
+                }, children: [_jsxs("span", { children: [formatTime(event.startDate), event.endDate ? ` - ${formatTime(event.endDate)}` : null] }), _jsxs("strong", { children: [event.name, _jsx(EventBadgeContainer, { event: event })] }), booth && (_jsx("div", { className: "efp-schedule__event-booth-and-tracks", children: _jsx("div", { className: "efp-schedule__event-booth", children: _jsx("div", { children: booth.name }) }) })), event.logoFile && (_jsx("div", { className: "efp-schedule__event-logo", children: _jsx("img", { src: event.logoFile, alt: event.name, crossOrigin: "anonymous" }) }))] })] }));
+});
+// List semantics for screen readers; group headers are only the separator.
+function SessionsListList({ context: _context, ...props }) {
+    return _jsx("div", { ...props, role: "list" });
+}
+function SessionsListItem({ item: _item, context: _context, ...props }) {
+    return _jsx("div", { ...props, role: "listitem" });
+}
+function SessionsListGroup({ context: _context, ...props }) {
+    return _jsx("div", { ...props, "aria-hidden": "true" });
+}
+/**
+ * Brings back sticky's push, which Virtuoso's stuck headers lack (they all stick to the whole
+ * list, so the next day's date just covers the stuck one): the next day's header shifts the
+ * stuck date up by however much it overlaps it. Relies only on the headers being sticky at the
+ * top of the scroller; if that changes, the dates overlap again and nothing else breaks.
+ */
+function useDatePush(scrollParent) {
+    const [dates] = useState(() => new Set());
+    const scheduleRef = useRef(() => undefined);
+    useEffect(() => {
+        if (!scrollParent)
+            return;
+        let frame = 0;
+        const update = () => {
+            frame = 0;
+            const scrollTop = scrollParent.getBoundingClientRect().top;
+            // The group header, not the date: the date's own rect includes the shift.
+            const items = [...dates].map((date) => ({
+                date,
+                index: Number(date.dataset.groupIndex),
+                top: date.parentElement.getBoundingClientRect().top - scrollTop,
+            }));
+            // Several headers may sit at the top (Virtuoso's stuck copy among them); the latest day wins.
+            let current = -1;
+            let next;
+            for (const item of items)
+                if (item.top <= 1)
+                    current = Math.max(current, item.index);
+            for (const item of items) {
+                if (item.index > current && item.top > 1 && (!next || item.top < next.top))
+                    next = item;
+            }
+            for (const item of items) {
+                const shift = item.index === current && next
+                    ? Math.min(0, next.top - item.top - item.date.offsetTop - item.date.offsetHeight)
+                    : 0;
+                item.date.style.transform = shift ? `translateY(${shift}px)` : '';
+            }
+        };
+        const schedule = () => {
+            if (!frame)
+                frame = requestAnimationFrame(update);
+        };
+        scheduleRef.current = schedule;
+        scrollParent.addEventListener('scroll', schedule, { passive: true });
+        schedule();
+        return () => {
+            scrollParent.removeEventListener('scroll', schedule);
+            cancelAnimationFrame(frame);
+            scheduleRef.current = () => undefined;
+        };
+    }, [scrollParent, dates]);
+    // Stable, so React doesn't detach and reattach the dates on every render.
+    const [dateRef] = useState(() => (date) => {
+        if (!date)
+            return;
+        dates.add(date);
+        return () => {
+            dates.delete(date);
+        };
+    });
+    // Virtuoso renders rows on its own schedule; re-measure after each render too.
+    return { dateRef, update: () => scheduleRef.current() };
+}
+/** Virtualized sessions list; returning from details scrolls back to the session. */
+const SessionsList = observer(({ events, onEventClick }) => {
+    const scrollParent = use(OverlayScrollContext);
+    const layout = useMemo(() => buildLayout(events), [events]);
+    const datePush = useDatePush(scrollParent);
+    // Observable, unlike getListScrollItemId; shared by all lists, so check it is ours.
+    const { listScrollItemId } = uiState;
+    const selectedId = listScrollItemId === uiState.getListScrollItemId(SESSIONS_LIST_TYPE) ? listScrollItemId : null;
+    // Once, on mount: filter changes must not scroll back to the saved session.
+    const [initialIndex] = useState(() => {
+        const savedId = uiState.getListScrollItemId(SESSIONS_LIST_TYPE);
+        if (savedId == null)
+            return undefined;
+        const index = layout.rows.findIndex((row) => row.kind === 'event' && String(row.event.id) === String(savedId));
+        return index === -1 ? undefined : index;
+    });
+    // OverlayContainer keeps the scroll for a saved session; if it was filtered out, start at the top.
+    useLayoutEffect(() => {
+        if (initialIndex === undefined)
+            scrollParent?.scrollTo({ top: 0 });
+    }, [scrollParent, initialIndex]);
+    if (!scrollParent)
+        return null;
+    return (_jsx("div", { className: "efp-sessions-list", children: _jsx(Suspense, { fallback: _jsx(Spinner, { active: true, isCenter: true }), children: _jsx(LazyGroupedVirtuoso, { customScrollParent: scrollParent, ...(initialIndex !== undefined && {
+                    initialTopMostItemIndex: { index: initialIndex, align: 'center' },
+                }), groupCounts: layout.groupCounts, groupContent: (index) => (_jsx(DayHeader, { group: layout.groups[index], index: index, dateRef: datePush.dateRef })), itemContent: (index, groupIndex) => {
+                    const row = layout.rows[index];
+                    if (row.kind === 'past-title') {
+                        return _jsx("div", { className: "efp-sessions-list__past-title", children: t('Past Sessions') });
+                    }
+                    return (_jsx(SessionRow, { row: row, groupIndex: groupIndex, selected: String(row.event.id) === String(selectedId), onClick: onEventClick }));
+                }, components: {
+                    List: SessionsListList,
+                    Item: SessionsListItem,
+                    Group: SessionsListGroup,
+                }, increaseViewportBy: 400, itemsRendered: datePush.update }) }) }));
+});
+export default SessionsList;

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

@@ -0,0 +1,7 @@
+export interface ShareContainerProps {
+    title: string;
+    url: string;
+}
+declare const ShareContainer: import("react").FunctionComponent<ShareContainerProps>;
+export default ShareContainer;
+//# sourceMappingURL=ShareContainer.d.ts.map

package/dist/esm/components/ShareContainer.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Share } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { t } from '../utils/i18n';
+const ShareContainer = observer(({ title, url }) => {
+    const encodedUrl = encodeURIComponent(url);
+    const socials = [
+        {
+            network: 'facebook',
+            name: 'Facebook',
+            url: `https://www.facebook.com/sharer/sharer.php?u=${encodedUrl}`,
+            ariaLabel: t('Share {{title}} on Facebook', { title }),
+        },
+        {
+            network: 'xcom',
+            name: 'X.COM',
+            url: `https://x.com/share?url=${encodedUrl}`,
+            ariaLabel: t('Share {{title}} on X.com', { title }),
+        },
+        {
+            network: 'linkedin',
+            name: 'LinkedIn',
+            url: `https://linkedin.com/shareArticle?url=${encodedUrl}`,
+            ariaLabel: t('Share {{title}} on LinkedIn', { title }),
+        },
+    ];
+    return (_jsx(Share, { title: title, url: url, shareHeading: t('Share'), socials: socials, copyLinkSectionLabel: t('or copy link'), directLinkAriaLabel: t('Direct link to {{title}}', { title }), copyButtonAriaLabel: t('Copy link to clipboard'), copyLabel: t('Copy'), copiedLabel: t('Copied') }));
+});
+export default ShareContainer;

package/dist/esm/components/Shortcuts/ShortcutButton.d.ts

@@ -0,0 +1,9 @@
+import './ShortcutButton.scss';
+import React from 'react';
+import { type ShortcutConfig } from '../../store/ShortcutProvider';
+export interface ShortcutButtonProps extends ShortcutConfig {
+    interfaceId: string;
+}
+declare const ShortcutButton: React.FC<ShortcutButtonProps>;
+export default ShortcutButton;
+//# sourceMappingURL=ShortcutButton.d.ts.map

package/dist/esm/components/Shortcuts/ShortcutButton.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './ShortcutButton.scss';
+import cn from 'classnames';
+import { memo, useCallback } from 'react';
+import store from '../../store';
+import { t } from '../../utils/i18n';
+const ShortcutButton = memo(({ id, label, icon, enabled, active, tooltip, badge, variant = 'default', showResetButton = false, interfaceId, }) => {
+    const handleClick = useCallback(() => {
+        if (enabled) {
+            store.shortcutRegistry.handleShortcutClick(interfaceId, id);
+        }
+    }, [enabled, interfaceId, id]);
+    const handleResetClick = useCallback((e) => {
+        e.stopPropagation();
+        if (enabled && active) {
+            store.shortcutRegistry.handleShortcutReset(interfaceId, id);
+        }
+    }, [enabled, active, interfaceId, id]);
+    return (_jsxs("button", { className: cn('shortcut-button', `shortcut-button--${variant}`, {
+            'is-active': active,
+            'is-disabled': !enabled,
+        }), onClick: handleClick, disabled: !enabled, title: tooltip || label, type: "button", "aria-label": tooltip || label, children: [showResetButton && active && (_jsx("div", { className: "shortcut-reset-button", onClick: handleResetClick, title: t('Reset filter'), "aria-label": t('Reset filter'), children: _jsx("i", { className: "icon-close-solid" }) })), icon && _jsx("i", { className: icon }), label && _jsx("span", { className: "shortcut-button__label", children: label }), badge && _jsx("span", { className: "shortcut-button__badge", children: badge })] }));
+});
+ShortcutButton.displayName = 'ShortcutButton';
+export default ShortcutButton;

package/dist/esm/components/Shortcuts/ShortcutsFiltersButton.d.ts

@@ -0,0 +1,9 @@
+import './ShortcutsFiltersButton.scss';
+import React from 'react';
+export interface ShortcutsFiltersButtonProps {
+    interfaceId: string;
+    className?: string;
+}
+declare const ShortcutsFiltersButton: React.FC<ShortcutsFiltersButtonProps>;
+export default ShortcutsFiltersButton;
+//# sourceMappingURL=ShortcutsFiltersButton.d.ts.map

package/dist/esm/components/Shortcuts/ShortcutsFiltersButton.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './ShortcutsFiltersButton.scss';
+import cn from 'classnames';
+import { observer } from 'mobx-react-lite';
+import { memo } from 'react';
+import store from '../../store';
+import { t } from '../../utils/i18n';
+const ShortcutsFiltersButton = memo(observer(({ interfaceId, className }) => {
+    const { shortcutRegistry } = store;
+    const shortcutsCount = shortcutRegistry
+        .getShortcuts(interfaceId)
+        .filter((shortcut) => shortcut.active).length;
+    let modalFiltersCount = 0;
+    if (interfaceId === 'sessions') {
+        modalFiltersCount = store.sessionsFilterStore.activeFiltersCount;
+    }
+    else if (interfaceId === 'speakers') {
+        modalFiltersCount = store.speakerFilterStore.activeFiltersCount;
+    }
+    const activeFiltersCount = Math.max(shortcutsCount, modalFiltersCount);
+    const handleClick = () => {
+        if (interfaceId === 'sessions') {
+            store.sessionsFilterStore.openFilterWithSections([
+                'tracks',
+                'venues',
+                'date',
+                'time',
+                'sort',
+                'settings',
+            ]);
+        }
+        else if (interfaceId === 'speakers') {
+            store.speakerFilterStore.openFilterWithSections(['companies', 'jobTitles']);
+        }
+    };
+    return (_jsx("button", { className: cn('shortcuts-filters-button', className, {
+            'is-active': activeFiltersCount > 0,
+        }), onClick: handleClick, type: "button", "aria-label": t('Open filters'), title: t('Open filters'), children: _jsx("i", { className: "icon-filter-horizontal-solid" }) }));
+}));
+ShortcutsFiltersButton.displayName = 'ShortcutsFiltersButton';
+export default ShortcutsFiltersButton;

package/dist/esm/components/Shortcuts/ShortcutsToolbar.d.ts

@@ -0,0 +1,10 @@
+import './ShortcutsToolbar.scss';
+import React from 'react';
+export interface ShortcutsToolbarProps {
+    interfaceId: string;
+    showFiltersButton?: boolean;
+    className?: string;
+}
+declare const ShortcutsToolbar: React.NamedExoticComponent<ShortcutsToolbarProps>;
+export default ShortcutsToolbar;
+//# sourceMappingURL=ShortcutsToolbar.d.ts.map

package/dist/esm/components/Shortcuts/ShortcutsToolbar.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+import './ShortcutsToolbar.scss';
+import cn from 'classnames';
+import { observer } from 'mobx-react-lite';
+import { memo } from 'react';
+import store from '../../store';
+import { t } from '../../utils/i18n';
+import ScrollableRow from '../ScrollableRowContainer';
+import ShortcutButton from './ShortcutButton';
+import ShortcutsFiltersButton from './ShortcutsFiltersButton';
+const ShortcutsToolbar = memo(observer(({ interfaceId, showFiltersButton = true, className }) => {
+    const { shortcutRegistry } = store;
+    const shortcuts = shortcutRegistry.getShortcuts(interfaceId);
+    const shouldShow = shortcutRegistry.shouldShowShortcuts(interfaceId);
+    if (!shouldShow || shortcuts.length === 0) {
+        return null;
+    }
+    return (_jsx("div", { className: cn('shortcuts-toolbar', className), children: _jsxs(ScrollableRow, { ariaLabel: t('Shortcuts'), className: "shortcuts-toolbar__scrollable", scrollAmount: 150, showArrowsOnMobile: false, arrowPosition: "inside", children: [showFiltersButton && _jsx(ShortcutsFiltersButton, { interfaceId: interfaceId }), shortcuts.map((shortcut) => (_jsx(ShortcutButton, { ...shortcut, interfaceId: interfaceId }, shortcut.id)))] }) }));
+}));
+ShortcutsToolbar.displayName = 'ShortcutsToolbar';
+export default ShortcutsToolbar;

package/dist/esm/components/Shortcuts/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ShortcutsToolbar } from './ShortcutsToolbar';
+export { default as ShortcutButton } from './ShortcutButton';
+export { default as ShortcutsFiltersButton } from './ShortcutsFiltersButton';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/Shortcuts/index.js

@@ -0,0 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
+export { default as ShortcutsToolbar } from './ShortcutsToolbar';
+export { default as ShortcutButton } from './ShortcutButton';
+export { default as ShortcutsFiltersButton } from './ShortcutsFiltersButton';