@smallwei/avue 3.8.5 → 3.8.6

package/lib/packages/element-plus/mention/index.vue

@@ -1,117 +0,0 @@
-<template>
-  <el-mention v-model="text"
-              :class="b()"
-              @click="handleClick"
-              @focus="handleFocus"
-              @blur="handleBlur"
-              :placeholder="placeholder"
-              :size="size"
-              :prefix="prefix"
-              :options="options"
-              :loading="loading"
-              :split="split"
-              :whole="whole"
-              :check-is-whole="checkIsWhole"
-              @search="remote?handleRemoteMethod:undefined"
-              :clearable="clearableVal"
-              :readonly="readonly"
-              :disabled="disabled">
-    <template #prepend
-              v-if="prepend"><span @click="prependClick(text)">{{prepend}}</span>
-    </template>
-    <template #append
-              v-if="append">
-      <span @click="appendClick(text)">{{append}}</span>
-    </template>
-    <template #label="{ item }">
-      <slot :item="item"
-            :label="labelKey"
-            :value="valueKey"
-            v-if="$slots.default">
-      </slot>
-      <span v-else>{{ item.label }}</span>
-    </template>
-  </el-mention>
-</template>
-
-<script>
-import create from "../../../core/create.js";
-import props from "../../core/common/props.js";
-import event from "../../core/common/event.js";
-import { sendDic } from "../../../core/dic.js";
-export default create({
-  name: "mention",
-  mixins: [props(), event()],
-  data () {
-    return {
-      created: false,
-      loading: false,
-      netDic: [],
-    };
-  },
-  props: {
-    split: {
-      type: String,
-      default: ','
-    },
-    remote: Boolean,
-    prependClick: {
-      type: Function,
-      default: () => { }
-    },
-    prepend: {
-      type: String
-    },
-    appendClick: {
-      type: Function,
-      default: () => { }
-    },
-    append: {
-      type: String
-    },
-    prefix: String,
-    whole: Boolean,
-    checkIsWhole: Function
-  },
-  created () { },
-  mounted () { },
-  computed: {
-    options () {
-      return this.netDic.map(ele => {
-        return {
-          label: ele[this.labelKey],
-          value: ele[this.valueKey],
-        }
-      })
-    }
-  },
-  watch: {
-    dic: {
-      handler (val) {
-        this.netDic = val;
-      },
-      immediate: true
-    }
-  },
-  methods: {
-    handleModelValue (val) {
-      if (!this.validatenull(this.text)) {
-        if (this.remote && !this.created) {
-          this.created = true
-          this.handleRemoteMethod(this.text)
-        }
-      }
-    },
-    handleRemoteMethod (query) {
-      this.loading = true
-      sendDic({
-        column: this.column,
-        value: query,
-      }, this).then(res => {
-        this.loading = false;
-        this.netDic = res;
-      });
-    }
-  }
-});
-</script>

package/lib/packages/element-plus/radio/index.vue

@@ -1,38 +0,0 @@
-<template>
-  <div :class="b()">
-    <el-radio-group v-model="text"
-                    :size="size"
-                    @click="handleClick"
-                    :disabled="disabled">
-      <component :is="componentName"
-                 v-for="(item,index) in dic"
-                 :value="item[valueKey]"
-                 :border="border"
-                 :readonly="readonly"
-                 :disabled="item[disabledKey]"
-                 :key="index">{{item[labelKey]}}</component>
-    </el-radio-group>
-  </div>
-</template>
-
-<script>
-import create from "../../../core/create.js";
-import props from "../../core/common/props.js";
-import event from "../../core/common/event.js";
-export default create({
-  name: "radio",
-  mixins: [props(), event()],
-  data () {
-    return {
-      name: 'radio',
-    };
-  },
-  props: {
-    modelValue: {}
-  },
-  watch: {},
-  created () { },
-  mounted () { },
-  methods: {}
-});
-</script>

package/lib/packages/element-plus/rate/index.vue

