@zkwq/business 0.0.1

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

@@ -0,0 +1,262 @@
+import Vue from 'vue'
+
+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) => {
+  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, '\\$&')
+
+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
+}
+
+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 isString = (obj) => {
+  return Object.prototype.toString.call(obj) === '[object String]'
+}
+
+export const isObject = (obj) => {
+  return Object.prototype.toString.call(obj) === '[object Object]'
+}
+
+export const isHtmlElement = (node) => {
+  return node && node.nodeType === Node.ELEMENT_NODE
+}
+
+export const isFunction = (functionToCheck) => {
+  var getType = {}
+  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]'
+}
+
+export const isUndefined = (val)=> {
+  return val === void 0
+}
+
+export const isDefined = (val) => {
+  return val !== undefined && val !== null
+}

package/src/components/base/ui/util/menu/aria-menubar.js

@@ -0,0 +1,14 @@
+import MenuItem from './aria-menuitem';
+
+const Menu = function(domNode) {
+  this.domNode = domNode;
+  this.init();
+};
+
+Menu.prototype.init = function() {
+  let menuChildren = this.domNode.childNodes;
+  [].filter.call(menuChildren, child => child.nodeType === 1).forEach(child => {
+    new MenuItem(child); // eslint-disable-line
+  });
+};
+export default Menu;

package/src/components/base/ui/util/menu/aria-menuitem.js

@@ -0,0 +1,49 @@
+import Utils from '../aria-utils';
+import SubMenu from './aria-submenu';
+
+const MenuItem = function(domNode) {
+  this.domNode = domNode;
+  this.submenu = null;
+  this.init();
+};
+
+MenuItem.prototype.init = function() {
+  this.domNode.setAttribute('tabindex', '0');
+  let menuChild = this.domNode.querySelector('.el-menu');
+  if (menuChild) {
+    this.submenu = new SubMenu(this, menuChild);
+  }
+  this.addListeners();
+};
+
+MenuItem.prototype.addListeners = function() {
+  const keys = Utils.keys;
+  this.domNode.addEventListener('keydown', event => {
+    let prevDef = false;
+    switch (event.keyCode) {
+      case keys.down:
+        Utils.triggerEvent(event.currentTarget, 'mouseenter');
+        this.submenu && this.submenu.gotoSubIndex(0);
+        prevDef = true;
+        break;
+      case keys.up:
+        Utils.triggerEvent(event.currentTarget, 'mouseenter');
+        this.submenu && this.submenu.gotoSubIndex(this.submenu.subMenuItems.length - 1);
+        prevDef = true;
+        break;
+      case keys.tab:
+        Utils.triggerEvent(event.currentTarget, 'mouseleave');
+        break;
+      case keys.enter:
+      case keys.space:
+        prevDef = true;
+        event.currentTarget.click();
+        break;
+    }
+    if (prevDef) {
+      event.preventDefault();
+    }
+  });
+};
+
+export default MenuItem;

package/src/components/base/ui/util/menu/aria-submenu.js

@@ -0,0 +1,59 @@
+import Utils from '../aria-utils';
+
+const SubMenu = function(parent, domNode) {
+  this.domNode = domNode;
+  this.parent = parent;
+  this.subMenuItems = [];
+  this.subIndex = 0;
+  this.init();
+};
+
+SubMenu.prototype.init = function() {
+  this.subMenuItems = this.domNode.querySelectorAll('li');
+  this.addListeners();
+};
+
+SubMenu.prototype.gotoSubIndex = function(idx) {
+  if (idx === this.subMenuItems.length) {
+    idx = 0;
+  } else if (idx < 0) {
+    idx = this.subMenuItems.length - 1;
+  }
+  this.subMenuItems[idx].focus();
+  this.subIndex = idx;
+};
+
+SubMenu.prototype.addListeners = function() {
+  const keys = Utils.keys;
+  const parentNode = this.parent.domNode;
+  Array.prototype.forEach.call(this.subMenuItems, el => {
+    el.addEventListener('keydown', event => {
+      let prevDef = false;
+      switch (event.keyCode) {
+        case keys.down:
+          this.gotoSubIndex(this.subIndex + 1);
+          prevDef = true;
+          break;
+        case keys.up:
+          this.gotoSubIndex(this.subIndex - 1);
+          prevDef = true;
+          break;
+        case keys.tab:
+          Utils.triggerEvent(parentNode, 'mouseleave');
+          break;
+        case keys.enter:
+        case keys.space:
+          prevDef = true;
+          event.currentTarget.click();
+          break;
+      }
+      if (prevDef) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return false;
+    });
+  });
+};
+
+export default SubMenu;

package/src/components/base/ui/util/merge.js

@@ -0,0 +1,14 @@
+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
+}