add all frontend files

node_modules/rc-motion/es/CSSMotion.d.ts

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import type { MotionEndEventHandler, MotionEventHandler, MotionPrepareEventHandler, MotionStatus } from './interface';
+export type CSSMotionConfig = boolean | {
+    transitionSupport?: boolean;
+    /** @deprecated, no need this anymore since `rc-motion` only support latest react */
+    forwardRef?: boolean;
+};
+export type MotionName = string | {
+    appear?: string;
+    enter?: string;
+    leave?: string;
+    appearActive?: string;
+    enterActive?: string;
+    leaveActive?: string;
+};
+export interface CSSMotionProps {
+    motionName?: MotionName;
+    visible?: boolean;
+    motionAppear?: boolean;
+    motionEnter?: boolean;
+    motionLeave?: boolean;
+    motionLeaveImmediately?: boolean;
+    motionDeadline?: number;
+    /**
+     * Create element in view even the element is invisible.
+     * Will patch `display: none` style on it.
+     */
+    forceRender?: boolean;
+    /**
+     * Remove element when motion end. This will not work when `forceRender` is set.
+     */
+    removeOnLeave?: boolean;
+    leavedClassName?: string;
+    /** @private Used by CSSMotionList. Do not use in your production. */
+    eventProps?: object;
+    /** Prepare phase is used for measure element info. It will always trigger even motion is off */
+    onAppearPrepare?: MotionPrepareEventHandler;
+    /** Prepare phase is used for measure element info. It will always trigger even motion is off */
+    onEnterPrepare?: MotionPrepareEventHandler;
+    /** Prepare phase is used for measure element info. It will always trigger even motion is off */
+    onLeavePrepare?: MotionPrepareEventHandler;
+    onAppearStart?: MotionEventHandler;
+    onEnterStart?: MotionEventHandler;
+    onLeaveStart?: MotionEventHandler;
+    onAppearActive?: MotionEventHandler;
+    onEnterActive?: MotionEventHandler;
+    onLeaveActive?: MotionEventHandler;
+    onAppearEnd?: MotionEndEventHandler;
+    onEnterEnd?: MotionEndEventHandler;
+    onLeaveEnd?: MotionEndEventHandler;
+    /** This will always trigger after final visible changed. Even if no motion configured. */
+    onVisibleChanged?: (visible: boolean) => void;
+    internalRef?: React.Ref<any>;
+    children?: (props: {
+        visible?: boolean;
+        className?: string;
+        style?: React.CSSProperties;
+        [key: string]: any;
+    }, ref: (node: any) => void) => React.ReactElement;
+}
+export interface CSSMotionState {
+    status?: MotionStatus;
+    statusActive?: boolean;
+    newStatus?: boolean;
+    statusStyle?: React.CSSProperties;
+    prevProps?: CSSMotionProps;
+}
+/**
+ * `transitionSupport` is used for none transition test case.
+ * Default we use browser transition event support check.
+ */
+export declare function genCSSMotion(config: CSSMotionConfig): React.ForwardRefExoticComponent<CSSMotionProps & React.RefAttributes<any>>;
+declare const _default: React.ForwardRefExoticComponent<CSSMotionProps & React.RefAttributes<any>>;
+export default _default;

node_modules/rc-motion/es/CSSMotion.js

