cbvirtua 1.0.57 → 1.0.58

package/src/packages/input-number/src/input-number.vue

@@ -1,283 +0,0 @@
-<template>
-  <div
-    @dragstart.prevent
-    :class="[
-      'el-input-number',
-      inputNumberSize ? 'el-input-number--' + inputNumberSize : '',
-      { 'is-disabled': inputNumberDisabled },
-      { 'is-without-controls': !controls },
-      { 'is-controls-right': controlsAtRight }
-    ]">
-    <span
-      class="el-input-number__decrease"
-      role="button"
-      v-if="controls"
-      v-repeat-click="decrease"
-      :class="{'is-disabled': minDisabled}"
-      @keydown.enter="decrease">
-      <i :class="`el-icon-${controlsAtRight ? 'arrow-down' : 'minus'}`"></i>
-    </span>
-    <span
-      class="el-input-number__increase"
-      role="button"
-      v-if="controls"
-      v-repeat-click="increase"
-      :class="{'is-disabled': maxDisabled}"
-      @keydown.enter="increase">
-      <i :class="`el-icon-${controlsAtRight ? 'arrow-up' : 'plus'}`"></i>
-    </span>
-    <el-input
-      ref="input"
-      :value="displayValue"
-      :placeholder="placeholder"
-      :disabled="inputNumberDisabled"
-      :size="inputNumberSize"
-      :max="max"
-      :min="min"
-      :name="name"
-      :label="label"
-      @keydown.up.native.prevent="increase"
-      @keydown.down.native.prevent="decrease"
-      @blur="handleBlur"
-      @focus="handleFocus"
-      @input="handleInput"
-      @change="handleInputChange">
-    </el-input>
-  </div>
-</template>
-<script>
-  import ElInput from 'element-ui/packages/input';
-  import Focus from 'element-ui/src/mixins/focus';
-  import RepeatClick from 'element-ui/src/directives/repeat-click';
-
-  export default {
-    name: 'ElInputNumber',
-    mixins: [Focus('input')],
-    inject: {
-      elForm: {
-        default: ''
-      },
-      elFormItem: {
-        default: ''
-      }
-    },
-    directives: {
-      repeatClick: RepeatClick
-    },
-    components: {
-      ElInput
-    },
-    props: {
-      step: {
-        type: Number,
-        default: 1
-      },
-      stepStrictly: {
-        type: Boolean,
-        default: false
-      },
-      max: {
-        type: Number,
-        default: Infinity
-      },
-      min: {
-        type: Number,
-        default: -Infinity
-      },
-      value: {},
-      disabled: Boolean,
-      size: String,
-      controls: {
-        type: Boolean,
-        default: true
-      },
-      controlsPosition: {
-        type: String,
-        default: ''
-      },
-      name: String,
-      label: String,
-      placeholder: String,
-      precision: {
-        type: Number,
-        validator(val) {
-          return val >= 0 && val === parseInt(val, 10);
-        }
-      }
-    },
-    data() {
-      return {
-        currentValue: 0,
-        userInput: null
-      };
-    },
-    watch: {
-      value: {
-        immediate: true,
-        handler(value) {
-          let newVal = value === undefined ? value : Number(value);
-          if (newVal !== undefined) {
-            if (isNaN(newVal)) {
-              return;
-            }
-
-            if (this.stepStrictly) {
-              const stepPrecision = this.getPrecision(this.step);
-              const precisionFactor = Math.pow(10, stepPrecision);
-              newVal = Math.round(newVal / this.step) * precisionFactor * this.step / precisionFactor;
-            }
-
-            if (this.precision !== undefined) {
-              newVal = this.toPrecision(newVal, this.precision);
-            }
-          }
-          if (newVal >= this.max) newVal = this.max;
-          if (newVal <= this.min) newVal = this.min;
-          this.currentValue = newVal;
-          this.userInput = null;
-          this.$emit('input', newVal);
-        }
-      }
-    },
-    computed: {
-      minDisabled() {
-        return this._decrease(this.value, this.step) < this.min;
-      },
-      maxDisabled() {
-        return this._increase(this.value, this.step) > this.max;
-      },
-      numPrecision() {
-        const { value, step, getPrecision, precision } = this;
-        const stepPrecision = getPrecision(step);
-        if (precision !== undefined) {
-          if (stepPrecision > precision) {
-            console.warn('[Element Warn][InputNumber]precision should not be less than the decimal places of step');
-          }
-          return precision;
-        } else {
-          return Math.max(getPrecision(value), stepPrecision);
-        }
-      },
-      controlsAtRight() {
-        return this.controls && this.controlsPosition === 'right';
-      },
-      _elFormItemSize() {
-        return (this.elFormItem || {}).elFormItemSize;
-      },
-      inputNumberSize() {
-        return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
-      },
-      inputNumberDisabled() {
-        return this.disabled || !!(this.elForm || {}).disabled;
-      },
-      displayValue() {
-        if (this.userInput !== null) {
-          return this.userInput;
-        }
-
-        let currentValue = this.currentValue;
-
-        if (typeof currentValue === 'number') {
-          if (this.stepStrictly) {
-            const stepPrecision = this.getPrecision(this.step);
-            const precisionFactor = Math.pow(10, stepPrecision);
-            currentValue = Math.round(currentValue / this.step) * precisionFactor * this.step / precisionFactor;
-          }
-
-          if (this.precision !== undefined) {
-            currentValue = currentValue.toFixed(this.precision);
-          }
-        }
-
-        return currentValue;
-      }
-    },
-    methods: {
-      toPrecision(num, precision) {
-        if (precision === undefined) precision = this.numPrecision;
-        return parseFloat(Math.round(num * Math.pow(10, precision)) / Math.pow(10, precision));
-      },
-      getPrecision(value) {
-        if (value === undefined) return 0;
-        const valueString = value.toString();
-        const dotPosition = valueString.indexOf('.');
-        let precision = 0;
-        if (dotPosition !== -1) {
-          precision = valueString.length - dotPosition - 1;
-        }
-        return precision;
-      },
-      _increase(val, step) {
-        if (typeof val !== 'number' && val !== undefined) return this.currentValue;
-
-        const precisionFactor = Math.pow(10, this.numPrecision);
-        // Solve the accuracy problem of JS decimal calculation by converting the value to integer.
-        return this.toPrecision((precisionFactor * val + precisionFactor * step) / precisionFactor);
-      },
-      _decrease(val, step) {
-        if (typeof val !== 'number' && val !== undefined) return this.currentValue;
-
-        const precisionFactor = Math.pow(10, this.numPrecision);
-
-        return this.toPrecision((precisionFactor * val - precisionFactor * step) / precisionFactor);
-      },
-      increase() {
-        if (this.inputNumberDisabled || this.maxDisabled) return;
-        const value = this.value || 0;
-        const newVal = this._increase(value, this.step);
-        this.setCurrentValue(newVal);
-      },
-      decrease() {
-        if (this.inputNumberDisabled || this.minDisabled) return;
-        const value = this.value || 0;
-        const newVal = this._decrease(value, this.step);
-        this.setCurrentValue(newVal);
-      },
-      handleBlur(event) {
-        this.$emit('blur', event);
-      },
-      handleFocus(event) {
-        this.$emit('focus', event);
-      },
-      setCurrentValue(newVal) {
-        const oldVal = this.currentValue;
-        if (typeof newVal === 'number' && this.precision !== undefined) {
-          newVal = this.toPrecision(newVal, this.precision);
-        }
-        if (newVal >= this.max) newVal = this.max;
-        if (newVal <= this.min) newVal = this.min;
-        if (oldVal === newVal) return;
-        this.userInput = null;
-        this.$emit('input', newVal);
-        this.$emit('change', newVal, oldVal);
-        this.currentValue = newVal;
-      },
-      handleInput(value) {
-        this.userInput = value;
-      },
-      handleInputChange(value) {
-        const newVal = value === '' ? undefined : Number(value);
-        if (!isNaN(newVal) || value === '') {
-          this.setCurrentValue(newVal);
-        }
-        this.userInput = null;
-      },
-      select() {
-        this.$refs.input.select();
-      }
-    },
-    mounted() {
-      let innerInput = this.$refs.input.$refs.input;
-      innerInput.setAttribute('role', 'spinbutton');
-      innerInput.setAttribute('aria-valuemax', this.max);
-      innerInput.setAttribute('aria-valuemin', this.min);
-      innerInput.setAttribute('aria-valuenow', this.currentValue);
-      innerInput.setAttribute('aria-disabled', this.inputNumberDisabled);
-    },
-    updated() {
-      if (!this.$refs || !this.$refs.input) return;
-      const innerInput = this.$refs.input.$refs.input;
-      innerInput.setAttribute('aria-valuenow', this.currentValue);
-    }
-  };
-</script>

