@expofp/ui 0.0.0-experimental.2d6c681

package/dist/components/Overlay/Overlay.d.ts

@@ -0,0 +1,30 @@
+import './Overlay.scss';
+import { type ReactNode } from 'react';
+export type Size = 'small' | 'medium' | 'full';
+export interface OverlayProps {
+    children?: ReactNode;
+    open: boolean;
+    size?: Size;
+    /** Slot rendered above the content (e.g. a particles canvas); nothing when omitted. */
+    particles?: ReactNode;
+    className?: string;
+    smallSizeMultiplier?: number;
+    mediumSizeMultiplier?: number;
+    fullSizeOffset?: number;
+    scrollThreshold?: number;
+    disableDrag?: boolean;
+    forceFull?: boolean;
+    scrollResetKey?: unknown;
+    /** Viewport width (px) at or below which the overlay switches to its mobile bottom-sheet mode. */
+    mobileBreakpoint?: number;
+    /** Shown when `children` is empty. */
+    noContentLabel: string;
+    withFloatingButton?: boolean;
+    onChangeSize?: (size: Size) => void;
+    onScrollStateChange?: (isScrolled: boolean) => void;
+    /** Fired (debounced) on scroll — lets the host react to user activity. */
+    onScrollActivity?: () => void;
+}
+declare const Overlay: ({ children, open, size, particles, className, onChangeSize, onScrollStateChange, onScrollActivity, smallSizeMultiplier, mediumSizeMultiplier, fullSizeOffset, scrollThreshold, disableDrag, forceFull, scrollResetKey, mobileBreakpoint, noContentLabel, withFloatingButton, }: OverlayProps) => import("react").JSX.Element | null;
+export default Overlay;
+//# sourceMappingURL=Overlay.d.ts.map

package/dist/components/Overlay/Overlay.js

