@unicom-cloud/ui 0.8.41

package/types/image/interface.d.ts

@@ -0,0 +1,58 @@
+import { CSSProperties, HTMLAttributes, ImgHTMLAttributes, ReactElement, ReactNode, SyntheticEvent } from 'react';
+export interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'className'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    src?: string;
+    width?: string | number;
+    height?: string | number;
+    title?: string;
+    description?: string;
+    actions?: ReactNode[];
+    footerPosition?: 'inner' | 'outer';
+    simple?: boolean;
+    loader?: boolean | ReactNode;
+    loaderClassName?: string | string[];
+    error?: ReactNode;
+    preview?: boolean;
+    previewProps?: PartialImagePreviewProps;
+    index?: number;
+    lazyload?: boolean | IntersectionObserverInit;
+    onLoad?: (ev: SyntheticEvent<HTMLImageElement>) => void;
+    onError?: (ev: SyntheticEvent<HTMLImageElement>) => void;
+}
+export interface ImagePreviewProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    src: string;
+    imgAttributes?: Omit<ImgHTMLAttributes<HTMLImageElement>, 'src'>;
+    extra?: ReactNode;
+    visible?: boolean;
+    defaultVisible?: boolean;
+    breakPoint?: number;
+    maskClosable?: boolean;
+    closable?: boolean;
+    actions?: ImagePreviewActionProps[];
+    actionsLayout?: string[];
+    scales?: number[];
+    onVisibleChange?: (visible: boolean, preVisible: boolean) => void;
+    getPopupContainer?: () => HTMLElement;
+    escToExit?: boolean;
+    imageRender?: (originalNode: ReactElement) => ReactNode;
+    resetTranslate?: boolean;
+}
+export type PartialImagePreviewProps = Partial<ImagePreviewProps>;
+export interface ImagePreviewGroupProps extends Omit<PartialImagePreviewProps, 'src'> {
+    srcList?: string[];
+    current?: number;
+    defaultCurrent?: number;
+    infinite?: boolean;
+    forceRender?: boolean;
+    onChange?: (index: number) => void;
+}
+export interface ImagePreviewActionProps extends HTMLAttributes<HTMLDivElement> {
+    key: string;
+    content: ReactNode;
+    getContainer?: (actionElement: ReactNode) => ReactNode;
+    name?: string;
+    disabled?: boolean;
+}

package/types/image/previewGroupContext.d.ts

@@ -0,0 +1,24 @@
+import type { ImagePreviewProps } from './interface';
+export interface PreviewUrl {
+    url: string;
+    preview: boolean;
+}
+export type PreviewUrlMap = Map<number, PreviewUrl>;
+export type UnRegisterPreviewUrl = (id: number) => void;
+export type UnRegisterPreviewProps = (id: number) => void;
+export type RegisterPreviewUrl = (id: number, url: string, preview: boolean) => UnRegisterPreviewUrl;
+export type RegisterPreviewProps = (id: number, previewProps?: Partial<ImagePreviewProps>) => UnRegisterPreviewProps;
+export interface PreviewGroupContextProps {
+    previewGroup: boolean;
+    previewUrlMap: Map<number, string>;
+    previewPropsMap: Map<number, Partial<ImagePreviewProps>>;
+    infinite?: boolean;
+    currentIndex: number;
+    setCurrentIndex: (current: number) => void;
+    setPreviewUrlMap: (map: PreviewUrlMap) => void;
+    registerPreviewUrl: RegisterPreviewUrl;
+    registerPreviewProps: RegisterPreviewProps;
+    visible: boolean;
+    handleVisibleChange: (visible: boolean, preVisible?: boolean) => void;
+}
+export declare const PreviewGroupContext: import("react").Context<PreviewGroupContextProps>;

package/types/image/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/image/util/getFixTranslate.d.ts

@@ -0,0 +1 @@
+export default function getFixTranslate(wrapperRect: DOMRect, imgRect: DOMRect, translateX: number, translateY: number, scale: number): [number, number];