package/src/packages/link/index.js

@@ -1,8 +0,0 @@
-import Link from './src/main';
-
-/* istanbul ignore next */
-Link.install = function(Vue) {
-  Vue.component(Link.name, Link);
-};
-
-export default Link;

package/src/packages/link/src/main.vue

@@ -1,53 +0,0 @@
-<template>
-  <a
-    :class="[
-      'el-link',
-      type ? `el-link--${type}` : '',
-      disabled && 'is-disabled',
-      underline && !disabled && 'is-underline'
-    ]"
-    :href="disabled ? null : href"
-    v-bind="$attrs"
-    @click="handleClick"
-  >
-
-    <i :class="icon" v-if="icon"></i>
-
-    <span v-if="$slots.default" class="el-link--inner">
-      <slot></slot>
-    </span>
-
-    <template v-if="$slots.icon"><slot v-if="$slots.icon" name="icon"></slot></template>
-  </a>
-</template>
-
-<script>
-
-export default {
-  name: 'ElLink',
-
-  props: {
-    type: {
-      type: String,
-      default: 'default'
-    },
-    underline: {
-      type: Boolean,
-      default: true
-    },
-    disabled: Boolean,
-    href: String,
-    icon: String
-  },
-
-  methods: {
-    handleClick(event) {
-      if (!this.disabled) {
-        if (!this.href) {
-          this.$emit('click', event);
-        }
-      }
-    }
-  }
-};
-</script>

