@vuu-ui/vuu-ui-controls 2.1.19-beta.2 → 2.1.19-beta.4

package/src/calendar/internal/useFocusManagement.js

@@ -1,66 +0,0 @@
-import { endOfWeek, startOfWeek } from "@internationalized/date";
-import { useCalendarContext } from "./CalendarContext.js";
-import { getCurrentLocale } from "./utils.js";
-function useFocusManagement({ date }) {
-    const { helpers: { setFocusedDate } } = useCalendarContext();
-    const handleClick = (event)=>{
-        setFocusedDate(event, date);
-    };
-    const handleKeyDown = (event)=>{
-        let newDate = date;
-        switch(event.key){
-            case "ArrowUp":
-                newDate = date.subtract({
-                    weeks: 1
-                });
-                break;
-            case "ArrowDown":
-                newDate = date.add({
-                    weeks: 1
-                });
-                break;
-            case "ArrowLeft":
-                newDate = date.subtract({
-                    days: 1
-                });
-                break;
-            case "ArrowRight":
-                newDate = date.add({
-                    days: 1
-                });
-                break;
-            case "Home":
-                newDate = startOfWeek(date, getCurrentLocale());
-                break;
-            case "End":
-                newDate = endOfWeek(date, getCurrentLocale());
-                break;
-            case "PageUp":
-                newDate = event.shiftKey ? date.subtract({
-                    years: 1
-                }) : date.subtract({
-                    months: 1
-                });
-                break;
-            case "PageDown":
-                newDate = event.shiftKey ? date.add({
-                    years: 1
-                }) : date.add({
-                    months: 1
-                });
-                break;
-            default:
-        }
-        if (0 !== newDate.compare(date)) event.preventDefault();
-        setFocusedDate(event, newDate);
-    };
-    const handleFocus = (event)=>{
-        setFocusedDate(event, date);
-    };
-    return {
-        handleClick,
-        handleKeyDown,
-        handleFocus
-    };
-}
-export { useFocusManagement };

package/src/calendar/internal/utils.js

@@ -1,57 +0,0 @@
-import { DateFormatter, createCalendar, getLocalTimeZone, isSameMonth, startOfMonth, startOfWeek, startOfYear, today } from "@internationalized/date";
-const localTimezone = getLocalTimeZone();
-function getCurrentLocale() {
-    return navigator.languages[0];
-}
-function getDateFormatter(options) {
-    return new DateFormatter(getCurrentLocale(), options);
-}
-function formatDate(date, options) {
-    const formatter = getDateFormatter(options);
-    return formatter.format(date.toDate(localTimezone));
-}
-function getCalender() {
-    const calendarIdentifier = getDateFormatter().resolvedOptions().calendar;
-    return createCalendar(calendarIdentifier);
-}
-function daysForLocale(weekday = "long") {
-    return [
-        ...Array(7).keys()
-    ].map((day)=>formatDate(startOfWeek(today(getLocalTimeZone()), getCurrentLocale()).add({
-            days: day
-        }), {
-            weekday
-        }));
-}
-function monthsForLocale(currentYear) {
-    const calendar = getCalender();
-    return [
-        ...Array(calendar.getMonthsInYear(currentYear)).keys()
-    ].map((month)=>startOfYear(currentYear).add({
-            months: month
-        }));
-}
-function mapDate(currentDate, currentMonth) {
-    return {
-        date: currentDate,
-        dateOfMonth: currentDate.month,
-        isCurrentMonth: isSameMonth(currentDate, currentMonth)
-    };
-}
-function generateVisibleDays(currentMonth) {
-    const totalDays = 42;
-    const currentLocale = getCurrentLocale();
-    const startDate = startOfWeek(startOfMonth(currentMonth), currentLocale);
-    return [
-        ...Array(totalDays).keys()
-    ].map((dayDelta)=>{
-        const day = startDate.add({
-            days: dayDelta
-        });
-        return mapDate(day, currentMonth);
-    });
-}
-function monthDiff(a, b) {
-    return b.month - a.month + 12 * (b.year - a.year);
-}
-export { daysForLocale, formatDate, generateVisibleDays, getCalender, getCurrentLocale, getDateFormatter, monthDiff, monthsForLocale };

package/src/calendar/useCalendar.js

