@ringcentral/spring-ui 1.7.0 → 1.8.0

package/src/ListItem/ListItem.type.d.ts

@@ -4,55 +4,14 @@ import { ListItemClassesKey } from './ListItem.classes';
 export declare type ListItemProps = StandardProps<{
     hoverActions?: ReactNode;
     size?: 'small' | 'large' | 'auto';
-    /**
-     * If true, show listItem divider
-     * @default true
-     */
     divider?: boolean;
-    /**
-     * If true, show dragged style
-     * @default false
-     */
     dragged?: boolean;
-    /**
-     * If true, show selected style
-     * @default false
-     */
     selected?: boolean;
-    /**
-     * If true, shows the focused state of the item by default.
-     * @default undefined
-     */
     focused?: boolean;
-    /**
-     * Auto focus item when mounted.
-     */
     autoFocus?: boolean;
-    /**
-     * If false, no style about `active`.
-     *
-     * If unset and no click handler, it will be false.
-     */
     clickable?: boolean;
-    /**
-     * If false, no style about `active`
-     * @default true
-     */
     hoverable?: boolean;
-    /**
-     * If true, shows the hover state of the item by default.
-     * @default undefined
-     */
     highlighted?: boolean;
-    /**
-     * If true, hover actions will always show
-     * @default false
-     */
     alwaysShowHoverActions?: boolean;
-    /**
-     * If true, the transition of the hover actions will show instantly.
-     * If false or unset, it will use the default transition.
-     * @default false
-     */
     instantHoverActions?: boolean;
 }, ListItemClassesKey, 'div'>;

package/src/ListItemText/ListItemText.type.d.ts

@@ -3,31 +3,10 @@ import { ReactNode } from 'react';
 import { ListItemTextClassesKey } from './ListItemText.classes';
 export declare type ListItemTextVariant = 'primary' | 'secondary';
 export declare type ListItemTextProps = StandardProps<{
-    /**
-     * The primary content element. This is used in the same way as the `children` prop.
-     * @deprecated Use the `primary` prop instead.
-     */
     primaryText?: ReactNode;
-    /**
-     * The primary content element. This is used in the same way as the `children` prop.
-     */
     primary?: ReactNode;
-    /**
-     * The primary content element. This is used in the same way as the `primary` prop.
-     */
     children?: ReactNode;
-    /**
-     * The secondary content element.
-     * @deprecated Use the `secondary` prop instead.
-     */
     secondaryText?: ReactNode;
-    /**
-     * The secondary content element.
-     */
     secondary?: ReactNode;
-    /**
-     * The variant of the component. When the variant is `secondary`, only the `primary` prop is supported.
-     * @default primary
-     */
     variant?: ListItemTextVariant;
 }, ListItemTextClassesKey, 'div'>;

package/src/ListNavigation/useListNavigation.d.ts

@@ -11,26 +11,10 @@ export declare type SearchAndFocusItemHandler = (searchElementOption: SearchElem
     isAfterBaseElement?: boolean;
 };
 export declare type UseListNavigationActions = {
-    /**
-     * Focus to first focusable item. If no focusable item, will focus to list.
-     *
-     * Invoking native focus function of list element can also focus first focusable item,
-     * but it's relatedTarget of focus event will be list element.
-     */
     focus: () => void;
 };
 export declare type UseListNavigationProps = {
-    /**
-     * If true, will prevent list container scroll when move focus via press
-     * ArrowDown or ArrowUp.
-     *
-     * @default true
-     */
     preventContainerScroll?: boolean;
-    /**
-     * Custom focus item logic. It is useful for virtual list.
-     * Because virtual list will not render full dom element.
-     */
     searchAndFocusItemHandler?: SearchAndFocusItemHandler;
     actions?: Ref<UseListNavigationActions>;
 };

package/src/Menu/Menu.type.d.ts

