@expofp/ui 3.21.0

package/dist/components/EventBadge/EventBadge.d.ts

@@ -0,0 +1,13 @@
+import './EventBadge.scss';
+export type EventBadgeStatus = 'live' | 'upcoming' | 'starting-soon' | 'past' | 'none';
+export interface EventBadgeProps {
+    status: EventBadgeStatus;
+    statusLabel?: string;
+    showFullBadge?: boolean;
+    fullLabel: string;
+    isUrgent?: boolean;
+    className?: string;
+}
+declare const EventBadge: ({ status, statusLabel, showFullBadge, fullLabel, isUrgent, className, }: EventBadgeProps) => import("react").JSX.Element | null;
+export default EventBadge;
+//# sourceMappingURL=EventBadge.d.ts.map

package/dist/components/EventBadge/EventBadge.js

@@ -0,0 +1,10 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './EventBadge.scss';
+import classNames from 'classnames';
+const EventBadge = ({ status, statusLabel, showFullBadge = false, fullLabel, isUrgent = false, className = '', }) => {
+    const mainBadge = status !== 'none' ? (_jsx("div", { className: classNames('efp-event-badge', `efp-event-badge--${status}`, { 'is-urgent': isUrgent }, className), children: statusLabel })) : null;
+    if (!mainBadge && !showFullBadge)
+        return null;
+    return (_jsxs(_Fragment, { children: [mainBadge, showFullBadge && (_jsx("div", { className: classNames('efp-event-badge', 'efp-event-badge--full', className), children: fullLabel }))] }));
+};
+export default EventBadge;

package/dist/components/EventBadge/index.d.ts

@@ -0,0 +1,3 @@
+export type { EventBadgeProps, EventBadgeStatus } from './EventBadge';
+export { default } from './EventBadge';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/EventBadge/index.js

@@ -0,0 +1 @@
+export { default } from './EventBadge';

package/dist/components/Gallery/Gallery.d.ts

@@ -0,0 +1,25 @@
+import './Gallery.scss';
+import React from 'react';
+export interface GalleryImage {
+    thumbnailUrl: string;
+    fullUrl: string;
+}
+export interface GalleryProps {
+    images: GalleryImage[];
+    leading?: boolean;
+    closeLabel: string;
+    zoomInLabel: string;
+    zoomOutLabel: string;
+    nextSlideLabel: string;
+    prevSlideLabel: string;
+    fullscreenLabel: string;
+    itemLabel: (index: number) => string;
+    renderTarget?: HTMLElement | null;
+    onImageLoadHeightUpdate?: () => void;
+    onOpenGallery?: () => void;
+    onCloseGallery?: () => void;
+    className?: string;
+}
+declare const Gallery: (props: GalleryProps) => React.JSX.Element;
+export default Gallery;
+//# sourceMappingURL=Gallery.d.ts.map

package/dist/components/Gallery/Gallery.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './Gallery.scss';
+import classNames from 'classnames';
+import React, { useState } from 'react';
+import GalleryBadges from './GalleryBadges/GalleryBadges';
+import GalleryItem from './GalleryItem/GalleryItem';
+import GalleryModal from './GalleryModal/GalleryModal';
+const Gallery = (props) => {
+    const { images, leading = false, closeLabel, zoomInLabel, zoomOutLabel, nextSlideLabel, prevSlideLabel, fullscreenLabel, itemLabel, renderTarget, onImageLoadHeightUpdate, onOpenGallery, onCloseGallery, className, } = props;
+    const [isModalOpen, setIsModalOpen] = useState(false);
+    const [currentSlideIndex, setCurrentSlideIndex] = useState(0);
+    const openModal = (initialSlideIndex) => {
+        setCurrentSlideIndex(initialSlideIndex);
+        setIsModalOpen(true);
+        onOpenGallery?.();
+    };
+    const closeModal = () => {
+        setIsModalOpen(false);
+        onCloseGallery?.();
+    };
+    return (_jsxs(React.Fragment, { children: [_jsxs("div", { className: classNames('efp-gallery', {
+                    'efp-gallery--leading': leading,
+                }, className), children: [_jsx("div", { className: "efp-gallery__wrapper", children: leading ? (_jsx(GalleryItem, { url: images[0].thumbnailUrl, index: 0, itemLabel: itemLabel, leading: leading, autoHeight: true, fillMode: "contain", onClick: () => openModal(0), onImageLoadHeightUpdate: onImageLoadHeightUpdate })) : (images.map((image, i) => (_jsx(GalleryItem, { url: image.thumbnailUrl, index: i, itemLabel: itemLabel, position: "top", fillMode: "cover", onClick: () => openModal(i), onImageLoadHeightUpdate: onImageLoadHeightUpdate }, image.thumbnailUrl + i)))) }), !leading && (_jsx(GalleryBadges, { fullscreenLabel: fullscreenLabel, onFullscreen: () => openModal(0), count: images.length }))] }), isModalOpen && (_jsx(GalleryModal, { className: className, images: images.map((image) => image.fullUrl), leading: leading, initialSlideIndex: currentSlideIndex, closeLabel: closeLabel, zoomInLabel: zoomInLabel, zoomOutLabel: zoomOutLabel, nextSlideLabel: nextSlideLabel, prevSlideLabel: prevSlideLabel, itemLabel: itemLabel, renderTarget: renderTarget, onClose: closeModal }))] }));
+};
+export default Gallery;