package/src/packages/loading/index.js

@@ -1,11 +0,0 @@
-import directive from './src/directive';
-import service from './src/index';
-
-export default {
-  install(Vue) {
-    Vue.use(directive);
-    Vue.prototype.$loading = service;
-  },
-  directive,
-  service
-};

package/src/packages/loading/src/directive.js

@@ -1,133 +0,0 @@
-import Vue from 'vue';
-import Loading from './loading.vue';
-import { addClass, removeClass, getStyle } from 'element-ui/src/utils/dom';
-import { PopupManager } from 'element-ui/src/utils/popup';
-import afterLeave from 'element-ui/src/utils/after-leave';
-const Mask = Vue.extend(Loading);
-
-const loadingDirective = {};
-loadingDirective.install = Vue => {
-  if (Vue.prototype.$isServer) return;
-  const toggleLoading = (el, binding) => {
-    if (binding.value) {
-      Vue.nextTick(() => {
-        if (binding.modifiers.fullscreen) {
-          el.originalPosition = getStyle(document.body, 'position');
-          el.originalOverflow = getStyle(document.body, 'overflow');
-          el.maskStyle.zIndex = PopupManager.nextZIndex();
-
-          addClass(el.mask, 'is-fullscreen');
-          insertDom(document.body, el, binding);
-        } else {
-          removeClass(el.mask, 'is-fullscreen');
-
-          if (binding.modifiers.body) {
-            el.originalPosition = getStyle(document.body, 'position');
-
-            ['top', 'left'].forEach(property => {
-              const scroll = property === 'top' ? 'scrollTop' : 'scrollLeft';
-              el.maskStyle[property] = el.getBoundingClientRect()[property] +
-                document.body[scroll] +
-                document.documentElement[scroll] -
-                parseInt(getStyle(document.body, `margin-${ property }`), 10) +
-                'px';
-            });
-            ['height', 'width'].forEach(property => {
-              el.maskStyle[property] = el.getBoundingClientRect()[property] + 'px';
-            });
-
-            insertDom(document.body, el, binding);
-          } else {
-            el.originalPosition = getStyle(el, 'position');
-            insertDom(el, el, binding);
-          }
-        }
-      });
-    } else {
-      afterLeave(el.instance, _ => {
-        if (!el.instance.hiding) return;
-        el.domVisible = false;
-        const target = binding.modifiers.fullscreen || binding.modifiers.body
-          ? document.body
-          : el;
-        removeClass(target, 'el-loading-parent--relative');
-        removeClass(target, 'el-loading-parent--hidden');
-        el.instance.hiding = false;
-      }, 300, true);
-      el.instance.visible = false;
-      el.instance.hiding = true;
-    }
-  };
-  const insertDom = (parent, el, binding) => {
-    if (!el.domVisible && getStyle(el, 'display') !== 'none' && getStyle(el, 'visibility') !== 'hidden') {
-      Object.keys(el.maskStyle).forEach(property => {
-        el.mask.style[property] = el.maskStyle[property];
-      });
-
-      if (el.originalPosition !== 'absolute' && el.originalPosition !== 'fixed' && el.originalPosition !== 'sticky') {
-        addClass(parent, 'el-loading-parent--relative');
-      }
-      if (binding.modifiers.fullscreen && binding.modifiers.lock) {
-        addClass(parent, 'el-loading-parent--hidden');
-      }
-      el.domVisible = true;
-
-      parent.appendChild(el.mask);
-      Vue.nextTick(() => {
-        if (el.instance.hiding) {
-          el.instance.$emit('after-leave');
-        } else {
-          el.instance.visible = true;
-        }
-      });
-      el.domInserted = true;
-    } else if (el.domVisible && el.instance.hiding === true) {
-      el.instance.visible = true;
-      el.instance.hiding = false;
-    }
-  };
-
-  Vue.directive('loading', {
-    bind: function(el, binding, vnode) {
-      const textExr = el.getAttribute('element-loading-text');
-      const spinnerExr = el.getAttribute('element-loading-spinner');
-      const backgroundExr = el.getAttribute('element-loading-background');
-      const customClassExr = el.getAttribute('element-loading-custom-class');
-      const vm = vnode.context;
-      const mask = new Mask({
-        el: document.createElement('div'),
-        data: {
-          text: vm && vm[textExr] || textExr,
-          spinner: vm && vm[spinnerExr] || spinnerExr,
-          background: vm && vm[backgroundExr] || backgroundExr,
-          customClass: vm && vm[customClassExr] || customClassExr,
-          fullscreen: !!binding.modifiers.fullscreen
-        }
-      });
-      el.instance = mask;
-      el.mask = mask.$el;
-      el.maskStyle = {};
-
-      binding.value && toggleLoading(el, binding);
-    },
-
-    update: function(el, binding) {
-      el.instance.setText(el.getAttribute('element-loading-text'));
-      if (binding.oldValue !== binding.value) {
-        toggleLoading(el, binding);
-      }
-    },
-
-    unbind: function(el, binding) {
-      if (el.domInserted) {
-        el.mask &&
-        el.mask.parentNode &&
-        el.mask.parentNode.removeChild(el.mask);
-        toggleLoading(el, { value: false, modifiers: binding.modifiers });
-      }
-      el.instance && el.instance.$destroy();
-    }
-  });
-};
-
-export default loadingDirective;

