@smallwei/avue 3.8.1 → 3.8.3

package/es/packages/core/common/init.mjs

@@ -0,0 +1,134 @@
+import { sendDic, loadDic, loadCascaderDic, loadLocalDic } from '../../../core/dic.mjs';
+import { DIC_PROPS } from '../../../global/variable.mjs';
+import slot from '../../../core/slot.mjs';
+export default function (name) {
+    return {
+        mixins: [slot],
+        emits: ['update:modelValue', 'change'],
+        props: {
+            tableData: {
+                type: Object,
+                default: () => {
+                    return {};
+                },
+            },
+            option: {
+                type: Object,
+                required: true,
+                default: () => {
+                    return {};
+                },
+            },
+        },
+        watch: {
+            propOption: {
+                handler(list) {
+                    list.forEach((ele) => (this.objectOption[ele.prop] = ele));
+                },
+                deep: true,
+            },
+            option: {
+                handler() {
+                    this.init(false);
+                },
+                deep: true,
+            },
+        },
+        data() {
+            return {
+                DIC: {},
+                cascaderDIC: {},
+                tableOption: {},
+                objectOption: {},
+            };
+        },
+        mounted() {
+            this.init();
+        },
+        computed: {
+            isMobile() {
+                return document.body.clientWidth <= 768;
+            },
+            resultOption() {
+                return {
+                    ...this.tableOption,
+                    ...{
+                        column: this.propOption || [],
+                    },
+                };
+            },
+            rowKey() {
+                return this.tableOption.rowKey || DIC_PROPS.rowKey;
+            },
+            formRules() {
+                const result = {};
+                this.propOption.forEach((ele) => {
+                    if (ele.rules && ele.display !== false)
+                        result[ele.prop] = ele.rules;
+                });
+                return result;
+            },
+        },
+        methods: {
+            init(type) {
+                const globOption = this.deepClone(this.$AVUE[`${name}Option`]);
+                const option = {
+                    ...globOption,
+                    ...this.option,
+                };
+                this.tableOption = option;
+                this.handleLocalDic();
+                if (type !== false)
+                    this.handleLoadDic();
+            },
+            dicInit(type) {
+                if (type === 'cascader') {
+                    this.handleLoadCascaderDic();
+                }
+                else {
+                    this.handleLoadDic();
+                }
+            },
+            updateDic(prop, list) {
+                const column = this.findObject(this.propOption, prop);
+                const formatter = column.dicFormatter;
+                const callback = (currentList, useFormatter = true) => {
+                    if (useFormatter && typeof formatter === 'function') {
+                        this.DIC[prop] = formatter(currentList, this.tableForm || this.form);
+                    }
+                    else {
+                        this.DIC[prop] = currentList;
+                    }
+                };
+                if (this.validatenull(list) && this.validatenull(prop)) {
+                    this.handleLoadDic();
+                    return;
+                }
+                if (this.validatenull(list) && !this.validatenull(column.dicUrl)) {
+                    sendDic({
+                        column,
+                    }, this).then((currentList) => {
+                        callback(currentList, false);
+                    });
+                }
+                else {
+                    callback(list || []);
+                }
+            },
+            handleSetDic(list, res = {}) {
+                Object.keys(res).forEach((ele) => {
+                    list[ele] = res[ele];
+                });
+            },
+            handleLocalDic() {
+                loadLocalDic(this.resultOption, this);
+            },
+            handleLoadDic() {
+                loadDic(this.resultOption, this);
+            },
+            handleLoadCascaderDic() {
+                loadCascaderDic(this.propOption, this);
+            },
+        },
+    };
+}

package/es/packages/core/common/init.ts

