@10yun/cv-pc-ui 0.2.4 → 0.2.8

package/src/dict/area-province.js

@@ -0,0 +1,37 @@
+export default {
+  110000: '北京市',
+  120000: '天津市',
+  130000: '河北省',
+  140000: '山西省',
+  150000: '内蒙古自治区',
+  210000: '辽宁省',
+  220000: '吉林省',
+  230000: '黑龙江省',
+  310000: '上海市',
+  320000: '江苏省',
+  330000: '浙江省',
+  340000: '安徽省',
+  350000: '福建省',
+  360000: '江西省',
+  370000: '山东省',
+  410000: '河南省',
+  420000: '湖北省',
+  430000: '湖南省',
+  440000: '广东省',
+  450000: '广西壮族自治区',
+  460000: '海南省',
+  500000: '重庆市',
+  510000: '四川省',
+  520000: '贵州省',
+  530000: '云南省',
+  540000: '西藏自治区',
+  610000: '陕西省',
+  620000: '甘肃省',
+  630000: '青海省',
+  640000: '宁夏回族自治区',
+  650000: '新疆维吾尔自治区',
+  710000: '台湾省',
+  810000: '香港特别行政区',
+  820000: '澳门特别行政区',
+  900000: '海外',
+};

package/src/mixins/cascader.js

@@ -61,7 +61,6 @@ export default {
       type: Boolean,
       default: false
     },
