@ringcentral/spring-ui 1.11.2 → 1.13.0

package/src/InlineEditable/InlineEditable.type.d.ts

@@ -1,6 +1,6 @@
 import { TextareaAutosizeProps } from '@mui/base';
 import { HTMLDataAttribute, StandardProps } from '@ringcentral/spring-base';
-import { ComponentProps, ComponentPropsWithRef, FocusEvent, KeyboardEvent } from 'react';
+import { ComponentProps, ComponentPropsWithRef, FocusEvent, KeyboardEvent, ReactNode } from 'react';
 import { TooltipProps } from '../Tooltip';
 import { InlineEditableClassesKey } from './InlineEditable.classes';
 export type TextareaEditHandler<T = EditCompleteReason> = (e: KeyboardEvent<HTMLTextAreaElement> | FocusEvent<HTMLTextAreaElement>, reason: T, value: {
@@ -38,4 +38,5 @@ export type InlineEditableProps = StandardProps<(({
     fullWidth?: boolean;
     TooltipProps?: Omit<TooltipProps, 'children' | 'open' | 'onOpenStateChange'>;
     rootProps?: ComponentProps<'div'> & HTMLDataAttribute;
+    children?: ReactNode;
 }, InlineEditableClassesKey>;

package/src/ListNavigation/useListNavigation.d.ts

@@ -1,4 +1,4 @@
-import { FocusEventHandler, KeyboardEventHandler, ReactNode, Ref } from 'react';
+import { FocusEventHandler, KeyboardEventHandler, type ReactElement, ReactNode, Ref } from 'react';
 export type SearchElementOption = {
     baseElement: HTMLElement;
     direction: 'up' | 'down';
@@ -19,8 +19,8 @@ export type UseListNavigationProps = {
     actions?: Ref<UseListNavigationActions>;
 };
 export declare const useListNavigation: (props: UseListNavigationProps) => {
-    renderItems: (items: ReactNode) => import("react/jsx-runtime").JSX.Element;
-    renderTabBoundary: () => import("react/jsx-runtime").JSX.Element;
+    renderItems: (items: ReactNode) => ReactElement;
+    renderTabBoundary: () => ReactElement;
     getListProps: (otherHandler: {
         onKeyDown?: KeyboardEventHandler;
         onFocus?: FocusEventHandler;

package/src/MenuActions/MenuActions.d.ts

@@ -1,9 +1,9 @@
-import { ComponentProps } from 'react';
+import { ComponentProps, type ReactElement } from 'react';
 import { MenuActionsProps } from './MenuActions.type';
 import menuActionsStyle from './styles/MenuActions.css';
 declare const MenuActions: import("react").ForwardRefExoticComponent<Omit<MenuActionsProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
 declare const MenuActionsGroup: {
-    ({ className, ...rest }: ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...rest }: ComponentProps<'div'>): ReactElement;
     displayName: string;
 };
 export { MenuActions, MenuActionsGroup, menuActionsStyle };

package/src/MenuItem/MenuItem.type.d.ts

@@ -7,4 +7,5 @@ export type MenuItemProps = StandardProps<{
     focused?: boolean;
     autoFocus?: boolean;
     autoClose?: boolean;
+    nowrap?: boolean;
 } & Omit<UseMenuItemParameters, 'label' | 'rootRef'>, MenuItemClassesKey, 'div'>;

package/src/MenuItem/useMenuItem.d.ts

@@ -10,7 +10,7 @@ export type UseMenuItemProps = {
     autoClose?: boolean;
 };
 export declare const useMenuItem: (props: UseMenuItemProps) => {
-    getRootProps: (otherProps: any) => any;
+    getRootProps: (otherProps?: any) => any;
     focusVisible: boolean;
     active: boolean;
 };

package/src/MenuItem/useVirtualizedMenuItem.d.ts

@@ -10,7 +10,7 @@ export type UseVirtualizedMenuItemProps = {
     autoClose?: boolean;
 };
 export declare const useVirtualizedMenuItem: (props: UseVirtualizedMenuItemProps) => {
-    getRootProps: (otherProps: any) => any;
+    getRootProps: (otherProps?: any) => any;
     focusVisible: boolean;
     active: boolean;
 };

package/src/MenuList/MenuList.type.d.ts

@@ -3,7 +3,7 @@ import { StandardProps } from '@ringcentral/spring-base';
 import { MenuItemSelectProps, SelectMode } from '../MenuItem';
 import { MenuListClassesKey } from './MenuList.classes';
 import { MenuListContextValue } from './MenuListContext';
-export type MenuListProps<M extends SelectMode = 'single', V = unknown> = StandardProps<MenuItemSelectProps<V, M> & {
+export type MenuListProps<M extends SelectMode = 'single', V = unknown> = StandardProps<Omit<MenuItemSelectProps<V, M>, 'onClose'> & {
     autoFocus?: boolean;
 } & MenuListContextValue, MenuListClassesKey, 'div'>;
 export interface MenuListComponent {

package/src/MenuList/MenuListContext.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="react" />
-export type MenuListContextValue = {
-    nowrap?: boolean;
-};
+import type { MenuItemProps } from '../MenuItem/MenuItem.type';
+export type MenuListContextValue = Pick<MenuItemProps, 'nowrap'>;
 export declare const MenuListContext: import("react").Context<MenuListContextValue>;
 export declare const useMenuListContext: () => MenuListContextValue;

package/src/Modal/Modal.type.d.ts

@@ -2,6 +2,7 @@ import { PortalProps } from '../Portal';
 import { InnerModalProps, ModalCloseReason } from './InnerModal.type';
 export type ModalProps = InnerModalProps & {
     onExitComplete?: () => void;
+    onAfterClose?: () => void;
     disableBackdropAnimation?: boolean;
     disableScrollLock?: boolean;
 } & Omit<PortalProps, 'children'>;

package/src/NestedMenuContext/MenuOverlayGroupContext.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import { type ReactElement } from 'react';
 export type MenuOverlayGroupContextValue = {
     container: HTMLElement | null;
 };
@@ -11,5 +11,5 @@ export declare const useMenuOverlayGroupValue: () => {
     setContainer: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
     value: MenuOverlayGroupContextValue;
 };
-export declare const MenuOverlayGroupContainer: (props: MenuOverlayGroupContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MenuOverlayGroupContainer: (props: MenuOverlayGroupContainerProps) => ReactElement;
 export { MenuOverlayGroupContext };

package/src/Popover/Popover.classes.d.ts

@@ -1,5 +1,5 @@
 import type { CamelCase } from 'type-fest';
-export type BasePopoverClassesKey = 'root' | 'popper' | 'paper' | 'bordered' | 'shadow';
+export type BasePopoverClassesKey = 'root' | 'popper' | 'paper' | 'paper-content-no-vertical-scroll' | 'bordered' | 'shadow';
 export type PopoverClassesKey = CamelCase<BasePopoverClassesKey>;
 export type PopoverClasses = {
     name: 'popover';

package/src/Popover/Popover.internal.d.ts

@@ -0,0 +1,8 @@
+import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } from 'react';
+import { PopoverProps } from './Popover.type';
+export type InternalPopoverProps = PopoverProps & {
+    measureDesiredHeight?: () => number | void;
+    disableContentVerticalScroll?: boolean;
+    deferEnterAnimation?: boolean;
+};
+export type InternalPopoverComponent = ForwardRefExoticComponent<PropsWithoutRef<InternalPopoverProps> & RefAttributes<HTMLDivElement>>;

package/src/Popover/Popover.type.d.ts

@@ -13,6 +13,7 @@ export type PopoverProps = StandardProps<{
     shadow?: boolean;
     variant?: 'standard' | 'pointed';
     PopperProps?: Omit<PopperProps, 'anchorEl' | 'className' | 'placement' | 'actions'> & HTMLDataAttribute;
+    maxHeight?: number;
     onAvailableHeightChange?: (height: number) => void;
     PopperPaperProps?: Partial<PopperPaperProps>;
     motionProps?: MotionProps | null;

package/src/Popper/Popper.type.d.ts

@@ -3,6 +3,11 @@ import { PropsWithRoot } from '@ringcentral/spring-base';
 import { CSSProperties, ReactNode, Ref, RefObject } from 'react';
 import { PortalProps } from '../Portal';
 export type PopperPlacementType = Placement;
+export type PopperChildrenRenderProps = {
+    placement: PopperPlacementType;
+    arrowRef: RefObject<HTMLDivElement>;
+    arrowStyle: CSSProperties;
+};
 export type PopperProps = PropsWithRoot<{
     ref?: Ref<HTMLDivElement>;
     anchorEl?: ReferenceType | null | (() => ReferenceType | null);
@@ -14,18 +19,16 @@ export type PopperProps = PropsWithRoot<{
     actions?: Ref<PopperActions>;
     autoUpdate?: AutoUpdateOptions | boolean;
     matchAnchorWidth?: boolean;
-    children?: ReactNode | ((props: {
-        placement: PopperPlacementType;
-        arrowRef: RefObject<HTMLDivElement>;
-        arrowStyle: CSSProperties;
-    }) => ReactNode);
+    tether?: boolean;
+    children?: ReactNode | ((props: PopperChildrenRenderProps) => ReactNode);
 } & Omit<UseFloatingOptions, 'middleware' | 'strategy'> & Omit<PortalProps, 'children'>, 'div'>;
-export type AutoUpdateOptions = {
+export type AutoUpdateOptions = Partial<{
     ancestorScroll: boolean;
     ancestorResize: boolean;
     elementResize: boolean;
+    layoutShift: boolean;
     animationFrame: boolean;
-};
+}>;
 export type PopperActions = {
     update: () => void;
 };

package/src/Rating/utils.d.ts

@@ -1,4 +1,5 @@
+import type { ReactElement } from 'react';
 export declare function roundValueToPrecision<T extends number | null = number>(value: T, precision: number): number | T;
-export declare const defaultIcon: import("react/jsx-runtime").JSX.Element;
-export declare const defaultEmptyIcon: import("react/jsx-runtime").JSX.Element;
+export declare const defaultIcon: ReactElement;
+export declare const defaultEmptyIcon: ReactElement;
 export declare function defaultLabelText(value: number | null): string;

package/src/Select/Select.type.d.ts

@@ -6,29 +6,31 @@ import type { VirtualizedMenuProps } from '../VirtualizedMenu';
 import type { SelectMode } from '../MenuItem';
 import type { SelectClassesKey } from './Select.classes';
 export type SelectVariant = UnionOmit<FormFieldVariant, 'quiet'>;
+type SelectDataItem<T> = NonNullable<T> extends unknown[] ? NonNullable<T>[number] : NonNullable<T>;
 export type SelectProps<T = unknown> = StandardProps<{
     variant?: SelectVariant;
     selectMode?: SelectMode;
     defaultValue?: T;
     value?: T;
-    onChange?: (e: React.ChangeEvent<HTMLInputElement>, child: React.ReactNode) => void;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>, input?: HTMLInputElement | null) => void;
     placeholder?: ReactNode;
     renderValue?: (value: T) => ReactNode;
     displayEmpty?: boolean;
     open?: boolean;
     defaultOpen?: boolean;
     virtualize?: boolean;
-    data?: T extends unknown[] ? T : T[];
+    data?: SelectDataItem<T>[];
     getSelectedIndex?: (value: T) => number;
     onOpen?: () => void;
     onClose?: () => void;
     selectorProps?: SlotProps<'button'>;
     MenuProps?: Omit<MenuProps, 'open' | 'anchorEl' | 'onClose' | 'children'> & HTMLDataAttribute;
-    VirtualizedMenuProps?: Omit<VirtualizedMenuProps, 'open' | 'onClose' | 'children'> & HTMLDataAttribute;
+    VirtualizedMenuProps?: Omit<VirtualizedMenuProps<SelectDataItem<T>>, 'open' | 'onClose' | 'children'> & HTMLDataAttribute;
     inputProps?: InputHTMLAttributes<HTMLInputElement>;
-    children?: FormFieldProps['children'] | VirtualizedMenuProps['children'];
+    children?: FormFieldProps['children'] | VirtualizedMenuProps<SelectDataItem<T>>['children'];
 } & Omit<FormFieldProps, 'onChange' | 'classes' | 'variant' | 'children'> & Pick<InputHTMLAttributes<HTMLInputElement>, 'name'>, SelectClassesKey, 'div'>;
 export interface SelectComponent {
-    <V = unknown>(props: SelectProps<V>): ReactElement;
+    <T = unknown>(props: SelectProps<T>): ReactElement;
     displayName?: string;
 }
+export {};

package/src/Slider/Slider.d.ts

@@ -1,7 +1,7 @@
-import { ForwardedRef, PropsWithoutRef } from 'react';
+import { ForwardedRef, PropsWithoutRef, type ReactElement } from 'react';
 import { SliderProps } from './Slider.type';
 import sliderStyle from './styles/Slider.css';
-declare const InnerSlider: <V extends number | number[] = number>(inProps: PropsWithoutRef<SliderProps<V>>, ref: ForwardedRef<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;
+declare const InnerSlider: <V extends number | number[] = number>(inProps: PropsWithoutRef<SliderProps<V>>, ref: ForwardedRef<HTMLSpanElement>) => ReactElement;
 declare const Slider: (<V extends number | number[] = number>(props: PropsWithoutRef<SliderProps<V>> & {
     ref?: ForwardedRef<HTMLSpanElement>;
 }) => ReturnType<typeof InnerSlider>) & {

package/src/Slider/SliderThumb.d.ts

@@ -1,3 +1,4 @@
+import type { ReactElement } from 'react';
 import { Transition } from 'framer-motion';
 import { UseSliderReturnValue } from '@mui/base';
 import { SliderProps } from './Slider.type';
@@ -9,7 +10,7 @@ type SliderThumbProps = Pick<SliderProps, 'classes' | 'valueLabelDisplay' | 'val
     dragging: boolean;
 };
 declare const SliderThumb: {
-    (props: SliderThumbProps): import("react/jsx-runtime").JSX.Element;
+    (props: SliderThumbProps): ReactElement;
     displayName: string;
 };
 export { SliderThumb };

package/src/Squircle/Squircle.d.ts

@@ -1,4 +1,4 @@
 import { SquircleComponent } from './Squircle.type';
-import squircleStyle from './styles/squircle.css';
+import squircleStyle from './styles/Squircle.css';
 export declare const Squircle: SquircleComponent;
 export { squircleStyle };

package/src/StatusIndicator/StatusIndicator.d.ts

@@ -1,7 +1,8 @@
+import type { ReactElement } from 'react';
 import { StatusIndicatorProps } from './StatusIndicator.type';
 import statusIndicatorStyle from './styles/StatusIndicator.css';
 export declare const StatusIndicator: {
-    (inProps: StatusIndicatorProps): import("react/jsx-runtime").JSX.Element;
+    (inProps: StatusIndicatorProps): ReactElement;
     displayName: string;
 };
 export { statusIndicatorStyle };

package/src/SubMenu/PopperMenu.type.d.ts

@@ -1,4 +1,7 @@
 import { StandardProps } from '@ringcentral/spring-base';
+import { ReactNode } from 'react';
 import { Popper } from '../Popper';
 import { PopperMenuClassesKey } from './PopperMenu.classes';
-export type PopperMenuProps = StandardProps<{}, PopperMenuClassesKey, typeof Popper>;
+export type PopperMenuProps = StandardProps<{
+    children?: ReactNode;
+}, PopperMenuClassesKey, typeof Popper>;

package/src/Table/Table.type.d.ts

@@ -1,6 +1,7 @@
 import { OverridableComponent, OverridableProps, WithClassesProps } from '@ringcentral/spring-base';
 import { ElementType, ReactNode } from 'react';
 import { TableClassesKey } from './Table.classes';
+export type TableSize = 'small' | 'medium' | 'large';
 type DefaultElementType = 'table';
 type ExtendElementType = ElementType;
 type BaseTableProps = WithClassesProps<{
@@ -8,6 +9,8 @@ type BaseTableProps = WithClassesProps<{
     stickyHeader?: boolean;
     stickyFooter?: boolean;
     columnDivider?: boolean;
+    rowDivider?: boolean;
+    size?: TableSize;
 }, TableClassesKey>;
 export type TableProps<T extends ExtendElementType = DefaultElementType> = OverridableProps<BaseTableProps, T>;
 export type TableComponent = OverridableComponent<{

package/src/Table/TableContext.d.ts

@@ -1,8 +1,11 @@
 /// <reference types="react" />
+import { TableSize } from './Table.type';
 export type TableContextValue = {
     stickyHeader?: boolean;
     stickyFooter?: boolean;
     columnDivider?: boolean;
+    rowDivider?: boolean;
+    size?: TableSize;
 };
 export declare const TableContext: import("react").Context<TableContextValue>;
 export declare const useTableContext: () => TableContextValue;

package/src/Table/TableRowContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { TableSize } from './Table.type';
+export type TableRowContextValue = {
+    size?: TableSize;
+};
+export declare const TableRowContext: import("react").Context<TableRowContextValue>;
+export declare const useTableRowContext: () => TableRowContextValue;

package/src/Table/index.d.ts

@@ -3,3 +3,4 @@ export * from './Table';
 export * from './Table.type';
 export * from './TableContext';
 export * from './Tablelvl2Context';
+export * from './TableRowContext';

package/src/TableCell/TableCell.classes.d.ts

@@ -1,5 +1,5 @@
 import type { CamelCase } from 'type-fest';
-export type BaseTableCellClassesKey = 'root' | 'head' | 'body' | 'sortable' | 'sorted' | 'footer' | 'padding-checkbox' | 'padding-none' | 'align-left' | 'align-center' | 'align-right' | 'align-justify' | 'sticky-header-default-bg' | 'content' | 'content-padding-checkbox' | 'content-align-right' | 'content-align-center' | 'content-align-justify' | 'content-sortable' | 'sort-icon' | 'sort-icon-sorted' | 'sort-indicator' | 'column-divider';
+export type BaseTableCellClassesKey = 'root' | 'head' | 'body' | 'sortable' | 'sorted' | 'footer' | 'small' | 'large' | 'padding-checkbox' | 'padding-none' | 'align-left' | 'align-center' | 'align-right' | 'align-justify' | 'sticky-header-default-bg' | 'content' | 'content-padding-checkbox' | 'content-align-right' | 'content-align-center' | 'content-align-justify' | 'content-sortable' | 'sort-icon' | 'sort-icon-sorted' | 'sort-indicator' | 'column-divider' | 'hide-row-divider';
 export type TableCellClassesKey = CamelCase<BaseTableCellClassesKey>;
 export type TableCellClasses = {
     name: 'table-cell';

package/src/TableFooter/TableFooter.classes.d.ts

@@ -1,5 +1,5 @@
 import { CamelCase } from 'type-fest';
-type BaseTableFooterClassesKey = 'root' | 'content' | 'padding-checkbox' | 'padding-none' | 'sticky';
+type BaseTableFooterClassesKey = 'root' | 'content' | 'padding-checkbox' | 'padding-none' | 'sticky' | 'hide-divider';
 export type TableFooterClassesKey = CamelCase<BaseTableFooterClassesKey>;
 export type TableFooterClasses = {
     name: 'table-footer';

package/src/TableFooter/TableFooter.type.d.ts

@@ -3,4 +3,5 @@ import { TdHTMLAttributes } from 'react';
 import { TableFooterClassesKey } from './TableFooter.classes';
 export type TableFooterProps = StandardProps<{
     padding?: 'normal' | 'checkbox' | 'none';
+    divider?: boolean;
 } & Pick<TdHTMLAttributes<HTMLTableCellElement>, 'colSpan'>, TableFooterClassesKey, 'tfoot'>;

package/src/TableHead/TableHead.classes.d.ts

@@ -1,5 +1,5 @@
 import type { CamelCase } from 'type-fest';
-export type BaseTableHeadClassesKey = 'root' | 'background' | 'title' | 'end-slot' | 'sticky' | 'divider';
+export type BaseTableHeadClassesKey = 'root' | 'background' | 'title' | 'end-slot' | 'sticky' | 'hide-divider';
 export type TableHeadClassesKey = CamelCase<BaseTableHeadClassesKey>;
 export type TableHeadClasses = {
     name: 'table-head';

package/src/TableHead/TableHead.type.d.ts

@@ -6,6 +6,7 @@ type ExtendElementType = ElementType;
 type BaseTableHeadProps = WithClassesProps<{
     children?: React.ReactNode;
     useDefaultBgColor?: boolean;
+    divider?: boolean;
 }, TableHeadClassesKey>;
 export type TableHeadProps<T extends ExtendElementType = DefaultElementType> = OverridableProps<BaseTableHeadProps, T>;
 export type TableHeadComponent = OverridableComponent<{

package/src/TableRow/TableRow.type.d.ts

@@ -1,5 +1,6 @@
 import { WithClassesProps, OverridableComponent, OverridableProps } from '@ringcentral/spring-base';
 import { ElementType } from 'react';
+import { TableSize } from '../Table/Table.type';
 import { TableRowClassesKey } from './TableRow.classes';
 type DefaultElementType = 'tr';
 type ExtendElementType = ElementType;
@@ -8,6 +9,7 @@ type BaseTableRowProps = WithClassesProps<{
     hoverable?: boolean;
     clickable?: boolean;
     selected?: boolean;
+    size?: TableSize;
 }, TableRowClassesKey>;
 export type TableRowProps<T extends ExtendElementType = DefaultElementType> = OverridableProps<BaseTableRowProps, T>;
 export type TableRowComponent = OverridableComponent<{

package/chunks/AccordionContext.js

@@ -1,6 +0,0 @@
-import { createContext, useContext } from 'react';
-
-const AccordionContext = createContext({});
-const useAccordionContext = () => useContext(AccordionContext);
-
-export { AccordionContext as A, useAccordionContext as u };

package/chunks/Alert.js

@@ -1,48 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { forwardRef, useMemo, isValidElement } from 'react';
-import { Xmd, InfoMd, AlertMd, SuccessMd } from '@ringcentral/spring-icon';
-import { useThemeProps, useClassesWithMode, useMode } from '@ringcentral/spring-theme';
-import clsx from 'clsx';
-import { I as Icon } from './Icon.js';
-import { I as IconButton } from './IconButtonLabel.js';
-
-const DEFAULT_ICON_MAP = {
-    info: InfoMd,
-    error: AlertMd,
-    success: SuccessMd,
-    warning: AlertMd,
-    neutral: InfoMd,
-};
-const Alert = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'Alert' });
-    const { action, classes, className, component: AlertRoot = 'div', closeText = 'close', children, icon: iconProp, startSlot, onClose, severity = 'info', CloseButtonProps, ...rest } = props;
-    const cls = useClassesWithMode('alert', classes, className);
-    const { mode } = useMode();
-    const iconSize = useMemo(() => (mode === 'compact' ? 'small' : 'medium'), [mode]);
-    const renderIcon = (icon, severity) => {
-        return (jsx("div", { className: cls('icon', `${severity}-icon`), children: isValidElement(icon) ? (icon) : (jsx(Icon, { size: iconSize, symbol: icon })) }));
-    };
-    let startSlotContent = null;
-    if (startSlot) {
-        startSlotContent = renderIcon(startSlot, severity);
-    }
-    else if (iconProp) {
-        const iconComponent = iconProp === true ? DEFAULT_ICON_MAP[severity] : iconProp;
-        startSlotContent = renderIcon(iconComponent, severity);
-    }
-    let closeSlot = null;
-    if (onClose) {
-        closeSlot = (jsx(IconButton, { symbol: Xmd, variant: "icon", shape: 'squircle', color: 'secondary', size: iconSize, background: false, title: closeText, "aria-label": closeText, onClick: onClose, ...CloseButtonProps, className: clsx(cls('close'), CloseButtonProps?.className) }));
-    }
-    let actionSlot = null;
-    if (action) {
-        actionSlot = jsx("div", { className: cls('action'), children: action });
-    }
-    return (jsxs(AlertRoot, { ...rest, ref: ref, className: cls('root', severity), children: [startSlotContent, jsxs("div", { className: cls('body'), children: [jsx("div", { className: cls('content'), role: "alert", children: children }), actionSlot] }), closeSlot] }));
-});
-const AlertTitle = ({ className, classes, ...rest }) => {
-    const cls = useClassesWithMode('alert-title', classes, className);
-    return jsx("div", { className: cls('root'), ...rest });
-};
-
-export { AlertTitle as A, Alert as a };

package/chunks/AvatarGroup.js

@@ -1,22 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { createContext, forwardRef, Children } from 'react';
-import { useClasses, logInDev } from '@ringcentral/spring-base';
-import { useThemeProps } from '@ringcentral/spring-theme';
-
-const AvatarGroupContext = createContext({});
-const AvatarGroup = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'AvatarGroup' });
-    const { component: AvatarGroupRoot = 'div', classes, className, children, ...rest } = props;
-    const cls = useClasses('avatar-group', classes, className);
-    const childrenLength = Children.toArray(children).filter(Boolean).length;
-    if (process.env.NODE_ENV !== 'production' && childrenLength !== 2) {
-        logInDev({
-            scope: 'AvatarGroup',
-            message: 'AvatarGroup only accept 2 valid child components as its children',
-        });
-    }
-    return (jsx(AvatarGroupContext.Provider, { value: { size: 'small', className: cls('item') }, children: jsx(AvatarGroupRoot, { className: cls('root'), ...rest, ref: ref, children: children }) }));
-});
-AvatarGroup.displayName = 'SuiAvatarGroup';
-
-export { AvatarGroupContext as A, AvatarGroup as a };

package/chunks/Backdrop.js

@@ -1,18 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { forwardRef } from 'react';
-import { useClasses } from '@ringcentral/spring-base';
-import { useThemeProps } from '@ringcentral/spring-theme';
-
-const Backdrop = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'Backdrop' });
-    const { classes, className, children, isTransparent = false, onClick, ...rest } = props;
-    const cls = useClasses('backdrop', classes, className);
-    const handleClick = (e) => {
-        e.stopPropagation();
-        onClick?.(e);
-    };
-    return (jsx("div", { className: cls('root', { transparent: isTransparent }), "aria-hidden": true, tabIndex: -1, ...rest, ref: ref, onClick: handleClick, children: children }));
-});
-Backdrop.displayName = 'SuiBackdrop';
-
-export { Backdrop as B };

package/chunks/Badge.js

@@ -1,32 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useMemo } from 'react';
-import { AnimatePresence, motion } from 'framer-motion';
-import isNumber from 'lodash/isNumber';
-import kebabCase from 'lodash/kebabCase';
-import { useClasses } from '@ringcentral/spring-base';
-import { useThemeProps, motionTransition } from '@ringcentral/spring-theme';
-import './Icon.js';
-import { u as useMotionSafeTransition } from './useMotionSafeTransition.js';
-
-const Badge = (inProps) => {
-    const props = useThemeProps({ props: inProps, name: 'Badge' });
-    const { count, classes, showZero, className, invisible, forceOverlap, type = 'standard', max = 999, size = 'small', color = 'primary', variant = 'contained', children, anchorOrigin = 'topRight', overlap = 'rectangular', ...rest } = props;
-    const cls = useClasses('badge', classes, className);
-    const transition = useMotionSafeTransition(motionTransition['haste-01-fast']);
-    const numeric = isNumber(count);
-    const content = type === 'standard'
-        ? numeric && count > max
-            ? `${max}+`
-            : count
-        : undefined;
-    const toOrigin = useMemo(() => kebabCase(anchorOrigin), [anchorOrigin]);
-    const overlapMode = children || forceOverlap;
-    return (jsxs("span", { className: cls('root', {
-            absolute: !children && forceOverlap,
-        }), ...rest, children: [children, jsx(AnimatePresence, { initial: false, children: invisible ||
-                    (!showZero && count === 0) ||
-                    (content === undefined && type === 'standard') ? null : (jsx(motion.span, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, transition: transition, className: cls('content', color, size, type, variant, toOrigin, `${type}-${size}`, `${type}-${color}`, `${type}-${variant}`, `${type}-${variant}-${size}`, overlapMode && overlap, overlapMode && `${overlap}-${toOrigin}`), children: content })) })] }));
-};
-Badge.displayName = 'SuiBadge';
-
-export { Badge as B };

package/chunks/BottomNavigationItem.js

@@ -1,36 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { createContext, useContext, forwardRef } from 'react';
-import { useClasses, combineClasses } from '@ringcentral/spring-base';
-import { useThemeProps } from '@ringcentral/spring-theme';
-import { B as Badge } from './Badge.js';
-import { I as IconButton } from './IconButtonLabel.js';
-import { T as Tooltip } from './Tooltip.js';
-import { u as useTooltipForceHide } from './useTooltipForceHide.js';
-
-const BottomNavigationContext = createContext(null);
-const useBottomNavigationContext = () => useContext(BottomNavigationContext);
-
-const BottomNavigationItem = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'BottomNavigationItem' });
-    const { classes, symbol, activatedSymbol, count, value: valueProp, activated: activatedProp, expanded: expandedProp, onClick, BadgeProps = {}, TooltipProps = {}, ButtonProps = {}, label, className, } = props;
-    const cls = useClasses('bottom-navigation-item', classes, className);
-    const { value: selectedValue, expanded: isExpanded, onSelected, animationComplete, } = useBottomNavigationContext() || {};
-    const tooltipOpenProps = useTooltipForceHide(animationComplete === false);
-    const selected = selectedValue === valueProp;
-    const activated = activatedProp !== undefined ? activatedProp : selected;
-    const expanded = expandedProp !== undefined ? expandedProp : isExpanded;
-    const handleClick = (event) => {
-        if (valueProp !== undefined && !selected) {
-            onSelected?.(event, valueProp);
-        }
-        onClick?.(event);
-    };
-    let buttonClasses = { root: cls('button', { activated, expanded }) };
-    if (ButtonProps.classes) {
-        buttonClasses = combineClasses(buttonClasses, ButtonProps.classes);
-    }
-    return (jsx(Badge, { variant: "outlined", count: count, className: cls('root'), ...BadgeProps, children: jsx(Tooltip, { ...TooltipProps, title: label, PopperProps: { offset: 8 }, motionProps: null, ...tooltipOpenProps, children: jsx(IconButton, { shape: 'squircle', variant: "contained", size: "small", color: 'secondary', symbol: activated && activatedSymbol ? activatedSymbol : symbol, onClick: handleClick, "aria-label": label, ...ButtonProps, classes: buttonClasses, ref: ref }) }) }));
-});
-BottomNavigationItem.displayName = 'SuiBottomNavigationItem';
-
-export { BottomNavigationItem as B, BottomNavigationContext as a, useBottomNavigationContext as u };