@unicom-cloud/ui 0.8.41

package/types/date-picker/panel/month/index.d.ts

@@ -0,0 +1,17 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { ModeType, MonthPickerProps, PrivateCType } from '../../../date-picker/interface';
+interface InnerMonthPickerProps extends MonthPickerProps {
+    rangeValues?: Dayjs[];
+    onMouseEnterCell?: (time: Dayjs, disabled: boolean) => void;
+    onMouseLeaveCell?: (time: Dayjs, disabled: boolean) => void;
+    dateRender?: (currentDate: Dayjs) => ReactNode;
+    pageShowDate?: Dayjs;
+    isRangePicker?: boolean;
+    onSuperPrev?: () => void;
+    onSuperNext?: () => void;
+    panelMode?: ModeType;
+    setPanelMode?: (mode: ModeType) => void;
+}
+declare function MonthPicker(props: InnerMonthPickerProps & PrivateCType): import("react/jsx-dev-runtime").JSX.Element;
+export default MonthPicker;

package/types/date-picker/panel/quarter/index.d.ts

@@ -0,0 +1,17 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { ModeType, PrivateCType, QuarterPickerProps } from '../../../date-picker/interface';
+interface InnerQuarterPickerProps extends QuarterPickerProps {
+    rangeValues?: Dayjs[];
+    onMouseEnterCell?: (time: Dayjs, disabled: boolean) => void;
+    onMouseLeaveCell?: (time: Dayjs, disabled: boolean) => void;
+    dateRender?: (currentDate: Dayjs) => ReactNode;
+    pageShowDate?: Dayjs;
+    isRangePicker?: boolean;
+    onSuperPrev?: () => void;
+    onSuperNext?: () => void;
+    panelMode?: ModeType;
+    setPanelMode?: (mode: ModeType) => void;
+}
+declare function QuarterPicker(props: InnerQuarterPickerProps & PrivateCType): import("react/jsx-dev-runtime").JSX.Element;
+export default QuarterPicker;

package/types/date-picker/panel/range/index.d.ts

@@ -0,0 +1,28 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { IconsType, ModeType, PrivateCType, RangePickerProps } from '../../../date-picker/interface';
+interface InnerRangePickerProps extends RangePickerProps {
+    disabledDate?: (current: Dayjs) => boolean;
+    dateRender?: (currentDate: Dayjs) => ReactNode;
+    icons?: IconsType;
+    locale?: Record<string, any>;
+    pageShowDates?: Dayjs[];
+    onSelectPanel?: (dateString: string, date: Dayjs) => void;
+    onMouseEnterCell?: (time: Dayjs, disabled: boolean) => void;
+    onMouseLeaveCell?: (time: Dayjs, disabled: boolean) => void;
+    onPrev?: () => void;
+    onSuperPrev?: () => void;
+    onNext?: () => void;
+    onSuperNext?: () => void;
+    localeName?: string;
+    onTimePickerSelect?: (index: number, timeString: string, time: Dayjs) => void;
+    setRangePageShowDates?: (dates: Dayjs[], index: number) => void;
+    disabledTimePickerIndex?: number;
+    timeValues?: Dayjs[];
+    isTimePanel?: boolean;
+    valueShowHover?: Dayjs[];
+    panelModes?: ModeType[];
+    setPanelModes?: (modes: ModeType[]) => void;
+}
+declare function RangePicker(props: InnerRangePickerProps & PrivateCType): import("react/jsx-dev-runtime").JSX.Element;
+export default RangePicker;

package/types/date-picker/panel/week/index.d.ts

@@ -0,0 +1,16 @@
+import { Dayjs } from 'dayjs';
+import { ModeType, PrivateCType, WeekPickerProps } from '../../../date-picker/interface';
+interface InnerWeekPickerProps extends WeekPickerProps {
+    isRangePicker?: boolean;
+    rangeValues?: Dayjs[];
+    pageShowDate?: Dayjs;
+    onPrev?: () => void;
+    onNext?: () => void;
+    onSuperPrev?: () => void;
+    onSuperNext?: () => void;
+    localeName?: string;
+    panelMode?: ModeType;
+    setPanelMode?: (mode: ModeType) => void;
+}
+declare function WeekPicker(props: InnerWeekPickerProps & PrivateCType): import("react/jsx-dev-runtime").JSX.Element;
+export default WeekPicker;