package/dist/components/Gallery/GalleryBadges/GalleryBadges.d.ts

@@ -0,0 +1,8 @@
+export interface GalleryBadgesProps {
+    count: number;
+    fullscreenLabel: string;
+    onFullscreen: () => void;
+}
+declare const GalleryBadges: ({ count, fullscreenLabel, onFullscreen }: GalleryBadgesProps) => import("react").JSX.Element;
+export default GalleryBadges;
+//# sourceMappingURL=GalleryBadges.d.ts.map

package/dist/components/Gallery/GalleryBadges/GalleryBadges.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const GalleryBadges = ({ count, fullscreenLabel, onFullscreen }) => {
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "efp-gallery__badge efp-gallery__badge-count", children: [_jsx("i", { className: "icon-image", "aria-hidden": "true" }), _jsx("span", { children: count })] }), _jsx("button", { type: "button", className: "efp-gallery__badge efp-gallery__badge-fullscreen", "aria-label": fullscreenLabel, title: fullscreenLabel, onClick: onFullscreen, children: _jsx("i", { className: "icon-maximize", "aria-hidden": "true" }) })] }));
+};
+export default GalleryBadges;

package/dist/components/Gallery/GalleryControls/GalleryControls.d.ts

@@ -0,0 +1,11 @@
+export interface GalleryControlsProps {
+    closeLabel: string;
+    zoomInLabel: string;
+    zoomOutLabel: string;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    onClose: () => void;
+}
+declare const GalleryControls: ({ closeLabel, zoomInLabel, zoomOutLabel, zoomIn, zoomOut, onClose, }: GalleryControlsProps) => import("react").JSX.Element;
+export default GalleryControls;
+//# sourceMappingURL=GalleryControls.d.ts.map

package/dist/components/Gallery/GalleryControls/GalleryControls.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const GalleryControls = ({ closeLabel, zoomInLabel, zoomOutLabel, zoomIn, zoomOut, onClose, }) => {
+    return (_jsxs("div", { className: "efp-gallery-slider__controls", children: [_jsx("button", { type: "button", className: "efp-gallery-slider__btn efp-gallery-slider__btn--close", title: closeLabel, "aria-label": closeLabel, onClick: onClose, children: _jsx("i", { className: "icon-close", "aria-hidden": "true" }) }), _jsx("button", { type: "button", className: "efp-gallery-slider__btn efp-gallery-slider__btn--zoom-in", title: zoomInLabel, "aria-label": zoomInLabel, onClick: () => zoomIn(), children: _jsx("i", { className: "icon-zoom-in", "aria-hidden": "true" }) }), _jsx("button", { type: "button", className: "efp-gallery-slider__btn efp-gallery-slider__btn--zoom-out", title: zoomOutLabel, "aria-label": zoomOutLabel, onClick: () => zoomOut(), children: _jsx("i", { className: "icon-zoom-out", "aria-hidden": "true" }) })] }));
+};
+export default GalleryControls;

