@dt-frames/ui 2.0.8 → 2.0.9

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

@@ -0,0 +1,375 @@
+import { DtEvent, Recordable, SelectOptions } from "@dt-frames/core";
+import dayjs from "dayjs";
+import { Ref, Slot, VNode, CSSProperties } 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[];
+    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[];
+    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;
+    })[];
+    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[];
+    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 {};

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/ModalFooter.d.ts

@@ -107,11 +107,11 @@ declare const _sfc_main: import("vue").DefineComponent<{
         "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

@@ -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: {
@@ -620,11 +620,11 @@ declare const _sfc_main: import("vue").DefineComponent<{
             "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 +649,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;
     };
@@ -747,27 +747,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;
 }>;

package/es/components/source/index.js

@@ -7,7 +7,8 @@ import dayjs from "dayjs";
 const getApi = (api, baseUrl) => {
   const loading = {
     onSearch: ref(false),
-    onReset: ref(false)
+    onReset: ref(false),
+    onQuerypage: ref(false)
   };
   const newApi = {};
   const testIsFullApi = (str) => str.startsWith("/") ? str : baseUrl + str;
@@ -274,6 +275,8 @@ function useSource(props) {
             curdInstance && curdInstance.closeModal();
             if (queryAfterUpdate !== false)
               onSearch();
+            if (afterUpdate && isFunction(afterUpdate))
+              afterUpdate(result.data);
           }
         } catch (err) {
         } finally {
@@ -288,6 +291,8 @@ function useSource(props) {
             curdInstance && curdInstance.closeModal();
             if (queryAfterUpdate !== false)
               onSearch();
+            if (afterUpdate && isFunction(afterUpdate))
+              afterUpdate(result.data);
           }
         } catch (err) {
         } finally {
@@ -323,6 +328,8 @@ function useSource(props) {
             !isSingleDelete && tableInstance.clearSelectedRowKeys();
             if (queryAfterUpdate !== false)
               onSearch();
+            if (afterUpdate && isFunction(afterUpdate))
+              afterUpdate(rsp.data);
           }
         }).finally(() => {
           isSingleDelete && (loading.onDeletes.value = false);

package/es/components/source/types/source.type.d.ts

@@ -14,7 +14,7 @@ export declare type SourceOption = {
     exportName?: string | ComputedRef;
     queryAfterUpdate?: boolean;
     beforeUpdate?: (model: Recordable) => boolean | Recordable | undefined;
-    afterUpdate?: () => void;
+    afterUpdate?: (data: Recordable) => void;
     api?: ApiObjType;
 };
 export declare type orderType = {