@vuu-ui/vuu-data-react 0.13.45 → 0.13.46

package/types/vuu-popups/src/tooltip/useTooltip.d.ts

@@ -0,0 +1,19 @@
+import { MouseEvent, ReactNode } from "react";
+import { TooltipProps } from "./Tooltip";
+import { TooltipPlacement } from "./useTooltipAnchoredPosition";
+export interface TooltipHookProps {
+    anchorQuery?: string;
+    id: string;
+    placement?: TooltipPlacement | TooltipPlacement[];
+    tooltipContent: ReactNode;
+}
+export declare const useTooltip: ({ anchorQuery, id: idProp, placement, tooltipContent, }: TooltipHookProps) => {
+    anchorProps: {
+        "aria-describedby": string;
+        onMouseEnter: (evt: MouseEvent) => void;
+        onMouseLeave: () => void;
+    };
+    hideTooltip: (defer?: number) => void;
+    showTooltip: (ref?: import("react").RefObject<HTMLElement | null>) => void;
+    tooltipProps: TooltipProps | undefined;
+};

package/types/vuu-popups/src/tooltip/useTooltipAnchoredPosition.d.ts

@@ -0,0 +1,7 @@
+import { RefCallback, RefObject } from "react";
+export type TooltipPlacement = "above" | "right" | "below" | "left";
+export interface TooltipAnchoredPositionHookProps {
+    anchorElement: RefObject<HTMLElement | null>;
+    placement: TooltipPlacement | TooltipPlacement[];
+}
+export declare const useTooltipAnchoredPosition: ({ anchorElement, placement, }: TooltipAnchoredPositionHookProps) => RefCallback<HTMLDivElement>;

package/types/vuu-ui-controls/src/calendar/Calendar.d.ts

@@ -0,0 +1,13 @@
+import { type CalendarCarouselProps } from "./internal/CalendarCarousel";
+import { type CalendarNavigationProps } from "./internal/CalendarNavigation";
+import { type useCalendarProps } from "./useCalendar";
+export type CalendarProps = useCalendarProps & {
+    className?: string;
+    id?: string;
+    renderDayContents?: CalendarCarouselProps["renderDayContents"];
+    hideYearDropdown?: CalendarNavigationProps["hideYearDropdown"];
+    borderedDropdown?: CalendarNavigationProps["borderedDropdown"];
+    TooltipProps?: CalendarCarouselProps["TooltipProps"];
+    hideOutOfRangeDates?: CalendarCarouselProps["hideOutOfRangeDates"];
+};
+export declare const Calendar: import("react").ForwardRefExoticComponent<CalendarProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/calendar/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Calendar";
+export * from "./useCalendarDay";
+export * from "./useCalendar";
+export * from "./useSelection";

package/types/vuu-ui-controls/src/calendar/internal/CalendarCarousel.d.ts

@@ -0,0 +1,3 @@
+import { type CalendarMonthProps } from "./CalendarMonth";
+export type CalendarCarouselProps = Omit<CalendarMonthProps, "date">;
+export declare const CalendarCarousel: import("react").ForwardRefExoticComponent<Omit<CalendarCarouselProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/calendar/internal/CalendarContext.d.ts

@@ -0,0 +1,8 @@
+import type { useCalendar } from "../useCalendar";
+interface CalendarState {
+    state: ReturnType<typeof useCalendar>["state"];
+    helpers: ReturnType<typeof useCalendar>["helpers"];
+}
+declare const CalendarContext: import("react").Context<CalendarState | null>;
+declare function useCalendarContext(): CalendarState;
+export { CalendarContext, useCalendarContext };

package/types/vuu-ui-controls/src/calendar/internal/CalendarDay.d.ts