@@ -1,116 +0,0 @@
-import { endOfMonth, endOfYear, getLocalTimeZone, isSameDay, isSameMonth, startOfMonth, startOfYear, today } from "@internationalized/date";
-import { useControlled } from "@salt-ds/core";
-import { useCallback, useEffect, useState } from "react";
-import { isRangeOrOffsetSelectionWithStartDate, useSelectionCalendar } from "./useSelection.js";
-const defaultIsDayUnselectable = ()=>false;
-const defaultIsDayHighlighted = ()=>false;
-const defaultIsDayDisabled = ()=>false;
-function useCalendar(props) {
-    const { selectedDate, defaultSelectedDate, visibleMonth: visibleMonthProp, hideYearDropdown, hideOutOfRangeDates, defaultVisibleMonth = today(getLocalTimeZone()), onSelectedDateChange, onVisibleMonthChange, isDayUnselectable = defaultIsDayUnselectable, isDayHighlighted = defaultIsDayHighlighted, isDayDisabled = defaultIsDayDisabled, minDate = hideYearDropdown ? startOfYear(today(getLocalTimeZone())) : void 0, maxDate = hideYearDropdown ? endOfYear(today(getLocalTimeZone())) : void 0, selectionVariant, onHoveredDateChange, hoveredDate } = props;
-    const [visibleMonth, setVisibleMonthState] = useControlled({
-        controlled: visibleMonthProp ? startOfMonth(visibleMonthProp) : void 0,
-        default: startOfMonth(defaultVisibleMonth),
-        name: "Calendar",
-        state: "visibleMonth"
-    });
-    const isOutsideAllowedDates = useCallback((date)=>null != minDate && date.compare(minDate) < 0 || null != maxDate && date.compare(maxDate) > 0, [
-        maxDate,
-        minDate
-    ]);
-    const isOutsideAllowedMonths = (date)=>null != minDate && endOfMonth(date).compare(minDate) < 0 || null != maxDate && startOfMonth(date).compare(maxDate) > 0;
-    const isOutsideAllowedYears = (date)=>null != minDate && endOfYear(date).compare(minDate) < 0 || null != maxDate && startOfYear(date).compare(maxDate) > 0;
-    const isDaySelectable = useCallback((date)=>!(date && (isDayUnselectable(date) || isDayDisabled(date) || isOutsideAllowedDates(date))), [
-        isDayUnselectable,
-        isDayDisabled,
-        isOutsideAllowedDates
-    ]);
-    const selectionManager = useSelectionCalendar({
-        defaultSelectedDate: defaultSelectedDate,
-        selectedDate,
-        onSelectedDateChange,
-        startDateOffset: "offset" === props.selectionVariant ? props.startDateOffset : (date)=>date,
-        endDateOffset: "offset" === props.selectionVariant ? props.endDateOffset : (date)=>date,
-        isDaySelectable,
-        selectionVariant,
-        onHoveredDateChange,
-        hoveredDate
-    });
-    const [calendarFocused, setCalendarFocused] = useState(false);
-    const isInVisibleMonth = (date)=>null != date && isSameMonth(date, visibleMonth);
-    const getInitialFocusedDate = ()=>{
-        const selectedDate = selectionManager.state.selectedDate;
-        if (("range" === selectionVariant || "offset" === selectionVariant) && isRangeOrOffsetSelectionWithStartDate(selectedDate)) {
-            if (isInVisibleMonth(selectedDate?.startDate)) return selectedDate.startDate;
-            if (isInVisibleMonth(selectedDate?.endDate)) return selectedDate.endDate;
-            if (selectedDate?.startDate && selectedDate?.endDate && visibleMonth.compare(selectedDate.startDate) < 0 && visibleMonth.compare(selectedDate.endDate) > 0) return startOfMonth(visibleMonth);
-        }
-        if ("multiselect" === selectionVariant && Array.isArray(selectedDate)) {
-            const selectionInMonth = selectedDate.filter((day)=>isInVisibleMonth(day)).sort((a, b)=>a.compare(b));
-            if (selectionInMonth.length > 0) return selectionInMonth[0];
-        }
-        if ("default" === selectionVariant && !isRangeOrOffsetSelectionWithStartDate(selectedDate) && !Array.isArray(selectedDate) && isInVisibleMonth(selectedDate)) return selectedDate;
-        if (isInVisibleMonth(today(getLocalTimeZone()))) return today(getLocalTimeZone());
-        return startOfMonth(visibleMonth);
-    };
-    const [focusedDate, setFocusedDateState] = useState(getInitialFocusedDate);
-    const isDayVisible = useCallback((date)=>{
-        const startInsideDays = startOfMonth(visibleMonth);
-        if (date.compare(startInsideDays) < 0) return false;
-        const endInsideDays = endOfMonth(visibleMonth);
-        return !(date.compare(endInsideDays) > 0);
-    }, [
-        visibleMonth
-    ]);
-    const setVisibleMonth = useCallback((event, newVisibleMonth)=>{
-        setVisibleMonthState(newVisibleMonth);
-        onVisibleMonthChange?.(event, newVisibleMonth);
-    }, [
-        onVisibleMonthChange,
-        setVisibleMonthState
-    ]);
-    const setFocusedDate = useCallback((event, date)=>{
-        if (isSameDay(date, focusedDate) || isOutsideAllowedDates(date)) return;
-        setFocusedDateState(date);
-        const shouldTransition = !isDayVisible(date) && isDaySelectable(date) && !isOutsideAllowedDates(date);
-        if (shouldTransition) setVisibleMonth(event, startOfMonth(date));
-    }, [
-        focusedDate,
-        isDaySelectable,
-        isDayVisible,
-        isOutsideAllowedDates,
-        setVisibleMonth
-    ]);
-    useEffect(()=>{
-        if (!isDayVisible(focusedDate)) setFocusedDateState(getInitialFocusedDate());
-    }, [
-        isDayVisible,
-        focusedDate,
-        visibleMonth
-    ]);
-    return {
-        state: {
-            visibleMonth,
-            focusedDate,
-            minDate,
-            maxDate,
-            selectionVariant,
-            hideOutOfRangeDates,
-            calendarFocused,
-            ...selectionManager.state
-        },
-        helpers: {
-            setVisibleMonth,
-            setFocusedDate,
-            setCalendarFocused,
-            isDayUnselectable,
-            isDayHighlighted,
-            isDayDisabled,
-            isDayVisible,
-            isOutsideAllowedDates,
-            isOutsideAllowedMonths,
-            isOutsideAllowedYears,
-            ...selectionManager.helpers
-        }
-    };
-}
-export { useCalendar };

