@smallwei/avue 3.8.4 → 3.8.6

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

@@ -1,133 +0,0 @@
-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.ts

@@ -1,240 +0,0 @@
-import { DIC_PROPS, DIC_SPLIT, DIC_HTTP_PROPS } from '../../../global/variable';
-import slot from '../../../core/slot';
-
-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: any) {
-          this.handleChange(val);
-          this.handleTextValue && this.handleTextValue(val);
-        },
-        deep: true,
-      },
-      modelValue: {
-        handler(val: any) {
-          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: any) => {
-          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();
-    },
-  };
-}

package/lib/packages/core/components/dialog-form/index.ts

@@ -1,29 +0,0 @@
-import { createVNode, render } from 'vue';
-import Main from './index.vue';
-
-export default function (_context: any) {
-  const defaultContext = _context;
-  return (opt: Record<string, any>) => {
-    const options = {
-      opt,
-    };
-    let appendTo: Element | HTMLElement | null = opt.appendTo;
-    if (opt.appendTo) {
-      appendTo = document.querySelector(opt.appendTo);
-    } else {
-      appendTo = document.body;
-    }
-    const parent = document.createElement('div');
-    const instance: any = createVNode(Main, options);
-    instance.appContext = defaultContext;
-    const onDestroy = () => {
-      render(null, parent);
-      parent.remove();
-    };
-    instance.props.onDestroy = onDestroy;
-    instance.close = onDestroy;
-    render(instance, parent);
-    appendTo?.appendChild(parent);
-    return instance;
-  };
-}

package/lib/packages/core/components/dialog-form/index.vue

@@ -1,108 +0,0 @@
-<template>
-  <component :is="dialogType"
-             v-model="visible"
-             destroy-on-close
-             class="avue-dialog"
-             :beforeClose="beforeClose"
-             v-bind="dialog">
-    <avue-form ref="form"
-               :option="{...deepClone(option),...{menuBtn: false}}"
-               v-model="data"
-               v-model:status="disabled"
-               @submit="handleSubmit"
-               @reset-change="close"></avue-form>
-    <span class="avue-dialog__footer"
-          v-if="validData(option.menuBtn,true)"
-          :class="'avue-dialog__footer--'+menuPosition">
-      <el-button @click="submit"
-                 :size="$AVUE.size"
-                 :icon="option.submitIcon"
-                 :loading="disabled"
-                 v-if="validData(option.submitBtn,true)"
-                 type="primary">{{option.submitText}}</el-button>
-      <el-button @click="reset"
-                 v-if="validData(option.emptyBtn,true)"
-                 :disabled="disabled"
-                 :size="$AVUE.size"
-                 :icon="option.emptyIcon ">{{option.emptyText}}</el-button>
-    </span>
-  </component>
-</template>
-<script>
-import locale from "../../../../core/locale.js";
-export default {
-  mixins: [locale],
-  props: {
-    opt: Object,
-    onDestroy: Function
-  },
-  data () {
-    return {
-      disabled: false,
-      callback: null,
-      visible: true,
-      dialog: {
-        closeOnClickModal: false
-      },
-      isDrawer: false,
-      option: {
-        submitText: this.t('form.submitBtn'),
-        emptyText: this.t('common.closeBtn'),
-        submitIcon: 'el-icon-check',
-        emptyIcon: 'el-icon-close',
-        column: []
-      },
-      data: {}
-    };
-  },
-  created () {
-    this.show()
-  },
-  computed: {
-    dialogType () {
-      return this.isDrawer ? 'elDrawer' : 'elDialog'
-    },
-    menuPosition () {
-      return this.opt.menuPosition || 'center'
-    }
-  },
-  methods: {
-    submit () {
-      this.$refs.form.submit()
-    },
-    reset () {
-      this.$refs.form.resetForm()
-    },
-    beforeClose (done) {
-      done()
-      this.close()
-    },
-    show () {
-      let opt = this.opt;
-      this.callback = opt.callback;
-      let dialog = this.deepClone(opt);
-      ['callback', 'option', 'data'].forEach(ele => delete dialog[ele])
-      this.dialog = Object.assign(this.dialog, dialog);
-      this.dialog.size = this.dialog.width
-      this.isDrawer = this.dialog.type === 'drawer';
-      this.option = Object.assign(this.option, opt.option);
-      this.data = opt.data;
-      this.visible = true;
-    },
-    close () {
-      const callback = () => {
-        this.visible = false;
-        this.onDestroy()
-      }
-      if (typeof this.dialog.beforeClose === 'function') {
-        this.dialog.beforeClose(callback);
-      } else {
-        callback()
-      }
-    },
-    handleSubmit (data, done) {
-      this.callback && this.callback({ data: data, close: this.close, done: done });
-    }
-  }
-};
-</script>

package/lib/packages/core/components/form/custom.ts

@@ -1,41 +0,0 @@
-export default {
-  props: {
-    render: Function,
-    row: Object,
-    index: [String, Number],
-    column: {
-      type: Object,
-      default: () => {
-        return {};
-      },
-    },
-    dic: {
-      type: Array,
-      default: () => {
-        return [];
-      },
-    },
-    params: {
-      type: Object,
-      default: () => {
-        return {};
-      },
-    },
-    event: {
-      type: Object,
-      default: () => {
-        return {};
-      },
-    },
-  },
-  render(this: any) {
-    return this.render.call(this, {
-      column: this.column,
-      dic: this.dic,
-      params: this.params,
-      event: this.event,
-      row: this.row,
-      index: this.index,
-    });
-  },
-};