@@ -0,0 +1,14 @@
+import type { DateValue } from "@internationalized/date";
+import { type TooltipProps } from "@salt-ds/core";
+import { type ComponentPropsWithRef, type ReactElement } from "react";
+import { type DayStatus } from "../useCalendarDay";
+export type DateFormatter = (day: Date) => string | undefined;
+export interface CalendarDayProps extends Omit<ComponentPropsWithRef<"button">, "children"> {
+    day: DateValue;
+    formatDate?: DateFormatter;
+    renderDayContents?: (date: DateValue, status: DayStatus) => ReactElement;
+    status?: DayStatus;
+    month: DateValue;
+    TooltipProps?: Partial<TooltipProps>;
+}
+export declare const CalendarDay: import("react").ForwardRefExoticComponent<Omit<CalendarDayProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/types/vuu-ui-controls/src/calendar/internal/CalendarMonth.d.ts

@@ -0,0 +1,10 @@
+import type { DateValue } from "@internationalized/date";
+import { type ComponentPropsWithRef } from "react";
+import { type CalendarDayProps } from "./CalendarDay";
+export interface CalendarMonthProps extends ComponentPropsWithRef<"div"> {
+    date: DateValue;
+    hideOutOfRangeDates?: boolean;
+    renderDayContents?: CalendarDayProps["renderDayContents"];
+    TooltipProps?: CalendarDayProps["TooltipProps"];
+}
+export declare const CalendarMonth: import("react").ForwardRefExoticComponent<Omit<CalendarMonthProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/calendar/internal/CalendarNavigation.d.ts

@@ -0,0 +1,16 @@
+import { type ButtonProps, type DropdownProps } from "@salt-ds/core";
+import { type ComponentPropsWithRef } from "react";
+import { type DateValue } from "@internationalized/date";
+type dateDropdownProps = DropdownProps<DateValue>;
+export interface CalendarNavigationProps extends ComponentPropsWithRef<"div"> {
+    MonthDropdownProps?: dateDropdownProps;
+    YearDropdownProps?: dateDropdownProps;
+    onMonthSelect?: dateDropdownProps["onChange"];
+    onYearSelect?: dateDropdownProps["onChange"];
+    borderedDropdown?: dateDropdownProps["bordered"];
+    onNavigateNext?: ButtonProps["onClick"];
+    onNavigatePrevious?: ButtonProps["onClick"];
+    hideYearDropdown?: boolean;
+}
+export declare const CalendarNavigation: import("react").ForwardRefExoticComponent<Omit<CalendarNavigationProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/types/vuu-ui-controls/src/calendar/internal/CalendarWeekHeader.d.ts

@@ -0,0 +1,3 @@
+import { type ComponentPropsWithRef } from "react";
+export type CalendarWeekHeaderProps = ComponentPropsWithRef<"div">;
+export declare const CalendarWeekHeader: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/calendar/internal/useFocusManagement.d.ts

