@pungfe/element 0.0.1-alpha.18 → 0.0.1-alpha.21

package/dist/types/components/Pagination.vue.d.ts

@@ -0,0 +1,40 @@
+import { PaginationProps } from 'element-plus';
+export interface XPaginationProps {
+    pageSizes?: PaginationProps['pageSizes'];
+    background?: PaginationProps['background'];
+    size?: PaginationProps['size'];
+    layout?: PaginationProps['layout'];
+    total?: PaginationProps['total'];
+}
+type __VLS_Props = XPaginationProps;
+type __VLS_PublicProps = {
+    'currentPage'?: number;
+    'pageSize'?: number;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sizeChange: (size: number) => any;
+    currentChange: (current: number) => any;
+    "update:currentPage": (value: number) => any;
+    "update:pageSize": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSizeChange?: ((size: number) => any) | undefined;
+    onCurrentChange?: ((current: number) => any) | undefined;
+    "onUpdate:currentPage"?: ((value: number) => any) | undefined;
+    "onUpdate:pageSize"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Select.vue.d.ts

@@ -0,0 +1,45 @@
+import { SelectProps } from 'element-plus';
+export interface XSelectOptionProps<V> {
+    disabled?: boolean;
+    label?: number | string;
+    value: V;
+}
+export interface XSelectProps<D, V> {
+    collapseTagsTooltip?: SelectProps['collapseTagsTooltip'];
+    clearable?: SelectProps['clearable'];
+    allowCreate?: SelectProps['allowCreate'];
+    collapseTags?: SelectProps['collapseTags'];
+    data?: D[];
+    disabled?: SelectProps['disabled'];
+    factory: (option: D) => XSelectOptionProps<V>;
+    filterable?: SelectProps['filterable'];
+    identify?: (value: V) => number | string;
+    loading?: SelectProps['loading'];
+    multiple?: SelectProps['multiple'];
+    remote?: SelectProps['remote'];
+    remoteMethod?: (query: string) => void;
+    size?: SelectProps['size'];
+    supplement?: (lacks: V[]) => D[] | PromiseLike<D[]>;
+    placeholder?: SelectProps['placeholder'];
+    noDataText?: SelectProps['noDataText'];
+}
+declare const _default: <D, V, MV extends V | V[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: MV) => any) | undefined;
+        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
+        readonly onFocus?: (() => any) | undefined;
+        readonly onChange?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onUpdate:modelValue"> & ({
+        modelValue?: MV;
+    } & XSelectProps<D, V>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "blur", e: FocusEvent) => void) & ((evt: "focus") => void) & ((evt: "change", value: V) => void)) & ((evt: "update:modelValue", value: MV) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/TabPane.vue.d.ts

@@ -0,0 +1,32 @@
+import { TabPaneProps } from 'element-plus';
+export interface XTabPaneConfig {
+    label?: string;
+    name?: number | string;
+}
+export interface XTabPaneProps {
+    closable?: TabPaneProps['closable'];
+    disabled?: TabPaneProps['disabled'];
+    label?: TabPaneProps['label'];
+    lazy?: TabPaneProps['lazy'];
+    name?: TabPaneProps['name'];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XTabPaneProps, {
+    label: string | undefined;
+    name: string | number | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XTabPaneProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Table.vue.d.ts

@@ -0,0 +1,89 @@
+import { TableColumnCtx, TableProps } from 'element-plus';
+import { CSSProperties, VNode, VNodeChild } from 'vue';
+export interface XTableColumnProps<D> {
+    content?: (scope: {
+        index: number;
+        row: D;
+    }) => VNodeChild;
+    fixed?: 'left' | 'right';
+    header?: (scope: {
+        column: XTableColumnProps<D>;
+    }) => VNodeChild;
+    label?: string;
+    prop?: string;
+    selectable?: (row: D, index: number) => boolean;
+    type?: 'index' | 'selection';
+    width?: number;
+}
+export interface XTableProps<D> {
+    border?: TableProps<any>['border'];
+    cellClassName?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    cellStyle?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+    columns?: XTableColumnProps<D>[];
+    data?: D[];
+    height?: TableProps<any>['height'];
+    emptyText?: TableProps<any>['emptyText'];
+    rowClassName?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    rowKey?: (scope: {
+        row: D;
+    }) => string;
+    rowStyle?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+    showOverflowTooltip?: TableProps<any>['showOverflowTooltip'];
+    showSummary?: TableProps<any>['showSummary'];
+    size?: TableProps<any>['size'];
+    spanMethod?: (scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => number[] | undefined | {
+        colspan: number;
+        rowspan: number;
+    };
+    summaryMethod?: (scope: {
+        columns: TableColumnCtx[];
+        data: D[];
+    }) => (string | VNode)[];
+}
+declare const _default: <D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onHeaderDragend?: ((newWidth: number, oldWidth: number, column: TableColumnCtx) => any) | undefined;
+        readonly onRowClick?: ((row: D) => any) | undefined;
+        readonly onRowDbClick?: ((row: D) => any) | undefined;
+        readonly onSelectionChange?: ((rows: D[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onHeaderDragend" | "onRowClick" | "onRowDbClick" | "onSelectionChange"> & XTableProps<D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        clearSelection: () => void | undefined;
+        getSelectionRows: () => any[] | undefined;
+        scrollTo: (options: number | ScrollToOptions, yCoord?: number) => void | undefined;
+        setCurrentRow: (row: D) => void | undefined;
+        setScrollLeft: (left: number) => void | undefined;
+        setScrollTop: (top: number) => void | undefined;
+        toggleRowSelection: (row: D, selected?: boolean, ignoreSelectable?: boolean) => void | undefined;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "headerDragend", newWidth: number, oldWidth: number, column: TableColumnCtx) => void) & ((evt: "rowClick", row: D) => void) & ((evt: "rowDbClick", row: D) => void) & ((evt: "selectionChange", rows: D[]) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/{basic/XTabs.vue.d.ts → types/components/Tabs.vue.d.ts}

@@ -1,22 +1,14 @@
-import { TabPaneProps, TabsProps } from 'element-plus';
+import { TabsProps } from 'element-plus';
 export interface XTabsProps {
-    type?: TabsProps['type'];
-    defaultValue?: TabsProps['defaultValue'];
     addable?: TabsProps['addable'];
     editable?: TabsProps['editable'];
     tabPosition?: TabsProps['tabPosition'];
+    type?: TabsProps['type'];
 }
-export interface XTabPaneProps extends Partial<TabPaneProps> {
-}
-export interface XTabPaneInstance extends Pick<XTabPaneProps, 'label' | 'name'> {
-}
-export declare const XTabPane: import('vue').DefineSetupFnComponent<XTabPaneProps, {}, {}, XTabPaneProps & {}, import('vue').PublicProps>;
 declare const _default: <V extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
-        readonly onTabChange?: ((name: V) => any) | undefined;
-        readonly onTabRemove?: ((name: V) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onTabChange" | "onTabRemove"> & ({
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
         modelValue?: V;
     } & XTabsProps) & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
@@ -24,7 +16,7 @@ declare const _default: <V extends string | number>(__VLS_props: NonNullable<Awa
     slots: {
         default?(_: {}): any;
     };
-    emit: (((evt: "tabChange", name: V) => void) & ((evt: "tabRemove", name: V) => void)) & ((evt: "update:modelValue", value: V) => void);
+    emit: (evt: "update:modelValue", value: V) => void;
 }>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/types/components/Upload.vue.d.ts

@@ -0,0 +1,40 @@
+import { UploadFile, UploadProps } from 'element-plus';
+import { VNodeChild } from 'vue';
+export interface XUploadProps {
+    accept?: UploadProps['accept'];
+    data?: UploadProps['data'];
+    disabled?: UploadProps['disabled'];
+    limit?: UploadProps['limit'];
+    showFileList?: UploadProps['showFileList'];
+}
+declare const _default: <MV extends string | string[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: MV) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: MV;
+    } & XUploadProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: () => VNodeChild;
+        file: (scope: {
+            file: UploadFile;
+            index: number;
+        }) => VNodeChild;
+        tips: () => VNodeChild;
+    }> & {
+        default: () => VNodeChild;
+        file: (scope: {
+            file: UploadFile;
+            index: number;
+        }) => VNodeChild;
+        tips: () => VNodeChild;
+    };
+    emit: (evt: "update:modelValue", value: MV) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/index.d.ts

@@ -0,0 +1,50 @@
+import { default as XButton } from './Button.vue';
+import { default as XButtonPopconfirm } from './ButtonPopconfirm.vue';
+import { default as XConfigProvider } from './ConfigProvider.vue';
+import { default as XDatePicker } from './DatePicker.vue';
+import { default as XDialog } from './Dialog.vue';
+import { default as XForm } from './Form.vue';
+import { default as XFormItem } from './FormItem.vue';
+import { default as XInput } from './Input.vue';
+import { default as XInputNumber } from './InputNumber.vue';
+import { default as XPagination } from './Pagination.vue';
+import { default as XSelect } from './Select.vue';
+import { default as XTable } from './Table.vue';
+import { default as XTabPane } from './TabPane.vue';
+import { default as XTabs } from './Tabs.vue';
+import { default as XUpload } from './Upload.vue';
+export { XButton, XButtonPopconfirm, XConfigProvider, XDatePicker, XDialog, XForm, XFormItem, XInput, XInputNumber, XPagination, XSelect, XTable, XTabPane, XTabs, XUpload };
+export * from './Button.vue';
+export * from './ButtonPopconfirm.vue';
+export * from './ConfigProvider.vue';
+export * from './DatePicker.vue';
+export * from './Dialog.vue';
+export * from './Form.vue';
+export * from './FormItem.vue';
+export * from './Input.vue';
+export * from './InputNumber.vue';
+export * from './Pagination.vue';
+export * from './Select.vue';
+export * from './Table.vue';
+export * from './TabPane.vue';
+export * from './Tabs.vue';
+export * from './Upload.vue';
+declare module 'vue' {
+    interface GlobalComponents {
+        XButton: typeof XButton;
+        XButtonPopconfirm: typeof XButtonPopconfirm;
+        XConfigProvider: typeof XConfigProvider;
+        XDatePicker: typeof XDatePicker;
+        XDialog: typeof XDialog;
+        XForm: typeof XForm;
+        XFormItem: typeof XFormItem;
+        XInput: typeof XInput;
+        XInputNumber: typeof XInputNumber;
+        XPagination: typeof XPagination;
+        XSelect: typeof XSelect;
+        XTable: typeof XTable;
+        XTabPane: typeof XTabPane;
+        XTabs: typeof XTabs;
+        XUpload: typeof XUpload;
+    }
+}

package/dist/types/constants/index.d.ts

@@ -0,0 +1,15 @@
+import { EventHook } from '@vueuse/core';
+import { Language } from 'element-plus/es/locale';
+import { InjectionKey, Ref } from 'vue';
+import { XFormItemValidation } from '../components/FormItem.vue';
+export declare const X_LOCALE_CONFIG: InjectionKey<Ref<Language>>;
+export declare const X_ELEMENT_IN_TABLE: InjectionKey<boolean>;
+export declare const X_ELEMENT_IN_TABLE_COLUMN: InjectionKey<boolean>;
+export declare const X_ELEMENT_IN_FORM: InjectionKey<boolean>;
+export declare const X_ELEMENT_IN_FORM_ITEM: InjectionKey<boolean>;
+export declare const X_ELEMENT_IN_TABS: InjectionKey<boolean>;
+export declare const X_ELEMENT_IN_TAB_PANE: InjectionKey<boolean>;
+export declare const X_FORM_VALIDATIONS: InjectionKey<XFormItemValidation[]>;
+export declare const X_FORM_ITEM_VALIDATION: InjectionKey<XFormItemValidation>;
+export declare const X_TAB_PANE_NAME: InjectionKey<string | number | undefined>;
+export declare const X_TABS_MODEL_UPDATE_HOOK: InjectionKey<EventHook>;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+import { install } from './install';
+export * from './components';
+export * from './install';
+export * from './locales';
+export default install;

package/dist/types/install.d.ts

@@ -0,0 +1,2 @@
+import { App } from 'vue';
+export declare const install: (app: App) => void;

package/dist/types/locales/en.d.ts

@@ -0,0 +1,2 @@
+import { default as en } from 'element-plus/es/locale/lang/en';
+export { en };

package/dist/types/locales/index.d.ts

@@ -0,0 +1,2 @@
+export { en } from './en';
+export { zhCn } from './zh-cn';

package/dist/types/locales/zh-cn.d.ts

@@ -0,0 +1,2 @@
+import { default as zhCn } from 'element-plus/es/locale/lang/zh-cn';
+export { zhCn };

package/dist/{resolver.d.ts → types/resolver.d.ts}

@@ -1,3 +1,3 @@
 import { ComponentResolver } from 'unplugin-vue-components';
-declare const _default: () => ComponentResolver[];
+declare const _default: () => ComponentResolver;
 export default _default;

package/dist/types/src/components/Button.vue.d.ts

@@ -0,0 +1,31 @@
+import { ButtonProps, ButtonType } from 'element-plus';
+export interface XButtonProps {
+    disabled?: ButtonProps['disabled'];
+    link?: ButtonProps['link'];
+    size?: ButtonProps['size'];
+    text?: ButtonProps['text'];
+    type?: ButtonProps['type'];
+    icon?: ButtonProps['icon'];
+}
+export type XButtonType = ButtonType;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (e: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<XButtonProps> & Readonly<{
+    onClick?: ((e: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/ButtonPopconfirm.vue.d.ts

@@ -0,0 +1,27 @@
+import { XButtonProps } from './Button.vue';
+export interface XButtonPopconfirmProps extends XButtonProps {
+    title?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XButtonPopconfirmProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<XButtonPopconfirmProps> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/ConfigProvider.vue.d.ts

@@ -0,0 +1,21 @@
+import { ConfigProviderProps } from 'element-plus';
+export interface XConfigProviderProps {
+    locale?: ConfigProviderProps['locale'];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XConfigProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XConfigProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/DatePicker.vue.d.ts

@@ -0,0 +1,34 @@
+import { DatePickerProps } from 'element-plus';
+export interface XDatePickerProps {
+    disabled?: boolean;
+    disabledDate?: DatePickerProps['disabledDate'];
+    endPlaceholder?: DatePickerProps['endPlaceholder'];
+    placeholder?: DatePickerProps['placeholder'];
+    shortcuts?: DatePickerProps['shortcuts'];
+    startPlaceholder?: DatePickerProps['startPlaceholder'];
+    type?: DatePickerProps['type'];
+    valueFormat?: DatePickerProps['valueFormat'];
+}
+declare const _default: <V extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        readonly "onUpdate:start"?: ((value: V) => any) | undefined;
+        readonly "onUpdate:end"?: ((value: V) => any) | undefined;
+        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
+        readonly onFocus?: ((e: FocusEvent) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onUpdate:modelValue" | "onUpdate:start" | "onUpdate:end"> & ({
+        modelValue?: V;
+        start?: V;
+        end?: V;
+    } & XDatePickerProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "blur", e: FocusEvent) => void) & ((evt: "focus", e: FocusEvent) => void)) & (((evt: "update:modelValue", value: V) => void) & ((evt: "update:start", value: V) => void) & ((evt: "update:end", value: V) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/src/components/Dialog.vue.d.ts

@@ -0,0 +1,44 @@
+import { DialogProps } from 'element-plus';
+import { VNodeChild } from 'vue';
+export interface XDialogProps {
+    bodyClass?: DialogProps['bodyClass'];
+    width?: DialogProps['width'];
+    showClose?: DialogProps['showClose'];
+    title?: DialogProps['title'];
+    center?: DialogProps['center'];
+    alignCenter?: DialogProps['alignCenter'];
+    draggable?: DialogProps['draggable'];
+    closeOnClickModal?: DialogProps['closeOnClickModal'];
+    closeOnPressEscape?: DialogProps['closeOnPressEscape'];
+}
+type __VLS_Props = XDialogProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => VNodeChild;
+        header?: () => VNodeChild;
+        footer?: () => VNodeChild;
+    }> & {
+        default?: () => VNodeChild;
+        header?: () => VNodeChild;
+        footer?: () => VNodeChild;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/{basic/XForm.vue.d.ts → types/src/components/Form.vue.d.ts}

@@ -1,9 +1,10 @@
 import { VNodeChild } from 'vue';
-export interface XFormItemConfig<D> extends Omit<XFormItemProps, 'content' | 'label'> {
-    content?: (scope: {
-        data: D;
-    }) => VNodeChild;
-    label: string;
+export interface XFormItemProps {
+    content?: () => VNodeChild;
+    label?: string;
+    labelPosition?: '' | 'left' | 'right' | 'top';
+    labelWidth?: number | string;
+    required?: boolean;
 }
 export interface XFormProps<D> {
     content?: (scope: {
@@ -12,35 +13,16 @@ export interface XFormProps<D> {
     data?: D;
     disabled?: boolean;
     inline?: boolean;
-    labelWidth?: number | string;
     labelPosition?: 'left' | 'right' | 'top';
-    statusIcon?: boolean;
-}
-export interface XFormItemProps {
-    content?: () => VNodeChild;
-    label?: string;
-    labelPosition?: '' | 'left' | 'right' | 'top';
+    labelSuffix?: string;
     labelWidth?: number | string;
-    required?: boolean;
-    tooltip?: {
-        type?: 'success' | 'warning';
-        content?: string;
-    };
-}
-export interface XFormItemValidation {
-    label: string;
-    required: boolean;
-    clearValidate: () => void;
-    validate: () => boolean;
-    validator?: () => string | void;
 }
-export declare const XFormItem: import('vue').DefineSetupFnComponent<XFormItemProps, {}, {}, XFormItemProps & {}, import('vue').PublicProps>;
 declare const _default: <D extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & XFormProps<D> & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
-        data: D | (() => void);
+        clearValidate: () => void;
+        data: D | undefined;
         validate: () => boolean;
-        resetFields: () => void;
     }>): void;
     attrs: any;
     slots: {};

package/dist/types/src/components/FormItem.vue.d.ts

@@ -0,0 +1,33 @@
+import { VNodeChild } from 'vue';
+export interface XFormItemProps {
+    content?: () => VNodeChild;
+    label?: string;
+    required?: boolean;
+    validator?: () => string | void;
+}
+export interface XFormItemValidation {
+    clearValidate: () => void;
+    label?: string;
+    required?: boolean;
+    validate: () => boolean;
+    validator?: () => string | void;
+}
+declare const _default: <D extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & XFormItemProps & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: () => VNodeChild;
+        label: () => VNodeChild;
+    }> & {
+        default: () => VNodeChild;
+        label: () => VNodeChild;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};