340 lines
10 KiB
JavaScript
340 lines
10 KiB
JavaScript
"use strict";
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.styles = exports.DELAY_RIPPLE = void 0;
|
|
|
|
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _propTypes = _interopRequireDefault(require("prop-types"));
|
|
|
|
var _reactTransitionGroup = require("react-transition-group");
|
|
|
|
var _clsx = _interopRequireDefault(require("clsx"));
|
|
|
|
var _withStyles = _interopRequireDefault(require("../styles/withStyles"));
|
|
|
|
var _Ripple = _interopRequireDefault(require("./Ripple"));
|
|
|
|
var DURATION = 550;
|
|
var DELAY_RIPPLE = 80;
|
|
exports.DELAY_RIPPLE = DELAY_RIPPLE;
|
|
|
|
var styles = function styles(theme) {
|
|
return {
|
|
/* Styles applied to the root element. */
|
|
root: {
|
|
overflow: 'hidden',
|
|
pointerEvents: 'none',
|
|
position: 'absolute',
|
|
zIndex: 0,
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0,
|
|
borderRadius: 'inherit'
|
|
},
|
|
|
|
/* Styles applied to the internal `Ripple` components `ripple` class. */
|
|
ripple: {
|
|
opacity: 0,
|
|
position: 'absolute'
|
|
},
|
|
|
|
/* Styles applied to the internal `Ripple` components `rippleVisible` class. */
|
|
rippleVisible: {
|
|
opacity: 0.3,
|
|
transform: 'scale(1)',
|
|
animation: "$enter ".concat(DURATION, "ms ").concat(theme.transitions.easing.easeInOut)
|
|
},
|
|
|
|
/* Styles applied to the internal `Ripple` components `ripplePulsate` class. */
|
|
ripplePulsate: {
|
|
animationDuration: "".concat(theme.transitions.duration.shorter, "ms")
|
|
},
|
|
|
|
/* Styles applied to the internal `Ripple` components `child` class. */
|
|
child: {
|
|
opacity: 1,
|
|
display: 'block',
|
|
width: '100%',
|
|
height: '100%',
|
|
borderRadius: '50%',
|
|
backgroundColor: 'currentColor'
|
|
},
|
|
|
|
/* Styles applied to the internal `Ripple` components `childLeaving` class. */
|
|
childLeaving: {
|
|
opacity: 0,
|
|
animation: "$exit ".concat(DURATION, "ms ").concat(theme.transitions.easing.easeInOut)
|
|
},
|
|
|
|
/* Styles applied to the internal `Ripple` components `childPulsate` class. */
|
|
childPulsate: {
|
|
position: 'absolute',
|
|
left: 0,
|
|
top: 0,
|
|
animation: "$pulsate 2500ms ".concat(theme.transitions.easing.easeInOut, " 200ms infinite")
|
|
},
|
|
'@keyframes enter': {
|
|
'0%': {
|
|
transform: 'scale(0)',
|
|
opacity: 0.1
|
|
},
|
|
'100%': {
|
|
transform: 'scale(1)',
|
|
opacity: 0.3
|
|
}
|
|
},
|
|
'@keyframes exit': {
|
|
'0%': {
|
|
opacity: 1
|
|
},
|
|
'100%': {
|
|
opacity: 0
|
|
}
|
|
},
|
|
'@keyframes pulsate': {
|
|
'0%': {
|
|
transform: 'scale(1)'
|
|
},
|
|
'50%': {
|
|
transform: 'scale(0.92)'
|
|
},
|
|
'100%': {
|
|
transform: 'scale(1)'
|
|
}
|
|
}
|
|
};
|
|
};
|
|
/**
|
|
* @ignore - internal component.
|
|
*
|
|
* TODO v5: Make private
|
|
*/
|
|
|
|
|
|
exports.styles = styles;
|
|
var TouchRipple = /*#__PURE__*/React.forwardRef(function TouchRipple(props, ref) {
|
|
var _props$center = props.center,
|
|
centerProp = _props$center === void 0 ? false : _props$center,
|
|
classes = props.classes,
|
|
className = props.className,
|
|
other = (0, _objectWithoutProperties2.default)(props, ["center", "classes", "className"]);
|
|
|
|
var _React$useState = React.useState([]),
|
|
ripples = _React$useState[0],
|
|
setRipples = _React$useState[1];
|
|
|
|
var nextKey = React.useRef(0);
|
|
var rippleCallback = React.useRef(null);
|
|
React.useEffect(function () {
|
|
if (rippleCallback.current) {
|
|
rippleCallback.current();
|
|
rippleCallback.current = null;
|
|
}
|
|
}, [ripples]); // Used to filter out mouse emulated events on mobile.
|
|
|
|
var ignoringMouseDown = React.useRef(false); // We use a timer in order to only show the ripples for touch "click" like events.
|
|
// We don't want to display the ripple for touch scroll events.
|
|
|
|
var startTimer = React.useRef(null); // This is the hook called once the previous timeout is ready.
|
|
|
|
var startTimerCommit = React.useRef(null);
|
|
var container = React.useRef(null);
|
|
React.useEffect(function () {
|
|
return function () {
|
|
clearTimeout(startTimer.current);
|
|
};
|
|
}, []);
|
|
var startCommit = React.useCallback(function (params) {
|
|
var pulsate = params.pulsate,
|
|
rippleX = params.rippleX,
|
|
rippleY = params.rippleY,
|
|
rippleSize = params.rippleSize,
|
|
cb = params.cb;
|
|
setRipples(function (oldRipples) {
|
|
return [].concat((0, _toConsumableArray2.default)(oldRipples), [/*#__PURE__*/React.createElement(_Ripple.default, {
|
|
key: nextKey.current,
|
|
classes: classes,
|
|
timeout: DURATION,
|
|
pulsate: pulsate,
|
|
rippleX: rippleX,
|
|
rippleY: rippleY,
|
|
rippleSize: rippleSize
|
|
})]);
|
|
});
|
|
nextKey.current += 1;
|
|
rippleCallback.current = cb;
|
|
}, [classes]);
|
|
var start = React.useCallback(function () {
|
|
var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var cb = arguments.length > 2 ? arguments[2] : undefined;
|
|
var _options$pulsate = options.pulsate,
|
|
pulsate = _options$pulsate === void 0 ? false : _options$pulsate,
|
|
_options$center = options.center,
|
|
center = _options$center === void 0 ? centerProp || options.pulsate : _options$center,
|
|
_options$fakeElement = options.fakeElement,
|
|
fakeElement = _options$fakeElement === void 0 ? false : _options$fakeElement;
|
|
|
|
if (event.type === 'mousedown' && ignoringMouseDown.current) {
|
|
ignoringMouseDown.current = false;
|
|
return;
|
|
}
|
|
|
|
if (event.type === 'touchstart') {
|
|
ignoringMouseDown.current = true;
|
|
}
|
|
|
|
var element = fakeElement ? null : container.current;
|
|
var rect = element ? element.getBoundingClientRect() : {
|
|
width: 0,
|
|
height: 0,
|
|
left: 0,
|
|
top: 0
|
|
}; // Get the size of the ripple
|
|
|
|
var rippleX;
|
|
var rippleY;
|
|
var rippleSize;
|
|
|
|
if (center || event.clientX === 0 && event.clientY === 0 || !event.clientX && !event.touches) {
|
|
rippleX = Math.round(rect.width / 2);
|
|
rippleY = Math.round(rect.height / 2);
|
|
} else {
|
|
var _ref = event.touches ? event.touches[0] : event,
|
|
clientX = _ref.clientX,
|
|
clientY = _ref.clientY;
|
|
|
|
rippleX = Math.round(clientX - rect.left);
|
|
rippleY = Math.round(clientY - rect.top);
|
|
}
|
|
|
|
if (center) {
|
|
rippleSize = Math.sqrt((2 * Math.pow(rect.width, 2) + Math.pow(rect.height, 2)) / 3); // For some reason the animation is broken on Mobile Chrome if the size if even.
|
|
|
|
if (rippleSize % 2 === 0) {
|
|
rippleSize += 1;
|
|
}
|
|
} else {
|
|
var sizeX = Math.max(Math.abs((element ? element.clientWidth : 0) - rippleX), rippleX) * 2 + 2;
|
|
var sizeY = Math.max(Math.abs((element ? element.clientHeight : 0) - rippleY), rippleY) * 2 + 2;
|
|
rippleSize = Math.sqrt(Math.pow(sizeX, 2) + Math.pow(sizeY, 2));
|
|
} // Touche devices
|
|
|
|
|
|
if (event.touches) {
|
|
// check that this isn't another touchstart due to multitouch
|
|
// otherwise we will only clear a single timer when unmounting while two
|
|
// are running
|
|
if (startTimerCommit.current === null) {
|
|
// Prepare the ripple effect.
|
|
startTimerCommit.current = function () {
|
|
startCommit({
|
|
pulsate: pulsate,
|
|
rippleX: rippleX,
|
|
rippleY: rippleY,
|
|
rippleSize: rippleSize,
|
|
cb: cb
|
|
});
|
|
}; // Delay the execution of the ripple effect.
|
|
|
|
|
|
startTimer.current = setTimeout(function () {
|
|
if (startTimerCommit.current) {
|
|
startTimerCommit.current();
|
|
startTimerCommit.current = null;
|
|
}
|
|
}, DELAY_RIPPLE); // We have to make a tradeoff with this value.
|
|
}
|
|
} else {
|
|
startCommit({
|
|
pulsate: pulsate,
|
|
rippleX: rippleX,
|
|
rippleY: rippleY,
|
|
rippleSize: rippleSize,
|
|
cb: cb
|
|
});
|
|
}
|
|
}, [centerProp, startCommit]);
|
|
var pulsate = React.useCallback(function () {
|
|
start({}, {
|
|
pulsate: true
|
|
});
|
|
}, [start]);
|
|
var stop = React.useCallback(function (event, cb) {
|
|
clearTimeout(startTimer.current); // The touch interaction occurs too quickly.
|
|
// We still want to show ripple effect.
|
|
|
|
if (event.type === 'touchend' && startTimerCommit.current) {
|
|
event.persist();
|
|
startTimerCommit.current();
|
|
startTimerCommit.current = null;
|
|
startTimer.current = setTimeout(function () {
|
|
stop(event, cb);
|
|
});
|
|
return;
|
|
}
|
|
|
|
startTimerCommit.current = null;
|
|
setRipples(function (oldRipples) {
|
|
if (oldRipples.length > 0) {
|
|
return oldRipples.slice(1);
|
|
}
|
|
|
|
return oldRipples;
|
|
});
|
|
rippleCallback.current = cb;
|
|
}, []);
|
|
React.useImperativeHandle(ref, function () {
|
|
return {
|
|
pulsate: pulsate,
|
|
start: start,
|
|
stop: stop
|
|
};
|
|
}, [pulsate, start, stop]);
|
|
return /*#__PURE__*/React.createElement("span", (0, _extends2.default)({
|
|
className: (0, _clsx.default)(classes.root, className),
|
|
ref: container
|
|
}, other), /*#__PURE__*/React.createElement(_reactTransitionGroup.TransitionGroup, {
|
|
component: null,
|
|
exit: true
|
|
}, ripples));
|
|
});
|
|
process.env.NODE_ENV !== "production" ? TouchRipple.propTypes = {
|
|
/**
|
|
* If `true`, the ripple starts at the center of the component
|
|
* rather than at the point of interaction.
|
|
*/
|
|
center: _propTypes.default.bool,
|
|
|
|
/**
|
|
* Override or extend the styles applied to the component.
|
|
* See [CSS API](#css) below for more details.
|
|
*/
|
|
classes: _propTypes.default.object.isRequired,
|
|
|
|
/**
|
|
* @ignore
|
|
*/
|
|
className: _propTypes.default.string
|
|
} : void 0;
|
|
|
|
var _default = (0, _withStyles.default)(styles, {
|
|
flip: false,
|
|
name: 'MuiTouchRipple'
|
|
})( /*#__PURE__*/React.memo(TouchRipple));
|
|
|
|
exports.default = _default; |