package/src/calendar/useCalendarDay.js

@@ -1,74 +0,0 @@
-import { getLocalTimeZone, isSameDay, isSameMonth, isToday } from "@internationalized/date";
-import { useEffect } from "react";
-import { useCalendarContext } from "./internal/CalendarContext.js";
-import { useFocusManagement } from "./internal/useFocusManagement.js";
-import { useSelectionDay } from "./useSelection.js";
-function useCalendarDay({ date, month }, ref) {
-    const { state: { focusedDate, hideOutOfRangeDates, calendarFocused }, helpers: { isDayUnselectable, isDayHighlighted, isDayDisabled, isOutsideAllowedMonths } } = useCalendarContext();
-    const selectionManager = useSelectionDay({
-        date
-    });
-    const focusManager = useFocusManagement({
-        date
-    });
-    const handleClick = (event)=>{
-        selectionManager?.handleClick(event);
-        focusManager.handleClick(event);
-    };
-    const handleKeyDown = (event)=>{
-        focusManager.handleKeyDown(event);
-        selectionManager?.handleKeyDown(event);
-    };
-    const handleFocus = (event)=>{
-        focusManager.handleFocus(event);
-    };
-    const handleMouseOver = (event)=>{
-        selectionManager.handleMouseOver?.(event);
-    };
-    const eventHandlers = {
-        onClick: handleClick,
-        onKeyDown: handleKeyDown,
-        onFocus: handleFocus,
-        onMouseOver: handleMouseOver
-    };
-    const outOfRange = !isSameMonth(date, month);
-    const focused = isSameDay(date, focusedDate) && calendarFocused && !outOfRange;
-    const tabIndex = isSameDay(date, focusedDate) && !outOfRange ? 0 : -1;
-    const today = isToday(date, getLocalTimeZone());
-    const unselectableReason = isDayUnselectable(date);
-    const highlightedReason = isDayHighlighted(date);
-    const disabled = isDayDisabled(date) || outOfRange && isOutsideAllowedMonths(date);
-    const unselectable = Boolean(unselectableReason);
-    const highlighted = Boolean(highlightedReason);
-    const hidden = hideOutOfRangeDates && outOfRange;
-    useEffect(()=>{
-        if (focused) ref.current?.focus({
-            preventScroll: true
-        });
-    }, [
-        ref,
-        focused
-    ]);
-    return {
-        status: {
-            outOfRange,
-            today,
-            unselectable,
-            focused,
-            hidden,
-            disabled,
-            highlighted,
-            ...selectionManager.status
-        },
-        dayProps: {
-            tabIndex,
-            "aria-current": today ? "date" : void 0,
-            "aria-hidden": hidden ? "true" : void 0,
-            ...eventHandlers,
-            ...selectionManager.dayProps
-        },
-        unselectableReason,
-        highlightedReason
-    };
-}
-export { useCalendarDay };

