@broxus/react-uikit 0.21.0 → 0.23.0

package/dist/esm/components/Dotnav/Dotnav.d.ts

@@ -3,7 +3,7 @@ export interface DotnavProps extends React.HTMLAttributes<HTMLUListElement> {
     prefixCls?: string;
     vertical?: boolean;
 }
-export declare function Dotnav(props: DotnavProps): React.JSX.Element;
+export declare function Dotnav({ className, vertical, ...props }: DotnavProps): React.ReactElement;
 export declare namespace Dotnav {
     var displayName: string;
 }

package/dist/esm/components/Dotnav/Dotnav.js

@@ -1,9 +1,9 @@
 import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
-export function Dotnav(props) {
+export function Dotnav({ className, vertical, ...props }) {
     const config = useConfig();
-    const { className, prefixCls = config.prefixCls, vertical, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'dotnav'), [config, prefixCls]);
     return (React.createElement("ul", { className: classNames(rootCls, {
             [`${rootCls}-vertical`]: vertical,

package/dist/esm/components/Dotnav/Item.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 export interface DotnavItemProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, 'children'> {
     isActive?: boolean;
 }
-export declare function Item(props: DotnavItemProps): React.JSX.Element;
+export declare function Item({ className, isActive, onClick, ...props }: DotnavItemProps): React.ReactElement;
 export declare namespace Item {
     var displayName: string;
 }

package/dist/esm/components/Dotnav/Item.js

@@ -2,12 +2,11 @@ import classNames from 'classnames';
 import * as React from 'react';
 import { Button } from '../../components/Button';
 import { useConfig } from '../../components/ConfigProvider';
-export function Item(props) {
+export function Item({ className, isActive, onClick, ...props }) {
     const config = useConfig();
-    const { className, isActive, onClick, ...restProps } = props;
     return (React.createElement("li", { className: classNames({
             [`${config.prefixCls}-active`]: isActive,
-        }, className), ...restProps },
+        }, className), ...props },
         React.createElement(Button, { type: "text", onClick: onClick })));
 }
 if (process.env.NODE_ENV !== 'production') {

package/dist/esm/components/Drawer/index.d.ts

@@ -2,11 +2,11 @@ import { type DrawerProps as RcDrawerProps } from '@rc-component/drawer';
 import * as React from 'react';
 import { type Direction } from '../../types';
 export type DrawerSize = 'large';
-export type DrawerRef = {
+export interface DrawerRef {
     collapse: VoidFunction;
     expand: VoidFunction;
     isOpen?: boolean;
-};
+}
 export interface PushState {
     distance: string | number;
 }
@@ -17,6 +17,6 @@ export interface DrawerProps extends RcDrawerProps {
     defaultOpen?: boolean;
     direction?: Direction;
     size?: DrawerSize;
-    trigger?: (ref: DrawerRef) => React.JSX.Element;
+    trigger?: (ref: DrawerRef) => React.ReactElement;
 }
 export declare const Drawer: React.ForwardRefExoticComponent<DrawerProps & React.RefAttributes<DrawerRef>>;

package/dist/esm/components/Drawer/index.js

@@ -5,9 +5,9 @@ import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
 import { addModalMode, getMotionName, removeModalMode } from '../../utils';
 const defaultPushState = { distance: 180 };
-export const Drawer = React.forwardRef((props, ref) => {
+export const Drawer = React.forwardRef(({ animation = 'slide', children, className, defaultOpen, destroyOnHidden, direction, keyboard = true, mask = true, maskClosable = true, motion, open, placement = 'right', push = defaultPushState, rootClassName, rootStyle, size, trigger, onClose: onCloseCallback, ...props }, ref) => {
     const config = useConfig();
-    const { animation = 'slide', children, className, defaultOpen, destroyOnHidden, direction, getContainer = config.getPopupContainer, keyboard = true, mask = true, maskClosable = true, motion, open, placement = 'right', prefixCls = config.prefixCls, push = defaultPushState, rootClassName, rootStyle, size, trigger, onClose: onCloseCallback, ...restProps } = props;
+    const { getContainer = config.getPopupContainer, prefixCls = config.prefixCls, ...restProps } = props;
     const [isShown, setShown] = React.useState(defaultOpen);
     const [internalOpen, setOpen] = React.useState(defaultOpen);
     const mergedOpen = open === undefined ? internalOpen : open;

package/dist/esm/components/Drop/index.d.ts

@@ -1,6 +1,5 @@
 import { type CSSMotionProps } from '@rc-component/motion';
-import { type BuildInPlacements, type TriggerProps } from '@rc-component/trigger';
-import { type AlignType } from '@rc-component/trigger/lib/interface';
+import { type AlignType, type BuildInPlacements, type TriggerProps } from '@rc-component/trigger';
 import * as React from 'react';
 export type DropPlacement = 'bottom-center' | 'bottom-left' | 'bottom-right' | 'top-center' | 'top-left' | 'top-right';
 export interface DropProps extends Pick<TriggerProps, 'alignPoint' | 'action' | 'autoDestroy' | 'blurDelay' | 'children' | 'focusDelay' | 'getPopupContainer' | 'hideAction' | 'mask' | 'maskClosable' | 'maskMotion' | 'mouseEnterDelay' | 'mouseLeaveDelay' | 'prefixCls' | 'showAction' | 'stretch' | 'zIndex'> {
@@ -22,12 +21,12 @@ export interface DropProps extends Pick<TriggerProps, 'alignPoint' | 'action' |
     onOverlayClick?: (event: Event) => void;
     onVisibleChange?: (visible: boolean) => void;
 }
-export type TriggerRef = {
+export interface TriggerRef {
     forceAlign: VoidFunction;
-};
-export type DropRef = {
+}
+export interface DropRef {
     close: VoidFunction;
     open: VoidFunction;
     triggerRef: TriggerRef | null;
-};
+}
 export declare const Drop: React.ForwardRefExoticComponent<DropProps & React.RefAttributes<DropRef>>;

package/dist/esm/components/Drop/index.js

@@ -1,12 +1,13 @@
 import Trigger from '@rc-component/trigger';
+import { merge } from '@rc-component/util';
 import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
 import placements from '../../components/Drop/placements';
 import { getMotionName, mergeDropMaskMotion } from '../../utils';
-export const Drop = React.forwardRef((props, ref) => {
+export const Drop = React.forwardRef(({ action = ['hover'], align, alignPoint, arrow = false, autoDestroy, builtinPlacements = placements, children, defaultVisible, hideAction = action, maskMotion, minOverlayWidthMatchTrigger, motion, openClassName, overlay, overlayClassName, overlayStyle, placement = 'bottom-left', rootCls: externalRootCls, showAction = action, visible, onAlign, onOverlayClick, onVisibleChange, ...props }, ref) => {
     const config = useConfig();
-    const { action = ['hover'], align, alignPoint, arrow = false, autoDestroy, builtinPlacements = placements, children, defaultVisible, getPopupContainer = config.getPopupContainer, hideAction = action, maskMotion, minOverlayWidthMatchTrigger, motion, openClassName, overlay, overlayClassName, overlayStyle, placement = 'bottom-left', prefixCls = config.prefixCls, rootCls: externalRootCls, showAction = action, visible, onAlign, onOverlayClick, onVisibleChange, ...restProps } = props;
+    const { getPopupContainer = config.getPopupContainer, prefixCls = config.prefixCls, ...restProps } = props;
     const triggerRef = React.useRef(null);
     const [triggerVisible, setTriggerVisible] = React.useState(defaultVisible);
     const mergedVisible = 'visible' in restProps ? visible : triggerVisible;
@@ -60,7 +61,7 @@ export const Drop = React.forwardRef((props, ref) => {
     if (!triggerHideAction && action.indexOf('contextMenu') > -1) {
         triggerHideAction = ['click'];
     }
-    return (React.createElement(Trigger, { ref: triggerRef, action: action, autoDestroy: autoDestroy, builtinPlacements: builtinPlacements, getPopupContainer: getPopupContainer, hideAction: triggerHideAction || [], maskMotion: mergeDropMaskMotion(prefixCls || config.prefixCls, maskMotion), mouseLeaveDelay: 0.2, popup: getDropElementOrLambda(), popupAlign: align, popupClassName: classNames(overlayClassName, {
+    return (React.createElement(Trigger, { ref: triggerRef, action: action, autoDestroy: autoDestroy, builtinPlacements: merge(placements, builtinPlacements), getPopupContainer: getPopupContainer, hideAction: triggerHideAction || [], maskMotion: mergeDropMaskMotion(prefixCls || config.prefixCls, maskMotion), mouseLeaveDelay: 0.2, popup: getDropElementOrLambda(), popupAlign: align, popupClassName: classNames(overlayClassName, {
             [`${rootCls}-show-arrow`]: arrow,
             [openClassName ?? '']: mergedVisible,
         }), popupMotion: {

package/dist/esm/components/Dropdown/index.js

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
 import { Drop } from '../../components/Drop';
-export const Dropdown = React.forwardRef((props, ref) => {
+export const Dropdown = React.forwardRef(({ children, ...props }, ref) => {
     const config = useConfig();
-    const { children, prefixCls = config.prefixCls, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'dropdown'), [config, prefixCls]);
     return (React.createElement(Drop, { ref: ref, ...restProps, rootCls: rootCls }, children));
 });

package/dist/esm/components/Flex/Flex.d.ts

@@ -18,7 +18,7 @@ export interface FlexOwnProps extends FlexBreakpoint, FlexBreakpointsConfig {
     inline?: boolean;
     prefixCls?: string;
 }
-export type FlexProps<E extends React.ElementType = React.ElementType> = React.PropsWithChildren<FlexOwnProps & PolymorphicProps<E>> & PolymorphicProps<E, FlexOwnProps>;
+export type FlexProps<E extends React.ElementType = React.ElementType> = FlexOwnProps & PolymorphicProps<E> & PolymorphicProps<E, FlexOwnProps>;
 declare const defaultElement = "div";
-export declare function Flex<E extends React.ElementType = typeof defaultElement>(props: FlexProps<E>): React.JSX.Element;
+export declare function Flex<E extends React.ElementType = typeof defaultElement>({ alignContent, alignItems, className, component, flexDirection, flexWrap, inline, justifyContent, ...props }: React.PropsWithChildren<FlexProps<E>>): React.ReactElement;
 export {};

package/dist/esm/components/Flex/Flex.js

@@ -37,9 +37,9 @@ function mapJustifyContentBreakpoints(value) {
     }
     return config;
 }
-export function Flex(props) {
+export function Flex({ alignContent, alignItems, className, component = defaultElement, flexDirection, flexWrap, inline, justifyContent, ...props }) {
     const config = useConfig();
-    const { alignContent, alignItems, className, flexDirection, flexWrap, inline, justifyContent, prefixCls = config.prefixCls, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'flex'), [config, prefixCls]);
     const justifyContentCls = React.useMemo(
     // eslint-disable-next-line no-nested-ternary
@@ -59,5 +59,5 @@ export function Flex(props) {
                 [`${rootCls}-inline`]: inline,
                 [`${rootCls}-wrap-${alignContentMap.get(alignContent)}`]: alignContent && alignContentMap.has(alignContent),
                 [rootCls]: !inline,
-            }, justifyContentCls, className), component: defaultElement, ...restProps })));
+            }, justifyContentCls, className), component: component, ...restProps })));
 }

package/dist/esm/components/Flex/Item.d.ts

@@ -8,7 +8,7 @@ export interface ItemOwnItem {
     order?: Order | BreakpointsConfig<Order>;
     prefixCls?: string;
 }
-export type ItemProps<E extends React.ElementType = React.ElementType> = React.PropsWithChildren<ItemOwnItem & PolymorphicProps<E>> & PolymorphicProps<E, ItemOwnItem>;
+export type ItemProps<E extends React.ElementType = React.ElementType> = ItemOwnItem & PolymorphicProps<E> & PolymorphicProps<E, ItemOwnItem>;
 declare const defaultElement = "div";
-export declare function Item<E extends React.ElementType = typeof defaultElement>(props: ItemProps<E>): React.JSX.Element;
+export declare function Item<E extends React.ElementType = typeof defaultElement>({ className, component, itemDimensions, order, ...props }: React.PropsWithChildren<ItemProps<E>>): React.ReactElement;
 export {};

package/dist/esm/components/Flex/Item.js

@@ -5,14 +5,14 @@ import { useConfig } from '../../components/ConfigProvider';
 import { FlexContext } from '../../components/Flex/context';
 import { getBreakpointsConfigClasses } from '../../utils';
 const defaultElement = 'div';
-export function Item(props) {
+export function Item({ className, component = defaultElement, itemDimensions, order, ...props }) {
     const config = useConfig();
     const { getRootCls } = React.useContext(FlexContext);
-    const { className, itemDimensions, order, prefixCls = getRootCls(), ...restProps } = props;
+    const { prefixCls = getRootCls(), ...restProps } = props;
     const orderCls = React.useMemo(() => (typeof order === 'string'
         ? `${prefixCls}-${order}`
         : getBreakpointsConfigClasses(prefixCls || config.prefixCls, 'flex', order)), [config.prefixCls, order, prefixCls]);
     return (React.createElement(Component, { className: classNames({
             [`${prefixCls}-${itemDimensions}`]: itemDimensions !== undefined,
-        }, orderCls, className), component: defaultElement, ...restProps }));
+        }, orderCls, className), component: component, ...restProps }));
 }

package/dist/esm/components/Flex/context.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-export type FlexContextConsumerProps = {
+export interface FlexContextConsumerProps {
     getRootCls(): string | undefined;
-};
+}
 export declare const FlexContext: React.Context<FlexContextConsumerProps>;

package/dist/esm/components/Flex/index.d.ts

@@ -1,7 +1,7 @@
 import type * as React from 'react';
 import { type FlexAlignContent, type FlexAlignItems, type FlexDirection, type FlexJustifyContent, type FlexProps, type FlexWrap } from '../../components/Flex/Flex';
 import { type ItemProps as FlexItemProps, Item } from '../../components/Flex/Item';
-export type { FlexAlignContent, FlexAlignItems, FlexDirection, FlexJustifyContent, FlexItemProps, FlexProps, FlexWrap };
+export type { FlexAlignContent, FlexAlignItems, FlexDirection, FlexItemProps, FlexJustifyContent, FlexProps, FlexWrap };
 export interface Flex extends React.FunctionComponent<FlexProps> {
     Item: typeof Item;
 }

package/dist/esm/components/Form/Controls.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 export interface ControlsProps extends React.HTMLAttributes<HTMLDivElement> {
     prefixCls?: string;
 }
-export declare function Controls(props: ControlsProps): React.JSX.Element;
+export declare function Controls({ className, ...props }: ControlsProps): React.ReactElement;
 export declare namespace Controls {
     var displayName: string;
 }

package/dist/esm/components/Form/Controls.js

@@ -2,10 +2,10 @@ import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
 import { FormContext } from '../../components/Form/context';
-export function Controls(props) {
+export function Controls({ className, ...props }) {
     const config = useConfig();
     const { getRootCls } = React.useContext(FormContext);
-    const { className, prefixCls = getRootCls(), ...restProps } = props;
+    const { prefixCls = getRootCls(), ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'controls'), [config, prefixCls]);
     return React.createElement("div", { className: classNames(rootCls, className), ...restProps });
 }

package/dist/esm/components/Form/ControlsText.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 export interface ControlsTextProps extends React.HTMLAttributes<HTMLDivElement> {
     prefixCls?: string;
 }
-export declare function ControlsText(props: ControlsTextProps): React.JSX.Element;
+export declare function ControlsText({ className, ...props }: ControlsTextProps): React.ReactElement;
 export declare namespace ControlsText {
     var displayName: string;
 }

package/dist/esm/components/Form/ControlsText.js

@@ -2,10 +2,10 @@ import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
 import { FormContext } from '../../components/Form/context';
-export function ControlsText(props) {
+export function ControlsText({ className, ...props }) {
     const config = useConfig();
     const { getRootCls } = React.useContext(FormContext);
-    const { className, prefixCls = getRootCls(), ...restProps } = props;
+    const { prefixCls = getRootCls(), ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'controls-text'), [config, prefixCls]);
     return React.createElement("div", { className: classNames(rootCls, className), ...restProps });
 }

package/dist/esm/components/Form/Fieldset.d.ts

@@ -3,7 +3,7 @@ export interface FieldsetProps extends React.FieldsetHTMLAttributes<HTMLFieldSet
     layout?: 'stacked' | 'horizontal';
     prefixCls?: string;
 }
-export declare function Fieldset(props: FieldsetProps): React.JSX.Element;
+export declare function Fieldset({ className, layout, ...props }: FieldsetProps): React.ReactElement;
 export declare namespace Fieldset {
     var displayName: string;
 }

package/dist/esm/components/Form/Fieldset.js

@@ -1,9 +1,9 @@
 import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
-export function Fieldset(props) {
+export function Fieldset({ className, layout, ...props }) {
     const config = useConfig();
-    const { className, layout, prefixCls = config.prefixCls, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'fieldset'), [config, prefixCls]);
     return (React.createElement("fieldset", { className: classNames(rootCls, {
             [`${rootCls}-${layout}`]: layout !== undefined,

package/dist/esm/components/Form/Form.d.ts

@@ -4,7 +4,7 @@ export interface FormOwnProps {
     layout?: 'stacked' | 'horizontal';
     prefixCls?: string;
 }
-export type FormProps<E extends React.ElementType = React.ElementType> = React.PropsWithChildren<FormOwnProps & PolymorphicProps<E>> & PolymorphicProps<E, FormOwnProps>;
+export type FormProps<E extends React.ElementType = React.ElementType> = FormOwnProps & PolymorphicProps<E> & PolymorphicProps<E, FormOwnProps>;
 declare const defaultElement = "form";
-export declare function Form<E extends React.ElementType = typeof defaultElement>(props: FormProps<E>): React.JSX.Element;
+export declare function Form<E extends React.ElementType = typeof defaultElement>({ className, component, layout, ...props }: React.PropsWithChildren<FormProps<E>>): React.ReactElement;
 export {};

package/dist/esm/components/Form/Form.js

@@ -4,9 +4,9 @@ import { Component } from '../../components/Component';
 import { useConfig } from '../../components/ConfigProvider';
 import { FormContext } from '../../components/Form/context';
 const defaultElement = 'form';
-export function Form(props) {
+export function Form({ className, component = defaultElement, layout, ...props }) {
     const config = useConfig();
-    const { className, layout, prefixCls = config.prefixCls, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'form'), [config, prefixCls]);
     const context = React.useMemo(() => ({
         getRootCls() {
@@ -16,5 +16,5 @@ export function Form(props) {
     return (React.createElement(FormContext.Provider, { value: context },
         React.createElement(Component, { className: classNames(rootCls, {
                 [`${rootCls}-${layout}`]: layout !== undefined,
-            }, className), component: defaultElement, ...restProps })));
+            }, className), component: component, ...restProps })));
 }

package/dist/esm/components/Form/Label.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 export interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
     prefixCls?: string;
 }
-export declare function Label(props: LabelProps): React.JSX.Element;
+export declare function Label({ className, ...props }: LabelProps): React.ReactElement;
 export declare namespace Label {
     var displayName: string;
 }

package/dist/esm/components/Form/Label.js

@@ -2,9 +2,9 @@ import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
 /* eslint-disable jsx-a11y/label-has-associated-control */
-export function Label(props) {
+export function Label({ className, ...props }) {
     const config = useConfig();
-    const { className, prefixCls, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'form-label'), [config, prefixCls]);
     return React.createElement("label", { className: classNames(rootCls, className), ...restProps });
 }

package/dist/esm/components/Form/Legend.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 export interface LegendProps extends React.HTMLAttributes<HTMLLegendElement> {
     prefixCls?: string;
 }
-export declare function Legend(props: LegendProps): React.JSX.Element;
+export declare function Legend({ className, ...props }: LegendProps): React.ReactElement;
 export declare namespace Legend {
     var displayName: string;
 }

package/dist/esm/components/Form/Legend.js

@@ -1,9 +1,9 @@
 import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
-export function Legend(props) {
+export function Legend({ className, ...props }) {
     const config = useConfig();
-    const { className, prefixCls = config.prefixCls, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'legend'), [config, prefixCls]);
     return React.createElement("legend", { className: classNames(rootCls, className), ...restProps });
 }

package/dist/esm/components/Form/context.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-export type FormContextConsumerProps = {
+export interface FormContextConsumerProps {
     getRootCls(): string | undefined;
-};
+}
 export declare const FormContext: React.Context<FormContextConsumerProps>;

package/dist/esm/components/Grid/index.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 import { type PolymorphicProps } from '../../components/Component';
 import { type ChildWidthBreakpointsConfig, type ChildWidthSize } from '../../components/Width';
 export type GridGap = 'collapse' | 'xsmall' | 'small' | 'medium' | 'large';
-export type GridOwnProps = {
+export interface GridOwnProps {
     childWidth?: ChildWidthSize | ChildWidthBreakpointsConfig;
     columnGap?: GridGap;
     divider?: boolean;
@@ -11,8 +11,8 @@ export type GridOwnProps = {
     match?: boolean;
     prefixCls?: string;
     rowGap?: GridGap;
-};
-export type GridProps<E extends React.ElementType = React.ElementType> = React.PropsWithChildren<GridOwnProps & PolymorphicProps<E>> & PolymorphicProps<E, GridOwnProps>;
+}
+export type GridProps<E extends React.ElementType = React.ElementType> = GridOwnProps & PolymorphicProps<E> & PolymorphicProps<E, GridOwnProps>;
 declare const defaultElement = "div";
-export declare function Grid<E extends React.ElementType = typeof defaultElement>(props: GridProps<E>): React.JSX.Element;
+export declare function Grid<E extends React.ElementType = typeof defaultElement>({ childWidth, className, columnGap, component, divider, gap, margin, match, rowGap, ...props }: React.PropsWithChildren<GridProps<E>>): React.ReactElement;
 export {};

package/dist/esm/components/Grid/index.js

@@ -4,9 +4,9 @@ import { Component } from '../../components/Component';
 import { useConfig } from '../../components/ConfigProvider';
 import { getChildWidthClassname } from '../../components/Width';
 const defaultElement = 'div';
-export function Grid(props) {
+export function Grid({ childWidth, className, columnGap, component = defaultElement, divider, gap, margin, match, rowGap, ...props }) {
     const config = useConfig();
-    const { childWidth, className, columnGap, divider, gap, margin, match, prefixCls = config.prefixCls, rowGap, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const childWithClassName = React.useMemo(() => getChildWidthClassname(childWidth), [childWidth]);
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'grid'), [config, prefixCls]);
     return (React.createElement(Component, { className: classNames(rootCls, {
@@ -16,5 +16,5 @@ export function Grid(props) {
             [`${rootCls}-margin-${margin}`]: margin !== undefined,
             [`${rootCls}-match`]: match,
             [`${rootCls}-row-${rowGap}`]: rowGap !== undefined,
-        }, childWithClassName, className), component: defaultElement, "data-uk-grid": "margin: ", ...restProps }));
+        }, childWithClassName, className), component: component, "data-uk-grid": "margin: ", ...restProps }));
 }

package/dist/esm/components/Heading/index.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 import { type PolymorphicProps } from '../../components/Component';
-export type HeadingOwnProps = {
+export interface HeadingOwnProps {
     decoration?: 'bullet' | 'divider' | 'line';
     prefixCls?: string;
     size?: 'small' | 'medium' | 'large' | 'xlarge' | '2xlarge';
-};
-export type HeadingProps<E extends React.ElementType = React.ElementType> = React.PropsWithChildren<HeadingOwnProps & PolymorphicProps<E>> & PolymorphicProps<E, HeadingOwnProps>;
+}
+export type HeadingProps<E extends React.ElementType = React.ElementType> = HeadingOwnProps & PolymorphicProps<E> & PolymorphicProps<E, HeadingOwnProps>;
 declare const defaultElement = "div";
-export declare function Heading<E extends React.ElementType = typeof defaultElement>(props: HeadingProps<E>): React.JSX.Element;
+export declare function Heading<E extends React.ElementType = typeof defaultElement>({ children, className, decoration, size, ...props }: React.PropsWithChildren<HeadingProps<E>>): React.ReactElement;
 export declare namespace Heading {
     var displayName: string;
 }

package/dist/esm/components/Heading/index.js

@@ -3,9 +3,9 @@ import * as React from 'react';
 import { Component } from '../../components/Component';
 import { useConfig } from '../../components/ConfigProvider';
 const defaultElement = 'div';
-export function Heading(props) {
+export function Heading({ children, className, decoration, size, ...props }) {
     const config = useConfig();
-    const { children, className, decoration, prefixCls = config.prefixCls, size, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'heading'), [config, prefixCls]);
     return (React.createElement(Component, { className: classNames({
             [`${rootCls}-${decoration}`]: decoration !== undefined,

package/dist/esm/components/Icon/Button.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { type IconProps } from '../../components/Icon/Icon';
-export declare function Button(props: IconProps): React.JSX.Element;
+export declare function Button(props: IconProps): React.ReactElement;
 export declare namespace Button {
     var displayName: string;
 }

package/dist/esm/components/Icon/Icon.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 import { type PolymorphicProps } from '../../components/Component';
-export type IconOwnProps = {
+export interface IconOwnProps {
     icon: string;
     material?: boolean;
     mode?: 'button' | 'image' | 'link';
     prefixCls?: string;
     round?: boolean;
-};
-export type IconProps<E extends React.ElementType = React.ElementType> = React.PropsWithChildren<IconOwnProps & PolymorphicProps<E>> & PolymorphicProps<E, IconOwnProps>;
+}
+export type IconProps<E extends React.ElementType = React.ElementType> = IconOwnProps & PolymorphicProps<E> & PolymorphicProps<E, IconOwnProps>;
 declare const defaultElement = "span";
-export declare function Icon<E extends React.ElementType = typeof defaultElement>(props: IconProps<E>): React.JSX.Element | null;
+export declare function Icon<E extends React.ElementType = typeof defaultElement>({ children, className, component, icon, material, mode, round, type, ...props }: React.PropsWithChildren<IconProps<E>>): React.ReactElement | null;
 export {};

package/dist/esm/components/Icon/Icon.js

@@ -3,9 +3,9 @@ import * as React from 'react';
 import { Component } from '../../components/Component';
 import { useConfig } from '../../components/ConfigProvider';
 const defaultElement = 'span';
-export function Icon(props) {
+export function Icon({ children, className, component = defaultElement, icon, material = true, mode, round, type, ...props }) {
     const config = useConfig();
-    const { children, className, icon, material = true, mode, prefixCls = config.prefixCls, round, type, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'icon'), [config, prefixCls]);
     if (!icon) {
         return null;
@@ -15,5 +15,5 @@ export function Icon(props) {
             [`${rootCls}-button`]: type === 'button',
             [`${rootCls}-material`]: material,
             [`${rootCls}-round`]: material && round,
-        }, className), component: defaultElement, ...restProps }, material ? React.createElement("i", null, icon) : children));
+        }, className), component: component, ...restProps }, material ? React.createElement("i", null, icon) : children));
 }

package/dist/esm/components/Icon/Link.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { type IconProps } from '../../components/Icon/Icon';
-export declare function Link(props: IconProps): React.JSX.Element;
+export declare function Link(props: IconProps): React.ReactElement;
 export declare namespace Link {
     var displayName: string;
 }

package/dist/esm/components/Icon/index.d.ts

@@ -4,7 +4,7 @@ import { type IconOwnProps, type IconProps } from '../../components/Icon/Icon';
 import { Link } from '../../components/Icon/Link';
 export * from '../../components/Icon/default-svg-props';
 export * from '../../components/Icon/get-size';
-export type { IconProps, IconOwnProps };
+export type { IconOwnProps, IconProps };
 export interface Icon extends React.FunctionComponent<IconProps> {
     Button: typeof Button;
     Link: typeof Link;

package/dist/esm/components/Iconnav/Iconnav.d.ts

@@ -3,4 +3,4 @@ export interface IconnavProps extends React.HTMLAttributes<HTMLUListElement> {
     prefixCls?: string;
     vertical?: boolean;
 }
-export declare function Iconnav(props: IconnavProps): React.JSX.Element;
+export declare function Iconnav({ className, vertical, ...props }: IconnavProps): React.ReactElement;

package/dist/esm/components/Iconnav/Iconnav.js

@@ -1,9 +1,9 @@
 import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
-export function Iconnav(props) {
+export function Iconnav({ className, vertical, ...props }) {
     const config = useConfig();
-    const { className, prefixCls = config.prefixCls, vertical, ...restProps } = props;
+    const { prefixCls = config.prefixCls, ...restProps } = props;
     const rootCls = React.useMemo(() => config.getRootPrefixCls(prefixCls || config.prefixCls, 'iconnav'), [config, prefixCls]);
     return (React.createElement("ul", { className: classNames(rootCls, {
             [`${rootCls}-vertical`]: vertical,

package/dist/esm/components/Iconnav/Item.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 export interface IconnavItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
     isActive?: boolean;
 }
-export declare function Item(props: IconnavItemProps): React.JSX.Element;
+export declare function Item({ children, className, isActive, ...props }: IconnavItemProps): React.ReactElement;
 export declare namespace Item {
     var displayName: string;
 }

package/dist/esm/components/Iconnav/Item.js

@@ -1,12 +1,11 @@
 import classNames from 'classnames';
 import * as React from 'react';
 import { useConfig } from '../../components/ConfigProvider';
-export function Item(props) {
+export function Item({ children, className, isActive, ...props }) {
     const config = useConfig();
-    const { children, className, isActive, ...restProps } = props;
     return (React.createElement("li", { className: classNames({
             [`${config.prefixCls}-active`]: isActive,
-        }, className), ...restProps }, children));
+        }, className), ...props }, children));
 }
 if (process.env.NODE_ENV !== 'production') {
     Item.displayName = 'Iconnav.Item';

package/dist/esm/components/Inverse/index.d.ts

@@ -16,8 +16,8 @@ export interface InverseProviderProps {
     primaryColorLight?: string;
     storageKey?: string;
 }
-export declare const lib: Record<ColorMode, () => React.JSX.Element>;
+export declare const lib: Record<ColorMode, () => React.ReactElement>;
 export declare const InverseContext: React.Context<InverseConfig | null>;
 export declare function useInverse(): InverseConfig;
 export declare const INVERSE_STORAGE_KEY = "colorMode";
-export declare const InverseProvider: React.MemoExoticComponent<({ children, defaultColorMode, globalDarkClassName, globalLightClassName, primaryColorDark, primaryColorLight, storageKey, }: React.PropsWithChildren<InverseProviderProps>) => React.JSX.Element>;
+export declare function InverseProvider({ children, defaultColorMode, globalDarkClassName, globalLightClassName, primaryColorDark, primaryColorLight, storageKey, }: React.PropsWithChildren<InverseProviderProps>): React.ReactElement;

package/dist/esm/components/Inverse/index.js

@@ -19,7 +19,7 @@ export function useInverse() {
     return useContext(InverseContext);
 }
 export const INVERSE_STORAGE_KEY = 'colorMode';
-export const InverseProvider = React.memo(({ children, defaultColorMode = ColorMode.Dark, globalDarkClassName = 'tm-dark', globalLightClassName = 'tm-light', primaryColorDark, primaryColorLight, storageKey = INVERSE_STORAGE_KEY, }) => {
+export function InverseProvider({ children, defaultColorMode = ColorMode.Dark, globalDarkClassName = 'tm-dark', globalLightClassName = 'tm-light', primaryColorDark, primaryColorLight, storageKey = INVERSE_STORAGE_KEY, }) {
     const [colorMode, setColorMode] = React.useState(() => {
         const stored = storage.get(storageKey);
         return stored ? stored : defaultColorMode ?? ColorMode.Dark;
@@ -52,4 +52,4 @@ export const InverseProvider = React.memo(({ children, defaultColorMode = ColorM
         };
     }, [onChangeStorageValue]);
     return React.createElement(InverseContext.Provider, { value: context }, children);
-});
+}