@penggy/element-ui 2.4.11

package/packages/rate/src/main.vue

@@ -0,0 +1,350 @@
+<template>
+  <div
+    class="el-rate"
+    @keydown="handleKey"
+    role="slider"
+    :aria-valuenow="currentValue"
+    :aria-valuetext="text"
+    aria-valuemin="0"
+    :aria-valuemax="max"
+    tabindex="0">
+    <span
+      v-for="(item, key) in max"
+      class="el-rate__item"
+      @mousemove="setCurrentValue(item, $event)"
+      @mouseleave="resetCurrentValue"
+      @click="selectValue(item)"
+      :style="{ cursor: rateDisabled ? 'auto' : 'pointer' }"
+      :key="key">
+      <i
+        :class="[classes[item - 1], { 'hover': hoverIndex === item }]"
+        class="el-rate__icon"
+        :style="getIconStyle(item)">
+        <i
+          v-if="showDecimalIcon(item)"
+          :class="decimalIconClass"
+          :style="decimalStyle"
+          class="el-rate__decimal">
+        </i>
+      </i>
+    </span>
+    <span v-if="showText || showScore" class="el-rate__text" :style="{ color: textColor }">{{ text }}</span>
+  </div>
+</template>
+
+<script>
+  import { hasClass } from 'element-ui/src/utils/dom';
+  import Migrating from 'element-ui/src/mixins/migrating';
+
+  export default {
+    name: 'ElRate',
+
+    mixins: [Migrating],
+
+    inject: {
+      elForm: {
+        default: ''
+      }
+    },
+
+    data() {
+      return {
+        pointerAtLeftHalf: true,
+        currentValue: this.value,
+        hoverIndex: -1
+      };
+    },
+
+    props: {
+      value: {
+        type: Number,
+        default: 0
+      },
+      lowThreshold: {
+        type: Number,
+        default: 2
+      },
+      highThreshold: {
+        type: Number,
+        default: 4
+      },
+      max: {
+        type: Number,
+        default: 5
+      },
+      colors: {
+        type: Array,
+        default() {
+          return ['#F7BA2A', '#F7BA2A', '#F7BA2A'];
+        }
+      },
+      voidColor: {
+        type: String,
+        default: '#C6D1DE'
+      },
+      disabledVoidColor: {
+        type: String,
+        default: '#EFF2F7'
+      },
+      iconClasses: {
+        type: Array,
+        default() {
+          return ['el-icon-star-on', 'el-icon-star-on', 'el-icon-star-on'];
+        }
+      },
+      voidIconClass: {
+        type: String,
+        default: 'el-icon-star-off'
+      },
+      disabledVoidIconClass: {
+        type: String,
+        default: 'el-icon-star-on'
+      },
+      disabled: {
+        type: Boolean,
+        default: false
+      },
+      allowHalf: {
+        type: Boolean,
+        default: false
+      },
+      showText: {
+        type: Boolean,
+        default: false
+      },
+      showScore: {
+        type: Boolean,
+        default: false
+      },
+      textColor: {
+        type: String,
+        default: '#1f2d3d'
+      },
+      texts: {
+        type: Array,
+        default() {
+          return ['极差', '失望', '一般', '满意', '惊喜'];
+        }
+      },
+      scoreTemplate: {
+        type: String,
+        default: '{value}'
+      }
+    },
+
+    computed: {
+      text() {
+        let result = '';
+        if (this.showScore) {
+          result = this.scoreTemplate.replace(/\{\s*value\s*\}/, this.rateDisabled
+            ? this.value
+            : this.currentValue);
+        } else if (this.showText) {
+          result = this.texts[Math.ceil(this.currentValue) - 1];
+        }
+        return result;
+      },
+
+      decimalStyle() {
+        let width = '';
+        if (this.rateDisabled) {
+          width = `${ this.valueDecimal < 50 ? 0 : 50 }%`;
+        }
+        if (this.allowHalf) {
+          width = '50%';
+        }
+        return {
+          color: this.activeColor,
+          width
+        };
+      },
+
+      valueDecimal() {
+        return this.value * 100 - Math.floor(this.value) * 100;
+      },
+
+      decimalIconClass() {
+        return this.getValueFromMap(this.value, this.classMap);
+      },
+
+      voidClass() {
+        return this.rateDisabled ? this.classMap.disabledVoidClass : this.classMap.voidClass;
+      },
+
+      activeClass() {
+        return this.getValueFromMap(this.currentValue, this.classMap);
+      },
+
+      colorMap() {
+        return {
+          lowColor: this.colors[0],
+          mediumColor: this.colors[1],
+          highColor: this.colors[2],
+          voidColor: this.voidColor,
+          disabledVoidColor: this.disabledVoidColor
+        };
+      },
+
+      activeColor() {
+        return this.getValueFromMap(this.currentValue, this.colorMap);
+      },
+
+      classes() {
+        let result = [];
+        let i = 0;
+        let threshold = this.currentValue;
+        if (this.allowHalf && this.currentValue !== Math.floor(this.currentValue)) {
+          threshold--;
+        }
+        for (; i < threshold; i++) {
+          result.push(this.activeClass);
+        }
+        for (; i < this.max; i++) {
+          result.push(this.voidClass);
+        }
+        return result;
+      },
+
+      classMap() {
+        return {
+          lowClass: this.iconClasses[0],
+          mediumClass: this.iconClasses[1],
+          highClass: this.iconClasses[2],
+          voidClass: this.voidIconClass,
+          disabledVoidClass: this.disabledVoidIconClass
+        };
+      },
+
+      rateDisabled() {
+        return this.disabled || (this.elForm || {}).disabled;
+      }
+    },
+
+    watch: {
+      value(val) {
+        this.currentValue = val;
+        this.pointerAtLeftHalf = this.value !== Math.floor(this.value);
+      }
+    },
+
+    methods: {
+      getMigratingConfig() {
+        return {
+          props: {
+            'text-template': 'text-template is renamed to score-template.'
+          }
+        };
+      },
+
+      getValueFromMap(value, map) {
+        let result = '';
+        if (value <= this.lowThreshold) {
+          result = map.lowColor || map.lowClass;
+        } else if (value >= this.highThreshold) {
+          result = map.highColor || map.highClass;
+        } else {
+          result = map.mediumColor || map.mediumClass;
+        }
+        return result;
+      },
+
+      showDecimalIcon(item) {
+        let showWhenDisabled = this.rateDisabled && this.valueDecimal > 0 && item - 1 < this.value && item > this.value;
+        /* istanbul ignore next */
+        let showWhenAllowHalf = this.allowHalf &&
+          this.pointerAtLeftHalf &&
+          item - 0.5 <= this.currentValue &&
+          item > this.currentValue;
+        return showWhenDisabled || showWhenAllowHalf;
+      },
+
+      getIconStyle(item) {
+        const voidColor = this.rateDisabled ? this.colorMap.disabledVoidColor : this.colorMap.voidColor;
+        return {
+          color: item <= this.currentValue ? this.activeColor : voidColor
+        };
+      },
+
+      selectValue(value) {
+        if (this.rateDisabled) {
+          return;
+        }
+        if (this.allowHalf && this.pointerAtLeftHalf) {
+          this.$emit('input', this.currentValue);
+          this.$emit('change', this.currentValue);
+        } else {
+          this.$emit('input', value);
+          this.$emit('change', value);
+        }
+      },
+
+      handleKey(e) {
+        if (this.rateDisabled) {
+          return;
+        }
+        let currentValue = this.currentValue;
+        const keyCode = e.keyCode;
+        if (keyCode === 38 || keyCode === 39) { // left / down
+          if (this.allowHalf) {
+            currentValue += 0.5;
+          } else {
+            currentValue += 1;
+          }
+          e.stopPropagation();
+          e.preventDefault();
+        } else if (keyCode === 37 || keyCode === 40) {
+          if (this.allowHalf) {
+            currentValue -= 0.5;
+          } else {
+            currentValue -= 1;
+          }
+          e.stopPropagation();
+          e.preventDefault();
+        }
+        currentValue = currentValue < 0 ? 0 : currentValue;
+        currentValue = currentValue > this.max ? this.max : currentValue;
+
+        this.$emit('input', currentValue);
+        this.$emit('change', currentValue);
+      },
+
+      setCurrentValue(value, event) {
+        if (this.rateDisabled) {
+          return;
+        }
+        /* istanbul ignore if */
+        if (this.allowHalf) {
+          let target = event.target;
+          if (hasClass(target, 'el-rate__item')) {
+            target = target.querySelector('.el-rate__icon');
+          }
+          if (hasClass(target, 'el-rate__decimal')) {
+            target = target.parentNode;
+          }
+          this.pointerAtLeftHalf = event.offsetX * 2 <= target.clientWidth;
+          this.currentValue = this.pointerAtLeftHalf ? value - 0.5 : value;
+        } else {
+          this.currentValue = value;
+        }
+        this.hoverIndex = value;
+      },
+
+      resetCurrentValue() {
+        if (this.rateDisabled) {
+          return;
+        }
+        if (this.allowHalf) {
+          this.pointerAtLeftHalf = this.value !== Math.floor(this.value);
+        }
+        this.currentValue = this.value;
+        this.hoverIndex = -1;
+      }
+    },
+
+    created() {
+      if (!this.value) {
+        this.$emit('input', 0);
+      }
+    }
+  };
+</script>

