cbvirtua 1.0.37 → 1.0.38

package/src/src/utils/util.js

@@ -0,0 +1,245 @@
+import Vue from 'vue';
+import { isString, isObject } from 'element-ui/src/utils/types';
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+export function noop() {};
+
+export function hasOwn(obj, key) {
+  return hasOwnProperty.call(obj, key);
+};
+
+function extend(to, _from) {
+  for (let key in _from) {
+    to[key] = _from[key];
+  }
+  return to;
+};
+
+export function toObject(arr) {
+  var res = {};
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i]) {
+      extend(res, arr[i]);
+    }
+  }
+  return res;
+};
+
+export const getValueByPath = function(object, prop) {
+  prop = prop || '';
+  const paths = prop.split('.');
+  let current = object;
+  let result = null;
+  for (let i = 0, j = paths.length; i < j; i++) {
+    const path = paths[i];
+    if (!current) break;
+
+    if (i === j - 1) {
+      result = current[path];
+      break;
+    }
+    current = current[path];
+  }
+  return result;
+};
+
+export function getPropByPath(obj, path, strict) {
+  let tempObj = obj;
+  path = path.replace(/\[(\w+)\]/g, '.$1');
+  path = path.replace(/^\./, '');
+
+  let keyArr = path.split('.');
+  let i = 0;
+  for (let len = keyArr.length; i < len - 1; ++i) {
+    if (!tempObj && !strict) break;
+    let key = keyArr[i];
+    if (key in tempObj) {
+      tempObj = tempObj[key];
+    } else {
+      if (strict) {
+        throw new Error('please transfer a valid prop path to form item!');
+      }
+      break;
+    }
+  }
+  return {
+    o: tempObj,
+    k: keyArr[i],
+    v: tempObj ? tempObj[keyArr[i]] : null
+  };
+};
+
+export const generateId = function() {
+  return Math.floor(Math.random() * 10000);
+};
+
+export const valueEquals = (a, b) => {
+  // see: https://stackoverflow.com/questions/3115982/how-to-check-if-two-arrays-are-equal-with-javascript
+  if (a === b) return true;
+  if (!(a instanceof Array)) return false;
+  if (!(b instanceof Array)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i !== a.length; ++i) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+};
+
+export const escapeRegexpString = (value = '') => String(value).replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+
+// TODO: use native Array.find, Array.findIndex when IE support is dropped
+export const arrayFindIndex = function(arr, pred) {
+  for (let i = 0; i !== arr.length; ++i) {
+    if (pred(arr[i])) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+export const arrayFind = function(arr, pred) {
+  const idx = arrayFindIndex(arr, pred);
+  return idx !== -1 ? arr[idx] : undefined;
+};
+
+// coerce truthy value to array
+export const coerceTruthyValueToArray = function(val) {
+  if (Array.isArray(val)) {
+    return val;
+  } else if (val) {
+    return [val];
+  } else {
+    return [];
+  }
+};
+
+export const isIE = function() {
+  return !Vue.prototype.$isServer && !isNaN(Number(document.documentMode));
+};
+
+export const isEdge = function() {
+  return !Vue.prototype.$isServer && navigator.userAgent.indexOf('Edge') > -1;
+};
+
+export const isFirefox = function() {
+  return !Vue.prototype.$isServer && !!window.navigator.userAgent.match(/firefox/i);
+};
+
+export const autoprefixer = function(style) {
+  if (typeof style !== 'object') return style;
+  const rules = ['transform', 'transition', 'animation'];
+  const prefixes = ['ms-', 'webkit-'];
+  rules.forEach(rule => {
+    const value = style[rule];
+    if (rule && value) {
+      prefixes.forEach(prefix => {
+        style[prefix + rule] = value;
+      });
+    }
+  });
+  return style;
+};
+
+export const kebabCase = function(str) {
+  const hyphenateRE = /([^-])([A-Z])/g;
+  return str
+    .replace(hyphenateRE, '$1-$2')
+    .replace(hyphenateRE, '$1-$2')
+    .toLowerCase();
+};
+
+export const capitalize = function(str) {
+  if (!isString(str)) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+export const looseEqual = function(a, b) {
+  const isObjectA = isObject(a);
+  const isObjectB = isObject(b);
+  if (isObjectA && isObjectB) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } else if (!isObjectA && !isObjectB) {
+    return String(a) === String(b);
+  } else {
+    return false;
+  }
+};
+
+export const arrayEquals = function(arrayA, arrayB) {
+  arrayA = arrayA || [];
+  arrayB = arrayB || [];
+
+  if (arrayA.length !== arrayB.length) {
+    return false;
+  }
+
+  for (let i = 0; i < arrayA.length; i++) {
+    if (!looseEqual(arrayA[i], arrayB[i])) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export const isEqual = function(value1, value2) {
+  if (Array.isArray(value1) && Array.isArray(value2)) {
+    return arrayEquals(value1, value2);
+  }
+  return looseEqual(value1, value2);
+};
+
+export const isEmpty = function(val) {
+  // null or undefined
+  if (val == null) return true;
+
+  if (typeof val === 'boolean') return false;
+
+  if (typeof val === 'number') return !val;
+
+  if (val instanceof Error) return val.message === '';
+
+  switch (Object.prototype.toString.call(val)) {
+    // String or Array
+    case '[object String]':
+    case '[object Array]':
+      return !val.length;
+
+    // Map or Set or File
+    case '[object File]':
+    case '[object Map]':
+    case '[object Set]': {
+      return !val.size;
+    }
+    // Plain Object
+    case '[object Object]': {
+      return !Object.keys(val).length;
+    }
+  }
+
+  return false;
+};
+
+export function rafThrottle(fn) {
+  let locked = false;
+  return function(...args) {
+    if (locked) return;
+    locked = true;
+    window.requestAnimationFrame(_ => {
+      fn.apply(this, args);
+      locked = false;
+    });
+  };
+}
+
+export function objToArray(obj) {
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+  return isEmpty(obj) ? [] : [obj];
+}
+
+export const isMac = function() {
+  return !Vue.prototype.$isServer && /macintosh|mac os x/i.test(navigator.userAgent);
+};

package/src/src/utils/vdom.js

@@ -0,0 +1,5 @@
+import { hasOwn } from 'element-ui/src/utils/util';
+
+export function isVNode(node) {
+  return node !== null && typeof node === 'object' && hasOwn(node, 'componentOptions');
+};

package/src/src/utils/vue-popper.js

@@ -0,0 +1,198 @@
+import Vue from 'vue';
+import {
+  PopupManager
+} from 'element-ui/src/utils/popup';
+
+const PopperJS = Vue.prototype.$isServer ? function() {} : require('./popper');
+const stop = e => e.stopPropagation();
+
+/**
+ * @param {HTMLElement} [reference=$refs.reference] - The reference element used to position the popper.
+ * @param {HTMLElement} [popper=$refs.popper] - The HTML element used as popper, or a configuration used to generate the popper.
+ * @param {String} [placement=button] - Placement of the popper accepted values: top(-start, -end), right(-start, -end), bottom(-start, -end), left(-start, -end)
+ * @param {Number} [offset=0] - Amount of pixels the popper will be shifted (can be negative).
+ * @param {Boolean} [visible=false] Visibility of the popup element.
+ * @param {Boolean} [visible-arrow=false] Visibility of the arrow, no style.
+ */
+export default {
+  props: {
+    transformOrigin: {
+      type: [Boolean, String],
+      default: true
+    },
+    placement: {
+      type: String,
+      default: 'bottom'
+    },
+    boundariesPadding: {
+      type: Number,
+      default: 5
+    },
+    reference: {},
+    popper: {},
+    offset: {
+      default: 0
+    },
+    value: Boolean,
+    visibleArrow: Boolean,
+    arrowOffset: {
+      type: Number,
+      default: 35
+    },
+    appendToBody: {
+      type: Boolean,
+      default: true
+    },
+    popperOptions: {
+      type: Object,
+      default() {
+        return {
+          gpuAcceleration: false
+        };
+      }
+    }
+  },
+
+  data() {
+    return {
+      showPopper: false,
+      currentPlacement: ''
+    };
+  },
+
+  watch: {
+    value: {
+      immediate: true,
+      handler(val) {
+        this.showPopper = val;
+        this.$emit('input', val);
+      }
+    },
+
+    showPopper(val) {
+      if (this.disabled) return;
+      val ? this.updatePopper() : this.destroyPopper();
+      this.$emit('input', val);
+    }
+  },
+
+  methods: {
+    createPopper() {
+      if (this.$isServer) return;
+      this.currentPlacement = this.currentPlacement || this.placement;
+      if (!/^(top|bottom|left|right)(-start|-end)?$/g.test(this.currentPlacement)) {
+        return;
+      }
+
+      const options = this.popperOptions;
+      const popper = this.popperElm = this.popperElm || this.popper || this.$refs.popper;
+      let reference = this.referenceElm = this.referenceElm || this.reference || this.$refs.reference;
+
+      if (!reference &&
+        this.$slots.reference &&
+        this.$slots.reference[0]) {
+        reference = this.referenceElm = this.$slots.reference[0].elm;
+      }
+
+      if (!popper || !reference) return;
+      if (this.visibleArrow) this.appendArrow(popper);
+      if (this.appendToBody) document.body.appendChild(this.popperElm);
+      if (this.popperJS && this.popperJS.destroy) {
+        this.popperJS.destroy();
+      }
+
+      options.placement = this.currentPlacement;
+      options.offset = this.offset;
+      options.arrowOffset = this.arrowOffset;
+      this.popperJS = new PopperJS(reference, popper, options);
+      this.popperJS.onCreate(_ => {
+        this.$emit('created', this);
+        this.resetTransformOrigin();
+        this.$nextTick(this.updatePopper);
+      });
+      if (typeof options.onUpdate === 'function') {
+        this.popperJS.onUpdate(options.onUpdate);
+      }
+      this.popperJS._popper.style.zIndex = PopupManager.nextZIndex();
+      this.popperElm.addEventListener('click', stop);
+    },
+
+    updatePopper() {
+      const popperJS = this.popperJS;
+      if (popperJS) {
+        popperJS.update();
+        if (popperJS._popper) {
+          popperJS._popper.style.zIndex = PopupManager.nextZIndex();
+        }
+      } else {
+        this.createPopper();
+      }
+    },
+
+    doDestroy(forceDestroy) {
+      /* istanbul ignore if */
+      if (!this.popperJS || (this.showPopper && !forceDestroy)) return;
+      this.popperJS.destroy();
+      this.popperJS = null;
+    },
+
+    destroyPopper() {
+      if (this.popperJS) {
+        this.resetTransformOrigin();
+      }
+    },
+
+    resetTransformOrigin() {
+      if (!this.transformOrigin) return;
+      let placementMap = {
+        top: 'bottom',
+        bottom: 'top',
+        left: 'right',
+        right: 'left'
+      };
+      let placement = this.popperJS._popper.getAttribute('x-placement').split('-')[0];
+      let origin = placementMap[placement];
+      this.popperJS._popper.style.transformOrigin = typeof this.transformOrigin === 'string'
+        ? this.transformOrigin
+        : ['top', 'bottom'].indexOf(placement) > -1 ? `center ${ origin }` : `${ origin } center`;
+    },
+
+    appendArrow(element) {
+      let hash;
+      if (this.appended) {
+        return;
+      }
+
+      this.appended = true;
+
+      for (let item in element.attributes) {
+        if (/^_v-/.test(element.attributes[item].name)) {
+          hash = element.attributes[item].name;
+          break;
+        }
+      }
+
+      const arrow = document.createElement('div');
+
+      if (hash) {
+        arrow.setAttribute(hash, '');
+      }
+      arrow.setAttribute('x-arrow', '');
+      arrow.className = 'popper__arrow';
+      element.appendChild(arrow);
+    }
+  },
+
+  beforeDestroy() {
+    this.doDestroy(true);
+    if (this.popperElm && this.popperElm.parentNode === document.body) {
+      this.popperElm.removeEventListener('click', stop);
+      document.body.removeChild(this.popperElm);
+    }
+  },
+
+  // call destroy in keep-alive mode
+  deactivated() {
+    this.$options.beforeDestroy[0].call(this);
+  }
+};

package/.postcssrc.js

@@ -1,18 +0,0 @@
-const p2 = require("./p2");
-
-module.exports = ({ file }) => {
-  return {
-    plugins: [
-      p2({
-        unitToConvert: 'px',
-        viewportWidth: 320,
-        viewportHeight: 568, // not now used; TODO: need for different units and math for different properties
-        unitPrecision: 5,
-        viewportUnit: 'vw',
-        fontViewportUnit: 'vw',  // vmin is more suitable.
-        selectorBlackList: [],
-        propList: ['*']
-      }),
-    ],
-  };
-};

package/asy.js

@@ -1,32 +0,0 @@
-async function asyncTaskWithCb(cb) {
-    let err, user, savedTask, notification;
-
-    [ err, user ] = await to(UserModel.findById(1));
-    if(!user) return cb('No user found');
-
-    [ err, savedTask ] = await to(TaskModel({userId: user.id, name: 'Demo Task'}));
-    if(err) return cb('Error occurred while saving task');
-
-   if(user.notificationsEnabled) {
-      [ err ] = await to(NotificationService.sendNotification(user.id, 'Task Created'));
-      if(err) return cb('Error while sending notification');
-   }
-
-   if(savedTask.assignedUser.id !== user.id) {
-      [ err, notification ] = await to(NotificationService.sendNotification(savedTask.assignedUser.id, 'Task was created for you'));
-      if(err) return cb('Error while sending notification');
-   }
-
-   cb(null, savedTask);
-}
-
-function to(promise, errorExt) {
-    return promise
-        .then(function (data) { return [null, data]; }) // 执行成功，返回数组第一项为 null。第二个是结果。
-        .catch(function (err) {
-        if (errorExt) {
-            Object.assign(err, errorExt);
-        }
-        return [err, undefined]; // 执行失败，返回数组第一项为错误信息，第二项为 undefined
-    });
-}

package/catch.js

@@ -1,176 +0,0 @@
-// 可以自动停止的定时器
-function myInterval(callback, interval = 2000) {
-    let timer
-    let isStop = false
-    const stop = () => {
-        console.log('停止')
-        isStop = true
-        clearTimeout(timer)
-    }
-    const start = () => {
-        isStop = false
-        loop()
-    }
-    const loop = async () => {
-        callback()
-        if (isStop) return
-        return (timer = setTimeout(loop, interval))
-    }
-    return {
-        start,
-        stop
-    }
-}
-
-
-function isPromise(ret) {
-    return (ret && typeof ret.then === 'function' && typeof ret.catch === "function")
-}
-const errorHandler = (error, vm, info) => {
-    console.error('抛出全局异常')
-    console.error(vm)
-    console.error(error)
-    console.error(info)
-}
-function registerActionHandle(actions) {
-    Object.keys(actions).forEach(key => {
-        let fn = actions[key]
-        actions[key] = function (...args) {
-            let ret = fn.apply(this, args)
-            if (isPromise(ret)) {
-                return ret.catch(errorHandler)
-            } else { // 默认错误处理
-                return ret
-            }
-        }
-    })
-}
-const registerVuex = (instance) => {
-    if (instance.$options['store']) {
-        let actions = instance.$options['store']['_actions'] || {}
-        if (actions) {
-            let tempActions = {}
-            Object.keys(actions).forEach(key => {
-                tempActions[key] = actions[key][0]
-            })
-            registerActionHandle(tempActions)
-        }
-    }
-}
-const registerVue = (instance) => {
-    if (instance.$options.methods) {
-        let actions = instance.$options.methods || {}
-        if (actions) {
-            registerActionHandle(actions)
-        }
-    }
-}
-
-let VueError = {
-    install: (Vue, options) => {
-        /**
-         * 全局异常处理
-         * @param {
-         * } error 
-         * @param {*} vm 
-         */
-        console.log('VueErrorInstallSuc')
-        Vue.config.errorHandler = errorHandler
-        Vue.mixin({
-            beforeCreate() {
-                registerVue(this)
-                registerVuex(this)
-            }
-        })
-        Vue.prototype.$throw = errorHandler
-    }
-}
-
-export default VueError
-import axios from 'axios'
-import { getToken, setToken, getRefreshToken } from '@utils/auth'
-
-// 刷新 access_token 的接口
-const refreshToken = () => {
-  return instance.post('/auth/refresh', { refresh_token: getRefreshToken() }, true)
-}
-
-// 创建 axios 实例
-const instance = axios.create({
-  baseURL:  process.env.GATSBY_API_URL,
-  timeout: 30000,
-  headers: {
-    'Content-Type': 'application/json',
-  }
-})
-
-let isRefreshing = false // 标记是否正在刷新 token
-let requests = [] // 存储待重发请求的数组
-
-instance.interceptors.response.use(response => {
-    return response
-}, error => {
-    if (!error.response) {
-        return Promise.reject(error)
-    }
-    if (error.response.status === 401 && !error.config.url.includes('/auth/refresh')) {
-        const { config } = error
-        if (!isRefreshing) {
-            isRefreshing = true
-            return refreshToken().then(res=> {
-                const { access_token } = res.data
-                setToken(access_token)
-                config.headers.Authorization = `Bearer ${access_token}`
-                // token 刷新后将数组的方法重新执行
-                requests.forEach((cb) => cb(access_token))
-                requests = [] // 重新请求完清空
-                return instance(config)
-            }).catch(err => {
-                console.log('抱歉，您的登录状态已失效，请重新登录！')
-                return Promise.reject(err)
-            }).finally(() => {
-                isRefreshing = false
-            })
-        } else {
-            // 返回未执行 resolve 的 Promise
-            return new Promise(resolve => {
-                // 用函数形式将 resolve 存入，等待刷新后再执行
-                requests.push(token => {
-                    config.headers.Authorization = `Bearer ${token}`
-                    resolve(instance(config))
-                })  
-            })
-        }
-    }
-    return Promise.reject(error)
-})
-
-// 给请求头添加 access_token
-const setHeaderToken = (isNeedToken) => {
-  const accessToken = isNeedToken ? getToken() : null
-  if (isNeedToken) { // api 请求需要携带 access_token 
-    if (!accessToken) { 
-      console.log('不存在 access_token 则跳转回登录页')
-    }
-    instance.defaults.headers.common.Authorization = `Bearer ${accessToken}`
-  }
-}
-
-// 有些 api 并不需要用户授权使用，则无需携带 access_token；默认不携带，需要传则设置第三个参数为 true
-export const get = (url, params = {}, isNeedToken = false) => {
-  setHeaderToken(isNeedToken)
-  return instance({
-    method: 'get',
-    url,
-    params,
-  })
-}
-
-export const post = (url, params = {}, isNeedToken = false) => {
-  setHeaderToken(isNeedToken)
-  return instance({
-    method: 'post',
-    url,
-    data: params,
-  })
-}