package/src/calendar/useSelection.js

@@ -1,202 +0,0 @@
-import { CalendarDate, isSameDay } from "@internationalized/date";
-import { makePrefixer, useControlled } from "@salt-ds/core";
-import { clsx } from "clsx";
-import { isPlainObject } from "../utils/index.js";
-import { useCalendarContext } from "./internal/CalendarContext.js";
-function addOrRemoveFromArray(array, item) {
-    if (Array.isArray(array)) {
-        if (array.find((element)=>isSameDay(element, item))) return array.filter((element)=>!isSameDay(element, item));
-        return array.concat(item);
-    }
-    return [
-        item
-    ];
-}
-const defaultOffset = (date)=>date;
-function isRangeOrOffsetSelectionValue(selectionValue) {
-    return null != selectionValue && isPlainObject(selectionValue);
-}
-function isRangeOrOffsetSelectionWithStartDate(selectionValue) {
-    return isRangeOrOffsetSelectionValue(selectionValue) && Object.prototype.hasOwnProperty.call(selectionValue, "startDate");
-}
-const withBaseName = makePrefixer("saltCalendarDay");
-function useSelectionCalendar(props) {
-    const { hoveredDate: hoveredDateProp, selectedDate: selectedDateProp, defaultSelectedDate, onHoveredDateChange, isDaySelectable, selectionVariant } = props;
-    const [selectedDate, setSelectedDateState] = useControlled({
-        controlled: selectedDateProp,
-        default: defaultSelectedDate,
-        name: "Calendar",
-        state: "selectedDate"
-    });
-    const getStartDateOffset = (date)=>{
-        if ("offset" === props.selectionVariant && props.startDateOffset) return props.startDateOffset(date);
-        return defaultOffset(date);
-    };
-    const getEndDateOffset = (date)=>{
-        if ("offset" === props.selectionVariant && props.endDateOffset) return props.endDateOffset(date);
-        return defaultOffset(date);
-    };
-    const setSelectedDate = (event, newSelectedDate)=>{
-        if (isDaySelectable(newSelectedDate)) switch(props.selectionVariant){
-            case "default":
-                setSelectedDateState(newSelectedDate);
-                props.onSelectedDateChange?.(event, newSelectedDate);
-                break;
-            case "multiselect":
-                {
-                    const newDates = addOrRemoveFromArray(selectedDate ?? [], newSelectedDate);
-                    setSelectedDateState(newDates);
-                    props.onSelectedDateChange?.(event, newDates);
-                    break;
-                }
-            case "range":
-                {
-                    let base = selectedDate;
-                    base = isRangeOrOffsetSelectionValue(base) ? base?.startDate && base?.endDate ? {
-                        startDate: newSelectedDate
-                    } : base?.startDate && newSelectedDate.compare(base.startDate) > 0 ? {
-                        ...base,
-                        endDate: newSelectedDate
-                    } : {
-                        startDate: newSelectedDate
-                    } : {
-                        startDate: newSelectedDate
-                    };
-                    setSelectedDateState(base);
-                    props.onSelectedDateChange?.(event, base);
-                    break;
-                }
-            case "offset":
-                {
-                    const newRange = {
-                        startDate: getStartDateOffset(newSelectedDate),
-                        endDate: getEndDateOffset(newSelectedDate)
-                    };
-                    setSelectedDateState(newRange);
-                    props.onSelectedDateChange?.(event, newRange);
-                }
-        }
-    };
-    const isSelected = (date)=>{
-        switch(selectionVariant){
-            case "default":
-                return selectedDate instanceof CalendarDate && isSameDay(selectedDate, date);
-            case "multiselect":
-                return Array.isArray(selectedDate) && !!selectedDate.find((element)=>isSameDay(element, date));
-            default:
-                return false;
-        }
-    };
-    const [hoveredDate, setHoveredDateState] = useControlled({
-        controlled: hoveredDateProp,
-        default: void 0,
-        name: "Calendar",
-        state: "hoveredDate"
-    });
-    const setHoveredDate = (event, date)=>{
-        setHoveredDateState(date);
-        onHoveredDateChange?.(event, date);
-    };
-    const isHovered = (date)=>!!hoveredDate && isSameDay(date, hoveredDate);
-    const isSelectedSpan = (date)=>{
-        if (("range" === selectionVariant || "offset" === selectionVariant) && isRangeOrOffsetSelectionValue(selectedDate) && selectedDate?.startDate && selectedDate?.endDate) return date.compare(selectedDate.startDate) > 0 && date.compare(selectedDate.endDate) < 0;
-        return false;
-    };
-    const isHoveredSpan = (date)=>{
-        if (("range" === selectionVariant || "offset" === selectionVariant) && isRangeOrOffsetSelectionValue(selectedDate) && selectedDate.startDate && !selectedDate.endDate && hoveredDate) {
-            const isForwardRange = hoveredDate.compare(selectedDate.startDate) > 0 && (date.compare(selectedDate.startDate) > 0 && date.compare(hoveredDate) < 0 || isSameDay(date, hoveredDate));
-            const isValidDayHovered = isDaySelectable(hoveredDate);
-            return isForwardRange && isValidDayHovered;
-        }
-        return false;
-    };
-    const isSelectedStart = (date)=>{
-        if (("range" === selectionVariant || "offset" === selectionVariant) && isRangeOrOffsetSelectionValue(selectedDate) && selectedDate.startDate) return isSameDay(selectedDate.startDate, date);
-        return false;
-    };
-    const isSelectedEnd = (date)=>{
-        if (("range" === selectionVariant || "offset" === selectionVariant) && isRangeOrOffsetSelectionValue(selectedDate) && selectedDate.endDate) return isSameDay(selectedDate.endDate, date);
-        return false;
-    };
-    const isHoveredOffset = (date)=>{
-        if (hoveredDate && "offset" === selectionVariant) {
-            const startDate = getStartDateOffset(hoveredDate);
-            const endDate = getEndDateOffset(hoveredDate);
-            return date.compare(startDate) >= 0 && date.compare(endDate) <= 0 && isDaySelectable(date);
-        }
-        return false;
-    };
-    return {
-        state: {
-            selectedDate,
-            hoveredDate
-        },
-        helpers: {
-            setSelectedDate,
-            isSelected,
-            setHoveredDate,
-            isHovered,
-            isSelectedSpan,
-            isHoveredSpan,
-            isSelectedStart,
-            isSelectedEnd,
-            isHoveredOffset
-        }
-    };
-}
-function useSelectionDay({ date }) {
-    const { helpers: { setSelectedDate, isSelected, setHoveredDate, isSelectedSpan, isHoveredSpan, isSelectedStart, isSelectedEnd, isHovered, isHoveredOffset, isDayUnselectable } } = useCalendarContext();
-    const handleClick = (event)=>{
-        setSelectedDate(event, date);
-    };
-    const handleKeyDown = (event)=>{
-        switch(event.key){
-            case "Space":
-            case "Enter":
-                setSelectedDate(event, date);
-                event.preventDefault();
-        }
-    };
-    const handleMouseOver = (event)=>{
-        setHoveredDate(event, date);
-    };
-    const handleMouseLeave = (event)=>{
-        setHoveredDate(event, null);
-    };
-    const selected = isSelected(date);
-    const selectedSpan = isSelectedSpan(date);
-    const hoveredSpan = isHoveredSpan(date);
-    const selectedStart = isSelectedStart(date);
-    const selectedEnd = isSelectedEnd(date);
-    const hovered = isHovered(date);
-    const hoveredOffset = isHoveredOffset(date);
-    return {
-        handleClick,
-        handleKeyDown,
-        handleMouseOver,
-        handleMouseLeave,
-        status: {
-            selected,
-            selectedSpan,
-            hoveredSpan,
-            selectedStart,
-            selectedEnd,
-            hovered,
-            hoveredOffset
-        },
-        dayProps: {
-            className: clsx({
-                [withBaseName("selected")]: selected,
-                [withBaseName("selectedSpan")]: selectedSpan,
-                [withBaseName("hoveredSpan")]: hoveredSpan,
-                [withBaseName("selectedStart")]: selectedStart,
-                [withBaseName("selectedEnd")]: selectedEnd,
-                [withBaseName("hovered")]: hovered,
-                [withBaseName("hoveredOffset")]: hoveredOffset
-            }),
-            "aria-pressed": selected || selectedEnd || selectedStart || selectedSpan ? "true" : void 0,
-            "aria-disabled": isDayUnselectable(date) ? "true" : void 0
-        }
-    };
-}
-export { isRangeOrOffsetSelectionValue, isRangeOrOffsetSelectionWithStartDate, useSelectionCalendar, useSelectionDay };

