asterui 0.12.26 → 0.12.28

package/dist/components/Collapse.d.ts

@@ -1,25 +1,45 @@
 import { default as React } from 'react';
-export interface CollapseProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title' | 'onChange'> {
-    children: React.ReactNode;
-    title?: React.ReactNode;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onChange?: (open: boolean) => void;
-    icon?: 'arrow' | 'plus' | 'none';
-}
-export interface CollapseTitleProps {
+export type CollapseSize = 'sm' | 'md' | 'lg';
+export type CollapseIconPosition = 'start' | 'end';
+export type CollapseCollapsible = 'header' | 'icon' | 'disabled';
+export interface CollapseItemType {
+    /** Unique key for the panel */
+    key: string | number;
+    /** Panel header/label */
+    label: React.ReactNode;
+    /** Panel content */
     children: React.ReactNode;
+    /** Extra element in the corner */
+    extra?: React.ReactNode;
+    /** Whether to show the arrow icon */
+    showArrow?: boolean;
+    /** Collapsible mode for this panel */
+    collapsible?: CollapseCollapsible;
+    /** Custom class name for this panel */
     className?: string;
 }
-export interface CollapseContentProps {
-    children: React.ReactNode;
-    className?: string;
+export interface CollapseProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Collapse items */
+    items?: CollapseItemType[];
+    /** Currently active panel keys (controlled) */
+    activeKey?: string | number | (string | number)[];
+    /** Default active panel keys (uncontrolled) */
+    defaultActiveKey?: string | number | (string | number)[];
+    /** Accordion mode - only one panel open at a time */
+    accordion?: boolean;
+    /** Show border around panels */
+    bordered?: boolean;
+    /** Ghost mode - transparent background */
+    ghost?: boolean;
+    /** Size variant */
+    size?: CollapseSize;
+    /** Icon type */
+    icon?: 'arrow' | 'plus' | 'none';
+    /** Icon placement */
+    expandIconPlacement?: CollapseIconPosition;
+    /** Callback when panels change */
+    onChange?: (activeKey: (string | number)[]) => void;
+    /** Test ID */
+    'data-testid'?: string;
 }
-declare function CollapseRoot({ children, title, open, defaultOpen, onChange, icon, className, ...rest }: CollapseProps): import("react/jsx-runtime").JSX.Element;
-declare function CollapseTitle({ children, className }: CollapseTitleProps): import("react/jsx-runtime").JSX.Element;
-declare function CollapseContent({ children, className }: CollapseContentProps): import("react/jsx-runtime").JSX.Element;
-export declare const Collapse: typeof CollapseRoot & {
-    Title: typeof CollapseTitle;
-    Content: typeof CollapseContent;
-};
-export {};
+export declare const Collapse: React.ForwardRefExoticComponent<CollapseProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Descriptions.d.ts

@@ -1,16 +1,39 @@
 import { default as React } from 'react';
-export type DescriptionsSize = 'small' | 'default' | 'large';
+export type DescriptionsSize = 'sm' | 'md' | 'lg';
 export type DescriptionsLayout = 'horizontal' | 'vertical';
 export interface DescriptionsItemProps {
+    /** Label for the item */
     label?: React.ReactNode;
+    /** Number of columns to span */
     span?: number;
+    /** Content of the item */
     children?: React.ReactNode;
+    /** Custom label styles */
     labelStyle?: React.CSSProperties;
+    /** Custom content styles */
+    contentStyle?: React.CSSProperties;
+}
+/** Item configuration for the items prop */
+export interface DescriptionsItemConfig {
+    /** Label for the item */
+    label: React.ReactNode;
+    /** Content of the item */
+    children: React.ReactNode;
+    /** Number of columns to span */
+    span?: number;
+    /** Custom label styles */
+    labelStyle?: React.CSSProperties;
+    /** Custom content styles */
     contentStyle?: React.CSSProperties;
 }
 export interface DescriptionsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Title of the descriptions block */
     title?: React.ReactNode;
+    /** Extra content in the top-right corner */
+    extra?: React.ReactNode;
+    /** Show borders around cells */
     bordered?: boolean;
+    /** Number of columns (or responsive config) */
     column?: number | {
         xs?: number;
         sm?: number;
@@ -19,16 +42,25 @@ export interface DescriptionsProps extends Omit<React.HTMLAttributes<HTMLDivElem
         xl?: number;
         '2xl'?: number;
     };
+    /** Size variant */
     size?: DescriptionsSize;
+    /** Layout direction */
     layout?: DescriptionsLayout;
+    /** Show colon after labels */
     colon?: boolean;
+    /** Default label styles */
     labelStyle?: React.CSSProperties;
+    /** Default content styles */
     contentStyle?: React.CSSProperties;
+    /** Item configurations (alternative to children) */
+    items?: DescriptionsItemConfig[];
+    /** Children (Descriptions.Item elements) */
     children?: React.ReactNode;
+    /** Test ID for the component */
+    'data-testid'?: string;
 }
 declare function DescriptionsItem(_props: DescriptionsItemProps): null;