package/types/date-picker/panel/year/index.d.ts

@@ -0,0 +1,16 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { YearPickerProps } from '../../../date-picker/interface';
+interface InnerYearPickerProps extends YearPickerProps {
+    dateRender?: (currentDate: Dayjs) => ReactNode;
+    disabledDate?: (current: Dayjs) => boolean;
+    onMouseEnterCell?: (time: Dayjs, disabled: boolean) => void;
+    onMouseLeaveCell?: (time: Dayjs, disabled: boolean) => void;
+    pageShowDate?: Dayjs;
+    isRangePicker?: boolean;
+    rangeValues?: Dayjs[];
+    onSuperPrev?: () => void;
+    onSuperNext?: () => void;
+}
+declare function YearPicker(props: InnerYearPickerProps): import("react/jsx-dev-runtime").JSX.Element;
+export default YearPicker;

package/types/date-picker/style/index.d.ts

@@ -0,0 +1,7 @@
+import '../../button/style';
+import '../../link/style';
+import '../../picker/style/index.less';
+import '../../style/index.less';
+import '../../time-picker/style';
+import '../../trigger/style';
+import './index.less';

package/types/date-picker/util.d.ts

@@ -0,0 +1,9 @@
+import { Dayjs } from 'dayjs';
+export declare function isTimeArrayChange(prevTime: Dayjs[], nextTime: Dayjs[]): boolean;
+export declare function getAvailableDayjsLength(value: any): 0 | 1 | 2;
+export declare function isDisabledDate(cellDate: any, disabledDate: any, mode: any): boolean;
+type WeekStartType = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export declare function getDefaultWeekStart(dayjsLocale: string): WeekStartType;
+export declare function getLocaleDayjsValue(date: Dayjs | undefined, dayjsLocale: string): Dayjs | undefined;
+export declare function getFormatByIndex(format: string | string[], index: number): string;
+export {};

package/types/descriptions/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import type { DescriptionsProps } from './interface';
+declare function Descriptions(baseProps: DescriptionsProps): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Descriptions {
+    var displayName: string;
+}
+export default Descriptions;
+export type { DescriptionsProps };

package/types/descriptions/interface.d.ts

@@ -0,0 +1,29 @@
+import React, { CSSProperties, ReactNode } from 'react';
+export type DataType = {
+    key?: React.Key;
+    label?: ReactNode;
+    value?: ReactNode;
+    span?: number;
+}[];
+export interface DescriptionsProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    labelStyle?: CSSProperties;
+    valueStyle?: CSSProperties;
+    data?: DataType;
+    column?: number | {
+        xs?: number;
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+        xxl?: number;
+        xxxl?: number;
+    };
+    title?: ReactNode;
+    colon?: ReactNode;
+    border?: boolean;
+    layout?: 'horizontal' | 'vertical' | 'inline-horizontal' | 'inline-vertical';
+    size?: 'mini' | 'small' | 'medium' | 'default' | 'large';
+    tableLayout?: 'auto' | 'fixed';
+}

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

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

package/types/divider/index.d.ts

@@ -0,0 +1,6 @@
+import './style';
+import React from 'react';
+import type { DividerProps } from './interface';
+declare const DividerComponent: React.ForwardRefExoticComponent<DividerProps & React.RefAttributes<unknown>>;
+export default DividerComponent;
+export type { DividerProps };

package/types/divider/interface.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface DividerProps {
+    children?: ReactNode;
+    style?: CSSProperties;
+    className?: string | string[];
+    type?: 'horizontal' | 'vertical';
+    orientation?: 'left' | 'right' | 'center';
+}

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

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

package/types/draggable/Item.d.ts

@@ -0,0 +1,3 @@
+import type { DraggableItemProps } from './interface';
+declare function Item(props: DraggableItemProps): import("react/jsx-dev-runtime").JSX.Element;
+export default Item;

package/types/draggable/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import type { DraggableProps } from './interface';
+declare function Draggable(props: DraggableProps): import("react/jsx-dev-runtime").JSX.Element;
+export default Draggable;