package/types/image/util/getScale.d.ts

@@ -0,0 +1,13 @@
+export declare const defaultScales: number[];
+type ZoomType = 'zoomIn' | 'zoomOut';
+declare class PreviewScales {
+    private scaleAttr;
+    constructor(scales: number[]);
+    get scales(): any;
+    get minScale(): any;
+    get maxScale(): any;
+    updateScale(scales: number[]): void;
+    private findClosestIndex;
+    getNextScale(cur: number, type?: ZoomType): number;
+}
+export default PreviewScales;

package/types/image/util/hook/useImageStatus.d.ts

@@ -0,0 +1,11 @@
+type ImageStatusType = 'beforeLoad' | 'loading' | 'error' | 'loaded' | 'lazyload';
+export default function useImageStatus(defaultValue: ImageStatusType): {
+    status: ImageStatusType;
+    isBeforeLoad: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    isLoaded: boolean;
+    isLazyLoad: boolean;
+    setStatus: import("react").Dispatch<import("react").SetStateAction<ImageStatusType>>;
+};
+export {};

package/types/image/util/hook/useShowFooter.d.ts

@@ -0,0 +1,8 @@
+import { ImageProps } from '../../../image/interface';
+interface ShowFooterProps {
+    title: ImageProps['title'];
+    description: ImageProps['description'];
+    actions: ImageProps['actions'];
+}
+export default function useShowFooter(props: ShowFooterProps): (string | number | undefined)[];
+export {};

package/types/index.d.ts