@@ -1,51 +0,0 @@
-<template>
-  <el-rate v-model="text"
-           @click="handleClick"
-           :max="max"
-           :readonly="readonly"
-           :texts="texts"
-           :show-text="showText"
-           :icon-classes="iconClasses"
-           :void-icon-class="voidIconClass"
-           :disabled="disabled"
-           :colors="colors"></el-rate>
-</template>
-
-<script>
-import create from "../../../core/create.js";
-import props from "../../core/common/props.js";
-import event from "../../core/common/event.js";
-export default create({
-  name: "rate",
-  mixins: [props(), event()],
-  props: {
-    colors: {
-      type: Array
-    },
-    max: {
-      type: Number,
-      default: 5
-    },
-    iconClasses: {
-      type: Array
-    },
-    texts: {
-      type: Array
-    },
-    showText: {
-      type: Boolean,
-      default: false
-    },
-    voidIconClass: {
-      type: String
-    }
-  },
-  data () {
-    return {};
-  },
-  watch: {},
-  created () { },
-  mounted () { },
-  methods: {}
-});
-</script>

package/lib/packages/element-plus/search/index.vue

@@ -1,129 +0,0 @@
-<template>
-  <el-row :class="[b(),{'avue--card':isCard}]"
-          :span="24">
-    <el-col :span="column.span || 24"
-            v-for="(column,index) in columnOption"
-            :key="column.prop"
-            :class="b('item')">
-      <p :class="b('title')">{{column.label}}:</p>
-      <div :class="b('content')">
-        <slot :name="column.prop"
-              :dic="DIC[column.prop]"
-              v-if="mainSlot.includes(column.prop)"></slot>
-        <span v-else
-              :class="[b('tags'),{'avue-search__tags--active':getActive(item,column)}]"
-              @click="handleClick(column,item)"
-              v-for="item in DIC[column.prop]"
-              :key="getKey(item,column.props,valueKey)">{{getKey(item,column.props,labelKey)}}</span>
-      </div>
-    </el-col>
-  </el-row>
-</template>
-
-<script>
-import create from "../../../core/create.js";
-import { DIC_PROPS } from '../../../global/variable.js'
-import init from "../../core/common/init.js";
-export default create({
-  name: "search",
-  mixins: [init()],
-  props: {
-    modelValue: {
-      type: Object,
-      default: () => {
-        return {}
-      }
-    }
-  },
-  watch: {
-    modelValue: {
-      handler (val) {
-        this.setVal(val)
-      },
-      deep: true
-    }
-  },
-  computed: {
-    form: {
-      get () {
-        return this.modelValue
-      },
-      set (val) {
-        this.setVal(val)
-      }
-    },
-    props () {
-      return this.parentOption.props || {}
-    },
-    labelKey () {
-      return DIC_PROPS.label
-    },
-    valueKey () {
-      return DIC_PROPS.value
-    },
-    mainSlot () {
-      let result = [];
-      this.propOption.forEach(item => {
-        if (this.$slots[item.prop]) result.push(item.prop)
-      })
-      return result
-    },
-    isCard () {
-      return this.parentOption.card;
-    },
-    parentOption () {
-      return this.tableOption;
-    },
-    propOption () {
-      return this.columnOption;
-    },
-    columnOption () {
-      return this.parentOption.column;
-    }
-  },
-  mounted () {
-    this.dataFormat();
-  },
-  methods: {
-    setVal (val) {
-      this.$emit('update:modelValue', val)
-      this.$emit("change", val);
-    },
-    getKey (item = {}, props = {}, key) {
-      return item[props[key] || this.props[key] || key];
-    },
-    dataFormat () {
-      this.columnOption.forEach(ele => {
-        const prop = ele.prop;
-        if (this.validatenull(this.form[prop])) {
-          this.form[prop] = ele.multiple === false ? '' : []
-        }
-      });
-    },
-    getActive (item, column) {
-      const value = this.getKey(item, column.props, this.valueKey);
-      if (column.multiple === false) {
-        return this.form[column.prop] === value;
-      } else {
-        return this.form[column.prop].includes(value);
-      }
-    },
-    handleClick (column, item) {
-      const value = this.getKey(item, column.props, this.valueKey);
-      //单选
-      if (column.multiple === false) {
-        this.form[column.prop] = value;
-      } else {
-        // 多选
-        const index = this.form[column.prop].indexOf(value);
-        if (index === -1) {
-          this.form[column.prop].push(value);
-        } else {
-          this.form[column.prop].splice(index, 1);
-        }
-      }
-    }
-  }
-});
-</script>
-