@@ -0,0 +1,137 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+/* eslint-disable react/default-props-match-prop-types, react/no-multi-comp, react/prop-types */
+import classNames from 'classnames';
+import findDOMNode from "rc-util/es/Dom/findDOMNode";
+import { fillRef, getNodeRef, supportRef } from "rc-util/es/ref";
+import * as React from 'react';
+import { useRef } from 'react';
+import { Context } from "./context";
+import DomWrapper from "./DomWrapper";
+import useStatus from "./hooks/useStatus";
+import { isActive } from "./hooks/useStepQueue";
+import { STATUS_NONE, STEP_PREPARE, STEP_START } from "./interface";
+import { getTransitionName, supportTransition } from "./util/motion";
+/**
+ * `transitionSupport` is used for none transition test case.
+ * Default we use browser transition event support check.
+ */
+export function genCSSMotion(config) {
+  var transitionSupport = config;
+  if (_typeof(config) === 'object') {
+    transitionSupport = config.transitionSupport;
+  }
+  function isSupportTransition(props, contextMotion) {
+    return !!(props.motionName && transitionSupport && contextMotion !== false);
+  }
+  var CSSMotion = /*#__PURE__*/React.forwardRef(function (props, ref) {
+    var _props$visible = props.visible,
+      visible = _props$visible === void 0 ? true : _props$visible,
+      _props$removeOnLeave = props.removeOnLeave,
+      removeOnLeave = _props$removeOnLeave === void 0 ? true : _props$removeOnLeave,
+      forceRender = props.forceRender,
+      children = props.children,
+      motionName = props.motionName,
+      leavedClassName = props.leavedClassName,
+      eventProps = props.eventProps;
+    var _React$useContext = React.useContext(Context),
+      contextMotion = _React$useContext.motion;
+    var supportMotion = isSupportTransition(props, contextMotion);
+
+    // Ref to the react node, it may be a HTMLElement
+    var nodeRef = useRef();
+    // Ref to the dom wrapper in case ref can not pass to HTMLElement
+    var wrapperNodeRef = useRef();
+    function getDomElement() {
+      try {
+        // Here we're avoiding call for findDOMNode since it's deprecated
+        // in strict mode. We're calling it only when node ref is not
+        // an instance of DOM HTMLElement. Otherwise use
+        // findDOMNode as a final resort
+        return nodeRef.current instanceof HTMLElement ? nodeRef.current : findDOMNode(wrapperNodeRef.current);
+      } catch (e) {
+        // Only happen when `motionDeadline` trigger but element removed.
+        return null;
+      }
+    }
+    var _useStatus = useStatus(supportMotion, visible, getDomElement, props),
+      _useStatus2 = _slicedToArray(_useStatus, 4),
+      status = _useStatus2[0],
+      statusStep = _useStatus2[1],
+      statusStyle = _useStatus2[2],
+      mergedVisible = _useStatus2[3];
+
+    // Record whether content has rendered
+    // Will return null for un-rendered even when `removeOnLeave={false}`
+    var renderedRef = React.useRef(mergedVisible);
+    if (mergedVisible) {
+      renderedRef.current = true;
+    }
+
+    // ====================== Refs ======================
+    var setNodeRef = React.useCallback(function (node) {
+      nodeRef.current = node;
+      fillRef(ref, node);
+    }, [ref]);
+
+    // ===================== Render =====================
+    var motionChildren;
+    var mergedProps = _objectSpread(_objectSpread({}, eventProps), {}, {
+      visible: visible
+    });
+    if (!children) {
+      // No children
+      motionChildren = null;
+    } else if (status === STATUS_NONE) {
+      // Stable children
+      if (mergedVisible) {
+        motionChildren = children(_objectSpread({}, mergedProps), setNodeRef);
+      } else if (!removeOnLeave && renderedRef.current && leavedClassName) {
+        motionChildren = children(_objectSpread(_objectSpread({}, mergedProps), {}, {
+          className: leavedClassName
+        }), setNodeRef);
+      } else if (forceRender || !removeOnLeave && !leavedClassName) {
+        motionChildren = children(_objectSpread(_objectSpread({}, mergedProps), {}, {
+          style: {
+            display: 'none'
+          }
+        }), setNodeRef);
+      } else {
+        motionChildren = null;
+      }
+    } else {
+      // In motion
+      var statusSuffix;
+      if (statusStep === STEP_PREPARE) {
+        statusSuffix = 'prepare';
+      } else if (isActive(statusStep)) {
+        statusSuffix = 'active';
+      } else if (statusStep === STEP_START) {
+        statusSuffix = 'start';
+      }
+      var motionCls = getTransitionName(motionName, "".concat(status, "-").concat(statusSuffix));
+      motionChildren = children(_objectSpread(_objectSpread({}, mergedProps), {}, {
+        className: classNames(getTransitionName(motionName, status), _defineProperty(_defineProperty({}, motionCls, motionCls && statusSuffix), motionName, typeof motionName === 'string')),
+        style: statusStyle
+      }), setNodeRef);
+    }
+
+    // Auto inject ref if child node not have `ref` props
+    if ( /*#__PURE__*/React.isValidElement(motionChildren) && supportRef(motionChildren)) {
+      var originNodeRef = getNodeRef(motionChildren);
+      if (!originNodeRef) {
+        motionChildren = /*#__PURE__*/React.cloneElement(motionChildren, {
+          ref: setNodeRef
+        });
+      }
+    }
+    return /*#__PURE__*/React.createElement(DomWrapper, {
+      ref: wrapperNodeRef
+    }, motionChildren);
+  });
+  CSSMotion.displayName = 'CSSMotion';
+  return CSSMotion;
+}
+export default genCSSMotion(supportTransition);

node_modules/rc-motion/es/CSSMotionList.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { CSSMotionProps } from './CSSMotion';
+import type { KeyObject } from './util/diff';
+export interface CSSMotionListProps extends Omit<CSSMotionProps, 'onVisibleChanged' | 'children'>, Omit<React.HTMLAttributes<any>, 'children'> {
+    keys: (React.Key | {
+        key: React.Key;
+        [name: string]: any;
+    })[];
+    component?: string | React.ComponentType | false;
+    /** This will always trigger after final visible changed. Even if no motion configured. */
+    onVisibleChanged?: (visible: boolean, info: {
+        key: React.Key;
+    }) => void;
+    /** All motion leaves in the screen */
+    onAllRemoved?: () => void;
+    children?: (props: {
+        visible?: boolean;
+        className?: string;
+        style?: React.CSSProperties;
+        index?: number;
+        [key: string]: any;
+    }, ref: (node: any) => void) => React.ReactElement;
+}
+export interface CSSMotionListState {
+    keyEntities: KeyObject[];
+}
+/**
+ * Generate a CSSMotionList component with config
+ * @param transitionSupport No need since CSSMotionList no longer depends on transition support
+ * @param CSSMotion CSSMotion component
+ */
+export declare function genCSSMotionList(transitionSupport: boolean, CSSMotion?: React.ForwardRefExoticComponent<CSSMotionProps & React.RefAttributes<any>>): React.ComponentClass<CSSMotionListProps>;
+declare const _default: React.ComponentClass<CSSMotionListProps, any>;
+export default _default;

node_modules/rc-motion/es/CSSMotionList.js

