@dt-frames/ui 2.0.8 → 2.0.10

package/es/components/form/src/types/form.type.d.ts

@@ -1,14 +1,15 @@
 import { Recordable } from "@dt-frames/core";
 import { ComputedRef, ExtractPropTypes, Ref, VNode } from "vue";
-import { RuleObject } from 'ant-design-vue/lib/form/interface';
+import { RuleObject } from 'ant-design-vue/es/form/interface';
 import { TooltipProps } from "ant-design-vue/es/tooltip/Tooltip";
 import { BasicProps } from "../props";
+import type { Cascader, Checkbox, CheckboxGroup, DatePicker, Divider, Input, InputGroup, InputNumber, InputPassword, InputSearch, InputTextArea, InputWithDialog, Radio, RadioGroup, RangePicker, Rate, Select, Switch, TimePicker, TreeSelect } from "./items.type";
 export declare type ButtonFlag = 'OK' | 'CANCEL';
 export declare type Rule = RuleObject & {
     trigger?: 'blur' | 'change' | ['change', 'blur'];
 };
 export declare type FormProps = Partial<ExtractPropTypes<typeof BasicProps>>;
-export declare type ComponentType = 'Input' | 'InputWithDialog' | 'InputGroup' | 'InputPassword' | 'InputSearch' | 'InputTextArea' | 'InputNumber' | 'InputCountDown' | 'Select' | 'TreeSelect' | 'ApiTree' | 'ApiTreeSelect' | 'Radio' | 'RadioButtonGroup' | 'RadioGroup' | 'Checkbox' | 'CheckboxGroup' | 'AutoComplete' | 'Cascader' | 'DatePicker' | 'MonthPicker' | 'RangePicker' | 'WeekPicker' | 'TimePicker' | 'Switch' | 'Upload' | 'IconPicker' | 'Render' | 'Slider' | 'Rate' | 'Divider' | 'Icon';
+export declare type ComponentType = 'Input' | 'InputWithDialog' | 'InputGroup' | 'InputPassword' | 'InputSearch' | 'InputTextArea' | 'InputNumber' | 'Select' | 'TreeSelect' | 'Radio' | 'RadioButtonGroup' | 'RadioGroup' | 'Checkbox' | 'CheckboxGroup' | 'AutoComplete' | 'Cascader' | 'DatePicker' | 'MonthPicker' | 'RangePicker' | 'WeekPicker' | 'TimePicker' | 'Switch' | 'Upload' | 'Slider' | 'Rate' | 'Divider';
 export declare type ColEx = {
     style?: any;
     span?: number | string;
@@ -18,7 +19,7 @@ export declare type ColEx = {
     xl?: number | string;
     xxl?: number | string;
 };
-export declare type FormSchema = {
+declare type Schema<ComponentType, T> = {
     t?: string;
     name?: string | string[];
     changeEvent?: string;
@@ -30,12 +31,13 @@ export declare type FormSchema = {
     toolTip?: boolean | ((model: Recordable) => boolean);
     toolTipProps?: TooltipProps;
     component?: ComponentType;
-    props?: ((model: Recordable) => Recordable) | object;
+    props?: ((model: Recordable) => T) | T;
     required?: boolean | ((model: Recordable) => boolean) | Ref<boolean> | ComputedRef<boolean>;
     suffix?: string | number | VNode | ((model: Recordable) => VNode | VNode[] | string);
     prefix?: string | number | VNode | ((model: Recordable) => VNode | VNode[] | string);
     rules?: Rule[];
     rulesMessageJoinLabel?: boolean;
+    validateTrigger?: string | string[] | false;
     defaultValue?: any;
     show?: boolean | ((model: Recordable) => boolean);
     render?: (model: Recordable) => VNode | VNode[] | string;
@@ -50,9 +52,12 @@ export declare type FormSchema = {
     labelCol?: Partial<ColEx>;
     wrapperCol?: Partial<ColEx>;
     isAdvanced?: boolean;
-    openDialog?: (parms: Recordable) => void;
     extraName?: string[];
 };
+export declare type FormSchema = Schema<'Input', Input> | Schema<'InputWithDialog', InputWithDialog> | Schema<'InputGroup', InputGroup> | Schema<'InputPassword', InputPassword> | Schema<'InputSearch', InputSearch> | Schema<'InputTextArea', InputTextArea> | Schema<'InputNumber', InputNumber> | Schema<'Select', Select> | Schema<'TreeSelect', TreeSelect> | Schema<'Radio', Radio> | Schema<'RadioButtonGroup', Radio> | Schema<'RadioGroup', RadioGroup> | Schema<'Checkbox', Checkbox> | Schema<'CheckboxGroup', CheckboxGroup> | Schema<'AutoComplete', Recordable> | Schema<'Cascader', Cascader> | Schema<'DatePicker', DatePicker> | Schema<'MonthPicker', DatePicker> | Schema<'RangePicker', RangePicker> | Schema<'WeekPicker', DatePicker> | Schema<'TimePicker', TimePicker> | Schema<'Switch', Switch> | Schema<'Slider', {
+    disabled?: boolean;
+    [key: string]: any;
+}> | Schema<'Rate', Rate> | Schema<'Divider', Divider>;
 export declare type ButtonProps = {
     t?: string;
     label: string;
@@ -68,3 +73,4 @@ export declare type ButtonProps = {
     loading?: Ref<boolean>;
     onClick?: (args?: any) => any;
 };
+export {};

package/es/components/form/src/types/items.type.d.ts

@@ -0,0 +1,382 @@
+import { DtEvent, Recordable, SelectOptions } from "@dt-frames/core";
+import dayjs from "dayjs";
+import { Ref, Slot, VNode, CSSProperties, ComputedRef } from "vue";
+declare type BaseInput = {
+    placeholder?: string;
+    addonAfter?: string | VNode;
+    addonBefore?: string | VNode;
+    allowClear?: boolean;
+    bordered?: boolean;
+    defaultValue?: string;
+    disabled?: boolean | Ref<boolean>;
+    id?: string;
+    maxlength?: number;
+    prefix?: string | VNode;
+    showCount?: boolean;
+    size?: 'large' | 'default' | 'small';
+    suffix?: string | VNode;
+    [key: string]: any;
+};
+export declare type Input = BaseInput & {
+    onChange?: (e: DtEvent, model: Recordable) => void;
+    onPressEnter?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputGroup = {
+    defaultValue?: any[];
+    compact?: boolean;
+    size?: 'large' | 'default' | 'small';
+    [key: string]: any;
+};
+export declare type InputPassword = Input & {
+    visibilityToggle?: boolean;
+    onChange?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputSearch = Input & {
+    enterButton?: boolean | VNode;
+    loading?: boolean | Ref<boolean>;
+    onSearch?: (searchValue: string) => void;
+    onChange?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputTextArea = Input & {
+    autosize?: boolean | object;
+    onPressEnter?: (e: DtEvent, model: Recordable) => void;
+    onChange?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputNumber = {
+    addonAfter?: string | VNode;
+    addonBefore?: string | VNode;
+    autofocus?: boolean;
+    bordered?: boolean;
+    controls?: boolean;
+    decimalSeparator?: string;
+    defaultValue?: number;
+    disabled?: boolean | Ref<boolean>;
+    formatter?: (value: number | string, info: {
+        userTyping: boolean;
+        input: string;
+    }) => string;
+    parser?: (value: string) => number | string;
+    keyboard?: boolean;
+    max?: number;
+    min?: number;
+    precision?: number;
+    prefix?: string | VNode;
+    size?: 'large' | 'default' | 'small';
+    step?: number | string;
+    stringMode?: boolean;
+    onChange?: (value: number | string, model: Recordable) => void;
+    onPressEnter?: (e: DtEvent, model: Recordable) => void;
+    onStep?: (value: number, info: {
+        offset: number;
+        type: 'up' | 'down';
+    }, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type Select = {
+    allowClear?: boolean;
+    autoClearSearchValue?: boolean;
+    autofocus?: boolean;
+    bordered?: boolean;
+    clearIcon?: VNode | Slot;
+    defaultActiveFirstOption?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean | Ref<boolean>;
+    dropdownClassName?: string;
+    dropdownMatchSelectWidth?: boolean | number;
+    dropdownMenuStyle?: CSSProperties;
+    dropdownRender?: ({ menuNode, props }: {
+        menuNode: any;
+        props: any;
+    }) => VNode | Slot;
+    dropdownStyle?: CSSProperties;
+    fieldNames?: {
+        options?: string;
+        label?: string;
+        value?: string;
+    };
+    filterOption?: boolean | ((inputValue: string, option: SelectOptions) => object);
+    firstActiveValue?: string | string[];
+    getPopupContainer?: () => object;
+    listHeight?: number;
+    maxTagCount?: number;
+    maxTagPlaceholder?: Slot;
+    maxTagTextLength?: number;
+    menuItemSelectedIcon?: VNode | Slot;
+    mode?: 'multiple' | 'tags' | 'combobox';
+    notFoundContent?: string | Slot;
+    open?: boolean;
+    optionFilterProp?: string;
+    options?: SelectOptions[] | ComputedRef<SelectOptions[]> | Ref<SelectOptions[]>;
+    placeholder?: string;
+    removeIcon?: VNode | Slot;
+    searchValue?: string;
+    showArrow?: boolean;
+    showSearch?: boolean;
+    size?: 'large' | 'default' | 'small';
+    suffixIcon?: VNode | Slot;
+    virtual?: boolean;
+    onBlur?: (e: DtEvent, model: Recordable) => void;
+    onChange?: (value: string | number | boolean, option: SelectOptions, model: Recordable) => void;
+    onDeselect?: (value: string | number | boolean, option: SelectOptions, model: Recordable) => void;
+    dropdownVisibleChange?: (option: SelectOptions, model: Recordable) => void;
+    onFocus?: (e: DtEvent, model: Recordable) => void;
+    onInputKeyDown?: (e: DtEvent, model: Recordable) => void;
+    onPopupScroll?: (e: DtEvent, model: Recordable) => void;
+    onSearch?: (val: string, model: Recordable) => void;
+    onSelect?: (value: string | number | boolean, option: SelectOptions, model: Recordable) => void;
+    [key: string]: any;
+};
+declare type TreeNode = {
+    checkable?: boolean;
+    disableCheckbox?: boolean;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    key?: string | number;
+    selectable?: boolean;
+    title?: string | Slot;
+    value?: string;
+    children?: TreeNode[];
+    [key: string]: any;
+};
+export declare type TreeSelect = {
+    allowClear?: boolean;
+    defaultValue?: string | string[];
+    disabled?: boolean | Ref<boolean>;
+    dropdownClassName?: string;
+    dropdownMatchSelectWidth?: boolean | number;
+    dropdownStyle?: CSSProperties;
+    fieldNames?: {
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    filterTreeNode?: boolean | ((inputValue: string, treeNode: TreeNode) => boolean);
+    getPopupContainer?: () => object;
+    listHeight?: number;
+    maxTagCount?: number;
+    multiple?: boolean;
+    placeholder?: string;
+    replaceFields?: {
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    searchPlaceholder?: string;
+    showSearch?: boolean;
+    size?: 'large' | 'default' | 'small';
+    treeCheckable?: boolean;
+    treeCheckStrictly?: boolean;
+    treeData?: TreeNode[];
+    treeDataSimpleMode?: boolean;
+    treeDefaultExpandAll?: boolean;
+    treeDefaultExpandedKeys?: string[] | number[];
+    treeExpandedKeys?: string[] | number[];
+    treeIcon?: boolean;
+    treeLine?: boolean;
+    treeNodeFilterProp?: string;
+    treeNodeLabelProp?: string;
+    virtual?: boolean;
+    onChange?: (value: string | number, label: string, extra: object, model: Recordable) => void;
+    onDropdownVisibleChange?: (open: boolean, model: Recordable) => void;
+    onSearch?: (val: string, model: Recordable) => void;
+    onSelect?: (val: string | number, node: TreeNode, extra: object, model: Recordable) => void;
+    onTreeExpand?: (expandedKeys: (string | number)[], model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type Radio = {
+    autofocus?: boolean;
+    defaultValue?: string | number;
+    disabled?: boolean | Ref<boolean>;
+    value?: string | number;
+    [key: string]: any;
+};
+export declare type RadioGroup = {
+    buttonStyle?: 'outline' | 'solid';
+    disabled?: boolean;
+    name?: string;
+    options?: string[] | number[] | SelectOptions[] | ComputedRef<SelectOptions[]> | Ref<SelectOptions[]>;
+    optionType?: 'default' | 'button';
+    size?: 'large' | 'default' | 'small';
+    defaultValue?: string | number | boolean;
+    [key: string]: any;
+};
+export declare type Checkbox = {
+    autofocus?: boolean;
+    defaultValue?: string | number | boolean;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    value?: boolean | string | number;
+    onChange?: (e: Event, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type CheckboxGroup = {
+    defaultValue?: (string | number | boolean)[];
+    disabled?: boolean;
+    name?: string;
+    options?: string[] | (SelectOptions & {
+        indeterminate?: boolean;
+    })[] | ComputedRef<(SelectOptions & {
+        indeterminate?: boolean;
+    })[]> | Ref<(SelectOptions & {
+        indeterminate?: boolean;
+    })[]>;
+    onChange?: (checkedValue: (string | number | boolean)[], model: Recordable) => void;
+    [key: string]: any;
+};
+declare type CascaderOption = {
+    value?: string | number;
+    label?: any;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    children?: CascaderOption[];
+    [key: string]: any;
+};
+export declare type Cascader = {
+    allowClear?: boolean;
+    autofocus?: boolean;
+    bordered?: boolean;
+    clearIcon?: VNode;
+    changeOnSelect?: boolean;
+    defaultValue?: string[] | number[];
+    disabled?: boolean;
+    dropdownClassName?: string;
+    dropdownStyle?: CSSProperties;
+    expandIcon?: VNode;
+    expandTrigger?: 'click' | 'hover';
+    fieldNames?: {
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    getPopupContainer?: () => object;
+    loadData?: (selectedOptions: CascaderOption) => void;
+    maxTagCount?: number | 'responsive';
+    multiple?: boolean;
+    notFoundContent?: string | VNode;
+    open?: boolean;
+    options?: CascaderOption[] | ComputedRef<CascaderOption[]> | Ref<CascaderOption[]>;
+    placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+    searchValue?: string;
+    showSearch?: boolean | object;
+    size?: 'large' | 'default' | 'small';
+    suffixIcon?: string | VNode | Slot;
+    filter?: (inputValue: string | number, path: any) => boolean;
+    limit?: number | false;
+    matchInputWidth?: boolean;
+    render?: (inputValue: string | number, path: any) => VNode;
+    sort?: (a: Recordable, b: Recordable, inputValue: string | number) => boolean;
+    onChange?: (value: string | number, selectedOptions: CascaderOption, model: Recordable) => void;
+    dropdownVisibleChange?: (val: boolean, model: Recordable) => void;
+    onSearch?: (val: string | number, model: Recordable) => void;
+    [key: string]: any;
+};
+declare type BaseDatepicker = {
+    allowClear?: boolean;
+    autofocus?: boolean;
+    bordered?: boolean;
+    disabled?: boolean;
+    disabledDate?: (currentDate: any) => boolean;
+    dropdownClassName?: string;
+    getPopupContainer?: object;
+    inputReadOnly?: boolean;
+    mode?: 'time' | 'date' | 'month' | 'year' | 'decade';
+    open?: boolean | Ref<boolean>;
+    picker?: 'date' | 'week' | 'month' | 'quarter' | 'year';
+    placeholder?: string;
+    popupStyle?: CSSProperties;
+    size?: 'large' | 'middle' | 'small';
+    onOpenChange?: (status: boolean, model: Recordable) => void;
+    onPanelChange?: (val: any, mode: any, model: Recordable) => void;
+};
+export declare type DatePicker = BaseDatepicker & {
+    defaultPickerValue?: dayjs.Dayjs;
+    disabledTime?: (date: dayjs.Dayjs) => boolean;
+    format?: string | ((value: dayjs.Dayjs) => string) | (string | ((value: dayjs.Dayjs) => string))[];
+    showNow?: boolean;
+    showTime?: boolean | {
+        defaultValue?: dayjs.Dayjs;
+    };
+    showToday?: boolean;
+    onChange?: (date: dayjs.Dayjs | string, dateString: string, model: Recordable) => void;
+    onOk?: (date: dayjs.Dayjs | string, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type RangePicker = BaseDatepicker & {
+    allowEmpty?: [boolean, boolean];
+    defaultPickerValue?: dayjs.Dayjs[];
+    disabled?: [boolean, boolean];
+    disabledTime?: (date: dayjs.Dayjs, partial: 'start' | 'end') => boolean;
+    format?: string;
+    showTime?: boolean | {
+        defaultValue?: dayjs.Dayjs[];
+    };
+    onCalendarChange?: (dates: [dayjs.Dayjs, dayjs.Dayjs] | [string, string], dateStrings: [string, string], info: {
+        range: 'start' | 'end';
+    }, model: Recordable) => void;
+    onChange?: (date: [dayjs.Dayjs, dayjs.Dayjs] | [string, string], dateString: [string, string], model: Recordable) => void;
+    onOk?: (date: [dayjs.Dayjs, dayjs.Dayjs] | [string, string], model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type TimePicker = {
+    allowClear?: boolean;
+    autofocus?: boolean;
+    defaultPickerValue?: string | dayjs.Dayjs;
+    bordered?: boolean;
+    clearText?: string;
+    disabled?: boolean;
+    format?: string;
+    getPopupContainer?: () => object;
+    hideDisabledOptions?: boolean;
+    hourStep?: number;
+    inputReadOnly?: boolean;
+    minuteStep?: number;
+    open?: boolean | Ref<boolean>;
+    placeholder?: string | [string | string];
+    popupClassName?: string;
+    popupStyle?: CSSProperties;
+    secondStep?: number;
+    showNow?: boolean;
+    use12Hours?: boolean;
+    onChange?: (time: dayjs.Dayjs | string, dateString: string, model: Recordable) => void;
+    onOpenChange?: (open: boolean) => void;
+    [key: string]: any;
+};
+export declare type Switch = {
+    autofocus?: boolean;
+    checkedChildren?: string | VNode;
+    defaultPickerValue?: boolean | string | number;
+    checkedValue?: boolean | string | number;
+    disabled?: boolean;
+    loading?: boolean | Ref<boolean>;
+    size?: 'default' | 'small';
+    unCheckedChildren?: string | VNode;
+    unCheckedValue?: boolean | string | number;
+    onChange?: (checked: boolean | string | number, event: Event, model: Recordable) => void;
+    onClick?: (checked: boolean | string | number, event: Event, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type Rate = {
+    allowClear?: boolean;
+    allowHalf?: boolean;
+    autofocus?: boolean;
+    defaultPickerValue?: number;
+    character?: string | VNode;
+    count?: number;
+    disabled?: boolean;
+    tooltips?: string[];
+    onBlur?: (e: any, model: Recordable) => void;
+    onChange?: (value: number) => void;
+    [key: string]: any;
+};
+export declare type Divider = {
+    dashed?: boolean;
+    orientation?: boolean;
+    orientationMargin?: string | number;
+    plain?: boolean;
+    type?: 'horizontal' | 'vertical';
+    [key: string]: any;
+};
+export declare type InputWithDialog = Input & {
+    openDialog?: (model: Recordable) => void;
+};
+export {};

package/es/components/modal/index.js

@@ -100,6 +100,12 @@ function useModal(props, setModalData) {
       return;
     nextTick(() => {
       setModalData(data);
+      if (!data)
+        return;
+      if (props?.title && isFunction(props?.title)) {
+        let title = props.title(data);
+        methods.setModalProps({ title });
+      }
     });
   });
   const methods = {
@@ -812,6 +818,9 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
     isAdvanced: {
       type: Boolean,
       default: true
+    },
+    colspan: {
+      type: Object
     }
   },
   emits: ["handle-method"],
@@ -831,6 +840,17 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
         Object.assign(style, {
           display: "inline-block"
         });
+        return { style };
+      } else if (props.mode === null) {
+        Object.assign(style, {
+          display: "flex",
+          justifyContent: "center",
+          marginBottom: "20px"
+        });
+        return {
+          style,
+          span: 24
+        };
       }
       return { style };
     });
@@ -853,8 +873,8 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
       }
     }
     watch(() => props.isAdvanced, (v) => {
-      if (v) {
-        nextTick(() => toggleAdvanced());
+      if (v || props.mode !== "search") {
+        requestAnimationFrame(toggleAdvanced);
       }
     }, {
       immediate: true

package/es/components/modal/index.less

@@ -61,4 +61,7 @@
 	.ant-form-item-control-input-content{
 		display: flex;
 	}
+    .ant-btn{
+        display: flex;
+    }
 }

package/es/components/modal/src/components/Modal.d.ts

@@ -40,7 +40,7 @@ declare const _sfc_main: {
             default: boolean;
         };
         title: {
-            type: import("vue").PropType<String | import("vue").ComputedRef<String>>;
+            type: import("vue").PropType<String | import("vue").ComputedRef<String> | ((data: import("@dt-frames/core").Recordable<any>) => String)>;
         };
         loading: {
             type: BooleanConstructor;

package/es/components/modal/src/components/ModalFooter.d.ts

@@ -54,6 +54,9 @@ declare const _sfc_main: import("vue").DefineComponent<{
             type: BooleanConstructor;
             default: boolean;
         };
+        colspan: {
+            type: ObjectConstructor;
+        };
     }, {
         props: any;
         emits: (event: "handle-method", ...args: any[]) => void;
@@ -72,6 +75,10 @@ declare const _sfc_main: import("vue").DefineComponent<{
         showAdvanceRef: import("vue").ComputedRef<boolean>;
         colOpt: import("vue").ComputedRef<{
             style: import("@dt-frames/core").Recordable<any>;
+            span?: undefined;
+        } | {
+            style: import("@dt-frames/core").Recordable<any>;
+            span: number;
         }>;
         getAdvanceClass: import("vue").ComputedRef<(string | {
             'basic-arrow--active': boolean;
@@ -103,15 +110,18 @@ declare const _sfc_main: import("vue").DefineComponent<{
             type: BooleanConstructor;
             default: boolean;
         };
+        colspan: {
+            type: ObjectConstructor;
+        };
     }>> & {
         "onHandle-method"?: (...args: any[]) => any;
     }, {
         mode: "search" | "dialog";
-        minShowColumn: number;
-        showAdvancedButton: boolean;
         show: boolean;
-        isAdvanced: boolean;
+        showAdvancedButton: boolean;
+        minShowColumn: number;
         buttonList: ButtonProps[];
+        isAdvanced: boolean;
     }>;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("handleSave" | "handleCancel")[], "handleSave" | "handleCancel", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     buttons: PropType<ButtonProps[]>;

package/es/components/modal/src/index.d.ts

@@ -40,7 +40,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
         default: boolean;
     };
     title: {
-        type: import("vue").PropType<String | import("vue").ComputedRef<String>>;
+        type: import("vue").PropType<String | import("vue").ComputedRef<String> | ((data: import("@dt-frames/core").Recordable<any>) => String)>;
     };
     loading: {
         type: BooleanConstructor;
@@ -100,7 +100,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
     afterClose: FunctionConstructor;
 }, {
     props: any;
-    emits: (event: "register" | "visible-change" | "height-change" | "cancel" | "save" | "update:visible", ...args: any[]) => void;
+    emits: (event: "visible-change" | "height-change" | "cancel" | "save" | "register" | "update:visible", ...args: any[]) => void;
     visibleRef: import("vue").Ref<boolean>;
     propsRef: import("vue").Ref<Partial<ExtractPropTypes<{
         t: {
@@ -141,7 +141,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
             default: boolean;
         };
         title: {
-            type: import("vue").PropType<String | import("vue").ComputedRef<String>>;
+            type: import("vue").PropType<String | import("vue").ComputedRef<String> | ((data: import("@dt-frames/core").Recordable<any>) => String)>;
         };
         loading: {
             type: BooleanConstructor;
@@ -257,7 +257,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
                 default: boolean;
             };
             title: {
-                type: import("vue").PropType<String | import("vue").ComputedRef<String>>;
+                type: import("vue").PropType<String | import("vue").ComputedRef<String> | ((data: import("@dt-frames/core").Recordable<any>) => String)>;
             };
             loading: {
                 type: BooleanConstructor;
@@ -567,6 +567,9 @@ declare const _sfc_main: import("vue").DefineComponent<{
                 type: BooleanConstructor;
                 default: boolean;
             };
+            colspan: {
+                type: ObjectConstructor;
+            };
         }, {
             props: any;
             emits: (event: "handle-method", ...args: any[]) => void;
@@ -585,6 +588,10 @@ declare const _sfc_main: import("vue").DefineComponent<{
             showAdvanceRef: import("vue").ComputedRef<boolean>;
             colOpt: import("vue").ComputedRef<{
                 style: import("@dt-frames/core").Recordable<any>;
+                span?: undefined;
+            } | {
+                style: import("@dt-frames/core").Recordable<any>;
+                span: number;
             }>;
             getAdvanceClass: import("vue").ComputedRef<(string | {
                 'basic-arrow--active': boolean;
@@ -616,15 +623,18 @@ declare const _sfc_main: import("vue").DefineComponent<{
                 type: BooleanConstructor;
                 default: boolean;
             };
+            colspan: {
+                type: ObjectConstructor;
+            };
         }>> & {
             "onHandle-method"?: (...args: any[]) => any;
         }, {
             mode: "search" | "dialog";
-            minShowColumn: number;
-            showAdvancedButton: boolean;
             show: boolean;
-            isAdvanced: boolean;
+            showAdvancedButton: boolean;
+            minShowColumn: number;
             buttonList: import("../../form/src/types/form.type").ButtonProps[];
+            isAdvanced: boolean;
         }>;
     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("handleSave" | "handleCancel")[], "handleSave" | "handleCancel", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
         buttons: import("vue").PropType<import("../../form/src/types/form.type").ButtonProps[]>;
@@ -649,7 +659,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
         showSave: boolean;
         showCancel: boolean;
     }>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("register" | "visible-change" | "height-change" | "cancel" | "save" | "update:visible")[], "register" | "visible-change" | "height-change" | "cancel" | "save" | "update:visible", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("visible-change" | "height-change" | "cancel" | "save" | "register" | "update:visible")[], "visible-change" | "height-change" | "cancel" | "save" | "register" | "update:visible", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
     t: {
         type: StringConstructor;
     };
@@ -688,7 +698,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
         default: boolean;
     };
     title: {
-        type: import("vue").PropType<String | import("vue").ComputedRef<String>>;
+        type: import("vue").PropType<String | import("vue").ComputedRef<String> | ((data: import("@dt-frames/core").Recordable<any>) => String)>;
     };
     loading: {
         type: BooleanConstructor;
@@ -747,27 +757,27 @@ declare const _sfc_main: import("vue").DefineComponent<{
     closeFunc: import("vue").PropType<() => Promise<boolean>>;
     afterClose: FunctionConstructor;
 }>> & {
-    onRegister?: (...args: any[]) => any;
-    "onUpdate:visible"?: (...args: any[]) => any;
     "onVisible-change"?: (...args: any[]) => any;
     "onHeight-change"?: (...args: any[]) => any;
     onCancel?: (...args: any[]) => any;
     onSave?: (...args: any[]) => any;
+    onRegister?: (...args: any[]) => any;
+    "onUpdate:visible"?: (...args: any[]) => any;
 }, {
-    loading: boolean;
     visible: boolean;
-    mask: boolean;
     closable: boolean;
     destroyOnClose: boolean;
     scrollTop: boolean;
     draggable: boolean;
     defaultFullscreen: boolean;
     canFullscreen: boolean;
+    loading: boolean;
     loadingTip: string;
     useWrapper: boolean;
     centered: boolean;
     showOkBtn: boolean;
     showCancelBtn: boolean;
+    mask: boolean;
     maskClosable: boolean;
     keyboard: boolean;
 }>;