@@ -3,17 +3,7 @@ import { SyntheticEvent } from 'react';
 import { Popover, PopoverCloseReason } from '../Popover';
 import { MenuClassesKey } from './Menu.classes';
 export declare type MenuProps = StandardProps<{
-    /**
-     * Triggered when focus leaves the menu and the menu should close.
-     */
     onClose?: (event: SyntheticEvent<HTMLElement> | undefined, reason: PopoverCloseReason | 'Other') => void;
-    /**
-     * Controls whether the menu is displayed.
-     */
     open: boolean;
-    /**
-     * If true, auto focus to menu list
-     * @default true
-     */
     autoFocus?: boolean;
 }, MenuClassesKey, typeof Popover>;

package/src/MenuFooter/MenuFooter.type.d.ts

@@ -1,9 +1,5 @@
 import { StandardProps } from '@ringcentral/spring-base';
 import { MenuFooterClassesKey } from './MenuFooter.classes';
 export declare type MenuFooterProps = StandardProps<{
-    /**
-     * If true, show divider
-     * @default true
-     */
     divider?: boolean;
 }, MenuFooterClassesKey, 'div'>;

package/src/MenuHeader/MenuHeader.type.d.ts

@@ -2,17 +2,7 @@ import { StandardProps } from '@ringcentral/spring-base';
 import { ReactNode } from 'react';
 import { MenuHeaderClassesKey } from './MenuHeader.classes';
 export declare type MenuHeaderProps = StandardProps<{
-    /**
-     * Start slot for putting an IconButton
-     */
     start?: ReactNode;
-    /**
-     * End slot for putting a IconButton
-     */
     end?: ReactNode;
-    /**
-     * If true, show divider
-     * @default true
-     */
     divider?: boolean;
 }, MenuHeaderClassesKey, 'div'>;

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

@@ -2,28 +2,9 @@ import { UseMenuItemParameters } from '@mui/base';
 import { StandardProps } from '@ringcentral/spring-base';
 import { MenuItemClassesKey } from './MenuItem.classes';
 export declare type MenuItemProps = StandardProps<{
-    /**
-     * If not undefined, apply selectable styling.
-     * @default undefined
-     */
     selected?: boolean;
-    /**
-     * If not undefined, shows the hover state of the item by default.
-     * @default undefined
-     */
     highlighted?: boolean;
-    /**
-     * If not undefined, shows the focused state of the item by default.
-     * @default undefined
-     */
     focused?: boolean;
-    /**
-     * Auto focus item when mounted.
-     */
     autoFocus?: boolean;
-    /**
-     * Auto close menu after click item.
-     * @default true
-     */
     autoClose?: boolean;
 } & Omit<UseMenuItemParameters, 'label' | 'rootRef'>, MenuItemClassesKey, 'div'>;

package/src/MenuItem/MenuItemSelectContext.d.ts