package/types/draggable/interface.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties, ReactNode } from 'react';
+export type DragStatus = 'none' | 'dragged' | 'dragging';
+export type DragPosition = 'left' | 'right' | 'top' | 'bottom';
+export interface DraggableItemProps extends Pick<DraggableProps, 'direction'> {
+    style?: CSSProperties;
+    prefixCls: string | undefined;
+    children?: ReactNode;
+    disabled?: boolean;
+    droppable?: boolean;
+    onDragStart?: (e: any) => void;
+    onDragEnd?: (e: any) => void;
+    onDragLeave?: (e: any) => void;
+    onDragOver?: (e: any) => void;
+    onDrop?: (e: any, dropPosition: DragPosition) => void;
+}
+export interface DraggableProps {
+    children?: ReactNode;
+    direction?: 'horizontal' | 'vertical';
+    className?: string | string[];
+    itemWrapperStyle?: CSSProperties;
+    onIndexChange?: (index: number, prevIndex: number) => void;
+}

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

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

package/types/drawer/Drawer.d.ts

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

package/types/drawer/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import Drawer from './Drawer';
+export default Drawer;
+export type { DrawerProps } from './interface';

package/types/drawer/interface.d.ts

@@ -0,0 +1,36 @@
+import { CSSProperties, MouseEvent, ReactNode } from 'react';
+import { ButtonProps } from '../button';
+export interface DrawerProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    zIndex?: number;
+    children?: ReactNode;
+    wrapClassName?: string | string[];
+    title?: ReactNode;
+    footer?: ReactNode;
+    headerStyle?: CSSProperties;
+    bodyStyle?: CSSProperties;
+    maskStyle?: CSSProperties;
+    okText?: ReactNode;
+    cancelText?: ReactNode;
+    okButtonProps?: ButtonProps;
+    cancelButtonProps?: ButtonProps;
+    placement?: 'top' | 'right' | 'bottom' | 'left';
+    width?: string | number;
+    height?: string | number;
+    escToExit?: boolean;
+    mask?: boolean;
+    visible?: boolean;
+    closable?: boolean;
+    closeIcon?: ReactNode;
+    maskClosable?: boolean;
+    confirmLoading?: boolean;
+    mountOnEnter?: boolean;
+    unmountOnExit?: boolean;
+    onOk?: (e: Event) => void;
+    onCancel?: (e: MouseEvent | Event) => void;
+    afterOpen?: () => void;
+    afterClose?: () => void;
+    getPopupContainer?: () => Element;
+    getChildrenPopupContainer?: (node: HTMLElement) => Element;
+}

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

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

package/types/dropdown/Button.d.ts

@@ -0,0 +1,4 @@
+import type { DropdownButtonProps } from './interface';
+declare const ButtonComponent: import("react").ForwardRefExoticComponent<DropdownButtonProps & import("react").RefAttributes<unknown>>;
+export default ButtonComponent;
+export type { DropdownButtonProps };

package/types/dropdown/index.d.ts

@@ -0,0 +1,9 @@
+import './style';
+import React from 'react';
+import Button from './Button';
+import type { DropdownProps } from './interface';
+declare const DropdownComponent: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<unknown>> & {
+    Button: typeof Button;
+};
+export default DropdownComponent;
+export type { DropdownProps };

package/types/dropdown/interface.d.ts

@@ -0,0 +1,28 @@
+import { CSSProperties, ReactNode } from 'react';
+import { ButtonProps } from '../button';
+import { TriggerProps } from '../trigger';
+export interface DropdownProps {
+    children?: ReactNode;
+    droplist?: ReactNode;
+    position?: 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br';
+    trigger?: TriggerProps['trigger'];
+    disabled?: boolean;
+    unmountOnExit?: boolean;
+    defaultPopupVisible?: boolean;
+    popupVisible?: boolean;
+    triggerProps?: Partial<TriggerProps>;
+    onVisibleChange?: (visible: boolean) => void;
+    getPopupContainer?: (node: HTMLElement) => Element;
+}
+export interface DropdownButtonProps extends Omit<DropdownProps, 'position'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    position?: 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br';
+    size?: 'mini' | 'small' | 'default' | 'large';
+    type?: 'default' | 'primary' | 'secondary' | 'dashed' | 'outline' | 'text';
+    buttonProps?: ButtonProps;
+    icon?: ReactNode;
+    buttonsRender?: (buttons: ReactNode[]) => ReactNode[];
+    onClick?: (e: Event) => void;
+    children?: ReactNode;
+}

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

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