package/lib/packages/element-plus/select/index.vue

@@ -1,292 +0,0 @@
-<template>
-  <component
-    :is="componentName"
-    ref="main"
-    :class="b()"
-    v-model="text"
-    :size="size"
-    :options="netDic"
-    :props="props"
-    :loading="loading"
-    :loading-text="loadingText"
-    :value-on-clear="valueOnClear"
-    :multiple="multiple"
-    :filterable="remote ? true : filterable"
-    :remote="remote"
-    :readonly="readonly"
-    :no-match-text="noMatchText"
-    :no-data-text="noDataText"
-    :remote-method="remote ? handleRemoteMethod : undefined"
-    :popper-class="popperClass"
-    :popper-append-to-body="popperAppendToBody"
-    :collapse-tags="tags || collapseTags"
-    :collapse-tags-tooltip="collapseTagsTooltip"
-    :max-collapse-tags="maxCollapseTags"
-    :clearable="clearableVal"
-    :placeholder="placeholder"
-    @focus="handleFocus"
-    @blur="handleBlur"
-    @click="handleClick"
-    @remove-tag="handleremoveTag"
-    :multiple-limit="limit"
-    :allow-create="allowCreate"
-    :default-first-option="defaultFirstOption"
-    :disabled="disabled"
-  >
-    <template #="scope">
-      <template v-if="virtualize">
-        <slot
-          :label="labelKey"
-          :value="valueKey"
-          :item="scope.item"
-          v-if="$slots.default"
-        >
-        </slot>
-        <template v-else>
-          <span>{{ getLabelText(scope.item) }}</span>
-          <span v-if="scope.item[descKey]" :class="b('desc')">{{
-            scope.item[descKey]
-          }}</span>
-        </template>
-      </template>
-      <template v-else>
-        <template v-if="isGroup">
-          <el-option-group
-            v-for="(item, index) in netDic"
-            :key="index"
-            :label="getLabelText(item)"
-          >
-            <el-option
-              v-for="(citem, cindex) in item[groupsKey]"
-              :key="citem[valueKey]"
-              :class="citem[classNameKey]"
-              :disabled="citem[disabledKey]"
-              :label="getLabelText(citem)"
-              :value="citem[valueKey]"
-            >
-              <template #>
-                <slot
-                  :label="labelKey"
-                  :value="valueKey"
-                  :item="citem"
-                  v-if="$slots.default"
-                >
-                </slot>
-                <template v-else>
-                  <span>{{ getLabelText(citem) }}</span>
-                  <span v-if="citem[descKey]" :class="b('desc')">{{
-                    citem[descKey]
-                  }}</span>
-                </template>
-              </template>
-            </el-option>
-          </el-option-group>
-        </template>
-        <template v-else>
-          <div :class="b('check')">
-            <el-checkbox
-              v-if="all && multiple"
-              v-model="checked"
-              :disabled="disabled"
-              :indeterminate="indeterminate"
-              @change="checkChange"
-              >{{ t('check.checkAll') }}</el-checkbox
-            >
-          </div>
-
-          <el-option
-            v-for="(item, index) in netDic"
-            :key="item[valueKey]"
-            :class="item[classNameKey]"
-            :disabled="item[disabledKey]"
-            :label="getLabelText(item)"
-            :value="item[valueKey]"
-          >
-            <template #>
-              <slot
-                :label="labelKey"
-                :value="valueKey"
-                :item="item"
-                v-if="$slots.default"
-              >
-              </slot>
-              <template v-else>
-                <span>{{ getLabelText(item) }}</span>
-                <span v-if="item[descKey]" :class="b('desc')">{{
-                  item[descKey]
-                }}</span>
-              </template>
-            </template>
-          </el-option>
-        </template>
-      </template>
-    </template>
-  </component>
-</template>
-
-<script>
-import packages from "../../../core/packages.js";
-import create from "../../../core/create.js";
-import props from "../../core/common/props.js";
-import event from "../../core/common/event.js";
-import locale from "../../../core/locale.js";
-import { sendDic } from "../../../core/dic.js";
-import { DIC_SPLIT } from "../../../global/variable.js";
-export default create({
-  name: "select",
-  mixins: [props(), event(), locale],
-  data() {
-    return {
-      checked: false,
-      indeterminate: false,
-      create: false,
-      netDic: [],
-      loading: false,
-    };
-  },
-  props: {
-    virtualize: Boolean,
-    valueOnClear: {
-      type: [String, Number, Boolean, Function],
-      default: undefined,
-    },
-    loadingText: {
-      type: String,
-    },
-    noMatchText: {
-      type: String,
-    },
-    noDataText: {
-      type: String,
-    },
-    drag: {
-      type: Boolean,
-      default: false,
-    },
-    remote: {
-      type: Boolean,
-      default: false,
-    },
-    tags: {
-      type: Boolean,
-      default: false,
-    },
-    removeTag: Function,
-    collapseTags: Boolean,
-    collapseTagsTooltip: Boolean,
-    maxCollapseTags: Number,
-    limit: {
-      type: Number,
-      default: 0,
-    },
-    filterable: {
-      type: Boolean,
-      default: false,
-    },
-    allowCreate: {
-      type: Boolean,
-      default: false,
-    },
-    defaultFirstOption: {
-      type: Boolean,
-      default: false,
-    },
-    all: {
-      type: Boolean,
-      default: false,
-    },
-    popperAppendToBody: {
-      type: Boolean,
-      default: true,
-    },
-  },
-  watch: {
-    dic: {
-      handler(val) {
-        this.netDic = val;
-      },
-      immediate: true,
-    },
-  },
-  computed: {
-    classNameKey() {
-      return this.props.className || "className";
-    },
-    componentName() {
-      return "elSelect" + (this.virtualize ? "V2" : "");
-    },
-  },
-  mounted() {
-    if (this.drag) {
-      this.setSort();
-    }
-  },
-  methods: {
-    handleModelValue(val) {
-      if (!this.validatenull(this.text)) {
-        if (this.remote && !this.created) {
-          this.created = true;
-          this.handleRemoteMethod(
-            this.multiple ? this.text.join(DIC_SPLIT) : this.text
-          );
-        }
-      }
-      if (this.multiple) {
-        if (this.text.length == 0) {
-          this.checked = false;
-          this.indeterminate = false;
-        } else if (this.text.length == this.netDic.length) {
-          this.checked = true;
-          this.indeterminate = false;
-        } else {
-          this.indeterminate = true;
-        }
-      }
-    },
-    setSort() {
-      if (!window.Sortable) {
-        packages.logs("Sortable");
-        return;
-      }
-      const el = this.$refs.main.$el.querySelectorAll(
-        ".el-select__selection"
-      )[0];
-      this.sortable = window.Sortable.create(el, {
-        animation: 100,
-        onEnd: (evt) => {
-          const targetRow = this.modelValue.splice(evt.oldIndex, 1)[0];
-          this.modelValue.splice(evt.newIndex, 0, targetRow);
-        },
-      });
-    },
-    handleRemoteMethod(query) {
-      this.loading = true;
-      sendDic(
-        {
-          column: this.column,
-          value: query,
-        },
-        this
-      ).then((res) => {
-        this.loading = false;
-        this.netDic = res;
-      });
-    },
-    checkChange(val) {
-      this.text = [];
-      this.checked = val;
-      this.indeterminate = false;
-      if (val) {
-        this.text = this.netDic
-          .filter((ele) => !ele[this.disabledKey])
-          .map((ele) => ele[this.valueKey]);
-      }
-    },
-    handleremoveTag(tagValue) {
-      if (this.removeTag && typeof this.removeTag === 'function') {
-        this.removeTag(tagValue);
-      }
-    },
-  },
-});
-</script>