@@ -0,0 +1,9 @@
+import { type DateValue } from "@internationalized/date";
+import type { FocusEventHandler, KeyboardEventHandler, MouseEventHandler } from "react";
+export declare function useFocusManagement({ date }: {
+    date: DateValue;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    handleFocus: FocusEventHandler<HTMLButtonElement>;
+};

package/types/vuu-ui-controls/src/calendar/internal/utils.d.ts

@@ -0,0 +1,15 @@
+import { DateFormatter, type DateValue } from "@internationalized/date";
+export declare function getCurrentLocale(): string;
+export declare function getDateFormatter(options?: Intl.DateTimeFormatOptions): DateFormatter;
+export declare function formatDate(date: DateValue, options?: Intl.DateTimeFormatOptions): string;
+export declare function getCalender(): import("@internationalized/date").Calendar;
+type WeekdayFormat = Intl.DateTimeFormatOptions["weekday"];
+export declare function daysForLocale(weekday?: WeekdayFormat): string[];
+export declare function monthsForLocale(currentYear: DateValue): (import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime)[];
+export declare function generateVisibleDays(currentMonth: DateValue): {
+    date: DateValue;
+    dateOfMonth: number;
+    isCurrentMonth: boolean;
+}[];
+export declare function monthDiff(a: DateValue, b: DateValue): number;
+export {};

package/types/vuu-ui-controls/src/calendar/useCalendar.d.ts

@@ -0,0 +1,54 @@
+import { type DateValue } from "@internationalized/date";
+import { type SyntheticEvent } from "react";
+import { type UseMultiSelectionCalendarProps, type UseOffsetSelectionCalendarProps, type UseRangeSelectionCalendarProps, type UseSingleSelectionCalendarProps } from "./useSelection";
+interface BaseUseCalendarProps {
+    defaultVisibleMonth?: DateValue;
+    onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: DateValue) => void;
+    isDayUnselectable?: (date: DateValue) => string | false | undefined;
+    isDayHighlighted?: (date: DateValue) => string | false | undefined;
+    isDayDisabled?: (date: DateValue) => boolean;
+    visibleMonth?: DateValue;
+    hideOutOfRangeDates?: boolean;
+    hideYearDropdown?: boolean;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+export type useCalendarProps = (Omit<UseSingleSelectionCalendarProps, "isDaySelectable"> | Omit<UseMultiSelectionCalendarProps, "isDaySelectable"> | Omit<UseRangeSelectionCalendarProps, "isDaySelectable"> | Omit<UseOffsetSelectionCalendarProps, "isDaySelectable">) & BaseUseCalendarProps;
+export declare function useCalendar(props: useCalendarProps): {
+    state: {
+        selectedDate: DateValue | import("./useSelection").RangeSelectionValueType | {
+            startDate?: DateValue;
+            endDate?: DateValue;
+        } | DateValue[] | null | undefined;
+        hoveredDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | null | undefined;
+        visibleMonth: DateValue;
+        focusedDate: DateValue;
+        minDate: DateValue | undefined;
+        maxDate: DateValue | undefined;
+        selectionVariant: "default" | "offset" | "range" | "multiselect";
+        hideOutOfRangeDates: boolean | undefined;
+        calendarFocused: boolean;
+    };
+    helpers: {
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement>, newSelectedDate: DateValue) => void;
+        isSelected: (date: DateValue) => boolean;
+        setHoveredDate: (event: SyntheticEvent, date: DateValue | null) => void;
+        isHovered: (date: DateValue) => boolean;
+        isSelectedSpan: (date: DateValue) => boolean;
+        isHoveredSpan: (date: DateValue) => boolean;
+        isSelectedStart: (date: DateValue) => boolean;
+        isSelectedEnd: (date: DateValue) => boolean;
+        isHoveredOffset: (date: DateValue) => boolean;
+        setVisibleMonth: (event: SyntheticEvent, newVisibleMonth: DateValue) => void;
+        setFocusedDate: (event: SyntheticEvent, date: DateValue) => void;
+        setCalendarFocused: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        isDayUnselectable: (date: DateValue) => string | false | undefined;
+        isDayHighlighted: (date: DateValue) => string | false | undefined;
+        isDayDisabled: (date: DateValue) => boolean;
+        isDayVisible: (date: DateValue) => boolean;
+        isOutsideAllowedDates: (date: DateValue) => boolean;
+        isOutsideAllowedMonths: (date: DateValue) => boolean;
+        isOutsideAllowedYears: (date: DateValue) => boolean;
+    };
+};
+export {};

package/types/vuu-ui-controls/src/calendar/useCalendarDay.d.ts

@@ -0,0 +1,22 @@
+import { type DateValue } from "@internationalized/date";
+import { type ComponentPropsWithoutRef, type RefObject } from "react";
+export interface DayStatus {
+    outOfRange?: boolean;
+    selected?: boolean;
+    today?: boolean;
+    unselectable?: string | false;
+    highlighted?: string | false;
+    focused?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+}
+export interface useCalendarDayProps {
+    date: DateValue;
+    month: DateValue;
+}
+export declare function useCalendarDay({ date, month }: useCalendarDayProps, ref: RefObject<HTMLElement | null>): {
+    status: DayStatus;
+    dayProps: ComponentPropsWithoutRef<"button">;
+    unselectableReason: string | false | undefined;
+    highlightedReason: string | false | undefined;
+};

