@zkwq/business 0.0.1

package/src/components/base/ui/input/calcTextareaHeight.js

@@ -0,0 +1,104 @@
+let hiddenTextarea;
+
+const HIDDEN_STYLE = `
+  height:0 !important;
+  visibility:hidden !important;
+  overflow:hidden !important;
+  position:absolute !important;
+  z-index:-1000 !important;
+  top:0 !important;
+  right:0 !important
+`;
+
+const CONTEXT_STYLE = [
+  'letter-spacing',
+  'line-height',
+  'padding-top',
+  'padding-bottom',
+  'font-family',
+  'font-weight',
+  'font-size',
+  'text-rendering',
+  'text-transform',
+  'width',
+  'text-indent',
+  'padding-left',
+  'padding-right',
+  'border-width',
+  'box-sizing'
+];
+
+function calculateNodeStyling(targetElement) {
+  const style = window.getComputedStyle(targetElement);
+
+  const boxSizing = style.getPropertyValue('box-sizing');
+
+  const paddingSize = (
+    parseFloat(style.getPropertyValue('padding-bottom')) +
+    parseFloat(style.getPropertyValue('padding-top'))
+  );
+
+  const borderSize = (
+    parseFloat(style.getPropertyValue('border-bottom-width')) +
+    parseFloat(style.getPropertyValue('border-top-width'))
+  );
+
+  const contextStyle = CONTEXT_STYLE
+    .map(name => `${name}:${style.getPropertyValue(name)}`)
+    .join(';');
+
+  return { contextStyle, paddingSize, borderSize, boxSizing };
+}
+
+export default function calcTextareaHeight(
+  targetElement,
+  minRows = 1,
+  maxRows = null
+) {
+  if (!hiddenTextarea) {
+    hiddenTextarea = document.createElement('textarea');
+    document.body.appendChild(hiddenTextarea);
+  }
+
+  let {
+    paddingSize,
+    borderSize,
+    boxSizing,
+    contextStyle
+  } = calculateNodeStyling(targetElement);
+
+  hiddenTextarea.setAttribute('style', `${contextStyle};${HIDDEN_STYLE}`);
+  hiddenTextarea.value = targetElement.value || targetElement.placeholder || '';
+
+  let height = hiddenTextarea.scrollHeight;
+  const result = {};
+
+  if (boxSizing === 'border-box') {
+    height = height + borderSize;
+  } else if (boxSizing === 'content-box') {
+    height = height - paddingSize;
+  }
+
+  hiddenTextarea.value = '';
+  let singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
+
+  if (minRows !== null) {
+    let minHeight = singleRowHeight * minRows;
+    if (boxSizing === 'border-box') {
+      minHeight = minHeight + paddingSize + borderSize;
+    }
+    height = Math.max(minHeight, height);
+    result.minHeight = `${ minHeight }px`;
+  }
+  if (maxRows !== null) {
+    let maxHeight = singleRowHeight * maxRows;
+    if (boxSizing === 'border-box') {
+      maxHeight = maxHeight + paddingSize + borderSize;
+    }
+    height = Math.min(maxHeight, height);
+  }
+  result.height = `${ height }px`;
+  hiddenTextarea.parentNode && hiddenTextarea.parentNode.removeChild(hiddenTextarea);
+  hiddenTextarea = null;
+  return result;
+};

package/src/components/base/ui/input-number/input-number.vue