-
   },
   watch: {
     value() {
@@ -91,7 +90,7 @@ export default {
   },
   computed: {
     // 传给内部组件的数据，内部组件通过 props 接收一个对象，因此把数据整合在一个对象中
-    props() {
+    props2() {
       return Object.assign(this.dataField, { emitPath: this.emitPath }, { multiple: this.multiple })
     }
   },

package/src/mixins/emitter.js

@@ -0,0 +1,33 @@
+function broadcast(componentName, eventName, params) {
+  this.$children.forEach(child => {
+    var name = child.$options.componentName;
+
+    if (name === componentName) {
+      child.$emit.apply(child, [eventName].concat(params));
+    } else {
+      broadcast.apply(child, [componentName, eventName].concat([params]));
+    }
+  });
+}
+export default {
+  methods: {
+    dispatch(componentName, eventName, params) {
+      var parent = this.$parent || this.$root;
+      var name = parent.$options.componentName;
+
+      while (parent && (!name || name !== componentName)) {
+        parent = parent.$parent;
+
+        if (parent) {
+          name = parent.$options.componentName;
+        }
+      }
+      if (parent) {
+        parent.$emit.apply(parent, [eventName].concat(params));
+      }
+    },
+    broadcast(componentName, eventName, params) {
+      broadcast.call(this, componentName, eventName, params);
+    }
+  }
+};

package/src/mixins/formItem.js

@@ -49,18 +49,17 @@ export default {
   },
   data() {
     return {
-      // 是否处于表单中
-      is_form: false,
       // 是否必填
       // localRequired: false,
       // 错误提示信息
       localError: "",
       // 自定义的input错误状态
-      validateState: "",
+      // validateState: "",
     };
   },
   // data() {
   //   return {
+  //     is_form:false,
   //     localVal: this.value //将prop属性绑定到data属性上，以便修改prop属性（Vue不允许直接修改prop属性的值）
   //   };
   // },
@@ -71,9 +70,9 @@ export default {
   // },
   beforeMount() {
     // 判断祖先元素是否存在form节点
-    if (this.elForm && this.elForm._vnode.data.staticClass === "el-form") {
-      this.is_form = true;
-    }
+    // if (this.elForm && this.elForm._vnode.data.staticClass === "el-form") {
+    // this.is_form = true;
+    // }
   },
 
   methods: {

package/src/mixins/input.js

@@ -57,7 +57,7 @@ export default {
     },
     // 处理错误提示信息
     _showError(msg) {
-      this.validateState = "error";
+      // this.validateState = "error";
       this.localError = msg || "请输入正确的" + this.label;
     },
     _diyValidate() {
@@ -68,7 +68,7 @@ export default {
       const localRules = newArr;
 
       this.localError = "";
-      this.validateState = "";
+      // this.validateState = "";
 
       for (let i in localRules) {
         let itemRuleStr = localRules[i];

package/src/mixins/migrating.js

@@ -0,0 +1,54 @@
+import { kebabCase } from '../utils/util';
+/**
+ * Show migrating guide in browser console.
+ *
+ * Usage:
+ * import Migrating from 'element-ui/src/mixins/migrating';
+ *
+ * mixins: [Migrating]
+ *
+ * add getMigratingConfig method for your component.
+ *  getMigratingConfig() {
+ *    return {
+ *      props: {
+ *        'allow-no-selection': 'allow-no-selection is removed.',
+ *        'selection-mode': 'selection-mode is removed.'
+ *      },
+ *      events: {
+ *        selectionchange: 'selectionchange is renamed to selection-change.'
+ *      }
+ *    };
+ *  },
+ */
+export default {
+  mounted() {
+    if (process.env.NODE_ENV === 'production') return;
+    if (!this.$vnode) return;
+    const { props = {}, events = {} } = this.getMigratingConfig();
+    const { data, componentOptions } = this.$vnode;
+    const definedProps = data.attrs || {};
+    const definedEvents = componentOptions.listeners || {};
+
+    for (let propName in definedProps) {
+      propName = kebabCase(propName); // compatible with camel case
+      if (props[propName]) {
+        console.warn(`[Element Migrating][${this.$options.name}][Attribute]: ${props[propName]}`);
+      }
+    }
+
+    for (let eventName in definedEvents) {
+      eventName = kebabCase(eventName); // compatible with camel case
+      if (events[eventName]) {
+        console.warn(`[Element Migrating][${this.$options.name}][Event]: ${events[eventName]}`);
+      }
+    }
+  },
+  methods: {
+    getMigratingConfig() {
+      return {
+        props: {},
+        events: {}
+      };
+    }
+  }
+};

package/src/utils/dom.js

@@ -0,0 +1,227 @@
+/* istanbul ignore next */
+
+import Vue from 'vue';
+
+const isServer = Vue.prototype.$isServer;
+const SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
+const MOZ_HACK_REGEXP = /^moz([A-Z])/;
+const ieVersion = isServer ? 0 : Number(document.documentMode);
+
+/* istanbul ignore next */
+const trim = function(string) {
+  return (string || '').replace(/^[\s\uFEFF]+|[\s\uFEFF]+$/g, '');
+};
+/* istanbul ignore next */
+const camelCase = function(name) {
+  return name.replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
+    return offset ? letter.toUpperCase() : letter;
+  }).replace(MOZ_HACK_REGEXP, 'Moz$1');
+};
+
+/* istanbul ignore next */
+export const on = (function() {
+  if (!isServer && document.addEventListener) {
+    return function(element, event, handler) {
+      if (element && event && handler) {
+        element.addEventListener(event, handler, false);
+      }
+    };
+  } else {
+    return function(element, event, handler) {
+      if (element && event && handler) {
+        element.attachEvent('on' + event, handler);
+      }
+    };
+  }
+})();
+
+/* istanbul ignore next */
+export const off = (function() {
+  if (!isServer && document.removeEventListener) {
+    return function(element, event, handler) {
+      if (element && event) {
+        element.removeEventListener(event, handler, false);
+      }
+    };
+  } else {
+    return function(element, event, handler) {
+      if (element && event) {
+        element.detachEvent('on' + event, handler);
+      }
+    };
+  }
+})();
+
+/* istanbul ignore next */
+export const once = function(el, event, fn) {
+  var listener = function() {
+    if (fn) {
+      fn.apply(this, arguments);
+    }
+    off(el, event, listener);
+  };
+  on(el, event, listener);
+};
+
+/* istanbul ignore next */
+export function hasClass(el, cls) {
+  if (!el || !cls) return false;
+  if (cls.indexOf(' ') !== -1) throw new Error('className should not contain space.');
+  if (el.classList) {
+    return el.classList.contains(cls);
+  } else {
+    return (' ' + el.className + ' ').indexOf(' ' + cls + ' ') > -1;
+  }
+};
+
+/* istanbul ignore next */
+export function addClass(el, cls) {
+  if (!el) return;
+  var curClass = el.className;
+  var classes = (cls || '').split(' ');
+
+  for (var i = 0, j = classes.length; i < j; i++) {
+    var clsName = classes[i];
+    if (!clsName) continue;
+
+    if (el.classList) {
+      el.classList.add(clsName);
+    } else if (!hasClass(el, clsName)) {
+      curClass += ' ' + clsName;
+    }
+  }
+  if (!el.classList) {
+    el.setAttribute('class', curClass);
+  }
+};
+
+/* istanbul ignore next */
+export function removeClass(el, cls) {
+  if (!el || !cls) return;
+  var classes = cls.split(' ');
+  var curClass = ' ' + el.className + ' ';
+
+  for (var i = 0, j = classes.length; i < j; i++) {
+    var clsName = classes[i];
+    if (!clsName) continue;
+
+    if (el.classList) {
+      el.classList.remove(clsName);
+    } else if (hasClass(el, clsName)) {
+      curClass = curClass.replace(' ' + clsName + ' ', ' ');
+    }
+  }
+  if (!el.classList) {
+    el.setAttribute('class', trim(curClass));
+  }
+};
+
+/* istanbul ignore next */
+export const getStyle = ieVersion < 9 ? function(element, styleName) {
+  if (isServer) return;
+  if (!element || !styleName) return null;
+  styleName = camelCase(styleName);
+  if (styleName === 'float') {
+    styleName = 'styleFloat';
+  }
+  try {
+    switch (styleName) {
+      case 'opacity':
+        try {
+          return element.filters.item('alpha').opacity / 100;
+        } catch (e) {
+          return 1.0;
+        }
+      default:
+        return (element.style[styleName] || element.currentStyle ? element.currentStyle[styleName] : null);
+    }
+  } catch (e) {
+    return element.style[styleName];
+  }
+} : function(element, styleName) {
+  if (isServer) return;
+  if (!element || !styleName) return null;
+  styleName = camelCase(styleName);
+  if (styleName === 'float') {
+    styleName = 'cssFloat';
+  }
+  try {
+    var computed = document.defaultView.getComputedStyle(element, '');
+    return element.style[styleName] || computed ? computed[styleName] : null;
+  } catch (e) {
+    return element.style[styleName];
+  }
+};
+
+/* istanbul ignore next */
+export function setStyle(element, styleName, value) {
+  if (!element || !styleName) return;
+
+  if (typeof styleName === 'object') {
+    for (var prop in styleName) {
+      if (styleName.hasOwnProperty(prop)) {
+        setStyle(element, prop, styleName[prop]);
+      }
+    }
+  } else {
+    styleName = camelCase(styleName);
+    if (styleName === 'opacity' && ieVersion < 9) {
+      element.style.filter = isNaN(value) ? '' : 'alpha(opacity=' + value * 100 + ')';
+    } else {
+      element.style[styleName] = value;
+    }
+  }
+};
+
+export const isScroll = (el, vertical) => {
+  if (isServer) return;
+
+  const determinedDirection = vertical !== null && vertical !== undefined;
+  const overflow = determinedDirection
+    ? vertical
+      ? getStyle(el, 'overflow-y')
+      : getStyle(el, 'overflow-x')
+    : getStyle(el, 'overflow');
+
+  return overflow.match(/(scroll|auto|overlay)/);
+};
+
+export const getScrollContainer = (el, vertical) => {
+  if (isServer) return;
+
+  let parent = el;
+  while (parent) {
+    if ([window, document, document.documentElement].includes(parent)) {
+      return window;
+    }
+    if (isScroll(parent, vertical)) {
+      return parent;
+    }
+    parent = parent.parentNode;
+  }
+
+  return parent;
+};
+
+export const isInContainer = (el, container) => {
+  if (isServer || !el || !container) return false;
+
+  const elRect = el.getBoundingClientRect();
+  let containerRect;
+
+  if ([window, document, document.documentElement, null, undefined].includes(container)) {
+    containerRect = {
+      top: 0,
+      right: window.innerWidth,
+      bottom: window.innerHeight,
+      left: 0
+    };
+  } else {
+    containerRect = container.getBoundingClientRect();
+  }
+
+  return elRect.top < containerRect.bottom &&
+    elRect.bottom > containerRect.top &&
+    elRect.right > containerRect.left &&
+    elRect.left < containerRect.right;
+};

package/src/utils/merge.js

@@ -0,0 +1,15 @@
+export default function(target) {
+  for (let i = 1, j = arguments.length; i < j; i++) {
+    let source = arguments[i] || {};
+    for (let prop in source) {
+      if (source.hasOwnProperty(prop)) {
+        let value = source[prop];
+        if (value !== undefined) {
+          target[prop] = value;
+        }
+      }
+    }
+  }
+
+  return target;
+};

package/src/utils/scrollbar-width.js

@@ -0,0 +1,29 @@
+import Vue from 'vue';
+
+let scrollBarWidth;
+
+export default function() {
+  if (Vue.prototype.$isServer) return 0;
+  if (scrollBarWidth !== undefined) return scrollBarWidth;
+
+  const outer = document.createElement('div');
+  outer.className = 'el-scrollbar__wrap';
+  outer.style.visibility = 'hidden';
+  outer.style.width = '100px';
+  outer.style.position = 'absolute';
+  outer.style.top = '-9999px';
+  document.body.appendChild(outer);
+
+  const widthNoScroll = outer.offsetWidth;
+  outer.style.overflow = 'scroll';
+
+  const inner = document.createElement('div');
+  inner.style.width = '100%';
+  outer.appendChild(inner);
+
+  const widthWithScroll = inner.offsetWidth;
+  outer.parentNode.removeChild(outer);
+  scrollBarWidth = widthNoScroll - widthWithScroll;
+
+  return scrollBarWidth;
+};

package/src/utils/types.js

@@ -0,0 +1,40 @@
+import Vue from 'vue';
+
+export function isString(obj) {
+  return Object.prototype.toString.call(obj) === '[object String]';
+}
+
+export function isObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]';
+}
+
+export function isHtmlElement(node) {
+  return node && node.nodeType === Node.ELEMENT_NODE;
+}
+
+/**
+ *  - Inspired:
+ *    https://github.com/jashkenas/underscore/blob/master/modules/isFunction.js
+ */
+let isFunction = (functionToCheck) => {
+  var getType = {};
+  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
+};
+
+if (typeof /./ !== 'function' && typeof Int8Array !== 'object' && (Vue.prototype.$isServer || typeof document.childNodes !== 'function')) {
+  isFunction = function (obj) {
+    return typeof obj === 'function' || false;
+  };
+}
+
+export {
+  isFunction
+};
+
+export const isUndefined = (val) => {
+  return val === void 0;
+};
+
+export const isDefined = (val) => {
+  return val !== undefined && val !== null;
+};