@@ -0,0 +1,134 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _excluded = ["component", "children", "onVisibleChanged", "onAllRemoved"],
+  _excluded2 = ["status"];
+/* eslint react/prop-types: 0 */
+import * as React from 'react';
+import OriginCSSMotion from "./CSSMotion";
+import { diffKeys, parseKeys, STATUS_ADD, STATUS_KEEP, STATUS_REMOVE, STATUS_REMOVED } from "./util/diff";
+import { supportTransition } from "./util/motion";
+var MOTION_PROP_NAMES = ['eventProps', 'visible', 'children', 'motionName', 'motionAppear', 'motionEnter', 'motionLeave', 'motionLeaveImmediately', 'motionDeadline', 'removeOnLeave', 'leavedClassName', 'onAppearPrepare', 'onAppearStart', 'onAppearActive', 'onAppearEnd', 'onEnterStart', 'onEnterActive', 'onEnterEnd', 'onLeaveStart', 'onLeaveActive', 'onLeaveEnd'];
+/**
+ * Generate a CSSMotionList component with config
+ * @param transitionSupport No need since CSSMotionList no longer depends on transition support
+ * @param CSSMotion CSSMotion component
+ */
+export function genCSSMotionList(transitionSupport) {
+  var CSSMotion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : OriginCSSMotion;
+  var CSSMotionList = /*#__PURE__*/function (_React$Component) {
+    _inherits(CSSMotionList, _React$Component);
+    var _super = _createSuper(CSSMotionList);
+    function CSSMotionList() {
+      var _this;
+      _classCallCheck(this, CSSMotionList);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
+        keyEntities: []
+      });
+      // ZombieJ: Return the count of rest keys. It's safe to refactor if need more info.
+      _defineProperty(_assertThisInitialized(_this), "removeKey", function (removeKey) {
+        _this.setState(function (prevState) {
+          var nextKeyEntities = prevState.keyEntities.map(function (entity) {
+            if (entity.key !== removeKey) return entity;
+            return _objectSpread(_objectSpread({}, entity), {}, {
+              status: STATUS_REMOVED
+            });
+          });
+          return {
+            keyEntities: nextKeyEntities
+          };
+        }, function () {
+          var keyEntities = _this.state.keyEntities;
+          var restKeysCount = keyEntities.filter(function (_ref) {
+            var status = _ref.status;
+            return status !== STATUS_REMOVED;
+          }).length;
+          if (restKeysCount === 0 && _this.props.onAllRemoved) {
+            _this.props.onAllRemoved();
+          }
+        });
+      });
+      return _this;
+    }
+    _createClass(CSSMotionList, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        var keyEntities = this.state.keyEntities;
+        var _this$props = this.props,
+          component = _this$props.component,
+          children = _this$props.children,
+          _onVisibleChanged = _this$props.onVisibleChanged,
+          onAllRemoved = _this$props.onAllRemoved,
+          restProps = _objectWithoutProperties(_this$props, _excluded);
+        var Component = component || React.Fragment;
+        var motionProps = {};
+        MOTION_PROP_NAMES.forEach(function (prop) {
+          motionProps[prop] = restProps[prop];
+          delete restProps[prop];
+        });
+        delete restProps.keys;
+        return /*#__PURE__*/React.createElement(Component, restProps, keyEntities.map(function (_ref2, index) {
+          var status = _ref2.status,
+            eventProps = _objectWithoutProperties(_ref2, _excluded2);
+          var visible = status === STATUS_ADD || status === STATUS_KEEP;
+          return /*#__PURE__*/React.createElement(CSSMotion, _extends({}, motionProps, {
+            key: eventProps.key,
+            visible: visible,
+            eventProps: eventProps,
+            onVisibleChanged: function onVisibleChanged(changedVisible) {
+              _onVisibleChanged === null || _onVisibleChanged === void 0 || _onVisibleChanged(changedVisible, {
+                key: eventProps.key
+              });
+              if (!changedVisible) {
+                _this2.removeKey(eventProps.key);
+              }
+            }
+          }), function (props, ref) {
+            return children(_objectSpread(_objectSpread({}, props), {}, {
+              index: index
+            }), ref);
+          });
+        }));
+      }
+    }], [{
+      key: "getDerivedStateFromProps",
+      value: function getDerivedStateFromProps(_ref3, _ref4) {
+        var keys = _ref3.keys;
+        var keyEntities = _ref4.keyEntities;
+        var parsedKeyObjects = parseKeys(keys);
+        var mixedKeyEntities = diffKeys(keyEntities, parsedKeyObjects);
+        return {
+          keyEntities: mixedKeyEntities.filter(function (entity) {
+            var prevEntity = keyEntities.find(function (_ref5) {
+              var key = _ref5.key;
+              return entity.key === key;
+            });
+
+            // Remove if already mark as removed
+            if (prevEntity && prevEntity.status === STATUS_REMOVED && entity.status === STATUS_REMOVE) {
+              return false;
+            }
+            return true;
+          })
+        };
+      }
+    }]);
+    return CSSMotionList;
+  }(React.Component);
+  _defineProperty(CSSMotionList, "defaultProps", {
+    component: 'div'
+  });
+  return CSSMotionList;
+}
+export default genCSSMotionList(supportTransition);

node_modules/rc-motion/es/DomWrapper.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface DomWrapperProps {
+    children: React.ReactNode;
+}
+declare class DomWrapper extends React.Component<DomWrapperProps> {
+    render(): React.ReactNode;
+}
+export default DomWrapper;

node_modules/rc-motion/es/DomWrapper.js

@@ -0,0 +1,21 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import * as React from 'react';
+var DomWrapper = /*#__PURE__*/function (_React$Component) {
+  _inherits(DomWrapper, _React$Component);
+  var _super = _createSuper(DomWrapper);
+  function DomWrapper() {
+    _classCallCheck(this, DomWrapper);
+    return _super.apply(this, arguments);
+  }
+  _createClass(DomWrapper, [{
+    key: "render",
+    value: function render() {
+      return this.props.children;
+    }
+  }]);
+  return DomWrapper;
+}(React.Component);
+export default DomWrapper;