@@ -0,0 +1,197 @@
+export { default as useAsync } from "./hooks/useAsync";
+export { default as useAsyncFn } from "./hooks/useAsyncFn";
+export { default as useAsyncRetry } from "./hooks/useAsyncRetry";
+export { default as useAudio } from "./hooks/useAudio";
+export { default as useBeforeUnload } from "./hooks/useBeforeUnload";
+export { default as useBoolean } from "./hooks/useBoolean";
+export { default as useClickAway } from "./hooks/useClickAway";
+export { default as useComputedState } from "./hooks/useComputedState";
+export { default as useCopyToClipboard } from "./hooks/useCopyToClipboard";
+export { default as useCounter } from "./hooks/useCounter";
+export { default as useCreation } from "./hooks/useCreation";
+export { default as useCustomCompareEffect } from "./hooks/useCustomCompareEffect";
+export { default as useDebounce } from "./hooks/useDebounce";
+export { default as useDefault } from "./hooks/useDefault";
+export { default as useDrop } from "./hooks/useDrop";
+export { default as useDropArea } from "./hooks/useDropArea";
+export { default as useEffectOnce } from "./hooks/useEffectOnce";
+export { default as useEffectState } from "./hooks/useEffectState";
+export { default as useEnsuredForwardedRef } from "./hooks/useEnsuredForwardedRef";
+export { default as useError } from "./hooks/useError";
+export { default as useEvent } from "./hooks/useEvent";
+export { default as useEventListener } from "./hooks/useEventListener";
+export { default as useFavicon } from "./hooks/useFavicon";
+export { default as useFirstMountState } from "./hooks/useFirstMountState";
+export { default as useForceUpdate } from "./hooks/useForceUpdate";
+export { default as useFullscreen } from "./hooks/useFullscreen";
+export { default as useGeolocation } from "./hooks/useGeolocation";
+export { default as useGetSet } from "./hooks/useGetSet";
+export { default as useGetSetState } from "./hooks/useGetSetState";
+export { default as useHash } from "./hooks/useHash";
+export { default as useHover } from "./hooks/useHover";
+export { default as useHoverDirty } from "./hooks/useHoverDirty";
+export { default as useId } from "./hooks/useId";
+export { default as useIdle } from "./hooks/useIdle";
+export { default as useInView } from "./hooks/useInView";
+export { default as useIntersection } from "./hooks/useIntersection";
+export { default as useIntersectionObserver } from "./hooks/useIntersectionObserver";
+export { default as useInterval } from "./hooks/useInterval";
+export { default as useIsFirstRender } from "./hooks/useIsFirstRender";
+export { default as useIsomorphicLayoutEffect } from "./hooks/useIsomorphicLayoutEffect";
+export { default as useKey } from "./hooks/useKey";
+export { default as useKeyPress } from "./hooks/useKeyPress";
+export { default as useKeyPressEvent } from "./hooks/useKeyPressEvent";
+export { default as useKeyboardEvent } from "./hooks/useKeyboardEvent";
+export { default as useLatest } from "./hooks/useLatest";
+export { default as useLifecycles } from "./hooks/useLifecycles";
+export { default as useList } from "./hooks/useList";
+export { default as useLocalStorage } from "./hooks/useLocalStorage";
+export { default as useLocation } from "./hooks/useLocation";
+export { default as useLockBodyScroll } from "./hooks/useLockBodyScroll";
+export { default as useLogger } from "./hooks/useLogger";
+export { default as useLongPress } from "./hooks/useLongPress";
+export { default as useMap } from "./hooks/useMap";
+export { default as useMeasure } from "./hooks/useMeasure";
+export { default as useMeasureDirty } from "./hooks/useMeasureDirty";
+export { default as useMedia } from "./hooks/useMedia";
+export { default as useMediaDevices } from "./hooks/useMediaDevices";
+export { default as useMediatedState } from "./hooks/useMediatedState";
+export { default as useMergeProps } from "./hooks/useMergeProps";
+export { default as useMergeValue } from "./hooks/useMergeValue";
+export { default as useMethods } from "./hooks/useMethods";
+export { default as useMotion } from "./hooks/useMotion";
+export { default as useMount } from "./hooks/useMount";
+export { default as useMountedState } from "./hooks/useMountedState";
+export { default as useMouse } from "./hooks/useMouse";
+export { default as useMouseHovered } from "./hooks/useMouseHovered";
+export { default as useMouseWheel } from "./hooks/useMouseWheel";
+export { default as useMultiStateValidator } from "./hooks/useMultiStateValidator";
+export { default as useNetworkState } from "./hooks/useNetworkState";
+export { default as useNumber } from "./hooks/useNumber";
+export { default as useObservable } from "./hooks/useObservable";
+export { default as useOrientation } from "./hooks/useOrientation";
+export { default as useOverflowHidden } from "./hooks/useOverflowHidden";
+export { default as usePageLeave } from "./hooks/usePageLeave";
+export { default as usePermission } from "./hooks/usePermission";
+export { default as usePinchZoom } from "./hooks/usePinchZoom";
+export { default as usePrevious } from "./hooks/usePrevious";
+export { default as usePreviousDistinct } from "./hooks/usePreviousDistinct";
+export { default as usePromise } from "./hooks/usePromise";
+export { default as useQueue } from "./hooks/useQueue";
+export { default as useRaf } from "./hooks/useRaf";
+export { default as useRafLoop } from "./hooks/useRafLoop";
+export { default as useRafState } from "./hooks/useRafState";
+export { default as useReactive } from "./hooks/useReactive";
+export { default as useRefs } from "./hooks/useRefs";
+export { default as useRendersCount } from "./hooks/useRendersCount";
+export { default as useScroll } from "./hooks/useScroll";
+export { default as useScrolling } from "./hooks/useScrolling";
+export { default as useSearchParam } from "./hooks/useSearchParam";
+export { default as useSessionStorage } from "./hooks/useSessionStorage";
+export { default as useSet } from "./hooks/useSet";
+export { default as useSetState } from "./hooks/useSetState";
+export { default as useSize } from "./hooks/useSize";
+export { default as useSlider } from "./hooks/useSlider";
+export { default as useSpeech } from "./hooks/useSpeech";
+export { default as useStartTyping } from "./hooks/useStartTyping";
+export { default as useStateCallback } from "./hooks/useStateCallback";
+export { default as useStateList } from "./hooks/useStateList";
+export { default as useStateValidator } from "./hooks/useStateValidator";
+export { default as useStateWithHistory } from "./hooks/useStateWithHistory";
+export { default as useStateWithPromise } from "./hooks/useStateWithPromise";
+export { default as useSyncState } from "./hooks/useSyncState";
+export { default as useThrottle } from "./hooks/useThrottle";
+export { default as useThrottleFn } from "./hooks/useThrottleFn";
+export { default as useTimeout } from "./hooks/useTimeout";
+export { default as useTimeoutFn } from "./hooks/useTimeoutFn";
+export { default as useTitle } from "./hooks/useTitle";
+export { default as useToggle } from "./hooks/useToggle";
+export { default as useTween } from "./hooks/useTween";
+export { default as useUnmount } from "./hooks/useUnmount";
+export { default as useUnmountPromise } from "./hooks/useUnmountPromise";
+export { default as useUpdate } from "./hooks/useUpdate";
+export { default as useUpdateEffect } from "./hooks/useUpdateEffect";
+export { default as useUpdateTimeout } from "./hooks/useUpdateTimeout";
+export { default as useUpsert } from "./hooks/useUpsert";
+export { default as useVibrate } from "./hooks/useVibrate";
+export { default as useVideo } from "./hooks/useVideo";
+export { default as useWatch } from "./hooks/useWatch";
+export { default as useWindowScroll } from "./hooks/useWindowScroll";
+export { default as useWindowSize } from "./hooks/useWindowSize";
+export { default as className } from "./utils/className";
+export { default as Affix } from "./affix";
+export { default as Alert } from "./alert";
+export { default as Anchor } from "./anchor";
+export { default as AutoComplete } from "./auto-complete";
+export { default as Avatar } from "./avatar";
+export { default as BackTop } from "./back-top";
+export { default as Badge } from "./badge";
+export { default as Breadcrumb } from "./breadcrumb";
+export { default as Button } from "./button";
+export { default as Calendar } from "./calendar";
+export { default as Card } from "./card";
+export { default as Carousel } from "./carousel";
+export { default as Cascader } from "./cascader";
+export { default as Checkbox } from "./checkbox";
+export { default as Collapse } from "./collapse";
+export { default as Comment } from "./comment";
+export { default as Copy } from "./copy";
+export { default as DatePicker } from "./date-picker";
+export { default as Descriptions } from "./descriptions";
+export { default as Divider } from "./divider";
+export { default as Drawer } from "./drawer";
+export { default as Dropdown } from "./dropdown";
+export { default as Empty } from "./empty";
+export { default as Form } from "./form";
+export { default as Grid } from "./grid";
+export { default as Icon } from "./icon";
+export { default as Image } from "./image";
+export { default as Input } from "./input";
+export { default as InputNumber } from "./input-number";
+export { default as InputTag } from "./input-tag";
+export { default as Layout } from "./layout";
+export { default as Link } from "./link";
+export { default as List } from "./list";
+export { default as Mentions } from "./mentions";
+export { default as Menu } from "./menu";
+export { default as Message } from "./message";
+export { default as Modal } from "./modal";
+export { default as Notification } from "./notification";
+export { default as PageHeader } from "./page-header";
+export { default as Pagination } from "./pagination";
+export { default as Popconfirm } from "./popconfirm";
+export { default as Popover } from "./popover";
+export { default as Portal } from "./portal";
+export { default as Progress } from "./progress";
+export { default as ColorPicker } from "./color-picker";
+export { default as Loading } from "./loading";
+export { default as Radio } from "./radio";
+export { default as Rate } from "./rate";
+export { default as ResizeBox } from "./resize-box";
+export { default as Result } from "./result";
+export { default as Select } from "./select";
+export { default as Skeleton } from "./skeleton";
+export { default as Slider } from "./slider";
+export { default as Space } from "./space";
+export { default as SpeechSynthesis } from "./speech-synthesis";
+export { default as Spin } from "./spin";
+export { default as Statistic } from "./statistic";
+export { default as Steps } from "./steps";
+export { default as SuspenseFallbackTest } from "./suspense-fallback-test";
+export { default as Switch } from "./switch";
+export { default as Table } from "./table";
+export { default as Tabs } from "./tabs";
+export { default as Tag } from "./tag";
+export { default as TimePicker } from "./time-picker";
+export { default as Timeline } from "./timeline";
+export { default as Tooltip } from "./tooltip";
+export { default as Transfer } from "./transfer";
+export { default as Tree } from "./tree";
+export { default as TreeSelect } from "./tree-select";
+export { default as Trigger } from "./trigger";
+export { default as Typography } from "./typography";
+export { default as Upload } from "./upload";
+export { default as VerificationCode } from "./verification-code";
+export { default as Version } from "./version";
+export { default as Watermark } from "./watermark";
+export { ConfigConsumer, ConfigContext, default as ConfigProvider } from "./config-provider";