package/src/packages/loading/src/index.js

@@ -1,106 +0,0 @@
-import Vue from 'vue';
-import loadingVue from './loading.vue';
-import { addClass, removeClass, getStyle } from 'element-ui/src/utils/dom';
-import { PopupManager } from 'element-ui/src/utils/popup';
-import afterLeave from 'element-ui/src/utils/after-leave';
-import merge from 'element-ui/src/utils/merge';
-
-const LoadingConstructor = Vue.extend(loadingVue);
-
-const defaults = {
-  text: null,
-  fullscreen: true,
-  body: false,
-  lock: false,
-  customClass: ''
-};
-
-let fullscreenLoading;
-
-LoadingConstructor.prototype.originalPosition = '';
-LoadingConstructor.prototype.originalOverflow = '';
-
-LoadingConstructor.prototype.close = function() {
-  if (this.fullscreen) {
-    fullscreenLoading = undefined;
-  }
-  afterLeave(this, _ => {
-    const target = this.fullscreen || this.body
-      ? document.body
-      : this.target;
-    removeClass(target, 'el-loading-parent--relative');
-    removeClass(target, 'el-loading-parent--hidden');
-    if (this.$el && this.$el.parentNode) {
-      this.$el.parentNode.removeChild(this.$el);
-    }
-    this.$destroy();
-  }, 300);
-  this.visible = false;
-};
-
-const addStyle = (options, parent, instance) => {
-  let maskStyle = {};
-  if (options.fullscreen) {
-    instance.originalPosition = getStyle(document.body, 'position');
-    instance.originalOverflow = getStyle(document.body, 'overflow');
-    maskStyle.zIndex = PopupManager.nextZIndex();
-  } else if (options.body) {
-    instance.originalPosition = getStyle(document.body, 'position');
-    ['top', 'left'].forEach(property => {
-      let scroll = property === 'top' ? 'scrollTop' : 'scrollLeft';
-      maskStyle[property] = options.target.getBoundingClientRect()[property] +
-        document.body[scroll] +
-        document.documentElement[scroll] +
-        'px';
-    });
-    ['height', 'width'].forEach(property => {
-      maskStyle[property] = options.target.getBoundingClientRect()[property] + 'px';
-    });
-  } else {
-    instance.originalPosition = getStyle(parent, 'position');
-  }
-  Object.keys(maskStyle).forEach(property => {
-    instance.$el.style[property] = maskStyle[property];
-  });
-};
-
-const Loading = (options = {}) => {
-  if (Vue.prototype.$isServer) return;
-  options = merge({}, defaults, options);
-  if (typeof options.target === 'string') {
-    options.target = document.querySelector(options.target);
-  }
-  options.target = options.target || document.body;
-  if (options.target !== document.body) {
-    options.fullscreen = false;
-  } else {
-    options.body = true;
-  }
-  if (options.fullscreen && fullscreenLoading) {
-    return fullscreenLoading;
-  }
-
-  let parent = options.body ? document.body : options.target;
-  let instance = new LoadingConstructor({
-    el: document.createElement('div'),
-    data: options
-  });
-
-  addStyle(options, parent, instance);
-  if (instance.originalPosition !== 'absolute' && instance.originalPosition !== 'fixed' && instance.originalPosition !== 'sticky') {
-    addClass(parent, 'el-loading-parent--relative');
-  }
-  if (options.fullscreen && options.lock) {
-    addClass(parent, 'el-loading-parent--hidden');
-  }
-  parent.appendChild(instance.$el);
-  Vue.nextTick(() => {
-    instance.visible = true;
-  });
-  if (options.fullscreen) {
-    fullscreenLoading = instance;
-  }
-  return instance;
-};
-
-export default Loading;

