@qsxy/element-plus-react 1.0.2 → 2.0.0

package/dist/TreeSelect/useTree.js

@@ -0,0 +1,285 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import isEqual from 'lodash/isEqual';
+import isNil from 'lodash/isNil';
+import pick from 'lodash/pick';
+import React, { useCallback, useEffect, useMemo, useRef } from 'react';
+import { treeAllProps } from "../hooks/treePropsUtils";
+import { escapeStringRegexp, isEmpty, isFunction, nextTick } from "../Util";
+import TreeSelectOption from "./TreeSelectOption";
+import { isValidArray, isValidValue, toValidArray, treeEach, treeFind } from "./Utils"; // 假设工具函数已存在
+
+var useTree = function useTree(props, _ref) {
+  var selectRef = _ref.selectRef,
+    treeRef = _ref.treeRef,
+    key = _ref.key,
+    value = _ref.value,
+    setValue = _ref.setValue;
+  var isEffect = useRef(true);
+
+  // 监听 value 变化并同步树的选中状态
+  useEffect(function () {
+    if (props.showCheckbox && treeRef.current) {
+      var treeInstance = treeRef.current;
+      var currentKeys = treeInstance.getCheckedKeys();
+      if (!isEqual(currentKeys, toValidArray(value))) {
+        treeInstance.setCheckedKeys(toValidArray(value));
+      }
+    }
+  }, [value]);
+
+  // 计算 propsMap
+  var propsMap = useMemo(function () {
+    return _objectSpread({
+      value: key,
+      label: 'label',
+      children: 'children',
+      disabled: 'disabled',
+      isLeaf: 'isLeaf'
+    }, props.props);
+  }, [key, props.props]);
+
+  // 获取节点属性值
+  var getNodeValByProp = useCallback(function (prop, data) {
+    var propVal = propsMap[prop];
+    if (isFunction(propVal)) {
+      var _treeRef$current;
+      // @ts-ignore
+      return propVal(data, (_treeRef$current = treeRef.current) === null || _treeRef$current === void 0 ? void 0 : _treeRef$current.getNode(getNodeValByProp('value', data)));
+    }
+    return data[propVal];
+  }, [propsMap, treeRef]);
+
+  // 默认展开父节点的 Key
+  var defaultExpandedParentKeys = useMemo(function () {
+    return toValidArray(value).map(function (val) {
+      return treeFind(props.data || [], function (data) {
+        return getNodeValByProp('value', data) === val;
+      }, function (data) {
+        return getNodeValByProp('children', data);
+      }, function (data, index, array, parent) {
+        return parent && getNodeValByProp('value', parent);
+      });
+    }).filter(isValidValue);
+  }, [value, props.data, getNodeValByProp]);
+
+  // 缓存选项
+  var cacheOptions = useMemo(function () {
+    // if (!props.renderAfterExpand && !props.lazy) {
+    //     return [];
+    // }
+
+    var options = [];
+    treeEach([].concat(_toConsumableArray(props.data || []), _toConsumableArray(props.cacheData || [])), function (node) {
+      var val = getNodeValByProp('value', node);
+      options.push({
+        value: val,
+        currentLabel: getNodeValByProp('label', node),
+        label: getNodeValByProp('label', node),
+        isDisabled: getNodeValByProp('disabled', node)
+      });
+    }, function (data) {
+      return getNodeValByProp('children', data);
+    });
+    return options;
+  }, [props.data, props.cacheData, getNodeValByProp]);
+  useEffect(function () {
+    if (isEffect.current) {
+      if (!props.multiple) {
+        var optionData = cacheOptions.find(function (item) {
+          return item.value === value;
+        });
+        if (optionData) {
+          if (treeRef.current.getNode(value)) {
+            var _treeRef$current2;
+            (_treeRef$current2 = treeRef.current) === null || _treeRef$current2 === void 0 || _treeRef$current2.setCurrentNode(treeRef.current.getNode(value));
+          }
+        }
+      }
+    } else {
+      isEffect.current = true;
+    }
+  }, [value]);
+
+  // 获取子节点选中的 Key
+  var getChildCheckedKeys = useCallback(function () {
+    var _treeRef$current3;
+    return (_treeRef$current3 = treeRef.current) === null || _treeRef$current3 === void 0 ? void 0 : _treeRef$current3.getCheckedKeys().filter(function (item) {
+      var _treeRef$current4;
+      var node = (_treeRef$current4 = treeRef.current) === null || _treeRef$current4 === void 0 ? void 0 : _treeRef$current4.getNode(item);
+      return !isNil(node) && isEmpty(node.childNodes);
+    });
+  }, [treeRef]);
+  var expandOnClickNode = useMemo(function () {
+    return !props.checkStrictly && props.expandOnClickNode;
+  }, [props.checkStrictly, props.expandOnClickNode]);
+  var defaultExpandedKeys = useMemo(function () {
+    return props.defaultExpandedKeys ? [].concat(_toConsumableArray(props.defaultExpandedKeys), _toConsumableArray(defaultExpandedParentKeys)) : defaultExpandedParentKeys;
+  }, [props.defaultExpandedKeys, defaultExpandedParentKeys]);
+
+  // 渲染内容
+  var renderContent = useCallback(function (_ref2) {
+    var node = _ref2.node,
+      data = _ref2.data,
+      store = _ref2.store;
+    return /*#__PURE__*/React.createElement(TreeSelectOption, {
+      value: getNodeValByProp('value', data),
+      label: getNodeValByProp('label', data),
+      disabled: getNodeValByProp('disabled', data),
+      visible: node.visible
+    }, props.renderContent ? props.renderContent({
+      node: node,
+      data: data,
+      store: store
+    }) : props.children);
+  }, [getNodeValByProp, props]);
+
+  // 过滤节点方法
+  var filterNodeMethod = useCallback(function (val, data, node) {
+    if (props.filterNodeMethod) {
+      return props.filterNodeMethod(val, data, node);
+    }
+    if (!val) {
+      return true;
+    }
+    var regexp = new RegExp(escapeStringRegexp(val), 'i');
+    return regexp.test(getNodeValByProp('label', data) || '');
+  }, [props, getNodeValByProp]);
+
+  // 节点点击事件
+  var onNodeClick = useCallback(function (data, node, treeNodeRef, e) {
+    var _props$onNodeClick;
+    (_props$onNodeClick = props.onNodeClick) === null || _props$onNodeClick === void 0 || _props$onNodeClick.call(props, data, node, treeNodeRef, e);
+    if (props.showCheckbox && props.checkOnClickNode) {
+      return;
+    }
+    if (!props.showCheckbox && (props.checkStrictly || node.isLeaf)) {
+      if (!getNodeValByProp('disabled', data)) {
+        var _selectRef$current;
+        var val = (_selectRef$current = selectRef.current) === null || _selectRef$current === void 0 ? void 0 : _selectRef$current.onChoose(getNodeValByProp('value', data), data, e);
+        isEffect.current = false;
+        setValue(val);
+      }
+    } else if (props.expandOnClickNode) {
+      // treeNodeRef.current.handleExpandIconClick();
+    }
+  }, [props, getNodeValByProp, selectRef, setValue]);
+
+  // 节点勾选事件
+  var onCheck = useCallback(function (data, params) {
+    var _treeRef$current5;
+    if (!props.showCheckbox) {
+      return;
+    }
+    var controlledValue = null;
+    var dataValue = getNodeValByProp('value', data);
+    var dataMap = {};
+    treeEach([(_treeRef$current5 = treeRef.current) === null || _treeRef$current5 === void 0 ? void 0 : _treeRef$current5.store.root], function (node) {
+      return dataMap[node.key] = node;
+    }, function (node) {
+      return node.childNodes;
+    });
+    var uncachedCheckedKeys = params.checkedKeys;
+    var cachedKeys = props.multiple ? toValidArray(value).filter(function (item) {
+      return !(item in dataMap) && !uncachedCheckedKeys.includes(item);
+    }) : [];
+    var newCheckedKeys = cachedKeys.concat(uncachedCheckedKeys);
+    if (props.checkStrictly) {
+      var _selectRef$current2;
+      var res = null;
+      if (props.multiple) {
+        res = newCheckedKeys;
+      } else {
+        res = newCheckedKeys.includes(dataValue) ? dataValue : undefined;
+      }
+      isEffect.current = false;
+      var val = (_selectRef$current2 = selectRef.current) === null || _selectRef$current2 === void 0 ? void 0 : _selectRef$current2.onChoose(dataValue, cacheOptions.find(function (cache) {
+        return cache.value === dataValue;
+      }));
+      controlledValue = val;
+    } else {
+      if (props.multiple) {
+        var _selectRef$current3;
+        // const childKeys = getChildCheckedKeys();
+        isEffect.current = false;
+        var _val = (_selectRef$current3 = selectRef.current) === null || _selectRef$current3 === void 0 ? void 0 : _selectRef$current3.onChoose(dataValue, cacheOptions.find(function (cache) {
+          return cache.value === dataValue;
+        }));
+        controlledValue = _val;
+      } else {
+        var _selectRef$current4;
+        var firstLeaf = treeFind([data], function (item) {
+          return !isValidArray(getNodeValByProp('children', item)) && !getNodeValByProp('disabled', item);
+        }, function (item) {
+          return getNodeValByProp('children', item);
+        });
+        var firstLeafKey = firstLeaf ? getNodeValByProp('value', firstLeaf) : undefined;
+        var hasCheckedChild = isValidValue(value) && !!treeFind([data], function (item) {
+          return getNodeValByProp('value', item) === value;
+        }, function (item) {
+          return getNodeValByProp('children', item);
+        });
+        (_selectRef$current4 = selectRef.current) === null || _selectRef$current4 === void 0 || _selectRef$current4.onChoose(firstLeafKey === value || hasCheckedChild ? undefined : firstLeafKey, firstLeaf);
+        controlledValue = firstLeafKey === value || hasCheckedChild ? undefined : firstLeafKey;
+      }
+    }
+    setValue(controlledValue);
+    nextTick(function () {
+      var _props$onCheck;
+      var _checkedKeys = toValidArray(controlledValue);
+      treeRef.current.setCheckedKeys(_checkedKeys);
+      (_props$onCheck = props.onCheck) === null || _props$onCheck === void 0 || _props$onCheck.call(props, data, {
+        checkedKeys: treeRef.current.getCheckedKeys(),
+        checkedNodes: treeRef.current.getCheckedNodes(),
+        halfCheckedKeys: treeRef.current.getHalfCheckedKeys(),
+        halfCheckedNodes: treeRef.current.getHalfCheckedNodes()
+      });
+    });
+    // selectRef.current?.focus();
+  }, [props, getNodeValByProp, treeRef, value, setValue, selectRef, cacheOptions]);
+
+  // 节点展开事件
+  var onNodeExpand = useCallback(function (data, node, treeNodeRef) {
+    var _props$onNodeExpand;
+    (_props$onNodeExpand = props.onNodeExpand) === null || _props$onNodeExpand === void 0 || _props$onNodeExpand.call(props, data, node, treeNodeRef);
+    nextTick(function () {
+      if (!props.checkStrictly && props.lazy && props.multiple && node.checked) {
+        var _treeRef$current6, _treeRef$current7, _props$onChange;
+        var dataMap = {};
+        var uncachedCheckedKeys = (_treeRef$current6 = treeRef.current) === null || _treeRef$current6 === void 0 ? void 0 : _treeRef$current6.getCheckedKeys();
+        treeEach([(_treeRef$current7 = treeRef.current) === null || _treeRef$current7 === void 0 ? void 0 : _treeRef$current7.store.root], function (item) {
+          return dataMap[item.key] = item;
+        }, function (item) {
+          return item.childNodes;
+        });
+        var cachedKeys = toValidArray(value).filter(function (item) {
+          return !(item in dataMap) && !uncachedCheckedKeys.includes(item);
+        });
+        var childKeys = getChildCheckedKeys();
+        (_props$onChange = props.onChange) === null || _props$onChange === void 0 || _props$onChange.call(props, cachedKeys.concat(childKeys));
+      }
+    });
+  }, [props, treeRef, value, getChildCheckedKeys]);
+  return _objectSpread(_objectSpread({}, pick(props, treeAllProps)), {}, {
+    nodeKey: key,
+    expandOnClickNode: expandOnClickNode,
+    defaultExpandedKeys: defaultExpandedKeys,
+    renderContent: renderContent,
+    filterNodeMethod: filterNodeMethod,
+    onNodeClick: onNodeClick,
+    onCheck: onCheck,
+    onNodeExpand: onNodeExpand,
+    cacheOptions: cacheOptions
+  });
+};
+export default useTree;