package/dist/components/Gallery/GalleryImg/GalleryImg.d.ts

@@ -0,0 +1,13 @@
+type FillMode = 'cover' | 'contain';
+export interface GalleryImgProps {
+    url: string;
+    fillMode?: FillMode;
+    leading?: boolean;
+    autoHeight?: boolean;
+    fullscreen?: boolean;
+    position?: 'center' | 'top';
+    onImageLoadHeightUpdate?: () => void;
+}
+declare const GalleryImg: ({ url, autoHeight, position, fullscreen, leading, fillMode, onImageLoadHeightUpdate, }: GalleryImgProps) => import("react").JSX.Element;
+export default GalleryImg;
+//# sourceMappingURL=GalleryImg.d.ts.map

package/dist/components/Gallery/GalleryImg/GalleryImg.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef } from 'react';
+import GalleryPreLoader from '../GalleryPreLoader';
+const GalleryImg = ({ url, autoHeight = false, position = 'center', fullscreen = false, leading = false, fillMode = 'contain', onImageLoadHeightUpdate, }) => {
+    const imgRef = useRef(null);
+    const containerRef = useRef(null);
+    const loadImage = useCallback(async (imageUrl) => {
+        if (!autoHeight || !containerRef.current)
+            return;
+        const container = containerRef.current;
+        try {
+            const loadedImage = await GalleryPreLoader.load(imageUrl);
+            if (!loadedImage)
+                return;
+            container.style.height =
+                (loadedImage.height * container.clientWidth) / loadedImage.width + 'px';
+            onImageLoadHeightUpdate?.();
+        }
+        catch {
+            // image failed to load — keep default height
+        }
+    }, [autoHeight, onImageLoadHeightUpdate]);
+    useEffect(() => {
+        if (!imgRef.current || !containerRef.current || !leading)
+            return;
+        void loadImage(url);
+    }, [url, leading, loadImage]);
+    const style = {
+        backgroundImage: `url("${url}")`,
+        backgroundSize: fillMode,
+        backgroundRepeat: 'no-repeat',
+        transition: leading ? 'all 0.5s ease 0s' : 'none',
+        backgroundPosition: position,
+    };
+    return (_jsx("div", { ref: containerRef, style: { width: '100%', height: leading && !fullscreen ? '250px' : '100%' }, children: _jsx("div", { ref: imgRef, className: "efp-gallery__img", style: style }) }));
+};
+export default GalleryImg;

package/dist/components/Gallery/GalleryItem/GalleryItem.d.ts

@@ -0,0 +1,14 @@
+export interface GalleryItemProps {
+    url: string;
+    index: number;
+    itemLabel: (index: number) => string;
+    leading?: boolean;
+    autoHeight?: boolean;
+    fillMode?: 'cover' | 'contain';
+    position?: 'center' | 'top';
+    onClick: () => void;
+    onImageLoadHeightUpdate?: () => void;
+}
+declare const GalleryItem: ({ url, index, itemLabel, position, leading, autoHeight, fillMode, onClick, onImageLoadHeightUpdate, }: GalleryItemProps) => import("react").JSX.Element;
+export default GalleryItem;
+//# sourceMappingURL=GalleryItem.d.ts.map

package/dist/components/Gallery/GalleryItem/GalleryItem.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import GalleryImg from '../GalleryImg/GalleryImg';
+const GalleryItem = ({ url, index, itemLabel, position = 'center', leading = false, autoHeight = false, fillMode, onClick, onImageLoadHeightUpdate, }) => {
+    return (_jsx("button", { type: "button", className: "efp-gallery__item", "aria-label": itemLabel(index), onClick: onClick, children: _jsx(GalleryImg, { position: position, fillMode: fillMode, url: url, leading: leading, autoHeight: autoHeight, onImageLoadHeightUpdate: onImageLoadHeightUpdate }) }));
+};
+export default GalleryItem;

package/dist/components/Gallery/GalleryModal/GalleryModal.d.ts