package/packages/row/index.js

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

package/packages/row/src/row.js

@@ -0,0 +1,47 @@
+export default {
+  name: 'ElRow',
+
+  componentName: 'ElRow',
+
+  props: {
+    tag: {
+      type: String,
+      default: 'div'
+    },
+    gutter: Number,
+    type: String,
+    justify: {
+      type: String,
+      default: 'start'
+    },
+    align: {
+      type: String,
+      default: 'top'
+    }
+  },
+
+  computed: {
+    style() {
+      const ret = {};
+
+      if (this.gutter) {
+        ret.marginLeft = `-${this.gutter / 2}px`;
+        ret.marginRight = ret.marginLeft;
+      }
+
+      return ret;
+    }
+  },
+
+  render(h) {
+    return h(this.tag, {
+      class: [
+        'el-row',
+        this.justify !== 'start' ? `is-justify-${this.justify}` : '',
+        this.align !== 'top' ? `is-align-${this.align}` : '',
+        { 'el-row--flex': this.type === 'flex' }
+      ],
+      style: this.style
+    }, this.$slots.default);
+  }
+};

package/packages/scrollbar/index.js

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

package/packages/scrollbar/src/bar.js

@@ -0,0 +1,88 @@
+import { on, off } from 'element-ui/src/utils/dom';
+import { renderThumbStyle, BAR_MAP } from './util';
+
+/* istanbul ignore next */
+export default {
+  name: 'Bar',
+
+  props: {
+    vertical: Boolean,
+    size: String,
+    move: Number
+  },
+
+  computed: {
+    bar() {
+      return BAR_MAP[this.vertical ? 'vertical' : 'horizontal'];
+    },
+
+    wrap() {
+      return this.$parent.wrap;
+    }
+  },
+
+  render(h) {
+    const { size, move, bar } = this;
+
+    return (
+      <div
+        class={ ['el-scrollbar__bar', 'is-' + bar.key] }
+        onMousedown={ this.clickTrackHandler } >
+        <div
+          ref="thumb"
+          class="el-scrollbar__thumb"
+          onMousedown={ this.clickThumbHandler }
+          style={ renderThumbStyle({ size, move, bar }) }>
+        </div>
+      </div>
+    );
+  },
+
+  methods: {
+    clickThumbHandler(e) {
+      this.startDrag(e);
+      this[this.bar.axis] = (e.currentTarget[this.bar.offset] - (e[this.bar.client] - e.currentTarget.getBoundingClientRect()[this.bar.direction]));
+    },
+
+    clickTrackHandler(e) {
+      const offset = Math.abs(e.target.getBoundingClientRect()[this.bar.direction] - e[this.bar.client]);
+      const thumbHalf = (this.$refs.thumb[this.bar.offset] / 2);
+      const thumbPositionPercentage = ((offset - thumbHalf) * 100 / this.$el[this.bar.offset]);
+
+      this.wrap[this.bar.scroll] = (thumbPositionPercentage * this.wrap[this.bar.scrollSize] / 100);
+    },
+
+    startDrag(e) {
+      e.stopImmediatePropagation();
+      this.cursorDown = true;
+
+      on(document, 'mousemove', this.mouseMoveDocumentHandler);
+      on(document, 'mouseup', this.mouseUpDocumentHandler);
+      document.onselectstart = () => false;
+    },
+
+    mouseMoveDocumentHandler(e) {
+      if (this.cursorDown === false) return;
+      const prevPage = this[this.bar.axis];
+
+      if (!prevPage) return;
+
+      const offset = ((this.$el.getBoundingClientRect()[this.bar.direction] - e[this.bar.client]) * -1);
+      const thumbClickPosition = (this.$refs.thumb[this.bar.offset] - prevPage);
+      const thumbPositionPercentage = ((offset - thumbClickPosition) * 100 / this.$el[this.bar.offset]);
+
+      this.wrap[this.bar.scroll] = (thumbPositionPercentage * this.wrap[this.bar.scrollSize] / 100);
+    },
+
+    mouseUpDocumentHandler(e) {
+      this.cursorDown = false;
+      this[this.bar.axis] = 0;
+      off(document, 'mousemove', this.mouseMoveDocumentHandler);
+      document.onselectstart = null;
+    }
+  },
+
+  destroyed() {
+    off(document, 'mouseup', this.mouseUpDocumentHandler);
+  }
+};