package/types/input/Group.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { InputGroupProps } from './interface';
+declare const Group: React.ForwardRefExoticComponent<InputGroupProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export default Group;
+export type { InputGroupProps };

package/types/input/Input.d.ts

@@ -0,0 +1,23 @@
+import React, { ForwardRefExoticComponent } from 'react';
+import { MergePropsOptions } from '../hooks/useMergeProps';
+import Group from './Group';
+import InputNumber from './Number';
+import Password from './Password';
+import Search from './Search';
+import InputTag from './Tag';
+import TextArea from './Textarea';
+import type { InputProps, RefInputType } from './interface';
+export declare function formatValue(value: any, maxLength: any): any;
+type InputRefType = ForwardRefExoticComponent<InputProps & React.RefAttributes<RefInputType> & MergePropsOptions> & {
+    Search: typeof Search;
+    TextArea: typeof TextArea;
+    Password: typeof Password;
+    Number: typeof InputNumber;
+    InputNumber: typeof InputNumber;
+    Tag: typeof InputTag;
+    InputTag: typeof InputTag;
+    Group: typeof Group;
+};
+declare const InputElement: InputRefType;
+export type InputRef = InputRefType;
+export default InputElement;

package/types/input/InputElement.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { InputComponentProps, RefInputType } from './interface';
+declare const InputComponent: React.ForwardRefExoticComponent<InputComponentProps & React.RefAttributes<RefInputType>>;
+export default InputComponent;

