x-next 0.0.0-alpha.7 → 0.0.0-alpha.70

package/README.md

@@ -1,6 +1,6 @@
 # 简介
 
-X-Next是Ringing Tech的基础UI库。
+X-Next致力打造一套最好看、最好用的Vue3 UI组件库。
 
 # 安装
 
@@ -24,3 +24,77 @@ const app = createApp(App)
 app.use(XNext)
 app.mount('#app')
 ```
+### 目前已完成的组件
+
+```
+    XButton: (typeof import('x-next'))['Button']
+    XDialog: (typeof import('x-next'))['Dialog']
+    XMessage: (typeof import('x-next'))['Message']
+    XMessageBox: (typeof import('x-next'))['MessageBox']
+    XNotification: (typeof import('x-next'))['Notification']
+    XSpace: (typeof import('x-next'))['Space']
+    XPopconfirm: (typeof import('x-next'))['Popconfirm']
+    XTrendChart: (typeof import('x-next'))['TrendChart']
+    XTimeline: (typeof import('x-next'))['Timeline']
+    XTimelineItem: (typeof import('x-next'))['TimelineItem']
+    XPopup: (typeof import('x-next'))['Popup']
+    XScrollbar: (typeof import('x-next'))['Scrollbar']
+    XDrawer: (typeof import('x-next'))['Drawer']
+    XTag: (typeof import('x-next'))['Tag']
+    XTooltip: (typeof import('x-next'))['Tooltip']
+    XImage: (typeof import('x-next'))['Image']
+    XImagePreview: (typeof import('x-next'))['ImagePreview']
+    XImagePreviewGroup: (typeof import('x-next'))['ImagePreviewGroup']
+    XImagePreviewAction: (typeof import('x-next'))['ImagePreviewAction']
+    XTabPane: (typeof import('x-next'))['TabPane']
+    XTabs: (typeof import('x-next'))['Tabs']
+    XButtonGroup: (typeof import('x-next'))['ButtonGroup']
+    XDropdown: (typeof import('x-next'))['Dropdown']
+    XDropdownButton: (typeof import('x-next'))['DropdownButton']
+    XEmpty: (typeof import('x-next'))['Empty']
+    XDropdownOption: (typeof import('x-next'))['DropdownOption']
+    XDropdownGroup: (typeof import('x-next'))['DropdownGroup']
+    XDropdownSubmenu: (typeof import('x-next'))['DropdownSubmenu']
+    XInput: (typeof import('x-next'))['Input']
+    XInputGroup: (typeof import('x-next'))['InputGroup']
+    XInputPassword: (typeof import('x-next'))['InputPassword']
+    XInputSearch: (typeof import('x-next'))['InputSearch']
+    XCol: (typeof import('x-next'))['Col']
+    XGrid: (typeof import('x-next'))['Grid']
+    XGridItem: (typeof import('x-next'))['GridItem']
+    XRow: (typeof import('x-next'))['Row']
+    XForm: (typeof import('x-next'))['Form']
+    XFormItem: (typeof import('x-next'))['FormItem']
+    XNetwork: (typeof import('x-next'))['Network']
+    XStep: (typeof import('x-next'))['Step']
+    XSteps: (typeof import('x-next'))['Steps']
+    XCheckbox: (typeof import('x-next'))['Checkbox']
+    XCheckboxGroup: (typeof import('x-next'))['CheckboxGroup']
+    XSwitch: (typeof import('x-next'))['Switch']
+    XRadio: (typeof import('x-next'))['Radio']
+    XRadioGroup: (typeof import('x-next'))['RadioGroup']
+    XSelect: (typeof import('x-next'))['Select']
+    XSelectDropdown: (typeof import('x-next'))['SelectDropdown']
+    XSelectOption: (typeof import('x-next'))['SelectOption']
+    XSelectOptionGroup: (typeof import('x-next'))['SelectOptionGroup']
+    XSpin: (typeof import('x-next'))['Spin']
+    XInputTag: (typeof import('x-next'))['InputTag']
+    XProgress: (typeof import('x-next'))['Progress']
+    XInputNumber: (typeof import('x-next'))['InputNumber']
+    XSlider: (typeof import('x-next'))['Slider']
+    XAlert: (typeof import('x-next'))['Alert']
+    XSkeleton: (typeof import('x-next'))['Skeleton']
+    XSkeletonLine: (typeof import('x-next'))['SkeletonLine']
+    XSkeletonShape: (typeof import('x-next'))['SkeletonShape']
+    XMenu: (typeof import('x-next'))['Menu']
+    XLayout: (typeof import('x-next'))['Layout']
+    XLayoutContent: (typeof import('x-next'))['LayoutContent']
+    XLayoutFooter: (typeof import('x-next'))['LayoutFooter']
+    XLayoutHeader: (typeof import('x-next'))['LayoutHeader']
+    XLayoutSidebar: (typeof import('x-next'))['LayoutSidebar']
+    XResizeBox: (typeof import('x-next'))['ResizeBox']
+    XMenuItem: (typeof import('x-next'))['MenuItem']
+    XMenuSubMenu: (typeof import('x-next'))['MenuSubMenu']
+    XTimeRangeSelector: (typeof import('x-next'))['TimeRangeSelector']
+    XDraggable: (typeof import('x-next'))['Draggable']
+```

package/dist/_container/client-only.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | null | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/parent-scroll-observer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "scroll"[], "scroll", import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/render-function.d.ts

@@ -0,0 +1,14 @@
+import { PropType, VNodeTypes } from 'vue';
+export type RenderFunc = (props: Record<string, unknown>) => VNodeTypes;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    renderFunc: {
+        type: PropType<RenderFunc>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    renderFunc: {
+        type: PropType<RenderFunc>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/resize-observer-2.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    watchOnUpdated: BooleanConstructor;
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "resize"[], "resize", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    watchOnUpdated: BooleanConstructor;
+}>> & Readonly<{
+    onResize?: ((...args: any[]) => any) | undefined;
+}>, {
+    watchOnUpdated: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/resize-observer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "resize"[], "resize", import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onResize?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/resize-trigger.vue.d.ts

@@ -0,0 +1,135 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    prefixCls: {
+        type: StringConstructor;
+        required: true;
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+}>, {
+    classNames: import('vue').ComputedRef<(string | {
+        [x: string]: boolean;
+    })[]>;
+    onResize: (entry: ResizeObserverEntry) => void;
+    isHorizontal: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "resize"[], "resize", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    prefixCls: {
+        type: StringConstructor;
+        required: true;
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+}>> & Readonly<{
+    onResize?: ((...args: any[]) => any) | undefined;
+}>, {
+    direction: "horizontal" | "vertical";
+}, {}, {
+    ResizeObserver: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "resize"[], "resize", import('vue').PublicProps, Readonly<{}> & Readonly<{
+        onResize?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    IconDragDot: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        size: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        rotate: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        spin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        color: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        fillColor: {
+            type: ArrayConstructor;
+            default: undefined;
+        };
+    }>, () => VNode, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        size: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        rotate: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        spin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        color: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        fillColor: {
+            type: ArrayConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, {
+        size: string | number;
+        rotate: number;
+        spin: boolean;
+        color: string;
+        fillColor: unknown[];
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    IconDragDotVertical: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        size: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        rotate: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        spin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        color: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        fillColor: {
+            type: ArrayConstructor;
+            default: undefined;
+        };
+    }>, () => VNode, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        size: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        rotate: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        spin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        color: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        fillColor: {
+            type: ArrayConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, {
+        size: string | number;
+        rotate: number;
+        spin: boolean;
+        color: string;
+        fillColor: unknown[];
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const getProp: (target: any, path: any, defVal?: any) => any;
+export declare const setProp: (target: any, path: any, value: any) => any;
+export declare const deepClone: (obj: any, set?: any) => any;
+export declare const NOOP: () => void;
+export declare const addUnit: (value: string | number | undefined, unit?: string) => string;
+export declare const upperFirstChar: (text: string) => string | undefined;
+export declare const compose: <T>(...fns: ((...v: T[]) => T)[]) => (...v: T[]) => T;
+export declare const pipe: <T>(...fns: ((...v: T[]) => T)[]) => (...v: T[]) => T;
+export declare const findLastIndex: (arr: never[] | undefined, callback: (item: any, i: number, origin: any[]) => boolean) => number;
+export declare const getUniqueId: (size?: number) => string;
+export declare const genMatrix: (list: any[], row: number) => any[];
+export declare const sleep: (delay?: number) => Promise<unknown>;

package/dist/_hooks/_types.d.ts

@@ -0,0 +1,14 @@
+import { VNode } from 'vue';
+export interface SlotChildren {
+    value?: VNode[];
+}
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type EmitFn<T> = (event: T, ...args: any[]) => void;
+export type EmitFn2<Options = Record<string, any>, Event extends keyof Options = keyof Options> = UnionToIntersection<{
+    [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : (event: key, ...args: any[]) => void;
+}[Event]>;
+export type EmitType<T> = T | T[];
+export type FieldString<T> = {
+    [K in keyof T]?: string;
+};
+export {};

package/dist/_hooks/use-children-components.d.ts

@@ -0,0 +1,5 @@
+import { SlotChildren } from './_types';
+export declare const useChildrenComponents: (name: string) => {
+    children: SlotChildren;
+    components: import('vue').Ref<number[], number[]>;
+};

package/dist/_hooks/use-component-ref.d.ts

@@ -0,0 +1,5 @@
+import { ComponentPublicInstance } from 'vue';
+export declare const useComponentRef: (name: string) => {
+    componentRef: import('vue').Ref<HTMLElement | ComponentPublicInstance | undefined, HTMLElement | ComponentPublicInstance | undefined>;
+    elementRef: import('vue').Ref<any, any>;
+};

package/dist/_hooks/use-cursor.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useCursor(input: Ref<HTMLInputElement | undefined>): [() => void, () => void];

package/dist/_hooks/use-first-element.d.ts

@@ -0,0 +1,5 @@
+import { SlotChildren } from './_types.ts';
+export declare const useFirstElement: () => {
+    children: SlotChildren;
+    firstElement: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+};

package/dist/_hooks/use-form-item.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { FormItemContext } from '../components/form/context';
+import { Size } from '../_utils/constant';
+export declare const useFormItem: ({ size, disabled, error, uninject, }?: {
+    size?: Ref<Size | undefined>;
+    disabled?: Ref<boolean>;
+    error?: Ref<boolean>;
+    uninject?: boolean;
+}) => {
+    formItemCtx: FormItemContext;
+    mergedSize: import('vue').ComputedRef<"mini" | "small" | "medium" | "large" | undefined>;
+    mergedDisabled: import('vue').ComputedRef<boolean>;
+    mergedError: import('vue').ComputedRef<boolean>;
+    feedback: Ref<string | undefined, string | undefined>;
+    eventHandlers: Ref<import('../components/form/interface').FormItemEventHandler, import('../components/form/interface').FormItemEventHandler>;
+};

package/dist/_hooks/use-index.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+export declare const useIndex: ({ itemRef, selector, index, parentClassName, }: {
+    itemRef: Ref<HTMLElement | undefined | null>;
+    selector: string;
+    index?: Ref<number | undefined>;
+    parentClassName?: string;
+}) => {
+    innerIndex: import('vue').ComputedRef<number>;
+};

package/dist/_hooks/use-input.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { EmitFn } from './_types';
+import { FormItemEventHandler } from '../components/form/interface';
+export declare const useInput: ({ defaultValue, modelValue, emit, eventName, updateEventName, eventHandlers, }: {
+    defaultValue?: Ref<string>;
+    modelValue?: Ref<string>;
+    emit: EmitFn<any>;
+    eventName?: string;
+    updateEventName?: string;
+    eventHandlers?: Ref<FormItemEventHandler>;
+}) => {
+    inputRef: Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    _value: Ref<string, string>;
+    _focused: Ref<boolean, boolean>;
+    isComposition: Ref<boolean, boolean>;
+    compositionValue: Ref<string, string>;
+    computedValue: import('vue').ComputedRef<string>;
+    handleInput: (ev: Event) => void;
+    handleComposition: (ev: CompositionEvent) => void;
+    handleFocus: (ev: FocusEvent) => void;
+    handleBlur: (ev: FocusEvent) => void;
+    handleKeyDown: (ev: KeyboardEvent) => void;
+    handleMousedown: (ev: MouseEvent) => void;
+};

package/dist/_hooks/use-merge-state.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ComputedRef } from 'vue';
+export default function useMergeState<T, E = T | undefined>(defaultValue: T, props: {
+    value: E;
+}): [ComputedRef<T>, (val: E) => void, Ref<T>];

package/dist/_hooks/use-pick-slots.d.ts

@@ -0,0 +1,2 @@
+import { Slots } from 'vue';
+export default function usePickSlots(slots: Slots, slotName: string): import('vue').Ref<import('vue').Slot<any> | undefined, import('vue').Slot<any> | undefined>;

package/dist/_hooks/use-popup-container.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef } from 'vue';
+interface PopupContainerProps {
+    popupContainer: string | HTMLElement | undefined;
+}
+export default function usePopupContainer(defaultPopupContainer: HTMLElement, props: PopupContainerProps): ComputedRef<HTMLElement>;
+export {};

package/dist/_hooks/use-popup-overflow-hidden.d.ts

@@ -0,0 +1,6 @@
+interface PopupOverflowHiddenProps {
+    container: HTMLElement | undefined;
+    hidden: boolean;
+}
+export default function usePopupOverflowHidden(props: PopupOverflowHiddenProps): (() => void)[];
+export {};

package/dist/_hooks/use-resize-observer.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+export declare const useResizeObserver: ({ elementRef, onResize, }: {
+    elementRef: Ref<HTMLElement | undefined>;
+    onResize: (args: ResizeObserverEntry) => void;
+}) => {
+    createResizeObserver: () => void;
+    destroyResizeObserver: () => void;
+};

package/dist/_hooks/use-responsive.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { Breakpoint } from '../_utils/responsive-observe';
+export declare function useResponsive(breakpoint: Breakpoint | undefined | Ref<Breakpoint | undefined>, callback: (checked: boolean) => void): void;

package/dist/_hooks/use-scrollbar.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { ScrollbarProps } from '../components/scrollbar-v2/interface';
+export declare const useScrollbar: (scrollbar: Ref<ScrollbarProps | boolean>) => {
+    displayScrollbar: import('vue').ComputedRef<boolean>;
+    scrollbarProps: import('vue').ComputedRef<ScrollbarProps | undefined>;
+};

package/dist/_hooks/use-size.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { Size } from '../_utils/constant';
+export declare const useSize: (size?: Ref<Size | undefined>, { defaultValue }?: {
+    defaultValue?: Size;
+}) => {
+    mergedSize: import('vue').ComputedRef<"mini" | "small" | "medium" | "large">;
+};

package/dist/_hooks/use-state.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useState<T>(defaultValue?: T): [Ref<T>, (newValue: T) => void];

package/dist/_hooks/use-teleport-container.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+export declare const useTeleportContainer: ({ popupContainer, visible, defaultContainer, documentContainer, }: {
+    popupContainer: Ref<string | HTMLElement | undefined>;
+    visible: Ref<boolean>;
+    defaultContainer?: string;
+    documentContainer?: boolean;
+}) => {
+    teleportContainer: Ref<string | HTMLElement | undefined, string | HTMLElement | undefined>;
+    containerRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+};

package/dist/_hooks/use-trigger.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { EmitFn2 } from './_types';
+export declare const useTrigger: ({ popupVisible, defaultPopupVisible, emit, }: {
+    popupVisible?: Ref<boolean | undefined>;
+    defaultPopupVisible?: Ref<boolean>;
+    emit: EmitFn2<{
+        "update:popupVisible": (visible: boolean) => true;
+        popupVisibleChange: (visible: boolean) => true;
+    }>;
+}) => {
+    computedPopupVisible: import('vue').ComputedRef<boolean>;
+    handlePopupVisibleChange: (visible: boolean) => void;
+};

package/dist/_props/constant.d.ts

@@ -0,0 +1,4 @@
+export declare const TRIGGER_POSITIONS: readonly ["top", "tl", "tr", "bottom", "bl", "br", "left", "lt", "lb", "right", "rt", "rb"];
+export type TriggerPosition = (typeof TRIGGER_POSITIONS)[number];
+export declare const TRIGGER_EVENTS: readonly ["hover", "click", "focus", "contextMenu"];
+export type TriggerEvent = (typeof TRIGGER_EVENTS)[number];

package/dist/_props/types.d.ts

@@ -0,0 +1 @@
+export type ClassName = string | Record<string, boolean> | (string | Record<string, boolean>)[];

package/dist/_utils/click.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description: 防抖函数
+ * @param callback
+ * @param delay
+ * @param immediate
+ */
+export declare const debounce: (callback: (e: any) => void, delay: number, immediate?: boolean) => any;
+/**
+ * @description: 节流函数
+ * @param callback
+ * @param delay
+ */
+export declare const throttle: (callback: (e: any) => void, delay?: number) => any;

package/dist/_utils/config.d.ts

@@ -1,6 +1,6 @@
 export declare const COMPONENT_INSTALLED_KEY: unique symbol;
 export declare const getClassPrefix: (name?: string) => string;
-export declare const getComponentPrefix: (name: string) => string;
+export declare const getComponentPrefix: (name: string) => `X${string}`;
 export declare const getClassNameMixin: (name: string) => {
     block: string;
     element: (className: string) => string;

package/dist/_utils/constant.d.ts

@@ -0,0 +1,17 @@
+export declare const SIZES: readonly ["mini", "small", "medium", "large"];
+export type Size = typeof SIZES[number];
+export declare const BORDER_SHAPES: readonly ["square", "round", "circle"];
+export type BorderShape = typeof BORDER_SHAPES[number];
+export declare const STATUSES: readonly ["normal", "success", "warning", "danger"];
+export type Status = typeof STATUSES[number];
+export declare const MESSAGE_TYPES: readonly ["info", "success", "warning", "error"];
+export type MessageType = typeof MESSAGE_TYPES[number];
+export declare const TRIGGER_POSITIONS: readonly ["top", "tl", "tr", "bottom", "bl", "br", "left", "lt", "lb", "right", "rt", "rb"];
+export type TriggerPosition = typeof TRIGGER_POSITIONS[number];
+export declare const TRIGGER_EVENTS: readonly ["hover", "click", "focus", "contextMenu"];
+export type TriggerEvent = typeof TRIGGER_EVENTS[number];
+export declare const DIRECTIONS: readonly ["horizontal", "vertical"];
+export type Direction = typeof DIRECTIONS[number];
+export declare const INPUT_EVENTS: string[];
+export declare const TEXT_ALIGNS: readonly ["left", "center", "right"];
+export type TextAlign = typeof TEXT_ALIGNS[number];

package/dist/_utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce(callback: (...args: any[]) => void, delay: number): (...args: any[]) => void;

package/dist/_utils/dom.d.ts

@@ -3,8 +3,27 @@ export declare const NOOP: () => void;
 export declare const querySelector: (selectors: string, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const getScrollBarWidth: (element: HTMLElement) => number;
 export declare const isScroll: (element: HTMLElement) => boolean;
+export declare const isServerRendering: boolean;
 export declare const getStyle: (element: HTMLElement, styleName: keyof CSSProperties) => string;
 export declare const setStyle: (element: HTMLElement, styleName: CSSProperties | keyof CSSProperties, value?: string | number) => void;
 export declare const getElement: (target: string | HTMLElement | undefined, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const on: <K extends keyof HTMLElementEventMap>(element: HTMLElement | Window, event: K, handler: (ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void;
 export declare const off: <K extends keyof HTMLElementEventMap>(element: HTMLElement | Window, type: K, handler: (ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void;
+export interface Size {
+    height: number;
+    width: number;
+}
+export declare const getDocumentSize: () => Size;
+/**
+ * Get the relative distance between two DOMs
+ * @param target
+ * @param relative
+ */
+export declare const getRelativeRect: (target: HTMLElement, relative: HTMLElement) => {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    width: number;
+    height: number;
+};

package/dist/_utils/get-value-by-path.d.ts

@@ -0,0 +1,5 @@
+import { Data } from './types';
+export declare const getValueByPath: <T = any>(obj: Data | undefined, path: string | undefined) => T | undefined;
+export declare const setValueByPath: (obj: Data | undefined, path: string | undefined, value: any, { addPath }?: {
+    addPath?: boolean;
+}) => void;

package/dist/_utils/is-equal.d.ts

@@ -0,0 +1,3 @@
+export declare const isEqualObject: (obj: Record<string, unknown> | undefined, other: Record<string, unknown> | undefined) => boolean;
+export declare const isEqualArray: (arr: unknown[] | undefined, other: unknown[] | undefined) => boolean;
+export declare const isEqual: (a: unknown, b: unknown) => boolean;

package/dist/_utils/is.d.ts

@@ -5,6 +5,8 @@ export declare function isNull(obj: any): obj is null;
 export declare function isBoolean(obj: unknown): obj is boolean;
 export declare function isObject<T>(obj: T): obj is Extract<T, Record<string, any>>;
 export declare const isPromise: <T>(obj: unknown) => obj is Promise<T>;
+export declare const isAsync: (fn: unknown) => boolean;
+export declare const isAsyncOrPromise: (fn: unknown) => boolean;
 export declare function isString(obj: any): obj is string;
 export declare function isNumber(obj: any): obj is number;
 export declare function isRegExp(obj: any): boolean;
@@ -20,3 +22,4 @@ export declare const isArrayChildren: (children: VNodeNormalizedChildren) => chi
 export declare const isQuarter: (fromat: string) => boolean;
 export declare function isDayjs(time: any): time is Dayjs;
 export declare function isClient(): boolean;
+export declare const isFirefox: () => boolean;

package/dist/_utils/keycode.d.ts

@@ -0,0 +1,36 @@
+export declare const Enter: {
+    key: string;
+    code: string;
+};
+export declare const Esc: {
+    key: string;
+    code: string;
+};
+export declare const Backspace: {
+    key: string;
+    code: string;
+};
+export declare const Tab: {
+    key: string;
+    code: string;
+};
+export declare const Space: {
+    key: string;
+    code: string;
+};
+export declare const ArrowUp: {
+    key: string;
+    code: string;
+};
+export declare const ArrowDown: {
+    key: string;
+    code: string;
+};
+export declare const ArrowLeft: {
+    key: string;
+    code: string;
+};
+export declare const ArrowRight: {
+    key: string;
+    code: string;
+};