node_modules/rc-motion/es/context.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface MotionContextProps {
+    motion?: boolean;
+}
+export declare const Context: React.Context<MotionContextProps>;
+export default function MotionProvider({ children, ...props }: MotionContextProps & {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+export {};

node_modules/rc-motion/es/context.js

@@ -0,0 +1,11 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children"];
+import * as React from 'react';
+export var Context = /*#__PURE__*/React.createContext({});
+export default function MotionProvider(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement(Context.Provider, {
+    value: props
+  }, children);
+}

node_modules/rc-motion/es/hooks/useDomMotionEvents.d.ts

@@ -0,0 +1,3 @@
+import type { MotionEvent } from '../interface';
+declare const _default: (onInternalMotionEnd: (event: MotionEvent) => void) => [(element: HTMLElement) => void, (element: HTMLElement) => void];
+export default _default;

node_modules/rc-motion/es/hooks/useDomMotionEvents.js

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { useRef } from 'react';
+import { animationEndName, transitionEndName } from "../util/motion";
+export default (function (onInternalMotionEnd) {
+  var cacheElementRef = useRef();
+
+  // Remove events
+  function removeMotionEvents(element) {
+    if (element) {
+      element.removeEventListener(transitionEndName, onInternalMotionEnd);
+      element.removeEventListener(animationEndName, onInternalMotionEnd);
+    }
+  }
+
+  // Patch events
+  function patchMotionEvents(element) {
+    if (cacheElementRef.current && cacheElementRef.current !== element) {
+      removeMotionEvents(cacheElementRef.current);
+    }
+    if (element && element !== cacheElementRef.current) {
+      element.addEventListener(transitionEndName, onInternalMotionEnd);
+      element.addEventListener(animationEndName, onInternalMotionEnd);
+
+      // Save as cache in case dom removed trigger by `motionDeadline`
+      cacheElementRef.current = element;
+    }
+  }
+
+  // Clean up when removed
+  React.useEffect(function () {
+    return function () {
+      removeMotionEvents(cacheElementRef.current);
+    };
+  }, []);
+  return [patchMotionEvents, removeMotionEvents];
+});

node_modules/rc-motion/es/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+export default useIsomorphicLayoutEffect;

node_modules/rc-motion/es/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,6 @@
+import canUseDom from "rc-util/es/Dom/canUseDom";
+import { useEffect, useLayoutEffect } from 'react';
+
+// It's safe to use `useLayoutEffect` but the warning is annoying
+var useIsomorphicLayoutEffect = canUseDom() ? useLayoutEffect : useEffect;
+export default useIsomorphicLayoutEffect;

node_modules/rc-motion/es/hooks/useNextFrame.d.ts

@@ -0,0 +1,4 @@
+declare const _default: () => [(callback: (info: {
+    isCanceled: () => boolean;
+}) => void) => void, () => void];
+export default _default;

node_modules/rc-motion/es/hooks/useNextFrame.js

@@ -0,0 +1,30 @@
+import raf from "rc-util/es/raf";
+import * as React from 'react';
+export default (function () {
+  var nextFrameRef = React.useRef(null);
+  function cancelNextFrame() {
+    raf.cancel(nextFrameRef.current);
+  }
+  function nextFrame(callback) {
+    var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+    cancelNextFrame();
+    var nextFrameId = raf(function () {
+      if (delay <= 1) {
+        callback({
+          isCanceled: function isCanceled() {
+            return nextFrameId !== nextFrameRef.current;
+          }
+        });
+      } else {
+        nextFrame(callback, delay - 1);
+      }
+    });
+    nextFrameRef.current = nextFrameId;
+  }
+  React.useEffect(function () {
+    return function () {
+      cancelNextFrame();
+    };
+  }, []);
+  return [nextFrame, cancelNextFrame];
+});

node_modules/rc-motion/es/hooks/useStatus.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { CSSMotionProps } from '../CSSMotion';
+import type { MotionStatus, StepStatus } from '../interface';
+export default function useStatus(supportMotion: boolean, visible: boolean, getElement: () => HTMLElement, { motionEnter, motionAppear, motionLeave, motionDeadline, motionLeaveImmediately, onAppearPrepare, onEnterPrepare, onLeavePrepare, onAppearStart, onEnterStart, onLeaveStart, onAppearActive, onEnterActive, onLeaveActive, onAppearEnd, onEnterEnd, onLeaveEnd, onVisibleChanged, }: CSSMotionProps): [MotionStatus, StepStatus, React.CSSProperties, boolean];

node_modules/rc-motion/es/hooks/useStatus.js

@@ -0,0 +1,246 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEvent } from 'rc-util';
+import useState from "rc-util/es/hooks/useState";
+import useSyncState from "rc-util/es/hooks/useSyncState";
+import * as React from 'react';
+import { useEffect, useRef } from 'react';
+import { STATUS_APPEAR, STATUS_ENTER, STATUS_LEAVE, STATUS_NONE, STEP_ACTIVE, STEP_PREPARE, STEP_PREPARED, STEP_START } from "../interface";
+import useDomMotionEvents from "./useDomMotionEvents";
+import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect";
+import useStepQueue, { DoStep, isActive, SkipStep } from "./useStepQueue";
+export default function useStatus(supportMotion, visible, getElement, _ref) {
+  var _ref$motionEnter = _ref.motionEnter,
+    motionEnter = _ref$motionEnter === void 0 ? true : _ref$motionEnter,
+    _ref$motionAppear = _ref.motionAppear,
+    motionAppear = _ref$motionAppear === void 0 ? true : _ref$motionAppear,
+    _ref$motionLeave = _ref.motionLeave,
+    motionLeave = _ref$motionLeave === void 0 ? true : _ref$motionLeave,
+    motionDeadline = _ref.motionDeadline,
+    motionLeaveImmediately = _ref.motionLeaveImmediately,
+    onAppearPrepare = _ref.onAppearPrepare,
+    onEnterPrepare = _ref.onEnterPrepare,
+    onLeavePrepare = _ref.onLeavePrepare,
+    onAppearStart = _ref.onAppearStart,
+    onEnterStart = _ref.onEnterStart,
+    onLeaveStart = _ref.onLeaveStart,
+    onAppearActive = _ref.onAppearActive,
+    onEnterActive = _ref.onEnterActive,
+    onLeaveActive = _ref.onLeaveActive,
+    onAppearEnd = _ref.onAppearEnd,
+    onEnterEnd = _ref.onEnterEnd,
+    onLeaveEnd = _ref.onLeaveEnd,
+    onVisibleChanged = _ref.onVisibleChanged;
+  // Used for outer render usage to avoid `visible: false & status: none` to render nothing
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    asyncVisible = _useState2[0],
+    setAsyncVisible = _useState2[1];
+  var _useSyncState = useSyncState(STATUS_NONE),
+    _useSyncState2 = _slicedToArray(_useSyncState, 2),
+    getStatus = _useSyncState2[0],
+    setStatus = _useSyncState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    style = _useState4[0],
+    setStyle = _useState4[1];
+  var currentStatus = getStatus();
+  var mountedRef = useRef(false);
+  var deadlineRef = useRef(null);
+
+  // =========================== Dom Node ===========================
+  function getDomElement() {
+    return getElement();
+  }
+
+  // ========================== Motion End ==========================
+  var activeRef = useRef(false);
+
+  /**
+   * Clean up status & style
+   */
+  function updateMotionEndStatus() {
+    setStatus(STATUS_NONE);
+    setStyle(null, true);
+  }
+  var onInternalMotionEnd = useEvent(function (event) {
+    var status = getStatus();
+    // Do nothing since not in any transition status.
+    // This may happen when `motionDeadline` trigger.
+    if (status === STATUS_NONE) {
+      return;
+    }
+    var element = getDomElement();
+    if (event && !event.deadline && event.target !== element) {
+      // event exists
+      // not initiated by deadline
+      // transitionEnd not fired by inner elements
+      return;
+    }
+    var currentActive = activeRef.current;
+    var canEnd;
+    if (status === STATUS_APPEAR && currentActive) {
+      canEnd = onAppearEnd === null || onAppearEnd === void 0 ? void 0 : onAppearEnd(element, event);
+    } else if (status === STATUS_ENTER && currentActive) {
+      canEnd = onEnterEnd === null || onEnterEnd === void 0 ? void 0 : onEnterEnd(element, event);
+    } else if (status === STATUS_LEAVE && currentActive) {
+      canEnd = onLeaveEnd === null || onLeaveEnd === void 0 ? void 0 : onLeaveEnd(element, event);
+    }
+
+    // Only update status when `canEnd` and not destroyed
+    if (currentActive && canEnd !== false) {
+      updateMotionEndStatus();
+    }
+  });
+  var _useDomMotionEvents = useDomMotionEvents(onInternalMotionEnd),
+    _useDomMotionEvents2 = _slicedToArray(_useDomMotionEvents, 1),
+    patchMotionEvents = _useDomMotionEvents2[0];
+
+  // ============================= Step =============================
+  var getEventHandlers = function getEventHandlers(targetStatus) {
+    switch (targetStatus) {
+      case STATUS_APPEAR:
+        return _defineProperty(_defineProperty(_defineProperty({}, STEP_PREPARE, onAppearPrepare), STEP_START, onAppearStart), STEP_ACTIVE, onAppearActive);
+      case STATUS_ENTER:
+        return _defineProperty(_defineProperty(_defineProperty({}, STEP_PREPARE, onEnterPrepare), STEP_START, onEnterStart), STEP_ACTIVE, onEnterActive);
+      case STATUS_LEAVE:
+        return _defineProperty(_defineProperty(_defineProperty({}, STEP_PREPARE, onLeavePrepare), STEP_START, onLeaveStart), STEP_ACTIVE, onLeaveActive);
+      default:
+        return {};
+    }
+  };
+  var eventHandlers = React.useMemo(function () {
+    return getEventHandlers(currentStatus);
+  }, [currentStatus]);
+  var _useStepQueue = useStepQueue(currentStatus, !supportMotion, function (newStep) {
+      // Only prepare step can be skip
+      if (newStep === STEP_PREPARE) {
+        var onPrepare = eventHandlers[STEP_PREPARE];
+        if (!onPrepare) {
+          return SkipStep;
+        }
+        return onPrepare(getDomElement());
+      }
+
+      // Rest step is sync update
+      if (step in eventHandlers) {
+        var _eventHandlers$step;
+        setStyle(((_eventHandlers$step = eventHandlers[step]) === null || _eventHandlers$step === void 0 ? void 0 : _eventHandlers$step.call(eventHandlers, getDomElement(), null)) || null);
+      }
+      if (step === STEP_ACTIVE && currentStatus !== STATUS_NONE) {
+        // Patch events when motion needed
+        patchMotionEvents(getDomElement());
+        if (motionDeadline > 0) {
+          clearTimeout(deadlineRef.current);
+          deadlineRef.current = setTimeout(function () {
+            onInternalMotionEnd({
+              deadline: true
+            });
+          }, motionDeadline);
+        }
+      }
+      if (step === STEP_PREPARED) {
+        updateMotionEndStatus();
+      }
+      return DoStep;
+    }),
+    _useStepQueue2 = _slicedToArray(_useStepQueue, 2),
+    startStep = _useStepQueue2[0],
+    step = _useStepQueue2[1];
+  var active = isActive(step);
+  activeRef.current = active;
+
+  // ============================ Status ============================
+  var visibleRef = useRef(null);
+
+  // Update with new status
+  useIsomorphicLayoutEffect(function () {
+    // When use Suspense, the `visible` will repeat trigger,
+    // But not real change of the `visible`, we need to skip it.
+    // https://github.com/ant-design/ant-design/issues/44379
+    if (mountedRef.current && visibleRef.current === visible) {
+      return;
+    }
+    setAsyncVisible(visible);
+    var isMounted = mountedRef.current;
+    mountedRef.current = true;
+
+    // if (!supportMotion) {
+    //   return;
+    // }
+
+    var nextStatus;
+
+    // Appear
+    if (!isMounted && visible && motionAppear) {
+      nextStatus = STATUS_APPEAR;
+    }
+
+    // Enter
+    if (isMounted && visible && motionEnter) {
+      nextStatus = STATUS_ENTER;
+    }
+
+    // Leave
+    if (isMounted && !visible && motionLeave || !isMounted && motionLeaveImmediately && !visible && motionLeave) {
+      nextStatus = STATUS_LEAVE;
+    }
+    var nextEventHandlers = getEventHandlers(nextStatus);
+
+    // Update to next status
+    if (nextStatus && (supportMotion || nextEventHandlers[STEP_PREPARE])) {
+      setStatus(nextStatus);
+      startStep();
+    } else {
+      // Set back in case no motion but prev status has prepare step
+      setStatus(STATUS_NONE);
+    }
+    visibleRef.current = visible;
+  }, [visible]);
+
+  // ============================ Effect ============================
+  // Reset when motion changed
+  useEffect(function () {
+    if (
+    // Cancel appear
+    currentStatus === STATUS_APPEAR && !motionAppear ||
+    // Cancel enter
+    currentStatus === STATUS_ENTER && !motionEnter ||
+    // Cancel leave
+    currentStatus === STATUS_LEAVE && !motionLeave) {
+      setStatus(STATUS_NONE);
+    }
+  }, [motionAppear, motionEnter, motionLeave]);
+  useEffect(function () {
+    return function () {
+      mountedRef.current = false;
+      clearTimeout(deadlineRef.current);
+    };
+  }, []);
+
+  // Trigger `onVisibleChanged`
+  var firstMountChangeRef = React.useRef(false);
+  useEffect(function () {
+    // [visible & motion not end] => [!visible & motion end] still need trigger onVisibleChanged
+    if (asyncVisible) {
+      firstMountChangeRef.current = true;
+    }
+    if (asyncVisible !== undefined && currentStatus === STATUS_NONE) {
+      // Skip first render is invisible since it's nothing changed
+      if (firstMountChangeRef.current || asyncVisible) {
+        onVisibleChanged === null || onVisibleChanged === void 0 || onVisibleChanged(asyncVisible);
+      }
+      firstMountChangeRef.current = true;
+    }
+  }, [asyncVisible, currentStatus]);
+
+  // ============================ Styles ============================
+  var mergedStyle = style;
+  if (eventHandlers[STEP_PREPARE] && step === STEP_START) {
+    mergedStyle = _objectSpread({
+      transition: 'none'
+    }, mergedStyle);
+  }
+  return [currentStatus, step, mergedStyle, asyncVisible !== null && asyncVisible !== void 0 ? asyncVisible : visible];
+}

node_modules/rc-motion/es/hooks/useStepQueue.d.ts

@@ -0,0 +1,8 @@
+import type { MotionStatus, StepStatus } from '../interface';
+/** Skip current step */
+export declare const SkipStep: false;
+/** Current step should be update in */
+export declare const DoStep: true;
+export declare function isActive(step: StepStatus): boolean;
+declare const _default: (status: MotionStatus, prepareOnly: boolean, callback: (step: StepStatus) => Promise<void> | void | typeof SkipStep | typeof DoStep) => [() => void, StepStatus];
+export default _default;

node_modules/rc-motion/es/hooks/useStepQueue.js

@@ -0,0 +1,62 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import useState from "rc-util/es/hooks/useState";
+import * as React from 'react';
+import { STEP_ACTIVATED, STEP_ACTIVE, STEP_NONE, STEP_PREPARE, STEP_PREPARED, STEP_START } from "../interface";
+import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect";
+import useNextFrame from "./useNextFrame";
+var FULL_STEP_QUEUE = [STEP_PREPARE, STEP_START, STEP_ACTIVE, STEP_ACTIVATED];
+var SIMPLE_STEP_QUEUE = [STEP_PREPARE, STEP_PREPARED];
+
+/** Skip current step */
+export var SkipStep = false;
+/** Current step should be update in */
+export var DoStep = true;
+export function isActive(step) {
+  return step === STEP_ACTIVE || step === STEP_ACTIVATED;
+}
+export default (function (status, prepareOnly, callback) {
+  var _useState = useState(STEP_NONE),
+    _useState2 = _slicedToArray(_useState, 2),
+    step = _useState2[0],
+    setStep = _useState2[1];
+  var _useNextFrame = useNextFrame(),
+    _useNextFrame2 = _slicedToArray(_useNextFrame, 2),
+    nextFrame = _useNextFrame2[0],
+    cancelNextFrame = _useNextFrame2[1];
+  function startQueue() {
+    setStep(STEP_PREPARE, true);
+  }
+  var STEP_QUEUE = prepareOnly ? SIMPLE_STEP_QUEUE : FULL_STEP_QUEUE;
+  useIsomorphicLayoutEffect(function () {
+    if (step !== STEP_NONE && step !== STEP_ACTIVATED) {
+      var index = STEP_QUEUE.indexOf(step);
+      var nextStep = STEP_QUEUE[index + 1];
+      var result = callback(step);
+      if (result === SkipStep) {
+        // Skip when no needed
+        setStep(nextStep, true);
+      } else if (nextStep) {
+        // Do as frame for step update
+        nextFrame(function (info) {
+          function doNext() {
+            // Skip since current queue is ood
+            if (info.isCanceled()) return;
+            setStep(nextStep, true);
+          }
+          if (result === true) {
+            doNext();
+          } else {
+            // Only promise should be async
+            Promise.resolve(result).then(doNext);
+          }
+        });
+      }
+    }
+  }, [status, step]);
+  React.useEffect(function () {
+    return function () {
+      cancelNextFrame();
+    };
+  }, []);
+  return [startQueue, step];
+});

node_modules/rc-motion/es/index.d.ts

@@ -0,0 +1,9 @@
+import type { CSSMotionProps } from './CSSMotion';
+import CSSMotion from './CSSMotion';
+import type { CSSMotionListProps } from './CSSMotionList';
+import CSSMotionList from './CSSMotionList';
+import type { MotionEndEventHandler, MotionEventHandler } from './interface';
+export { default as Provider } from './context';
+export { CSSMotionList };
+export type { CSSMotionProps, CSSMotionListProps, MotionEventHandler, MotionEndEventHandler, };
+export default CSSMotion;

node_modules/rc-motion/es/index.js

@@ -0,0 +1,5 @@
+import CSSMotion from "./CSSMotion";
+import CSSMotionList from "./CSSMotionList";
+export { default as Provider } from "./context";
+export { CSSMotionList };
+export default CSSMotion;

node_modules/rc-motion/es/interface.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+export declare const STATUS_NONE: "none";
+export declare const STATUS_APPEAR: "appear";
+export declare const STATUS_ENTER: "enter";
+export declare const STATUS_LEAVE: "leave";
+export type MotionStatus = typeof STATUS_NONE | typeof STATUS_APPEAR | typeof STATUS_ENTER | typeof STATUS_LEAVE;
+export declare const STEP_NONE: "none";
+export declare const STEP_PREPARE: "prepare";
+export declare const STEP_START: "start";
+export declare const STEP_ACTIVE: "active";
+export declare const STEP_ACTIVATED: "end";
+/**
+ * Used for disabled motion case.
+ * Prepare stage will still work but start & active will be skipped.
+ */
+export declare const STEP_PREPARED: "prepared";
+export type StepStatus = typeof STEP_NONE | typeof STEP_PREPARE | typeof STEP_START | typeof STEP_ACTIVE | typeof STEP_ACTIVATED | typeof STEP_PREPARED;
+export type MotionEvent = (TransitionEvent | AnimationEvent) & {
+    deadline?: boolean;
+};
+export type MotionPrepareEventHandler = (element: HTMLElement) => Promise<any> | void;
+export type MotionEventHandler = (element: HTMLElement, event: MotionEvent) => React.CSSProperties | void;
+export type MotionEndEventHandler = (element: HTMLElement, event: MotionEvent) => boolean | void;

node_modules/rc-motion/es/interface.js

@@ -0,0 +1,14 @@
+export var STATUS_NONE = 'none';
+export var STATUS_APPEAR = 'appear';
+export var STATUS_ENTER = 'enter';
+export var STATUS_LEAVE = 'leave';
+export var STEP_NONE = 'none';
+export var STEP_PREPARE = 'prepare';
+export var STEP_START = 'start';
+export var STEP_ACTIVE = 'active';
+export var STEP_ACTIVATED = 'end';
+/**
+ * Used for disabled motion case.
+ * Prepare stage will still work but start & active will be skipped.
+ */
+export var STEP_PREPARED = 'prepared';

node_modules/rc-motion/es/util/diff.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+export declare const STATUS_ADD: "add";
+export declare const STATUS_KEEP: "keep";
+export declare const STATUS_REMOVE: "remove";
+export declare const STATUS_REMOVED: "removed";
+export type DiffStatus = typeof STATUS_ADD | typeof STATUS_KEEP | typeof STATUS_REMOVE | typeof STATUS_REMOVED;
+type RawKeyType = string | number;
+export interface KeyObject {
+    key: RawKeyType;
+    status?: DiffStatus;
+}
+export declare function wrapKeyToObject(key: React.Key | KeyObject): {
+    key: string;
+    status?: DiffStatus;
+};
+export declare function parseKeys(keys?: any[]): {
+    key: string;
+    status?: DiffStatus;
+}[];
+export declare function diffKeys(prevKeys?: KeyObject[], currentKeys?: KeyObject[]): KeyObject[];
+export {};

node_modules/rc-motion/es/util/diff.js

@@ -0,0 +1,103 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+export var STATUS_ADD = 'add';
+export var STATUS_KEEP = 'keep';
+export var STATUS_REMOVE = 'remove';
+export var STATUS_REMOVED = 'removed';
+export function wrapKeyToObject(key) {
+  var keyObj;
+  if (key && _typeof(key) === 'object' && 'key' in key) {
+    keyObj = key;
+  } else {
+    keyObj = {
+      key: key
+    };
+  }
+  return _objectSpread(_objectSpread({}, keyObj), {}, {
+    key: String(keyObj.key)
+  });
+}
+export function parseKeys() {
+  var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return keys.map(wrapKeyToObject);
+}
+export function diffKeys() {
+  var prevKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var currentKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var list = [];
+  var currentIndex = 0;
+  var currentLen = currentKeys.length;
+  var prevKeyObjects = parseKeys(prevKeys);
+  var currentKeyObjects = parseKeys(currentKeys);
+
+  // Check prev keys to insert or keep
+  prevKeyObjects.forEach(function (keyObj) {
+    var hit = false;
+    for (var i = currentIndex; i < currentLen; i += 1) {
+      var currentKeyObj = currentKeyObjects[i];
+      if (currentKeyObj.key === keyObj.key) {
+        // New added keys should add before current key
+        if (currentIndex < i) {
+          list = list.concat(currentKeyObjects.slice(currentIndex, i).map(function (obj) {
+            return _objectSpread(_objectSpread({}, obj), {}, {
+              status: STATUS_ADD
+            });
+          }));
+          currentIndex = i;
+        }
+        list.push(_objectSpread(_objectSpread({}, currentKeyObj), {}, {
+          status: STATUS_KEEP
+        }));
+        currentIndex += 1;
+        hit = true;
+        break;
+      }
+    }
+
+    // If not hit, it means key is removed
+    if (!hit) {
+      list.push(_objectSpread(_objectSpread({}, keyObj), {}, {
+        status: STATUS_REMOVE
+      }));
+    }
+  });
+
+  // Add rest to the list
+  if (currentIndex < currentLen) {
+    list = list.concat(currentKeyObjects.slice(currentIndex).map(function (obj) {
+      return _objectSpread(_objectSpread({}, obj), {}, {
+        status: STATUS_ADD
+      });
+    }));
+  }
+
+  /**
+   * Merge same key when it remove and add again:
+   *    [1 - add, 2 - keep, 1 - remove] -> [1 - keep, 2 - keep]
+   */
+  var keys = {};
+  list.forEach(function (_ref) {
+    var key = _ref.key;
+    keys[key] = (keys[key] || 0) + 1;
+  });
+  var duplicatedKeys = Object.keys(keys).filter(function (key) {
+    return keys[key] > 1;
+  });
+  duplicatedKeys.forEach(function (matchKey) {
+    // Remove `STATUS_REMOVE` node.
+    list = list.filter(function (_ref2) {
+      var key = _ref2.key,
+        status = _ref2.status;
+      return key !== matchKey || status !== STATUS_REMOVE;
+    });
+
+    // Update `STATUS_ADD` to `STATUS_KEEP`
+    list.forEach(function (node) {
+      if (node.key === matchKey) {
+        // eslint-disable-next-line no-param-reassign
+        node.status = STATUS_KEEP;
+      }
+    });
+  });
+  return list;
+}

node_modules/rc-motion/es/util/motion.d.ts

@@ -0,0 +1,10 @@
+import { MotionName } from '../CSSMotion';
+export declare function getVendorPrefixes(domSupport: boolean, win: object): {
+    animationend: Record<string, string>;
+    transitionend: Record<string, string>;
+};
+export declare function getVendorPrefixedEventName(eventName: string): any;
+export declare const supportTransition: boolean;
+export declare const animationEndName: any;
+export declare const transitionEndName: any;
+export declare function getTransitionName(transitionName: MotionName, transitionType: string): any;

node_modules/rc-motion/es/util/motion.js

@@ -0,0 +1,68 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import canUseDOM from "rc-util/es/Dom/canUseDom";
+// ================= Transition =================
+// Event wrapper. Copy from react source code
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit".concat(styleProp)] = "webkit".concat(eventName);
+  prefixes["Moz".concat(styleProp)] = "moz".concat(eventName);
+  prefixes["ms".concat(styleProp)] = "MS".concat(eventName);
+  prefixes["O".concat(styleProp)] = "o".concat(eventName.toLowerCase());
+  return prefixes;
+}
+export function getVendorPrefixes(domSupport, win) {
+  var prefixes = {
+    animationend: makePrefixMap('Animation', 'AnimationEnd'),
+    transitionend: makePrefixMap('Transition', 'TransitionEnd')
+  };
+  if (domSupport) {
+    if (!('AnimationEvent' in win)) {
+      delete prefixes.animationend.animation;
+    }
+    if (!('TransitionEvent' in win)) {
+      delete prefixes.transitionend.transition;
+    }
+  }
+  return prefixes;
+}
+var vendorPrefixes = getVendorPrefixes(canUseDOM(), typeof window !== 'undefined' ? window : {});
+var style = {};
+if (canUseDOM()) {
+  var _document$createEleme = document.createElement('div');
+  style = _document$createEleme.style;
+}
+var prefixedEventNames = {};
+export function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  }
+  var prefixMap = vendorPrefixes[eventName];
+  if (prefixMap) {
+    var stylePropList = Object.keys(prefixMap);
+    var len = stylePropList.length;
+    for (var i = 0; i < len; i += 1) {
+      var styleProp = stylePropList[i];
+      if (Object.prototype.hasOwnProperty.call(prefixMap, styleProp) && styleProp in style) {
+        prefixedEventNames[eventName] = prefixMap[styleProp];
+        return prefixedEventNames[eventName];
+      }
+    }
+  }
+  return '';
+}
+var internalAnimationEndName = getVendorPrefixedEventName('animationend');
+var internalTransitionEndName = getVendorPrefixedEventName('transitionend');
+export var supportTransition = !!(internalAnimationEndName && internalTransitionEndName);
+export var animationEndName = internalAnimationEndName || 'animationend';
+export var transitionEndName = internalTransitionEndName || 'transitionend';
+export function getTransitionName(transitionName, transitionType) {
+  if (!transitionName) return null;
+  if (_typeof(transitionName) === 'object') {
+    var type = transitionType.replace(/-\w/g, function (match) {
+      return match[1].toUpperCase();
+    });
+    return transitionName[type];
+  }
+  return "".concat(transitionName, "-").concat(transitionType);
+}