@@ -1,8 +1,5 @@
 /// <reference types="react" />
 export declare type MenuItemSelectContextValue<T> = {
-    /**
-     * @default 'single'
-     */
     selectMode: 'single' | 'multiple';
     value: T;
     handleSelect: (itemValue: T) => void;

package/src/MenuItem/useMenuItemSelect.d.ts

@@ -10,32 +10,11 @@ declare type MultipleModeOnChange<T> = (value: T[], operation: {
 declare type SingleModeOnChange<T> = (value: T) => void;
 export declare type MenuItemSelectProps<T = unknown, M extends SelectMode = 'single'> = UseMenuItemSelectParameters<T, M>;
 export declare type UseMenuItemSelectParameters<T = unknown, S extends SelectMode = 'single'> = {
-    /**
-     * @default 'menu'
-     */
     widget?: 'menu' | 'select';
-    /**
-     * The select mode of the menu items.
-     * @default 'single'
-     */
     selectMode?: 'single' | 'multiple';
-    /**
-     * The selected value.
-     */
     value?: S extends 'multiple' ? T[] : T;
-    /**
-     * Callback fired when an option is selected.
-     */
     onChange?: S extends 'multiple' ? MultipleModeOnChange<T> : SingleModeOnChange<T>;
-    /**
-     * If true, auto focus to selected item when mounted
-     * @default true
-     */
     autoFocus?: boolean;
-    /**
-     * Callback fired when the menu should be closed.
-     * Fired when an already selected item is selected again in single select mode.
-     */
     onClose?: () => void;
 };
 export declare const useMenuItemSelect: <T = unknown, S extends SelectMode = "single">(props: UseMenuItemSelectParameters<T, S>) => {

package/src/MenuItemText/MenuItemText.type.d.ts

@@ -2,26 +2,9 @@ import { StandardProps } from '@ringcentral/spring-base';
 import { ReactNode } from 'react';
 import { MenuItemTextClassesKey } from './MenuItemText.classes';
 export declare type MenuItemTextProps = StandardProps<{
-    /**
-     * The primary content element. This is used in the same way as the `children` prop.
-     * @deprecated Use the `primary` prop instead.
-     */
     primaryText?: ReactNode;
-    /**
-     * The primary content element. This is used in the same way as the `children` prop.
-     */
     primary?: ReactNode;
-    /**
-     * The primary content element. This is used in the same way as the `primary` prop.
-     */
     children?: ReactNode;
-    /**
-     * The info text element.
-     * @deprecated Use the `info` prop instead.
-     */
     infoText?: ReactNode;
-    /**
-     * The info text element.
-     */
     info?: ReactNode;
 }, MenuItemTextClassesKey, 'div'>;

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

@@ -4,10 +4,6 @@ import { MenuItemSelectProps, SelectMode } from '../MenuItem';
 import { MenuListClassesKey } from './MenuList.classes';
 import { MenuListContextValue } from './MenuListContext';
 export declare type MenuListProps<M extends SelectMode = 'single', V = unknown> = StandardProps<MenuItemSelectProps<V, M> & {
-    /**
-     * auto focus when component mounted
-     * @default true
-     */
     autoFocus?: boolean;
 } & MenuListContextValue, MenuListClassesKey, 'div'>;
 export interface MenuListComponent {

package/src/MenuList/MenuListContext.d.ts

@@ -1,11 +1,5 @@
 /// <reference types="react" />
 export declare type MenuListContextValue = {
-    /**
-     * When primary text of menu item is longer than one line,
-     * if nowrap is true, text will be truncated,
-     * if false, text will wrap into multiple lines.
-     * @default true
-     */
     nowrap?: boolean;
 };
 export declare const MenuListContext: import("react").Context<MenuListContextValue>;

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

@@ -14,10 +14,5 @@ export declare type InnerModalProps = StandardProps<{
     onEscapeKeyDown?: KeyboardEventHandler<HTMLDivElement>;
     onClose?: (event: SyntheticEvent<HTMLElement>, reason: ModalCloseReason) => void;
     backdropProps?: BackdropProps;
-    /**
-     * If true, the modal will block interaction with the rest of the page.
-     * When false, aria-hidden and focus trapping are disabled.
-     * @default true
-     */
     blocking?: boolean;
 } & GroupedMotionProps & Pick<FocusTrapProps, 'disableRestoreFocus' | 'disableAutoFocus' | 'disableEnforceFocus' | 'isEnabled'>, ModalClassesKey, 'div'>;

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

@@ -1,19 +1,8 @@
 import { PortalProps } from '../Portal';
 import { InnerModalProps, ModalCloseReason } from './InnerModal.type';
 export declare type ModalProps = InnerModalProps & {
-    /**
-     * Called when the modal's exit animation has finished playing
-     */
     onExitComplete?: () => void;
     disableBackdropAnimation?: boolean;
-    /**
-     * If true, the modal will not lock body scrolling
-     *
-     * Popover overrides this to `true` to avoid scroll lock conflicts
-     * with parent modals. If you’re using Popover as a dialog-like
-     * component and want to re-enable scroll lock, pass `disableScrollLock={false}`.
-     * @default false
-     */
     disableScrollLock?: boolean;
 } & Omit<PortalProps, 'children'>;
 export type { ModalCloseReason };

package/src/Modal/ModalContext.d.ts

@@ -1,9 +1,5 @@
 /// <reference types="react" />
 export declare type ModalContextValue = {
-    /**
-     * Indicates whether the `aria-hidden` attribute is being applied to elements outside the modal.
-     * When true, Popper-based components should disable portal to avoid being hidden from screen readers.
-     */
     ariaHideEnabled: boolean;
 };
 export declare const ModalContext: import("react").Context<ModalContextValue | null>;

package/src/Option/Option.type.d.ts

@@ -1,7 +1,4 @@
 import { MenuItemProps } from '../MenuItem';
 export declare type OptionProps = {
-    /**
-     * Value of select option
-     */
     value: any;
 } & Omit<MenuItemProps, 'value' | 'selected'>;

package/src/Overlap/Overlap.type.d.ts

@@ -7,19 +7,8 @@ export declare type KeyPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bo
 declare type RawPosition = Partial<Record<'top' | 'bottom' | 'left' | 'right', string>>;
 export declare type OverlapPosition = RawPosition | KeyPosition;
 declare type BaseOverlapProps = WithClassesProps<{
-    /**
-     * Accept two types of value:
-     * - { top: '0px', left: '0px', right: '0px', bottom: '0px' }
-     * - "top-left" | "top-right" | "bottom-left" | "bottom-right"
-     */
     position: OverlapPosition;
-    /**
-     * The component you want to position on top of children
-     */
     floater?: ReactElement;
-    /**
-     * Only shows the floater component when hovering
-     */
     showFloaterOnHoverOnly?: boolean;
 }, OverlapClassesKey>;
 export declare type OverlapProps<T extends ExtendElementType = OverlapDefaultElementType> = OverridableProps<BaseOverlapProps, T>;

package/src/PageHeader/PageHeader.type.d.ts

@@ -2,10 +2,6 @@ import { StandardProps } from '@ringcentral/spring-base';
 import { PageHeaderCenterClassesKey, PageHeaderClassesKey, PageHeaderLeftClassesKey, PageHeaderRightClassesKey, PageHeaderTitleClassesKey } from './PageHeader.classes';
 export declare type PageHeaderVariant = 'integrated' | 'detached';
 export declare type PageHeaderProps = StandardProps<{
-    /**
-     * The variant to use.
-     * @default 'integrated'
-     */
     variant?: PageHeaderVariant;
 }, PageHeaderClassesKey, 'header'>;
 export declare type PageHeaderLeftProps = StandardProps<{}, PageHeaderLeftClassesKey, 'div'>;

package/src/PickerTextField/PickerTextField.type.d.ts

@@ -5,22 +5,12 @@ import { PopoverProps } from '../Popover';
 import { TextField, TextFieldProps } from '../TextField';
 import { PickerTextFieldClassesKey } from './PickerTextField.classes';
 declare type PickerTextFieldProps = StandardProps<{
-    /** trigger when user click the clear button */
     onClear?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
-    /**
-     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
-     * announcementText for screen reader read
-     */
     inputProps?: TextFieldProps['inputProps'];
-    /** announcementText announced by screen reader when textField focused */
     announcementText?: string;
-    /** props for hourPicker component */
     PopoverProps?: Omit<PopoverProps, 'open' | 'anchorEl' | 'anchorOrigin' | 'transformOrigin' | 'onClose'>;
-    /** children for render in popover */
     children: ReactNode;
-    /** end adornment icon */
     endIconSymbol?: IconProps['symbol'];
-    /** can manual trigger close by ref */
     action?: Ref<PickerTextFieldActions>;
     textInputClasses?: TextFieldProps['classes'];
 } & Pick<PopoverProps, 'onClose'>, PickerTextFieldClassesKey, typeof TextField, 'readOnly' | 'inputComponent' | 'classes'>;

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

@@ -8,43 +8,14 @@ import { PopperPaperProps } from '../PopperPaper';
 import { PopoverClassesKey } from './Popover.classes';
 export declare type PopoverCloseReason = 'escapeKeyDown' | 'backdropClick';
 export declare type PopoverProps = StandardProps<{
-    /**
-     * Content for Popover
-     */
     children?: ReactNode;
-    /**
-     * If true, show border
-     * @default true
-     */
     bordered?: boolean;
-    /**
-     * If true, show border
-     * @default true
-     */
     shadow?: boolean;
-    /**
-     * @default standard
-     */
     variant?: 'standard' | 'pointed';
-    /**
-     * Props applied to Popper
-     */
     PopperProps?: Omit<PopperProps, 'anchorEl' | 'className' | 'placement' | 'actions'> & HTMLDataAttribute;
-    /**
-     * Callback fired when the available viewport height changes.
-     */
     onAvailableHeightChange?: (height: number) => void;
-    /**
-     * Props passed to the underlying PopperPaper component.
-     */
     PopperPaperProps?: Partial<PopperPaperProps>;
-    /**
-     * props apply animation element
-     */
     motionProps?: MotionProps | null;
-    /**
-     * force transform origin for default animation
-     */
     transformOrigin?: GetGrowOptions['transformOrigin'];
     popperRef?: Ref<HTMLDivElement>;
 } & Pick<PopperProps, 'placement' | 'anchorEl' | 'actions'>, PopoverClassesKey, typeof Modal>;

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

@@ -5,53 +5,14 @@ import { PortalProps } from '../Portal';
 export declare type PopperPlacementType = Placement;
 export declare type PopperProps = PropsWithRoot<{
     ref?: Ref<HTMLDivElement>;
-    /**
-     * An HTML element, [virtualElement](https://floating-ui.com/docs/virtual-elements),
-     * or a function that returns either.
-     * It's used to set the position of the popper.
-     * The return value will passed as the reference object of the Popper instance.
-     *
-     * ❗️If anchor is `VirtualElement`, pls set container by yourself or disable portal
-     */
     anchorEl?: ReferenceType | null | (() => ReferenceType | null);
     middlewares?: Middleware[] | ((presetMiddlewares: Middleware[]) => Middleware[]);
-    /**
-     * displaces the floating element from its core placement along the specified axes.
-     * @default 0
-     */
     offset?: number;
-    /**
-     * The surrounding gap between the content and window edge. Can be set to a number or { top, right, bottom, left }.
-     * Padding applies to shift and flip props.
-     * @default 0
-     */
     padding?: Padding;
-    /**
-     * Set arrow height. If unset or 0, not show arrow.
-     * @default 0
-     */
     arrowHeight?: number;
-    /**
-     * This describes the padding between the arrow and the edges of the floating element.
-     * If your floating element has border-radius, this will prevent it from overflowing the corners.
-     * @default 0
-     */
     arrowPadding?: number;
-    /**
-     * A ref with imperative actions.
-     * It allows to update position of popper.
-     */
     actions?: Ref<PopperActions>;
-    /**
-     * To improve performance about auto update popper position.
-     * If true, use default config.
-     * If false, disable auto update.
-     * @default true
-     */
     autoUpdate?: AutoUpdateOptions | boolean;
-    /**
-     * If true, the popper will match the width of the anchor element.
-     */
     matchAnchorWidth?: boolean;
     children?: ReactNode | ((props: {
         placement: PopperPlacementType;
@@ -60,33 +21,11 @@ export declare type PopperProps = PropsWithRoot<{
     }) => ReactNode);
 } & Omit<UseFloatingOptions, 'middleware' | 'strategy'> & Omit<PortalProps, 'children'>, 'div'>;
 export declare type AutoUpdateOptions = {
-    /**
-     * Whether to update the position when an overflow ancestor is scrolled.
-     * @default true
-     */
     ancestorScroll: boolean;
-    /**
-     * Whether to update the position when an overflow ancestor is resized. This
-     * uses the native `resize` event.
-     * @default true
-     */
     ancestorResize: boolean;
-    /**
-     * Whether to update the position when either the reference or floating
-     * elements resized. This uses a `ResizeObserver`.
-     * @default false
-     */
     elementResize: boolean;
-    /**
-     * Whether to update on every animation frame if necessary. Optimized for
-     * performance so updates are only called when necessary, but use sparingly.
-     * @default false
-     */
     animationFrame: boolean;
 };
 export declare type PopperActions = {
-    /**
-     * re-compute position of popper
-     */
     update: () => void;
 };

package/src/Radio/Radio.type.d.ts

@@ -3,14 +3,9 @@ import { UseSwitchParameters } from '@mui/base';
 import { HTMLDataAttribute, StandardProps } from '@ringcentral/spring-base';
 import { RadioClassesKey } from './Radio.classes';
 export declare type RadioProps = StandardProps<{
-    /** The value to be used in radio group. */
     value?: string;
-    /** The name of the group which the radio stay in. */
     name?: string;
-    /** Pass a ref to the `input` element. */
     inputRef?: Ref<HTMLInputElement>;
-    /** Attributes applied to root */
     rootProps?: Omit<ComponentProps<'div'>, 'className'> & HTMLDataAttribute;
-    /** Attributes applied to `input` element */
     inputProps?: Omit<ComponentProps<'input'>, 'className' | 'type' | 'ref'>;
 } & Omit<UseSwitchParameters, 'readonly'>, RadioClassesKey>;

package/src/RadioGroup/RadioGroup.type.d.ts

@@ -3,12 +3,8 @@ import { StandardProps } from '@ringcentral/spring-base';
 import { RadioProps } from '../Radio/Radio.type';
 import { RadioGroupClassesKey } from './RadioGroup.classes';
 export declare type RadioGroupProps = StandardProps<{
-    /** Display group of elements in a compact row. */
     row?: boolean;
-    /** The name of radio group. */
     name: string;
-    /** The default value for uncontrolled radio group. */
     defaultValue?: string;
-    /** The children for radio group. */
     children?: ReactNode;
 } & Pick<RadioProps, 'value' | 'onChange'>, RadioGroupClassesKey, 'div'>;

package/src/Rating/Rating.type.d.ts

@@ -3,95 +3,21 @@ import { ChangeEventHandler, ComponentPropsWithRef } from 'react';
 import { IconProps } from '../Icon/Icon.type';
 import { RatingClassesKey } from './Rating.classes';
 export declare type RatingProps = StandardProps<{
-    /**
-     * The default value. Use when the component is not controlled.
-     * @default null
-     */
     defaultValue?: number;
-    /**
-     * If `true`, the component is disabled.
-     * @default false
-     */
     disabled?: boolean;
-    /**
-     * The icon to display.
-     * @default <Icon symbol={StarFilledMd} size="large" />
-     */
     icon?: React.ReactNode;
-    /**
-     * The icon to display when empty.
-     * @default <Icon symbol={StarMd} size="large" />
-     */
     emptyIcon?: React.ReactNode;
-    /**
-     * The label read when the rating input is empty.
-     * @default 'Empty'
-     */
     emptyLabelText?: React.ReactNode;
-    /**
-     * Accepts a function which returns a string value that provides a user-friendly name for the current value of the rating.
-     * This is important for screen reader users.
-     *
-     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
-     * @param {number} value The rating label's value to format.
-     * @returns {string}
-     *
-     * @default function defaultLabelText(value) {
-     *    return `${value || '0'} Star${value !== 1 ? 's' : ''}`;
-     * }
-     */
     getLabelText?: (value: number | null) => string;
-    /**
-     * If `true`, only the selected icon will be highlighted.
-     * @default false
-     */
     highlightSelectedOnly?: boolean;
-    /**
-     * The component containing the icon.
-     * @default 'div'
-     */
     IconContainerComponent?: React.ElementType<ComponentPropsWithRef<any>>;
-    /**
-     * Maximum rating.
-     * @default 5
-     */
     max?: number;
-    /**
-     * The name attribute of the radio `input` elements.
-     * This input `name` should be unique within the page.
-     * Being unique within a form is insufficient since the `name` is used to generated IDs.
-     */
     name?: string;
-    /**
-     * Callback fired when the value changes.
-     * @param {React.SyntheticEvent} event The event source of the callback.
-     * @param {number|null} value The new value.
-     */
     onChange?: (event: React.SyntheticEvent, value: number | null) => void;
-    /**
-     * Callback function that is fired when the hover state changes.
-     * @param {React.SyntheticEvent} event The event source of the callback.
-     * @param {number} value The new value.
-     */
     onChangeActive?: (event: React.SyntheticEvent, value: number) => void;
-    /**
-     * The minimum increment value change allowed.
-     * @default 1
-     */
     precision?: number;
-    /**
-     * Removes all hover effects and pointer events.
-     * @default false
-     */
     readOnly?: boolean;
-    /**
-     * The size of the Icon component.
-     * @default 'large'
-     */
     size?: IconProps['size'];
-    /**
-     * The rating value.
-     */
     value?: number | null;
 }, RatingClassesKey, 'div'>;
 export declare type RatingItemProps = StandardProps<{