package/types/input/Number.d.ts

@@ -0,0 +1,2 @@
+import InputNumber from '../input-number';
+export default InputNumber;

package/types/input/Password.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { InputPasswordProps, RefInputType } from './interface';
+declare const Password: React.ForwardRefExoticComponent<InputPasswordProps & React.RefAttributes<RefInputType>>;
+export default Password;
+export type { InputPasswordProps };

package/types/input/Search.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { InputSearchProps, RefInputType } from './interface';
+declare const Search: React.ForwardRefExoticComponent<InputSearchProps & React.RefAttributes<RefInputType>>;
+export default Search;
+export type { InputSearchProps };

package/types/input/Tag.d.ts

@@ -0,0 +1,2 @@
+import InputTag from '../input-tag';
+export default InputTag;

package/types/input/Textarea.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { TextAreaProps } from './interface';
+export type RefTextAreaType = {
+    blur: () => void;
+    focus: () => void;
+    dom: HTMLTextAreaElement;
+};
+declare const TextAreaRef: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<RefTextAreaType>>;
+export default TextAreaRef;

package/types/input/autoSizeTextAreaHeight.d.ts

@@ -0,0 +1,5 @@
+declare function autoSizeTextAreaHeight(autoSize?: boolean | {
+    minRows?: number;
+    maxRows?: number;
+}, node?: HTMLTextAreaElement): any;
+export default autoSizeTextAreaHeight;