package/packages/scrollbar/src/main.js

@@ -0,0 +1,130 @@
+// reference https://github.com/noeldelgado/gemini-scrollbar/blob/master/index.js
+
+import { addResizeListener, removeResizeListener } from 'element-ui/src/utils/resize-event';
+import scrollbarWidth from 'element-ui/src/utils/scrollbar-width';
+import { toObject } from 'element-ui/src/utils/util';
+import Bar from './bar';
+
+/* istanbul ignore next */
+export default {
+  name: 'ElScrollbar',
+
+  components: { Bar },
+
+  props: {
+    native: Boolean,
+    wrapStyle: {},
+    wrapClass: {},
+    viewClass: {},
+    viewStyle: {},
+    noresize: Boolean, // 如果 container 尺寸不会发生变化，最好设置它可以优化性能
+    tag: {
+      type: String,
+      default: 'div'
+    }
+  },
+
+  data() {
+    return {
+      sizeWidth: '0',
+      sizeHeight: '0',
+      moveX: 0,
+      moveY: 0
+    };
+  },
+
+  computed: {
+    wrap() {
+      return this.$refs.wrap;
+    }
+  },
+
+  render(h) {
+    let gutter = scrollbarWidth();
+    let style = this.wrapStyle;
+
+    if (gutter) {
+      const gutterWith = `-${gutter}px`;
+      const gutterStyle = `margin-bottom: ${gutterWith}; margin-right: ${gutterWith};`;
+
+      if (Array.isArray(this.wrapStyle)) {
+        style = toObject(this.wrapStyle);
+        style.marginRight = style.marginBottom = gutterWith;
+      } else if (typeof this.wrapStyle === 'string') {
+        style += gutterStyle;
+      } else {
+        style = gutterStyle;
+      }
+    }
+    const view = h(this.tag, {
+      class: ['el-scrollbar__view', this.viewClass],
+      style: this.viewStyle,
+      ref: 'resize'
+    }, this.$slots.default);
+    const wrap = (
+      <div
+        ref="wrap"
+        style={ style }
+        onScroll={ this.handleScroll }
+        class={ [this.wrapClass, 'el-scrollbar__wrap', gutter ? '' : 'el-scrollbar__wrap--hidden-default'] }>
+        { [view] }
+      </div>
+    );
+    let nodes;
+
+    if (!this.native) {
+      nodes = ([
+        wrap,
+        <Bar
+          move={ this.moveX }
+          size={ this.sizeWidth }></Bar>,
+        <Bar
+          vertical
+          move={ this.moveY }
+          size={ this.sizeHeight }></Bar>
+      ]);
+    } else {
+      nodes = ([
+        <div
+          ref="wrap"
+          class={ [this.wrapClass, 'el-scrollbar__wrap'] }
+          style={ style }>
+          { [view] }
+        </div>
+      ]);
+    }
+    return h('div', { class: 'el-scrollbar' }, nodes);
+  },
+
+  methods: {
+    handleScroll() {
+      const wrap = this.wrap;
+
+      this.moveY = ((wrap.scrollTop * 100) / wrap.clientHeight);
+      this.moveX = ((wrap.scrollLeft * 100) / wrap.clientWidth);
+    },
+
+    update() {
+      let heightPercentage, widthPercentage;
+      const wrap = this.wrap;
+      if (!wrap) return;
+
+      heightPercentage = (wrap.clientHeight * 100 / wrap.scrollHeight);
+      widthPercentage = (wrap.clientWidth * 100 / wrap.scrollWidth);
+
+      this.sizeHeight = (heightPercentage < 100) ? (heightPercentage + '%') : '';
+      this.sizeWidth = (widthPercentage < 100) ? (widthPercentage + '%') : '';
+    }
+  },
+
+  mounted() {
+    if (this.native) return;
+    this.$nextTick(this.update);
+    !this.noresize && addResizeListener(this.$refs.resize, this.update);
+  },
+
+  beforeDestroy() {
+    if (this.native) return;
+    !this.noresize && removeResizeListener(this.$refs.resize, this.update);
+  }
+};

package/packages/scrollbar/src/util.js

@@ -0,0 +1,34 @@
+export const BAR_MAP = {
+  vertical: {
+    offset: 'offsetHeight',
+    scroll: 'scrollTop',
+    scrollSize: 'scrollHeight',
+    size: 'height',
+    key: 'vertical',
+    axis: 'Y',
+    client: 'clientY',
+    direction: 'top'
+  },
+  horizontal: {
+    offset: 'offsetWidth',
+    scroll: 'scrollLeft',
+    scrollSize: 'scrollWidth',
+    size: 'width',
+    key: 'horizontal',
+    axis: 'X',
+    client: 'clientX',
+    direction: 'left'
+  }
+};
+
+export function renderThumbStyle({ move, size, bar }) {
+  const style = {};
+  const translate = `translate${bar.axis}(${ move }%)`;
+
+  style[bar.size] = size;
+  style.transform = translate;
+  style.msTransform = translate;
+  style.webkitTransform = translate;
+
+  return style;
+};

package/packages/select/index.js

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