@@ -0,0 +1,133 @@
+import { sendDic, loadDic, loadCascaderDic, loadLocalDic } from '../../../core/dic';
+import { DIC_PROPS } from '../../../global/variable';
+import slot from '../../../core/slot';
+
+export default function (name: string) {
+  return {
+    mixins: [slot],
+    emits: ['update:modelValue', 'change'],
+    props: {
+      tableData: {
+        type: Object,
+        default: () => {
+          return {};
+        },
+      },
+      option: {
+        type: Object,
+        required: true,
+        default: () => {
+          return {};
+        },
+      },
+    },
+    watch: {
+      propOption: {
+        handler(list: any[]) {
+          list.forEach((ele) => (this.objectOption[ele.prop] = ele));
+        },
+        deep: true,
+      },
+      option: {
+        handler() {
+          this.init(false);
+        },
+        deep: true,
+      },
+    },
+    data() {
+      return {
+        DIC: {},
+        cascaderDIC: {},
+        tableOption: {},
+        objectOption: {},
+      };
+    },
+    mounted() {
+      this.init();
+    },
+    computed: {
+      isMobile() {
+        return document.body.clientWidth <= 768;
+      },
+      resultOption() {
+        return {
+          ...this.tableOption,
+          ...{
+            column: this.propOption || [],
+          },
+        };
+      },
+      rowKey() {
+        return this.tableOption.rowKey || DIC_PROPS.rowKey;
+      },
+      formRules() {
+        const result: Record<string, any> = {};
+        this.propOption.forEach((ele: any) => {
+          if (ele.rules && ele.display !== false) result[ele.prop] = ele.rules;
+        });
+        return result;
+      },
+    },
+    methods: {
+      init(this: any, type?: boolean) {
+        const globOption = this.deepClone(this.$AVUE[`${name}Option`]);
+        const option = {
+          ...globOption,
+          ...this.option,
+        };
+        this.tableOption = option;
+        this.handleLocalDic();
+        if (type !== false) this.handleLoadDic();
+      },
+      dicInit(this: any, type: string) {
+        if (type === 'cascader') {
+          this.handleLoadCascaderDic();
+        } else {
+          this.handleLoadDic();
+        }
+      },
+      updateDic(this: any, prop: string, list?: any[]) {
+        const column = this.findObject(this.propOption, prop);
+        const formatter = column.dicFormatter;
+        const callback = (currentList: any[], useFormatter = true) => {
+          if (useFormatter && typeof formatter === 'function') {
+            this.DIC[prop] = formatter(currentList, this.tableForm || this.form);
+          } else {
+            this.DIC[prop] = currentList;
+          }
+        };
+        if (this.validatenull(list) && this.validatenull(prop)) {
+          this.handleLoadDic();
+          return;
+        }
+        if (this.validatenull(list) && !this.validatenull(column.dicUrl)) {
+          sendDic(
+            {
+              column,
+            },
+            this
+          ).then((currentList: any[]) => {
+            callback(currentList, false);
+          });
+        } else {
+          callback(list || []);
+        }
+      },
+      handleSetDic(list: Record<string, any>, res: Record<string, any> = {}) {
+        Object.keys(res).forEach((ele) => {
+          list[ele] = res[ele];
+        });
+      },
+      handleLocalDic(this: any) {
+        loadLocalDic(this.resultOption, this);
+      },
+      handleLoadDic(this: any) {
+        loadDic(this.resultOption, this);
+      },
+      handleLoadCascaderDic(this: any) {
+        loadCascaderDic(this.propOption, this);
+      },
+    },
+  };
+}

package/es/packages/core/common/props.mjs

