@douyinfe/semi-animation-react 2.1.1 → 2.1.2

package/lib/cjs/src/StyledAnimation.js

@@ -0,0 +1,181 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));
+
+var _values = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/values"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _react = require("react");
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _semiAnimationStyled = require("@douyinfe/semi-animation-styled");
+
+var _noop = _interopRequireDefault(require("./utils/noop"));
+
+var _invokeFns = _interopRequireDefault(require("./utils/invokeFns"));
+
+var _context;
+
+const types = (0, _reduce.default)(_context = (0, _values.default)(_semiAnimationStyled.types)).call(_context, (arr, cur) => [...arr, ...cur], []);
+
+class StyledAnimation extends _react.PureComponent {
+  constructor() {
+    var _this;
+
+    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(props);
+    _this = this;
+
+    this._generateAnimateEvents = function (child) {
+      let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return {
+        onAnimationIteration: function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+
+          return (0, _invokeFns.default)([child && child.props && child.props.onAnimationIteration, props.onFrame], args);
+        },
+        onAnimationStart: function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+
+          return (0, _invokeFns.default)([child && child.props && child.props.onAnimationStart, props.onStart], args);
+        },
+        onAnimationEnd: function () {
+          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+            args[_key3] = arguments[_key3];
+          }
+
+          return (0, _invokeFns.default)([child && child.props && child.props.onAnimationEnd, props.onRest], args);
+        }
+      };
+    };
+
+    this._hasSpeedClass = function () {
+      let speed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props.speed;
+      return speed != null && (0, _includes.default)(_semiAnimationStyled.speeds).call(_semiAnimationStyled.speeds, speed);
+    };
+
+    this._hasTypeClass = function () {
+      let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props.type;
+      return type != null && (0, _includes.default)(types).call(types, type);
+    };
+
+    this._hasDelayClass = function () {
+      let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props.delay;
+      return delay != null && (0, _includes.default)(_semiAnimationStyled.delays).call(_semiAnimationStyled.delays, delay);
+    };
+
+    this._hasLoopClass = function () {
+      let loop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props.loop;
+      return loop != null && (0, _includes.default)(_semiAnimationStyled.loops).call(_semiAnimationStyled.loops, loop);
+    };
+  }
+
+  render() {
+    var _context2, _context3, _context4, _context5;
+
+    let {
+      type,
+      speed,
+      duration,
+      delay,
+      loop,
+      reverse,
+      children,
+      prefixCls,
+      timing,
+      className,
+      fillMode
+    } = this.props;
+
+    const hasTypeClass = this._hasTypeClass();
+
+    const hasSpeedClass = this._hasSpeedClass();
+
+    const hasDelayClass = this._hasDelayClass();
+
+    const hasLoopClass = this._hasLoopClass();
+
+    const animateCls = className || (0, _classnames.default)("".concat(prefixCls, "-animated"), {
+      [(0, _concat.default)(_context2 = "".concat(prefixCls, "-")).call(_context2, type)]: Boolean(type),
+      [(0, _concat.default)(_context3 = "".concat(prefixCls, "-speed-")).call(_context3, speed)]: hasSpeedClass,
+      [(0, _concat.default)(_context4 = "".concat(prefixCls, "-delay-")).call(_context4, delay)]: hasDelayClass,
+      [(0, _concat.default)(_context5 = "".concat(prefixCls, "-loop-")).call(_context5, loop)]: hasLoopClass
+    });
+    const animateStyle = {
+      animationTimingFunction: timing,
+      animationName: !hasTypeClass && type,
+      animationDuration: duration,
+      animationDelay: !hasDelayClass && delay,
+      animationIterationCount: !hasLoopClass && loop,
+      animationDirection: reverse ? 'alternate' : 'normal',
+      animationFillMode: fillMode
+    };
+
+    if ( /*#__PURE__*/(0, _react.isValidElement)(children)) {
+      children = (0, _map.default)(_react.Children).call(_react.Children, children, child => {
+        const animateEvents = this._generateAnimateEvents(child, this.props);
+
+        return /*#__PURE__*/(0, _react.cloneElement)(child, (0, _assign.default)({
+          className: (0, _classnames.default)(child.props.className, animateCls),
+          style: (0, _assign.default)((0, _assign.default)({}, child.props.style), this.props.style)
+        }, animateEvents));
+      });
+    }
+
+    return typeof children === 'function' ? children({
+      animateCls,
+      animateStyle,
+      animateEvents: this._generateAnimateEvents(null, this.props)
+    }) : children;
+  }
+
+}
+
+exports.default = StyledAnimation;
+StyledAnimation.propTypes = {
+  className: _propTypes.default.string,
+  type: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.any]),
+  speed: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  delay: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  reverse: _propTypes.default.oneOfType([_propTypes.default.bool, _propTypes.default.string]),
+  loop: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  children: _propTypes.default.any,
+  onStart: _propTypes.default.func,
+  onFrame: _propTypes.default.func,
+  onRest: _propTypes.default.func,
+  prefixCls: _propTypes.default.string,
+  timing: _propTypes.default.string,
+  duration: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  fillMode: _propTypes.default.string
+};
+StyledAnimation.defaultProps = {
+  prefixCls: 'semi',
+  speed: 'faster',
+  onFrame: _noop.default,
+  onStart: _noop.default,
+  onRest: _noop.default
+};