@@ -0,0 +1,250 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './Overlay.scss';
+import cn from 'classnames';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
+import debounce from '../../shared/debounce';
+import { useKeyboardInset } from '../../shared/hooks/useKeyboardInset';
+import { useSheetDrag } from '../../shared/hooks/useSheetDrag';
+import { useWindowSize } from '../../shared/hooks/useWindowSize';
+import { OverlayHeaderContext } from './OverlayHeaderContext';
+import { OverlayKeyboardInsetContext } from './OverlayKeyboardInsetContext';
+import { OverlayScrollContext } from './OverlayScrollContext';
+const TRANSITION_DURATION = '0.3s';
+const DEFAULT_SCROLL_THRESHOLD = 10;
+const DEFAULT_MOBILE_BREAKPOINT = 768;
+const getActualViewportHeight = () => {
+    const isInIframe = window !== window.top;
+    if (isInIframe) {
+        return (document.documentElement.clientHeight || document.body.clientHeight || window.innerHeight);
+    }
+    return window.innerHeight;
+};
+const generateSizes = (height = getActualViewportHeight(), smallMultiplier, mediumMultiplier, fullSizeOffset) => ({
+    small: height / smallMultiplier,
+    medium: height / mediumMultiplier,
+    full: height - fullSizeOffset,
+});
+const Overlay = ({ children, open, size = 'medium', particles, className, onChangeSize, onScrollStateChange, onScrollActivity, smallSizeMultiplier = 12.6, mediumSizeMultiplier = 2.6, fullSizeOffset = 0, scrollThreshold = DEFAULT_SCROLL_THRESHOLD, disableDrag = false, forceFull = false, scrollResetKey, mobileBreakpoint = DEFAULT_MOBILE_BREAKPOINT, noContentLabel, withFloatingButton = false, }) => {
+    const { width: windowWidth, height: windowHeight } = useWindowSize();
+    // Pure derivations of the window size — computed in render, not stored/synced via an effect.
+    const mobile = windowWidth <= mobileBreakpoint;
+    const sizes = useMemo(() => generateSizes(windowHeight, smallSizeMultiplier, mediumSizeMultiplier, fullSizeOffset), [windowHeight, smallSizeMultiplier, mediumSizeMultiplier, fullSizeOffset]);
+    // The on-screen keyboard covers the sheet without resizing the window (#1567):
+    // give up the height the keyboard took, and let the content scroll clear of it.
+    const keyboardInset = useKeyboardInset(mobile);
+    // What the sheet can show right now. Snap points and visible heights must
+    // come from the same numbers, or a drag lands where the sheet is not.
+    const effectiveSizes = useMemo(() => {
+        if (keyboardInset <= 0)
+            return sizes;
+        // Never below the smallest snap point: a collapsed sheet reads as a white screen.
+        const full = Math.max(sizes.full - keyboardInset, sizes.small);
+        return {
+            small: Math.min(sizes.small, full),
+            medium: Math.min(sizes.medium, full),
+            full,
+        };
+    }, [sizes, keyboardInset]);
+    const [dragging, setDragging] = useState(false);
+    // The sheet is at zero height: closed, or mounted and about to animate open.
+    const [collapsed, setCollapsed] = useState(!open);
+    const [isAnimating, setIsAnimating] = useState(false);
+    const [shouldRender, setShouldRender] = useState(open);
+    const [isScrolled, setIsScrolled] = useState(false);
+    const overlayPanelRef = useRef(null);
+    const scrollRef = useRef(null);
+    const openedAtRef = useRef(undefined);
+    // The scroll container is published to descendants through context, and context is read during
+    // render — where a ref is still null on the render that mounts the element. Held as state as
+    // well, written from the ref callback: that write lands in the mount commit, so consumers see the
+    // element as soon as it exists rather than on whichever later render happens to come by.
+    const [scrollElement, setScrollElement] = useState(null);
+    const attachScroll = useCallback((node) => {
+        scrollRef.current = node;
+        setScrollElement(node);
+    }, []);
+    // The header slot, held as state for the same reason.
+    const [headerElement, setHeaderElement] = useState(null);
+    // The snap point the sheet actually sits on. The prop may be undefined
+    // before the host has chosen one, and a drag needs a value to start from.
+    const [currentSnap, setCurrentSnap] = useState(size);
+    // Mirror for the identity-stable callbacks below. Written after paint, not
+    // during render, so a concurrent re-render cannot observe a torn value.
+    const snapRef = useRef(currentSnap);
+    const sizeRef = useRef(size);
+    const onChangeSizeRef = useRef(onChangeSize);
+    useLayoutEffect(() => {
+        snapRef.current = currentSnap;
+        sizeRef.current = size;
+        onChangeSizeRef.current = onChangeSize;
+    });
+    // The snap point is the state; the height follows from it every render. Storing
+    // pixels instead would freeze whatever the keyboard allowed at that moment and
+    // keep the sheet short after it closes.
+    const setSize = useCallback((newSize) => {
+        setCurrentSnap(newSize);
+        setCollapsed(false);
+        onChangeSizeRef.current?.(newSize);
+    }, []);
+    const positioningStyles = useMemo(() => {
+        if (mobile) {
+            // The sheet stays on the bottom edge and runs on under the keyboard. A
+            // sheet lifted whole leaves the page showing below it, through the
+            // translucent bars iOS 26 floats there (#1712).
+            const sheet = (visible) => ({ height: visible + keyboardInset });
+            if (forceFull && open) {
+                // Covers the screen: `fullSizeOffset` keeps room for the search box above a
+                // regular sheet, and a forced-full one is drawn over it (#1713). Only the
+                // keyboard takes visible height away, never below the smallest snap point.
+                return sheet(Math.max(getActualViewportHeight() - keyboardInset, sizes.small));
+            }
+            // A gesture freezes the sheet at its tallest point and moves it with
+            // `translate3d`, keeping the drag off the layout path.
+            if (dragging)
+                return sheet(effectiveSizes.full);
+            // Closed, it takes no room at all, the part under the keyboard included.
+            if (collapsed || !(open || isAnimating))
+                return { height: 0 };
+            return sheet(effectiveSizes[currentSnap]);
+        }
+        return {
+            height: open ? 'auto' : undefined,
+        };
+    }, [
+        mobile,
+        open,
+        collapsed,
+        currentSnap,
+        isAnimating,
+        forceFull,
+        dragging,
+        sizes,
+        effectiveSizes,
+        keyboardInset,
+    ]);
+    // The content runs on under the keyboard with the sheet (#1712). The padding
+    // is the covered part: with it the end of the content scrolls clear of the
+    // keyboard, and what the browser scrolls into view lands above it.
+    const scrollStyles = useMemo(() => mobile && keyboardInset > 0
+        ? { paddingBottom: keyboardInset, scrollPaddingBottom: keyboardInset }
+        : undefined, [mobile, keyboardInset]);
+    const snapPoints = useMemo(() => [
+        { name: 'small', height: effectiveSizes.small },
+        { name: 'medium', height: effectiveSizes.medium },
+        { name: 'full', height: effectiveSizes.full },
+    ], [effectiveSizes]);
+    const handleDragStart = useCallback(() => setDragging(true), []);
+    const handleSettle = useCallback(() => setDragging(false), []);
+    const handleTriggerClick = useCallback(() => {
+        const currentSize = snapRef.current;
+        const nextSize = currentSize === 'small' ? 'medium' : currentSize === 'medium' ? 'full' : 'small';
+        setSize(nextSize);
+    }, [setSize]);
+    const { onPointerDown } = useSheetDrag({
+        enabled: mobile && !disableDrag && !forceFull,
+        panelRef: overlayPanelRef,
+        scrollElement,
+        snapPoints,
+        current: currentSnap,
+        openedAtRef,
+        onDragStart: handleDragStart,
+        onSnap: setSize,
+        onSettle: handleSettle,
+        onHandleTap: handleTriggerClick,
+    });
+    // The gesture owns `transform`; React owns `height`. Clear the transform in
+    // the same paint as the height React just wrote, so the sheet does not jump.
+    useLayoutEffect(() => {
+        if (dragging)
+            return;
+        const panel = overlayPanelRef.current;
+        if (!panel)
+            return;
+        // The swap must not run through the `height` transition — it would flash
+        // the sheet to the top of the screen.
+        panel.style.transition = 'none';
+        panel.style.removeProperty('transform');
+        const frame = requestAnimationFrame(() => panel.style.removeProperty('transition'));
+        return () => cancelAnimationFrame(frame);
+    }, [dragging]);
+    const handleScroll = useCallback(() => {
+        const scrollEl = scrollRef.current;
+        if (!scrollEl)
+            return;
+        const scrollTop = scrollEl.scrollTop;
+        const shouldAddClass = scrollTop >= scrollThreshold;
+        if (isScrolled !== shouldAddClass) {
+            setIsScrolled(shouldAddClass);
+            onScrollStateChange?.(shouldAddClass);
+        }
+    }, [scrollThreshold, isScrolled, onScrollStateChange]);
+    const debouncedScrollActivity = useMemo(() => debounce(() => {
+        onScrollActivity?.();
+    }, 250), [onScrollActivity]);
+    // Runs on open/close only. A `size` prop change (or a host re-creating
+    // `onChangeSize`) is not a re-open: re-running this would re-arm the opening
+    // lock and, 10ms later, write the prop over the snap point a drag just chose.
+    useEffect(() => {
+        if (open) {
+            setShouldRender(true);
+            setIsAnimating(true);
+            openedAtRef.current = performance.now();
+            return;
+        }
+        setIsAnimating(true);
+        openedAtRef.current = undefined;
+        if (mobile) {
+            setCollapsed(true);
+        }
+        const timer = setTimeout(() => {
+            setShouldRender(false);
+            setIsAnimating(false);
+            setIsScrolled(false);
+        }, parseFloat(TRANSITION_DURATION) * 1000);
+        return () => clearTimeout(timer);
+    }, [open, mobile]);
+    // The step after the mount: the sheet mounts at zero height and takes its size a tick later, so
+    // the height transition has a frame to start from. Keyed on `shouldRender` rather than run from
+    // the effect above, which fires on the render that only *asked* for the mount and returned null:
+    // a timer started there raced the mount render, and when it won, React batched the size flip
+    // into the mount itself — no transition, and no second render for anything the mount render
+    // could not yet know.
+    useEffect(() => {
+        if (!open || !shouldRender)
+            return;
+        const timer = setTimeout(() => {
+            setSize(sizeRef.current);
+            setIsAnimating(false);
+        }, 10);
+        return () => clearTimeout(timer);
+    }, [open, shouldRender, setSize]);
+    // Host-driven size changes (details open at full, the planner at medium).
+    // The sheet's own reports come back through here too, already applied.
+    useEffect(() => {
+        setCurrentSnap(size);
+    }, [size]);
+    useEffect(() => {
+        if (open && !isAnimating) {
+            scrollRef.current?.scrollTo({ top: 0 });
+            setIsScrolled(false);
+            onScrollStateChange?.(false);
+        }
+    }, [open, isAnimating, onScrollStateChange, scrollResetKey]);
+    if (!shouldRender)
+        return null;
+    return (_jsx(OverlayScrollContext, { value: scrollElement, children: _jsxs("div", { className: cn('efp-overlay', {
+                'efp-overlay--draggable': dragging,
+                'efp-overlay--keyboard': mobile && keyboardInset > 0,
+                'efp-overlay--full': currentSnap === 'full',
+                'efp-overlay--mobile': mobile,
+                'efp-overlay--desktop': !mobile,
+                'efp-overlay--hidden': !mobile && !open,
+                'efp-overlay--scrolled': isScrolled,
+                'efp-overlay--forced-full': forceFull && mobile,
+                'efp-overlay--button-inset': mobile && withFloatingButton,
+            }, className), style: positioningStyles, ref: overlayPanelRef, onPointerDown: onPointerDown, children: [!disableDrag && _jsx("div", { className: "efp-overlay__draghandle", "data-sheet-handle": true }), _jsx("div", { className: "efp-overlay__header", ref: setHeaderElement }), _jsxs("div", { className: "efp-overlay__scroll", style: scrollStyles, ref: attachScroll, onScroll: () => {
+                        handleScroll();
+                        debouncedScrollActivity();
+                    }, children: [particles, _jsx("div", { className: "efp-overlay__content", children: _jsx(OverlayHeaderContext, { value: headerElement, children: _jsx(OverlayKeyboardInsetContext, { value: mobile ? keyboardInset : 0, children: children ? children : noContentLabel }) }) })] })] }) }));
+};
+export default Overlay;

