@wavv/ui 2.2.3 → 2.2.5

package/build/components/RangeCalendar.d.ts

@@ -8,6 +8,9 @@ type Props = {
     endDate?: Date;
     /** The function to be called when a date range is selected */
     onChange: (start: Date, end: Date) => void;
-} & CalendarBaseProps & Omit<RangeCalendarProps<CalendarDate>, 'onChange'>;
+    firstDayOfWeek?: RangeCalendarProps<CalendarDate>['firstDayOfWeek'];
+    className?: RangeCalendarProps<CalendarDate>['className'];
+    style?: RangeCalendarProps<CalendarDate>['style'];
+} & CalendarBaseProps & Pick<RangeCalendarProps<CalendarDate>, 'firstDayOfWeek' | 'className' | 'style'>;
 declare const RangeCalendar: ({ startDate, endDate, onChange, preventPast, preventFuture, noShadow, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default RangeCalendar;

package/build/components/Select.d.ts

@@ -1,10 +1,10 @@
-import { type SelectProps } from 'react-aria-components';
-import type { OpenStateProps, SelectInputProps, SelectItem } from './typeDefs/selectionTypes';
-type Props = SelectInputProps & OpenStateProps & {
+import type { SelectProps } from './typeDefs/reactAriaTypes';
+import type { OpenStateProps, SelectInputProps } from './typeDefs/selectionTypes';
+type Props = {
     ref?: React.Ref<HTMLButtonElement>;
-} & Omit<SelectProps<SelectItem>, 'children' | 'onSelectionChange' | 'isOpen' | 'isDisabled' | 'isInvalid' | 'isRequired' | 'defaultSelectedKey' | 'selectionMode' | 'value' | 'onChange' | 'validate'>;
+} & SelectInputProps & OpenStateProps & SelectProps;
 declare const _default: (({ backgroundColor, menuBackground, children, fontSize, fontWeight, color, disabled, invalid, required, readOnly, loading, label, options, placeholder, placeholderColor, description, errorMessage, textOnly, value, defaultValue, width, height, maxHeight, allowRepeatSelection, hideCaret, position, fixedPosition, borderRadius, iconLeft, leftElement, rightElement, before, after, open, onOpenChange, onChange, afterShow, afterHide, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element) & {
-    Item: ({ id, value, header, body, leftElement, rightElement, inline, disabled, ...props }: SelectItem & Omit<import("react-aria-components").ListBoxItemProps<object>, "id" | "value" | "isDisabled">) => import("react/jsx-runtime").JSX.Element;
+    Item: ({ id, value, header, body, leftElement, rightElement, inline, disabled, ...props }: import("..").SelectItem & Omit<import("react-aria-components").ListBoxItemProps<object>, "id" | "value" | "isDisabled">) => import("react/jsx-runtime").JSX.Element;
     Section: ({ id, title, children }: {
         id?: string;
         title?: string;

package/build/components/Slider.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { marginProps } from "./helpers/styledProps.js";
-const Slider_Slider = ({ value, max = 100, step = 1, width, height, disabled, onChange, ...props })=>{
+const Slider = ({ value, max = 100, step = 1, width, height, disabled, onChange, ...props })=>{
     const handleControlGrab = (event)=>{
         const { value: progressValue } = event.target;
         if (onChange) onChange(+progressValue);
@@ -46,5 +46,5 @@ const ProgressSlider = styled.input(({ theme, percent, width, height, disabled,
         }
     };
 }, marginProps);
-const Slider = Slider_Slider;
-export { Slider as default };
+const components_Slider = Slider;
+export { components_Slider as default };

package/build/components/Table/Body.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import { type TableLoadMoreItemProps } from 'react-aria-components';
+import { type TableBodyProps, type TableLoadMoreItemProps } from 'react-aria-components';
 type Props = {
     children?: ReactNode;
     /** The function to be called when the end of a scrolling async table has been reached */
@@ -10,7 +10,9 @@ type Props = {
     loading?: boolean;
     /** If true, shows a loading spinner at the bottom of the body */
     fetching?: boolean;
-    className?: string;
-} & Pick<TableLoadMoreItemProps, 'scrollOffset'>;
+    scrollOffset?: TableLoadMoreItemProps['scrollOffset'];
+    className?: TableBodyProps<unknown>['className'];
+    style?: TableBodyProps<unknown>['style'];
+} & Pick<TableLoadMoreItemProps, 'scrollOffset'> & Pick<TableBodyProps<unknown>, 'className' | 'style'>;
 declare const Body: ({ children, emptyFallback, fetching, loading, scrollOffset, onLoadMore, ...rest }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Body;

package/build/components/Table/Body.js

@@ -2,7 +2,7 @@ import { jsx, jsxs } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { TableBody, TableLoadMoreItem } from "react-aria-components";
 import Spinner from "../Spinner.js";
-const Body_Body = ({ children, emptyFallback, fetching, loading, scrollOffset, onLoadMore, ...rest })=>{
+const Body = ({ children, emptyFallback, fetching, loading, scrollOffset, onLoadMore, ...rest })=>{
     const emptyContent = loading ? /*#__PURE__*/ jsx(SpinnerContainer, {
         children: /*#__PURE__*/ jsx(Spinner, {})
     }) : emptyFallback;
@@ -45,5 +45,5 @@ const SpinnerContainer = styled.div(({ theme })=>({
         color: theme.scale6,
         paddingTop: 4
     }));
-const Body = Body_Body;
-export { Body as default };
+const Table_Body = Body;
+export { Table_Body as default };

package/build/components/Table/Cell.d.ts

@@ -1,6 +1,5 @@
 import { type ReactNode } from 'react';
 import { type CellProps } from 'react-aria-components';
-import type { Padding } from '../types';
 import { type ContentProps } from './contentStyles';
 type Props = {
     children?: ReactNode;
@@ -8,6 +7,10 @@ type Props = {
     defaultValue?: string;
     /** Number of lines to clamp */
     clampLines?: number;
-} & Padding & ContentProps & Omit<CellProps, 'children'>;
+    textValue?: CellProps['textValue'];
+    colSpan?: CellProps['colSpan'];
+    className?: CellProps['className'];
+    style?: CellProps['style'];
+} & ContentProps & Omit<CellProps, 'children'>;
 declare const Cell: ({ children, defaultValue, direction, justify, align, gap, clampLines, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Cell;

package/build/components/Table/Column.d.ts

@@ -1,6 +1,5 @@
 import { type MouseEvent, type ReactNode } from 'react';
 import { type ColumnProps } from 'react-aria-components';
-import type { Padding } from '../types';
 import { type ContentProps } from './contentStyles';
 import type { SortDir } from './types';
 type Props = {
@@ -12,6 +11,14 @@ type Props = {
     sorted?: SortDir;
     /** The property of the data object to sort by */
     sortKey?: string;
-} & Padding & ContentProps & Omit<ColumnProps, 'children' | 'allowsSorting'>;
+    isRowHeader?: ColumnProps['isRowHeader'];
+    textValue?: ColumnProps['textValue'];
+    width?: ColumnProps['width'];
+    minWidth?: ColumnProps['minWidth'];
+    maxWidth?: ColumnProps['maxWidth'];
+    defaultWidth?: ColumnProps['defaultWidth'];
+    className?: ColumnProps['className'];
+    style?: ColumnProps['style'];
+} & ContentProps & Omit<ColumnProps, 'children' | 'allowsSorting'>;
 declare const Column: ({ children, sortKey, sorted, onClick, resize, direction, justify, align, gap, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Column;

package/build/components/Table/ColumnSort.js

@@ -1,6 +1,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useTheme } from "@emotion/react";
-const ColumnSort_ColumnSort = ({ sortDirection })=>{
+const ColumnSort = ({ sortDirection })=>{
     const { accent, scale4 } = useTheme();
     const topColor = 'asc' === sortDirection ? accent : scale4;
     const bottomColor = 'desc' === sortDirection ? accent : scale4;
@@ -22,5 +22,5 @@ const ColumnSort_ColumnSort = ({ sortDirection })=>{
         ]
     });
 };
-const ColumnSort = ColumnSort_ColumnSort;
-export { ColumnSort as default };
+const Table_ColumnSort = ColumnSort;
+export { Table_ColumnSort as default };

package/build/components/Table/Header.js

@@ -2,11 +2,11 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { useContext, useEffect } from "react";
 import { TableHeader } from "react-aria-components";
+import Checkbox from "../Checkbox.js";
 import mergePadding from "../helpers/mergePadding.js";
-import Check from "./Check.js";
 import Column from "./Column.js";
 import context from "./context.js";
-const Header_Header = ({ children, backgroundColor, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest })=>{
+const Header = ({ children, backgroundColor, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest })=>{
     const { setHeaderPadding, selectionMode } = useContext(context);
     useEffect(()=>{
         const values = padding ?? paddingTop ?? paddingRight ?? paddingBottom ?? paddingLeft;
@@ -32,7 +32,7 @@ const Header_Header = ({ children, backgroundColor, padding, paddingTop, padding
         children: [
             /*#__PURE__*/ jsx(Column, {
                 width: 70,
-                children: 'multiple' === selectionMode && /*#__PURE__*/ jsx(Check, {
+                children: 'multiple' === selectionMode && /*#__PURE__*/ jsx(Checkbox, {
                     slot: "selection"
                 })
             }),
@@ -60,5 +60,5 @@ const TableHead = styled(TableHeader)(({ backgroundColor })=>({
             borderLeft: '2px solid transparent'
         }
     }));
-const Header = Header_Header;
-export { Header as default };
+const Table_Header = Header;
+export { Table_Header as default };

package/build/components/Table/Resizer.js

@@ -1,6 +1,6 @@
 import styled from "@emotion/styled";
 import { ColumnResizer } from "react-aria-components";
-const Resizer_Resizer = styled(ColumnResizer)(({ theme })=>({
+const Resizer = styled(ColumnResizer)(({ theme })=>({
         width: 9,
         height: 18,
         backgroundColor: theme.scale4,
@@ -21,5 +21,5 @@ const Resizer_Resizer = styled(ColumnResizer)(({ theme })=>({
             backgroundColor: theme.accent
         }
     }));
-const Resizer = Resizer_Resizer;
-export { Resizer as default };
+const Table_Resizer = Resizer;
+export { Table_Resizer as default };

package/build/components/Table/Row.js

@@ -2,9 +2,9 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { useContext, useEffect } from "react";
 import { Row } from "react-aria-components";
+import Checkbox from "../Checkbox.js";
 import mergePadding from "../helpers/mergePadding.js";
 import Cell from "./Cell.js";
-import Check from "./Check.js";
 import context from "./context.js";
 const Row_Row = ({ children, onClick, disabled, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest })=>{
     const { setRowPadding, selectionMode } = useContext(context);
@@ -31,7 +31,7 @@ const Row_Row = ({ children, onClick, disabled, padding, paddingTop, paddingRigh
     const cellsToRender = selectionMode ? /*#__PURE__*/ jsxs(Fragment, {
         children: [
             /*#__PURE__*/ jsx(Cell, {
-                children: /*#__PURE__*/ jsx(Check, {
+                children: /*#__PURE__*/ jsx(Checkbox, {
                     slot: "selection"
                 })
             }),

package/build/components/Table/Table.d.ts

@@ -9,7 +9,20 @@ type Props<T> = {
     backgroundLevel?: 0 | 1 | 2 | 3 | 4 | 5;
     /** Enabled Table.Columns to be resizable (using the `resize` prop) */
     resizable?: boolean;
-} & TableChildren<T> & MarginPadding & MaxHeight & Omit<TableProps, 'children' | 'sortDescriptor' | 'onSortChange' | 'onScroll'>;
+    disabledBehavior?: TableProps['disabledBehavior'];
+    disabledKeys?: TableProps['disabledKeys'];
+    selectionMode?: TableProps['selectionMode'];
+    selectionBehavior?: TableProps['selectionBehavior'];
+    disallowEmptySelection?: TableProps['disallowEmptySelection'];
+    escapeKeyBehavior?: TableProps['escapeKeyBehavior'];
+    selectedKeys?: TableProps['selectedKeys'];
+    defaultSelectedKeys?: TableProps['defaultSelectedKeys'];
+    shouldSelectOnPressUp?: TableProps['shouldSelectOnPressUp'];
+    className?: TableProps['className'];
+    style?: TableProps['style'];
+    onRowAction?: TableProps['onRowAction'];
+    onSelectionChange?: TableProps['onSelectionChange'];
+} & TableChildren<T> & MarginPadding & MaxHeight & Omit<TableProps, 'children' | 'sortDescriptor' | 'onSortChange' | 'onScroll' | 'dragAndDropHooks'>;
 declare const Table: {
     <DataType extends Data>({ children, data, backgroundColor, backgroundLevel, maxHeight, resizable, selectionMode, ...props }: Props<DataType>): import("react/jsx-runtime").JSX.Element;
     Header: ({ children, backgroundColor, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest }: {
@@ -23,20 +36,30 @@ declare const Table: {
         onClick?: (event: import("react").MouseEvent) => void;
         sorted?: import("./types").SortDir;
         sortKey?: string;
-    } & Padding & {
+        isRowHeader?: import("react-aria-components").ColumnProps["isRowHeader"];
+        textValue?: import("react-aria-components").ColumnProps["textValue"];
+        width?: import("react-aria-components").ColumnProps["width"];
+        minWidth?: import("react-aria-components").ColumnProps["minWidth"];
+        maxWidth?: import("react-aria-components").ColumnProps["maxWidth"];
+        defaultWidth?: import("react-aria-components").ColumnProps["defaultWidth"];
+        className?: import("react-aria-components").ColumnProps["className"];
+        style?: import("react-aria-components").ColumnProps["style"];
+    } & {
         direction?: import("../types").FlexDirection;
         justify?: import("../types").FlexPosition;
         align?: import("../types").FlexPosition;
         gap?: number | string;
-    } & Omit<import("react-aria-components").ColumnProps, "children" | "allowsSorting">) => import("react/jsx-runtime").JSX.Element;
+    } & Padding & Omit<import("react-aria-components").ColumnProps, "children" | "allowsSorting">) => import("react/jsx-runtime").JSX.Element;
     Body: ({ children, emptyFallback, fetching, loading, scrollOffset, onLoadMore, ...rest }: {
         children?: ReactNode;
         onLoadMore?: () => void;
         emptyFallback?: ReactNode;
         loading?: boolean;
         fetching?: boolean;
-        className?: string;
-    } & Pick<import("react-aria-components").TableLoadMoreItemProps, "scrollOffset">) => import("react/jsx-runtime").JSX.Element;
+        scrollOffset?: import("react-aria-components").TableLoadMoreItemProps["scrollOffset"];
+        className?: import("react-aria-components").TableBodyProps<unknown>["className"];
+        style?: import("react-aria-components").TableBodyProps<unknown>["style"];
+    } & Pick<import("react-aria-components").TableLoadMoreItemProps, "scrollOffset"> & Pick<import("react-aria-components").TableBodyProps<unknown>, "className" | "style">) => import("react/jsx-runtime").JSX.Element;
     Row: ({ children, onClick, disabled, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest }: {
         children: ReactNode;
         id?: string;
@@ -431,11 +454,15 @@ declare const Table: {
         children?: ReactNode;
         defaultValue?: string;
         clampLines?: number;
-    } & Padding & {
+        textValue?: import("react-aria-components").CellProps["textValue"];
+        colSpan?: import("react-aria-components").CellProps["colSpan"];
+        className?: import("react-aria-components").CellProps["className"];
+        style?: import("react-aria-components").CellProps["style"];
+    } & {
         direction?: import("../types").FlexDirection;
         justify?: import("../types").FlexPosition;
         align?: import("../types").FlexPosition;
         gap?: number | string;
-    } & Omit<import("react-aria-components").CellProps, "children">) => import("react/jsx-runtime").JSX.Element;
+    } & Padding & Omit<import("react-aria-components").CellProps, "children">) => import("react/jsx-runtime").JSX.Element;
 };
 export default Table;

package/build/components/Table/contentStyles.js

@@ -12,9 +12,9 @@ const baseStyles = ({ direction, justify, align = 'center', gap = 8 })=>({
         height: '100%',
         gap
     });
-const contentStyles_contentStyles = [
+const contentStyles = [
     baseStyles,
     paddingProps
 ];
-const contentStyles = contentStyles_contentStyles;
-export { contentStyles as default };
+const Table_contentStyles = contentStyles;
+export { Table_contentStyles as default };

package/build/components/Tabs.d.ts

@@ -7,7 +7,14 @@ type Props = {
     detached?: boolean;
     panelPosition?: 'top' | 'bottom';
     disabled?: boolean;
-} & Omit<TabsProps, 'children' | 'isDisabled'> & Margin & WidthHeight & MaxWidthHeight;
+    disabledKeys?: TabsProps['disabledKeys'];
+    selectedKey?: TabsProps['selectedKey'];
+    defaultSelectedKey?: TabsProps['defaultSelectedKey'];
+    keyboardActivation?: TabsProps['keyboardActivation'];
+    className?: TabsProps['className'];
+    style?: TabsProps['style'];
+    onSelectionChange?: TabsProps['onSelectionChange'];
+} & Omit<TabsProps, 'children' | 'isDisabled' | 'orientation'> & Margin & WidthHeight & MaxWidthHeight;
 declare const Tabs: {
     ({ children, detached, panelPosition, disabled, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     List: {
@@ -23,12 +30,15 @@ declare const Tabs: {
         displayName: string;
     };
 };
-type ListProps = TabListProps<any> & {
+type ListProps = {
     /** Controls whether tabs fill the container width or fit to their content */
     tabWidth?: 'fit' | 'fill';
     /** Sets the border radius for the tab items */
     borderRadius?: number;
-} & Padding;
+    children?: TabListProps<any>['children'];
+    className?: TabListProps<any>['className'];
+    style?: TabListProps<any>['style'];
+} & Omit<TabListProps<any>, 'items' | 'dependencies'> & Padding;
 export declare const List: {
     ({ tabWidth, borderRadius, padding, paddingTop, paddingBottom, paddingRight, paddingLeft, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
@@ -48,7 +58,13 @@ type ItemProps = {
     gap?: string | number;
     /** Disables the tab from being selected */
     disabled?: boolean;
-} & Omit<TabProps, 'children' | 'isDisabled' | 'id'>;
+    className?: TabProps['className'];
+    style?: TabProps['style'];
+    onPress?: TabProps['onPress'];
+    onHoverChange?: TabProps['onHoverChange'];
+    onHoverStart?: TabProps['onHoverStart'];
+    onHoverEnd?: TabProps['onHoverEnd'];
+} & Omit<TabProps, 'children' | 'isDisabled' | 'id' | 'href' | 'hrefLang' | 'rel' | 'target' | 'download' | 'ping' | 'referrerPolicy' | 'routerOptions' | 'onClick'>;
 export declare const Item: {
     ({ children, icon, iconColor, iconPosition, disabled, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
@@ -56,6 +72,10 @@ export declare const Item: {
 type PanelProps = {
     /** The unique id that matches the id of the tab */
     id: string;
+    shouldForceMount?: TabPanelProps['shouldForceMount'];
+    children?: TabPanelProps['children'];
+    className?: TabPanelProps['className'];
+    style?: TabPanelProps['style'];
 } & Omit<TabPanelProps, 'id'>;
 export declare const Panel: {
     (props: PanelProps): import("react/jsx-runtime").JSX.Element;

package/build/components/ToggleButton/ToggleButton.d.ts

@@ -24,6 +24,10 @@ type Props = {
     iconRight?: IconName;
     /** The border radius of the toggle button */
     borderRadius?: string | number;
+    isSelected?: ToggleButtonProps['isSelected'];
+    defaultSelected?: ToggleButtonProps['defaultSelected'];
+    className?: ToggleButtonProps['className'];
+    style?: ToggleButtonProps['style'];
 } & Omit<ToggleButtonProps, 'children' | 'id' | 'isDisabled'> & MarginPadding;
 declare const ToggleButton: ({ children, disabled, size, positive, negative, caution, secondary, iconLeft, iconRight, borderRadius, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default ToggleButton;

package/build/components/ToggleButton/ToggleButton.js

@@ -6,7 +6,7 @@ import { ToggleButton } from "react-aria-components";
 import getIcon from "../helpers/getIcon.js";
 import { marginProps, paddingProps } from "../helpers/styledProps.js";
 import { ToggleContext } from "./context.js";
-const ToggleButton_ToggleButton_ToggleButton = ({ children, disabled, size, positive, negative, caution, secondary, iconLeft, iconRight, borderRadius, ...props })=>{
+const ToggleButton_ToggleButton = ({ children, disabled, size, positive, negative, caution, secondary, iconLeft, iconRight, borderRadius, ...props })=>{
     const { type, joined, size: toggleSize, height } = useContext(ToggleContext);
     const { button } = useTheme();
     const { iconSize } = button[size || toggleSize];
@@ -100,5 +100,5 @@ const Button = styled(ToggleButton)(({ theme, secondary, negative, positive, cau
         } : {}
     };
 }, marginProps, paddingProps);
-const ToggleButton_ToggleButton = ToggleButton_ToggleButton_ToggleButton;
-export { ToggleButton_ToggleButton as default };
+const components_ToggleButton_ToggleButton = ToggleButton_ToggleButton;
+export { components_ToggleButton_ToggleButton as default };

package/build/components/ToggleButton/ToggleButtonGroup.d.ts

@@ -17,6 +17,14 @@ type Props = {
     joined?: boolean;
     /** The gap between the toggle buttons */
     gap?: string | number;
-} & Omit<ToggleButtonGroupProps, 'isDisabled'> & MarginPadding & WidthHeight;
+    children?: ToggleButtonGroupProps['children'];
+    selectionMode?: ToggleButtonGroupProps['selectionMode'];
+    disallowEmptySelection?: ToggleButtonGroupProps['disallowEmptySelection'];
+    selectedKeys?: ToggleButtonGroupProps['selectedKeys'];
+    defaultSelectedKeys?: ToggleButtonGroupProps['defaultSelectedKeys'];
+    className?: ToggleButtonGroupProps['className'];
+    style?: ToggleButtonGroupProps['style'];
+    onSelectionChange?: ToggleButtonGroupProps['onSelectionChange'];
+} & Omit<ToggleButtonGroupProps, 'isDisabled' | 'orientation'> & MarginPadding & WidthHeight;
 declare const ToggleButtonGroup: ({ disabled, secondary, negative, positive, caution, joined, gap, size, height, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default ToggleButtonGroup;

package/build/components/Tooltip.d.ts

@@ -2,7 +2,7 @@ import { type ReactNode } from 'react';
 import { type TooltipTriggerComponentProps } from 'react-aria-components';
 import type { Attributes } from './typeDefs/elementTypes';
 import type { Placement, ThemeProp } from './types';
-export type TooltipProps = {
+export type Props = {
     children?: ReactNode;
     /** The element that will trigger the opening of the Tooltip */
     trigger: ReactNode;
@@ -35,9 +35,12 @@ export type TooltipProps = {
     afterShow?: () => void;
     /** The function called after the Tooltip closes */
     afterHide?: () => void;
-} & Omit<TooltipTriggerComponentProps, 'children' | 'trigger' | 'isDisabled' | 'isOpen'>;
+    delay?: TooltipTriggerComponentProps['delay'];
+    closeDelay?: TooltipTriggerComponentProps['closeDelay'];
+    defaultOpen?: TooltipTriggerComponentProps['defaultOpen'];
+} & Pick<TooltipTriggerComponentProps, 'delay' | 'closeDelay' | 'defaultOpen'>;
 declare const Tooltip: {
-    ({ trigger, triggerProps, children, content, position, offset, zIndex, width, maxWidth, textAlign, open, disabled, bgColor, color, className, afterShow, afterHide, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+    ({ trigger, triggerProps, children, content, position, offset, zIndex, width, maxWidth, textAlign, open, disabled, bgColor, color, className, afterShow, afterHide, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     Header: import("@emotion/styled").StyledComponent<{
         theme?: import("@emotion/react").Theme;
         as?: React.ElementType;

package/build/components/Tree/Tree.d.ts

@@ -7,10 +7,23 @@ type Props = {
     selectedKeys?: Set<React.Key>;
     /** Handler that is called when the selection changes */
     onSelectionChange?: (keys: Set<React.Key>) => void;
-} & WidthHeight & Padding & Omit<TreeProps<object>, 'selectedKeys' | 'onSelectionChange'>;
+    expandedKeys?: TreeProps<object>['expandedKeys'];
+    defaultExpandedKeys?: TreeProps<object>['defaultExpandedKeys'];
+    renderEmptyState?: TreeProps<object>['renderEmptyState'];
+    disabledBehavior?: TreeProps<object>['disabledBehavior'];
+    escapeKeyBehavior?: TreeProps<object>['escapeKeyBehavior'];
+    autoFocus?: TreeProps<object>['autoFocus'];
+    shouldSelectOnPressUp?: TreeProps<object>['shouldSelectOnPressUp'];
+    disabledKeys?: TreeProps<object>['disabledKeys'];
+    children?: TreeProps<object>['children'];
+    className?: TreeProps<object>['className'];
+    style?: TreeProps<object>['style'];
+    onAction?: TreeProps<object>['onAction'];
+    onExpandedChange?: TreeProps<object>['onExpandedChange'];
+} & WidthHeight & Padding & Omit<TreeProps<object>, 'items' | 'selectionMode' | 'selectionBehavior' | 'selectedKeys' | 'onSelectionChange' | 'disallowEmptySelection' | 'dragAndDropHooks' | 'dependencies'>;
 declare const Tree: {
     ({ backgroundColor, expandedKeys: expandedKeysProp, onExpandedChange, defaultExpandedKeys, selectedKeys, onSelectionChange, ...props }: Props): import("react/jsx-runtime").JSX.Element;
-    Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, ...props }: {
+    Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, disabled, ...props }: {
         title: string;
         children?: import("react").ReactNode;
         content?: import("react").ReactNode;
@@ -18,6 +31,15 @@ declare const Tree: {
         iconRight?: import("../helpers/getIcon").IconType;
         expandOnSelect?: boolean;
         indent?: number;
-    } & Omit<import("react-aria-components").TreeItemProps<string>, "children" | "value" | "textValue">) => import("react/jsx-runtime").JSX.Element;
+        disabled?: boolean;
+        id?: import("react-aria-components").TreeItemProps<string>["id"];
+        className?: import("react-aria-components").TreeItemProps<string>["className"];
+        style?: import("react-aria-components").TreeItemProps<string>["style"];
+        onAction?: import("react-aria-components").TreeItemProps<string>["onAction"];
+        onPress?: import("react-aria-components").TreeItemProps<string>["onPress"];
+        onHoverStart?: import("react-aria-components").TreeItemProps<string>["onHoverStart"];
+        onHoverEnd?: import("react-aria-components").TreeItemProps<string>["onHoverEnd"];
+        onHoverChange?: import("react-aria-components").TreeItemProps<string>["onHoverChange"];
+    } & Pick<import("react-aria-components").TreeItemProps<string>, "className" | "style" | "id" | "aria-label" | "onPress" | "onPressStart" | "onPressEnd" | "onPressChange" | "onAction" | "onHoverStart" | "onHoverEnd" | "onHoverChange">) => import("react/jsx-runtime").JSX.Element;
 };
 export default Tree;

package/build/components/Tree/TreeItem.d.ts

@@ -16,6 +16,15 @@ type ItemProps = {
     expandOnSelect?: boolean;
     /** The indentation level of the item (default: 1 === 16px) */
     indent?: number;
-} & Omit<TreeItemProps<string>, 'textValue' | 'value' | 'children'>;
-declare const Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, ...props }: ItemProps) => import("react/jsx-runtime").JSX.Element;
+    disabled?: boolean;
+    id?: TreeItemProps<string>['id'];
+    className?: TreeItemProps<string>['className'];
+    style?: TreeItemProps<string>['style'];
+    onAction?: TreeItemProps<string>['onAction'];
+    onPress?: TreeItemProps<string>['onPress'];
+    onHoverStart?: TreeItemProps<string>['onHoverStart'];
+    onHoverEnd?: TreeItemProps<string>['onHoverEnd'];
+    onHoverChange?: TreeItemProps<string>['onHoverChange'];
+} & Pick<TreeItemProps<string>, 'id' | 'className' | 'style' | 'onAction' | 'onHoverStart' | 'onHoverEnd' | 'onHoverChange' | 'onPress' | 'onPressStart' | 'onPressEnd' | 'onPressChange' | 'aria-label'>;
+declare const Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, disabled, ...props }: ItemProps) => import("react/jsx-runtime").JSX.Element;
 export default Item;

package/build/components/Tree/TreeItem.js

@@ -6,12 +6,13 @@ import getIcon from "../helpers/getIcon.js";
 import Icon from "../Icon/index.js";
 import AriaButton from "../Inputs/helpers/AriaButton.js";
 import { TreeContext } from "./TreeContext.js";
-const Item = ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, ...props })=>{
+const Item = ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, disabled, ...props })=>{
     const { requestExpand } = useContext(TreeContext);
     return /*#__PURE__*/ jsxs(TreeItemContainer, {
         id: id || title,
         textValue: title,
         indent: indent,
+        isDisabled: disabled,
         ...expandOnSelect && children ? {
             onPress: ()=>{
                 requestExpand?.([

package/build/components/UnstyledButton.js

@@ -1,8 +1,8 @@
 import { jsx } from "react/jsx-runtime";
 import { Button } from "react-aria-components";
-const UnstyledButton_UnstyledButton = ({ children, ...props })=>/*#__PURE__*/ jsx(Button, {
+const UnstyledButton = ({ children, ...props })=>/*#__PURE__*/ jsx(Button, {
         ...props,
         children: children
     });
-const UnstyledButton = UnstyledButton_UnstyledButton;
-export { UnstyledButton as default };
+const components_UnstyledButton = UnstyledButton;
+export { components_UnstyledButton as default };

package/build/components/helpers/getIcon.d.ts

@@ -1,7 +1,7 @@
 import { type ReactElement } from 'react';
 import type { IconName } from '../Icon/Icon';
 import { type IconProps } from '../Icon/Icon';
-import type { TooltipProps } from '../Tooltip';
+import type { Props as TooltipProps } from '../Tooltip';
 export type IconType = IconName | IconProps | ReactElement<IconProps> | ReactElement<TooltipProps>;
 type ReducedIconProps = Omit<IconProps, 'name' | 'svg' | 'external'>;
 declare const getIcon: (icon: IconType, props?: ReducedIconProps) => ReactElement<IconProps | TooltipProps>;

package/build/components/helpers/mergePadding.js

@@ -3,7 +3,7 @@ const parseValue = (value)=>{
     if ('string' == typeof value) return Number.parseInt(value.replace('px', ''), 10);
     return 0;
 };
-const mergePadding_mergePadding = (paddingObj)=>{
+const mergePadding = (paddingObj)=>{
     const paddingValues = {
         top: 0,
         right: 0,
@@ -43,5 +43,5 @@ const mergePadding_mergePadding = (paddingObj)=>{
     if (void 0 !== paddingLeft) paddingValues.left = parseValue(paddingLeft);
     return paddingValues;
 };
-const mergePadding = mergePadding_mergePadding;
-export { mergePadding as default };
+const helpers_mergePadding = mergePadding;
+export { helpers_mergePadding as default };

package/build/components/typeDefs/inputTypes.d.ts

@@ -48,6 +48,7 @@ export type InputBaseProps = {
 export type TextInputProps = {
     /** A regex string, similar to `pattern`, but prevents input outside the pattern */
     accepts?: string;
+    asTrigger?: boolean;
 };
 export type TextAreaProps = TextInputProps & {
     /** Maximum height of the textarea. Content will scroll after this height is reached */