package/types/empty/index.d.ts

@@ -0,0 +1,6 @@
+import './style';
+import React from 'react';
+import type { EmptyProps } from './interface';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<EmptyProps & React.RefAttributes<unknown>>>;
+export default _default;
+export type { EmptyProps };

package/types/empty/interface.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode, CSSProperties } from 'react';
+export interface EmptyProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    description?: ReactNode;
+    icon?: ReactNode;
+    imgSrc?: string;
+}

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

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

package/types/form/Control.d.ts

@@ -0,0 +1,55 @@
+import React, { Component, ReactNode } from 'react';
+import type { FieldError, FormControlProps, FormItemContextProps, FormItemProps, KeyType } from './interface';
+import { NotifyType, StoreChangeInfo } from './store';
+export default class Control<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> extends Component<FormControlProps<FormData, FieldValue, FieldKey>> {
+    static defaultProps: {
+        trigger: string;
+        triggerPropName: string;
+    };
+    static isFormControl: boolean;
+    static contextType: React.Context<FormItemContextProps>;
+    context: FormItemContextProps<FormData, FieldValue, FieldKey>;
+    private errors;
+    private warnings;
+    private validateStatus;
+    private touched;
+    private isDestroyed;
+    private childrenElement;
+    private removeRegisterField;
+    constructor(props: FormControlProps<FormData, FieldValue, FieldKey>, context: FormItemContextProps<FormData, FieldValue, FieldKey>);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    private triggerStateCollect;
+    private toggleValidateStatus;
+    private toggleTouched;
+    private setWarnings;
+    private setErrors;
+    getErrors: () => FieldError<FieldValue> | null;
+    getWarnings: () => ReactNode[];
+    isTouched: () => boolean;
+    getValidateStatus: () => FormItemProps['validateStatus'];
+    hasFieldProps: () => boolean;
+    private clearFormItemError;
+    private updateFormItem;
+    private getFieldValue;
+    onStoreChange: (type: NotifyType, info: StoreChangeInfo<FieldKey> & {
+        current: any;
+    }) => void;
+    innerSetFieldValue: (field: FieldKey, value: FieldValue) => void;
+    validateFieldOnly: () => Promise<{
+        error: FieldError<FieldValue> | null;
+        value: FieldValue;
+        field: FieldKey;
+    }>;
+    validateField: (triggerType?: string) => Promise<{
+        error: FieldError<FieldValue> | null;
+        value: FieldValue;
+        field: FieldKey;
+    }>;
+    getValidateTrigger(): string[];
+    handleTrigger: (_value: any, ...args: any[]) => void;
+    renderControl(children: React.ReactNode, id: any): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    getChild: () => React.ReactNode;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-dev-runtime").JSX.Element | null | undefined;
+}

package/types/form/Form.d.ts

@@ -0,0 +1,6 @@
+import React, { PropsWithChildren } from 'react';
+import type { FormInstance, FormProps, KeyType } from './interface';
+declare const _default: <FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData>(props: React.PropsWithChildren<FormProps<FormData, FieldValue, FieldKey>> & {
+    ref?: React.Ref<FormInstance<FormData, FieldValue, FieldKey>>;
+}) => React.ReactElement;
+export default _default;

package/types/form/FormItem.d.ts

@@ -0,0 +1,7 @@
+import React, { ReactElement } from 'react';
+import { FormItemProps, KeyType } from './interface';
+declare const Row: React.ForwardRefExoticComponent<import("../grid").RowProps & React.RefAttributes<unknown>>;
+declare const _default: <FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData>(props: FormItemProps<FormData, FieldValue, FieldKey> & {
+    ref?: React.Ref<(typeof Row)['prototype']>;
+}) => React.ReactElement;
+export default _default;

package/types/form/FormItemTip.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactNode } from 'react';
+import { FieldError, FormItemProps } from './interface';
+interface FormItemTipProps extends Pick<FormItemProps, 'prefixCls' | 'help'> {
+    errors: FieldError[];
+    warnings?: ReactNode[];
+}
+declare const FormItemTip: React.FC<FormItemTipProps>;
+export default FormItemTip;

