@smallwei/avue 3.8.2 → 3.8.4

package/lib/packages/core/common/event.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const dataformat_js_1 = require("../../../core/dataformat.js");
+const util_js_1 = require("../../../utils/util.js");
+function default_1() {
+    return {
+        methods: {
+            bindEvent(name, params) {
+                const item = (0, util_js_1.findNode)(this.dic, this.props, this.text);
+                params = Object.assign(params, { column: this.column, dic: this.dic, item }, this.tableData);
+                if (typeof this[name] === 'function') {
+                    if (name == 'change') {
+                        if (this.column.cell != true) {
+                            this[name](params);
+                        }
+                    }
+                    else {
+                        this[name](params);
+                    }
+                }
+                this.$emit(name, params);
+            },
+            initVal() {
+                this.stringMode = typeof this.modelValue == 'string';
+                this.text = (0, dataformat_js_1.initVal)(this.modelValue, this);
+            },
+            getLabelText(item) {
+                if (this.validatenull(item))
+                    return '';
+                if (typeof this.typeformat === 'function') {
+                    return this.typeformat(item, this.labelKey, this.valueKey);
+                }
+                return item[this.labelKey];
+            },
+            handleFocus(event) {
+                this.bindEvent('focus', { value: this.modelValue, event });
+            },
+            handleBlur(event) {
+                this.bindEvent('blur', { value: this.modelValue, event });
+            },
+            handleClick(event) {
+                this.bindEvent('click', { value: this.modelValue, event });
+            },
+            handleChange(value) {
+                let result = value;
+                if (this.isJson) {
+                    result = JSON.stringify(value);
+                }
+                else {
+                    const flag = this.isString || this.isNumber || this.stringMode || this.listType === 'picture-img';
+                    if (flag && Array.isArray(value)) {
+                        result = value.join(this.separator);
+                    }
+                }
+                this.bindEvent('change', { value: result });
+                this.$emit('update:modelValue', result);
+            },
+        },
+    };
+}

package/lib/packages/core/common/event.ts

@@ -0,0 +1,56 @@
+import { initVal } from '../../../core/dataformat';
+import { findNode } from '../../../utils/util';
+
+export default function () {
+  return {
+    methods: {
+      bindEvent(this: any, name: string, params: Record<string, any>) {
+        const item = findNode(this.dic, this.props, this.text);
+        params = Object.assign(params, { column: this.column, dic: this.dic, item }, this.tableData);
+        if (typeof this[name] === 'function') {
+          if (name == 'change') {
+            if (this.column.cell != true) {
+              this[name](params);
+            }
+          } else {
+            this[name](params);
+          }
+        }
+        this.$emit(name, params);
+      },
+      initVal(this: any) {
+        this.stringMode = typeof this.modelValue == 'string';
+        this.text = initVal(this.modelValue, this);
+      },
+      getLabelText(this: any, item: any) {
+        if (this.validatenull(item)) return '';
+        if (typeof this.typeformat === 'function') {
+          return this.typeformat(item, this.labelKey, this.valueKey);
+        }
+        return item[this.labelKey];
+      },
+      handleFocus(this: any, event: Event) {
+        this.bindEvent('focus', { value: this.modelValue, event });
+      },
+      handleBlur(this: any, event: Event) {
+        this.bindEvent('blur', { value: this.modelValue, event });
+      },
+      handleClick(this: any, event: Event) {
+        this.bindEvent('click', { value: this.modelValue, event });
+      },
+      handleChange(this: any, value: any) {
+        let result = value;
+        if (this.isJson) {
+          result = JSON.stringify(value);
+        } else {
+          const flag = this.isString || this.isNumber || this.stringMode || this.listType === 'picture-img';
+          if (flag && Array.isArray(value)) {
+            result = value.join(this.separator);
+          }
+        }
+        this.bindEvent('change', { value: result });
+        this.$emit('update:modelValue', result);
+      },
+    },
+  };
+}

package/lib/packages/core/common/init.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const dic_js_1 = require("../../../core/dic.js");
+const variable_js_1 = require("../../../global/variable.js");
+const slot_js_1 = __importDefault(require("../../../core/slot.js"));
+function default_1(name) {
+    return {
+        mixins: [slot_js_1.default],
+        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 || variable_js_1.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)) {
+                    (0, dic_js_1.sendDic)({
+                        column,
+                    }, this).then((currentList) => {
+                        callback(currentList, false);
+                    });
+                }
+                else {
+                    callback(list || []);
+                }
+            },
+            handleSetDic(list, res = {}) {
+                Object.keys(res).forEach((ele) => {
+                    list[ele] = res[ele];
+                });
+            },
+            handleLocalDic() {
+                (0, dic_js_1.loadLocalDic)(this.resultOption, this);
+            },
+            handleLoadDic() {
+                (0, dic_js_1.loadDic)(this.resultOption, this);
+            },
+            handleLoadCascaderDic() {
+                (0, dic_js_1.loadCascaderDic)(this.propOption, this);
+            },
+        },
+    };
+}

package/lib/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/lib/packages/core/common/props.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const variable_js_1 = require("../../../global/variable.js");
+const slot_js_1 = __importDefault(require("../../../core/slot.js"));
+function default_1() {
+    return {
+        mixins: [slot_js_1.default],
+        emits: ['update:modelValue', 'click', 'focus', 'blur', 'change'],
+        data() {
+            return {
+                stringMode: false,
+                name: '',
+                text: undefined,
+                propsHttpDefault: variable_js_1.DIC_HTTP_PROPS,
+                propsDefault: variable_js_1.DIC_PROPS,
+            };
+        },
+        props: {
+            blur: Function,
+            focus: Function,
+            change: Function,
+            click: Function,
+            typeformat: Function,
+            control: Function,
+            separator: {
+                type: String,
+                default: variable_js_1.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: () => variable_js_1.DIC_HTTP_PROPS,
+            },
+            props: {
+                type: Object,
+                default: () => variable_js_1.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();
+        },
+    };
+}