add all frontend files

node_modules/rc-motion/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-present afc163
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/rc-motion/README.md

@@ -0,0 +1,95 @@
+# rc-motion
+
+<!-- prettier-ignore -->
+[![NPM version][npm-image]][npm-url]
+[![npm download][download-image]][download-url]
+[![build status][github-actions-image]][github-actions-url]
+[![Codecov][codecov-image]][codecov-url]
+[![bundle size][bundlephobia-image]][bundlephobia-url]
+[![dumi][dumi-image]][dumi-url]
+
+[npm-image]: http://img.shields.io/npm/v/rc-motion.svg?style=flat-square
+[npm-url]: http://npmjs.org/package/rc-motion
+[travis-image]: https://img.shields.io/travis/react-component/motion/master?style=flat-square
+[travis-url]: https://travis-ci.com/react-component/motion
+[github-actions-image]: https://github.com/react-component/motion/workflows/CI/badge.svg
+[github-actions-url]: https://github.com/react-component/motion/actions
+[codecov-image]: https://img.shields.io/codecov/c/github/react-component/motion/master.svg?style=flat-square
+[codecov-url]: https://app.codecov.io/gh/react-component/motion
+[david-url]: https://david-dm.org/react-component/motion
+[david-image]: https://david-dm.org/react-component/motion/status.svg?style=flat-square
+[david-dev-url]: https://david-dm.org/react-component/motion?type=dev
+[david-dev-image]: https://david-dm.org/react-component/motion/dev-status.svg?style=flat-square
+[download-image]: https://img.shields.io/npm/dm/rc-motion.svg?style=flat-square
+[download-url]: https://npmjs.org/package/rc-motion
+[bundlephobia-url]: https://bundlephobia.com/package/rc-motion
+[bundlephobia-image]: https://badgen.net/bundlephobia/minzip/rc-motion
+[dumi-url]: https://github.com/umijs/dumi
+[dumi-image]: https://img.shields.io/badge/docs%20by-dumi-blue?style=flat-square
+
+React lifecycle controlled motion library.
+
+## Live Demo
+
+https://react-component.github.io/motion/
+
+## Install
+
+[![rc-motion](https://nodei.co/npm/rc-motion.png)](https://npmjs.org/package/rc-motion)
+
+## Example
+
+```js
+import CSSMotion from 'rc-motion';
+
+export default ({ visible }) => (
+  <CSSMotion visible={visible} motionName="my-motion">
+    {({ className, style }) => <div className={className} style={style} />}
+  </CSSMotion>
+);
+```
+
+## API
+
+### CSSMotion
+
+| Property | Type | Default | Description |
+| --- | --- | --- | --- |
+| motionName | string | - | Config motion name, will dynamic update when status changed |
+| visible | boolean | true | Trigger motion events |
+| motionAppear | boolean | true | Use motion when appear |
+| motionEnter | boolean | true | Use motion when enter |
+| motionLeave | boolean | true | Use motion when leave |
+| motionLeaveImmediately | boolean | - | Will trigger leave even on mount |
+| motionDeadline | number | - | Trigger motion status change even when motion event not fire |
+| removeOnLeave | boolean | true | Remove element when motion leave end |
+| leavedClassName | string | - | Set leaved element className |
+| onAppearStart | (HTMLElement, Event) => CSSProperties \| void; | - | Trigger when appear start, return style will patch to element |
+| onEnterStart | (HTMLElement, Event) => CSSProperties \| void; | - | Trigger when enter start, return style will patch to element |
+| onLeaveStart | (HTMLElement, Event) => CSSProperties \| void; | - | Trigger when leave start, return style will patch to element |
+| onAppearActive | (HTMLElement, Event) => CSSProperties \| void; | - | Trigger when appear active, return style will patch to element |
+| onEnterActive | (HTMLElement, Event) => CSSProperties \| void; | - | Trigger when enter active, return style will patch to element |
+| onLeaveActive | (HTMLElement, Event) => CSSProperties \| void; | - | Trigger when leave active, return style will patch to element |
+| onAppearEnd | (HTMLElement, Event) => boolean \| void; | - | Trigger when appear end, will not finish when return false |
+| onEnterEnd | (HTMLElement, Event) => boolean \| void; | - | Trigger when enter end, will not finish when return false |
+| onLeaveEnd | (HTMLElement, Event) => boolean \| void; | - | Trigger when leave end, will not finish when return false |
+
+### CSSMotionList
+
+extends all the props from [CSSMotion](#CSSMotion)
+
+| Property  | Type                          | Default | Description       |
+| --------- | ----------------------------- | ------- | ----------------- |
+| keys      | React.Key[]                   | -       | Motion list keys  |
+| component | string \| React.ComponentType | div     | wrapper component |
+
+## Development
+
+```
+npm install
+npm start
+```
+
+## License
+
+rc-motion is released under the MIT license.

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);
+}

node_modules/rc-motion/lib/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/lib/CSSMotion.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.genCSSMotion = genCSSMotion;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _findDOMNode = _interopRequireDefault(require("rc-util/lib/Dom/findDOMNode"));
+var _ref = require("rc-util/lib/ref");
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _context = require("./context");
+var _DomWrapper = _interopRequireDefault(require("./DomWrapper"));
+var _useStatus3 = _interopRequireDefault(require("./hooks/useStatus"));
+var _useStepQueue = require("./hooks/useStepQueue");
+var _interface = require("./interface");
+var _motion = require("./util/motion");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/* eslint-disable react/default-props-match-prop-types, react/no-multi-comp, react/prop-types */
+
+/**
+ * `transitionSupport` is used for none transition test case.
+ * Default we use browser transition event support check.
+ */
+function genCSSMotion(config) {
+  var transitionSupport = config;
+  if ((0, _typeof2.default)(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.Context),
+      contextMotion = _React$useContext.motion;
+    var supportMotion = isSupportTransition(props, contextMotion);
+
+    // Ref to the react node, it may be a HTMLElement
+    var nodeRef = (0, _react.useRef)();
+    // Ref to the dom wrapper in case ref can not pass to HTMLElement
+    var wrapperNodeRef = (0, _react.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 : (0, _findDOMNode.default)(wrapperNodeRef.current);
+      } catch (e) {
+        // Only happen when `motionDeadline` trigger but element removed.
+        return null;
+      }
+    }
+    var _useStatus = (0, _useStatus3.default)(supportMotion, visible, getDomElement, props),
+      _useStatus2 = (0, _slicedToArray2.default)(_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;
+      (0, _ref.fillRef)(ref, node);
+    }, [ref]);
+
+    // ===================== Render =====================
+    var motionChildren;
+    var mergedProps = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, eventProps), {}, {
+      visible: visible
+    });
+    if (!children) {
+      // No children
+      motionChildren = null;
+    } else if (status === _interface.STATUS_NONE) {
+      // Stable children
+      if (mergedVisible) {
+        motionChildren = children((0, _objectSpread2.default)({}, mergedProps), setNodeRef);
+      } else if (!removeOnLeave && renderedRef.current && leavedClassName) {
+        motionChildren = children((0, _objectSpread2.default)((0, _objectSpread2.default)({}, mergedProps), {}, {
+          className: leavedClassName
+        }), setNodeRef);
+      } else if (forceRender || !removeOnLeave && !leavedClassName) {
+        motionChildren = children((0, _objectSpread2.default)((0, _objectSpread2.default)({}, mergedProps), {}, {
+          style: {
+            display: 'none'
+          }
+        }), setNodeRef);
+      } else {
+        motionChildren = null;
+      }
+    } else {
+      // In motion
+      var statusSuffix;
+      if (statusStep === _interface.STEP_PREPARE) {
+        statusSuffix = 'prepare';
+      } else if ((0, _useStepQueue.isActive)(statusStep)) {
+        statusSuffix = 'active';
+      } else if (statusStep === _interface.STEP_START) {
+        statusSuffix = 'start';
+      }
+      var motionCls = (0, _motion.getTransitionName)(motionName, "".concat(status, "-").concat(statusSuffix));
+      motionChildren = children((0, _objectSpread2.default)((0, _objectSpread2.default)({}, mergedProps), {}, {
+        className: (0, _classnames.default)((0, _motion.getTransitionName)(motionName, status), (0, _defineProperty2.default)((0, _defineProperty2.default)({}, 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) && (0, _ref.supportRef)(motionChildren)) {
+      var originNodeRef = (0, _ref.getNodeRef)(motionChildren);
+      if (!originNodeRef) {
+        motionChildren = /*#__PURE__*/React.cloneElement(motionChildren, {
+          ref: setNodeRef
+        });
+      }
+    }
+    return /*#__PURE__*/React.createElement(_DomWrapper.default, {
+      ref: wrapperNodeRef
+    }, motionChildren);
+  });
+  CSSMotion.displayName = 'CSSMotion';
+  return CSSMotion;
+}
+var _default = exports.default = genCSSMotion(_motion.supportTransition);

node_modules/rc-motion/lib/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/lib/CSSMotionList.js

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.genCSSMotionList = genCSSMotionList;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var React = _interopRequireWildcard(require("react"));
+var _CSSMotion = _interopRequireDefault(require("./CSSMotion"));
+var _diff = require("./util/diff");
+var _motion = require("./util/motion");
+var _excluded = ["component", "children", "onVisibleChanged", "onAllRemoved"],
+  _excluded2 = ["status"];
+/* eslint react/prop-types: 0 */
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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
+ */
+function genCSSMotionList(transitionSupport) {
+  var CSSMotion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _CSSMotion.default;
+  var CSSMotionList = /*#__PURE__*/function (_React$Component) {
+    (0, _inherits2.default)(CSSMotionList, _React$Component);
+    var _super = (0, _createSuper2.default)(CSSMotionList);
+    function CSSMotionList() {
+      var _this;
+      (0, _classCallCheck2.default)(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));
+      (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "state", {
+        keyEntities: []
+      });
+      // ZombieJ: Return the count of rest keys. It's safe to refactor if need more info.
+      (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "removeKey", function (removeKey) {
+        _this.setState(function (prevState) {
+          var nextKeyEntities = prevState.keyEntities.map(function (entity) {
+            if (entity.key !== removeKey) return entity;
+            return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entity), {}, {
+              status: _diff.STATUS_REMOVED
+            });
+          });
+          return {
+            keyEntities: nextKeyEntities
+          };
+        }, function () {
+          var keyEntities = _this.state.keyEntities;
+          var restKeysCount = keyEntities.filter(function (_ref) {
+            var status = _ref.status;
+            return status !== _diff.STATUS_REMOVED;
+          }).length;
+          if (restKeysCount === 0 && _this.props.onAllRemoved) {
+            _this.props.onAllRemoved();
+          }
+        });
+      });
+      return _this;
+    }
+    (0, _createClass2.default)(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 = (0, _objectWithoutProperties2.default)(_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 = (0, _objectWithoutProperties2.default)(_ref2, _excluded2);
+          var visible = status === _diff.STATUS_ADD || status === _diff.STATUS_KEEP;
+          return /*#__PURE__*/React.createElement(CSSMotion, (0, _extends2.default)({}, 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+              index: index
+            }), ref);
+          });
+        }));
+      }
+    }], [{
+      key: "getDerivedStateFromProps",
+      value: function getDerivedStateFromProps(_ref3, _ref4) {
+        var keys = _ref3.keys;
+        var keyEntities = _ref4.keyEntities;
+        var parsedKeyObjects = (0, _diff.parseKeys)(keys);
+        var mixedKeyEntities = (0, _diff.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 === _diff.STATUS_REMOVED && entity.status === _diff.STATUS_REMOVE) {
+              return false;
+            }
+            return true;
+          })
+        };
+      }
+    }]);
+    return CSSMotionList;
+  }(React.Component);
+  (0, _defineProperty2.default)(CSSMotionList, "defaultProps", {
+    component: 'div'
+  });
+  return CSSMotionList;
+}
+var _default = exports.default = genCSSMotionList(_motion.supportTransition);

