@qsxy/element-plus-react 1.0.1 → 1.0.3

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 { escapeStringRegexp, isEmpty, isFunction, nextTick } from "../Util";
+import { treeAllProps } from "../hooks/treePropsUtils";
+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/TreeSelect/utils.d.ts

@@ -0,0 +1,10 @@
+import { TreeNodeData } from '../Tree/typings';
+export declare function isValidValue(val: any): any;
+export declare function isValidArray(val: any): number;
+export declare function toValidArray(val: any): any[];
+type TreeCallback<T extends TreeNodeData, R> = (data: T, index: number, array: T[], parent?: T) => R;
+type TreeFindCallback<T extends TreeNodeData> = TreeCallback<T, boolean>;
+export declare function treeFind<T extends TreeNodeData>(treeData: T[], findCallback: TreeFindCallback<T>, getChildren: (data: T) => T[]): T | undefined;
+export declare function treeFind<T extends TreeNodeData, R>(treeData: T[], findCallback: TreeFindCallback<T>, getChildren: (data: T) => T[], resultCallback?: TreeCallback<T, R>, parent?: T): R | undefined;
+export declare function treeEach<T extends TreeNodeData>(treeData: T[], callback: TreeCallback<T, void>, getChildren: (data: T) => T[], parent?: T): void;
+export {};

package/dist/TreeSelect/utils.js

@@ -0,0 +1,38 @@
+export function isValidValue(val) {
+  return val || val === 0;
+}
+export function isValidArray(val) {
+  return Array.isArray(val) && val.length;
+}
+export function toValidArray(val) {
+  if (Array.isArray(val)) {
+    return val;
+  }
+  return isValidValue(val) ? [val] : [];
+}
+export function treeFind(treeData, findCallback, getChildren, resultCallback, parent) {
+  for (var i = 0; i < treeData.length; i++) {
+    var _data = treeData[i];
+    if (findCallback(_data, i, treeData, parent)) {
+      return resultCallback ? resultCallback(_data, i, treeData, parent) : _data;
+    } else {
+      var children = getChildren(_data);
+      if (isValidArray(children)) {
+        var find = treeFind(children, findCallback, getChildren, resultCallback, _data);
+        if (find) {
+          return find;
+        }
+      }
+    }
+  }
+}
+export function treeEach(treeData, callback, getChildren, parent) {
+  for (var i = 0; i < treeData.length; i++) {
+    var _data2 = treeData[i];
+    callback(_data2, i, treeData, parent);
+    var children = getChildren(_data2);
+    if (isValidArray(children)) {
+      treeEach(children, callback, getChildren, _data2);
+    }
+  }
+}

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,

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;
     /** 接受上传的文件类型 */
@@ -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/aria.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Determine if the testing element is visible on screen no matter if its on the viewport or not
+ */
+export declare const isVisible: (element: HTMLElement) => boolean;
+export declare const obtainAllFocusableElements: (element: HTMLElement) => HTMLElement[];
+/**
+ * @desc Determine if target element is focusable
+ * @param element {HTMLElement}
+ * @returns {Boolean} true if it is focusable
+ */
+export declare const isFocusable: (element: HTMLElement) => boolean;
+/**
+ * Trigger an event
+ * mouseenter, mouseleave, mouseover, keyup, change, click, etc.
+ * @param  {HTMLElement} elm
+ * @param  {String} name
+ * @param  {*} opts
+ */
+export declare const triggerEvent: (elm: HTMLElement, name: string, ...opts: Array<boolean>) => HTMLElement;
+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;
+export declare const focusNode: (el: HTMLElement) => void;

package/dist/Util/aria.js

@@ -0,0 +1,118 @@
+var FOCUSABLE_ELEMENT_SELECTORS = 'a[href],button:not([disabled]),button:not([hidden]),:not([tabindex="-1"]),input:not([disabled]),input:not([type="hidden"]),select:not([disabled]),textarea:not([disabled])';
+var isHTMLElement = function isHTMLElement(e) {
+  if (typeof Element === 'undefined') {
+    return false;
+  }
+  return e instanceof Element;
+};
+
+/**
+ * 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') {
+    return true;
+  }
+  var computed = getComputedStyle(element);
+  // element.offsetParent won't work on fix positioned
+  // WARNING: potential issue here, going to need some expert advices on this issue
+  return computed.position === 'fixed' ? false : element.offsetParent !== null;
+};
+export var obtainAllFocusableElements = function obtainAllFocusableElements(element) {
+  return Array.from(element.querySelectorAll(FOCUSABLE_ELEMENT_SELECTORS)).filter(function (item) {
+    return isFocusable(item) && isVisible(item);
+  });
+};
+
+/**
+ * @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) {
+    return true;
+  }
+  if (element.tabIndex < 0 || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true') {
+    return false;
+  }
+  switch (element.nodeName) {
+    case 'A':
+      {
+        // casting current element to Specific HTMLElement in order to be more type precise
+        return !!element.href && element.rel !== 'ignore';
+      }
+    case 'INPUT':
+      {
+        return !(element.type === 'hidden' || element.type === 'file');
+      }
+    case 'BUTTON':
+    case 'SELECT':
+    case 'TEXTAREA':
+      {
+        return true;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+/**
+ * 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;
+  if (name.includes('mouse') || name.includes('click')) {
+    eventName = 'MouseEvents';
+  } else if (name.includes('key')) {
+    eventName = 'KeyboardEvent';
+  } else {
+    eventName = 'HTMLEvents';
+  }
+  var evt = document.createEvent(eventName);
+  for (var _len = arguments.length, opts = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    opts[_key - 2] = arguments[_key];
+  }
+  evt.initEvent.apply(evt, [name].concat(opts));
+  elm.dispatchEvent(evt);
+  return elm;
+};
+export var isLeaf = function isLeaf(el) {
+  return !el.getAttribute('aria-owns');
+};
+export var getSibling = function getSibling(el, distance, elClass) {
+  var parentNode = el.parentNode;
+  if (!parentNode) {
+    return null;
+  }
+  var siblings = parentNode.querySelectorAll(elClass);
+  var index = Array.prototype.indexOf.call(siblings, el);
+  return siblings[index + distance] || null;
+};
+export var focusElement = function focusElement(el, options) {
+  if (!el || !el.focus) {
+    return;
+  }
+  var cleanup = false;
+  if (isHTMLElement(el) && !isFocusable(el) && !el.getAttribute('tabindex')) {
+    el.setAttribute('tabindex', '-1');
+    cleanup = true;
+  }
+  el.focus(options);
+  if (isHTMLElement(el) && cleanup) {
+    el.removeAttribute('tabindex');
+  }
+};
+export var focusNode = function focusNode(el) {
+  if (!el) {
+    return;
+  }
+  focusElement(el);
+  !isLeaf(el) && el.click();
+};

package/dist/Util/base.d.ts

@@ -36,6 +36,11 @@ 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 isFunction: (val: any) => boolean;
+export declare const isPropAbsent: (prop: unknown) => prop is null;
 export declare const isStringNumber: (val: string) => boolean;
 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;