mazey-element-ui 2.0.1 → 2.15.16

package/src/utils/merge.js

@@ -1,15 +1,5 @@
-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;
-        }
-      }
-    }
-  }
+import { assignDefined } from 'mazey';
 
-  return target;
+export default function(target, ...sources) {
+  return assignDefined(target, ...sources.map(source => source || {}));
 };

package/src/utils/popup/index.js

@@ -1,6 +1,6 @@
 import Vue from 'vue';
-import merge from 'element-ui/src/utils/merge';
-import PopupManager from 'element-ui/src/utils/popup/popup-manager';
+import merge from 'mazey-element-ui/src/utils/merge';
+import PopupManager from 'mazey-element-ui/src/utils/popup/popup-manager';
 import getScrollBarWidth from '../scrollbar-width';
 import { getStyle, addClass, removeClass, hasClass } from '../dom';
 
@@ -8,14 +8,6 @@ let idSeed = 1;
 
 let scrollBarWidth;
 
-const getDOM = function(dom) {
-  if (dom.nodeType === 3) {
-    dom = dom.nextElementSibling || dom.nextSibling;
-    getDOM(dom);
-  }
-  return dom;
-};
-
 export default {
   props: {
     visible: {
@@ -124,7 +116,7 @@ export default {
 
       this._opening = true;
 
-      const dom = getDOM(this.$el);
+      const dom = this.$el;
 
       const modal = props.modal;
 

package/src/utils/popup/popup-manager.js

@@ -1,9 +1,9 @@
 import Vue from 'vue';
-import { addClass, removeClass } from 'element-ui/src/utils/dom';
+import { addClass, removeClass } from 'mazey-element-ui/src/utils/dom';
 
 let hasModal = false;
 let hasInitZIndex = false;
-let zIndex = 2000;
+let zIndex;
 
 const getModal = function() {
   if (Vue.prototype.$isServer) return;
@@ -155,7 +155,7 @@ Object.defineProperty(PopupManager, 'zIndex', {
   configurable: true,
   get() {
     if (!hasInitZIndex) {
-      zIndex = (Vue.prototype.$ELEMENT || {}).zIndex || zIndex;
+      zIndex = zIndex || (Vue.prototype.$ELEMENT || {}).zIndex || 2000;
       hasInitZIndex = true;
     }
     return zIndex;

package/src/utils/resize-event.js

@@ -1,4 +1,5 @@
 import ResizeObserver from 'resize-observer-polyfill';
+import { debounce } from 'throttle-debounce';
 
 const isServer = typeof window === 'undefined';
 
@@ -19,7 +20,7 @@ export const addResizeListener = function(element, fn) {
   if (isServer) return;
   if (!element.__resizeListeners__) {
     element.__resizeListeners__ = [];
-    element.__ro__ = new ResizeObserver(resizeHandler);
+    element.__ro__ = new ResizeObserver(debounce(16, resizeHandler));
     element.__ro__.observe(element);
   }
   element.__resizeListeners__.push(fn);

package/src/utils/types.js

@@ -0,0 +1,38 @@
+import Vue from 'vue';
+
+export { isPureObject as isObject } from 'mazey';
+
+export function isString(obj) {
+  return Object.prototype.toString.call(obj) === '[object String]';
+}
+
+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;
+};

package/src/utils/util.js

@@ -1,3 +1,6 @@
+import Vue from 'vue';
+import { isString, isObject } from 'mazey-element-ui/src/utils/types';
+
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 export function noop() {};
@@ -82,3 +85,161 @@ export const valueEquals = (a, b) => {
   }
   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/utils/vdom.js

@@ -1,9 +1,5 @@
-import { hasOwn } from 'element-ui/src/utils/util';
+import { hasOwn } from 'mazey-element-ui/src/utils/util';
 
 export function isVNode(node) {
   return node !== null && typeof node === 'object' && hasOwn(node, 'componentOptions');
 };
-
-export function getFirstComponentChild(children) {
-  return children && children.filter(c => c && c.tag)[0];
-};

package/src/utils/vue-popper.js

@@ -1,7 +1,7 @@
 import Vue from 'vue';
 import {
   PopupManager
-} from 'element-ui/src/utils/popup';
+} from 'mazey-element-ui/src/utils/popup';
 
 const PopperJS = Vue.prototype.$isServer ? function() {} : require('./popper');
 const stop = e => e.stopPropagation();
@@ -70,6 +70,7 @@ export default {
     },
 
     showPopper(val) {
+      if (this.disabled) return;
       val ? this.updatePopper() : this.destroyPopper();
       this.$emit('input', val);
     }

package/types/alert.d.ts

@@ -1,6 +1,7 @@
 import { ElementUIComponent } from './component'
 
 export type AlertType = 'success' | 'warning' | 'info' | 'error'
+export type AlertEffect = 'dark' | 'light'
 
 /** Alert Component */
 export declare class ElAlert extends ElementUIComponent {
@@ -24,4 +25,7 @@ export declare class ElAlert extends ElementUIComponent {
 
   /** If a type icon is displayed */
   showIcon: boolean
+
+  /** Choose effect */
+  effect: AlertEffect
 }

package/types/autocomplete.d.ts

@@ -26,6 +26,9 @@ export declare class ElAutocomplete extends ElementUIComponent {
   /** The placeholder of Autocomplete */
   placeholder: string
 
+  /** Whether to show clear button */
+  clearable: boolean
+
   /** Whether Autocomplete is disabled */
   disabled: boolean
 
@@ -56,9 +59,6 @@ export declare class ElAutocomplete extends ElementUIComponent {
   /** Whether show suggestions when input focus */
   triggerOnFocus: boolean
 
-  /** Whether to emit a `select` event on enter when there is no autocomplete match */
-  selectWhenUnmatched: boolean
-
   /** Prefix icon class */
   prefixIcon: string
 
@@ -68,6 +68,9 @@ export declare class ElAutocomplete extends ElementUIComponent {
   /** Whether to hide the loading icon in remote search */
   hideLoading: boolean
 
+  /** Whether to append the dropdown to body */
+  popperAppendToBody: boolean
+
   /**
    * Focus the Input component
    */

package/types/avatar.d.ts

@@ -0,0 +1,20 @@
+import { ElementUIComponent } from './component'
+
+/** Avatar Component */
+export declare class ElAvatar extends ElementUIComponent {
+  icon: string;
+
+  size: string | number;
+
+  shape: string;
+
+  src: string;
+
+  error: () => false;
+
+  srcSet: string;
+
+  alt: string;
+
+  fit: string;
+}

package/types/backtop.d.ts

@@ -0,0 +1,16 @@
+import { ElementUIComponent } from './component'
+
+/** Backtop Component */
+export declare class ElBacktop extends ElementUIComponent {
+  /** Backtop target */
+  target: string
+  
+  /** Backtop visibility height */
+  visibilityHeight: string | number
+
+  /** Backtop right position */
+  right: string | number
+
+  /** Backtop bottom position */
+  bottom: string | number
+}

package/types/calendar.d.ts

@@ -0,0 +1,15 @@
+import { ElementUIComponent } from './component'
+
+export type DateType = Date | String | Number
+
+/** Calendar Component */
+export declare class ElCalendar extends ElementUIComponent {
+  /** Binding value */
+  value: DateType
+
+  /** Specify the display range of the calendar */
+  range: DateType[]
+
+  /** First day of week */
+  firstDayOfWeek: number
+}

package/types/carousel.d.ts

@@ -4,6 +4,7 @@ export type CarouselIndicatorTrigger = 'hover' | 'click'
 export type CarouselIndicatorPosition = 'outside' | 'none'
 export type CarouselArrowVisibility = 'always' | 'hover' | 'never'
 export type CarouselType = 'card'
+export type CarouselDirection = 'horizontal' | 'vertical'
 
 /** Loop a series of images or texts in a limited space */
 export declare class ElCarousel extends ElementUIComponent {
@@ -31,6 +32,9 @@ export declare class ElCarousel extends ElementUIComponent {
   /** Type of the Carousel */
   type: CarouselType
 
+  /** Display direction */
+  direction: CarouselDirection
+
   /**
    * Manually switch slide by index
    *

package/types/cascader-panel.d.ts

@@ -0,0 +1,72 @@
+import { VNode, CreateElement } from 'vue';
+import { ElementUIComponent } from './component'
+
+/** Trigger mode of expanding current item */
+export type ExpandTrigger = 'click' | 'hover'
+
+/** Cascader Option */
+export interface CascaderOption {
+  label: string,
+  value: any,
+  children?: CascaderOption[],
+  disabled?: boolean,
+  leaf?: boolean
+}
+
+/** Cascader Props */
+export interface CascaderProps<V, D> {
+  expandTrigger?: ExpandTrigger,
+  multiple?: boolean,
+  checkStrictly?: boolean,
+  emitPath?: boolean,
+  lazy?: boolean,
+  lazyLoad?: (node: CascaderNode<V, D>, resolve: Resolve<D>) => void,
+  value?: string,
+  label?: string,
+  children?: string,
+  disabled?: string
+  leaf?: string
+}
+
+/** Cascader Node */
+export interface CascaderNode<V, D> {
+  uid: number,
+  data: D,
+  value: V,
+  label: string,
+  level: number,
+  isDisabled: boolean,
+  isLeaf: boolean,
+  parent: CascaderNode<V, D> | null,
+  children: CascaderNode<V, D>[]
+  config: CascaderProps<V, D>
+}
+
+type Resolve<D> = (dataList?: D[]) => void
+
+export interface CascaderPanelSlots {
+  /** Custom label content */
+  default: VNode[]
+
+  [key: string]: VNode[]
+}
+
+/** CascaderPanel Component */
+export declare class ElCascaderPanel<V = any, D = CascaderOption> extends ElementUIComponent {
+  /** Selected value */
+  value: V | V[]
+
+  /** Data of the options */
+  options: D[]
+
+  /** Configuration options */
+  props: CascaderProps<V, D>
+
+  /** Whether to add border */
+  border: boolean
+
+  /** Render function of custom label content */
+  renderLabel: (h: CreateElement, context: { node: CascaderNode<V, D>; data: D }) => VNode
+
+  $slots: CascaderPanelSlots
+}

package/types/cascader.d.ts

@@ -1,29 +1,32 @@
+import { VNode } from 'vue';
 import { ElementUIComponent, ElementUIComponentSize } from './component'
+import { CascaderOption, CascaderProps, CascaderNode } from './cascader-panel';
 
-/** Trigger mode of expanding current item */
-export type ExpandTrigger = 'click' | 'hover'
+export { CascaderOption, CascaderProps, CascaderNode };
 
-/** Cascader Option */
-export interface CascaderOption {
-  label: string,
-  value: any,
-  children: CascaderOption[],
-  disabled: boolean
+export interface CascaderSlots {
+  /** Custom label content */
+  default: VNode[],
+
+  /** Empty content when no option matches */
+  empty: VNode[]
+
+  [key: string]: VNode[]
 }
 
 /** Cascader Component */
-export declare class ElCascader extends ElementUIComponent {
+export declare class ElCascader<V = any, D = CascaderOption> extends ElementUIComponent {
   /** Data of the options */
   options: CascaderOption[]
 
   /** Configuration options */
-  props: object
+  props: CascaderProps<V, D>
 
   /** Selected value */
-  value: any[]
+  value: V | V[]
 
-  /** Custom class name for Cascader's dropdown */
-  popperClass: string
+  /** Size of Input */
+  size: ElementUIComponentSize
 
   /** Input placeholder */
   placeholder: string
@@ -34,24 +37,29 @@ export declare class ElCascader extends ElementUIComponent {
   /** Whether selected value can be cleared */
   clearable: boolean
 
-  /** Trigger mode of expanding current item */
-  expandTrigger: ExpandTrigger
-
   /** Whether to display all levels of the selected value in the input */
   showAllLevels: boolean
 
+  /** Whether to collapse selected tags in multiple selection mode */
+  collapseTags: boolean
+
+  /** Separator of option labels */
+  separator: string
+
   /** Whether the options can be searched */
   filterable: boolean
 
+  /** filter method to match options according to input keyword */
+  filterMethod: (node: CascaderNode<V, D>, keyword: string) => boolean
+
   /** Debounce delay when typing filter keyword, in millisecond */
   debounce: number
 
-  /** Whether selecting an option of any level is permitted */
-  changeOnSelect: boolean
-
-  /** Size of Input */
-  size: ElementUIComponentSize
+  /** Custom class name for Cascader's dropdown */
+  popperClass: string
 
   /** Hook function before filtering with the value to be filtered as its parameter */
   beforeFilter: (value: string) => boolean | Promise<any>
+
+  $slots: CascaderSlots
 }

package/types/collapse-item.d.ts

@@ -20,4 +20,7 @@ export declare class ElCollapseItem extends ElementUIComponent {
   title: string
 
   $slots: CollapseItemSlots
+
+  /** Disable the collapse item */
+  disabled: boolean
 }

package/types/descriptions-item.d.ts

@@ -0,0 +1,37 @@
+import { ElementUIComponent } from './component'
+import { VNode } from 'vue'
+
+interface ElDescriptionsItemSlots {
+  /* label slot: custom label */
+  label: VNode[]
+
+  /* default slot: custom content */
+  default: VNode[]
+
+  [key: string]: VNode[]
+}
+
+/** description item. **/
+export declare class ElDescriptionsItem extends ElementUIComponent {
+
+  /* label text */
+  label: string
+
+  /*  the number of columns included */
+  span: number 
+
+  /* custom label class name */
+  labelClassName: string
+
+  /* custom content class name */
+  contentClassName: string
+
+  /* custom label style */
+  labelStyle: object
+
+  /* custom content style */
+  contentStyle: object
+
+  $slots: ElDescriptionsItemSlots
+
+}