@@ -0,0 +1,18 @@
+import './GalleryModal.scss';
+export interface GalleryModalProps {
+    images: string[];
+    leading: boolean;
+    initialSlideIndex: number;
+    closeLabel: string;
+    zoomInLabel: string;
+    zoomOutLabel: string;
+    nextSlideLabel: string;
+    prevSlideLabel: string;
+    itemLabel: (index: number) => string;
+    renderTarget?: HTMLElement | null;
+    onClose: () => void;
+    className?: string;
+}
+declare const GalleryModal: (props: GalleryModalProps) => import("react").ReactPortal | null;
+export default GalleryModal;
+//# sourceMappingURL=GalleryModal.d.ts.map

package/dist/components/Gallery/GalleryModal/GalleryModal.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './GalleryModal.scss';
+import classNames from 'classnames';
+import { useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { TransformWrapper } from 'react-zoom-pan-pinch-sr';
+import { Navigation } from 'swiper';
+import { Swiper as SwiperComponent, SwiperSlide } from 'swiper/react';
+import useOnEscape from '../../../shared/hooks/useOnEscape';
+import GalleryControls from '../GalleryControls/GalleryControls';
+import TransformImg from '../TransformImg/TransformImg';
+const isElementVisible = (el) => el.getClientRects().length > 0 && getComputedStyle(el).visibility !== 'hidden';
+const GalleryModal = (props) => {
+    const { images, leading, initialSlideIndex, closeLabel, zoomInLabel, zoomOutLabel, nextSlideLabel, prevSlideLabel, itemLabel, renderTarget, onClose, className, } = props;
+    const [currentSlideIndex, setCurrentSlideIndex] = useState(initialSlideIndex);
+    const [zoomUtils, setZoomUtils] = useState([]);
+    const swiperRef = useRef(null);
+    const prevRef = useRef(null);
+    const nextRef = useRef(null);
+    const modalRef = useRef(null);
+    useOnEscape(onClose);
+    // Scroll lock + focus trap/restore. Runs once for the modal's whole mounted
+    // lifetime — the parent only mounts this component while the modal is open.
+    useEffect(() => {
+        const previousFocus = document.activeElement;
+        const previousBodyOverflow = document.body.style.overflow;
+        document.body.style.overflow = 'hidden';
+        let inner = 0;
+        const outer = requestAnimationFrame(() => {
+            inner = requestAnimationFrame(() => modalRef.current?.focus());
+        });
+        const handleKeyDown = (e) => {
+            if (e.key !== 'Tab')
+                return;
+            const container = modalRef.current;
+            if (!container)
+                return;
+            const focusable = Array.from(container.querySelectorAll('a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])')).filter(isElementVisible);
+            if (focusable.length === 0) {
+                e.preventDefault();
+                return;
+            }
+            const first = focusable[0];
+            const last = focusable[focusable.length - 1];
+            const active = document.activeElement;
+            if (e.shiftKey) {
+                if (active === first || active === container) {
+                    e.preventDefault();
+                    last.focus();
+                }
+            }
+            else if (active === last) {
+                e.preventDefault();
+                first.focus();
+            }
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return () => {
+            cancelAnimationFrame(outer);
+            cancelAnimationFrame(inner);
+            document.removeEventListener('keydown', handleKeyDown);
+            document.body.style.overflow = previousBodyOverflow;
+            previousFocus?.focus();
+        };
+    }, []);
+    const mainSliderOptions = {
+        initialSlide: initialSlideIndex,
+        draggable: false,
+        modules: [Navigation],
+        spaceBetween: 50,
+        slidesPerView: 1,
+        navigation: {
+            prevEl: prevRef.current,
+            nextEl: nextRef.current,
+        },
+        grabCursor: true,
+    };
+    if (!renderTarget)
+        return null;
+    const modalContent = (_jsx("div", { className: classNames('efp-gallery-modal', className), role: "dialog", "aria-modal": "true", "aria-label": itemLabel(currentSlideIndex), ref: modalRef, tabIndex: -1, children: _jsxs(SwiperComponent, { onSwiper: (swiper) => (swiperRef.current = swiper), className: "efp-gallery-slider", onSlideChange: (swiper) => {
+                setCurrentSlideIndex(swiper.activeIndex);
+                zoomUtils[swiper.previousIndex]?.resetTransform();
+            }, ...mainSliderOptions, children: [zoomUtils[currentSlideIndex] ? (_jsx(GalleryControls, { closeLabel: closeLabel, zoomInLabel: zoomInLabel, zoomOutLabel: zoomOutLabel, onClose: onClose, zoomIn: zoomUtils[currentSlideIndex].zoomIn, zoomOut: zoomUtils[currentSlideIndex].zoomOut })) : null, images.length > 1 && (_jsx("button", { type: "button", ref: nextRef, title: nextSlideLabel, "aria-label": nextSlideLabel, className: "efp-gallery-slider__btn efp-gallery-slider__btn--next", children: _jsx("i", { className: "icon-chevron-right", "aria-hidden": "true" }) })), images.length > 1 && (_jsx("button", { type: "button", ref: prevRef, title: prevSlideLabel, "aria-label": prevSlideLabel, className: "efp-gallery-slider__btn efp-gallery-slider__btn--prev", children: _jsx("i", { className: "icon-chevron-left", "aria-hidden": "true" }) })), images.map((url, i) => (_jsx(SwiperSlide, { children: _jsx(TransformWrapper, { initialScale: 1, alignmentAnimation: { sizeX: 0, sizeY: 0 }, onInit: (controls) => {
+                            setZoomUtils((state) => [...state, controls]);
+                        }, children: _jsx(TransformImg, { leading: leading, swiperRef: swiperRef, url: url }) }) }, url + i)))] }) }));
+    return createPortal(modalContent, renderTarget);
+};
+export default GalleryModal;

package/dist/components/Gallery/GalleryPreLoader.d.ts

@@ -0,0 +1,7 @@
+declare class GalleryPreLoader {
+    private cache;
+    load: (url: string) => Promise<HTMLImageElement | null>;
+}
+declare const _default: GalleryPreLoader;
+export default _default;
+//# sourceMappingURL=GalleryPreLoader.d.ts.map

package/dist/components/Gallery/GalleryPreLoader.js

@@ -0,0 +1,29 @@
+class GalleryPreLoader {
+    cache = [];
+    load = (url) => {
+        return new Promise((resolve, reject) => {
+            if (!url) {
+                resolve(null);
+                return;
+            }
+            const cached = this.cache.find((i) => i.src === url);
+            if (cached) {
+                resolve(cached);
+                return;
+            }
+            const image = new Image();
+            image.crossOrigin = 'anonymous';
+            image.src = url;
+            image.onload = () => {
+                if (this.cache.length > 10)
+                    this.cache.shift();
+                this.cache.push(image);
+                resolve(image);
+            };
+            image.onerror = () => {
+                reject(new Error(`Failed to load image: ${url}`));
+            };
+        });
+    };
+}
+export default new GalleryPreLoader();

package/dist/components/Gallery/TransformImg/TransformImg.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { type Swiper as SwiperInstance } from 'swiper';
+export interface TransformImgProps {
+    swiperRef: React.RefObject<SwiperInstance | null>;
+    url: string;
+    leading: boolean;
+}
+declare const TransformImg: ({ swiperRef, leading, url }: TransformImgProps) => React.JSX.Element;
+export default TransformImg;
+//# sourceMappingURL=TransformImg.d.ts.map

package/dist/components/Gallery/TransformImg/TransformImg.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TransformComponent, useTransformEffect } from 'react-zoom-pan-pinch-sr';
+import GalleryImg from '../GalleryImg/GalleryImg';
+const TransformImg = ({ swiperRef, leading, url }) => {
+    useTransformEffect(({ state, instance }) => {
+        if (!swiperRef.current)
+            return;
+        swiperRef.current.allowTouchMove = state.scale === 1;
+        if (state.scale === 1 && state.positionX !== 0 && state.positionY !== 0) {
+            instance.setCenter();
+        }
+    });
+    return (_jsx(TransformComponent, { wrapperClass: "efp-gallery-slider__zoom", contentClass: "efp-gallery-slider__zoom-content", children: _jsx(GalleryImg, { fullscreen: true, leading: leading, url: url }) }));
+};
+export default TransformImg;

package/dist/components/Gallery/index.d.ts

@@ -0,0 +1,3 @@
+export type { GalleryImage, GalleryProps } from './Gallery';
+export { default } from './Gallery';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Gallery/index.js

@@ -0,0 +1 @@
+export { default } from './Gallery';

package/dist/components/HeatmapLegend/HeatmapLegend.d.ts

@@ -0,0 +1,15 @@
+import './HeatmapLegend.scss';
+import React from 'react';
+export interface HeatmapLegendTick {
+    value: number;
+    color: string;
+}
+export interface HeatmapLegendProps {
+    ticks: HeatmapLegendTick[];
+    ariaLabel: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const HeatmapLegend: ({ ticks, ariaLabel, className, style }: HeatmapLegendProps) => React.JSX.Element | null;
+export default HeatmapLegend;
+//# sourceMappingURL=HeatmapLegend.d.ts.map

package/dist/components/HeatmapLegend/HeatmapLegend.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './HeatmapLegend.scss';
+import classNames from 'classnames';
+const HeatmapLegend = ({ ticks, ariaLabel, className, style }) => {
+    if (ticks.length === 0)
+        return null;
+    const colors = ticks.map((tick) => tick.color);
+    const background = colors.length === 1 ? colors[0] : `linear-gradient(to right, ${colors.join(', ')})`;
+    return (_jsxs("div", { className: classNames('efp-heatmap-legend', className), style: style, role: "img", "aria-label": ariaLabel, children: [_jsx("div", { className: "efp-heatmap-legend__colors", style: { background }, "aria-hidden": "true" }), _jsx("div", { className: "efp-heatmap-legend__values", children: ticks.map(({ value }, index) => (_jsx("span", { "aria-hidden": "true", children: value }, index))) })] }));
+};
+export default HeatmapLegend;

package/dist/components/HeatmapLegend/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './HeatmapLegend';
+export type { HeatmapLegendProps, HeatmapLegendTick } from './HeatmapLegend';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/HeatmapLegend/index.js

@@ -0,0 +1,2 @@
+/* eslint-disable simple-import-sort/exports */
+export { default } from './HeatmapLegend';

package/dist/components/HighlightText/HighlightText.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare const HighlightText: ({ text, highlight }: {
+    text: string;
+    highlight?: string;
+}) => React.JSX.Element;
+export default HighlightText;
+//# sourceMappingURL=HighlightText.d.ts.map

package/dist/components/HighlightText/HighlightText.js

@@ -0,0 +1,14 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const HIGHLIGHT_COLOR = '#FFFF99';
+const HighlightText = ({ text, highlight }) => {
+    if (!highlight || !text) {
+        return _jsx(_Fragment, { children: text });
+    }
+    const startIndex = text.toLowerCase().indexOf(highlight.toLowerCase());
+    if (startIndex === -1) {
+        return _jsx(_Fragment, { children: text });
+    }
+    const endIndex = startIndex + highlight.length;
+    return (_jsxs(_Fragment, { children: [text.slice(0, startIndex), _jsx("mark", { style: { background: `linear-gradient(to top, ${HIGHLIGHT_COLOR}, transparent)` }, children: text.slice(startIndex, endIndex) }), text.slice(endIndex)] }));
+};
+export default HighlightText;

package/dist/components/HighlightText/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './HighlightText';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/HighlightText/index.js

@@ -0,0 +1 @@
+export { default } from './HighlightText';

package/dist/components/LevelBadge/LevelBadge.d.ts

@@ -0,0 +1,9 @@
+import './LevelBadge.scss';
+import React from 'react';
+export interface LevelBadgeProps {
+    level: string;
+    levelLabel: string;
+}
+declare const LevelBadge: ({ level, levelLabel }: LevelBadgeProps) => React.JSX.Element | null;
+export default LevelBadge;
+//# sourceMappingURL=LevelBadge.d.ts.map

package/dist/components/LevelBadge/LevelBadge.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import './LevelBadge.scss';
+const isNumeric = (input) => /^\d+$/.test(input);
+const LevelBadge = ({ level, levelLabel }) => {
+    if (!level)
+        return null;
+    return (_jsx("div", { className: "efp-level-badge", children: _jsx("span", { children: isNumeric(level) ? `${levelLabel} ${level}` : level }) }));
+};
+export default LevelBadge;

package/dist/components/LevelBadge/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './LevelBadge';
+export type { LevelBadgeProps } from './LevelBadge';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/LevelBadge/index.js

@@ -0,0 +1,2 @@
+/* eslint-disable simple-import-sort/exports */
+export { default } from './LevelBadge';

package/dist/components/LevelSelector/LevelSelector.d.ts

@@ -0,0 +1,19 @@
+import './LevelSelector.scss';
+export interface LevelSelectorFloor {
+    /** Stable identifier for the floor (used as React key and passed to `onSelect`). */
+    id: string;
+    /** Display name shown to the user (already resolved to short/full by the caller). */
+    label: string;
+    active: boolean;
+    disabled: boolean;
+}
+export interface LevelSelectorProps {
+    floors: LevelSelectorFloor[];
+    layout: 'compact-list' | 'dropdown';
+    onSelect: (id: string) => void;
+    floorSelectionLabel: string;
+    currentFloorLabel: string;
+    floorLabel: string;
+}
+export default function LevelSelector({ floors, layout, onSelect, floorSelectionLabel, currentFloorLabel, floorLabel, }: LevelSelectorProps): import("react").JSX.Element | null;
+//# sourceMappingURL=LevelSelector.d.ts.map

package/dist/components/LevelSelector/LevelSelector.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './LevelSelector.scss';
+import classNames from 'classnames';
+import { useCallback, useLayoutEffect, useRef, useState } from 'react';
+import useOnClickOutside from '../../shared/hooks/useOnClickOutside';
+import useOnEscape from '../../shared/hooks/useOnEscape';
+export default function LevelSelector({ floors, layout, onSelect, floorSelectionLabel, currentFloorLabel, floorLabel, }) {
+    const dropdownRef = useRef(null);
+    const triggerRef = useRef(null);
+    const itemRefs = useRef(new Map());
+    const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+    const [menuPosition, setMenuPosition] = useState('down');
+    const closeAndRefocus = useCallback(() => {
+        setIsDropdownOpen(false);
+        triggerRef.current?.focus();
+    }, []);
+    useOnClickOutside([dropdownRef, triggerRef], () => setIsDropdownOpen(false), isDropdownOpen);
+    useOnEscape(closeAndRefocus, isDropdownOpen);
+    useLayoutEffect(() => {
+        if (isDropdownOpen && triggerRef.current) {
+            const buttonRect = triggerRef.current.getBoundingClientRect();
+            const windowHeight = window.innerHeight;
+            const spaceBelow = windowHeight - buttonRect.bottom;
+            const minSpaceRequired = 200;
+            setMenuPosition(spaceBelow < minSpaceRequired ? 'up' : 'down');
+        }
+    }, [isDropdownOpen]);
+    const handleFloorSelect = useCallback((floor) => {
+        if (floor.disabled)
+            return;
+        onSelect(floor.id);
+        setIsDropdownOpen(false);
+        triggerRef.current?.focus();
+    }, [onSelect]);
+    const focusAdjacentFloor = useCallback((e, floor) => {
+        if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp')
+            return;
+        e.preventDefault();
+        const currentIndex = floors.findIndex((f) => f.id === floor.id);
+        const direction = e.key === 'ArrowDown' ? 1 : -1;
+        let nextIndex = currentIndex + direction;
+        while (nextIndex >= 0 && nextIndex < floors.length) {
+            if (!floors[nextIndex].disabled) {
+                itemRefs.current.get(floors[nextIndex].id)?.focus();
+                return;
+            }
+            nextIndex += direction;
+        }
+    }, [floors]);
+    const handleDropdownItemKeyDown = useCallback((e, floor) => {
+        if (e.key === 'Enter' || e.key === ' ') {
+            if (floor.disabled)
+                return;
+            e.preventDefault();
+            handleFloorSelect(floor);
+            return;
+        }
+        focusAdjacentFloor(e, floor);
+    }, [focusAdjacentFloor, handleFloorSelect]);
+    if (floors.length === 0)
+        return null;
+    const activeFloor = floors.find((floor) => floor.active);
+    if (layout === 'compact-list') {
+        // Roving tabindex: only the active floor (or the first enabled one as a
+        // fallback) is a tab stop; arrows move focus, Enter/Space select.
+        const tabbableFloor = activeFloor && !activeFloor.disabled ? activeFloor : floors.find((floor) => !floor.disabled);
+        return (_jsx("div", { className: classNames('efp-level-selector', 'efp-level-selector--compact-list'), role: "radiogroup", "aria-label": floorSelectionLabel, children: floors.map((floor) => (_jsx("button", { ref: (el) => {
+                    if (el)
+                        itemRefs.current.set(floor.id, el);
+                    else
+                        itemRefs.current.delete(floor.id);
+                }, type: "button", className: classNames('efp-level-selector__item', {
+                    'efp-level-selector__item--active': floor.active,
+                    'efp-level-selector__item--disabled': floor.disabled,
+                }), role: "radio", title: `${floor.active ? currentFloorLabel : floorLabel} ${floor.label}`, "aria-label": `${floor.active ? currentFloorLabel : floorLabel} ${floor.label}`, "aria-checked": floor.active, "aria-disabled": floor.disabled, tabIndex: floor.id === tabbableFloor?.id ? 0 : -1, onClick: () => handleFloorSelect(floor), onKeyDown: (e) => focusAdjacentFloor(e, floor), children: _jsx("span", { dir: "auto", children: floor.label }) }, floor.id))) }));
+    }
+    return (_jsxs("div", { className: classNames('efp-level-selector', 'efp-level-selector--dropdown'), children: [_jsxs("button", { ref: triggerRef, type: "button", className: classNames('efp-level-selector__trigger', {
+                    'efp-level-selector__trigger--open': isDropdownOpen,
+                }), onClick: () => setIsDropdownOpen(!isDropdownOpen), "aria-haspopup": "listbox", "aria-expanded": isDropdownOpen, "aria-label": `${currentFloorLabel}: ${activeFloor?.label ?? ''}`, children: [_jsxs("div", { className: "efp-level-selector__trigger-text", children: [_jsx("i", { className: "icon-layers", "aria-hidden": "true" }), _jsx("span", { dir: "auto", children: activeFloor?.label ?? '' })] }), _jsx("div", { className: "efp-level-selector__trigger-chevron", children: _jsx("i", { className: "icon-chevron-down", "aria-hidden": "true" }) })] }), isDropdownOpen && (_jsx("div", { ref: dropdownRef, className: classNames('efp-level-selector__dropdown', 'efp-level-selector__dropdown--full', {
+                    'efp-level-selector__dropdown--opens-up': menuPosition === 'up',
+                    'efp-level-selector__dropdown--opens-down': menuPosition === 'down',
+                }), role: "listbox", "aria-label": floorSelectionLabel, children: floors.map((floor) => (_jsxs("div", { ref: (el) => {
+                        if (el)
+                            itemRefs.current.set(floor.id, el);
+                        else
+                            itemRefs.current.delete(floor.id);
+                    }, className: classNames('efp-level-selector__dropdown-item', {
+                        'efp-level-selector__dropdown-item--active': floor.active,
+                        'efp-level-selector__dropdown-item--disabled': floor.disabled,
+                    }), role: "option", "aria-selected": floor.active, "aria-disabled": floor.disabled, tabIndex: floor.disabled ? -1 : 0, onClick: () => handleFloorSelect(floor), onKeyDown: (e) => handleDropdownItemKeyDown(e, floor), children: [_jsx("span", { className: "efp-level-selector__dropdown-item-icon", children: floor.active && _jsx("i", { className: "icon-checkmark-solid", "aria-hidden": "true" }) }), _jsx("span", { className: "efp-level-selector__dropdown-item-name", dir: "auto", children: floor.label })] }, floor.id))) }))] }));
+}

package/dist/components/LevelSelector/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './LevelSelector';
+export type { LevelSelectorProps, LevelSelectorFloor } from './LevelSelector';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/LevelSelector/index.js

@@ -0,0 +1,2 @@
+/* eslint-disable simple-import-sort/exports */
+export { default } from './LevelSelector';