package/types/form/FormLabel.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactNode } from 'react';
+import type { FormItemProps } from './interface';
+interface FormItemLabelProps extends Pick<FormItemProps, 'tooltip' | 'label' | 'requiredSymbol' | 'required' | 'rules'> {
+    showColon: boolean | ReactNode;
+    prefix: string | undefined;
+    htmlFor?: string;
+}
+declare const FormItemLabel: React.FC<FormItemLabelProps>;
+export default FormItemLabel;

package/types/form/FormList.d.ts

@@ -0,0 +1,6 @@
+import type { FormListProps, KeyType } from './interface';
+declare const List: {
+    <SubFieldValue extends unknown = any, SubFieldKey extends KeyType = string, FieldKey extends KeyType = string>(props: FormListProps<SubFieldValue, SubFieldKey, FieldKey>): import("react/jsx-dev-runtime").JSX.Element;
+    displayName: string;
+};
+export default List;

package/types/form/FormProvider.d.ts

@@ -0,0 +1,4 @@
+import { ForwardRefExoticComponent, PropsWithChildren } from 'react';
+import type { FormProviderProps } from './interface';
+declare const _default: ForwardRefExoticComponent<PropsWithChildren<FormProviderProps>>;
+export default _default;

package/types/form/IconSymbol.d.ts

@@ -0,0 +1,3 @@
+import { SVGProps } from 'react';
+import { JSX } from 'react/jsx-runtime';
+export default function IconUiCheck(props: JSX.IntrinsicAttributes & SVGProps<SVGSVGElement>): import("react/jsx-dev-runtime").JSX.Element;

package/types/form/context.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'react';
+import type { FormContextProps, FormInstance, FormItemContextProps, KeyType } from './interface';
+export type FormContextType<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Context<FormContextProps<FormData, FieldValue, FieldKey>>;
+export declare const FormContext: Context<FormContextProps>;
+export type FormItemContextType<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Context<FormItemContextProps<FormData, FieldValue, FieldKey>>;
+export declare const FormItemContext: Context<FormItemContextProps>;
+export declare const FormProviderContext: Context<{
+    register?: ((name: string, form: FormInstance) => void) | undefined;
+    onFormValuesChange?: ((id: string | undefined, changedValues: any) => void) | undefined;
+    onFormSubmit?: ((id: string | undefined, values: any) => void) | undefined;
+    onFormReset?: ((id: string | undefined, values: any) => void) | undefined;
+}>;
+export declare const FormListContext: Context<{
+    getItemKey?: ((key: any) => string) | undefined;
+}>;

package/types/form/hook/useContext.d.ts

@@ -0,0 +1,7 @@
+import { FormInstance } from '../../form/interface';
+declare const useFormContext: () => {
+    form: FormInstance;
+    disabled: boolean;
+    isSubmitting: boolean;
+};
+export default useFormContext;

package/types/form/hook/useState.d.ts

@@ -0,0 +1,3 @@
+import { FieldState, FormInstance, KeyType } from '../interface';
+declare const useFormState: <FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData>(field: FieldKey, form?: FormInstance) => FieldState<FieldValue> | undefined;
+export default useFormState;

package/types/form/hook/useWatch.d.ts

@@ -0,0 +1,3 @@
+import { FormInstance } from '../../form/interface';
+declare const useWatch: (field: string | string[], form?: FormInstance) => any;
+export default useWatch;

package/types/form/index.d.ts

@@ -0,0 +1,26 @@
+import './style';
+import Form from './Form';
+import type { FormInstance, FormItemProps, FormProps, FormProviderProps } from './interface';
+import FormControl from './Control';
+import FormItem from './FormItem';
+import FormList from './FormList';
+import FormProvider from './FormProvider';
+import useFormContext from './hook/useContext';
+import useFormState from './hook/useState';
+import useWatch from './hook/useWatch';
+import useForm from './useForm';
+export type { FormInstance, FormItemProps, FormProps, FormProviderProps };
+type RefForm = typeof Form;
+export interface FormComponent extends RefForm {
+    Item: typeof FormItem;
+    List: typeof FormList;
+    Control: typeof FormControl;
+    Provider: typeof FormProvider;
+    useForm: typeof useForm;
+    useFormContext: typeof useFormContext;
+    useWatch: typeof useWatch;
+    useFormState: typeof useFormState;
+}
+declare const FormComp: FormComponent;
+export { FormControl, FormItem, FormList, FormProvider, useForm, useFormContext, useFormState, useWatch, };
+export default FormComp;