@qsxy/element-plus-react 1.0.0-next.1 → 1.0.0-next.11

package/dist/Transition/TransitionGroup.js

@@ -1,99 +1,147 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var _excluded = ["component", "childFactory"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { Component } from 'react';
+import TransitionGroupContext from "./TransitionGroupContext";
+import { getChildMapping, getInitialChildMapping, getNextChildMapping } from "./childMapping";
+var values = Object.values || function (obj) {
+  return Object.keys(obj).map(function (k) {
+    return obj[k];
+  });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+var defaultProps = {
+  component: 'div',
+  childFactory: function childFactory(child) {
+    return child;
   }
-  return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+/**
+ * The `<TransitionGroup>` component manages a set of transition components
+ * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
+ * components, `<TransitionGroup>` is a state machine for managing the mounting
+ * and unmounting of components over time.
+ *
+ * Consider the example below. As items are removed or added to the TodoList the
+ * `in` prop is toggled automatically by the `<TransitionGroup>`.
+ *
+ * Note that `<TransitionGroup>`  does not define any animation behavior!
+ * Exactly _how_ a list item animates is up to the individual transition
+ * component. This means you can mix and match animations across different list
+ * items.
+ */
+var TransitionGroup = /*#__PURE__*/function (_Component) {
+  _inherits(TransitionGroup, _Component);
+  var _super = _createSuper(TransitionGroup);
+  function TransitionGroup(props, context) {
+    var _this;
+    _classCallCheck(this, TransitionGroup);
+    _this = _super.call(this, props, context);
+    _defineProperty(_assertThisInitialized(_this), "mounted", void 0);
+    var handleExited = _this.handleExited.bind(_assertThisInitialized(_this));
 
-// src/Transition/TransitionGroup.tsx
-var TransitionGroup_exports = {};
-__export(TransitionGroup_exports, {
-  default: () => TransitionGroup_default
-});
-module.exports = __toCommonJS(TransitionGroup_exports);
-var import_react = __toESM(require("react"));
-var import_TransitionGroupContext = __toESM(require("./TransitionGroupContext"));
-var import_childMapping = require("./childMapping");
-var values = Object.values || ((obj) => Object.keys(obj).map((k) => obj[k]));
-var defaultProps = {
-  component: "div",
-  childFactory: (child) => child
-};
-var TransitionGroup = class extends import_react.Component {
-  constructor(props, context) {
-    super(props, context);
-    const handleExited = this.handleExited.bind(this);
-    this.state = {
-      contextValue: { isMounting: true },
-      handleExited,
+    // Initial children should all be entering, dependent on transitionAppear
+    _this.state = {
+      contextValue: {
+        isMounting: true
+      },
+      handleExited: handleExited,
       firstRender: true
     };
+    return _this;
   }
-  componentDidMount() {
-    this.mounted = true;
-    this.setState({
-      contextValue: { isMounting: false }
-    });
-  }
-  componentWillUnmount() {
-    this.mounted = false;
-  }
-  static getDerivedStateFromProps(nextProps, { children: prevChildMapping, handleExited, firstRender }) {
-    return {
-      children: firstRender ? (0, import_childMapping.getInitialChildMapping)(nextProps, handleExited) : (0, import_childMapping.getNextChildMapping)(nextProps, prevChildMapping, handleExited),
-      firstRender: false
-    };
-  }
-  // node is `undefined` when user provided `nodeRef` prop
-  handleExited(child, node) {
-    const currentChildMapping = (0, import_childMapping.getChildMapping)(this.props.children);
-    if (child.key in currentChildMapping) {
-      return;
+  _createClass(TransitionGroup, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.mounted = true;
+      this.setState({
+        contextValue: {
+          isMounting: false
+        }
+      });
     }
-    if (child.props.afterLeave) {
-      child.props.afterLeave(node);
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.mounted = false;
     }
-    if (this.mounted) {
-      this.setState((state) => {
-        const children = { ...state.children };
-        delete children[child.key];
-        return { children };
-      });
+  }, {
+    key: "handleExited",
+    value:
+    // node is `undefined` when user provided `nodeRef` prop
+    function handleExited(child, node) {
+      // @ts-ignore
+      var currentChildMapping = getChildMapping(this.props.children);
+      if (child.key in currentChildMapping) {
+        return;
+      }
+      if (child.props.afterLeave) {
+        child.props.afterLeave(node);
+      }
+      if (this.mounted) {
+        this.setState(function (state) {
+          var children = _objectSpread({}, state.children);
+          delete children[child.key];
+          return {
+            children: children
+          };
+        });
+      }
     }
-  }
-  render() {
-    const { component: Component2 = "div", childFactory = (child) => child, ...props } = this.props;
-    const { contextValue } = this.state;
-    const children = values(this.state.children).map(childFactory);
-    delete props.transitionAppear;
-    delete props.enter;
-    delete props.exit;
-    if (Component2 === null) {
-      return /* @__PURE__ */ import_react.default.createElement(import_TransitionGroupContext.default.Provider, { value: contextValue }, children);
+  }, {
+    key: "render",
+    value: function render() {
+      // eslint-disable-next-line @typescript-eslint/no-shadow
+      var _this$props = this.props,
+        _this$props$component = _this$props.component,
+        Component = _this$props$component === void 0 ? 'div' : _this$props$component,
+        _this$props$childFact = _this$props.childFactory,
+        childFactory = _this$props$childFact === void 0 ? function (child) {
+          return child;
+        } : _this$props$childFact,
+        props = _objectWithoutProperties(_this$props, _excluded);
+      var contextValue = this.state.contextValue;
+      var children = values(this.state.children).map(childFactory);
+      delete props.transitionAppear;
+      delete props.enter;
+      delete props.exit;
+      if (Component === null) {
+        return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {
+          value: contextValue
+        }, children);
+      }
+      return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {
+        value: contextValue
+      }, /*#__PURE__*/React.createElement(Component, props, children));
     }
-    return /* @__PURE__ */ import_react.default.createElement(import_TransitionGroupContext.default.Provider, { value: contextValue }, /* @__PURE__ */ import_react.default.createElement(Component2, { ...props }, children));
-  }
-};
-TransitionGroup.defaultProps = defaultProps;
-var TransitionGroup_default = TransitionGroup;
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, _ref) {
+      var prevChildMapping = _ref.children,
+        handleExited = _ref.handleExited,
+        firstRender = _ref.firstRender;
+      return {
+        children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),
+        firstRender: false
+      };
+    }
+  }]);
+  return TransitionGroup;
+}(Component);
+_defineProperty(TransitionGroup, "defaultProps", defaultProps);
+export default TransitionGroup;

package/dist/Transition/TransitionGroupContext.js

@@ -1,26 +1,2 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Transition/TransitionGroupContext.ts
-var TransitionGroupContext_exports = {};
-__export(TransitionGroupContext_exports, {
-  default: () => TransitionGroupContext_default
-});
-module.exports = __toCommonJS(TransitionGroupContext_exports);
-var import_react = require("react");
-var TransitionGroupContext_default = (0, import_react.createContext)(null);
+import { createContext } from 'react';
+export default /*#__PURE__*/createContext(null);

package/dist/Transition/childMapping.d.ts

@@ -1,5 +1,28 @@
 import React from 'react';
+/**
+ * Given `this.props.children`, return an object mapping key to child.
+ *
+ * @param {*} children `this.props.children`
+ * @return {object} Mapping of key to child
+ */
 export declare function getChildMapping(children: React.ReactElement<any>[] | React.ReactElement<any>, mapFn?: (child: React.ReactElement<any>) => React.ReactNode): any;
+/**
+ * When you're adding or removing children some may be added or removed in the
+ * same render pass. We want to show *both* since we want to simultaneously
+ * animate elements in and out. This function takes a previous set of keys
+ * and a new set of keys and merges them with its best guess of the correct
+ * ordering. In the future we may expose some of the utilities in
+ * ReactMultiChild to make this easy, but for now React itself does not
+ * directly have this concept of the union of prevChildren and nextChildren
+ * so we implement it here.
+ *
+ * @param {object} prev prev children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @param {object} next next children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @return {object} a key set that contains all keys in `prev` and all keys
+ * in `next` in a reasonable order.
+ */
 export declare function mergeChildMappings(prev: any, next: any): {};
 export declare function getInitialChildMapping(props: any, afterLeave: any): any;
 export declare function getNextChildMapping(nextProps: any, prevChildMapping: any, afterLeave: any): {};

package/dist/Transition/childMapping.js

@@ -1,50 +1,56 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+import { Children, cloneElement, isValidElement } from 'react';
 
-// src/Transition/childMapping.ts
-var childMapping_exports = {};
-__export(childMapping_exports, {
-  getChildMapping: () => getChildMapping,
-  getInitialChildMapping: () => getInitialChildMapping,
-  getNextChildMapping: () => getNextChildMapping,
-  mergeChildMappings: () => mergeChildMappings
-});
-module.exports = __toCommonJS(childMapping_exports);
-var import_react = require("react");
-function getChildMapping(children, mapFn) {
-  const mapper = (child) => mapFn && (0, import_react.isValidElement)(child) ? mapFn(child) : child;
-  const result = /* @__PURE__ */ Object.create(null);
+/**
+ * Given `this.props.children`, return an object mapping key to child.
+ *
+ * @param {*} children `this.props.children`
+ * @return {object} Mapping of key to child
+ */
+export function getChildMapping(children, mapFn) {
+  var mapper = function mapper(child) {
+    return mapFn && /*#__PURE__*/isValidElement(child) ? mapFn(child) : child;
+  };
+  var result = Object.create(null);
   if (children) {
-    import_react.Children.map(children, (c) => c).forEach((child) => {
+    Children.map(children, function (c) {
+      return c;
+    }).forEach(function (child) {
+      // run the map function here instead so that the key is the computed one
       result[child.key] = mapper(child);
     });
   }
   return result;
 }
-function mergeChildMappings(prev, next) {
+
+/**
+ * When you're adding or removing children some may be added or removed in the
+ * same render pass. We want to show *both* since we want to simultaneously
+ * animate elements in and out. This function takes a previous set of keys
+ * and a new set of keys and merges them with its best guess of the correct
+ * ordering. In the future we may expose some of the utilities in
+ * ReactMultiChild to make this easy, but for now React itself does not
+ * directly have this concept of the union of prevChildren and nextChildren
+ * so we implement it here.
+ *
+ * @param {object} prev prev children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @param {object} next next children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @return {object} a key set that contains all keys in `prev` and all keys
+ * in `next` in a reasonable order.
+ */
+export function mergeChildMappings(prev, next) {
   prev = prev || {};
   next = next || {};
   function getValueForKey(key) {
     return key in next ? next[key] : prev[key];
   }
-  const nextKeysPending = /* @__PURE__ */ Object.create(null);
-  let pendingKeys = [];
-  for (const prevKey in prev) {
+
+  // For each key of `next`, the list of keys to insert before that key in
+  // the combined list
+  var nextKeysPending = Object.create(null);
+  var pendingKeys = [];
+  for (var prevKey in prev) {
     if (prevKey in next) {
       if (pendingKeys.length) {
         nextKeysPending[prevKey] = pendingKeys;
@@ -54,17 +60,19 @@ function mergeChildMappings(prev, next) {
       pendingKeys.push(prevKey);
     }
   }
-  let i;
-  const childMapping = {};
-  for (const nextKey in next) {
+  var i;
+  var childMapping = {};
+  for (var nextKey in next) {
     if (nextKeysPending[nextKey]) {
       for (i = 0; i < nextKeysPending[nextKey].length; i++) {
-        const pendingNextKey = nextKeysPending[nextKey][i];
+        var pendingNextKey = nextKeysPending[nextKey][i];
         childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
       }
     }
     childMapping[nextKey] = getValueForKey(nextKey);
   }
+
+  // Finally, add the keys which didn't appear before any key in `next`
   for (i = 0; i < pendingKeys.length; i++) {
     childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
   }
@@ -73,56 +81,61 @@ function mergeChildMappings(prev, next) {
 function getProp(child, prop, props) {
   return props[prop] != null ? props[prop] : child.props[prop];
 }
-function getInitialChildMapping(props, afterLeave) {
-  return getChildMapping(props.children, (child) => {
-    return (0, import_react.cloneElement)(child, {
+export function getInitialChildMapping(props, afterLeave) {
+  return getChildMapping(props.children, function (child) {
+    return /*#__PURE__*/cloneElement(child, {
       afterLeave: afterLeave.bind(null, child),
       visible: true,
-      transitionAppear: getProp(child, "transitionAppear", props),
-      enter: getProp(child, "enter", props),
-      exit: getProp(child, "exit", props)
+      transitionAppear: getProp(child, 'transitionAppear', props),
+      enter: getProp(child, 'enter', props),
+      exit: getProp(child, 'exit', props)
     });
   });
 }
-function getNextChildMapping(nextProps, prevChildMapping, afterLeave) {
-  const nextChildMapping = getChildMapping(nextProps.children);
-  const children = mergeChildMappings(prevChildMapping, nextChildMapping);
-  Object.keys(children).forEach((key) => {
-    const child = children[key];
-    if (!(0, import_react.isValidElement)(child)) {
+export function getNextChildMapping(nextProps, prevChildMapping, afterLeave) {
+  var nextChildMapping = getChildMapping(nextProps.children);
+  var children = mergeChildMappings(prevChildMapping, nextChildMapping);
+  Object.keys(children).forEach(function (key) {
+    var child = children[key];
+    if (! /*#__PURE__*/isValidElement(child)) {
       return;
     }
-    const hasPrev = key in prevChildMapping;
-    const hasNext = key in nextChildMapping;
-    const prevChild = prevChildMapping[key];
-    const isLeaving = (0, import_react.isValidElement)(prevChild) && !prevChild.props.visible;
+    var hasPrev = (key in prevChildMapping);
+    var hasNext = (key in nextChildMapping);
+    var prevChild = prevChildMapping[key];
+    // @ts-ignore
+    var isLeaving = /*#__PURE__*/isValidElement(prevChild) && !prevChild.props.visible;
+
+    // item is new (entering)
     if (hasNext && (!hasPrev || isLeaving)) {
-      children[key] = (0, import_react.cloneElement)(child, {
+      // console.log('entering', key)
+      children[key] = /*#__PURE__*/cloneElement(child, {
         // @ts-ignore
         afterLeave: afterLeave.bind(null, child),
         visible: true,
-        exit: getProp(child, "exit", nextProps),
-        enter: getProp(child, "enter", nextProps)
+        exit: getProp(child, 'exit', nextProps),
+        enter: getProp(child, 'enter', nextProps)
       });
     } else if (!hasNext && hasPrev && !isLeaving) {
-      children[key] = (0, import_react.cloneElement)(child, { visible: false });
-    } else if (hasNext && hasPrev && (0, import_react.isValidElement)(prevChild)) {
-      children[key] = (0, import_react.cloneElement)(child, {
+      // item is old (exiting)
+      // console.log('leaving', key)
+      // @ts-ignore
+      children[key] = /*#__PURE__*/cloneElement(child, {
+        visible: false
+      });
+    } else if (hasNext && hasPrev && /*#__PURE__*/isValidElement(prevChild)) {
+      // item hasn't changed transition states
+      // copy over the last transition props;
+      // console.log('unchanged', key)
+      children[key] = /*#__PURE__*/cloneElement(child, {
         // @ts-ignore
         afterLeave: afterLeave.bind(null, child),
         // @ts-ignore
         visible: prevChild.props.visible,
-        exit: getProp(child, "exit", nextProps),
-        enter: getProp(child, "enter", nextProps)
+        exit: getProp(child, 'exit', nextProps),
+        enter: getProp(child, 'enter', nextProps)
       });
     }
   });
   return children;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getChildMapping,
-  getInitialChildMapping,
-  getNextChildMapping,
-  mergeChildMappings
-});
+}

package/dist/Transition/index.js

@@ -1,42 +1,2 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Transition/index.ts
-var Transition_exports = {};
-__export(Transition_exports, {
-  Transition: () => import_Transition.default,
-  TransitionGroup: () => import_TransitionGroup.default
-});
-module.exports = __toCommonJS(Transition_exports);
-var import_Transition = __toESM(require("./Transition"));
-var import_TransitionGroup = __toESM(require("./TransitionGroup"));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Transition,
-  TransitionGroup
-});
+export { default as Transition } from "./Transition";
+export { default as TransitionGroup } from "./TransitionGroup";

package/dist/Transition/util.d.ts

@@ -1,2 +1 @@
-export declare function getDOMNode(elementOrRef: any): any;
 export declare function getAnimationEnd(): "webkitAnimationEnd" | "animationend";

package/dist/Transition/util.js

@@ -1,48 +1,7 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+export function getAnimationEnd() {
+  var style = document.createElement('div').style;
+  if ('webkitAnimation' in style) {
+    return 'webkitAnimationEnd';
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Transition/util.ts
-var util_exports = {};
-__export(util_exports, {
-  getAnimationEnd: () => getAnimationEnd,
-  getDOMNode: () => getDOMNode
-});
-module.exports = __toCommonJS(util_exports);
-var import_react_dom = require("react-dom");
-var getRefTarget = (ref) => {
-  return ref && ("current" in ref ? ref.current : ref);
-};
-function getDOMNode(elementOrRef) {
-  const element = (elementOrRef == null ? void 0 : elementOrRef.ref) || (elementOrRef == null ? void 0 : elementOrRef.child) || getRefTarget(elementOrRef);
-  if ((element == null ? void 0 : element.nodeType) && typeof (element == null ? void 0 : element.nodeName) === "string") {
-    return element;
-  }
-  return (0, import_react_dom.findDOMNode)(element);
-}
-function getAnimationEnd() {
-  const style = document.createElement("div").style;
-  if ("webkitAnimation" in style) {
-    return "webkitAnimationEnd";
-  }
-  return "animationend";
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getAnimationEnd,
-  getDOMNode
-});
+  return 'animationend';
+}

package/dist/Tree/DirectoryTree.d.ts

@@ -1,22 +1,15 @@
-import React, { Ref } from 'react';
+import * as React from 'react';
 import RcTree from './RCTree';
-import { Key } from './typings';
 import { TreeProps } from './Tree';
+import { BasicDataNode, DataNode, Key } from './typings';
 export type ExpandAction = false | 'click' | 'doubleClick';
-export interface DirectoryTreeProps<T> extends TreeProps<T> {
+export interface DirectoryTreeProps<T extends BasicDataNode = DataNode> extends TreeProps<T> {
     expandAction?: ExpandAction;
 }
+type DirectoryTreeCompoundedComponent = (<T extends BasicDataNode | DataNode = DataNode>(props: React.PropsWithChildren<DirectoryTreeProps<T>> & React.RefAttributes<RcTree>) => React.ReactElement) & Pick<React.FC, 'displayName'>;
 export interface DirectoryTreeState {
     expandedKeys?: Key[];
     selectedKeys?: Key[];
 }
-declare const ForwardDirectoryTree: <RecordType extends object = any>(props: DirectoryTreeProps<RecordType> & {
-    ref?: Ref<RcTree>;
-}) => React.ReactElement;
-type InternalDirectoryTreeType = typeof ForwardDirectoryTree;
-interface DirectoryTreeInterface extends InternalDirectoryTreeType {
-    displayName?: string;
-    defaultProps?: Partial<DirectoryTreeProps<any>>;
-}
-declare const DirectoryTree: DirectoryTreeInterface;
-export default DirectoryTree;
+declare const ForwardDirectoryTree: DirectoryTreeCompoundedComponent;
+export default ForwardDirectoryTree;