@uni-sw/u-design 2.0.4

package/es/components/_util/ActionButton.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { ButtonProps, LegacyButtonType } from '../UButton/button/button';
+export interface ActionButtonProps {
+    type?: LegacyButtonType;
+    actionFn?: (...args: any[]) => any | PromiseLike<any>;
+    close?: Function;
+    autoFocus?: boolean;
+    prefixCls: string;
+    buttonProps?: ButtonProps;
+    emitEvent?: boolean;
+    quitOnNullishReturnValue?: boolean;
+    children?: React.ReactNode;
+}
+declare const ActionButton: React.FC<ActionButtonProps>;
+export default ActionButton;

package/es/components/_util/ActionButton.js

@@ -0,0 +1,100 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import useState from 'rc-util/lib/hooks/useState';
+import * as React from 'react';
+import Button from "../UButton/button";
+import { convertLegacyProps } from "../UButton/button/button";
+function isThenable(thing) {
+  return !!(thing && !!thing.then);
+}
+var ActionButton = function ActionButton(props) {
+  var clickedRef = React.useRef(false);
+  var ref = React.useRef(null);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    loading = _useState2[0],
+    setLoading = _useState2[1];
+  var close = props.close;
+  var onInternalClose = function onInternalClose() {
+    close === null || close === void 0 ? void 0 : close.apply(void 0, arguments);
+  };
+  React.useEffect(function () {
+    var timeoutId = null;
+    if (props.autoFocus) {
+      timeoutId = setTimeout(function () {
+        var _a;
+        (_a = ref.current) === null || _a === void 0 ? void 0 : _a.focus();
+      });
+    }
+    return function () {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, []);
+  var handlePromiseOnOk = function handlePromiseOnOk(returnValueOfOnOk) {
+    if (!isThenable(returnValueOfOnOk)) {
+      return;
+    }
+    setLoading(true);
+    returnValueOfOnOk.then(function () {
+      setLoading(false, true);
+      onInternalClose.apply(void 0, arguments);
+      clickedRef.current = false;
+    }, function (e) {
+      // Emit error when catch promise reject
+      // eslint-disable-next-line no-console
+      console.error(e);
+      // See: https://github.com/ant-design/ant-design/issues/6183
+      setLoading(false, true);
+      clickedRef.current = false;
+    });
+  };
+  var onClick = function onClick(e) {
+    var actionFn = props.actionFn;
+    if (clickedRef.current) {
+      return;
+    }
+    clickedRef.current = true;
+    if (!actionFn) {
+      onInternalClose();
+      return;
+    }
+    var returnValueOfOnOk;
+    if (props.emitEvent) {
+      returnValueOfOnOk = actionFn(e);
+      if (props.quitOnNullishReturnValue && !isThenable(returnValueOfOnOk)) {
+        clickedRef.current = false;
+        onInternalClose(e);
+        return;
+      }
+    } else if (actionFn.length) {
+      returnValueOfOnOk = actionFn(close);
+      // https://github.com/ant-design/ant-design/issues/23358
+      clickedRef.current = false;
+    } else {
+      returnValueOfOnOk = actionFn();
+      if (!returnValueOfOnOk) {
+        onInternalClose();
+        return;
+      }
+    }
+    handlePromiseOnOk(returnValueOfOnOk);
+  };
+  var type = props.type,
+    children = props.children,
+    prefixCls = props.prefixCls,
+    buttonProps = props.buttonProps;
+  return /*#__PURE__*/React.createElement(Button, Object.assign({}, convertLegacyProps(type), {
+    onClick: onClick,
+    loading: loading,
+    prefixCls: prefixCls
+  }, buttonProps, {
+    ref: ref
+  }), children);
+};
+export default ActionButton;

package/es/components/_util/colors.d.ts

@@ -0,0 +1,5 @@
+import type { ElementOf } from './type';
+export declare const PresetStatusColorTypes: ["success", "processing", "error", "default", "warning"];
+export declare const PresetColorTypes: ["pink", "red", "yellow", "orange", "cyan", "green", "blue", "purple", "geekblue", "magenta", "volcano", "gold", "lime"];
+export type PresetColorType = ElementOf<typeof PresetColorTypes>;
+export type PresetStatusColorType = ElementOf<typeof PresetStatusColorTypes>;

package/es/components/_util/colors.js

@@ -0,0 +1,4 @@
+import { tuple } from "./type";
+export var PresetStatusColorTypes = tuple('success', 'processing', 'error', 'default', 'warning');
+// eslint-disable-next-line import/prefer-default-export
+export var PresetColorTypes = tuple('pink', 'red', 'yellow', 'orange', 'cyan', 'green', 'blue', 'purple', 'geekblue', 'magenta', 'volcano', 'gold', 'lime');

package/es/components/_util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/es/components/_util/easings.js

@@ -0,0 +1,10 @@
+// eslint-disable-next-line import/prefer-default-export
+export function easeInOutCubic(t, b, c, d) {
+  var cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+  // eslint-disable-next-line no-return-assign
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}

package/es/components/_util/getDataOrAriaProps.d.ts

@@ -0,0 +1 @@
+export default function getDataOrAriaProps(props: any): any;

package/es/components/_util/getDataOrAriaProps.js

@@ -0,0 +1,8 @@
+export default function getDataOrAriaProps(props) {
+  return Object.keys(props).reduce(function (prev, key) {
+    if ((key.startsWith('data-') || key.startsWith('aria-') || key === 'role') && !key.startsWith('data-__')) {
+      prev[key] = props[key];
+    }
+    return prev;
+  }, {});
+}

package/es/components/_util/getRenderPropValue.d.ts

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+export type RenderFunction = () => React.ReactNode;
+export declare const getRenderPropValue: (propValue?: React.ReactNode | RenderFunction) => React.ReactNode;

package/es/components/_util/getRenderPropValue.js

@@ -0,0 +1,9 @@
+export var getRenderPropValue = function getRenderPropValue(propValue) {
+  if (!propValue) {
+    return null;
+  }
+  if (typeof propValue === 'function') {
+    return propValue();
+  }
+  return propValue;
+};

package/es/components/_util/getScroll.d.ts

@@ -0,0 +1,2 @@
+export declare function isWindow(obj: any): obj is Window;
+export default function getScroll(target: HTMLElement | Window | Document | null, top: boolean): number;

package/es/components/_util/getScroll.js

@@ -0,0 +1,29 @@
+export function isWindow(obj) {
+  return obj !== null && obj !== undefined && obj === obj.window;
+}
+export default function getScroll(target, top) {
+  var _a, _b;
+  if (typeof window === 'undefined') {
+    return 0;
+  }
+  var method = top ? 'scrollTop' : 'scrollLeft';
+  var result = 0;
+  if (isWindow(target)) {
+    result = target[top ? 'pageYOffset' : 'pageXOffset'];
+  } else if (target instanceof Document) {
+    result = target.documentElement[method];
+  } else if (target instanceof HTMLElement) {
+    result = target[method];
+  } else if (target) {
+    // According to the type inference, the `target` is `never` type.
+    // Since we configured the loose mode type checking, and supports mocking the target with such shape below::
+    //    `{ documentElement: { scrollLeft: 200, scrollTop: 400 } }`,
+    //    the program may falls into this branch.
+    // Check the corresponding tests for details. Don't sure what is the real scenario this happens.
+    result = target[method];
+  }
+  if (target && !isWindow(target) && typeof result !== 'number') {
+    result = (_b = ((_a = target.ownerDocument) !== null && _a !== void 0 ? _a : target).documentElement) === null || _b === void 0 ? void 0 : _b[method];
+  }
+  return result;
+}

package/es/components/_util/hooks/useFlexGapSupport.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => boolean;
+export default _default;

package/es/components/_util/hooks/useFlexGapSupport.js

@@ -0,0 +1,18 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import * as React from 'react';
+import { detectFlexGapSupported } from "../styleChecker";
+export default (function () {
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    flexible = _React$useState2[0],
+    setFlexible = _React$useState2[1];
+  React.useEffect(function () {
+    setFlexible(detectFlexGapSupported());
+  }, []);
+  return flexible;
+});

package/es/components/_util/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useForceUpdate(): React.DispatchWithoutAction;

package/es/components/_util/hooks/useForceUpdate.js

@@ -0,0 +1,15 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import * as React from 'react';
+export default function useForceUpdate() {
+  var _React$useReducer = React.useReducer(function (x) {
+      return x + 1;
+    }, 0),
+    _React$useReducer2 = _slicedToArray(_React$useReducer, 2),
+    forceUpdate = _React$useReducer2[1];
+  return forceUpdate;
+}

package/es/components/_util/hooks/usePatchElement.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export default function usePatchElement(): [
+    React.ReactElement[],
+    (element: React.ReactElement) => Function
+];

package/es/components/_util/hooks/usePatchElement.js

@@ -0,0 +1,33 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _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 _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import * as React from 'react';
+export default function usePatchElement() {
+  var _React$useState = React.useState([]),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    elements = _React$useState2[0],
+    setElements = _React$useState2[1];
+  var patchElement = React.useCallback(function (element) {
+    // append a new element to elements (and create a new ref)
+    setElements(function (originElements) {
+      return [].concat(_toConsumableArray(originElements), [element]);
+    });
+    // return a function that removes the new element out of elements (and create a new ref)
+    // it works a little like useEffect
+    return function () {
+      setElements(function (originElements) {
+        return originElements.filter(function (ele) {
+          return ele !== element;
+        });
+      });
+    };
+  }, []);
+  return [elements, patchElement];
+}

package/es/components/_util/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+type UseSyncStateProps<T> = readonly [() => T, (newValue: T) => void];
+export default function useSyncState<T>(initialValue: T): UseSyncStateProps<T>;
+export {};

package/es/components/_util/hooks/useSyncState.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import useForceUpdate from "./useForceUpdate";
+export default function useSyncState(initialValue) {
+  var ref = React.useRef(initialValue);
+  var forceUpdate = useForceUpdate();
+  return [function () {
+    return ref.current;
+  }, function (newValue) {
+    ref.current = newValue;
+    // re-render
+    forceUpdate();
+  }];
+}

package/es/components/_util/isNumeric.d.ts

@@ -0,0 +1,2 @@
+declare const isNumeric: (value: any) => boolean;
+export default isNumeric;

package/es/components/_util/isNumeric.js

@@ -0,0 +1,4 @@
+var isNumeric = function isNumeric(value) {
+  return !isNaN(parseFloat(value)) && isFinite(value);
+};
+export default isNumeric;

package/es/components/_util/motion.d.ts

@@ -0,0 +1,8 @@
+import type { CSSMotionProps } from 'rc-motion';
+declare const collapseMotion: CSSMotionProps;
+declare const SelectPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = typeof SelectPlacements[number];
+declare const getTransitionDirection: (placement: SelectCommonPlacement | undefined) => "slide-down" | "slide-up";
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionName, getTransitionDirection };
+export default collapseMotion;

package/es/components/_util/motion.js

@@ -0,0 +1,51 @@
+import { tuple } from "./type";
+// ================== Collapse Motion ==================
+var getCollapsedHeight = function getCollapsedHeight() {
+  return {
+    height: 0,
+    opacity: 0
+  };
+};
+var getRealHeight = function getRealHeight(node) {
+  var scrollHeight = node.scrollHeight;
+  return {
+    height: scrollHeight,
+    opacity: 1
+  };
+};
+var getCurrentHeight = function getCurrentHeight(node) {
+  return {
+    height: node ? node.offsetHeight : 0
+  };
+};
+var skipOpacityTransition = function skipOpacityTransition(_, event) {
+  return (event === null || event === void 0 ? void 0 : event.deadline) === true || event.propertyName === 'height';
+};
+var collapseMotion = {
+  motionName: 'ant-motion-collapse',
+  onAppearStart: getCollapsedHeight,
+  onEnterStart: getCollapsedHeight,
+  onAppearActive: getRealHeight,
+  onEnterActive: getRealHeight,
+  onLeaveStart: getCurrentHeight,
+  onLeaveActive: getCollapsedHeight,
+  onAppearEnd: skipOpacityTransition,
+  onEnterEnd: skipOpacityTransition,
+  onLeaveEnd: skipOpacityTransition,
+  motionDeadline: 500
+};
+var SelectPlacements = tuple('bottomLeft', 'bottomRight', 'topLeft', 'topRight');
+var getTransitionDirection = function getTransitionDirection(placement) {
+  if (placement !== undefined && (placement === 'topLeft' || placement === 'topRight')) {
+    return "slide-down";
+  }
+  return "slide-up";
+};
+var getTransitionName = function getTransitionName(rootPrefixCls, motion, transitionName) {
+  if (transitionName !== undefined) {
+    return transitionName;
+  }
+  return "".concat(rootPrefixCls, "-").concat(motion);
+};
+export { getTransitionName, getTransitionDirection };
+export default collapseMotion;

package/es/components/_util/placements.d.ts

@@ -0,0 +1,17 @@
+import type { BuildInPlacements } from 'rc-trigger';
+export interface AdjustOverflow {
+    adjustX?: 0 | 1;
+    adjustY?: 0 | 1;
+}
+export interface PlacementsConfig {
+    arrowWidth?: number;
+    horizontalArrowShift?: number;
+    verticalArrowShift?: number;
+    arrowPointAtCenter?: boolean;
+    autoAdjustOverflow?: boolean | AdjustOverflow;
+}
+export declare function getOverflowOptions(autoAdjustOverflow?: boolean | AdjustOverflow): {
+    adjustX: number;
+    adjustY: number;
+};
+export default function getPlacements(config: PlacementsConfig): BuildInPlacements;

package/es/components/_util/placements.js

@@ -0,0 +1,86 @@
+import { placements } from 'rc-tooltip/lib/placements';
+var autoAdjustOverflowEnabled = {
+  adjustX: 1,
+  adjustY: 1
+};
+var autoAdjustOverflowDisabled = {
+  adjustX: 0,
+  adjustY: 0
+};
+var targetOffset = [0, 0];
+export function getOverflowOptions(autoAdjustOverflow) {
+  if (typeof autoAdjustOverflow === 'boolean') {
+    return autoAdjustOverflow ? autoAdjustOverflowEnabled : autoAdjustOverflowDisabled;
+  }
+  return Object.assign(Object.assign({}, autoAdjustOverflowDisabled), autoAdjustOverflow);
+}
+export default function getPlacements(config) {
+  var _config$arrowWidth = config.arrowWidth,
+    arrowWidth = _config$arrowWidth === void 0 ? 4 : _config$arrowWidth,
+    _config$horizontalArr = config.horizontalArrowShift,
+    horizontalArrowShift = _config$horizontalArr === void 0 ? 16 : _config$horizontalArr,
+    _config$verticalArrow = config.verticalArrowShift,
+    verticalArrowShift = _config$verticalArrow === void 0 ? 8 : _config$verticalArrow,
+    autoAdjustOverflow = config.autoAdjustOverflow,
+    arrowPointAtCenter = config.arrowPointAtCenter;
+  var placementMap = {
+    left: {
+      points: ['cr', 'cl'],
+      offset: [-4, 0]
+    },
+    right: {
+      points: ['cl', 'cr'],
+      offset: [4, 0]
+    },
+    top: {
+      points: ['bc', 'tc'],
+      offset: [0, -4]
+    },
+    bottom: {
+      points: ['tc', 'bc'],
+      offset: [0, 4]
+    },
+    topLeft: {
+      points: ['bl', 'tc'],
+      offset: [-(horizontalArrowShift + arrowWidth), -4]
+    },
+    leftTop: {
+      points: ['tr', 'cl'],
+      offset: [-4, -(verticalArrowShift + arrowWidth)]
+    },
+    topRight: {
+      points: ['br', 'tc'],
+      offset: [horizontalArrowShift + arrowWidth, -4]
+    },
+    rightTop: {
+      points: ['tl', 'cr'],
+      offset: [4, -(verticalArrowShift + arrowWidth)]
+    },
+    bottomRight: {
+      points: ['tr', 'bc'],
+      offset: [horizontalArrowShift + arrowWidth, 4]
+    },
+    rightBottom: {
+      points: ['bl', 'cr'],
+      offset: [4, verticalArrowShift + arrowWidth]
+    },
+    bottomLeft: {
+      points: ['tl', 'bc'],
+      offset: [-(horizontalArrowShift + arrowWidth), 4]
+    },
+    leftBottom: {
+      points: ['br', 'cl'],
+      offset: [-4, verticalArrowShift + arrowWidth]
+    }
+  };
+  Object.keys(placementMap).forEach(function (key) {
+    placementMap[key] = arrowPointAtCenter ? Object.assign(Object.assign({}, placementMap[key]), {
+      overflow: getOverflowOptions(autoAdjustOverflow),
+      targetOffset: targetOffset
+    }) : Object.assign(Object.assign({}, placements[key]), {
+      overflow: getOverflowOptions(autoAdjustOverflow)
+    });
+    placementMap[key].ignoreShake = true;
+  });
+  return placementMap;
+}

package/es/components/_util/raf.d.ts

@@ -0,0 +1,9 @@
+interface RafMap {
+    [id: number]: number;
+}
+declare function wrapperRaf(callback: () => void, delayFrames?: number): number;
+declare namespace wrapperRaf {
+    var cancel: (pid?: number | undefined) => void;
+    var ids: RafMap;
+}
+export default wrapperRaf;

package/es/components/_util/raf.js

@@ -0,0 +1,26 @@
+import raf from 'rc-util/lib/raf';
+var id = 0;
+var ids = {};
+// Support call raf with delay specified frame
+export default function wrapperRaf(callback) {
+  var delayFrames = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var myId = id++;
+  var restFrames = delayFrames;
+  function internalCallback() {
+    restFrames -= 1;
+    if (restFrames <= 0) {
+      callback();
+      delete ids[myId];
+    } else {
+      ids[myId] = raf(internalCallback);
+    }
+  }
+  ids[myId] = raf(internalCallback);
+  return myId;
+}
+wrapperRaf.cancel = function cancel(pid) {
+  if (pid === undefined) return;
+  raf.cancel(ids[pid]);
+  delete ids[pid];
+};
+wrapperRaf.ids = ids; // export this for test usage

package/es/components/_util/reactNode.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare const isValidElement: typeof React.isValidElement;
+export declare function isFragment(child: any): boolean;
+type AnyObject = Record<PropertyKey, any>;
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | void);
+export declare function replaceElement(element: React.ReactNode, replacement: React.ReactNode, props?: RenderProps): React.ReactNode;
+export declare function cloneElement(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/es/components/_util/reactNode.js

@@ -0,0 +1,15 @@
+import * as React from 'react';
+var isValidElement = React.isValidElement;
+export { isValidElement };
+export function isFragment(child) {
+  return child && isValidElement(child) && child.type === React.Fragment;
+}
+export function replaceElement(element, replacement, props) {
+  if (!isValidElement(element)) {
+    return replacement;
+  }
+  return /*#__PURE__*/React.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
+}
+export function cloneElement(element, props) {
+  return replaceElement(element, element, props);
+}

package/es/components/_util/responsiveObserve.d.ts

@@ -0,0 +1,21 @@
+export type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Record<Breakpoint, string>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export type ScreenSizeMap = Partial<Record<Breakpoint, number>>;
+export declare const responsiveArray: Breakpoint[];
+export declare const responsiveMap: BreakpointMap;
+type SubscribeFunc = (screens: ScreenMap) => void;
+declare const responsiveObserve: {
+    matchHandlers: {
+        [prop: string]: {
+            mql: MediaQueryList;
+            listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
+        };
+    };
+    dispatch(pointMap: ScreenMap): boolean;
+    subscribe(func: SubscribeFunc): number;
+    unsubscribe(token: number): void;
+    unregister(): void;
+    register(): void;
+};
+export default responsiveObserve;

package/es/components/_util/responsiveObserve.js

@@ -0,0 +1,64 @@
+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 _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : 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); }
+export var responsiveArray = ['xxl', 'xl', 'lg', 'md', 'sm', 'xs'];
+export var responsiveMap = {
+  xs: '(max-width: 575px)',
+  sm: '(min-width: 576px)',
+  md: '(min-width: 768px)',
+  lg: '(min-width: 992px)',
+  xl: '(min-width: 1200px)',
+  xxl: '(min-width: 1600px)'
+};
+var subscribers = new Map();
+var subUid = -1;
+var screens = {};
+var responsiveObserve = {
+  matchHandlers: {},
+  dispatch: function dispatch(pointMap) {
+    screens = pointMap;
+    subscribers.forEach(function (func) {
+      return func(screens);
+    });
+    return subscribers.size >= 1;
+  },
+  subscribe: function subscribe(func) {
+    if (!subscribers.size) this.register();
+    subUid += 1;
+    subscribers.set(subUid, func);
+    func(screens);
+    return subUid;
+  },
+  unsubscribe: function unsubscribe(token) {
+    subscribers.delete(token);
+    if (!subscribers.size) this.unregister();
+  },
+  unregister: function unregister() {
+    var _this = this;
+    Object.keys(responsiveMap).forEach(function (screen) {
+      var matchMediaQuery = responsiveMap[screen];
+      var handler = _this.matchHandlers[matchMediaQuery];
+      handler === null || handler === void 0 ? void 0 : handler.mql.removeListener(handler === null || handler === void 0 ? void 0 : handler.listener);
+    });
+    subscribers.clear();
+  },
+  register: function register() {
+    var _this2 = this;
+    Object.keys(responsiveMap).forEach(function (screen) {
+      var matchMediaQuery = responsiveMap[screen];
+      var listener = function listener(_ref) {
+        var matches = _ref.matches;
+        _this2.dispatch(Object.assign(Object.assign({}, screens), _defineProperty({}, screen, matches)));
+      };
+      var mql = window.matchMedia(matchMediaQuery);
+      mql.addListener(listener);
+      _this2.matchHandlers[matchMediaQuery] = {
+        mql: mql,
+        listener: listener
+      };
+      listener(mql);
+    });
+  }
+};
+export default responsiveObserve;