package/dist/components/Overlay/OverlayHeaderContext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The overlay's header slot: a node above the scroll container that descendants can portal into
+ * (e.g. a toolbar that must not scroll with the content). Provided by {@link Overlay}; `null` when
+ * rendered outside an overlay.
+ */
+export declare const OverlayHeaderContext: import("react").Context<HTMLDivElement | null>;
+//# sourceMappingURL=OverlayHeaderContext.d.ts.map

package/dist/components/Overlay/OverlayHeaderContext.js

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+/**
+ * The overlay's header slot: a node above the scroll container that descendants can portal into
+ * (e.g. a toolbar that must not scroll with the content). Provided by {@link Overlay}; `null` when
+ * rendered outside an overlay.
+ */
+export const OverlayHeaderContext = createContext(null);

package/dist/components/Overlay/OverlayKeyboardInsetContext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Height in px of the on-screen keyboard over the bottom of the overlay's scroll container, which
+ * runs on under it: whatever has to stay reachable must end that much above the container's
+ * bottom edge. Provided by {@link Overlay}; `0` with no keyboard, and outside an overlay.
+ */
+export declare const OverlayKeyboardInsetContext: import("react").Context<number>;
+//# sourceMappingURL=OverlayKeyboardInsetContext.d.ts.map

package/dist/components/Overlay/OverlayKeyboardInsetContext.js

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+/**
+ * Height in px of the on-screen keyboard over the bottom of the overlay's scroll container, which
+ * runs on under it: whatever has to stay reachable must end that much above the container's
+ * bottom edge. Provided by {@link Overlay}; `0` with no keyboard, and outside an overlay.
+ */
+export const OverlayKeyboardInsetContext = createContext(0);

