@mui/material
Version:
Quickly build beautiful React apps. MUI is a simple and customizable component library to build faster, beautiful, and more accessible React applications. Follow your own design system, or start with Material Design.
227 lines (204 loc) • 6.94 kB
JavaScript
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
import * as React from 'react';
import PropTypes from 'prop-types';
import { Transition } from 'react-transition-group';
import { elementAcceptingRef } from '@mui/utils';
import { duration } from '../styles/createTransitions';
import useTheme from '../styles/useTheme';
import { reflow, getTransitionProps } from '../transitions/utils';
import useForkRef from '../utils/useForkRef';
import { jsx as _jsx } from "react/jsx-runtime";
var styles = {
entering: {
transform: 'none'
},
entered: {
transform: 'none'
}
};
var defaultTimeout = {
enter: duration.enteringScreen,
exit: duration.leavingScreen
};
/**
* The Zoom transition can be used for the floating variant of the
* [Button](/components/buttons/#floating-action-buttons) component.
* It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
*/
var Zoom = /*#__PURE__*/React.forwardRef(function Zoom(props, ref) {
var addEndListener = props.addEndListener,
_props$appear = props.appear,
appear = _props$appear === void 0 ? true : _props$appear,
_children = props.children,
easing = props.easing,
inProp = props.in,
onEnter = props.onEnter,
onEntered = props.onEntered,
onEntering = props.onEntering,
onExit = props.onExit,
onExited = props.onExited,
onExiting = props.onExiting,
style = props.style,
_props$timeout = props.timeout,
timeout = _props$timeout === void 0 ? defaultTimeout : _props$timeout,
_props$TransitionComp = props.TransitionComponent,
TransitionComponent = _props$TransitionComp === void 0 ? Transition : _props$TransitionComp,
other = _objectWithoutProperties(props, ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"]);
var theme = useTheme();
var nodeRef = React.useRef(null);
var foreignRef = useForkRef(_children.ref, ref);
var handleRef = useForkRef(nodeRef, foreignRef);
var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {
return function (maybeIsAppearing) {
if (callback) {
var node = nodeRef.current; // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
if (maybeIsAppearing === undefined) {
callback(node);
} else {
callback(node, maybeIsAppearing);
}
}
};
};
var handleEntering = normalizedTransitionCallback(onEntering);
var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {
reflow(node); // So the animation always start from the start.
var transitionProps = getTransitionProps({
style: style,
timeout: timeout,
easing: easing
}, {
mode: 'enter'
});
node.style.webkitTransition = theme.transitions.create('transform', transitionProps);
node.style.transition = theme.transitions.create('transform', transitionProps);
if (onEnter) {
onEnter(node, isAppearing);
}
});
var handleEntered = normalizedTransitionCallback(onEntered);
var handleExiting = normalizedTransitionCallback(onExiting);
var handleExit = normalizedTransitionCallback(function (node) {
var transitionProps = getTransitionProps({
style: style,
timeout: timeout,
easing: easing
}, {
mode: 'exit'
});
node.style.webkitTransition = theme.transitions.create('transform', transitionProps);
node.style.transition = theme.transitions.create('transform', transitionProps);
if (onExit) {
onExit(node);
}
});
var handleExited = normalizedTransitionCallback(onExited);
var handleAddEndListener = function handleAddEndListener(next) {
if (addEndListener) {
// Old call signature before `react-transition-group` implemented `nodeRef`
addEndListener(nodeRef.current, next);
}
};
return /*#__PURE__*/_jsx(TransitionComponent, _extends({
appear: appear,
in: inProp,
nodeRef: nodeRef,
onEnter: handleEnter,
onEntered: handleEntered,
onEntering: handleEntering,
onExit: handleExit,
onExited: handleExited,
onExiting: handleExiting,
addEndListener: handleAddEndListener,
timeout: timeout
}, other, {
children: function children(state, childProps) {
return /*#__PURE__*/React.cloneElement(_children, _extends({
style: _extends({
transform: 'scale(0)',
visibility: state === 'exited' && !inProp ? 'hidden' : undefined
}, styles[state], style, _children.props.style),
ref: handleRef
}, childProps));
}
}));
});
process.env.NODE_ENV !== "production" ? Zoom.propTypes
/* remove-proptypes */
= {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the d.ts file and run "yarn proptypes" |
// ----------------------------------------------------------------------
/**
* Add a custom transition end trigger. Called with the transitioning DOM
* node and a done callback. Allows for more fine grained transition end
* logic. Note: Timeouts are still used as a fallback if provided.
*/
addEndListener: PropTypes.func,
/**
* Perform the enter transition when it first mounts if `in` is also `true`.
* Set this to `false` to disable this behavior.
* @default true
*/
appear: PropTypes.bool,
/**
* A single child content element.
*/
children: elementAcceptingRef.isRequired,
/**
* The transition timing function.
* You may specify a single easing or a object containing enter and exit values.
*/
easing: PropTypes.oneOfType([PropTypes.shape({
enter: PropTypes.string,
exit: PropTypes.string
}), PropTypes.string]),
/**
* If `true`, the component will transition in.
*/
in: PropTypes.bool,
/**
* @ignore
*/
onEnter: PropTypes.func,
/**
* @ignore
*/
onEntered: PropTypes.func,
/**
* @ignore
*/
onEntering: PropTypes.func,
/**
* @ignore
*/
onExit: PropTypes.func,
/**
* @ignore
*/
onExited: PropTypes.func,
/**
* @ignore
*/
onExiting: PropTypes.func,
/**
* @ignore
*/
style: PropTypes.object,
/**
* The duration for the transition, in milliseconds.
* You may specify a single timeout for all transitions, or individually with an object.
* @default {
* enter: duration.enteringScreen,
* exit: duration.leavingScreen,
* }
*/
timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
appear: PropTypes.number,
enter: PropTypes.number,
exit: PropTypes.number
})])
} : void 0;
export default Zoom;