node_modules/rc-motion/lib/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/lib/DomWrapper.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var DomWrapper = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(DomWrapper, _React$Component);
+  var _super = (0, _createSuper2.default)(DomWrapper);
+  function DomWrapper() {
+    (0, _classCallCheck2.default)(this, DomWrapper);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(DomWrapper, [{
+    key: "render",
+    value: function render() {
+      return this.props.children;
+    }
+  }]);
+  return DomWrapper;
+}(React.Component);
+var _default = exports.default = DomWrapper;

node_modules/rc-motion/lib/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/lib/context.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Context = void 0;
+exports.default = MotionProvider;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _excluded = ["children"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var Context = exports.Context = /*#__PURE__*/React.createContext({});
+function MotionProvider(_ref) {
+  var children = _ref.children,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  return /*#__PURE__*/React.createElement(Context.Provider, {
+    value: props
+  }, children);
+}

node_modules/rc-motion/lib/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/lib/hooks/useDomMotionEvents.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _motion = require("../util/motion");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = function _default(onInternalMotionEnd) {
+  var cacheElementRef = (0, _react.useRef)();
+
+  // Remove events
+  function removeMotionEvents(element) {
+    if (element) {
+      element.removeEventListener(_motion.transitionEndName, onInternalMotionEnd);
+      element.removeEventListener(_motion.animationEndName, onInternalMotionEnd);
+    }
+  }
+
+  // Patch events
+  function patchMotionEvents(element) {
+    if (cacheElementRef.current && cacheElementRef.current !== element) {
+      removeMotionEvents(cacheElementRef.current);
+    }
+    if (element && element !== cacheElementRef.current) {
+      element.addEventListener(_motion.transitionEndName, onInternalMotionEnd);
+      element.addEventListener(_motion.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/lib/hooks/useIsomorphicLayoutEffect.d.ts

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

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

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _canUseDom = _interopRequireDefault(require("rc-util/lib/Dom/canUseDom"));
+var _react = require("react");
+// It's safe to use `useLayoutEffect` but the warning is annoying
+var useIsomorphicLayoutEffect = (0, _canUseDom.default)() ? _react.useLayoutEffect : _react.useEffect;
+var _default = exports.default = useIsomorphicLayoutEffect;

node_modules/rc-motion/lib/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/lib/hooks/useNextFrame.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _raf = _interopRequireDefault(require("rc-util/lib/raf"));
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = function _default() {
+  var nextFrameRef = React.useRef(null);
+  function cancelNextFrame() {
+    _raf.default.cancel(nextFrameRef.current);
+  }
+  function nextFrame(callback) {
+    var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+    cancelNextFrame();
+    var nextFrameId = (0, _raf.default)(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/lib/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/lib/hooks/useStatus.js

@@ -0,0 +1,256 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useStatus;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _rcUtil = require("rc-util");
+var _useState5 = _interopRequireDefault(require("rc-util/lib/hooks/useState"));
+var _useSyncState3 = _interopRequireDefault(require("rc-util/lib/hooks/useSyncState"));
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _interface = require("../interface");
+var _useDomMotionEvents3 = _interopRequireDefault(require("./useDomMotionEvents"));
+var _useIsomorphicLayoutEffect = _interopRequireDefault(require("./useIsomorphicLayoutEffect"));
+var _useStepQueue3 = _interopRequireWildcard(require("./useStepQueue"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 = (0, _useState5.default)(),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    asyncVisible = _useState2[0],
+    setAsyncVisible = _useState2[1];
+  var _useSyncState = (0, _useSyncState3.default)(_interface.STATUS_NONE),
+    _useSyncState2 = (0, _slicedToArray2.default)(_useSyncState, 2),
+    getStatus = _useSyncState2[0],
+    setStatus = _useSyncState2[1];
+  var _useState3 = (0, _useState5.default)(null),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    style = _useState4[0],
+    setStyle = _useState4[1];
+  var currentStatus = getStatus();
+  var mountedRef = (0, _react.useRef)(false);
+  var deadlineRef = (0, _react.useRef)(null);
+
+  // =========================== Dom Node ===========================
+  function getDomElement() {
+    return getElement();
+  }
+
+  // ========================== Motion End ==========================
+  var activeRef = (0, _react.useRef)(false);
+
+  /**
+   * Clean up status & style
+   */
+  function updateMotionEndStatus() {
+    setStatus(_interface.STATUS_NONE);
+    setStyle(null, true);
+  }
+  var onInternalMotionEnd = (0, _rcUtil.useEvent)(function (event) {
+    var status = getStatus();
+    // Do nothing since not in any transition status.
+    // This may happen when `motionDeadline` trigger.
+    if (status === _interface.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 === _interface.STATUS_APPEAR && currentActive) {
+      canEnd = onAppearEnd === null || onAppearEnd === void 0 ? void 0 : onAppearEnd(element, event);
+    } else if (status === _interface.STATUS_ENTER && currentActive) {
+      canEnd = onEnterEnd === null || onEnterEnd === void 0 ? void 0 : onEnterEnd(element, event);
+    } else if (status === _interface.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 = (0, _useDomMotionEvents3.default)(onInternalMotionEnd),
+    _useDomMotionEvents2 = (0, _slicedToArray2.default)(_useDomMotionEvents, 1),
+    patchMotionEvents = _useDomMotionEvents2[0];
+
+  // ============================= Step =============================
+  var getEventHandlers = function getEventHandlers(targetStatus) {
+    switch (targetStatus) {
+      case _interface.STATUS_APPEAR:
+        return (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _interface.STEP_PREPARE, onAppearPrepare), _interface.STEP_START, onAppearStart), _interface.STEP_ACTIVE, onAppearActive);
+      case _interface.STATUS_ENTER:
+        return (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _interface.STEP_PREPARE, onEnterPrepare), _interface.STEP_START, onEnterStart), _interface.STEP_ACTIVE, onEnterActive);
+      case _interface.STATUS_LEAVE:
+        return (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _interface.STEP_PREPARE, onLeavePrepare), _interface.STEP_START, onLeaveStart), _interface.STEP_ACTIVE, onLeaveActive);
+      default:
+        return {};
+    }
+  };
+  var eventHandlers = React.useMemo(function () {
+    return getEventHandlers(currentStatus);
+  }, [currentStatus]);
+  var _useStepQueue = (0, _useStepQueue3.default)(currentStatus, !supportMotion, function (newStep) {
+      // Only prepare step can be skip
+      if (newStep === _interface.STEP_PREPARE) {
+        var onPrepare = eventHandlers[_interface.STEP_PREPARE];
+        if (!onPrepare) {
+          return _useStepQueue3.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 === _interface.STEP_ACTIVE && currentStatus !== _interface.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 === _interface.STEP_PREPARED) {
+        updateMotionEndStatus();
+      }
+      return _useStepQueue3.DoStep;
+    }),
+    _useStepQueue2 = (0, _slicedToArray2.default)(_useStepQueue, 2),
+    startStep = _useStepQueue2[0],
+    step = _useStepQueue2[1];
+  var active = (0, _useStepQueue3.isActive)(step);
+  activeRef.current = active;
+
+  // ============================ Status ============================
+  var visibleRef = (0, _react.useRef)(null);
+
+  // Update with new status
+  (0, _useIsomorphicLayoutEffect.default)(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 = _interface.STATUS_APPEAR;
+    }
+
+    // Enter
+    if (isMounted && visible && motionEnter) {
+      nextStatus = _interface.STATUS_ENTER;
+    }
+
+    // Leave
+    if (isMounted && !visible && motionLeave || !isMounted && motionLeaveImmediately && !visible && motionLeave) {
+      nextStatus = _interface.STATUS_LEAVE;
+    }
+    var nextEventHandlers = getEventHandlers(nextStatus);
+
+    // Update to next status
+    if (nextStatus && (supportMotion || nextEventHandlers[_interface.STEP_PREPARE])) {
+      setStatus(nextStatus);
+      startStep();
+    } else {
+      // Set back in case no motion but prev status has prepare step
+      setStatus(_interface.STATUS_NONE);
+    }
+    visibleRef.current = visible;
+  }, [visible]);
+
+  // ============================ Effect ============================
+  // Reset when motion changed
+  (0, _react.useEffect)(function () {
+    if (
+    // Cancel appear
+    currentStatus === _interface.STATUS_APPEAR && !motionAppear ||
+    // Cancel enter
+    currentStatus === _interface.STATUS_ENTER && !motionEnter ||
+    // Cancel leave
+    currentStatus === _interface.STATUS_LEAVE && !motionLeave) {
+      setStatus(_interface.STATUS_NONE);
+    }
+  }, [motionAppear, motionEnter, motionLeave]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      mountedRef.current = false;
+      clearTimeout(deadlineRef.current);
+    };
+  }, []);
+
+  // Trigger `onVisibleChanged`
+  var firstMountChangeRef = React.useRef(false);
+  (0, _react.useEffect)(function () {
+    // [visible & motion not end] => [!visible & motion end] still need trigger onVisibleChanged
+    if (asyncVisible) {
+      firstMountChangeRef.current = true;
+    }
+    if (asyncVisible !== undefined && currentStatus === _interface.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[_interface.STEP_PREPARE] && step === _interface.STEP_START) {
+    mergedStyle = (0, _objectSpread2.default)({
+      transition: 'none'
+    }, mergedStyle);
+  }
+  return [currentStatus, step, mergedStyle, asyncVisible !== null && asyncVisible !== void 0 ? asyncVisible : visible];
+}

node_modules/rc-motion/lib/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/lib/hooks/useStepQueue.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SkipStep = exports.DoStep = void 0;
+exports.isActive = isActive;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useState3 = _interopRequireDefault(require("rc-util/lib/hooks/useState"));
+var React = _interopRequireWildcard(require("react"));
+var _interface = require("../interface");
+var _useIsomorphicLayoutEffect = _interopRequireDefault(require("./useIsomorphicLayoutEffect"));
+var _useNextFrame3 = _interopRequireDefault(require("./useNextFrame"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var FULL_STEP_QUEUE = [_interface.STEP_PREPARE, _interface.STEP_START, _interface.STEP_ACTIVE, _interface.STEP_ACTIVATED];
+var SIMPLE_STEP_QUEUE = [_interface.STEP_PREPARE, _interface.STEP_PREPARED];
+
+/** Skip current step */
+var SkipStep = exports.SkipStep = false;
+/** Current step should be update in */
+var DoStep = exports.DoStep = true;
+function isActive(step) {
+  return step === _interface.STEP_ACTIVE || step === _interface.STEP_ACTIVATED;
+}
+var _default = exports.default = function _default(status, prepareOnly, callback) {
+  var _useState = (0, _useState3.default)(_interface.STEP_NONE),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    step = _useState2[0],
+    setStep = _useState2[1];
+  var _useNextFrame = (0, _useNextFrame3.default)(),
+    _useNextFrame2 = (0, _slicedToArray2.default)(_useNextFrame, 2),
+    nextFrame = _useNextFrame2[0],
+    cancelNextFrame = _useNextFrame2[1];
+  function startQueue() {
+    setStep(_interface.STEP_PREPARE, true);
+  }
+  var STEP_QUEUE = prepareOnly ? SIMPLE_STEP_QUEUE : FULL_STEP_QUEUE;
+  (0, _useIsomorphicLayoutEffect.default)(function () {
+    if (step !== _interface.STEP_NONE && step !== _interface.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/lib/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/lib/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CSSMotionList", {
+  enumerable: true,
+  get: function get() {
+    return _CSSMotionList.default;
+  }
+});
+Object.defineProperty(exports, "Provider", {
+  enumerable: true,
+  get: function get() {
+    return _context.default;
+  }
+});
+exports.default = void 0;
+var _CSSMotion = _interopRequireDefault(require("./CSSMotion"));
+var _CSSMotionList = _interopRequireDefault(require("./CSSMotionList"));
+var _context = _interopRequireDefault(require("./context"));
+var _default = exports.default = _CSSMotion.default;

node_modules/rc-motion/lib/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/lib/interface.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STEP_START = exports.STEP_PREPARED = exports.STEP_PREPARE = exports.STEP_NONE = exports.STEP_ACTIVE = exports.STEP_ACTIVATED = exports.STATUS_NONE = exports.STATUS_LEAVE = exports.STATUS_ENTER = exports.STATUS_APPEAR = void 0;
+var STATUS_NONE = exports.STATUS_NONE = 'none';
+var STATUS_APPEAR = exports.STATUS_APPEAR = 'appear';
+var STATUS_ENTER = exports.STATUS_ENTER = 'enter';
+var STATUS_LEAVE = exports.STATUS_LEAVE = 'leave';
+var STEP_NONE = exports.STEP_NONE = 'none';
+var STEP_PREPARE = exports.STEP_PREPARE = 'prepare';
+var STEP_START = exports.STEP_START = 'start';
+var STEP_ACTIVE = exports.STEP_ACTIVE = 'active';
+var STEP_ACTIVATED = exports.STEP_ACTIVATED = 'end';
+/**
+ * Used for disabled motion case.
+ * Prepare stage will still work but start & active will be skipped.
+ */
+var STEP_PREPARED = exports.STEP_PREPARED = 'prepared';

node_modules/rc-motion/lib/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/lib/util/diff.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STATUS_REMOVED = exports.STATUS_REMOVE = exports.STATUS_KEEP = exports.STATUS_ADD = void 0;
+exports.diffKeys = diffKeys;
+exports.parseKeys = parseKeys;
+exports.wrapKeyToObject = wrapKeyToObject;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var STATUS_ADD = exports.STATUS_ADD = 'add';
+var STATUS_KEEP = exports.STATUS_KEEP = 'keep';
+var STATUS_REMOVE = exports.STATUS_REMOVE = 'remove';
+var STATUS_REMOVED = exports.STATUS_REMOVED = 'removed';
+function wrapKeyToObject(key) {
+  var keyObj;
+  if (key && (0, _typeof2.default)(key) === 'object' && 'key' in key) {
+    keyObj = key;
+  } else {
+    keyObj = {
+      key: key
+    };
+  }
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, keyObj), {}, {
+    key: String(keyObj.key)
+  });
+}
+function parseKeys() {
+  var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return keys.map(wrapKeyToObject);
+}
+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 (0, _objectSpread2.default)((0, _objectSpread2.default)({}, obj), {}, {
+              status: STATUS_ADD
+            });
+          }));
+          currentIndex = i;
+        }
+        list.push((0, _objectSpread2.default)((0, _objectSpread2.default)({}, currentKeyObj), {}, {
+          status: STATUS_KEEP
+        }));
+        currentIndex += 1;
+        hit = true;
+        break;
+      }
+    }
+
+    // If not hit, it means key is removed
+    if (!hit) {
+      list.push((0, _objectSpread2.default)((0, _objectSpread2.default)({}, keyObj), {}, {
+        status: STATUS_REMOVE
+      }));
+    }
+  });
+
+  // Add rest to the list
+  if (currentIndex < currentLen) {
+    list = list.concat(currentKeyObjects.slice(currentIndex).map(function (obj) {
+      return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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/lib/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/lib/util/motion.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.animationEndName = void 0;
+exports.getTransitionName = getTransitionName;
+exports.getVendorPrefixedEventName = getVendorPrefixedEventName;
+exports.getVendorPrefixes = getVendorPrefixes;
+exports.transitionEndName = exports.supportTransition = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _canUseDom = _interopRequireDefault(require("rc-util/lib/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;
+}
+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((0, _canUseDom.default)(), typeof window !== 'undefined' ? window : {});
+var style = {};
+if ((0, _canUseDom.default)()) {
+  var _document$createEleme = document.createElement('div');
+  style = _document$createEleme.style;
+}
+var prefixedEventNames = {};
+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');
+var supportTransition = exports.supportTransition = !!(internalAnimationEndName && internalTransitionEndName);
+var animationEndName = exports.animationEndName = internalAnimationEndName || 'animationend';
+var transitionEndName = exports.transitionEndName = internalTransitionEndName || 'transitionend';
+function getTransitionName(transitionName, transitionType) {
+  if (!transitionName) return null;
+  if ((0, _typeof2.default)(transitionName) === 'object') {
+    var type = transitionType.replace(/-\w/g, function (match) {
+      return match[1].toUpperCase();
+    });
+    return transitionName[type];
+  }
+  return "".concat(transitionName, "-").concat(transitionType);
+}

node_modules/rc-motion/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "rc-motion",
+  "version": "2.9.5",
+  "description": "React lifecycle controlled motion library",
+  "keywords": [
+    "react",
+    "react-component",
+    "react-motion",
+    "motion",
+    "antd",
+    "ant-design"
+  ],
+  "homepage": "https://react-component.github.io/motion",
+  "bugs": {
+    "url": "http://github.com/react-component/motion/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:react-component/motion.git"
+  },
+  "license": "MIT",
+  "main": "./lib/index",
+  "module": "./es/index",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es",
+    "lib"
+  ],
+  "scripts": {
+    "compile": "father build",
+    "docs:build": "dumi build",
+    "docs:deploy": "gh-pages -d .doc",
+    "lint": "eslint src/ --ext .tsx,.ts",
+    "now-build": "npm run docs:build",
+    "prepare": "husky install",
+    "prepublishOnly": "npm run compile && np --yolo --no-publish",
+    "prettier": "prettier --write \"**/*.{js,jsx,tsx,ts,less,md,json}\"",
+    "postpublish": "npm run docs:build && npm run docs:deploy",
+    "start": "dumi dev",
+    "test": "rc-test"
+  },
+  "lint-staged": {
+    "**/*.{js,jsx,tsx,ts,md,json}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.11.1",
+    "classnames": "^2.2.1",
+    "rc-util": "^5.44.0"
+  },
+  "devDependencies": {
+    "@rc-component/father-plugin": "^1.0.1",
+    "@testing-library/jest-dom": "^5.16.4",
+    "@testing-library/react": "^15.0.7",
+    "@types/classnames": "^2.2.9",
+    "@types/jest": "^26.0.8",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@umijs/fabric": "^2.0.8",
+    "cross-env": "^7.0.2",
+    "dumi": "^2.0.18",
+    "eslint": "^7.0.0",
+    "father": "^4.1.2",
+    "gh-pages": "^6.0.0",
+    "husky": "^8.0.3",
+    "lint-staged": "^14.0.1",
+    "np": "^6.2.4",
+    "prettier": "^2.1.1",
+    "rc-test": "^7.0.14",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0",
+    "typescript": "^4.0.3"
+  },
+  "peerDependencies": {
+    "react": ">=16.9.0",
+    "react-dom": ">=16.9.0"
+  },
+  "cnpm": {
+    "mode": "npm"
+  },
+  "tnpm": {
+    "mode": "npm"
+  }
+}