package/types/vuu-ui-controls/src/calendar/useSelection.d.ts

@@ -0,0 +1,78 @@
+import { CalendarDate, type DateValue } from "@internationalized/date";
+import type { KeyboardEventHandler, MouseEventHandler, SyntheticEvent } from "react";
+interface BaseUseSelectionCalendarProps<SelectionVariantType> {
+    hoveredDate?: DateValue | null;
+    selectedDate?: SelectionVariantType | null;
+    defaultSelectedDate?: SelectionVariantType;
+    onSelectedDateChange?: (event: SyntheticEvent, selectedDate: SelectionVariantType) => void;
+    isDaySelectable: (date?: DateValue) => boolean;
+    onHoveredDateChange?: (event: SyntheticEvent, hoveredDate: DateValue | null) => void;
+}
+export type SingleSelectionValueType = DateValue;
+type MultiSelectionValueType = DateValue[];
+export type RangeSelectionValueType = {
+    startDate?: DateValue;
+    endDate?: DateValue;
+};
+type OffsetSelectionValueType = {
+    startDate?: DateValue;
+    endDate?: DateValue;
+};
+type AllSelectionValueType = SingleSelectionValueType | MultiSelectionValueType | RangeSelectionValueType | OffsetSelectionValueType | null;
+export interface UseOffsetSelectionCalendarProps extends Omit<BaseUseSelectionCalendarProps<OffsetSelectionValueType>, "startDateOffset" | "endDateOffset"> {
+    selectionVariant: "offset";
+    startDateOffset?: (date: DateValue) => DateValue;
+    endDateOffset?: (date: DateValue) => DateValue;
+}
+export interface UseRangeSelectionCalendarProps extends BaseUseSelectionCalendarProps<RangeSelectionValueType> {
+    selectionVariant: "range";
+}
+export interface UseMultiSelectionCalendarProps extends BaseUseSelectionCalendarProps<MultiSelectionValueType> {
+    selectionVariant: "multiselect";
+}
+export interface UseSingleSelectionCalendarProps extends BaseUseSelectionCalendarProps<SingleSelectionValueType> {
+    selectionVariant: "default";
+}
+export type useSelectionCalendarProps = UseSingleSelectionCalendarProps | UseMultiSelectionCalendarProps | UseRangeSelectionCalendarProps | UseOffsetSelectionCalendarProps;
+export declare function isRangeOrOffsetSelectionValue(selectionValue?: AllSelectionValueType): selectionValue is RangeSelectionValueType | OffsetSelectionValueType;
+export declare function isRangeOrOffsetSelectionWithStartDate(selectionValue?: AllSelectionValueType): selectionValue is RangeSelectionValueType | OffsetSelectionValueType;
+export declare function useSelectionCalendar(props: useSelectionCalendarProps): {
+    state: {
+        selectedDate: DateValue | RangeSelectionValueType | OffsetSelectionValueType | MultiSelectionValueType | null | undefined;
+        hoveredDate: CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | null | undefined;
+    };
+    helpers: {
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement>, newSelectedDate: DateValue) => void;
+        isSelected: (date: DateValue) => boolean;
+        setHoveredDate: (event: SyntheticEvent, date: DateValue | null) => void;
+        isHovered: (date: DateValue) => boolean;
+        isSelectedSpan: (date: DateValue) => boolean;
+        isHoveredSpan: (date: DateValue) => boolean;
+        isSelectedStart: (date: DateValue) => boolean;
+        isSelectedEnd: (date: DateValue) => boolean;
+        isHoveredOffset: (date: DateValue) => boolean;
+    };
+};
+export declare function useSelectionDay({ date }: {
+    date: DateValue;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    handleMouseOver: MouseEventHandler<HTMLButtonElement>;
+    handleMouseLeave: MouseEventHandler<HTMLButtonElement>;
+    status: {
+        selected: boolean;
+        selectedSpan: boolean;
+        hoveredSpan: boolean;
+        selectedStart: boolean;
+        selectedEnd: boolean;
+        hovered: boolean;
+        hoveredOffset: boolean;
+    };
+    dayProps: {
+        className: string;
+        "aria-pressed": string | undefined;
+        "aria-disabled": string | undefined;
+    };
+};
+export {};

package/types/vuu-ui-controls/src/column-picker/ColumnPicker.d.ts

@@ -0,0 +1,7 @@
+import { IconButtonProps } from "../icon-button";
+import { ColumnSearchProps } from "./ColumnSearch";
+export interface ColumnPickerProps extends Omit<IconButtonProps, "icon">, Pick<ColumnSearchProps, "columns" | "onSelectionChange" | "selected"> {
+    icon?: string;
+    iconSize?: number;
+}
+export declare const ColumnPicker: import("react").ForwardRefExoticComponent<ColumnPickerProps & import("react").RefAttributes<HTMLButtonElement>>;

package/types/vuu-ui-controls/src/column-picker/ColumnSearch.d.ts

@@ -0,0 +1,12 @@
+import { ListBoxProps } from "@salt-ds/core";
+import { HTMLAttributes } from "react";
+export interface ColumnSearchProps extends HTMLAttributes<HTMLDivElement>, Pick<ListBoxProps, "onSelectionChange" | "selected"> {
+    columns: string[];
+    onReorderColumns: (columns: string[]) => void;
+}
+/**
+ * @deprecated
+ *
+ * use ColumnList instead
+ */
+export declare const ColumnSearch: import("react").ForwardRefExoticComponent<ColumnSearchProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/column-picker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ColumnPicker";
+export * from "./ColumnSearch";

package/types/vuu-ui-controls/src/common-hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./useControlled";
+export * from "./use-resize-observer";
+export * from "./selectionTypes";

package/types/vuu-ui-controls/src/common-hooks/selectionTypes.d.ts

@@ -0,0 +1,70 @@
+import { MouseEventHandler, RefObject, SyntheticEvent } from "react";
+export type SelectionDisallowed = "none";
+export type SingleSelectionStrategy = "default" | "deselectable";
+export type MultiSelectionStrategy = "multiple" | "extended" | "extended-multi-range";
+/**
+ * SpecialKeyMultiple works as deselectable unless a special key
+ * (default SHIFT) is also pressed, then it allows multiple selection.
+ * Useful for column sorting, filters etc
+ */
+export type SpecialKeyMultipleSelection = "multiple-special-key";
+export type SelectionStrategy = SelectionDisallowed | SingleSelectionStrategy | MultiSelectionStrategy;
+export declare const isSingleSelection: (s?: SelectionStrategy) => s is SingleSelectionStrategy;
+export declare const isMultiSelection: (s?: SelectionStrategy) => s is MultiSelectionStrategy;
+export type SelectHandler<Item = string> = (event: SyntheticEvent, selectedItem: Item) => void;
+export declare const selectionIsDisallowed: (selection?: SelectionStrategy | SpecialKeyMultipleSelection) => selection is SelectionDisallowed;
+export declare const allowMultipleSelection: (selectionStrategy: SelectionStrategy | SpecialKeyMultipleSelection, specialKey?: boolean) => boolean;
+export declare const deselectionIsAllowed: (selection?: SelectionStrategy | SpecialKeyMultipleSelection) => selection is "deselectable" | MultiSelectionStrategy;
+export declare const hasSelection: <Item = unknown>(selected?: Item[]) => boolean;
+export declare const getFirstSelectedItem: <Item = unknown>(selected: Item[]) => Item;
+interface SelectionProps {
+    defaultSelected?: string[];
+    onSelect?: SelectHandler;
+    onSelectionChange?: MultiSelectionHandler;
+    selected?: string[];
+    selectionStrategy?: SelectionStrategy;
+}
+export interface ListHandlers {
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
+    onKeyboardNavigation?: (event: React.KeyboardEvent, currentIndex: number) => void;
+    onMouseMove?: (event: React.MouseEvent) => void;
+}
+export interface SelectionHookProps extends SelectionProps {
+    containerRef: RefObject<HTMLElement | null>;
+    disableSelection?: boolean;
+    highlightedIndex: number;
+    itemQuery: string;
+    label?: string;
+    onClick?: MouseEventHandler;
+    selectionKeys?: string[];
+    tabToSelect?: boolean;
+}
+export interface SelectionHookResult {
+    listHandlers: ListHandlers;
+    selected: string[];
+    setSelected: (selected: string[]) => void;
+}
+/**
+ * evt is only null in the special case of a selection fired from a multi-select
+ * host on tab or selection based on freeform text in combobox
+ */
+export type MultiSelectionHandler<Item = string> = (event: SyntheticEvent | null, selected: Item[]) => void;
+/**
+ * evt is only null in the special case of freeform text in combobox
+ */
+export type SingleSelectionHandler<Item = string> = (event: SyntheticEvent | null, selected: Item) => void;
+export type SelectionType<I, S extends SelectionStrategy> = S extends MultiSelectionStrategy ? I[] : I | null;
+export interface ComponentSelectionProps<Item = string, S extends SelectionStrategy = "default"> {
+    defaultSelected?: S extends MultiSelectionStrategy ? Item[] : Item;
+    onSelect?: SelectHandler<Item>;
+    onSelectionChange?: S extends MultiSelectionStrategy ? MultiSelectionHandler<Item> : SingleSelectionHandler<Item>;
+    selected?: SelectionType<Item, S>;
+    selectionStrategy?: S;
+    /**
+     * The keyboard keys used to effect selection, defaults to SPACE and ENTER
+     * TODO maybe this belongs on the SelectionProps interface ?
+     */
+    selectionKeys?: string[];
+}
+export {};

package/types/vuu-ui-controls/src/common-hooks/use-resize-observer.d.ts

@@ -0,0 +1,16 @@
+import { RefObject } from "react";
+export declare const WidthHeight: string[];
+export declare const WidthOnly: string[];
+export declare const HeightOnly: string[];
+export type measurements<T = string | number> = {
+    height?: T;
+    clientHeight?: number;
+    clientWidth?: number;
+    contentHeight?: number;
+    contentWidth?: number;
+    scrollHeight?: number;
+    scrollWidth?: number;
+    width?: T;
+};
+export type ResizeHandler = (measurements: measurements<number>) => void;
+export declare function useResizeObserver(ref: RefObject<Element | HTMLElement | null>, dimensions: string[], onResize: ResizeHandler, reportInitialSize?: boolean): void;

package/types/vuu-ui-controls/src/common-hooks/useControlled.d.ts

@@ -0,0 +1,24 @@
+import { Dispatch, SetStateAction } from "react";
+export interface UseControlledProps<T> {
+    /**
+     * Holds the component value when it's controlled.
+     */
+    controlled?: T;
+    /**
+     * The default value when uncontrolled.
+     */
+    default: T;
+    /**
+     * The component name displayed in warnings.
+     */
+    name: string;
+    /**
+     * The name of the state variable displayed in warnings.
+     */
+    state?: string;
+}
+/**
+ * Copied from MUI (v5) useControlled hook with one additional returned value
+ * @see https://github.com/mui-org/material-ui/blob/0979e6a54ba47c278d1f535953c0520a86349811/packages/material-ui-utils/src/useControlled.js
+ */
+export declare function useControlled<S>({ controlled, default: defaultProp, name, state, }: UseControlledProps<S>): [S, Dispatch<SetStateAction<S>>, boolean];

package/types/vuu-ui-controls/src/context-panel-provider/ContextPanelProvider.d.ts

@@ -0,0 +1,17 @@
+import React, { ReactElement, ReactNode } from "react";
+/**
+ * If component is a string, the component will be read from the
+ * comoponent registry. In that case, componentProps can be used
+ * to pass props to the component.
+ */
+export type ShowContextPanel = (component: string | ReactElement, title: string, componentProps?: unknown) => void;
+export interface ContextPanelProps {
+    hideContextPanel?: () => void;
+    showContextPanel: ShowContextPanel;
+}
+export declare const ContextPanelContext: React.Context<ContextPanelProps>;
+export declare const ContextPanelProvider: ({ children, hideContextPanel: hideContextPanelProp, showContextPanel: showContextPanelProp, }: Partial<ContextPanelProps> & {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useContextPanel(): ShowContextPanel;
+export declare function useHideContextPanel(): (() => void) | undefined;

package/types/vuu-ui-controls/src/cycle-state-button/CycleStateButton.d.ts

@@ -0,0 +1,11 @@
+import { ButtonProps } from "@salt-ds/core";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { CommitHandler } from "@vuu-ui/vuu-utils";
+export type CycleStateButtonChangeHandler = (value: VuuRowDataItemType) => void;
+export interface CycleStateButtonProps extends Omit<ButtonProps, "onChange"> {
+    onChange?: CycleStateButtonChangeHandler;
+    onCommit?: CommitHandler<HTMLButtonElement>;
+    values: string[];
+    value: string;
+}
+export declare const CycleStateButton: import("react").ForwardRefExoticComponent<CycleStateButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/types/vuu-ui-controls/src/cycle-state-button/index.d.ts

@@ -0,0 +1 @@
+export * from "./CycleStateButton";

package/types/vuu-ui-controls/src/date-input/DateInput.d.ts

@@ -0,0 +1,60 @@
+import { type ChangeEvent, type ComponentPropsWithoutRef, type InputHTMLAttributes, type ReactNode, type RefObject, type SyntheticEvent } from "react";
+import { type DateValue } from "@internationalized/date";
+import { type RangeSelectionValueType, type SingleSelectionValueType } from "../calendar";
+export interface DateInputProps<SelectionVariantType> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange">, Pick<ComponentPropsWithoutRef<"input">, "disabled" | "placeholder"> {
+    ariaLabel?: string;
+    /**
+     * The marker to use in an empty read only DateInput.
+     * Use `''` to disable this feature. Defaults to '—'.
+     */
+    emptyReadOnlyMarker?: string;
+    /**
+     * End adornment component
+     */
+    endAdornment?: ReactNode;
+    /**
+     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dateInput#Attributes) applied to the `input` elements.
+     */
+    inputProps?: InputHTMLAttributes<HTMLInputElement>;
+    /**
+     * If `true`, the component is read only.
+     */
+    readOnly?: boolean;
+    /**
+     * Validation status.
+     */
+    validationStatus?: "error" | "warning" | "success";
+    /**
+     * Styling variant. Defaults to "primary".
+     */
+    variant?: "primary" | "secondary";
+    /**
+     * Styling variant with full border. Defaults to false
+     */
+    bordered?: boolean;
+    /**
+     * Function to format the input value.
+     */
+    dateFormatter?: (input: DateValue | undefined) => string;
+    /**
+     * Reference for the startInput;
+     */
+    startInputRef?: RefObject<HTMLInputElement | null>;
+    /**
+     * Reference for the endInput;
+     */
+    endInputRef?: RefObject<HTMLInputElement | null>;
+    /**
+     * Selection variant. Defaults to single select.
+     */
+    selectionVariant?: "default" | "range";
+    /**
+     * Callback fired when the selected date change.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate?: SelectionVariantType) => void;
+    /**
+     * Callback fired when the input value change.
+     */
+    onChange?: SelectionVariantType extends SingleSelectionValueType ? (event: ChangeEvent<HTMLInputElement>, selectedDateInputValue?: string) => void : (event: ChangeEvent<HTMLInputElement>, startDateInputValue?: string, endDateInputValue?: string) => void;
+}
+export declare const DateInput: import("react").ForwardRefExoticComponent<DateInputProps<DateValue | RangeSelectionValueType> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/date-input/index.d.ts

@@ -0,0 +1 @@
+export * from "./DateInput";

package/types/vuu-ui-controls/src/date-picker/DatePicker.d.ts

@@ -0,0 +1,66 @@
+import { type ChangeEvent, type SyntheticEvent } from "react";
+import { type DateValue } from "@internationalized/date";
+import { type CalendarProps, type RangeSelectionValueType, type SingleSelectionValueType } from "../calendar";
+import { type DateInputProps } from "../date-input";
+export interface DatePickerProps<SelectionVariantType> extends DateInputProps<SelectionVariantType> {
+    /**
+     * Selection variant. Defaults to single select.
+     */
+    selectionVariant?: "default" | "range";
+    /**
+     * If `true`, the component will be disabled.
+     */
+    disabled?: boolean;
+    /**
+     * The selected date value. Use when the component is controlled.
+     * Can be a single date or an object with start and end dates for range selection.
+     */
+    selectedDate?: SelectionVariantType;
+    /**
+     * The default date value. Use when the component is not controlled.
+     * Can be a single date or an object with start and end dates for range selection.
+     */
+    defaultSelectedDate?: SelectionVariantType;
+    /**
+     * Props to be passed to the Calendar component.
+     */
+    CalendarProps?: Partial<Omit<CalendarProps, "selectionVariant" | "selectedDate" | "defaultSelectedDate" | "onSelectedDateChange">>;
+    /**
+     * Function to format the input value.
+     */
+    dateFormatter?: (input: DateValue | undefined) => string;
+    /**
+     * Callback function triggered when open state changes.
+     */
+    onOpenChange?: (newOpen: boolean) => void;
+    /**
+     * Display or hide the component.
+     */
+    open?: boolean;
+    /**
+     * The default open value. Use when the component is not controlled.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Helper text to display in the panel
+     */
+    helperText?: string;
+    /**
+     * Validation status.
+     */
+    validationStatus?: "error" | "warning" | "success";
+    /**
+     * Callback fired when the selected date change.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate?: SelectionVariantType) => void;
+    /**
+     * Callback fired when the input value change.
+     */
+    onChange?: SelectionVariantType extends SingleSelectionValueType ? (event: ChangeEvent<HTMLInputElement>, selectedDateInputValue?: string) => void : (event: ChangeEvent<HTMLInputElement>, startDateInputValue?: string, endDateInputValue?: string) => void;
+    /**
+     * Number of Calendars to be shown if selectionVariant is range.
+     * 2 is the default value.
+     */
+    visibleMonths?: 1 | 2;
+}
+export declare const DatePicker: import("react").ForwardRefExoticComponent<DatePickerProps<DateValue | RangeSelectionValueType> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/date-picker/DatePickerContext.d.ts

@@ -0,0 +1,19 @@
+import type { DateValue } from "@internationalized/date";
+import { type UseFloatingUIReturn } from "@salt-ds/core";
+import type { RangeSelectionValueType } from "../calendar";
+export interface DatePickerContextValue<SelectionVariantType> extends Partial<Pick<UseFloatingUIReturn, "context">> {
+    openState: boolean;
+    setOpen: (newOpen: boolean) => void;
+    disabled: boolean;
+    selectedDate: SelectionVariantType | undefined;
+    defaultSelectedDate: SelectionVariantType | undefined;
+    setSelectedDate: (newStartDate: SelectionVariantType | undefined) => void;
+    startVisibleMonth: DateValue | undefined;
+    setStartVisibleMonth: (newStartDate: DateValue | undefined) => void;
+    endVisibleMonth: DateValue | undefined;
+    setEndVisibleMonth: (newStartDate: DateValue | undefined) => void;
+    selectionVariant: "default" | "range";
+    getPanelPosition: () => Record<string, unknown>;
+}
+export declare const DatePickerContext: import("react").Context<DatePickerContextValue<DateValue | RangeSelectionValueType>>;
+export declare function useDatePickerContext(): DatePickerContextValue<DateValue | RangeSelectionValueType>;