package/types/input/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import Input from './Input';
+import type { InputProps, RefInputType, TextAreaProps } from './interface';
+import { InputPasswordProps } from './Password';
+import { InputSearchProps } from './Search';
+import { RefTextAreaType } from './Textarea';
+export type { InputPasswordProps, InputProps, InputSearchProps, RefInputType, RefTextAreaType, TextAreaProps, };
+export default Input;

package/types/input/interface.d.ts

@@ -0,0 +1,93 @@
+import { CSSProperties, InputHTMLAttributes, ReactNode, TextareaHTMLAttributes } from 'react';
+import { Omit } from '../utils/type';
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'prefix' | 'className' | 'size' | 'height' | 'maxLength'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    allowClear?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    defaultValue?: string;
+    placeholder?: string;
+    error?: boolean;
+    status?: 'error' | 'warning';
+    autoWidth?: boolean | {
+        minWidth?: CSSProperties['minWidth'];
+        maxWidth?: CSSProperties['maxWidth'];
+    };
+    onChange?: (value: string, e: any) => void;
+    onClear?: () => void;
+    onPressEnter?: (e: any) => void;
+    normalizeTrigger?: ('onBlur' | 'onPressEnter')[];
+    normalize?: (value: string) => string;
+    addBefore?: ReactNode;
+    addAfter?: ReactNode;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    value?: string;
+    beforeStyle?: object;
+    afterStyle?: object;
+    size?: 'mini' | 'small' | 'default' | 'large';
+    height?: number | string;
+    maxLength?: number | {
+        length: number;
+        errorOnly?: boolean;
+    };
+    showWordLimit?: boolean;
+    clearIcon?: ReactNode;
+}
+export interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange' | 'className' | 'maxLength'> {
+    style?: CSSProperties;
+    wrapperStyle?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    defaultValue?: string;
+    value?: string;
+    autoSize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    error?: boolean;
+    status?: 'error' | 'warning';
+    placeholder?: string;
+    onChange?: (value: string, e: any) => void;
+    onPressEnter?: (e: any) => void;
+    maxLength?: number | {
+        length: number;
+        errorOnly?: boolean;
+    };
+    showWordLimit?: boolean;
+    allowClear?: boolean;
+    onClear?: () => void;
+    clearIcon?: ReactNode;
+}
+export interface InputGroupProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    compact?: boolean;
+}
+export interface InputSearchProps extends InputProps {
+    loading?: boolean;
+    onSearch?: (value: string) => void;
+    searchButton?: boolean | ReactNode;
+}
+export interface InputPasswordProps extends InputProps {
+    visibilityToggle?: boolean;
+    defaultVisibility?: boolean;
+    visibility?: boolean;
+    onVisibilityChange?: (visibility: boolean) => void;
+}
+export interface InputComponentProps extends InputProps {
+    prefixCls?: string;
+    hasParent?: boolean;
+    autoFitWidth?: boolean | {
+        minWidth?: CSSProperties['minWidth'];
+        maxWidth?: CSSProperties['maxWidth'];
+        pure?: boolean;
+        delay: number | ((width: number, prevWidth: number) => number);
+    };
+}
+export type RefInputType = {
+    blur: () => void;
+    focus: () => void;
+    dom: HTMLInputElement;
+};

package/types/input/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../button/style';
+import '../../style/index.less';
+import './index.less';

package/types/input/useComposition.d.ts

@@ -0,0 +1,17 @@
+import { ChangeEventHandler, CompositionEventHandler, KeyboardEventHandler } from 'react';
+import type { InputProps, TextAreaProps } from './interface';
+export default function useComposition({ value, maxLength, onChange, onKeyDown, onPressEnter, beforeTriggerValueChangeCallback, normalizeHandler, }: {
+    value: string;
+    maxLength: number;
+    onChange: InputProps['onChange'];
+    onKeyDown: InputProps['onKeyDown'] | TextAreaProps['onKeyDown'];
+    onPressEnter: InputProps['onPressEnter'];
+    beforeTriggerValueChangeCallback?: (newValue: string) => void;
+    normalizeHandler?: (type: InputProps['normalizeTrigger'][number]) => InputProps['normalize'];
+}): {
+    compositionValue: string;
+    triggerValueChangeCallback: typeof onChange;
+    compositionHandler: CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    valueChangeHandler: ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    keyDownHandler: KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+};