@@ -0,0 +1,285 @@
+<template>
+  <div
+    @dragstart.prevent
+    :class="[
+      'base-input-number',
+      inputNumberSize ? 'base-input-number--' + inputNumberSize : '',
+      { 'is-disabled': inputNumberDisabled },
+      { 'is-without-controls': !controls },
+      { 'is-controls-right': controlsAtRight }
+    ]">
+    <span
+      class="base-input-number__decrease"
+      role="button"
+      v-if="controls"
+      v-repeat-click="decrease"
+      :class="{'is-disabled': minDisabled}"
+      @keydown.enter="decrease">
+      <i :class="`base-icon-${controlsAtRight ? 'arrow-down' : 'minus'}`"></i>
+    </span>
+    <span
+      class="base-input-number__increase"
+      role="button"
+      v-if="controls"
+      v-repeat-click="increase"
+      :class="{'is-disabled': maxDisabled}"
+      @keydown.enter="increase">
+      <i :class="`base-icon-${controlsAtRight ? 'arrow-up' : 'plus'}`"></i>
+    </span>
+    <base-input
+      ref="input"
+      :value="displayValue"
+      :placeholder="placeholder"
+      :disabled="inputNumberDisabled"
+      :size="inputNumberSize"
+      :max="max"
+      :min="min"
+      :name="name"
+      :label="label"
+      :show-lable="false"
+      :ripple="false"
+      @keydown.up.native.prevent="increase"
+      @keydown.down.native.prevent="decrease"
+      @blur="handleBlur"
+      @focus="handleFocus"
+      @input="handleInput"
+      @change="handleInputChange">
+    </base-input>
+  </div>
+</template>
+<script>
+  import BaseInput from '../input/Input';
+  import Focus from '../mixin/focus';
+  import RepeatClick from '../directive/repeat-click';
+
+  export default {
+    name: 'BaseInputNumber',
+    mixins: [Focus('input')],
+    inject: {
+      baseForm: {
+        default: ''
+      },
+      elFormItem: {
+        default: ''
+      }
+    },
+    directives: {
+      repeatClick: RepeatClick
+    },
+    components: {
+      BaseInput
+    },
+    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';
+      },
+      _baseFormItemSize() {
+        return (this.elFormItem || {}).baseFormItemSize;
+      },
+      inputNumberSize() {
+        return this.size || this._baseFormItemSize || (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/components/base/ui/locale/format.js

@@ -0,0 +1,32 @@
+import { hasOwn } from '../util/index'
+
+const RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g
+
+export default function(Vue) {
+  function template(string, ...args) {
+    if (args.length === 1 && typeof args[0] === 'object') {
+      args = args[0]
+    }
+
+    if (!args || !args.hasOwnProperty) {
+      args = {}
+    }
+
+    return string.replace(RE_NARGS, (match, prefix, i, index) => {
+      let result
+
+      if (string[index - 1] === '{' &&
+        string[index + match.length] === '}') {
+        return i
+      } else {
+        result = hasOwn(args, i) ? args[i] : null
+        if (result === null || result === undefined) {
+          return ''
+        }
+
+        return result
+      }
+    })
+  }
+  return template
+}

package/src/components/base/ui/locale/index.js

@@ -0,0 +1,48 @@
+import defaultLang from './lang/zh-CN'
+import Vue from 'vue'
+import deepmerge from '../util/deepmerge'
+import Format from './format'
+
+const format = Format(Vue)
+let lang = defaultLang
+let merged = false
+let i18nHandler = function() {
+  const vuei18n = Object.getPrototypeOf(this || Vue).$t
+  if (typeof vuei18n === 'function' && !!Vue.locale) {
+    if (!merged) {
+      merged = true
+      Vue.locale(
+        Vue.config.lang,
+        deepmerge(lang, Vue.locale(Vue.config.lang) || {}, { clone: true })
+      )
+    }
+    return vuei18n.apply(this, arguments)
+  }
+}
+
+export const t = function(path, options) {
+  let value = i18nHandler.apply(this, arguments)
+  if (value !== null && value !== undefined) return value
+
+  const array = path.split('.')
+  let current = lang
+
+  for (let i = 0, j = array.length; i < j; i++) {
+    const property = array[i]
+    value = current[property]
+    if (i === j - 1) return format(value, options)
+    if (!value) return ''
+    current = value
+  }
+  return ''
+}
+
+export const use = function(l) {
+  lang = l || lang
+}
+
+export const i18n = function(fn) {
+  i18nHandler = fn || i18nHandler
+}
+
+export default { use, t, i18n }

package/src/components/base/ui/locale/lang/zh-CN.js

@@ -0,0 +1,120 @@
+export default {
+  base: {
+    colorpicker: {
+      confirm: '确定',
+      clear: '清空'
+    },
+    datepicker: {
+      now: '此刻',
+      today: '今天',
+      cancel: '取消',
+      clear: '清空',
+      confirm: '确定',
+      selectDate: '选择日期',
+      selectTime: '选择时间',
+      startDate: '开始日期',
+      startTime: '开始时间',
+      endDate: '结束日期',
+      endTime: '结束时间',
+      prevYear: '前一年',
+      nextYear: '后一年',
+      prevMonth: '上个月',
+      nextMonth: '下个月',
+      year: '年',
+      month1: '1 月',
+      month2: '2 月',
+      month3: '3 月',
+      month4: '4 月',
+      month5: '5 月',
+      month6: '6 月',
+      month7: '7 月',
+      month8: '8 月',
+      month9: '9 月',
+      month10: '10 月',
+      month11: '11 月',
+      month12: '12 月',
+      // week: '周次',
+      weeks: {
+        sun: '日',
+        mon: '一',
+        tue: '二',
+        wed: '三',
+        thu: '四',
+        fri: '五',
+        sat: '六'
+      },
+      months: {
+        jan: '一月',
+        feb: '二月',
+        mar: '三月',
+        apr: '四月',
+        may: '五月',
+        jun: '六月',
+        jul: '七月',
+        aug: '八月',
+        sep: '九月',
+        oct: '十月',
+        nov: '十一月',
+        dec: '十二月'
+      }
+    },
+    select: {
+      loading: '加载中',
+      noMatch: '无匹配数据',
+      noData: '无数据',
+      placeholder: '请选择'
+    },
+    cascader: {
+      noMatch: '无匹配数据',
+      loading: '加载中',
+      placeholder: '请选择',
+      noData: '暂无数据'
+    },
+    pagination: {
+      goto: '前往',
+      pagesize: '条/页',
+      total: '共 {total} {unitText}',
+      pageClassifier: '页'
+    },
+    messagebox: {
+      title: '提示',
+      confirm: '确定',
+      cancel: '取消',
+      error: '输入的数据不合法!'
+    },
+    upload: {
+      deleteTip: '按 delete 键可删除',
+      delete: '删除',
+      preview: '查看图片',
+      continue: '继续上传'
+    },
+    table: {
+      emptyText: '暂无数据',
+      confirmFilter: '筛选',
+      resetFilter: '重置',
+      clearFilter: '全部',
+      sumText: '合计'
+    },
+    tree: {
+      emptyText: '暂无数据'
+    },
+    transfer: {
+      noMatch: '无匹配数据',
+      noData: '无数据',
+      titles: ['列表 1', '列表 2'],
+      filterPlaceholder: '请输入搜索内容',
+      noCheckedFormat: '共 {total} 项',
+      hasCheckedFormat: '已选 {checked}/{total} 项'
+    },
+    image: {
+      error: '加载失败'
+    },
+    pageHeader: {
+      title: '返回'
+    },
+    popconfirm: {
+      confirmButtonText: '确定',
+      cancelButtonText: '取消'
+    }
+  }
+}

package/src/components/base/ui/menu/menu-item-group.vue

@@ -0,0 +1,45 @@
+<template>
+  <li class="base-menu-item-group">
+    <div class="base-menu-item-group__title" :style="{paddingLeft: levelPadding + 'px'}">
+      <template v-if="!$slots.title">{{title}}</template>
+      <slot v-else name="title"></slot>
+    </div>
+    <ul>
+      <slot></slot>
+    </ul>
+  </li>
+</template>
+<script>
+  export default {
+    name: 'BaseMenuItemGroup',
+
+    componentName: 'BaseMenuItemGroup',
+
+    inject: ['rootMenu'],
+    props: {
+      title: {
+        type: String
+      }
+    },
+    data() {
+      return {
+        paddingLeft: 20
+      };
+    },
+    computed: {
+      levelPadding() {
+        let padding = 20;
+        let parent = this.$parent;
+        if (this.rootMenu.collapse) return 20;
+        while (parent && parent.$options.componentName !== 'BaseMenu') {
+          if (parent.$options.componentName === 'BaseSubmenu') {
+            padding += 20;
+          }
+          parent = parent.$parent;
+        }
+        return padding;
+      }
+    }
+  };
+</script>
+