package/lib/cjs/src/StyledTransition.d.ts

@@ -0,0 +1,49 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { StyledAnimationProps } from './StyledAnimation';
+import noop from './utils/noop';
+export interface StyledTransitionProps extends StyledAnimationProps {
+    state?: string | boolean;
+    enter?: string;
+    leave?: string;
+    children?: React.ReactNode;
+    willEnter?: (value: any) => void;
+    didEnter?: (value: any) => void;
+    willLeave?: (value: any) => void;
+    didLeave?: (value: any) => void;
+    onStart?: (value: any) => void;
+    onRest?: (value: any) => void;
+}
+export interface StyledTransitionState {
+    state: string | boolean;
+    lastChildren: React.ReactNode;
+    currentChildren: React.ReactNode;
+}
+export default class StyledTransition extends Component<StyledTransitionProps, StyledTransitionState> {
+    static propTypes: {
+        state: PropTypes.Requireable<string>;
+        enter: PropTypes.Requireable<string>;
+        leave: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<any>;
+        willEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        didEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        willLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        didLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        onStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onRest: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        willEnter: typeof noop;
+        didEnter: typeof noop;
+        willLeave: typeof noop;
+        didLeave: typeof noop;
+        onStart: typeof noop;
+        onRest: typeof noop;
+    };
+    constructor(props?: {});
+    static getDerivedStateFromProps(props: StyledTransitionProps, state: StyledTransitionState): Partial<StyledTransitionState>;
+    _isControlled: () => boolean;
+    onRest: (props: any) => void;
+    onStart: (props: any) => void;
+    render(): JSX.Element;
+}

package/lib/cjs/src/StyledTransition.js