package/src/packages/loading/src/loading.vue

@@ -1,41 +0,0 @@
-<template>
-  <transition name="el-loading-fade" @after-leave="handleAfterLeave">
-    <div
-      v-show="visible"
-      class="el-loading-mask"
-      :style="{ backgroundColor: background || '' }"
-      :class="[customClass, { 'is-fullscreen': fullscreen }]">
-      <div class="el-loading-spinner">
-        <svg v-if="!spinner" class="circular" viewBox="25 25 50 50">
-          <circle class="path" cx="50" cy="50" r="20" fill="none"/>
-        </svg>
-        <i v-else :class="spinner"></i>
-        <p v-if="text" class="el-loading-text">{{ text }}</p>
-      </div>
-    </div>
-  </transition>
-</template>
-
-<script>
-  export default {
-    data() {
-      return {
-        text: null,
-        spinner: null,
-        background: null,
-        fullscreen: true,
-        visible: false,
-        customClass: ''
-      };
-    },
-
-    methods: {
-      handleAfterLeave() {
-        this.$emit('after-leave');
-      },
-      setText(text) {
-        this.text = text;
-      }
-    }
-  };
-</script>

package/src/packages/main/index.js

@@ -1,8 +0,0 @@
-import Main from './src/main';
-
-/* istanbul ignore next */
-Main.install = function(Vue) {
-  Vue.component(Main.name, Main);
-};
-
-export default Main;

package/src/packages/main/src/main.vue

@@ -1,12 +0,0 @@
-<template>
-  <main class="el-main">
-    <slot></slot>
-  </main>
-</template>
-
-<script>
-  export default {
-    name: 'ElMain',
-    componentName: 'ElMain'
-  };
-</script>

package/src/packages/menu/index.js

@@ -1,8 +0,0 @@
-import ElMenu from './src/menu';
-
-/* istanbul ignore next */
-ElMenu.install = function(Vue) {
-  Vue.component(ElMenu.name, ElMenu);
-};
-
-export default ElMenu;