package/types/input-number/decimal.d.ts

@@ -0,0 +1,16 @@
+export interface Decimal {
+    readonly isEmpty: boolean;
+    readonly isNaN: boolean;
+    readonly isInvalid: boolean;
+    toNumber: () => number;
+    toString: (option?: {
+        safe: boolean;
+        precision?: number;
+    }) => string;
+    equals: (target: Decimal) => boolean;
+    less: (target: Decimal) => boolean;
+    negate: () => Decimal;
+    add: (target: string | number) => Decimal;
+}
+export declare function getDecimal(value: string | number): Decimal;
+export declare function toFixed(numStr: string, precision?: number, cutOnly?: boolean): string;

package/types/input-number/index.d.ts

@@ -0,0 +1,7 @@
+import './style';
+import React from 'react';
+import { RefInputType } from '../input/interface';
+import type { InputNumberProps } from './interface';
+declare const InputNumberComponent: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<RefInputType>>;
+export default InputNumberComponent;
+export type { InputNumberProps };

package/types/input-number/interface.d.ts

@@ -0,0 +1,37 @@
+import { CSSProperties, InputHTMLAttributes, ReactNode } from 'react';
+export type InputNumberValueChangeReason = 'manual' | 'increase' | 'decrease' | 'outOfRange';
+export interface InputNumberProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'prefix' | 'className' | 'size' | 'onChange' | 'onKeyDown'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    step?: number;
+    precision?: number;
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    strictMode?: boolean;
+    defaultValue?: number | string;
+    value?: undefined | number | string;
+    placeholder?: string;
+    mode?: 'embed' | 'button';
+    size?: 'mini' | 'small' | 'default' | 'large';
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    formatter?: (value: number | string, info: {
+        userTyping: boolean;
+        input: string;
+    }) => string;
+    parser?: (value: string) => number | string;
+    onChange?: (value: number, reason?: InputNumberValueChangeReason) => void;
+    onFocus?: (e: any) => void;
+    onBlur?: (e: any) => void;
+    onKeyDown?: (e: Event) => void;
+    hideControl?: boolean;
+    icons?: {
+        up?: ReactNode;
+        down?: ReactNode;
+        plus?: ReactNode;
+        minus?: ReactNode;
+    };
+}

package/types/input-number/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../input/style';
+import '../../style/index.less';
+import './index.less';

package/types/input-number/useSelectionRange.d.ts

@@ -0,0 +1,4 @@
+export default function useSelectionRange({ inputElement, inputValue, }: {
+    inputElement: HTMLInputElement;
+    inputValue: string;
+}): (e: any) => void;

package/types/input-number/util.d.ts

@@ -0,0 +1,13 @@
+export declare function isE(number: string | number): boolean;
+export declare function supportBigInt(): boolean;
+export declare function getNumberPrecision(number: string | number): number;
+export declare function toSafeString(number: number | string): string;
+export declare function validateNumber(num: string | number): boolean;
+export declare function trimNumber(numStr: string): {
+    negative: boolean;
+    negativeStr: string;
+    trimStr: string;
+    integerStr: string;
+    decimalStr: string;
+    fullStr: string;
+};

package/types/input-tag/InputTag.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { InputTagProps } from './interface';
+type InputTagHandle = {
+    focus: () => void;
+    blur: () => void;
+};
+declare const InputTagRef: React.ForwardRefExoticComponent<InputTagProps<any> & React.RefAttributes<InputTagHandle>>;
+export default InputTagRef;
+export type { InputTagProps };

package/types/input-tag/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import InputTag, { InputTagProps } from './InputTag';
+export default InputTag;
+export type { InputTagProps };