-declare function DescriptionsRoot({ title, bordered, column, size, layout, colon, labelStyle, contentStyle, className, style, children, ...rest }: DescriptionsProps): import("react/jsx-runtime").JSX.Element;
-export declare const Descriptions: typeof DescriptionsRoot & {
+export declare const Descriptions: React.ForwardRefExoticComponent<DescriptionsProps & React.RefAttributes<HTMLDivElement>> & {
     Item: typeof DescriptionsItem;
 };
 export default Descriptions;

package/dist/components/Empty.d.ts

@@ -1,8 +1,17 @@
 import { default as React } from 'react';
 export interface EmptyProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Extra content like buttons or actions */
     children?: React.ReactNode;
+    /** Text or node to display as description */
     description?: React.ReactNode;
+    /** Custom image or icon; set to null to hide */
     image?: React.ReactNode;
+    /** Styling applied to the image container */
     imageStyle?: React.CSSProperties;
+    /** Test ID for the component */
+    'data-testid'?: string;
 }
-export declare const Empty: React.FC<EmptyProps>;
+export declare const Empty: React.ForwardRefExoticComponent<EmptyProps & React.RefAttributes<HTMLDivElement>> & {
+    PRESENTED_IMAGE_DEFAULT: import("react/jsx-runtime").JSX.Element;
+    PRESENTED_IMAGE_SIMPLE: import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/Image.d.ts

@@ -1,14 +1,26 @@
 import { default as React } from 'react';
 export interface ImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'placeholder'> {
+    /** Image source URL */
     src: string;
+    /** Alternative text for the image */
     alt?: string;
+    /** Fallback image URL when source fails to load */
     fallback?: string;
+    /** Placeholder content shown while loading */
     placeholder?: React.ReactNode;
+    /** Enable click to preview image in lightbox */
     preview?: boolean;
+    /** Image width */
     width?: string | number;
+    /** Image height */
     height?: string | number;
+    /** Additional CSS classes */
     className?: string;
+    /** Callback when image loads successfully */
     onLoad?: () => void;
+    /** Callback when image fails to load */
     onError?: () => void;
+    /** Test ID for the component */
+    'data-testid'?: string;
 }
-export declare const Image: React.FC<ImageProps>;
+export declare const Image: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLImageElement>>;

package/dist/components/List.d.ts

@@ -1,13 +1,79 @@
 import { default as React } from 'react';
-export interface ListProps extends React.HTMLAttributes<HTMLUListElement> {
-    children: React.ReactNode;
+export interface ListPaginationConfig {
+    current?: number;
+    pageSize?: number;
+    total?: number;
+    onChange?: (page: number, pageSize: number) => void;
+}
+export interface ListGridConfig {
+    gutter?: number;
+    column?: number;
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
 }
-export interface ListRowProps extends React.LiHTMLAttributes<HTMLLIElement> {
+export interface ListProps<T = unknown> extends Omit<React.HTMLAttributes<HTMLUListElement>, 'children'> {
+    /** Data source array */
+    dataSource?: T[];
+    /** Function to render each item */
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    /** List header content */
+    header?: React.ReactNode;
+    /** List footer content */
+    footer?: React.ReactNode;
+    /** Show loading state */
+    loading?: boolean;
+    /** Pagination configuration or false to disable */
+    pagination?: ListPaginationConfig | false;
+    /** Grid layout configuration */
+    grid?: ListGridConfig;
+    /** Show border around list */
+    bordered?: boolean;
+    /** Show divider between items */
+    split?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Layout direction */
+    itemLayout?: 'horizontal' | 'vertical';
+    /** Empty state text */
+    locale?: {
+        emptyText?: React.ReactNode;
+    };
+    /** Load more content (e.g., button) */
+    loadMore?: React.ReactNode;
+    /** Custom key extraction function */
+    rowKey?: keyof T | ((item: T) => React.Key);
+    /** Compound pattern children */
+    children?: React.ReactNode;
+    /** Accessible label for the list */
+    'aria-label'?: string;
+    /** Test ID for the component */
+    'data-testid'?: string;
+}
+export interface ListItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    /** Item content */
     children: React.ReactNode;
+    /** Action buttons */
+    actions?: React.ReactNode[];
+    /** Extra content on the right */
+    extra?: React.ReactNode;
+    /** Test ID for this item */
+    'data-testid'?: string;
+}
+export interface ListItemMetaProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Avatar or icon */
+    avatar?: React.ReactNode;
+    /** Title content */
+    title?: React.ReactNode;
+    /** Description content */
+    description?: React.ReactNode;
 }
-declare function ListRoot({ children, className, ...rest }: ListProps): import("react/jsx-runtime").JSX.Element;
-declare function ListRow({ children, className, ...rest }: ListRowProps): import("react/jsx-runtime").JSX.Element;
-export declare const List: typeof ListRoot & {
-    Row: typeof ListRow;
+export type ListRowProps = ListItemProps;
+export declare const List: React.ForwardRefExoticComponent<ListProps<unknown> & React.RefAttributes<HTMLUListElement>> & {
+    Item: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>> & {
+        Meta: React.FC<ListItemMetaProps>;
+    };
+    Row: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>>;
 };
-export {};

package/dist/components/Table.d.ts

@@ -3,41 +3,79 @@ export interface FilterConfig {
     text: string;
     value: string | number | boolean;
 }
-export interface ColumnType<T = any> {
+export type TableSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface ColumnType<T> {
     key: string;
-    title: string;
-    dataIndex?: string;
-    render?: (value: any, record: T, index: number) => React.ReactNode;
+    title: React.ReactNode;
+    dataIndex?: keyof T & string;
+    render?: (value: T[keyof T] | undefined, record: T, index: number) => React.ReactNode;
     width?: string | number;
     align?: 'left' | 'center' | 'right';
     fixed?: 'left' | 'right';
     sorter?: boolean | ((a: T, b: T) => number);
+    sortOrder?: 'ascend' | 'descend' | null;
     filters?: FilterConfig[];
+    filteredValue?: (string | number | boolean)[];
     onFilter?: (value: string | number | boolean, record: T) => boolean;
     defaultSortOrder?: 'ascend' | 'descend';
     defaultFilteredValue?: (string | number | boolean)[];
+    ellipsis?: boolean;
+    hidden?: boolean;
 }
-export interface RowSelection<T = any> {
+export interface RowSelection<T> {
     type?: 'checkbox' | 'radio';
     selectedRowKeys?: React.Key[];
     onChange?: (selectedRowKeys: React.Key[], selectedRows: T[]) => void;
     getCheckboxProps?: (record: T) => {
         disabled?: boolean;
-        [key: string]: any;
+        name?: string;
     };
 }
+export interface ExpandableConfig<T> {
+    expandedRowKeys?: React.Key[];
+    defaultExpandedRowKeys?: React.Key[];
+    expandedRowRender: (record: T, index: number, expanded: boolean) => React.ReactNode;
+    rowExpandable?: (record: T) => boolean;
+    onExpand?: (expanded: boolean, record: T) => void;
+    onExpandedRowsChange?: (expandedKeys: React.Key[]) => void;
+    expandRowByClick?: boolean;
+    expandIcon?: (props: {
+        expanded: boolean;
+        onExpand: () => void;
+        record: T;
+    }) => React.ReactNode;
+}
 export interface PaginationConfig {
     current?: number;
     pageSize?: number;
     total?: number;
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: (total: number, range: [number, number]) => React.ReactNode;
+    pageSizeOptions?: number[];
     onChange?: (page: number, pageSize: number) => void;
+    onShowSizeChange?: (current: number, size: number) => void;
+    position?: 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
+}
+export interface ScrollConfig {
+    x?: number | string;
+    y?: number | string;
+}
+export interface SorterResult<T> {
+    column?: ColumnType<T>;
+    order?: 'ascend' | 'descend' | null;
+    field?: string;
 }
-export interface TableProps<T = any> {
+export interface TableChangeExtra<T> {
+    currentDataSource: T[];
+    action: 'paginate' | 'sort' | 'filter';
+}
+export interface TableProps<T> {
     columns: ColumnType<T>[];
     dataSource: T[];
-    rowKey?: string | ((record: T) => string);
+    rowKey?: (keyof T & string) | ((record: T) => string);
     loading?: boolean;
-    size?: 'xs' | 'sm' | 'md' | 'lg';
+    size?: TableSize;
     bordered?: boolean;
     hoverable?: boolean;
     striped?: boolean;
@@ -45,7 +83,23 @@ export interface TableProps<T = any> {
     pinCols?: boolean;
     pagination?: false | PaginationConfig;
     rowSelection?: RowSelection<T>;
+    expandable?: ExpandableConfig<T>;
+    scroll?: ScrollConfig;
     className?: string;
     onRow?: (record: T, index: number) => React.HTMLAttributes<HTMLTableRowElement>;
+    onChange?: (pagination: PaginationConfig, filters: Record<string, (string | number | boolean)[] | null>, sorter: SorterResult<T>, extra: TableChangeExtra<T>) => void;
+    onSortChange?: (sorter: SorterResult<T>) => void;
+    onFilterChange?: (filters: Record<string, (string | number | boolean)[] | null>) => void;
+    locale?: {
+        emptyText?: React.ReactNode;
+        filterConfirm?: string;
+        filterReset?: string;
+        selectAll?: string;
+        selectInvert?: string;
+    };
+    'data-testid'?: string;
+    'aria-label'?: string;
 }
-export declare function Table<T extends Record<string, any>>({ columns, dataSource, rowKey, loading, size, bordered, hoverable, striped, pinRows, pinCols, pagination, rowSelection, className, onRow, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const Table: <T extends Record<string, unknown>>(props: TableProps<T> & {
+    ref?: React.ForwardedRef<HTMLTableElement>;
+}) => React.ReactElement;

package/dist/components/Timeline.d.ts

@@ -1,24 +1,79 @@
 import { default as React } from 'react';
-export interface TimelineProps extends React.HTMLAttributes<HTMLUListElement> {
-    children: React.ReactNode;
+export type TimelineMode = 'start' | 'alternate' | 'end';
+export type TimelineColor = 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
+export interface TimelineItemConfig {
+    /** Unique key for the item */
+    key?: React.Key;
+    /** Content at start position (left/top) */
+    start?: React.ReactNode;
+    /** Content at end position (right/bottom) */
+    end?: React.ReactNode;
+    /** Central icon or marker */
+    icon?: React.ReactNode;
+    /** Wrap start content in timeline-box */
+    startBox?: boolean;
+    /** Wrap end content in timeline-box */
+    endBox?: boolean;
+    /** Color of the timeline dot/connector */
+    color?: TimelineColor;
+    /** Show loading spinner instead of icon */
+    loading?: boolean;
+    /** Additional CSS classes for this item */
+    className?: string;
+}
+export interface TimelineProps extends Omit<React.HTMLAttributes<HTMLUListElement>, 'children'> {
+    /** Timeline items (compound pattern) */
+    children?: React.ReactNode;
+    /** Timeline items (declarative API) */
+    items?: TimelineItemConfig[];
+    /** Vertical layout orientation */
     vertical?: boolean;
+    /** Horizontal layout (default) */
     horizontal?: boolean;
+    /** All items on one side */
     compact?: boolean;
+    /** Snap icon to start instead of center */
     snapIcon?: boolean;
+    /** Item distribution layout */
+    mode?: TimelineMode;
+    /** Reverse item order */
+    reverse?: boolean;
+    /** Show pending/loading indicator at end */
+    pending?: React.ReactNode;
+    /** Custom icon for pending item */
+    pendingIcon?: React.ReactNode;
+    /** Test ID for the component */
+    'data-testid'?: string;
+    /** Accessible label for the timeline */
+    'aria-label'?: string;
 }
-export interface TimelineItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
+export interface TimelineItemProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, 'color'> {
+    /** Content at start position (left/top) */
     start?: React.ReactNode;
+    /** Content at end position (right/bottom) */
     end?: React.ReactNode;
+    /** Central icon or marker */
     icon?: React.ReactNode;
+    /** Wrap start content in timeline-box */
     startBox?: boolean;
+    /** Wrap end content in timeline-box */
     endBox?: boolean;
+    /** Color of the timeline dot/connector */
+    color?: TimelineColor;
+    /** Show loading spinner instead of icon */
+    loading?: boolean;
+    /** Test ID for this item */
+    'data-testid'?: string;
+}
+interface TimelineItemInternalProps extends TimelineItemProps {
     _index?: number;
+    _total?: number;
     _compact?: boolean;
     _vertical?: boolean;
+    _mode?: TimelineMode;
+    _baseTestId?: string;
 }
-declare function TimelineRoot({ children, className, vertical, horizontal, compact, snapIcon, ...rest }: TimelineProps): import("react/jsx-runtime").JSX.Element;
-declare function TimelineItem({ start, end, icon, startBox, endBox, className, _index, _compact, _vertical, ...rest }: TimelineItemProps): import("react/jsx-runtime").JSX.Element;
-export declare const Timeline: typeof TimelineRoot & {
-    Item: typeof TimelineItem;
+export declare const Timeline: React.ForwardRefExoticComponent<TimelineProps & React.RefAttributes<HTMLUListElement>> & {
+    Item: React.ForwardRefExoticComponent<TimelineItemInternalProps & React.RefAttributes<HTMLLIElement>>;
 };
 export {};

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export type { CountdownProps } from './components/Countdown';
 export { DatePicker } from './components/DatePicker';
 export type { DatePickerProps } from './components/DatePicker';
 export { Descriptions } from './components/Descriptions';
-export type { DescriptionsProps, DescriptionsItemProps, DescriptionsSize, DescriptionsLayout } from './components/Descriptions';
+export type { DescriptionsProps, DescriptionsItemProps, DescriptionsItemConfig, DescriptionsSize, DescriptionsLayout } from './components/Descriptions';
 export { Diff } from './components/Diff';
 export type { DiffProps } from './components/Diff';
 export { Dock } from './components/Dock';
@@ -74,8 +74,6 @@ export { HoverGallery } from './components/HoverGallery';
 export type { HoverGalleryProps } from './components/HoverGallery';
 export { Image } from './components/Image';
 export type { ImageProps } from './components/Image';
-export { Indicator } from './components/Indicator';
-export type { IndicatorProps, IndicatorPosition } from './components/Indicator';
 export { Dropdown } from './components/Dropdown';
 export type { DropdownProps, DropdownTriggerProps, DropdownMenuProps, DropdownItemProps, DropdownSubMenuProps, DropdownDividerProps, DropdownMenuItem, DropdownMenuDivider, DropdownMenuItemType, DropdownTriggerType, } from './components/Dropdown';
 export { Empty } from './components/Empty';
@@ -91,7 +89,7 @@ export type { KbdProps } from './components/Kbd';
 export { Layout, useSiderContext } from './components/Layout';
 export type { LayoutProps, LayoutHeaderProps, LayoutFooterProps, LayoutContentProps, LayoutSiderProps } from './components/Layout';
 export { List } from './components/List';
-export type { ListProps, ListRowProps } from './components/List';
+export type { ListProps, ListRowProps, ListItemProps, ListItemMetaProps, ListPaginationConfig, ListGridConfig } from './components/List';
 export { Loading } from './components/Loading';
 export type { LoadingProps } from './components/Loading';
 export { Mask } from './components/Mask';
@@ -157,7 +155,7 @@ export type { StatusProps, StatusType, StatusSize } from './components/Status';
 export { Steps } from './components/Steps';
 export type { StepsProps, StepProps, StepItem, StepsDirection } from './components/Steps';
 export { Table } from './components/Table';
-export type { TableProps, ColumnType, PaginationConfig, FilterConfig, RowSelection } from './components/Table';
+export type { TableProps, TableSize, ColumnType, PaginationConfig, FilterConfig, RowSelection, ExpandableConfig, ScrollConfig, SorterResult, TableChangeExtra, } from './components/Table';
 export { Tabs } from './components/Tabs';
 export type { TabsProps, TabPanelProps, TabItem, TabsVariant, TabsSize, TabsPosition } from './components/Tabs';
 export { Textarea } from './components/Textarea';
@@ -171,7 +169,7 @@ export type { ThemeControllerSwapProps, ThemeControllerDropdownProps, ThemeContr
 export { TimePicker } from './components/TimePicker';
 export type { TimePickerProps } from './components/TimePicker';
 export { Timeline } from './components/Timeline';
-export type { TimelineProps, TimelineItemProps } from './components/Timeline';
+export type { TimelineProps, TimelineItemProps, TimelineItemConfig, TimelineMode, TimelineColor } from './components/Timeline';
 export { Toggle } from './components/Toggle';
 export type { ToggleProps } from './components/Toggle';
 export { Tour } from './components/Tour';