package/dist/components/Overlay/OverlayScrollContext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exposes the overlay's inner scroll container to descendants so they can
+ * observe / drive it (e.g. a virtualized list syncing its scroll position).
+ * Provided by {@link Overlay}; `null` when rendered outside an overlay.
+ */
+export declare const OverlayScrollContext: import("react").Context<HTMLDivElement | null>;
+//# sourceMappingURL=OverlayScrollContext.d.ts.map

package/dist/components/Overlay/OverlayScrollContext.js

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+/**
+ * Exposes the overlay's inner scroll container to descendants so they can
+ * observe / drive it (e.g. a virtualized list syncing its scroll position).
+ * Provided by {@link Overlay}; `null` when rendered outside an overlay.
+ */
+export const OverlayScrollContext = createContext(null);

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

@@ -0,0 +1,5 @@
+export type { OverlayProps, Size } from './Overlay';
+export { default } from './Overlay';
+export { OverlayHeaderContext } from './OverlayHeaderContext';
+export { OverlayScrollContext } from './OverlayScrollContext';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Overlay/index.js

@@ -0,0 +1,3 @@
+export { default } from './Overlay';
+export { OverlayHeaderContext } from './OverlayHeaderContext';
+export { OverlayScrollContext } from './OverlayScrollContext';