package/src/column-picker/ColumnPicker.css.js

@@ -1,8 +0,0 @@
-const css = `
-.vuuColumnPicker {
-  z-index: 100;
-}
-
-
-`;
-export default css;

package/src/column-picker/ColumnPicker.js

@@ -1,108 +0,0 @@
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { flip, size, useClick, useDismiss, useInteractions } from "@floating-ui/react";
-import { useFloatingComponent, useFloatingUI, useForkRef, useIdMemo } from "@salt-ds/core";
-import { useComponentCssInjection } from "@salt-ds/styles";
-import { useWindow } from "@salt-ds/window";
-import clsx from "clsx";
-import { forwardRef, useState } from "react";
-import { IconButton } from "../icon-button/index.js";
-import { ColumnSearch } from "./ColumnSearch.js";
-import ColumnPicker_0 from "./ColumnPicker.css";
-const classBase = "vuuColumnPicker";
-const ColumnPicker_FloatingColumnSearch = /*#__PURE__*/ forwardRef(function(props, ref) {
-    const { children, className, collapsed, open, ...rest } = props;
-    const { Component: FloatingComponent } = useFloatingComponent();
-    return /*#__PURE__*/ jsx(FloatingComponent, {
-        className: clsx(classBase, {
-            [`${classBase}-collapsed`]: collapsed
-        }, className),
-        role: "listbox",
-        open: open,
-        ...rest,
-        ref: ref,
-        children: children
-    });
-});
-const ColumnPicker_ColumnPicker = /*#__PURE__*/ forwardRef(function({ columns, icon = "add", iconSize, onSelectionChange, selected, ...htmlAttributes }, forwardedRef) {
-    const targetWindow = useWindow();
-    useComponentCssInjection({
-        testId: "vuu-column-picker",
-        css: ColumnPicker_0,
-        window: targetWindow
-    });
-    const [open, setOpen] = useState(false);
-    const listId = useIdMemo();
-    const { context, x, y, strategy, elements, floating, reference } = useFloatingUI({
-        open,
-        onOpenChange: setOpen,
-        placement: "bottom-start",
-        strategy: "fixed",
-        middleware: [
-            size({
-                apply ({ rects, elements, availableHeight }) {
-                    Object.assign(elements.floating.style, {
-                        minWidth: `${rects.reference.width}px`,
-                        maxHeight: `max(calc(${availableHeight}px - var(--salt-spacing-100)), calc((var(--salt-size-base) + var(--salt-spacing-100)) * 5))`
-                    });
-                }
-            }),
-            flip({
-                fallbackStrategy: "initialPlacement"
-            })
-        ]
-    });
-    const { getReferenceProps, getFloatingProps } = useInteractions([
-        useDismiss(context),
-        useClick(context, {
-            keyboardHandlers: false,
-            toggle: false
-        })
-    ]);
-    const handleButtonClick = ()=>{
-        setOpen((isOpen)=>!isOpen);
-    };
-    const forkedRef = useForkRef(reference, forwardedRef);
-    const handleChange = ()=>{
-        console.log("handleChange");
-    };
-    const handleReorderColumns = ()=>{
-        console.log("handleMoveListItem");
-    };
-    return /*#__PURE__*/ jsxs(Fragment, {
-        children: [
-            /*#__PURE__*/ jsx(IconButton, {
-                ...htmlAttributes,
-                ...getReferenceProps(),
-                icon: icon,
-                size: iconSize,
-                onClick: handleButtonClick,
-                ref: forkedRef,
-                variant: "secondary"
-            }),
-            /*#__PURE__*/ jsx(ColumnPicker_FloatingColumnSearch, {
-                ...getFloatingProps(),
-                open: open,
-                collapsed: !open,
-                id: listId,
-                left: x,
-                position: strategy,
-                ref: floating,
-                top: y,
-                width: elements.floating?.offsetWidth,
-                height: elements.floating?.offsetHeight,
-                children: /*#__PURE__*/ jsx(ColumnSearch, {
-                    columns: columns,
-                    onChange: handleChange,
-                    onReorderColumns: handleReorderColumns,
-                    onSelectionChange: onSelectionChange,
-                    selected: selected,
-                    style: {
-                        width: 220,
-                        height: 300
-                    }
-                })
-            })
-        ]
-    });
-});
-export { ColumnPicker_ColumnPicker as ColumnPicker };