@pungfe/element 0.0.1-alpha.9 → 0.1.1

package/dist/basic.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./basic-BfqwJFE_.cjs`);exports.XButton=e.b,exports.XCascader=e.g,exports.XCheckbox=e.h,exports.XConfigProvider=e.m,exports.XDatePicker=e.p,exports.XDialog=e.f,exports.XForm=e.d,exports.XFormItem=e.u,exports.XInput=e.l,exports.XInputNumber=e.c,exports.XPagination=e.s,exports.XSelect=e.o,exports.XTabPane=e.i,exports.XTable=e.a,exports.XTabs=e.r,exports.XUpload=e.n;

package/dist/basic.d.ts

@@ -0,0 +1,33 @@
+import { default as XButton } from './components/basic/Button.vue';
+import { default as XCascader } from './components/basic/Cascader.vue';
+import { default as XCheckbox } from './components/basic/Checkbox.vue';
+import { default as XConfigProvider } from './components/basic/ConfigProvider.vue';
+import { default as XDatePicker } from './components/basic/DatePicker.vue';
+import { default as XDialog } from './components/basic/Dialog.vue';
+import { default as XForm } from './components/basic/Form.vue';
+import { default as XFormItem } from './components/basic/FormItem.vue';
+import { default as XInput } from './components/basic/Input.vue';
+import { default as XInputNumber } from './components/basic/InputNumber.vue';
+import { default as XPagination } from './components/basic/Pagination.vue';
+import { default as XSelect } from './components/basic/Select.vue';
+import { default as XTable } from './components/basic/Table.vue';
+import { default as XTabPane } from './components/basic/TabPane.vue';
+import { default as XTabs } from './components/basic/Tabs.vue';
+import { default as XUpload } from './components/basic/Upload.vue';
+export { XButton, XCascader, XCheckbox, XConfigProvider, XDatePicker, XDialog, XForm, XFormItem, XInput, XInputNumber, XPagination, XSelect, XTable, XTabPane, XTabs, XUpload };
+export * from './components/basic/Button.vue';
+export * from './components/basic/Cascader.vue';
+export * from './components/basic/Checkbox.vue';
+export * from './components/basic/ConfigProvider.vue';
+export * from './components/basic/DatePicker.vue';
+export * from './components/basic/Dialog.vue';
+export * from './components/basic/Form.vue';
+export * from './components/basic/FormItem.vue';
+export * from './components/basic/Input.vue';
+export * from './components/basic/InputNumber.vue';
+export * from './components/basic/Pagination.vue';
+export * from './components/basic/Select.vue';
+export * from './components/basic/Table.vue';
+export * from './components/basic/TabPane.vue';
+export * from './components/basic/Tabs.vue';
+export * from './components/basic/Upload.vue';

package/dist/basic.js

@@ -0,0 +1,2 @@
+import { a as e, b as t, c as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, n as u, o as d, p as f, r as p, s as m, u as h } from "./basic-CZ74BN1R.js";
+export { t as XButton, a as XCascader, o as XCheckbox, l as XConfigProvider, f as XDatePicker, i as XDialog, r as XForm, h as XFormItem, c as XInput, n as XInputNumber, m as XPagination, d as XSelect, s as XTabPane, e as XTable, p as XTabs, u as XUpload };

package/dist/components/advance/XButtonAsync.vue.d.ts

@@ -0,0 +1,21 @@
+import { XButtonProps } from '../../basic';
+export interface XButtonAsyncProps extends XButtonProps {
+    action?: () => PromiseLike<unknown> | unknown;
+}
+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<XButtonAsyncProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XButtonAsyncProps> & 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/{basic/XReconfirm.vue.d.ts → components/advance/XButtonConfirm.vue.d.ts}

@@ -1,4 +1,5 @@
-export interface XReconfirmProps {
+import { XButtonProps } from '../../basic';
+export interface XButtonConfirmProps extends XButtonProps {
     title?: string;
 }
 declare function __VLS_template(): {
@@ -10,12 +11,12 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<XReconfirmProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    cancel: () => any;
+declare const __VLS_component: import('vue').DefineComponent<XButtonConfirmProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     confirm: () => any;
-}, string, import('vue').PublicProps, Readonly<XReconfirmProps> & Readonly<{
-    onCancel?: (() => any) | undefined;
+    cancel: () => any;
+}, string, import('vue').PublicProps, Readonly<XButtonConfirmProps> & Readonly<{
     onConfirm?: (() => any) | undefined;
+    onCancel?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/advance/XCascaderRequest.vue.d.ts

@@ -0,0 +1,55 @@
+import { XCascaderProps } from '../../basic';
+import { CascaderComponentProps } from 'element-plus';
+import { Ref } from 'vue';
+export interface XCascaderRequestProps<U, PT, QR, D, V> extends Omit<XCascaderProps<D, V>, 'data' | 'factory'> {
+    request: () => {
+        data: Ref<D[]>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
+    clearable?: CascaderComponentProps['clearable'];
+    disabled?: CascaderComponentProps['disabled'];
+    filterable?: CascaderComponentProps['filterable'];
+}
+export interface XCascaderRequestEvents<PT, QR, V> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+    change: [value: V];
+}
+declare const _default: <U, PT, QR, 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 onChange?: ((value: V) => any) | undefined;
+        readonly onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onChange" | "onPrepare"> & ({
+        modelValue?: MV;
+    } & XCascaderRequestProps<U, PT, QR, D, V>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        search: import('@vueuse/shared').UseDebounceFnReturn<() => Promise<void>>;
+        data: Ref<D[], D[]>;
+        path: Ref<PT, PT>;
+        url: U;
+        execute: () => PromiseLike<unknown>;
+        query: Ref<QR, QR>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "change", value: V) => void) & ((evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }) => 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/components/advance/XFormFlex.vue.d.ts

@@ -0,0 +1,19 @@
+import { XFormProps } from '../../basic';
+export interface XFormFlexProps<D> extends XFormProps<D> {
+}
+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> & XFormFlexProps<D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        validate: () => boolean | undefined;
+        clearValidate: () => void | undefined;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/advance/XFormRequestNext.vue.d.ts

@@ -0,0 +1,53 @@
+import { XFormProps } from '../../basic';
+import { Ref, VNodeChild } from 'vue';
+export interface XFormRequestProps<U, PT, QR, D> extends Omit<XFormProps<D>, 'disabled' | 'data'> {
+    request: () => {
+        data: Ref<D>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
+    content?: (scope: {
+        data: D;
+    }) => VNodeChild;
+    disabled?: ((scope: {
+        data: D;
+    }) => boolean) | boolean;
+}
+export interface XFormRequestEvents<PT, QR> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+}
+declare const _default: <U, PT, QR, 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<{
+        readonly onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onPrepare"> & XFormRequestProps<U, PT, QR, D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        data: Ref<D, D>;
+        url: U;
+        search: import('@vueuse/shared').UseDebounceFnReturn<() => Promise<void>>;
+        validate: () => boolean | undefined;
+        clearValidate: () => void | undefined;
+        reset: () => D;
+        resetFields: () => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/advance/XRequest.vue.d.ts

@@ -0,0 +1,74 @@
+import { Paging } from '../../types';
+import { Ref, VNodeChild } from 'vue';
+export interface XRequestProps<U, PT, QR, D> {
+    request: () => {
+        data: Ref<D>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        paging: Ref<Paging>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
+    content?: (scope: {
+        data: D;
+        query: QR;
+        path: PT;
+        isFetching: boolean;
+        paging: Paging;
+    }) => VNodeChild;
+}
+export interface XRequestEvents<PT, QR> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+}
+declare const _default: <U, PT, QR, 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 onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onPrepare"> & XRequestProps<U, PT, QR, D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        data: Ref<D, D>;
+        paging: Ref<Paging, Paging>;
+        path: Ref<PT, PT>;
+        query: Ref<QR, QR>;
+        isFetching: Ref<boolean, boolean>;
+        url: U;
+        execute: () => PromiseLike<unknown>;
+        search: import('@vueuse/shared').UseDebounceFnReturn<() => Promise<void>>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: (scope: {
+            data: D;
+            execute: () => PromiseLike<unknown>;
+            isFetching: boolean;
+            paging: Paging;
+            path: PT;
+            query: QR;
+        }) => VNodeChild;
+    }> & {
+        default: (scope: {
+            data: D;
+            execute: () => PromiseLike<unknown>;
+            isFetching: boolean;
+            paging: Paging;
+            path: PT;
+            query: QR;
+        }) => VNodeChild;
+    };
+    emit: (evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/advance/XSelectRequest.vue.d.ts

@@ -0,0 +1,53 @@
+import { XSelectEvents, XSelectProps } from '../../basic';
+import { Ref } from 'vue';
+export interface XSelectRequestProps<U, PT, QR, D, V> extends Omit<XSelectProps<D, V>, 'supplement'> {
+    request: () => {
+        data: Ref<D[]>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
+    supplement?: (lacks: V[], url: U) => D[] | PromiseLike<D[]>;
+}
+export interface XSelectRequestEvents<PT, QR, V> extends XSelectEvents<V> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }, input?: string];
+}
+declare const _default: <U, PT, QR, 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 onFocus?: ((e: FocusEvent) => any) | undefined;
+        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
+        readonly onChange?: ((value: V) => any) | undefined;
+        readonly onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }, input?: string | undefined) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onChange" | "onFocus" | "onPrepare"> & ({
+        modelValue?: MV;
+    } & XSelectRequestProps<U, PT, QR, D, V>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        search: import('@vueuse/shared').UseDebounceFnReturn<(input?: string) => Promise<void>>;
+        data: Ref<D[], D[]>;
+        path: Ref<PT, PT>;
+        url: U;
+        execute: () => PromiseLike<unknown>;
+        query: Ref<QR, QR>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void) & ((evt: "change", value: V) => void) & ((evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }, input?: string | undefined) => 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/components/advance/XTableFlex.vue.d.ts

@@ -0,0 +1,53 @@
+import { XTableEvents, XTableProps } from '../../basic';
+import { TableColumnCtx } from 'element-plus';
+import { CSSProperties } from 'vue';
+export interface XTableFlexProps<D> extends XTableProps<D> {
+    cellClassName?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    cellStyle?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+    rowClassName?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    rowStyle?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+}
+export interface XTableFlexEvents<D> extends XTableEvents<D> {
+}
+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 onRowDblclick?: ((row: D) => any) | undefined;
+        readonly onSelectionChange?: ((rows: D[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onHeaderDragend" | "onRowClick" | "onRowDblclick" | "onSelectionChange"> & XTableFlexProps<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: "rowDblclick", 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/components/advance/XTableRequestConfigNext.vue.d.ts

@@ -0,0 +1,68 @@
+import { Ref, VNodeChild } from 'vue';
+import { Paging, TableColumnField } from '../../types';
+import { XTableFlexEvents, XTableFlexProps, XTableRequestColumnsProps } from '../../advance';
+export interface XTableRequestConfigColumnsProps<QR, D> extends Omit<XTableRequestColumnsProps<D>, 'content'> {
+    content?: (scope: {
+        row: D;
+        index: number;
+    }) => VNodeChild;
+    search?: (scope: {
+        query: QR;
+    }) => VNodeChild;
+}
+export interface XTableRequestConfigProps<U, PT, QR, D> extends Omit<XTableFlexProps<D>, 'columns' | 'showOverflowTooltip'> {
+    request: () => {
+        data: Ref<D[]>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        paging: Ref<Paging>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
+    fields: () => {
+        data: Ref<TableColumnField[]>;
+        update: (fields: TableColumnField[]) => PromiseLike<unknown>;
+    };
+    config: Record<string, XTableRequestConfigColumnsProps<QR, D>>;
+    pagination?: boolean;
+}
+export interface XTableRequestConfigEvents<PT, QR, D> extends XTableFlexEvents<D> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+}
+declare const _default: <U, PT, QR, 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: import('element-plus').TableColumnCtx) => any) | undefined;
+        readonly onRowClick?: ((row: D) => any) | undefined;
+        readonly onRowDblclick?: ((row: D) => any) | undefined;
+        readonly onSelectionChange?: ((rows: D[]) => any) | undefined;
+        readonly onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onHeaderDragend" | "onRowClick" | "onRowDblclick" | "onSelectionChange" | "onPrepare"> & XTableRequestConfigProps<U, PT, QR, D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        search: import('@vueuse/shared').UseDebounceFnReturn<() => Promise<void>>;
+        data: Ref<D[], D[]>;
+        paging: Ref<Paging, Paging>;
+        isFetching: Ref<boolean, boolean>;
+        url: U;
+        query: Ref<QR, QR>;
+        path: Ref<PT, PT>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "headerDragend", newWidth: number, oldWidth: number, column: import('element-plus').TableColumnCtx) => void) & ((evt: "rowClick", row: D) => void) & ((evt: "rowDblclick", row: D) => void) & ((evt: "selectionChange", rows: D[]) => void) & ((evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/advance/XTableRequestNext.vue.d.ts

@@ -0,0 +1,89 @@
+import { TableColumnCtx } from 'element-plus';
+import { CSSProperties, Ref, VNodeChild } from 'vue';
+import { Paging } from '../../types';
+import { XTableFlexEvents, XTableFlexProps } from '../../advance';
+import { XTableColumnProps } from '../../basic';
+export interface XTableRequestColumnsProps<D> extends XTableColumnProps<D> {
+    content?: (scope: {
+        index: number;
+        row: D;
+    }) => VNodeChild;
+}
+export interface XTableRequestProps<U, PT, QR, D> extends Omit<XTableFlexProps<D>, 'data' | 'columns'> {
+    request: () => {
+        data: Ref<D[]>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        paging: Ref<Paging>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
+    pagination?: boolean;
+    columns: XTableRequestColumnsProps<D>[];
+    header?: (scope: {
+        query: QR;
+    }) => VNodeChild;
+    footer?: (scope: {
+        query: QR;
+    }) => VNodeChild;
+    cellClassName?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    cellStyle?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+    rowClassName?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    rowStyle?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+}
+export interface XTableRequestEvents<PT, QR, D> extends XTableFlexEvents<D> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+}
+declare const _default: <U, PT, QR, 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 onRowDblclick?: ((row: D) => any) | undefined;
+        readonly onSelectionChange?: ((rows: D[]) => any) | undefined;
+        readonly onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onHeaderDragend" | "onRowClick" | "onRowDblclick" | "onSelectionChange" | "onPrepare"> & XTableRequestProps<U, PT, QR, D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        search: import('@vueuse/shared').UseDebounceFnReturn<() => Promise<void>>;
+        data: Ref<D[], D[]>;
+        paging: Ref<Paging, Paging>;
+        isFetching: Ref<boolean, boolean>;
+        url: U;
+        query: Ref<QR, QR>;
+        path: Ref<PT, PT>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "headerDragend", newWidth: number, oldWidth: number, column: TableColumnCtx) => void) & ((evt: "rowClick", row: D) => void) & ((evt: "rowDblclick", row: D) => void) & ((evt: "selectionChange", rows: D[]) => void) & ((evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/advance/XUploadOssNext.vue.d.ts

@@ -0,0 +1,29 @@
+import { XUploadProps } from '../../basic';
+import { VNodeChild } from 'vue';
+export interface XUploadOssProps extends Omit<XUploadProps, 'action' | 'data' | 'fileList' | 'beforeUpload'> {
+    /** oss 接收文件最大 大约为50兆, 超过50兆应采取oss ststoken 分片上传 */
+    maxSize?: number;
+}
+declare const _default: <V extends string, 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;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: MV;
+    } & XUploadOssProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: () => VNodeChild;
+        tip: () => VNodeChild;
+    }> & {
+        default: () => VNodeChild;
+        tip: () => 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/{basic/XButton.vue.d.ts → components/basic/Button.vue.d.ts}

@@ -1,5 +1,18 @@
 import { ButtonProps } from 'element-plus';
-export interface XButtonProps extends Partial<ButtonProps> {
+export interface XButtonConfig {
+    /**
+     * 两个中文字符之间自动插入空格(仅当文本长度为 2 且所有字符均为中文时才生效)
+     * @default false
+     */
+    autoInsertSpace?: boolean;
+}
+export interface XButtonProps {
+    disabled?: ButtonProps['disabled'];
+    link?: ButtonProps['link'];
+    size?: ButtonProps['size'];
+    text?: ButtonProps['text'];
+    type?: ButtonProps['type'];
+    icon?: ButtonProps['icon'];
 }
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -14,9 +27,7 @@ declare const __VLS_component: import('vue').DefineComponent<XButtonProps, {}, {
     click: (e: MouseEvent) => any;
 }, string, import('vue').PublicProps, Readonly<XButtonProps> & Readonly<{
     onClick?: ((e: MouseEvent) => any) | undefined;
-}>, {
-    readonly disabled: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, 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 & {