@@ -0,0 +1,239 @@
+import { DIC_PROPS, DIC_SPLIT, DIC_HTTP_PROPS } from '../../../global/variable.mjs';
+import slot from '../../../core/slot.mjs';
+export default function () {
+    return {
+        mixins: [slot],
+        emits: ['update:modelValue', 'click', 'focus', 'blur', 'change'],
+        data() {
+            return {
+                stringMode: false,
+                name: '',
+                text: undefined,
+                propsHttpDefault: DIC_HTTP_PROPS,
+                propsDefault: DIC_PROPS,
+            };
+        },
+        props: {
+            blur: Function,
+            focus: Function,
+            change: Function,
+            click: Function,
+            typeformat: Function,
+            control: Function,
+            separator: {
+                type: String,
+                default: DIC_SPLIT,
+            },
+            params: {
+                type: Object,
+                default: () => {
+                    return {};
+                },
+            },
+            listType: {
+                type: String,
+                default: '',
+            },
+            tableData: {
+                type: Object,
+                default: () => {
+                    return {};
+                },
+            },
+            modelValue: {},
+            column: {
+                type: Object,
+                default: () => {
+                    return {};
+                },
+            },
+            label: {
+                type: String,
+                default: '',
+            },
+            readonly: {
+                type: Boolean,
+                default: false,
+            },
+            size: {
+                type: String,
+                default: '',
+            },
+            tip: {
+                type: String,
+                default: '',
+            },
+            disabled: {
+                type: Boolean,
+                default: false,
+            },
+            dataType: {
+                type: String,
+            },
+            clearable: {
+                type: Boolean,
+                default: true,
+            },
+            type: {
+                type: String,
+                default: '',
+            },
+            dicUrl: {
+                type: String,
+                default: '',
+            },
+            dicMethod: {
+                type: String,
+                default: '',
+            },
+            dicFormatter: Function,
+            dicQuery: {
+                type: Object,
+                default: () => {
+                    return {};
+                },
+            },
+            dic: {
+                type: [Array, Function],
+                default: () => {
+                    return [];
+                },
+            },
+            placeholder: {
+                type: String,
+                default: '',
+            },
+            rules: {
+                type: Array,
+            },
+            min: {
+                type: Number,
+            },
+            max: {
+                type: Number,
+            },
+            multiple: {
+                type: Boolean,
+                default: false,
+            },
+            button: {
+                type: Boolean,
+                default: false,
+            },
+            row: {
+                type: Boolean,
+                default: false,
+            },
+            prop: {
+                type: String,
+                default: '',
+            },
+            border: {
+                type: Boolean,
+                default: false,
+            },
+            popperClass: {
+                type: String,
+            },
+            propsHttp: {
+                type: Object,
+                default: () => DIC_HTTP_PROPS,
+            },
+            props: {
+                type: Object,
+                default: () => DIC_PROPS,
+            },
+        },
+        watch: {
+            text: {
+                handler(val) {
+                    this.handleChange(val);
+                    this.handleTextValue && this.handleTextValue(val);
+                },
+                deep: true,
+            },
+            modelValue: {
+                handler(val) {
+                    this.initVal();
+                    this.handleModelValue && this.handleModelValue(val);
+                },
+                deep: true,
+            },
+        },
+        computed: {
+            clearableVal() {
+                return this.disabled ? false : this.clearable;
+            },
+            componentName() {
+                const type = 'el';
+                return `${type}-${this.name}${this.button ? '-button' : ''}`;
+            },
+            required() {
+                return !this.validatenull(this.rules);
+            },
+            isGroup() {
+                let result = false;
+                this.dic.forEach((ele) => {
+                    if (ele[this.groupsKey]) {
+                        result = true;
+                    }
+                });
+                return result;
+            },
+            isArray() {
+                return this.dataType === 'array';
+            },
+            isString() {
+                return this.dataType === 'string';
+            },
+            isNumber() {
+                return this.dataType === 'number';
+            },
+            isJson() {
+                return this.dataType === 'json';
+            },
+            nameKey() {
+                return this.propsHttp.name || this.propsHttpDefault.name;
+            },
+            urlKey() {
+                return this.propsHttp.url || this.propsHttpDefault.url;
+            },
+            resKey() {
+                return this.propsHttp.res || this.propsHttpDefault.res;
+            },
+            fileTypeKey() {
+                return this.propsHttp.fileType || this.propsHttpDefault.fileType;
+            },
+            groupsKey() {
+                return this.props.groups || this.propsDefault.groups;
+            },
+            valueKey() {
+                return this.props.value || this.propsDefault.value;
+            },
+            typeKey() {
+                return this.props.type || this.propsDefault.type;
+            },
+            descKey() {
+                return this.props.desc || this.propsDefault.desc;
+            },
+            leafKey() {
+                return this.props.leaf || this.propsDefault.leaf;
+            },
+            labelKey() {
+                return this.props.label || this.propsDefault.label;
+            },
+            childrenKey() {
+                return this.props.children || this.propsDefault.children;
+            },
+            disabledKey() {
+                return this.props.disabled || this.propsDefault.disabled;
+            },
+            idKey() {
+                return this.props.id || this.propsDefault.id;
+            },
+        },
+        created() {
+            this.initVal();
+        },
+    };
+}