function shallowRecursively(wrapper, selector, _ref) {
let {
context
} = _ref,
other = _objectWithoutPropertiesLoose(_ref, ["context"]);
if (wrapper.isEmptyRender() || typeof wrapper.getElement().type === 'string') {
return wrapper;
}
let newContext = context;
const instance = wrapper.root().instance(); // The instance can be null with a stateless functional component and react >= 16.
if (instance && instance.getChildContext) {
newContext = _extends({}, context, instance.getChildContext());
}
const nextWrapper = wrapper.shallow(_extends({
context: newContext
}, other));
if (selector && wrapper.is(selector)) {
return nextWrapper;
}
return shallowRecursively(nextWrapper, selector, {
context: newContext
});
}
render() {
const _this$props = this.props,
{
anchor: anchorProp,
children,
classes,
className,
elevation,
ModalProps: {
BackdropProps: BackdropPropsProp
} = {},
onClose,
open,
PaperProps,
SlideProps,
theme,
transitionDuration,
variant
} = _this$props,
ModalProps = _objectWithoutProperties(_this$props.ModalProps, ["BackdropProps"]),
other = _objectWithoutProperties(_this$props, ["anchor", "children", "classes", "className", "elevation", "ModalProps", "onClose", "open", "PaperProps", "SlideProps", "theme", "transitionDuration", "variant"]);
const anchor = getAnchor(this.props);
const drawer = React.createElement(Paper, _extends({
elevation: variant === 'temporary' ? elevation : 0,
square: true,
className: classNames(classes.paper, classes[`paperAnchor${capitalize(anchor)}`], {
[classes[`paperAnchorDocked${capitalize(anchor)}`]]: variant !== 'temporary'
})
}, PaperProps), children);
if (variant === 'permanent') {
return React.createElement("div", _extends({
className: classNames(classes.docked, className)
}, other), drawer);
}
const slidingDrawer = React.createElement(Slide, _extends({
in: open,
direction: oppositeDirection[anchor],
timeout: transitionDuration,
appear: this.mounted
}, SlideProps), drawer);
if (variant === 'persistent') {
return React.createElement("div", _extends({
className: classNames(classes.docked, className)
}, other), slidingDrawer);
} // variant === temporary
return React.createElement(Modal, _extends({
BackdropProps: _objectSpread({}, BackdropPropsProp, {
transitionDuration
}),
className: classNames(classes.modal, className),
open: open,
onClose: onClose
}, other, ModalProps), slidingDrawer);
}
return React.createElement(ListContext.Consumer, null, ({
dense
}) => {
let primary = primaryProp != null ? primaryProp : children;
if (primary != null && primary.type !== Typography && !disableTypography) {
primary = React.createElement(Typography, _extends({
variant: theme.typography.useNextVariants ? 'body1' : 'subheading',
className: classNames(classes.primary, {
[classes.textDense]: dense
}),
component: "span"
}, primaryTypographyProps), primary);
}
let secondary = secondaryProp;
if (secondary != null && secondary.type !== Typography && !disableTypography) {
secondary = React.createElement(Typography, _extends({
className: classNames(classes.secondary, {
[classes.textDense]: dense
}),
color: "textSecondary"
}, secondaryTypographyProps), secondary);
}
return React.createElement("div", _extends({
className: classNames(classes.root, {
[classes.dense]: dense,
[classes.inset]: inset
}, classNameProp)
}, other), primary, secondary);
});
function Dialog(props) {
const {
BackdropProps,
children,
classes,
className,
disableBackdropClick,
disableEscapeKeyDown,
fullScreen,
fullWidth,
maxWidth,
onBackdropClick,
onClose,
onEnter,
onEntered,
onEntering,
onEscapeKeyDown,
onExit,
onExited,
onExiting,
open,
PaperProps,
scroll,
TransitionComponent,
transitionDuration,
TransitionProps
} = props,
other = _objectWithoutProperties(props, ["BackdropProps", "children", "classes", "className", "disableBackdropClick", "disableEscapeKeyDown", "fullScreen", "fullWidth", "maxWidth", "onBackdropClick", "onClose", "onEnter", "onEntered", "onEntering", "onEscapeKeyDown", "onExit", "onExited", "onExiting", "open", "PaperProps", "scroll", "TransitionComponent", "transitionDuration", "TransitionProps"]);
return React.createElement(Modal, _extends({
className: classNames(classes.root, classes[`scroll${capitalize(scroll)}`], className),
BackdropProps: _objectSpread({
transitionDuration
}, BackdropProps),
disableBackdropClick: disableBackdropClick,
disableEscapeKeyDown: disableEscapeKeyDown,
onBackdropClick: onBackdropClick,
onEscapeKeyDown: onEscapeKeyDown,
onClose: onClose,
open: open,
role: "dialog"
}, other), React.createElement(TransitionComponent, _extends({
appear: true,
in: open,
timeout: transitionDuration,
onEnter: onEnter,
onEntering: onEntering,
onEntered: onEntered,
onExit: onExit,
onExiting: onExiting,
onExited: onExited
}, TransitionProps), React.createElement(Paper, _extends({
elevation: 24,
className: classNames(classes.paper, classes[`paperScroll${capitalize(scroll)}`], {
[classes[`paperWidth${maxWidth ? capitalize(maxWidth) : ''}`]]: maxWidth,
[classes.paperFullScreen]: fullScreen,
[classes.paperFullWidth]: fullWidth
})
}, PaperProps), children)));
}
function StepContent(props) {
const {
active,
children,
classes,
className,
last,
orientation,
TransitionComponent,
transitionDuration: transitionDurationProp,
TransitionProps
} = props,
other = _objectWithoutPropertiesLoose(props, ["active", "alternativeLabel", "children", "classes", "className", "completed", "last", "optional", "orientation", "TransitionComponent", "transitionDuration", "TransitionProps"]);
process.env.NODE_ENV !== "production" ? warning(orientation === 'vertical', 'Material-UI: <StepContent /> is only designed for use with the vertical stepper.') : void 0;
let transitionDuration = transitionDurationProp;
if (transitionDurationProp === 'auto' && !TransitionComponent.muiSupportAuto) {
transitionDuration = undefined;
}
return React.createElement("div", _extends({
className: classNames(classes.root, {
[classes.last]: last
}, className)
}, other), React.createElement(TransitionComponent, _extends({
in: active,
className: classes.transition,
timeout: transitionDuration,
unmountOnExit: true
}, TransitionProps), children));
}
gutters: (styles = {}) => _extends({
paddingLeft: spacing.unit * 2,
paddingRight: spacing.unit * 2
}, styles, {
[breakpoints.up('sm')]: _extends({
paddingLeft: spacing.unit * 3,
paddingRight: spacing.unit * 3
}, styles[breakpoints.up('sm')])
}),
render() {
const _this$props = this.props,
{
children: childrenProp,
classes,
className: classNameProp,
CollapseProps: CollapsePropsProp,
defaultExpanded,
disabled,
expanded: expandedProp,
onChange
} = _this$props,
other = _objectWithoutProperties(_this$props, ["children", "classes", "className", "CollapseProps", "defaultExpanded", "disabled", "expanded", "onChange"]);
const expanded = this.isControlled ? expandedProp : this.state.expanded;
const className = classNames(classes.root, {
[classes.expanded]: expanded,
[classes.disabled]: disabled
}, classNameProp);
let summary = null;
const children = React.Children.map(childrenProp, child => {
if (!React.isValidElement(child)) {
return null;
}
process.env.NODE_ENV !== "production" ? warning(child.type !== React.Fragment, ["Material-UI: the ExpansionPanel component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n')) : void 0;
if (isMuiElement(child, ['ExpansionPanelSummary'])) {
summary = React.cloneElement(child, {
disabled,
expanded,
onChange: this.handleChange
});
return null;
}
return child;
});
const CollapseProps = !expanded ? {
'aria-hidden': 'true'
} : null;
return React.createElement(Paper, _extends({
className: className,
elevation: 1,
square: true
}, other), summary, React.createElement(Collapse, _extends({
in: expanded,
timeout: "auto"
}, CollapseProps, CollapsePropsProp), children));
}
render() {
const _this$props = this.props,
{
children,
className,
onBlur,
onKeyDown
} = _this$props,
other = _objectWithoutProperties(_this$props, ["children", "className", "onBlur", "onKeyDown"]);
return React.createElement(List, _extends({
role: "menu",
ref: ref => {
this.listRef = ReactDOM.findDOMNode(ref);
},
className: className,
onKeyDown: this.handleKeyDown,
onBlur: this.handleBlur
}, other), React.Children.map(children, (child, index) => {
if (!React.isValidElement(child)) {
return null;
}
process.env.NODE_ENV !== "production" ? warning(child.type !== React.Fragment, ["Material-UI: the MenuList component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n')) : void 0;
return React.cloneElement(child, {
tabIndex: index === this.state.currentTabIndex ? 0 : -1,
ref: child.props.selected ? ref => {
this.selectedItemRef = ReactDOM.findDOMNode(ref);
} : undefined,
onFocus: this.handleItemFocus
});
}));
}
function SvgIcon(props) {
const {
children,
classes,
className: classNameProp,
color,
component: Component,
fontSize,
nativeColor,
titleAccess,
viewBox
} = props,
other = _objectWithoutProperties(props, ["children", "classes", "className", "color", "component", "fontSize", "nativeColor", "titleAccess", "viewBox"]);
const className = classNames(classes.root, {
[classes.fontSizeInherit]: fontSize === 'inherit',
[classes[`color${capitalize(color)}`]]: color !== 'inherit'
}, classNameProp);
return React.createElement(Component, _extends({
className: className,
focusable: "false",
viewBox: viewBox,
color: nativeColor,
"aria-hidden": titleAccess ? 'false' : 'true'
}, other), children, titleAccess ? React.createElement("title", null, titleAccess) : null);
}
function FormLabel(props, context) {
const {
children,
classes,
className: classNameProp,
component: Component,
disabled,
error,
filled,
focused,
required
} = props,
other = _objectWithoutProperties(props, ["children", "classes", "className", "component", "disabled", "error", "filled", "focused", "required"]);
const fcs = formControlState({
props,
context,
states: ['required', 'focused', 'disabled', 'error', 'filled']
});
return React.createElement(Component, _extends({
className: classNames(classes.root, {
[classes.disabled]: fcs.disabled,
[classes.error]: fcs.error,
[classes.filled]: fcs.filled,
[classes.focused]: fcs.focused,
[classes.required]: fcs.required
}, classNameProp)
}, other), children, fcs.required && React.createElement("span", {
className: classNames(classes.asterisk, {
[classes.error]: fcs.error
})
}, '\u2009*'));
}
function NativeSelectInput(props) {
const {
children,
classes,
className,
disabled,
IconComponent,
inputRef,
name,
onChange,
value,
variant
} = props,
other = _objectWithoutPropertiesLoose(props, ["children", "classes", "className", "disabled", "IconComponent", "inputRef", "name", "onChange", "value", "variant"]);
return React.createElement("div", {
className: classes.root
}, React.createElement("select", _extends({
className: classNames(classes.select, {
[classes.filled]: variant === 'filled',
[classes.outlined]: variant === 'outlined',
[classes.disabled]: disabled
}, className),
name: name,
disabled: disabled,
onChange: onChange,
value: value,
ref: inputRef
}, other), children), React.createElement(IconComponent, {
className: classes.icon
}));
}
function StepButton(props) {
const {
active,
alternativeLabel,
children,
classes,
className: classNameProp,
completed,
disabled,
icon,
last,
optional,
orientation
} = props,
other = _objectWithoutProperties(props, ["active", "alternativeLabel", "children", "classes", "className", "completed", "disabled", "icon", "last", "optional", "orientation"]);
const childProps = {
active,
alternativeLabel,
completed,
disabled,
icon,
optional,
orientation
};
const child = isMuiElement(children, ['StepLabel']) ? React.cloneElement(children, childProps) : React.createElement(StepLabel, childProps, children);
return React.createElement(ButtonBase, _extends({
disabled: disabled,
TouchRippleProps: {
className: classes.touchRipple
},
className: classNames(classes.root, classes[orientation], classNameProp)
}, other), child);
}
render() {
const _this$props = this.props,
{
classes,
className: classNameProp,
icon,
label,
selected,
showLabel: showLabelProp
} = _this$props,
other = _objectWithoutPropertiesLoose(_this$props, ["classes", "className", "icon", "label", "onChange", "onClick", "selected", "showLabel", "value"]);
const className = classNames(classes.root, {
[classes.selected]: selected,
[classes.iconOnly]: !showLabelProp && !selected
}, classNameProp);
const labelClassName = classNames(classes.label, {
[classes.selected]: selected,
[classes.iconOnly]: !showLabelProp && !selected
});
return React.createElement(ButtonBase, _extends({
className: className,
focusRipple: true,
onClick: this.handleChange
}, other), React.createElement("span", {
className: classes.wrapper
}, icon, React.createElement("span", {
className: labelClassName
}, label)));
}
render() {
const _this$props = this.props,
{
children,
classes,
className,
component: Component
} = _this$props,
other = _objectWithoutPropertiesLoose(_this$props, ["children", "classes", "className", "cols", "component", "rows"]);
return React.createElement(Component, _extends({
className: classNames(classes.root, className)
}, other), React.createElement(EventListener, {
target: "window",
onResize: this.handleResize
}), React.createElement("div", {
className: classes.tile
}, React.Children.map(children, child => {
if (!React.isValidElement(child)) {
return null;
}
if (child.type === 'img') {
return React.cloneElement(child, {
ref: node => {
this.imgElement = node;
}
});
}
return child;
})));
}
function Checkbox(props) {
const {
checkedIcon,
classes,
className,
color,
icon,
indeterminate,
indeterminateIcon,
inputProps
} = props,
other = _objectWithoutProperties(props, ["checkedIcon", "classes", "className", "color", "icon", "indeterminate", "indeterminateIcon", "inputProps"]);
return React.createElement(SwitchBase, _extends({
type: "checkbox",
checkedIcon: indeterminate ? indeterminateIcon : checkedIcon,
className: classNames({
[classes.indeterminate]: indeterminate
}, className),
classes: {
root: classNames(classes.root, classes[`color${capitalize(color)}`]),
checked: classes.checked,
disabled: classes.disabled
},
inputProps: _objectSpread({
'data-indeterminate': indeterminate
}, inputProps),
icon: indeterminate ? indeterminateIcon : icon
}, other));
}
function Switch(props) {
const {
classes,
className,
color
} = props,
other = _objectWithoutPropertiesLoose(props, ["classes", "className", "color"]);
return React.createElement("span", {
className: classNames(classes.root, className)
}, React.createElement(SwitchBase, _extends({
type: "checkbox",
icon: React.createElement("span", {
className: classes.icon
}),
classes: {
root: classNames(classes.switchBase, classes[`color${capitalize(color)}`]),
checked: classes.checked,
disabled: classes.disabled
},
checkedIcon: React.createElement("span", {
className: classNames(classes.icon, classes.iconChecked)
})
}, other)), React.createElement("span", {
className: classes.bar
}));
}
render() {
const _this$props = this.props,
{
children,
name,
value: valueProp
} = _this$props,
other = _objectWithoutPropertiesLoose(_this$props, ["children", "name", "value", "onChange"]);
const value = this.isControlled ? valueProp : this.state.value;
this.radios = [];
return React.createElement(FormGroup, _extends({
role: "radiogroup"
}, other), React.Children.map(children, child => {
if (!React.isValidElement(child)) {
return null;
}
process.env.NODE_ENV !== "production" ? warning(child.type !== React.Fragment, ["Material-UI: the RadioGroup component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n')) : void 0;
return React.cloneElement(child, {
name,
inputRef: node => {
if (node) {
this.radios.push(node);
}
},
checked: value === child.props.value,
onChange: createChainedFunction(child.props.onChange, this.handleChange)
});
}));
}
render() {
const _this$props = this.props,
{
classes,
className,
defaultValue,
rows,
style,
value
} = _this$props,
other = _objectWithoutPropertiesLoose(_this$props, ["classes", "className", "defaultValue", "onChange", "rows", "rowsMax", "style", "textareaRef", "value"]);
return React.createElement("div", {
className: classes.root
}, React.createElement(EventListener, {
target: "window",
onResize: this.handleResize
}), React.createElement("textarea", {
"aria-hidden": "true",
className: classnames(classes.textarea, classes.shadow),
readOnly: true,
ref: this.handleRefSinglelineShadow,
rows: "1",
tabIndex: -1,
value: ""
}), React.createElement("textarea", {
"aria-hidden": "true",
className: classnames(classes.textarea, classes.shadow),
defaultValue: defaultValue,
readOnly: true,
ref: this.handleRefShadow,
rows: rows,
tabIndex: -1,
value: value
}), React.createElement("textarea", _extends({
rows: rows,
className: classnames(classes.textarea, className),
defaultValue: defaultValue,
value: value,
onChange: this.handleChange,
ref: this.handleRefInput,
style: _extends({
height: this.state.height
}, style)
}, other)));
}
}, PopperProps), ({
placement: placementInner,
TransitionProps: TransitionPropsInner
}) => React.createElement(TransitionComponent, _extends({
timeout: theme.transitions.duration.shorter
}, TransitionPropsInner, TransitionProps), React.createElement("div", {
className: classNames(classes.tooltip, {
[classes.touch]: this.ignoreNonTouchEvents
}, classes[`tooltipPlacement${capitalize(placementInner.split('-')[0])}`])
}, title))));
function InputLabel(props) {
const {
children,
classes,
className: classNameProp,
disableAnimation,
FormLabelClasses,
muiFormControl,
shrink: shrinkProp
} = props,
other = _objectWithoutPropertiesLoose(props, ["children", "classes", "className", "disableAnimation", "FormLabelClasses", "margin", "muiFormControl", "shrink", "variant"]);
let shrink = shrinkProp;
if (typeof shrink === 'undefined' && muiFormControl) {
shrink = muiFormControl.filled || muiFormControl.focused || muiFormControl.adornedStart;
}
const fcs = formControlState({
props,
muiFormControl,
states: ['margin', 'variant']
});
const className = classNames(classes.root, {
[classes.formControl]: muiFormControl,
[classes.animated]: !disableAnimation,
[classes.shrink]: shrink,
[classes.marginDense]: fcs.margin === 'dense',
[classes.filled]: fcs.variant === 'filled',
[classes.outlined]: fcs.variant === 'outlined'
}, classNameProp);
return React.createElement(FormLabel, _extends({
"data-shrink": shrink,
className: className,
classes: _extends({
focused: classes.focused,
disabled: classes.disabled,
error: classes.error,
required: classes.required
}, FormLabelClasses)
}, other), children);
}
function TabIndicator(props) {
const {
classes,
className,
color
} = props,
other = _objectWithoutPropertiesLoose(props, ["classes", "className", "color"]);
return React.createElement("span", _extends({
className: classNames(classes.root, classes[`color${capitalize(color)}`], className)
}, other));
}
function ExpansionPanelActions(props) {
const {
children,
classes,
className
} = props,
other = _objectWithoutPropertiesLoose(props, ["children", "classes", "className"]);
return React.createElement("div", _extends({
className: classNames(classes.root, className)
}, other), cloneChildrenWithClassName(children, classes.action));
}
function DialogContent(props) {
const {
classes,
children,
className
} = props,
other = _objectWithoutPropertiesLoose(props, ["classes", "children", "className"]);
return React.createElement("div", _extends({
className: classNames(classes.root, className)
}, other), children);
}
function CardContent(props) {
const {
classes,
className,
component: Component
} = props,
other = _objectWithoutPropertiesLoose(props, ["classes", "className", "component"]);
return React.createElement(Component, _extends({
className: classNames(classes.root, className)
}, other));
}
render() {
const _this$props = this.props,
{
classes,
className,
component: Component
} = _this$props,
other = _objectWithoutProperties(_this$props, ["classes", "className", "component"]);
return React.createElement(Component, _extends({
className: classNames(classes.root, className)
}, other));
}
function FilledInput(props) {
const {
classes
} = props,
other = _objectWithoutProperties(props, ["classes"]);
return React.createElement(InputBase, _extends({
classes: _objectSpread({}, classes, {
root: classNames(classes.root, classes.underline, {}),
underline: null
})
}, other));
}
function Card(props) {
const {
classes,
className,
raised
} = props,
other = _objectWithoutPropertiesLoose(props, ["classes", "className", "raised"]);
return React.createElement(Paper, _extends({
className: classNames(classes.root, className),
elevation: raised ? 8 : 1
}, other));
}
function TableFooter(props) {
const {
classes,
className,
component: Component
} = props,
other = _objectWithoutPropertiesLoose(props, ["classes", "className", "component"]);
return React.createElement(Tablelvl2Context.Provider, {
value: contextValue
}, React.createElement(Component, _extends({
className: classNames(classes.root, className)
}, other)));
}
render() {
const _this$props = this.props,
{
anchorEl,
children,
container,
disablePortal,
keepMounted,
modifiers,
open,
placement: placementProps,
popperOptions,
theme,
transition
} = _this$props,
other = _objectWithoutProperties(_this$props, ["anchorEl", "children", "container", "disablePortal", "keepMounted", "modifiers", "open", "placement", "popperOptions", "theme", "transition"]);
const {
exited,
placement
} = this.state;
if (!keepMounted && !open && (!transition || exited)) {
return null;
}
const childProps = {
placement: placement || flipPlacement(theme, placementProps)
};
if (transition) {
childProps.TransitionProps = {
in: open,
onExited: this.handleExited
};
}
return React.createElement(Portal, {
onRendered: this.handleOpen,
disablePortal: disablePortal,
container: container
}, React.createElement("div", _extends({
role: "tooltip",
style: {
// Prevents scroll issue, waiting for Popper.js to add this style once initiated.
position: 'absolute'
}
}, other), typeof children === 'function' ? children(childProps) : children));
}
function MobileStepper(props) {
const {
activeStep,
backButton,
classes,
className: classNameProp,
LinearProgressProps,
nextButton,
position,
steps,
variant
} = props,
other = _objectWithoutProperties(props, ["activeStep", "backButton", "classes", "className", "LinearProgressProps", "nextButton", "position", "steps", "variant"]);
const className = classNames(classes.root, classes[`position${capitalize(position)}`], classNameProp);
return React.createElement(Paper, _extends({
square: true,
elevation: 0,
className: className
}, other), backButton, variant === 'dots' && React.createElement("div", {
className: classes.dots
}, [...new Array(steps)].map((_, step) => {
const dotClassName = classNames(classes.dot, {
[classes.dotActive]: step === activeStep
}); // eslint-disable-next-line react/no-array-index-key
return React.createElement("div", {
key: step,
className: dotClassName
});
})), variant === 'progress' && React.createElement(LinearProgress, _extends({
className: classes.progress,
variant: "determinate",
value: Math.ceil(activeStep / (steps - 1) * 100)
}, LinearProgressProps)), nextButton);
}