package/dist/components/OverlayGrip/OverlayGrip.d.ts

@@ -0,0 +1,11 @@
+import './OverlayGrip.scss';
+import React from 'react';
+export interface OverlayGripProps {
+    isFull: boolean;
+    onToggle: () => void;
+    ariaLabel: string;
+    className?: string;
+}
+declare const OverlayGrip: ({ isFull, onToggle, ariaLabel, className }: OverlayGripProps) => React.JSX.Element;
+export default OverlayGrip;
+//# sourceMappingURL=OverlayGrip.d.ts.map

package/dist/components/OverlayGrip/OverlayGrip.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+import './OverlayGrip.scss';
+import cn from 'classnames';
+const OverlayGrip = ({ isFull, onToggle, ariaLabel, className }) => {
+    return (_jsx("button", { type: "button", className: cn('efp-overlay-grip', { 'efp-overlay-grip--full': isFull }, className), onClick: onToggle, "aria-label": ariaLabel, "aria-expanded": isFull, children: _jsxs("svg", { viewBox: "0 0 1200 200", preserveAspectRatio: "xMidYMid meet", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", children: [_jsx("path", { d: "M100,100 l 500 100 L 1100 100" }), _jsx("path", { d: "M100,150 l 500 0 L 1100 150" })] }) }));
+};
+export default OverlayGrip;

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

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

package/dist/components/OverlayGrip/index.js

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

package/dist/components/PermissionNotice/PermissionNotice.d.ts

@@ -0,0 +1,16 @@
+import './PermissionNotice.scss';
+import React from 'react';
+export type PermissionNoticePlacement = 'bottom-right' | 'bottom-left';
+export interface PermissionNoticeProps {
+    title: string;
+    acceptText: string;
+    rejectText: string;
+    children: React.ReactNode;
+    placement?: PermissionNoticePlacement;
+    onAccept?: () => void;
+    onReject?: () => void;
+    className?: string;
+}
+declare const PermissionNotice: ({ title, acceptText, rejectText, children, placement, onAccept, onReject, className, }: PermissionNoticeProps) => React.JSX.Element;
+export default PermissionNotice;
+//# sourceMappingURL=PermissionNotice.d.ts.map

package/dist/components/PermissionNotice/PermissionNotice.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './PermissionNotice.scss';
+import cn from 'classnames';
+import { useId } from 'react';
+import Button from '../Button';
+const PermissionNotice = ({ title, acceptText, rejectText, children, placement = 'bottom-right', onAccept, onReject, className, }) => {
+    const titleId = useId();
+    const descId = useId();
+    return (_jsxs("div", { className: cn('efp-permission-notice', `efp-permission-notice--${placement}`, className), role: "dialog", "aria-labelledby": titleId, "aria-describedby": descId, children: [_jsx("div", { className: "efp-permission-notice__title", id: titleId, children: title }), _jsx("div", { className: "efp-permission-notice__text", id: descId, children: children }), _jsxs("div", { className: "efp-permission-notice__bottom", children: [_jsx(Button, { size: "md", onClick: onAccept, children: acceptText }), _jsx(Button, { size: "md", variant: "gray", onClick: onReject, children: rejectText })] })] }));
+};
+export default PermissionNotice;

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

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

package/dist/components/PermissionNotice/index.js

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

package/dist/components/PlanSelector/PlanSelector.d.ts

@@ -0,0 +1,13 @@
+import './PlanSelector.scss';
+import type { ReactNode } from 'react';
+export interface PlanSelectorProps {
+    /** Plan-scope controls, stacked top to bottom (venue picker, then levels). */
+    children: ReactNode;
+}
+/**
+ * Places the plan-scope controls in the map's top corner. This is the only
+ * component of the stack that positions itself — the controls inside stay
+ * layout-agnostic, so composing them never means undoing their own placement.
+ */
+export default function PlanSelector({ children }: PlanSelectorProps): import("react").JSX.Element;
+//# sourceMappingURL=PlanSelector.d.ts.map

package/dist/components/PlanSelector/PlanSelector.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './PlanSelector.scss';
+/**
+ * Places the plan-scope controls in the map's top corner. This is the only
+ * component of the stack that positions itself — the controls inside stay
+ * layout-agnostic, so composing them never means undoing their own placement.
+ */
+export default function PlanSelector({ children }) {
+    return _jsx("div", { className: "efp-plan-selector", children: children });
+}

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

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

package/dist/components/PlanSelector/index.js

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

package/dist/components/Radio/Radio.d.ts

@@ -0,0 +1,15 @@
+import './Radio.scss';
+import React from 'react';
+export interface RadioProps {
+    name: string;
+    label: string;
+    value: string | number;
+    checked?: boolean;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    onChange?: () => void;
+}
+declare const Radio: ({ name, label, value, checked, disabled, className, ariaLabel, onChange, }: RadioProps) => React.JSX.Element;
+export default Radio;
+//# sourceMappingURL=Radio.d.ts.map

package/dist/components/Radio/Radio.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+import './Radio.scss';
+import classNames from 'classnames';
+import { useId } from 'react';
+const Radio = ({ name, label, value, checked, disabled, className, ariaLabel, onChange, }) => {
+    const id = useId();
+    return (_jsxs("label", { htmlFor: id, className: classNames('efp-radio', className, {
+            'efp-radio--checked': checked,
+            'efp-radio--disabled': disabled,
+        }), children: [_jsx("input", { type: "radio", className: "efp-radio__input", id: id, name: name, value: value, checked: checked, disabled: disabled, "aria-label": ariaLabel, onChange: onChange }), _jsx("span", { className: "efp-radio__control", "aria-hidden": "true" }), _jsx("span", { className: "efp-radio__label", children: label })] }));
+};
+export default Radio;

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

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

package/dist/components/Radio/index.js

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

package/dist/components/RebookingNotes/RebookingNotes.d.ts

@@ -0,0 +1,11 @@
+import './RebookingNotes.scss';
+export interface RebookingNotesProps {
+    value?: string;
+    noteLabel: string;
+    saveButtonLabel: string;
+    saveButtonAriaLabel: string;
+    onSave: (value: string) => void;
+}
+declare const RebookingNotes: ({ value, noteLabel, saveButtonLabel, saveButtonAriaLabel, onSave, }: RebookingNotesProps) => import("react").JSX.Element;
+export default RebookingNotes;
+//# sourceMappingURL=RebookingNotes.d.ts.map

package/dist/components/RebookingNotes/RebookingNotes.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './RebookingNotes.scss';
+import { useId, useState } from 'react';
+import Button from '../Button';
+const RebookingNotes = ({ value, noteLabel, saveButtonLabel, saveButtonAriaLabel, onSave, }) => {
+    const id = useId();
+    const labelId = `${id}-label`;
+    const textareaId = `${id}-textarea`;
+    // Uncontrolled editing buffer seeded from `value`; consumers reset it by remounting via `key`
+    // (see RebookingNotesContainer usage). Committed to the parent only on save.
+    const [internalValue, setInternalValue] = useState(value ?? '');
+    const handleChange = (event) => setInternalValue(event.target.value);
+    const handleSave = () => {
+        onSave(internalValue);
+    };
+    return (_jsxs("div", { className: "rebooking-notes", children: [_jsx("div", { className: "rebooking-notes__view-header", children: _jsx("strong", { id: labelId, children: noteLabel }) }), _jsxs("div", { className: "rebooking-notes__edit", children: [_jsx("div", { className: "rebooking-notes__val", children: _jsx("textarea", { id: textareaId, value: internalValue, onChange: handleChange, "aria-labelledby": labelId }) }), _jsx("div", { className: "rebooking-notes__buttons", children: _jsx(Button, { inline: true, onClick: handleSave, disabled: (value ?? '') === internalValue, "aria-label": saveButtonAriaLabel, children: saveButtonLabel }) })] })] }));
+};
+export default RebookingNotes;

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

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

package/dist/components/RebookingNotes/index.js

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

package/dist/components/RebookingRadioGroup/RebookingRadioGroup.d.ts

@@ -0,0 +1,17 @@
+import './RebookingRadioGroup.scss';
+export interface RebookingOption {
+    value: string;
+    label: string;
+    iconName?: string;
+    disabled?: boolean;
+    color: string;
+}
+export interface RebookingRadioGroupProps {
+    options: RebookingOption[];
+    value: string;
+    title?: string;
+    onChange: (value: string) => void;
+}
+declare const RebookingRadioGroup: ({ options, value, title, onChange }: RebookingRadioGroupProps) => import("react").JSX.Element;
+export default RebookingRadioGroup;
+//# sourceMappingURL=RebookingRadioGroup.d.ts.map

package/dist/components/RebookingRadioGroup/RebookingRadioGroup.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './RebookingRadioGroup.scss';
+import { useId } from 'react';
+const RebookingRadioGroup = ({ options, value, title, onChange }) => {
+    const idPrefix = useId();
+    return (_jsxs("div", { className: "rebooking-radio-group", children: [title && _jsx("div", { className: "rebooking-radio-group__title", children: title }), _jsx("div", { className: "rebooking-radio-group__options", children: options.map((option) => {
+                    const optionId = `${idPrefix}-${option.value}`;
+                    return (_jsxs("div", { className: "rebooking-radio", style: {
+                            '--rebooking-color-primary': option.color,
+                        }, children: [_jsx("input", { type: "radio", name: idPrefix, value: option.value, id: optionId, checked: option.value === value, disabled: option.disabled, onChange: () => onChange(option.value) }), _jsxs("label", { htmlFor: optionId, children: [_jsx("div", { className: "rebooking-radio__label", children: option.label }), _jsx("div", { className: "rebooking-radio__icon", children: _jsx("i", { className: option.iconName, "aria-hidden": "true" }) })] })] }, option.value));
+                }) })] }));
+};
+export default RebookingRadioGroup;

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

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

package/dist/components/RebookingRadioGroup/index.js

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

package/dist/components/ScrollableRow/ScrollableRow.d.ts

@@ -0,0 +1,21 @@
+import './ScrollableRow.scss';
+import React, { ReactNode } from 'react';
+export interface ScrollableRowProps {
+    children: ReactNode;
+    ariaLabel: string;
+    leftAriaLabel: string;
+    rightAriaLabel: string;
+    className?: string;
+    scrollAmount?: number;
+    mobileBreakpoint?: number;
+    showArrowsOnMobile?: boolean;
+    arrowPosition?: 'inside' | 'outside';
+    scrollBehavior?: 'smooth' | 'auto';
+    isRtl?: boolean;
+    enableDragScroll?: boolean;
+    dragScrollSensitivity?: number;
+    onScroll?: (scrollLeft: number) => void;
+}
+declare const ScrollableRow: ({ children, ariaLabel, leftAriaLabel, rightAriaLabel, className, scrollAmount, mobileBreakpoint, showArrowsOnMobile, arrowPosition, scrollBehavior, isRtl, enableDragScroll, dragScrollSensitivity, onScroll, }: ScrollableRowProps) => React.JSX.Element;
+export default ScrollableRow;
+//# sourceMappingURL=ScrollableRow.d.ts.map