package/dist/Upload/UploadContent.js

@@ -32,6 +32,7 @@ var UploadContent = /*#__PURE__*/forwardRef(function (props, ref) {
     data = props.data,
     method = props.method,
     withCredentials = props.withCredentials,
+    errorStatus = props.errorStatus,
     filename = props.name,
     action = props.action,
     _onProgress = props.onProgress,
@@ -56,6 +57,7 @@ var UploadContent = /*#__PURE__*/forwardRef(function (props, ref) {
     var options = {
       headers: headers || {},
       withCredentials: withCredentials,
+      errorStatus: errorStatus,
       file: rawFile,
       data: data,
       method: method,
@@ -99,7 +101,7 @@ var UploadContent = /*#__PURE__*/forwardRef(function (props, ref) {
         _request.then(options.onSuccess, options.onError);
       }
     }
-  }, [action, data, filename, headers, httpRequest, method, _onError, _onProgress, _onSuccess, withCredentials]);
+  }, [action, data, errorStatus, filename, headers, httpRequest, method, _onError, _onProgress, _onSuccess, withCredentials]);
   var upload = useCallback( /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(rawFile) {
       var hookResult, file;

package/dist/Upload/ajax.js

@@ -59,6 +59,9 @@ export var ajaxUpload = function ajaxUpload(option) {
     option.onError(getError(action, option, xhr));
   });
   xhr.addEventListener('load', function () {
+    if (option.errorStatus && option.errorStatus(xhr)) {
+      return option.onError(getError(action, option, xhr));
+    }
     if (xhr.status < 200 || xhr.status >= 300) {
       return option.onError(getError(action, option, xhr));
     }

package/dist/Upload/typings.d.ts

@@ -17,6 +17,8 @@ export interface UploadBaseProps {
     drag?: boolean;
     /** 支持发送 cookie 凭证信息 */
     withCredentials?: boolean;
+    /** 自定义上传请求的错误判断 */
+    errorStatus?: (xhr: XMLHttpRequest) => boolean;
     /** 是否显示已上传文件列表 */
     showFileList?: boolean;
     /** 接受上传的文件类型 */
@@ -81,7 +83,7 @@ export interface UploadRef {
     /** 手动移除文件。 file 和rawFile 已被合并。 rawFile 将在 v2.2.0 中移除 */
     handleRemove: (file: UploadFile | UploadRawFile) => void;
 }
-export interface UploadProps extends UploadBaseProps, UploadHooks, BaseProps, NativeProps {
+export interface UploadProps extends UploadBaseProps, UploadHooks, BaseProps, NativeProps<'--el-upload-dragger-padding-horizontal' | '--el-upload-dragger-padding-vertical'> {
     /** 缩略图模板的内容 */
     formatter?: (file: UploadFile) => React.ReactElement;
     /** 触发文件选择框的内容 */
@@ -113,6 +115,8 @@ export interface UploadRequestOptions {
     onError: (evt: UploadAjaxError) => void;
     onProgress: (evt: UploadProgressEvent) => void;
     onSuccess: (response: any) => void;
+    /** 自定义上传请求的错误判断 */
+    errorStatus?: (xhr: XMLHttpRequest) => boolean;
     withCredentials: boolean;
 }
 export interface UploadProgressEvent extends ProgressEvent {

package/dist/Util/PopupManager.js

@@ -1,5 +1,5 @@
 var PopupManager = {
-  zIndex: 1000000000,
+  zIndex: 10000,
   nextZIndex: function nextZIndex() {
     return ++PopupManager.zIndex;
   }

package/dist/Util/aria.d.ts

@@ -21,5 +21,5 @@ export declare const isLeaf: (el: HTMLElement) => boolean;
 export declare const getSibling: (el: HTMLElement, distance: number, elClass: string) => Element;
 export declare const focusElement: (el?: HTMLElement | {
     focus: () => void;
-} | null, options?: FocusOptions) => void;
+} | null, options?: any) => void;
 export declare const focusNode: (el: HTMLElement) => void;

package/dist/Util/aria.js

@@ -6,8 +6,8 @@ var isHTMLElement = function isHTMLElement(e) {
   return e instanceof Element;
 };
 
-/**
- * Determine if the testing element is visible on screen no matter if its on the viewport or not
+/**
+ * Determine if the testing element is visible on screen no matter if its on the viewport or not
  */
 export var isVisible = function isVisible(element) {
   if (process.env.NODE_ENV === 'test') {
@@ -24,10 +24,10 @@ export var obtainAllFocusableElements = function obtainAllFocusableElements(elem
   });
 };
 
-/**
- * @desc Determine if target element is focusable
- * @param element {HTMLElement}
- * @returns {Boolean} true if it is focusable
+/**
+ * @desc Determine if target element is focusable
+ * @param element {HTMLElement}
+ * @returns {Boolean} true if it is focusable
  */
 export var isFocusable = function isFocusable(element) {
   if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute('tabIndex') !== null) {
@@ -59,12 +59,12 @@ export var isFocusable = function isFocusable(element) {
   }
 };
 
-/**
- * Trigger an event
- * mouseenter, mouseleave, mouseover, keyup, change, click, etc.
- * @param  {HTMLElement} elm
- * @param  {String} name
- * @param  {*} opts
+/**
+ * Trigger an event
+ * mouseenter, mouseleave, mouseover, keyup, change, click, etc.
+ * @param  {HTMLElement} elm
+ * @param  {String} name
+ * @param  {*} opts
  */
 export var triggerEvent = function triggerEvent(elm, name) {
   var eventName;

package/dist/Util/base.d.ts

@@ -31,11 +31,41 @@ export declare const download: (url: string, params: {
     method?: 'post' | 'get';
     target?: string;
 }) => void;
-export declare const isObject: (val: any) => boolean;
-export declare const isUndefined: (val: any) => val is undefined;
-export declare const isBoolean: (val: any) => val is boolean;
-export declare const isNumber: (val: any) => val is number;
-export declare const isString: (val: any) => boolean;
-export declare const isStringNumber: (val: string) => boolean;
+/**
+ * @description 判断值是否为对象类型
+ */
+export declare function isObject(val: unknown): val is Record<any, any>;
+/**
+ * @description 判断值是否为undefined类型
+ */
+export declare function isUndefined(val: unknown): val is undefined;
+/**
+ * @description 判断值是否为布尔类型
+ */
+export declare function isBoolean(val: unknown): val is boolean;
+/**
+ * @description 判断值是否为数字类型
+ */
+export declare function isNumber(val: unknown): val is number;
+/**
+ * @description 判断值是否为字符串类型
+ */
+export declare function isString(val: unknown): val is string;
+/**
+ * @description 判断值是否为函数类型
+ */
+export declare function isFunction(val: unknown): val is Function;
+/**
+ * @description 判断值是否为字符串或数字类型
+ */
+export declare function isPropAbsent(prop: unknown): prop is null | undefined;
+/**
+ * @description 判断值是否为字符串类型
+ */
+export declare function isStringNumber(val: string): boolean;
+export declare function isPromise<T = any>(val: unknown): val is Promise<T>;
 export declare function addUnit(value?: string | number, defaultUnit?: string): string;
 export declare function mergeDefaultProps<T>(defaultProps: Partial<T>, target: T): T;
+export declare let isUsingMicroTask: boolean;
+export declare function nextTick(cb?: Function, ctx?: Object): Promise<unknown>;
+export declare const escapeStringRegexp: (string?: string) => string;

package/dist/Util/base.js

@@ -5,6 +5,8 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 import is_empty from 'lodash/isEmpty';
+import isNil from 'lodash/isNil';
+import noop from 'lodash/noop';
 
 /**
  * 判断对象是否为空
@@ -115,27 +117,61 @@ export var download = function download(url, params) {
   $tempForm.submit();
   document.body.removeChild($tempForm);
 };
-export var isObject = function isObject(val) {
+
+/**
+ * @description 判断值是否为对象类型
+ */
+export function isObject(val) {
   return val !== null && _typeof(val) === 'object';
-};
-export var isUndefined = function isUndefined(val) {
+}
+/**
+ * @description 判断值是否为undefined类型
+ */
+export function isUndefined(val) {
   return val === undefined;
-};
-export var isBoolean = function isBoolean(val) {
+}
+/**
+ * @description 判断值是否为布尔类型
+ */
+export function isBoolean(val) {
   return typeof val === 'boolean';
-};
-export var isNumber = function isNumber(val) {
+}
+/**
+ * @description 判断值是否为数字类型
+ */
+export function isNumber(val) {
   return typeof val === 'number';
-};
-export var isString = function isString(val) {
+}
+/**
+ * @description 判断值是否为字符串类型
+ */
+export function isString(val) {
   return typeof val === 'string';
-};
-export var isStringNumber = function isStringNumber(val) {
+}
+/**
+ * @description 判断值是否为函数类型
+ */
+export function isFunction(val) {
+  return typeof val === 'function';
+}
+/**
+ * @description 判断值是否为字符串或数字类型
+ */
+export function isPropAbsent(prop) {
+  return isNil(prop);
+}
+/**
+ * @description 判断值是否为字符串类型
+ */
+export function isStringNumber(val) {
   if (!isString(val)) {
     return false;
   }
   return !Number.isNaN(Number(val));
-};
+}
+export function isPromise(val) {
+  return !isNil(val) && isFunction(val.then) && isFunction(val.catch);
+}
 export function addUnit(value) {
   var defaultUnit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'px';
   if (!value) {
@@ -165,4 +201,135 @@ export function mergeDefaultProps() {
     }
   }
   return props;
-}
+}
+var isIOS = /iPhone|iPad|iPod/i.test(navigator.userAgent);
+function isNative(Ctor) {
+  return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+//  上面三行与核心代码关系不大，了解即可
+//  noop 表示一个无操作空函数，用作函数默认值，防止传入 undefined 导致报错
+//  handleError 错误处理函数
+//  isIE, isIOS, isNative 环境判断函数，
+//  isNative 判断某个属性或方法是否原生支持，如果不支持或通过第三方实现支持都会返回 false
+
+export var isUsingMicroTask = false; // 标记 nextTick 最终是否以微任务执行
+
+var callbacks = []; // 存放调用 nextTick 时传入的回调函数
+var pending = false; // 标记是否已经向任务队列中添加了一个任务，如果已经添加了就不能再添加了
+// 当向任务队列中添加了任务时，将 pending 置为 true，当任务被执行时将 pending 置为 false
+//
+
+// 声明 nextTick 函数，接收一个回调函数和一个执行上下文作为参数
+// 回调的 this 自动绑定到调用它的实例上
+export function nextTick(cb, ctx) {
+  var _resolve;
+  // 将传入的回调函数存放到数组中，后面会遍历执行其中的回调
+  callbacks.push(function () {
+    if (cb) {
+      // 对传入的回调进行 try catch 错误捕获
+      try {
+        cb.call(ctx);
+      } catch (e) {
+        // 进行统一的错误处理
+        // handleError(e, ctx, 'nextTick');
+      }
+    } else if (_resolve) {
+      _resolve(ctx);
+    }
+  });
+
+  // 如果当前没有在 pending 的回调，
+  // 就执行 timeFunc 函数选择当前环境优先支持的异步方法
+  if (!pending) {
+    pending = true;
+    timerFunc();
+  }
+
+  // 如果没有传入回调，并且当前环境支持 promise，就返回一个 promise
+  // 在返回的这个 promise.then 中 DOM 已经更新好了，
+  if (!cb && typeof Promise !== 'undefined') {
+    return new Promise(function (resolve) {
+      _resolve = resolve;
+    });
+  }
+}
+
+// 判断当前环境优先支持的异步方法，优先选择微任务
+// 优先级：Promise---> MutationObserver---> setImmediate---> setTimeout
+// setTimeout 可能产生一个 4ms 的延迟，而 setImmediate 会在主线程执行完后立刻执行
+// setImmediate 在 IE10 和 node 中支持
+
+// 当在同一轮事件循环中多次调用 nextTick 时 ,timerFunc 只会执行一次
+
+var timerFunc;
+// 判断当前环境是否原生支持 promise
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+  // 支持 promise
+  var p = Promise.resolve();
+  timerFunc = function timerFunc() {
+    // 用 promise.then 把 flushCallbacks 函数包裹成一个异步微任务
+    p.then(flushCallbacks);
+    if (isIOS) {
+      setTimeout(noop);
+    }
+    // 这里的 setTimeout 是用来强制刷新微任务队列的
+    // 因为在 ios 下 promise.then 后面没有宏任务的话，微任务队列不会刷新
+  };
+  // 标记当前 nextTick 使用的微任务
+  isUsingMicroTask = true;
+
+  // 如果不支持 promise，就判断是否支持 MutationObserver
+  // 不是IE环境，并且原生支持 MutationObserver，那也是一个微任务
+} else if (typeof MutationObserver !== 'undefined' && (isNative(MutationObserver) || MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+  var counter = 1;
+  // new 一个 MutationObserver 类
+  var observer = new MutationObserver(flushCallbacks);
+  // 创建一个文本节点
+  var textNode = document.createTextNode(String(counter));
+  // 监听这个文本节点，当数据发生变化就执行 flushCallbacks
+  observer.observe(textNode, {
+    characterData: true
+  });
+  timerFunc = function timerFunc() {
+    counter = (counter + 1) % 2;
+    textNode.data = String(counter); // 数据更新
+  };
+  isUsingMicroTask = true; // 标记当前 nextTick 使用的微任务
+
+  // 判断当前环境是否原生支持 setImmediate
+} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+  timerFunc = function timerFunc() {
+    setImmediate(flushCallbacks);
+  };
+} else {
+  // 以上三种都不支持就选择 setTimeout
+  timerFunc = function timerFunc() {
+    setTimeout(flushCallbacks, 0);
+  };
+}
+
+// 如果多次调用 nextTick，会依次执行上面的方法，将 nextTick 的回调放在 callbacks 数组中
+// 最后通过 flushCallbacks 函数遍历 callbacks 数组的拷贝并执行其中的回调
+function flushCallbacks() {
+  pending = false;
+  var copies = callbacks.slice(0); // 拷贝一份 callbacks
+  callbacks.length = 0; // 清空 callbacks
+  for (var i = 0; i < copies.length; i++) {
+    // 遍历执行传入的回调
+    copies[i]();
+  }
+}
+
+// 为什么要拷贝一份 callbacks
+
+// 用 callbacks.slice(0) 将 callbacks 拷贝出来一份，
+// 是因为考虑到在 nextTick 回调中可能还会调用 nextTick 的情况,
+// 如果在 nextTick 回调中又调用了一次 nextTick，则又会向 callbacks 中添加回调，
+// 而 nextTick 回调中的 nextTick 应该放在下一轮执行，
+// 否则就可能出现一直循环的情况，
+// 所以需要将 callbacks 复制一份出来然后清空，再遍历备份列表执行回调
+
+export var escapeStringRegexp = function escapeStringRegexp() {
+  var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+};