@@ -0,0 +1,191 @@
+"use strict";
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _StyledAnimation = _interopRequireDefault(require("./StyledAnimation"));
+
+var _noop = _interopRequireDefault(require("./utils/noop"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && (0, _indexOf.default)(e).call(e, p) < 0) t[p] = s[p];
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if ((0, _indexOf.default)(e).call(e, p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+/* eslint-disable eqeqeq */
+
+
+class StyledTransition extends _react.Component {
+  constructor() {
+    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(props);
+
+    this._isControlled = () => {
+      var _context;
+
+      return (0, _includes.default)(_context = [true, false, 'enter', 'leave']).call(_context, this.props.state);
+    };
+
+    this.onRest = props => {
+      const {
+        state
+      } = this.state;
+
+      if (state === 'enter') {
+        this.props.didEnter(props);
+      } else if (state === 'leave') {
+        this.setState({
+          currentChildren: null,
+          lastChildren: null
+        });
+        this.props.didLeave(props);
+      }
+
+      this.props.onRest(props);
+    };
+
+    this.onStart = props => {
+      const {
+        state
+      } = this.state;
+
+      if (state === 'enter') {
+        this.props.willEnter(props);
+      } else if (state === 'leave') {
+        this.props.willLeave(props);
+      }
+
+      this.props.onStart(props);
+    };
+
+    this.state = {
+      state: '',
+      lastChildren: null,
+      currentChildren: null
+    };
+  }
+
+  static getDerivedStateFromProps(props, state) {
+    const willUpdateStates = {};
+
+    if (props.children !== state.currentChildren) {
+      willUpdateStates.lastChildren = state.currentChildren;
+      willUpdateStates.currentChildren = props.children;
+
+      if (props.children == null) {
+        willUpdateStates.state = 'leave';
+      } else {
+        willUpdateStates.state = 'enter';
+      }
+    }
+
+    if (props.state != null && props.state !== state.state) {
+      willUpdateStates.state = props.state;
+    }
+
+    return willUpdateStates;
+  }
+
+  render() {
+    const _a = this.props,
+          {
+      enter,
+      leave
+    } = _a,
+          restProps = __rest(_a, ["enter", "leave"]);
+
+    const {
+      currentChildren,
+      lastChildren
+    } = this.state;
+
+    const isControlled = this._isControlled();
+
+    let children, type;
+    let {
+      state
+    } = this.state;
+
+    if (isControlled) {
+      children = this.props.children;
+      state = this.props.state;
+    } else if (currentChildren == null && lastChildren == null) {
+      return null;
+    }
+
+    if (state === 'enter') {
+      type = enter;
+
+      if (!isControlled) {
+        children = currentChildren;
+      }
+    } else if (state === 'leave') {
+      type = leave;
+
+      if (!isControlled) {
+        children = lastChildren;
+      }
+    }
+
+    return /*#__PURE__*/_react.default.createElement(_StyledAnimation.default, (0, _assign.default)({}, restProps, {
+      type: type,
+      onStart: this.onStart,
+      onRest: this.onRest
+    }), children);
+  }
+
+}
+
+exports.default = StyledTransition;
+StyledTransition.propTypes = {
+  state: _propTypes.default.string,
+  enter: _propTypes.default.string,
+  leave: _propTypes.default.string,
+  children: _propTypes.default.any,
+  willEnter: _propTypes.default.func,
+  didEnter: _propTypes.default.func,
+  willLeave: _propTypes.default.func,
+  didLeave: _propTypes.default.func,
+  onStart: _propTypes.default.func,
+  onRest: _propTypes.default.func
+};
+StyledTransition.defaultProps = {
+  willEnter: _noop.default,
+  didEnter: _noop.default,
+  willLeave: _noop.default,
+  didLeave: _noop.default,
+  onStart: _noop.default,
+  onRest: _noop.default
+};

package/lib/cjs/src/Transition.d.ts

@@ -0,0 +1,52 @@
+import { AnimationProps } from './Animation';
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import noop from './utils/noop';
+export interface TransitionProps extends AnimationProps {
+    children?: React.ReactNode;
+    from?: Record<string, any>;
+    enter?: Record<string, any>;
+    leave?: Record<string, any>;
+    state?: string | boolean;
+    willEnter?: (value: any) => void;
+    didEnter?: (value: any) => void;
+    willLeave?: (value: any) => void;
+    didLeave?: (value: any) => void;
+    onRest?: (value: any) => void;
+    onStart?: (value: any) => void;
+}
+export interface TransitionState {
+    state: string | boolean;
+    lastChildren: React.ReactNode;
+    currentChildren: React.ReactNode;
+}
+export default class Transition extends Component<TransitionProps, TransitionState> {
+    static propTypes: {
+        children: PropTypes.Requireable<any>;
+        from: PropTypes.Requireable<object>;
+        enter: PropTypes.Requireable<object>;
+        leave: PropTypes.Requireable<object>;
+        willEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        didEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        willLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        didLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        state: PropTypes.Requireable<string | boolean>;
+    };
+    static defaultProps: {
+        willEnter: typeof noop;
+        didEnter: typeof noop;
+        willLeave: typeof noop;
+        didLeave: typeof noop;
+        onStart: typeof noop;
+        onRest: typeof noop;
+    };
+    instance: any;
+    constructor(props?: {});
+    static getDerivedStateFromProps(props: TransitionProps, state: TransitionState): Partial<TransitionState>;
+    componentWillUnmount(): void;
+    _isControlled: () => boolean;
+    forwardInstance: (instance: any) => void;
+    onRest: (props: any) => void;
+    onStart: (props: any) => void;
+    render(): JSX.Element;
+}

package/lib/cjs/src/Transition.js

@@ -0,0 +1,208 @@
+"use strict";
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _Animation = _interopRequireDefault(require("./Animation"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _noop = _interopRequireDefault(require("./utils/noop"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && (0, _indexOf.default)(e).call(e, p) < 0) t[p] = s[p];
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if ((0, _indexOf.default)(e).call(e, p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+/* eslint-disable eqeqeq */
+
+
+class Transition extends _react.Component {
+  constructor() {
+    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(props);
+
+    this._isControlled = () => {
+      var _context;
+
+      return (0, _includes.default)(_context = [true, false, 'enter', 'leave']).call(_context, this.props.state);
+    };
+
+    this.forwardInstance = instance => {
+      this.instance = instance;
+    };
+
+    this.onRest = props => {
+      const {
+        state
+      } = this.state;
+
+      if (state === 'enter') {
+        this.props.didEnter(props);
+      } else if (state === 'leave') {
+        this.setState({
+          currentChildren: null,
+          lastChildren: null
+        });
+        this.props.didLeave(props);
+      }
+
+      this.props.onRest(props);
+    };
+
+    this.onStart = props => {
+      const {
+        state
+      } = this.state;
+
+      if (state === 'enter') {
+        this.props.willEnter(props);
+      } else if (state === 'leave') {
+        this.props.willLeave(props);
+      }
+
+      this.props.onStart(props);
+    };
+
+    this.state = {
+      state: '',
+      lastChildren: null,
+      currentChildren: null
+    };
+  }
+
+  static getDerivedStateFromProps(props, state) {
+    const willUpdateStates = {};
+
+    if (props.children !== state.currentChildren // && (props.children == null || state.currentChildren == null)
+    ) {
+      willUpdateStates.lastChildren = state.currentChildren;
+      willUpdateStates.currentChildren = props.children;
+
+      if (props.children == null) {
+        willUpdateStates.state = 'leave';
+      } else {
+        willUpdateStates.state = 'enter';
+      }
+    }
+
+    if (props.state != null) {
+      willUpdateStates.state = props.state;
+    }
+
+    return willUpdateStates;
+  }
+
+  componentWillUnmount() {
+    if (this.instance) {
+      this.instance.destroy();
+      this.instance = null;
+    }
+  }
+
+  render() {
+    const _a = this.props,
+          {
+      from: propsFrom,
+      enter,
+      leave
+    } = _a,
+          restProps = __rest(_a, ["from", "enter", "leave"]);
+
+    let children; // eslint-disable-next-line prefer-const
+
+    let {
+      currentChildren,
+      lastChildren,
+      state
+    } = this.state;
+    let from = {};
+    let to = {};
+
+    const isControlled = this._isControlled();
+
+    if (isControlled) {
+      children = this.props.children;
+      state = this.props.state;
+    } else if (currentChildren == null && lastChildren == null) {
+      return null;
+    }
+
+    if (state === 'enter') {
+      from = propsFrom;
+      to = enter;
+
+      if (!isControlled) {
+        children = currentChildren;
+      }
+    } else if (state === 'leave') {
+      from = enter;
+      to = leave;
+
+      if (!isControlled) {
+        children = lastChildren;
+      }
+    }
+
+    return /*#__PURE__*/_react.default.createElement(_Animation.default, (0, _assign.default)({}, restProps, {
+      force: true,
+      from: from,
+      to: to,
+      onRest: this.onRest,
+      onStart: this.onStart
+    }), props => // eslint-disable-next-line no-nested-ternary
+    typeof children === 'function' ? children(props) : /*#__PURE__*/(0, _react.isValidElement)(children) ? children : null);
+  }
+
+}
+
+exports.default = Transition;
+Transition.propTypes = {
+  children: _propTypes.default.any,
+  from: _propTypes.default.object,
+  enter: _propTypes.default.object,
+  leave: _propTypes.default.object,
+  willEnter: _propTypes.default.func,
+  didEnter: _propTypes.default.func,
+  willLeave: _propTypes.default.func,
+  didLeave: _propTypes.default.func,
+  state: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.bool])
+};
+Transition.defaultProps = {
+  willEnter: _noop.default,
+  didEnter: _noop.default,
+  willLeave: _noop.default,
+  didLeave: _noop.default,
+  onStart: _noop.default,
+  onRest: _noop.default
+};

package/lib/cjs/src/utils/invokeFns.d.ts

@@ -0,0 +1 @@
+export default function invokeFns(fns: any[], args?: any[]): void;