Techognito/react-playground
SHA256
1
0
Fork 0
Code Issues Activity

Added Statistics calculation

Browse source 
Statistics now show calculated values
This commit is contained in:
Techognito 2025-09-04 17:30:00 +02:00
parent fe87374e47
commit fc0f69dacb
2147 changed files with 141321 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

143
node_modules/@mui/x-date-pickers/internals/components/PickerFieldUI.d.ts generated vendored Normal file
View file

@ -0,0 +1,143 @@
import * as React from 'react';
import { TextFieldProps } from '@mui/material/TextField';
import { IconButtonProps } from '@mui/material/IconButton';
import { InputAdornmentProps } from '@mui/material/InputAdornment';
import { SvgIconProps } from '@mui/material/SvgIcon';
import { MakeOptional, SlotComponentPropsFromProps } from '@mui/x-internals/types';
import { FieldOwnerState } from "../../models/index.js";
import { UseFieldOwnerStateParameters } from "../hooks/useFieldOwnerState.js";
import type { UseFieldReturnValue, UseFieldProps } from "../hooks/useField/index.js";
import { PickersTextFieldProps } from "../../PickersTextField/index.js";
export declare const cleanFieldResponse: <TFieldResponse extends MakeOptional<UseFieldReturnValue<any, ExportedPickerFieldUIProps & {
[key: string]: any;
}>, "onClear" | "clearable">>({
enableAccessibleFieldDOMStructure,
...fieldResponse
}: TFieldResponse) => ExportedPickerFieldUIProps & {
openPickerAriaLabel: string;
textFieldProps: TextFieldProps | PickersTextFieldProps;
};
export declare const PickerFieldUIContext: React.Context<PickerFieldUIContextValue>;
/**
* Adds the button to open the Picker and the button to clear the value of the field.
* @ignore - internal component.
*/
export declare function PickerFieldUI<TEnableAccessibleFieldDOMStructure extends boolean, TProps extends UseFieldProps<TEnableAccessibleFieldDOMStructure>>(props: PickerFieldUIProps<TEnableAccessibleFieldDOMStructure, TProps>): React.JSX.Element;
export interface ExportedPickerFieldUIProps {
/**
* If `true`, a clear button will be shown in the field allowing value clearing.
* @default false
*/
clearable?: boolean;
/**
* Callback fired when the clear button is clicked.
*/
onClear?: React.MouseEventHandler;
/**
* The position at which the clear button is placed.
* If the field is not clearable, the button is not rendered.
* @default 'end'
*/
clearButtonPosition?: 'start' | 'end';
/**
* The position at which the opening button is placed.
* If there is no Picker to open, the button is not rendered
* @default 'end'
*/
openPickerButtonPosition?: 'start' | 'end';
}
export interface PickerFieldUIProps<TEnableAccessibleFieldDOMStructure extends boolean, TProps extends UseFieldProps<TEnableAccessibleFieldDOMStructure>> {
/**
* Overridable component slots.
* @default {}
*/
slots?: PickerFieldUISlots;
/**
* The props used for each component slot.
* @default {}
*/
slotProps?: PickerFieldUISlotProps;
/**
* Object returned by the `useField` hook or one of its wrapper (for example `useDateField`).
*/
fieldResponse: UseFieldReturnValue<TEnableAccessibleFieldDOMStructure, TProps>;
/**
* The component to use to render the Picker opening icon if none is provided in the Picker's slots.
*/
defaultOpenPickerIcon: React.ElementType;
}
export interface PickerFieldUISlots {
/**
* Form control with an input to render the value.
* @default <PickersTextField />, or <TextField /> from '@mui/material' if `enableAccessibleFieldDOMStructure` is `false`.
*/
textField?: React.ElementType;
/**
* Component displayed on the start or end input adornment used to open the Picker.
* @default InputAdornment
*/
inputAdornment?: React.ElementType<InputAdornmentProps>;
/**
* Button to clear the value.
* @default IconButton
*/
clearButton?: React.ElementType;
/**
* Icon to display in the button used to clean the value.
* @default ClearIcon
*/
clearIcon?: React.ElementType;
}
export interface PickerFieldUISlotsFromContext extends PickerFieldUISlots {
/**
* Button to open the Picker.
* @default IconButton
*/
openPickerButton?: React.ElementType<IconButtonProps>;
/**
* Icon to display in the button used to open the Picker.
*/
openPickerIcon?: React.ElementType;
}
export interface PickerFieldUISlotProps {
textField?: SlotComponentPropsFromProps<Omit<TextFieldProps, 'onKeyDown'> | PickersTextFieldProps, {}, FieldOwnerState>;
inputAdornment?: SlotComponentPropsFromProps<InputAdornmentProps, {}, FieldInputAdornmentOwnerState>;
clearIcon?: SlotComponentPropsFromProps<SvgIconProps, {}, FieldOwnerState>;
clearButton?: SlotComponentPropsFromProps<IconButtonProps, {}, FieldOwnerState>;
}
export interface PickerFieldUISlotPropsFromContext extends PickerFieldUISlotProps {
openPickerButton?: SlotComponentPropsFromProps<IconButtonProps, {}, FieldOwnerState>;
openPickerIcon?: SlotComponentPropsFromProps<SvgIconProps, {}, FieldOwnerState>;
}
interface FieldInputAdornmentOwnerState extends FieldOwnerState {
position: 'start' | 'end';
}
interface PickerFieldUIContextValue {
inputRef: React.Ref<HTMLInputElement> | undefined;
slots: PickerFieldUISlotsFromContext;
slotProps: PickerFieldUISlotPropsFromContext;
}
export declare function mergeSlotProps<TProps extends {}, TOwnerState extends FieldOwnerState>(slotPropsA: SlotComponentPropsFromProps<TProps, {}, TOwnerState> | undefined, slotPropsB: SlotComponentPropsFromProps<TProps, {}, TOwnerState> | undefined): Partial<TProps> | ((ownerState: TOwnerState) => {}) | undefined;
/**
* The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
* Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
*/
export declare function useFieldTextFieldProps<TProps extends UseFieldOwnerStateParameters & {
inputProps?: {};
InputProps?: {};
}>(parameters: UseFieldTextFieldPropsParameters): TProps;
interface UseFieldTextFieldPropsParameters {
slotProps: {
textField?: SlotComponentPropsFromProps<Omit<TextFieldProps, 'onKeyDown'> | PickersTextFieldProps, {}, FieldOwnerState>;
} | undefined;
ref: React.Ref<HTMLDivElement>;
externalForwardedProps: any;
}
export declare function PickerFieldUIContextProvider(props: PickerFieldUIContextProviderProps): React.JSX.Element;
interface PickerFieldUIContextProviderProps {
children: React.ReactNode;
inputRef: React.Ref<HTMLInputElement> | undefined;
slots: PickerFieldUISlotsFromContext | undefined;
slotProps: PickerFieldUISlotPropsFromContext | undefined;
}
export {};

337
node_modules/@mui/x-date-pickers/internals/components/PickerFieldUI.js generated vendored Normal file
View file

@ -0,0 +1,337 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickerFieldUI = PickerFieldUI;
exports.PickerFieldUIContext = void 0;
exports.PickerFieldUIContextProvider = PickerFieldUIContextProvider;
exports.cleanFieldResponse = void 0;
exports.mergeSlotProps = mergeSlotProps;
exports.useFieldTextFieldProps = useFieldTextFieldProps;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
var _resolveComponentProps = _interopRequireDefault(require("@mui/utils/resolveComponentProps"));
var _TextField = _interopRequireDefault(require("@mui/material/TextField"));
var _IconButton = _interopRequireDefault(require("@mui/material/IconButton"));
var _InputAdornment = _interopRequireDefault(require("@mui/material/InputAdornment"));
var _useSlotProps5 = _interopRequireDefault(require("@mui/utils/useSlotProps"));
var _useFieldOwnerState = require("../hooks/useFieldOwnerState");
var _hooks = require("../../hooks");
var _icons = require("../../icons");
var _useNullablePickerContext = require("../hooks/useNullablePickerContext");
var _PickersTextField = require("../../PickersTextField");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["enableAccessibleFieldDOMStructure"],
_excluded2 = ["InputProps", "readOnly", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
_excluded3 = ["onPaste", "onKeyDown", "inputMode", "readOnly", "InputProps", "inputProps", "inputRef", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
_excluded4 = ["ownerState"],
_excluded5 = ["ownerState"],
_excluded6 = ["ownerState"],
_excluded7 = ["ownerState"],
_excluded8 = ["InputProps", "inputProps"];
const cleanFieldResponse = _ref => {
let {
enableAccessibleFieldDOMStructure
} = _ref,
fieldResponse = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
if (enableAccessibleFieldDOMStructure) {
const {
InputProps,
readOnly,
onClear,
clearable,
clearButtonPosition,
openPickerButtonPosition,
openPickerAriaLabel
} = fieldResponse,
other = (0, _objectWithoutPropertiesLoose2.default)(fieldResponse, _excluded2);
return {
clearable,
onClear,
clearButtonPosition,
openPickerButtonPosition,
openPickerAriaLabel,
textFieldProps: (0, _extends2.default)({}, other, {
InputProps: (0, _extends2.default)({}, InputProps ?? {}, {
readOnly
})
})
};
}
const {
onPaste,
onKeyDown,
inputMode,
readOnly,
InputProps,
inputProps,
inputRef,
onClear,
clearable,
clearButtonPosition,
openPickerButtonPosition,
openPickerAriaLabel
} = fieldResponse,
other = (0, _objectWithoutPropertiesLoose2.default)(fieldResponse, _excluded3);
return {
clearable,
onClear,
clearButtonPosition,
openPickerButtonPosition,
openPickerAriaLabel,
textFieldProps: (0, _extends2.default)({}, other, {
InputProps: (0, _extends2.default)({}, InputProps ?? {}, {
readOnly
}),
inputProps: (0, _extends2.default)({}, inputProps ?? {}, {
inputMode,
onPaste,
onKeyDown,
ref: inputRef
})
})
};
};
exports.cleanFieldResponse = cleanFieldResponse;
const PickerFieldUIContext = exports.PickerFieldUIContext = /*#__PURE__*/React.createContext({
slots: {},
slotProps: {},
inputRef: undefined
});
/**
* Adds the button to open the Picker and the button to clear the value of the field.
* @ignore - internal component.
*/
if (process.env.NODE_ENV !== "production") PickerFieldUIContext.displayName = "PickerFieldUIContext";
function PickerFieldUI(props) {
const {
slots,
slotProps,
fieldResponse,
defaultOpenPickerIcon
} = props;
const translations = (0, _hooks.usePickerTranslations)();
const pickerContext = (0, _useNullablePickerContext.useNullablePickerContext)();
const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
const {
textFieldProps,
onClear,
clearable,
openPickerAriaLabel,
clearButtonPosition: clearButtonPositionProp = 'end',
openPickerButtonPosition: openPickerButtonPositionProp = 'end'
} = cleanFieldResponse(fieldResponse);
const ownerState = (0, _useFieldOwnerState.useFieldOwnerState)(textFieldProps);
const handleClickOpeningButton = (0, _useEventCallback.default)(event => {
event.preventDefault();
pickerContext?.setOpen(prev => !prev);
});
const triggerStatus = pickerContext ? pickerContext.triggerStatus : 'hidden';
const clearButtonPosition = clearable ? clearButtonPositionProp : null;
const openPickerButtonPosition = triggerStatus !== 'hidden' ? openPickerButtonPositionProp : null;
const TextField = slots?.textField ?? pickerFieldUIContext.slots.textField ?? (fieldResponse.enableAccessibleFieldDOMStructure === false ? _TextField.default : _PickersTextField.PickersTextField);
const InputAdornment = slots?.inputAdornment ?? pickerFieldUIContext.slots.inputAdornment ?? _InputAdornment.default;
const _useSlotProps = (0, _useSlotProps5.default)({
elementType: InputAdornment,
externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.inputAdornment, slotProps?.inputAdornment),
additionalProps: {
position: 'start'
},
ownerState: (0, _extends2.default)({}, ownerState, {
position: 'start'
})
}),
startInputAdornmentProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps, _excluded4);
const _useSlotProps2 = (0, _useSlotProps5.default)({
elementType: InputAdornment,
externalSlotProps: slotProps?.inputAdornment,
additionalProps: {
position: 'end'
},
ownerState: (0, _extends2.default)({}, ownerState, {
position: 'end'
})
}),
endInputAdornmentProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps2, _excluded5);
const OpenPickerButton = pickerFieldUIContext.slots.openPickerButton ?? _IconButton.default;
// We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
const _useSlotProps3 = (0, _useSlotProps5.default)({
elementType: OpenPickerButton,
externalSlotProps: pickerFieldUIContext.slotProps.openPickerButton,
additionalProps: {
disabled: triggerStatus === 'disabled',
onClick: handleClickOpeningButton,
'aria-label': openPickerAriaLabel,
edge:
// open button is always rendered at the edge
textFieldProps.variant !== 'standard' ? openPickerButtonPosition : false
},
ownerState
}),
openPickerButtonProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps3, _excluded6);
const OpenPickerIcon = pickerFieldUIContext.slots.openPickerIcon ?? defaultOpenPickerIcon;
const openPickerIconProps = (0, _useSlotProps5.default)({
elementType: OpenPickerIcon,
externalSlotProps: pickerFieldUIContext.slotProps.openPickerIcon,
ownerState
});
const ClearButton = slots?.clearButton ?? pickerFieldUIContext.slots.clearButton ?? _IconButton.default;
// We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
const _useSlotProps4 = (0, _useSlotProps5.default)({
elementType: ClearButton,
externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearButton, slotProps?.clearButton),
className: 'clearButton',
additionalProps: {
title: translations.fieldClearLabel,
tabIndex: -1,
onClick: onClear,
disabled: fieldResponse.disabled || fieldResponse.readOnly,
edge:
// clear button can only be at the edge if it's position differs from the open button
textFieldProps.variant !== 'standard' && clearButtonPosition !== openPickerButtonPosition ? clearButtonPosition : false
},
ownerState
}),
clearButtonProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps4, _excluded7);
const ClearIcon = slots?.clearIcon ?? pickerFieldUIContext.slots.clearIcon ?? _icons.ClearIcon;
const clearIconProps = (0, _useSlotProps5.default)({
elementType: ClearIcon,
externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearIcon, slotProps?.clearIcon),
additionalProps: {
fontSize: 'small'
},
ownerState
});
textFieldProps.ref = (0, _useForkRef.default)(textFieldProps.ref, pickerContext?.rootRef);
if (!textFieldProps.InputProps) {
textFieldProps.InputProps = {};
}
if (pickerContext) {
textFieldProps.InputProps.ref = pickerContext.triggerRef;
}
if (!textFieldProps.InputProps?.startAdornment && (clearButtonPosition === 'start' || openPickerButtonPosition === 'start')) {
textFieldProps.InputProps.startAdornment = /*#__PURE__*/(0, _jsxRuntime.jsxs)(InputAdornment, (0, _extends2.default)({}, startInputAdornmentProps, {
children: [openPickerButtonPosition === 'start' && /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerButton, (0, _extends2.default)({}, openPickerButtonProps, {
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerIcon, (0, _extends2.default)({}, openPickerIconProps))
})), clearButtonPosition === 'start' && /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearButton, (0, _extends2.default)({}, clearButtonProps, {
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearIcon, (0, _extends2.default)({}, clearIconProps))
}))]
}));
}
if (!textFieldProps.InputProps?.endAdornment && (clearButtonPosition === 'end' || openPickerButtonPosition === 'end')) {
textFieldProps.InputProps.endAdornment = /*#__PURE__*/(0, _jsxRuntime.jsxs)(InputAdornment, (0, _extends2.default)({}, endInputAdornmentProps, {
children: [clearButtonPosition === 'end' && /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearButton, (0, _extends2.default)({}, clearButtonProps, {
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearIcon, (0, _extends2.default)({}, clearIconProps))
})), openPickerButtonPosition === 'end' && /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerButton, (0, _extends2.default)({}, openPickerButtonProps, {
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerIcon, (0, _extends2.default)({}, openPickerIconProps))
}))]
}));
}
if (clearButtonPosition != null) {
textFieldProps.sx = [{
'& .clearButton': {
opacity: 1
},
'@media (pointer: fine)': {
'& .clearButton': {
opacity: 0
},
'&:hover, &:focus-within': {
'.clearButton': {
opacity: 1
}
}
}
}, ...(Array.isArray(textFieldProps.sx) ? textFieldProps.sx : [textFieldProps.sx])];
}
return /*#__PURE__*/(0, _jsxRuntime.jsx)(TextField, (0, _extends2.default)({}, textFieldProps));
}
function mergeSlotProps(slotPropsA, slotPropsB) {
if (!slotPropsA) {
return slotPropsB;
}
if (!slotPropsB) {
return slotPropsA;
}
return ownerState => {
return (0, _extends2.default)({}, (0, _resolveComponentProps.default)(slotPropsB, ownerState), (0, _resolveComponentProps.default)(slotPropsA, ownerState));
};
}
/**
* The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
* Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
*/
function useFieldTextFieldProps(parameters) {
const {
ref,
externalForwardedProps,
slotProps
} = parameters;
const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
const pickerContext = (0, _useNullablePickerContext.useNullablePickerContext)();
const ownerState = (0, _useFieldOwnerState.useFieldOwnerState)(externalForwardedProps);
const {
InputProps,
inputProps
} = externalForwardedProps,
otherExternalForwardedProps = (0, _objectWithoutPropertiesLoose2.default)(externalForwardedProps, _excluded8);
const textFieldProps = (0, _useSlotProps5.default)({
elementType: _PickersTextField.PickersTextField,
externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.textField, slotProps?.textField),
externalForwardedProps: otherExternalForwardedProps,
additionalProps: {
ref,
sx: pickerContext?.rootSx,
label: pickerContext?.label,
name: pickerContext?.name,
className: pickerContext?.rootClassName,
inputRef: pickerFieldUIContext.inputRef
},
ownerState
});
// TODO: Remove when mui/material-ui#35088 will be merged
textFieldProps.inputProps = (0, _extends2.default)({}, inputProps, textFieldProps.inputProps);
textFieldProps.InputProps = (0, _extends2.default)({}, InputProps, textFieldProps.InputProps);
return textFieldProps;
}
function PickerFieldUIContextProvider(props) {
const {
slots = {},
slotProps = {},
inputRef,
children
} = props;
const contextValue = React.useMemo(() => ({
inputRef,
slots: {
openPickerButton: slots.openPickerButton,
openPickerIcon: slots.openPickerIcon,
textField: slots.textField,
inputAdornment: slots.inputAdornment,
clearIcon: slots.clearIcon,
clearButton: slots.clearButton
},
slotProps: {
openPickerButton: slotProps.openPickerButton,
openPickerIcon: slotProps.openPickerIcon,
textField: slotProps.textField,
inputAdornment: slotProps.inputAdornment,
clearIcon: slotProps.clearIcon,
clearButton: slotProps.clearButton
}
}), [inputRef, slots.openPickerButton, slots.openPickerIcon, slots.textField, slots.inputAdornment, slots.clearIcon, slots.clearButton, slotProps.openPickerButton, slotProps.openPickerIcon, slotProps.textField, slotProps.inputAdornment, slotProps.clearIcon, slotProps.clearButton]);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickerFieldUIContext.Provider, {
value: contextValue,
children: children
});
}

67
node_modules/@mui/x-date-pickers/internals/components/PickerPopper/PickerPopper.d.ts generated vendored Normal file
View file

@ -0,0 +1,67 @@
import * as React from 'react';
import { PaperProps as MuiPaperProps, PaperProps } from '@mui/material/Paper';
import { PopperProps as MuiPopperProps, PopperPlacementType, PopperProps } from '@mui/material/Popper';
import { TrapFocusProps as MuiTrapFocusProps } from '@mui/material/Unstable_TrapFocus';
import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
import { PickerPopperClasses } from "./pickerPopperClasses.js";
import { PickerOwnerState } from "../../../models/index.js";
export interface PickerPopperOwnerState extends PickerOwnerState {
popperPlacement: PopperPlacementType;
}
export interface PickerPopperSlots {
/**
* Custom component for the paper rendered inside the desktop picker's Popper.
* @default PickerPopperPaper
*/
desktopPaper?: React.JSXElementConstructor<MuiPaperProps>;
/**
* Custom component for the desktop popper [Transition](https://mui.com/material-ui/transitions/).
* @default Grow or Fade from '@mui/material' when `reduceAnimations` is `true`.
*/
desktopTransition?: React.JSXElementConstructor<MuiTransitionProps>;
/**
* Custom component for trapping the focus inside the views on desktop.
* @default TrapFocus from '@mui/material'.
*/
desktopTrapFocus?: React.JSXElementConstructor<MuiTrapFocusProps>;
/**
* Custom component for the popper inside which the views are rendered on desktop.
* @default Popper from '@mui/material'.
*/
popper?: React.ElementType<MuiPopperProps>;
}
export interface PickerPopperSlotProps {
/**
* Props passed down to the desktop [Paper](https://mui.com/material-ui/api/paper/) component.
*/
desktopPaper?: SlotComponentPropsFromProps<PaperProps, {}, PickerPopperOwnerState>;
/**
* Props passed down to the desktop [Transition](https://mui.com/material-ui/transitions/) component.
*/
desktopTransition?: Partial<MuiTransitionProps>;
/**
* Props passed down to the [FocusTrap](https://mui.com/base-ui/react-focus-trap/) component on desktop.
*/
desktopTrapFocus?: Partial<MuiTrapFocusProps>;
/**
* Props passed down to [Popper](https://mui.com/material-ui/api/popper/) component.
*/
popper?: SlotComponentPropsFromProps<PopperProps, {}, PickerOwnerState>;
}
export interface ExportedPickerPopperProps {
/**
* Override or extend the styles applied to the component.
*/
classes?: Partial<PickerPopperClasses>;
/**
* @default "bottom-start"
*/
placement?: MuiPopperProps['placement'];
}
export interface PickerPopperProps extends ExportedPickerPopperProps {
children?: React.ReactNode;
slots?: PickerPopperSlots;
slotProps?: PickerPopperSlotProps;
}
export declare function PickerPopper(inProps: PickerPopperProps): React.JSX.Element;

350
node_modules/@mui/x-date-pickers/internals/components/PickerPopper/PickerPopper.js generated vendored Normal file
View file

@ -0,0 +1,350 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickerPopper = PickerPopper;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _useSlotProps = _interopRequireDefault(require("@mui/utils/useSlotProps"));
var _Grow = _interopRequireDefault(require("@mui/material/Grow"));
var _Fade = _interopRequireDefault(require("@mui/material/Fade"));
var _Paper = _interopRequireDefault(require("@mui/material/Paper"));
var _Popper = _interopRequireDefault(require("@mui/material/Popper"));
var _Unstable_TrapFocus = _interopRequireDefault(require("@mui/material/Unstable_TrapFocus"));
var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
var _ownerDocument = _interopRequireDefault(require("@mui/utils/ownerDocument"));
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _styles = require("@mui/material/styles");
var _pickerPopperClasses = require("./pickerPopperClasses");
var _utils = require("../../utils/utils");
var _usePickerPrivateContext = require("../../hooks/usePickerPrivateContext");
var _hooks = require("../../../hooks");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["PaperComponent", "ownerState", "children", "paperSlotProps", "paperClasses", "onPaperClick", "onPaperTouchStart"];
const useUtilityClasses = classes => {
const slots = {
root: ['root'],
paper: ['paper']
};
return (0, _composeClasses.default)(slots, _pickerPopperClasses.getPickerPopperUtilityClass, classes);
};
const PickerPopperRoot = (0, _styles.styled)(_Popper.default, {
name: 'MuiPickerPopper',
slot: 'Root'
})(({
theme
}) => ({
zIndex: theme.zIndex.modal
}));
const PickerPopperPaper = (0, _styles.styled)(_Paper.default, {
name: 'MuiPickerPopper',
slot: 'Paper'
})({
outline: 0,
transformOrigin: 'top center',
variants: [{
props: ({
popperPlacement
}) => new Set(['top', 'top-start', 'top-end']).has(popperPlacement),
style: {
transformOrigin: 'bottom center'
}
}]
});
function clickedRootScrollbar(event, doc) {
return doc.documentElement.clientWidth < event.clientX || doc.documentElement.clientHeight < event.clientY;
}
/**
* Based on @mui/material/ClickAwayListener without the customization.
* We can probably strip away even more since children won't be portaled.
* @param {boolean} active Only listen to clicks when the popper is opened.
* @param {(event: MouseEvent | TouchEvent) => void} onClickAway The callback to call when clicking outside the popper.
* @returns {Array} The ref and event handler to listen to the outside clicks.
*/
function useClickAwayListener(active, onClickAway) {
const movedRef = React.useRef(false);
const syntheticEventRef = React.useRef(false);
const nodeRef = React.useRef(null);
const activatedRef = React.useRef(false);
React.useEffect(() => {
if (!active) {
return undefined;
}
// Ensure that this hook is not "activated" synchronously.
// https://github.com/facebook/react/issues/20074
function armClickAwayListener() {
activatedRef.current = true;
}
document.addEventListener('mousedown', armClickAwayListener, true);
document.addEventListener('touchstart', armClickAwayListener, true);
return () => {
document.removeEventListener('mousedown', armClickAwayListener, true);
document.removeEventListener('touchstart', armClickAwayListener, true);
activatedRef.current = false;
};
}, [active]);
// The handler doesn't take event.defaultPrevented into account:
//
// event.preventDefault() is meant to stop default behaviors like
// clicking a checkbox to check it, hitting a button to submit a form,
// and hitting left arrow to move the cursor in a text input etc.
// Only special HTML elements have these default behaviors.
const handleClickAway = (0, _useEventCallback.default)(event => {
if (!activatedRef.current) {
return;
}
// Given developers can stop the propagation of the synthetic event,
// we can only be confident with a positive value.
const insideReactTree = syntheticEventRef.current;
syntheticEventRef.current = false;
const doc = (0, _ownerDocument.default)(nodeRef.current);
// 1. IE11 support, which trigger the handleClickAway even after the unbind
// 2. The child might render null.
// 3. Behave like a blur listener.
if (!nodeRef.current ||
// is a TouchEvent?
'clientX' in event && clickedRootScrollbar(event, doc)) {
return;
}
// Do not act if user performed touchmove
if (movedRef.current) {
movedRef.current = false;
return;
}
let insideDOM;
// If not enough, can use https://github.com/DieterHolvoet/event-propagation-path/blob/master/propagationPath.js
if (event.composedPath) {
insideDOM = event.composedPath().indexOf(nodeRef.current) > -1;
} else {
insideDOM = !doc.documentElement.contains(event.target) || nodeRef.current.contains(event.target);
}
if (!insideDOM && !insideReactTree) {
onClickAway(event);
}
});
// Keep track of mouse/touch events that bubbled up through the portal.
const handleSynthetic = event => {
// Ignore events handled by our internal components
if (!event.defaultMuiPrevented) {
syntheticEventRef.current = true;
}
};
React.useEffect(() => {
if (active) {
const doc = (0, _ownerDocument.default)(nodeRef.current);
const handleTouchMove = () => {
movedRef.current = true;
};
doc.addEventListener('touchstart', handleClickAway);
doc.addEventListener('touchmove', handleTouchMove);
return () => {
doc.removeEventListener('touchstart', handleClickAway);
doc.removeEventListener('touchmove', handleTouchMove);
};
}
return undefined;
}, [active, handleClickAway]);
React.useEffect(() => {
// TODO This behavior is not tested automatically
// It's unclear whether this is due to different update semantics in test (batched in act() vs discrete on click).
// Or if this is a timing related issues due to different Transition components
// Once we get rid of all the manual scheduling (for example setTimeout(update, 0)) we can revisit this code+test.
if (active) {
const doc = (0, _ownerDocument.default)(nodeRef.current);
doc.addEventListener('click', handleClickAway);
return () => {
doc.removeEventListener('click', handleClickAway);
// cleanup `handleClickAway`
syntheticEventRef.current = false;
};
}
return undefined;
}, [active, handleClickAway]);
return [nodeRef, handleSynthetic, handleSynthetic];
}
const PickerPopperPaperWrapper = /*#__PURE__*/React.forwardRef((props, ref) => {
const {
PaperComponent,
ownerState,
children,
paperSlotProps,
paperClasses,
onPaperClick,
onPaperTouchStart
// picks up the style props provided by `Transition`
// https://mui.com/material-ui/transitions/#child-requirement
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const paperProps = (0, _useSlotProps.default)({
elementType: PaperComponent,
externalSlotProps: paperSlotProps,
additionalProps: {
tabIndex: -1,
elevation: 8,
ref
},
className: paperClasses,
ownerState
});
return /*#__PURE__*/(0, _jsxRuntime.jsx)(PaperComponent, (0, _extends2.default)({}, other, paperProps, {
onClick: event => {
onPaperClick(event);
paperProps.onClick?.(event);
},
onTouchStart: event => {
onPaperTouchStart(event);
paperProps.onTouchStart?.(event);
},
ownerState: ownerState,
children: children
}));
});
if (process.env.NODE_ENV !== "production") PickerPopperPaperWrapper.displayName = "PickerPopperPaperWrapper";
function PickerPopper(inProps) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickerPopper'
});
const {
children,
placement = 'bottom-start',
slots,
slotProps,
classes: classesProp
} = props;
const {
open,
popupRef,
reduceAnimations
} = (0, _hooks.usePickerContext)();
const {
ownerState: pickerOwnerState,
rootRefObject
} = (0, _usePickerPrivateContext.usePickerPrivateContext)();
const {
dismissViews,
getCurrentViewMode,
onPopperExited,
triggerElement,
viewContainerRole
} = (0, _usePickerPrivateContext.usePickerPrivateContext)();
React.useEffect(() => {
function handleKeyDown(nativeEvent) {
if (open && nativeEvent.key === 'Escape') {
dismissViews();
}
}
document.addEventListener('keydown', handleKeyDown);
return () => {
document.removeEventListener('keydown', handleKeyDown);
};
}, [dismissViews, open]);
const lastFocusedElementRef = React.useRef(null);
React.useEffect(() => {
if (viewContainerRole === 'tooltip' || getCurrentViewMode() === 'field') {
return;
}
if (open) {
lastFocusedElementRef.current = (0, _utils.getActiveElement)(rootRefObject.current);
} else if (lastFocusedElementRef.current && lastFocusedElementRef.current instanceof HTMLElement) {
// make sure the button is flushed with updated label, before returning focus to it
// avoids issue, where screen reader could fail to announce selected date after selection
setTimeout(() => {
if (lastFocusedElementRef.current instanceof HTMLElement) {
lastFocusedElementRef.current.focus();
}
});
}
}, [open, viewContainerRole, getCurrentViewMode, rootRefObject]);
const classes = useUtilityClasses(classesProp);
const handleClickAway = (0, _useEventCallback.default)(() => {
if (viewContainerRole === 'tooltip') {
(0, _utils.executeInTheNextEventLoopTick)(() => {
if (rootRefObject.current?.contains((0, _utils.getActiveElement)(rootRefObject.current)) || popupRef.current?.contains((0, _utils.getActiveElement)(popupRef.current))) {
return;
}
dismissViews();
});
} else {
dismissViews();
}
});
const [clickAwayRef, onPaperClick, onPaperTouchStart] = useClickAwayListener(open, handleClickAway);
const paperRef = React.useRef(null);
const handleRef = (0, _useForkRef.default)(paperRef, popupRef);
const handlePaperRef = (0, _useForkRef.default)(handleRef, clickAwayRef);
const handleKeyDown = event => {
if (event.key === 'Escape') {
// stop the propagation to avoid closing parent modal
event.stopPropagation();
dismissViews();
}
};
const Transition = slots?.desktopTransition ?? reduceAnimations ? _Fade.default : _Grow.default;
const FocusTrap = slots?.desktopTrapFocus ?? _Unstable_TrapFocus.default;
const Paper = slots?.desktopPaper ?? PickerPopperPaper;
const Popper = slots?.popper ?? PickerPopperRoot;
const popperProps = (0, _useSlotProps.default)({
elementType: Popper,
externalSlotProps: slotProps?.popper,
additionalProps: {
transition: true,
role: viewContainerRole == null ? undefined : viewContainerRole,
open,
placement,
anchorEl: triggerElement,
onKeyDown: handleKeyDown
},
className: classes.root,
ownerState: pickerOwnerState
});
const ownerState = React.useMemo(() => (0, _extends2.default)({}, pickerOwnerState, {
popperPlacement: popperProps.placement
}), [pickerOwnerState, popperProps.placement]);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(Popper, (0, _extends2.default)({}, popperProps, {
children: ({
TransitionProps
}) => /*#__PURE__*/(0, _jsxRuntime.jsx)(FocusTrap, (0, _extends2.default)({
open: open,
disableAutoFocus: true
// pickers are managing focus position manually
// without this prop the focus is returned to the button before `aria-label` is updated
// which would force screen readers to read too old label
,
disableRestoreFocus: true,
disableEnforceFocus: viewContainerRole === 'tooltip',
isEnabled: () => true
}, slotProps?.desktopTrapFocus, {
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(Transition, (0, _extends2.default)({}, TransitionProps, slotProps?.desktopTransition, {
onExited: event => {
onPopperExited?.();
slotProps?.desktopTransition?.onExited?.(event);
TransitionProps?.onExited?.();
},
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(PickerPopperPaperWrapper, {
PaperComponent: Paper,
ownerState: ownerState,
ref: handlePaperRef,
onPaperClick: onPaperClick,
onPaperTouchStart: onPaperTouchStart,
paperClasses: classes.paper,
paperSlotProps: slotProps?.desktopPaper,
children: children
})
}))
}))
}));
}

4
node_modules/@mui/x-date-pickers/internals/components/PickerPopper/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export { PickerPopper } from "./PickerPopper.js";
export type { ExportedPickerPopperProps } from "./PickerPopper.js";
export { pickerPopperClasses, getPickerPopperUtilityClass } from "./pickerPopperClasses.js";
export type { PickerPopperClassKey, PickerPopperClasses } from "./pickerPopperClasses.js";

25
node_modules/@mui/x-date-pickers/internals/components/PickerPopper/index.js generated vendored Normal file
View file

@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickerPopper", {
enumerable: true,
get: function () {
return _PickerPopper.PickerPopper;
}
});
Object.defineProperty(exports, "getPickerPopperUtilityClass", {
enumerable: true,
get: function () {
return _pickerPopperClasses.getPickerPopperUtilityClass;
}
});
Object.defineProperty(exports, "pickerPopperClasses", {
enumerable: true,
get: function () {
return _pickerPopperClasses.pickerPopperClasses;
}
});
var _PickerPopper = require("./PickerPopper");
var _pickerPopperClasses = require("./pickerPopperClasses");

9
node_modules/@mui/x-date-pickers/internals/components/PickerPopper/pickerPopperClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,9 @@
export interface PickerPopperClasses {
/** Styles applied to the root element. */
root: string;
/** Styles applied to the paper element. */
paper: string;
}
export type PickerPopperClassKey = keyof PickerPopperClasses;
export declare function getPickerPopperUtilityClass(slot: string): string;
export declare const pickerPopperClasses: Record<"root" | "paper", string>;

14
node_modules/@mui/x-date-pickers/internals/components/PickerPopper/pickerPopperClasses.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickerPopperUtilityClass = getPickerPopperUtilityClass;
exports.pickerPopperClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickerPopperUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickerPopper', slot);
}
const pickerPopperClasses = exports.pickerPopperClasses = (0, _generateUtilityClasses.default)('MuiPickerPopper', ['root', 'paper']);

293
node_modules/@mui/x-date-pickers/internals/components/PickerProvider.d.ts generated vendored Normal file
View file

@ -0,0 +1,293 @@
import * as React from 'react';
import { SxProps } from '@mui/system';
import { Theme } from '@mui/material/styles';
import { PickerChangeImportance, PickerOwnerState, PickersTimezone } from "../../models/index.js";
import { PickersInputLocaleText } from "../../locales/index.js";
import { DateOrTimeViewWithMeridiem, PickerOrientation, PickerValidValue, PickerVariant } from "../models/index.js";
import { PickerFieldPrivateContextValue } from "../hooks/useNullableFieldPrivateContext.js";
import type { PickersShortcutsItemContext } from "../../PickersShortcuts/index.js";
import type { PickersActionBarAction } from "../../PickersActionBar/index.js";
export declare const PickerActionsContext: React.Context<PickerActionsContextValue<any, any, any> | null>;
export declare const PickerPrivateContext: React.Context<PickerPrivateContextValue>;
/**
* Provides the context for the various parts of a Picker component:
* - contextValue: the context for the Picker sub-components.
* - localizationProvider: the translations passed through the props and through a parent LocalizationProvider.
*
* @ignore - do not document.
*/
export declare function PickerProvider<TValue extends PickerValidValue>(props: PickerProviderProps<TValue>): React.JSX.Element;
export interface PickerProviderProps<TValue extends PickerValidValue> {
contextValue: PickerContextValue<any, any, any>;
actionsContextValue: PickerActionsContextValue<any, any, any>;
privateContextValue: PickerPrivateContextValue;
fieldPrivateContextValue: PickerFieldPrivateContextValue;
isValidContextValue: (value: TValue) => boolean;
localeText: PickersInputLocaleText | undefined;
children: React.ReactNode;
}
export interface PickerContextValue<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError> extends PickerActionsContextValue<TValue, TView, TError> {
/**
* The current value of the Picker.
*/
value: TValue;
/**
* The timezone to use when rendering the dates.
* If a `timezone` prop is provided, it will be used.
* If the `value` prop contains a valid date, its timezone will be used.
* If no `value` prop is provided, but the `defaultValue` contains a valid date, its timezone will be used.
* If no `value` or `defaultValue` is provided, but the `referenceDate` is provided, its timezone will be used.
* Otherwise, the timezone will be the default one of your date library.
*/
timezone: PickersTimezone;
/**
* Whether the Picker is open.
*/
open: boolean;
/**
* Whether the Picker is disabled.
*/
disabled: boolean;
/**
* Whether the Picker is read-only.
*/
readOnly: boolean;
/**
* Whether the Picker should be focused on mount.
* If the Picker has a field and is not open, the field should be focused.
* If the Picker does not have a field (static variant) or is not open, the view should be focused.
*/
autoFocus: boolean;
/**
* The views that the Picker has to render.
* It is equal to the Picker `views` prop—if defined.
* Otherwise, a default set of views is provided based on the component you are using:
* - Date Picker: ['year', 'day']
* - Time Picker: ['hours', 'minutes']
* - Date Time Picker: ['year', 'day', 'hours', 'minutes']
* - Date Range Picker: ['day']
* - Date Time Range Picker: ['day', 'hours', 'minutes']
*/
views: readonly TView[];
/**
* The currently rendered view.
*/
view: TView | null;
/**
* The first view shown when opening the Picker for the first time.
*/
initialView: TView | null;
/**
* The responsive variant of the Picker.
* It is equal to "desktop" when using a desktop Picker (like <DesktopDatePicker />).
* It is equal to "mobile" when using a mobile Picker (like <MobileDatePicker />).
* It is equal to "mobile" or "desktop" when using a responsive Picker (like <DatePicker />) depending on the `desktopModeMediaQuery` prop.
* It is equal to "mobile" or "desktop" when using a static Picker (like <StaticDatePicker />) depending on the `displayStaticWrapperAs` prop.
* It is always equal to "desktop" if the component you are accessing the context from is not wrapped with a Picker.
*/
variant: PickerVariant;
/**
* The orientation of the Picker.
* On Time Pickers and Date Time Pickers, it is always equal to "portrait".
* On Date Pickers, it is equal to the Picker `orientation` prop if defined, otherwise it is based on the current orientation of the user's screen.
* It is always equal to "portrait" if the component you are accessing the context from is not wrapped with a Picker.
*/
orientation: PickerOrientation;
/**
* Whether the heavy animations should be disabled.
* @default `@media(prefers-reduced-motion: reduce)` || `navigator.userAgent` matches Android <10 or iOS <13
*/
reduceAnimations?: boolean;
/**
* The ref to attach to the element that triggers the Picker opening.
* When using a built-in field component, this property is automatically attached to the right element.
*/
triggerRef: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
/**
* The status of the element that triggers the Picker opening.
* If it is "hidden", the field should not render the UI to open the Picker.
* If it is "disabled", the field should render a disabled UI to open the Picker.
* If it is "enabled", the field should render an interactive UI to open the Picker.
*/
triggerStatus: 'hidden' | 'disabled' | 'enabled';
/**
* Whether the Picker has any value picking steps left.
*/
hasNextStep: boolean;
/**
* The ref to attach to the popup's outermost element that contains the view, if any.
* When using a built-in popup component, this property is automatically attached to the appropriate element.
*/
popupRef: React.RefObject<any>;
/**
* The format to use when rendering the value in the field.
* It is equal to the Picker `format` prop if defined.
* It is generated based on the available views if not defined.
* It is always equal to an empty string if the Picker does not have a field (static variant).
* It is always equal to an empty string if the component you are accessing the context from is not wrapped with a Picker.
*/
fieldFormat: string;
/**
* The name to apply to the <input /> element if the Picker contains one.
* If the Picker has a field, it should probably be applied to its input element.
* It is equal to the Picker `name` prop if defined (the prop does not exist on the static variant).
* It is always equal to undefined if the component you are accessing the context from is not wrapped with a Picker.
*/
name: string | undefined;
/**
* The label to render by the field if the Picker contains one.
* It is equal to the Picker `label` prop if defined (the prop does not exist on the static variant).
* It is always equal to undefined if the component you are accessing the context from is not wrapped with a Picker.
*/
label: React.ReactNode | undefined;
/**
* The class name to apply to the root element.
* If the Picker has a field, it should be applied to field root element, otherwise to the layout root element.
* It is equal to the Picker `className` prop if defined.
* It is always equal to undefined if the component you are accessing the context from is not wrapped with a Picker.
*/
rootClassName: string | undefined;
/**
* The MUI style prop to apply to the root element.
* If the Picker has a field, it should be applied to field root element, otherwise to the layout root element.
* It is equal to the Picker `sx` prop if defined.
* It is always equal to undefined if the component you are accessing the context from is not wrapped with a Picker.
*/
rootSx: SxProps<Theme> | undefined;
/**
* The ref to attach to the root element.
* If the Picker has a field, it should be attached to field root element, otherwise to the layout root element.
* It is equal to the ref passed to the Picker component if defined.
* It is always equal to undefined if the component you are accessing the context from is not wrapped with a Picker.
*/
rootRef: React.ForwardedRef<HTMLDivElement> | undefined;
}
export interface PickerActionsContextValue<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError = string | null> {
/**
* Set the current value of the Picker.
* @param {TValue} value The new value of the Picker.
* @param {SetValueActionOptions<TError>} options The options to customize the behavior of this update.
*/
setValue: (value: TValue, options?: SetValueActionOptions<TError>) => void;
/**
* Set the current open state of the Picker.
* It can be a function that will receive the current open state as parameter.
* ```ts
* setOpen(true); // Opens the Picker.
* setOpen(false); // Closes the Picker.
* setOpen((prevOpen) => !prevOpen); // Toggles the open state.
* ```
* @param {React.SetStateAction<boolean>} action The new open state of the Picker.
*/
setOpen: React.Dispatch<React.SetStateAction<boolean>>;
/**
* Set the current view of the Picker.
* @template TView
* @param {TView} view The new view of the Picker
*/
setView: (view: TView) => void;
/**
* Set the current value of the Picker to be empty.
* The value will be `null` on a single Picker and `[null, null]` on a range Picker.
*/
clearValue: () => void;
/**
* Set the current value of the Picker to be the current date.
* The value will be `today` on a non-range Picker and `[today, today]` on a range Picker.
* With `today` being the current date, with its time set to `00:00:00` on Date Pickers and its time set to the current time on Time and Date and Time Pickers.
*/
setValueToToday: () => void;
/**
* Accept the current value of the Picker.
* Will call `onAccept` if defined.
* If the Picker is re-opened, this value will be the one used to initialize the views.
*/
acceptValueChanges: () => void;
/**
* Cancel the changes made to the current value of the Picker.
* The value will be reset to the last accepted value.
*/
cancelValueChanges: () => void;
/**
* Go to the next step in the value picking process.
* For example, on the Mobile Date Time Picker, if the user is editing the date, it will switch to editing the time.
*/
goToNextStep: () => void;
}
export interface SetValueActionOptions<TError = string | null> {
/**
* The importance of the change when picking a value:
* - "accept": fires `onChange`, fires `onAccept` and closes the Picker.
* - "set": fires `onChange` but do not fire `onAccept` and does not close the Picker.
* @default "accept"
*/
changeImportance?: PickerChangeImportance;
/**
* The validation error associated with the current value.
* If not defined, the validation will be computed by the Picker.
*/
validationError?: TError;
/**
* The shortcut that triggered this change.
* It should not be defined if the change does not come from a shortcut.
*/
shortcut?: PickersShortcutsItemContext;
/**
* Whether the value should call `onChange` and `onAccept` when the value is not controlled and has never been modified.
* If `true`, the `onChange` and `onAccept` callback will only be fired if the value has been modified (and is not equal to the last published value).
* If `false`, the `onChange` and `onAccept` callback will be fired when the value has never been modified (`onAccept` only if `changeImportance` is set to "accept").
* @default false
*/
skipPublicationIfPristine?: boolean;
/**
* Whether the Picker should close.
* @default changeImportance === "accept"
*/
shouldClose?: boolean;
}
export interface PickerPrivateContextValue {
dismissViews: () => void;
/**
* The ownerState of the picker.
*/
ownerState: PickerOwnerState;
/**
* Whether at least one view has an UI (it has a view renderer associated).
*/
hasUIView: boolean;
/**
* Return the mode of the current view.
* @returns {boolean} The mode of the current view.
*/
getCurrentViewMode: () => 'UI' | 'field';
/**
* The ref of the root element.
* This is the object counterpart of the `usePickerContext().rootRef` property which can be a function.
*/
rootRefObject: React.RefObject<HTMLDivElement | null>;
/**
* The id of the label element.
*/
labelId: string | undefined;
/**
* The element used as the anchor for the Picker Popper.
*/
triggerElement: HTMLElement | null;
/**
* The aria role associated with the view container.
* It is equal to "dialog" when the view is rendered inside a `@mui/material/Dialog`.
* It is equal to "dialog" when the view is rendered inside a `@mui/material/Popper` and the focus is trapped inside the view.
* It is equal to "tooltip" when the view is rendered inside a `@mui/material/Popper` and the focus remains inside the field.
* It is always equal to null if the Picker does not have a field (static variant).
* It is always equal to null if the component you are accessing the context from is not wrapped with a Picker.
*/
viewContainerRole: 'dialog' | 'tooltip' | null;
/**
* The actions to render in the action bar if the user doesn't provide any.
*/
defaultActionBarActions: PickersActionBarAction[];
/**
* The function to call when the Popper is closing animation is finished.
*/
onPopperExited: (() => void) | undefined;
}

77
node_modules/@mui/x-date-pickers/internals/components/PickerProvider.js generated vendored Normal file
View file

@ -0,0 +1,77 @@
"use strict";
'use client';
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickerPrivateContext = exports.PickerActionsContext = void 0;
exports.PickerProvider = PickerProvider;
var React = _interopRequireWildcard(require("react"));
var _LocalizationProvider = require("../../LocalizationProvider");
var _useIsValidValue = require("../../hooks/useIsValidValue");
var _useNullableFieldPrivateContext = require("../hooks/useNullableFieldPrivateContext");
var _usePickerContext = require("../../hooks/usePickerContext");
var _jsxRuntime = require("react/jsx-runtime");
const PickerActionsContext = exports.PickerActionsContext = /*#__PURE__*/React.createContext(null);
if (process.env.NODE_ENV !== "production") PickerActionsContext.displayName = "PickerActionsContext";
const PickerPrivateContext = exports.PickerPrivateContext = /*#__PURE__*/React.createContext({
ownerState: {
isPickerDisabled: false,
isPickerReadOnly: false,
isPickerValueEmpty: false,
isPickerOpen: false,
pickerVariant: 'desktop',
pickerOrientation: 'portrait'
},
rootRefObject: {
current: null
},
labelId: undefined,
dismissViews: () => {},
hasUIView: true,
getCurrentViewMode: () => 'UI',
triggerElement: null,
viewContainerRole: null,
defaultActionBarActions: [],
onPopperExited: undefined
});
/**
* Provides the context for the various parts of a Picker component:
* - contextValue: the context for the Picker sub-components.
* - localizationProvider: the translations passed through the props and through a parent LocalizationProvider.
*
* @ignore - do not document.
*/
if (process.env.NODE_ENV !== "production") PickerPrivateContext.displayName = "PickerPrivateContext";
function PickerProvider(props) {
const {
contextValue,
actionsContextValue,
privateContextValue,
fieldPrivateContextValue,
isValidContextValue,
localeText,
children
} = props;
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_usePickerContext.PickerContext.Provider, {
value: contextValue,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(PickerActionsContext.Provider, {
value: actionsContextValue,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(PickerPrivateContext.Provider, {
value: privateContextValue,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_useNullableFieldPrivateContext.PickerFieldPrivateContext.Provider, {
value: fieldPrivateContextValue,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_useIsValidValue.IsValidValueContext.Provider, {
value: isValidContextValue,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LocalizationProvider.LocalizationProvider, {
localeText: localeText,
children: children
})
})
})
})
})
});
}

1
node_modules/@mui/x-date-pickers/internals/components/PickerViewRoot/PickerViewRoot.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export declare const PickerViewRoot: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

16
node_modules/@mui/x-date-pickers/internals/components/PickerViewRoot/PickerViewRoot.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickerViewRoot = void 0;
var _styles = require("@mui/material/styles");
var _dimensions = require("../../constants/dimensions");
const PickerViewRoot = exports.PickerViewRoot = (0, _styles.styled)('div')({
overflow: 'hidden',
width: _dimensions.DIALOG_WIDTH,
maxHeight: _dimensions.VIEW_HEIGHT,
display: 'flex',
flexDirection: 'column',
margin: '0 auto'
});

1
node_modules/@mui/x-date-pickers/internals/components/PickerViewRoot/index.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export { PickerViewRoot } from "./PickerViewRoot.js";

12
node_modules/@mui/x-date-pickers/internals/components/PickerViewRoot/index.js generated vendored Normal file
View file

@ -0,0 +1,12 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickerViewRoot", {
enumerable: true,
get: function () {
return _PickerViewRoot.PickerViewRoot;
}
});
var _PickerViewRoot = require("./PickerViewRoot");

3
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
import * as React from 'react';
import { PickersArrowSwitcherProps } from "./PickersArrowSwitcher.types.js";
export declare const PickersArrowSwitcher: React.ForwardRefExoticComponent<PickersArrowSwitcherProps & React.RefAttributes<HTMLDivElement>>;

182
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.js generated vendored Normal file
View file

@ -0,0 +1,182 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickersArrowSwitcher = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _clsx = _interopRequireDefault(require("clsx"));
var _Typography = _interopRequireDefault(require("@mui/material/Typography"));
var _RtlProvider = require("@mui/system/RtlProvider");
var _styles = require("@mui/material/styles");
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _useSlotProps3 = _interopRequireDefault(require("@mui/utils/useSlotProps"));
var _IconButton = _interopRequireDefault(require("@mui/material/IconButton"));
var _icons = require("../../../icons");
var _pickersArrowSwitcherClasses = require("./pickersArrowSwitcherClasses");
var _usePickerPrivateContext = require("../../hooks/usePickerPrivateContext");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["children", "className", "slots", "slotProps", "isNextDisabled", "isNextHidden", "onGoToNext", "nextLabel", "isPreviousDisabled", "isPreviousHidden", "onGoToPrevious", "previousLabel", "labelId", "classes"],
_excluded2 = ["ownerState"],
_excluded3 = ["ownerState"];
const PickersArrowSwitcherRoot = (0, _styles.styled)('div', {
name: 'MuiPickersArrowSwitcher',
slot: 'Root'
})({
display: 'flex'
});
const PickersArrowSwitcherSpacer = (0, _styles.styled)('div', {
name: 'MuiPickersArrowSwitcher',
slot: 'Spacer'
})(({
theme
}) => ({
width: theme.spacing(3)
}));
const PickersArrowSwitcherButton = (0, _styles.styled)(_IconButton.default, {
name: 'MuiPickersArrowSwitcher',
slot: 'Button'
})({
variants: [{
props: {
isButtonHidden: true
},
style: {
visibility: 'hidden'
}
}]
});
const useUtilityClasses = classes => {
const slots = {
root: ['root'],
spacer: ['spacer'],
button: ['button'],
previousIconButton: ['previousIconButton'],
nextIconButton: ['nextIconButton'],
leftArrowIcon: ['leftArrowIcon'],
rightArrowIcon: ['rightArrowIcon']
};
return (0, _composeClasses.default)(slots, _pickersArrowSwitcherClasses.getPickersArrowSwitcherUtilityClass, classes);
};
const PickersArrowSwitcher = exports.PickersArrowSwitcher = /*#__PURE__*/React.forwardRef(function PickersArrowSwitcher(inProps, ref) {
const isRtl = (0, _RtlProvider.useRtl)();
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersArrowSwitcher'
});
const {
children,
className,
slots,
slotProps,
isNextDisabled,
isNextHidden,
onGoToNext,
nextLabel,
isPreviousDisabled,
isPreviousHidden,
onGoToPrevious,
previousLabel,
labelId,
classes: classesProp
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const {
ownerState
} = (0, _usePickerPrivateContext.usePickerPrivateContext)();
const classes = useUtilityClasses(classesProp);
const nextProps = {
isDisabled: isNextDisabled,
isHidden: isNextHidden,
goTo: onGoToNext,
label: nextLabel
};
const previousProps = {
isDisabled: isPreviousDisabled,
isHidden: isPreviousHidden,
goTo: onGoToPrevious,
label: previousLabel
};
const PreviousIconButton = slots?.previousIconButton ?? PickersArrowSwitcherButton;
const previousIconButtonProps = (0, _useSlotProps3.default)({
elementType: PreviousIconButton,
externalSlotProps: slotProps?.previousIconButton,
additionalProps: {
size: 'medium',
title: previousProps.label,
'aria-label': previousProps.label,
disabled: previousProps.isDisabled,
edge: 'end',
onClick: previousProps.goTo
},
ownerState: (0, _extends2.default)({}, ownerState, {
isButtonHidden: previousProps.isHidden ?? false
}),
className: (0, _clsx.default)(classes.button, classes.previousIconButton)
});
const NextIconButton = slots?.nextIconButton ?? PickersArrowSwitcherButton;
const nextIconButtonProps = (0, _useSlotProps3.default)({
elementType: NextIconButton,
externalSlotProps: slotProps?.nextIconButton,
additionalProps: {
size: 'medium',
title: nextProps.label,
'aria-label': nextProps.label,
disabled: nextProps.isDisabled,
edge: 'start',
onClick: nextProps.goTo
},
ownerState: (0, _extends2.default)({}, ownerState, {
isButtonHidden: nextProps.isHidden ?? false
}),
className: (0, _clsx.default)(classes.button, classes.nextIconButton)
});
const LeftArrowIcon = slots?.leftArrowIcon ?? _icons.ArrowLeftIcon;
// The spread is here to avoid this bug mui/material-ui#34056
const _useSlotProps = (0, _useSlotProps3.default)({
elementType: LeftArrowIcon,
externalSlotProps: slotProps?.leftArrowIcon,
additionalProps: {
fontSize: 'inherit'
},
ownerState,
className: classes.leftArrowIcon
}),
leftArrowIconProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps, _excluded2);
const RightArrowIcon = slots?.rightArrowIcon ?? _icons.ArrowRightIcon;
// The spread is here to avoid this bug mui/material-ui#34056
const _useSlotProps2 = (0, _useSlotProps3.default)({
elementType: RightArrowIcon,
externalSlotProps: slotProps?.rightArrowIcon,
additionalProps: {
fontSize: 'inherit'
},
ownerState,
className: classes.rightArrowIcon
}),
rightArrowIconProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps2, _excluded3);
return /*#__PURE__*/(0, _jsxRuntime.jsxs)(PickersArrowSwitcherRoot, (0, _extends2.default)({
ref: ref,
className: (0, _clsx.default)(classes.root, className),
ownerState: ownerState
}, other, {
children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(PreviousIconButton, (0, _extends2.default)({}, previousIconButtonProps, {
children: isRtl ? /*#__PURE__*/(0, _jsxRuntime.jsx)(RightArrowIcon, (0, _extends2.default)({}, rightArrowIconProps)) : /*#__PURE__*/(0, _jsxRuntime.jsx)(LeftArrowIcon, (0, _extends2.default)({}, leftArrowIconProps))
})), children ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_Typography.default, {
variant: "subtitle1",
component: "span",
id: labelId,
children: children
}) : /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersArrowSwitcherSpacer, {
className: classes.spacer,
ownerState: ownerState
}), /*#__PURE__*/(0, _jsxRuntime.jsx)(NextIconButton, (0, _extends2.default)({}, nextIconButtonProps, {
children: isRtl ? /*#__PURE__*/(0, _jsxRuntime.jsx)(LeftArrowIcon, (0, _extends2.default)({}, leftArrowIconProps)) : /*#__PURE__*/(0, _jsxRuntime.jsx)(RightArrowIcon, (0, _extends2.default)({}, rightArrowIconProps))
}))]
}));
});
if (process.env.NODE_ENV !== "production") PickersArrowSwitcher.displayName = "PickersArrowSwitcher";

74
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.types.d.ts generated vendored Normal file
View file

@ -0,0 +1,74 @@
import * as React from 'react';
import { SlotComponentProps } from '@mui/utils/types';
import IconButton from '@mui/material/IconButton';
import SvgIcon from '@mui/material/SvgIcon';
import { PickersArrowSwitcherClasses } from "./pickersArrowSwitcherClasses.js";
import { PickerOwnerState } from "../../../models/index.js";
export interface ExportedPickersArrowSwitcherProps {
/**
* Overridable component slots.
* @default {}
*/
slots?: PickersArrowSwitcherSlots;
/**
* The props used for each component slot.
* @default {}
*/
slotProps?: PickersArrowSwitcherSlotProps;
/**
* Override or extend the styles applied to the component.
*/
classes?: Partial<PickersArrowSwitcherClasses>;
/**
* Format used to display the date.
* @default `${adapter.formats.month} ${adapter.formats.year}`
*/
format?: string;
}
export interface PickersArrowSwitcherProps extends ExportedPickersArrowSwitcherProps, Omit<React.HTMLProps<HTMLDivElement>, 'ref' | 'as'> {
children?: React.ReactNode;
isPreviousDisabled: boolean;
isPreviousHidden?: boolean;
onGoToPrevious: () => void;
previousLabel: string;
isNextDisabled: boolean;
isNextHidden?: boolean;
onGoToNext: () => void;
nextLabel: string;
labelId?: string;
}
export interface PickersArrowSwitcherOwnerState extends PickerOwnerState {
/**
* If `true`, this button should be hidden.
*/
isButtonHidden: boolean;
}
export interface PickersArrowSwitcherSlotPropsOverrides {}
export interface PickersArrowSwitcherSlots {
/**
* Button allowing to switch to the left view.
* @default IconButton
*/
previousIconButton?: React.ElementType;
/**
* Button allowing to switch to the right view.
* @default IconButton
*/
nextIconButton?: React.ElementType;
/**
* Icon displayed in the left view switch button.
* @default ArrowLeft
*/
leftArrowIcon?: React.ElementType;
/**
* Icon displayed in the right view switch button.
* @default ArrowRight
*/
rightArrowIcon?: React.ElementType;
}
export interface PickersArrowSwitcherSlotProps {
previousIconButton?: SlotComponentProps<typeof IconButton, PickersArrowSwitcherSlotPropsOverrides, PickersArrowSwitcherOwnerState>;
nextIconButton?: SlotComponentProps<typeof IconButton, PickersArrowSwitcherSlotPropsOverrides, PickersArrowSwitcherOwnerState>;
leftArrowIcon?: SlotComponentProps<typeof SvgIcon, PickersArrowSwitcherSlotPropsOverrides, PickerOwnerState>;
rightArrowIcon?: SlotComponentProps<typeof SvgIcon, PickersArrowSwitcherSlotPropsOverrides, PickerOwnerState>;
}

5
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.types.js generated vendored Normal file
View file

@ -0,0 +1,5 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});

4
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export { PickersArrowSwitcher } from "./PickersArrowSwitcher.js";
export type { PickersArrowSwitcherSlots, PickersArrowSwitcherSlotProps, ExportedPickersArrowSwitcherProps } from "./PickersArrowSwitcher.types.js";
export { pickersArrowSwitcherClasses, getPickersArrowSwitcherUtilityClass } from "./pickersArrowSwitcherClasses.js";
export type { PickersArrowSwitcherClassKey, PickersArrowSwitcherClasses } from "./pickersArrowSwitcherClasses.js";

25
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/index.js generated vendored Normal file
View file

@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickersArrowSwitcher", {
enumerable: true,
get: function () {
return _PickersArrowSwitcher.PickersArrowSwitcher;
}
});
Object.defineProperty(exports, "getPickersArrowSwitcherUtilityClass", {
enumerable: true,
get: function () {
return _pickersArrowSwitcherClasses.getPickersArrowSwitcherUtilityClass;
}
});
Object.defineProperty(exports, "pickersArrowSwitcherClasses", {
enumerable: true,
get: function () {
return _pickersArrowSwitcherClasses.pickersArrowSwitcherClasses;
}
});
var _PickersArrowSwitcher = require("./PickersArrowSwitcher");
var _pickersArrowSwitcherClasses = require("./pickersArrowSwitcherClasses");

19
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/pickersArrowSwitcherClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
export interface PickersArrowSwitcherClasses {
/** Styles applied to the root element. */
root: string;
/** Styles applied to the spacer element. */
spacer: string;
/** Styles applied to the button element. */
button: string;
/** Styles applied to the previous icon button element. */
previousIconButton: string;
/** Styles applied to the next icon button element. */
nextIconButton: string;
/** Styles applied to the left icon element. */
leftArrowIcon: string;
/** Styles applied to the right icon element. */
rightArrowIcon: string;
}
export type PickersArrowSwitcherClassKey = keyof PickersArrowSwitcherClasses;
export declare function getPickersArrowSwitcherUtilityClass(slot: string): string;
export declare const pickersArrowSwitcherClasses: Record<"root" | "button" | "spacer" | "previousIconButton" | "nextIconButton" | "leftArrowIcon" | "rightArrowIcon", string>;

14
node_modules/@mui/x-date-pickers/internals/components/PickersArrowSwitcher/pickersArrowSwitcherClasses.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersArrowSwitcherUtilityClass = getPickersArrowSwitcherUtilityClass;
exports.pickersArrowSwitcherClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickersArrowSwitcherUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersArrowSwitcher', slot);
}
const pickersArrowSwitcherClasses = exports.pickersArrowSwitcherClasses = (0, _generateUtilityClasses.default)('MuiPickersArrowSwitcher', ['root', 'spacer', 'button', 'previousIconButton', 'nextIconButton', 'leftArrowIcon', 'rightArrowIcon']);

48
node_modules/@mui/x-date-pickers/internals/components/PickersModalDialog.d.ts generated vendored Normal file
View file

@ -0,0 +1,48 @@
import * as React from 'react';
import { DialogProps as MuiDialogProps } from '@mui/material/Dialog';
import { PaperProps as MuiPaperProps } from '@mui/material/Paper';
import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
export interface PickersModalDialogSlots {
/**
* Custom component for the dialog inside which the views are rendered on mobile.
* @default PickersModalDialogRoot
*/
dialog?: React.ElementType<MuiDialogProps>;
/**
* Custom component for the paper rendered inside the mobile picker's Dialog.
* @default Paper from '@mui/material'.
*/
mobilePaper?: React.JSXElementConstructor<MuiPaperProps>;
/**
* Custom component for the mobile dialog [Transition](https://mui.com/material-ui/transitions/).
* @default Fade from '@mui/material'.
*/
mobileTransition?: React.JSXElementConstructor<MuiTransitionProps>;
}
export interface PickersModalDialogSlotProps {
/**
* Props passed down to the [`Dialog`](https://mui.com/material-ui/api/dialog/) component.
*/
dialog?: Partial<MuiDialogProps>;
/**
* Props passed down to the mobile [Paper](https://mui.com/material-ui/api/paper/) component.
*/
mobilePaper?: Partial<MuiPaperProps>;
/**
* Props passed down to the mobile [Transition](https://mui.com/material-ui/transitions/) component.
*/
mobileTransition?: Partial<MuiTransitionProps>;
}
export interface PickersModalDialogProps {
/**
* Overridable component slots.
* @default {}
*/
slots?: PickersModalDialogSlots;
/**
* The props used for each component slot.
* @default {}
*/
slotProps?: PickersModalDialogSlotProps;
}
export declare function PickersModalDialog(props: React.PropsWithChildren<PickersModalDialogProps>): React.JSX.Element;

63
node_modules/@mui/x-date-pickers/internals/components/PickersModalDialog.js generated vendored Normal file
View file

@ -0,0 +1,63 @@
"use strict";
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickersModalDialog = PickersModalDialog;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var React = _interopRequireWildcard(require("react"));
var _DialogContent = _interopRequireDefault(require("@mui/material/DialogContent"));
var _Fade = _interopRequireDefault(require("@mui/material/Fade"));
var _Dialog = _interopRequireWildcard(require("@mui/material/Dialog"));
var _styles = require("@mui/material/styles");
var _dimensions = require("../constants/dimensions");
var _hooks = require("../../hooks");
var _usePickerPrivateContext = require("../hooks/usePickerPrivateContext");
var _jsxRuntime = require("react/jsx-runtime");
const PickersModalDialogRoot = (0, _styles.styled)(_Dialog.default)({
[`& .${_Dialog.dialogClasses.container}`]: {
outline: 0
},
[`& .${_Dialog.dialogClasses.paper}`]: {
outline: 0,
minWidth: _dimensions.DIALOG_WIDTH
}
});
const PickersModalDialogContent = (0, _styles.styled)(_DialogContent.default)({
'&:first-of-type': {
padding: 0
}
});
function PickersModalDialog(props) {
const {
children,
slots,
slotProps
} = props;
const {
open
} = (0, _hooks.usePickerContext)();
const {
dismissViews,
onPopperExited
} = (0, _usePickerPrivateContext.usePickerPrivateContext)();
const Dialog = slots?.dialog ?? PickersModalDialogRoot;
const Transition = slots?.mobileTransition ?? _Fade.default;
return /*#__PURE__*/(0, _jsxRuntime.jsx)(Dialog, (0, _extends2.default)({
open: open,
onClose: () => {
dismissViews();
onPopperExited?.();
}
}, slotProps?.dialog, {
TransitionComponent: Transition,
TransitionProps: slotProps?.mobileTransition,
PaperComponent: slots?.mobilePaper,
PaperProps: slotProps?.mobilePaper,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersModalDialogContent, {
children: children
})
}));
}

14
node_modules/@mui/x-date-pickers/internals/components/PickersToolbar.d.ts generated vendored Normal file
View file

@ -0,0 +1,14 @@
import * as React from 'react';
import { BaseToolbarProps } from "../models/props/toolbar.js";
import { PickersToolbarClasses } from "./pickersToolbarClasses.js";
export interface PickersToolbarProps extends Pick<BaseToolbarProps, 'hidden' | 'titleId'> {
className?: string;
landscapeDirection?: 'row' | 'column';
toolbarTitle: React.ReactNode;
classes?: Partial<PickersToolbarClasses>;
}
type PickersToolbarComponent = ((props: React.PropsWithChildren<PickersToolbarProps> & React.RefAttributes<HTMLDivElement>) => React.JSX.Element) & {
propTypes?: any;
};
export declare const PickersToolbar: PickersToolbarComponent;
export {};

123
node_modules/@mui/x-date-pickers/internals/components/PickersToolbar.js generated vendored Normal file
View file

@ -0,0 +1,123 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickersToolbar = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _clsx = _interopRequireDefault(require("clsx"));
var _Typography = _interopRequireDefault(require("@mui/material/Typography"));
var _styles = require("@mui/material/styles");
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _createStyled = require("@mui/system/createStyled");
var _pickersToolbarClasses = require("./pickersToolbarClasses");
var _useToolbarOwnerState = require("../hooks/useToolbarOwnerState");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["children", "className", "classes", "toolbarTitle", "hidden", "titleId", "classes", "landscapeDirection"];
const useUtilityClasses = classes => {
const slots = {
root: ['root'],
title: ['title'],
content: ['content']
};
return (0, _composeClasses.default)(slots, _pickersToolbarClasses.getPickersToolbarUtilityClass, classes);
};
const PickersToolbarRoot = (0, _styles.styled)('div', {
name: 'MuiPickersToolbar',
slot: 'Root'
})(({
theme
}) => ({
display: 'flex',
flexDirection: 'column',
alignItems: 'flex-start',
justifyContent: 'space-between',
padding: theme.spacing(2, 3),
variants: [{
props: {
pickerOrientation: 'landscape'
},
style: {
height: 'auto',
maxWidth: 160,
padding: 16,
justifyContent: 'flex-start',
flexWrap: 'wrap'
}
}]
}));
const PickersToolbarContent = (0, _styles.styled)('div', {
name: 'MuiPickersToolbar',
slot: 'Content',
shouldForwardProp: prop => (0, _createStyled.shouldForwardProp)(prop) && prop !== 'landscapeDirection'
})({
display: 'flex',
flexWrap: 'wrap',
width: '100%',
flex: 1,
justifyContent: 'space-between',
alignItems: 'center',
flexDirection: 'row',
variants: [{
props: {
pickerOrientation: 'landscape'
},
style: {
justifyContent: 'flex-start',
alignItems: 'flex-start',
flexDirection: 'column'
}
}, {
props: {
pickerOrientation: 'landscape',
landscapeDirection: 'row'
},
style: {
flexDirection: 'row'
}
}]
});
const PickersToolbar = exports.PickersToolbar = /*#__PURE__*/React.forwardRef(function PickersToolbar(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersToolbar'
});
const {
children,
className,
classes: classesProp,
toolbarTitle,
hidden,
titleId,
landscapeDirection
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const ownerState = (0, _useToolbarOwnerState.useToolbarOwnerState)();
const classes = useUtilityClasses(classesProp);
if (hidden) {
return null;
}
return /*#__PURE__*/(0, _jsxRuntime.jsxs)(PickersToolbarRoot, (0, _extends2.default)({
ref: ref,
className: (0, _clsx.default)(classes.root, className),
ownerState: ownerState
}, other, {
children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Typography.default, {
color: "text.secondary",
variant: "overline",
id: titleId,
className: classes.title,
children: toolbarTitle
}), /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersToolbarContent, {
className: classes.content,
ownerState: ownerState,
landscapeDirection: landscapeDirection,
children: children
})]
}));
});
if (process.env.NODE_ENV !== "production") PickersToolbar.displayName = "PickersToolbar";

15
node_modules/@mui/x-date-pickers/internals/components/PickersToolbarButton.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
import * as React from 'react';
import { ButtonProps } from '@mui/material/Button';
import { TypographyProps } from '@mui/material/Typography';
import { ExtendMui } from "../models/helpers.js";
import { PickersToolbarButtonClasses } from "./pickersToolbarButtonClasses.js";
export interface PickersToolbarButtonProps extends ExtendMui<ButtonProps, 'value' | 'variant'> {
align?: TypographyProps['align'];
selected: boolean;
typographyClassName?: string;
value: React.ReactNode;
variant: TypographyProps['variant'];
classes?: Partial<PickersToolbarButtonClasses>;
width?: number | string;
}
export declare const PickersToolbarButton: React.ForwardRefExoticComponent<Omit<PickersToolbarButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

70
node_modules/@mui/x-date-pickers/internals/components/PickersToolbarButton.js generated vendored Normal file
View file

@ -0,0 +1,70 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickersToolbarButton = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _clsx = _interopRequireDefault(require("clsx"));
var _Button = _interopRequireDefault(require("@mui/material/Button"));
var _styles = require("@mui/material/styles");
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _PickersToolbarText = require("./PickersToolbarText");
var _pickersToolbarClasses = require("./pickersToolbarClasses");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["align", "className", "classes", "selected", "typographyClassName", "value", "variant", "width"];
const useUtilityClasses = classes => {
const slots = {
root: ['root']
};
return (0, _composeClasses.default)(slots, _pickersToolbarClasses.getPickersToolbarUtilityClass, classes);
};
const PickersToolbarButtonRoot = (0, _styles.styled)(_Button.default, {
name: 'MuiPickersToolbarButton',
slot: 'Root'
})({
padding: 0,
minWidth: 16,
textTransform: 'none'
});
const PickersToolbarButton = exports.PickersToolbarButton = /*#__PURE__*/React.forwardRef(function PickersToolbarButton(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersToolbarButton'
});
const {
align,
className,
classes: classesProp,
selected,
typographyClassName,
value,
variant,
width
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const classes = useUtilityClasses(classesProp);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersToolbarButtonRoot, (0, _extends2.default)({
variant: "text",
ref: ref,
className: (0, _clsx.default)(classes.root, className),
ownerState: props
}, width ? {
sx: {
width
}
} : {}, other, {
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickersToolbarText.PickersToolbarText, {
align: align,
className: typographyClassName,
variant: variant,
value: value,
selected: selected
})
}));
});
if (process.env.NODE_ENV !== "production") PickersToolbarButton.displayName = "PickersToolbarButton";

11
node_modules/@mui/x-date-pickers/internals/components/PickersToolbarText.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import * as React from 'react';
import { TypographyProps } from '@mui/material/Typography';
import { PickersToolbarTextClasses } from "./pickersToolbarTextClasses.js";
export interface ExportedPickersToolbarTextProps extends Omit<TypographyProps, 'classes' | 'variant' | 'align'> {
classes?: Partial<PickersToolbarTextClasses>;
}
export interface PickersToolbarTextProps extends Omit<TypographyProps, 'classes'>, Pick<ExportedPickersToolbarTextProps, 'classes'> {
selected?: boolean;
value: React.ReactNode;
}
export declare const PickersToolbarText: React.ForwardRefExoticComponent<Omit<PickersToolbarTextProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

61
node_modules/@mui/x-date-pickers/internals/components/PickersToolbarText.js generated vendored Normal file
View file

@ -0,0 +1,61 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickersToolbarText = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _clsx = _interopRequireDefault(require("clsx"));
var _Typography = _interopRequireDefault(require("@mui/material/Typography"));
var _styles = require("@mui/material/styles");
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _pickersToolbarTextClasses = require("./pickersToolbarTextClasses");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["className", "classes", "selected", "value"];
const useUtilityClasses = classes => {
const slots = {
root: ['root']
};
return (0, _composeClasses.default)(slots, _pickersToolbarTextClasses.getPickersToolbarTextUtilityClass, classes);
};
const PickersToolbarTextRoot = (0, _styles.styled)(_Typography.default, {
name: 'MuiPickersToolbarText',
slot: 'Root'
})(({
theme
}) => ({
transition: theme.transitions.create('color'),
color: (theme.vars || theme).palette.text.secondary,
[`&[data-selected]`]: {
color: (theme.vars || theme).palette.text.primary
}
}));
const PickersToolbarText = exports.PickersToolbarText = /*#__PURE__*/React.forwardRef(function PickersToolbarText(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersToolbarText'
});
const {
className,
classes: classesProp,
selected,
value
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const classes = useUtilityClasses(classesProp);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersToolbarTextRoot, (0, _extends2.default)({
ref: ref,
className: (0, _clsx.default)(classes.root, className),
component: "span",
ownerState: props
}, selected && {
'data-selected': true
}, other, {
children: value
}));
});
if (process.env.NODE_ENV !== "production") PickersToolbarText.displayName = "PickersToolbarText";

7
node_modules/@mui/x-date-pickers/internals/components/pickersToolbarButtonClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
export interface PickersToolbarButtonClasses {
/** Styles applied to the root element. */
root: string;
}
export type PickersToolbarButtonClassKey = keyof PickersToolbarButtonClasses;
export declare function getPickersToolbarButtonUtilityClass(slot: string): string;
export declare const pickersToolbarButtonClasses: Record<"root", string>;

14
node_modules/@mui/x-date-pickers/internals/components/pickersToolbarButtonClasses.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersToolbarButtonUtilityClass = getPickersToolbarButtonUtilityClass;
exports.pickersToolbarButtonClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickersToolbarButtonUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersToolbarButton', slot);
}
const pickersToolbarButtonClasses = exports.pickersToolbarButtonClasses = (0, _generateUtilityClasses.default)('MuiPickersToolbarButton', ['root']);

11
node_modules/@mui/x-date-pickers/internals/components/pickersToolbarClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
export interface PickersToolbarClasses {
/** Styles applied to the root element. */
root: string;
/** Styles applied to the title element. */
title: string;
/** Styles applied to the content element. */
content: string;
}
export type PickersToolbarClassKey = keyof PickersToolbarClasses;
export declare function getPickersToolbarUtilityClass(slot: string): string;
export declare const pickersToolbarClasses: Record<"root" | "title" | "content", string>;

14
node_modules/@mui/x-date-pickers/internals/components/pickersToolbarClasses.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersToolbarUtilityClass = getPickersToolbarUtilityClass;
exports.pickersToolbarClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickersToolbarUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersToolbar', slot);
}
const pickersToolbarClasses = exports.pickersToolbarClasses = (0, _generateUtilityClasses.default)('MuiPickersToolbar', ['root', 'title', 'content']);

7
node_modules/@mui/x-date-pickers/internals/components/pickersToolbarTextClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
export interface PickersToolbarTextClasses {
/** Styles applied to the root element. */
root: string;
}
export type PickersToolbarTextClassKey = keyof PickersToolbarTextClasses;
export declare function getPickersToolbarTextUtilityClass(slot: string): string;
export declare const pickersToolbarTextClasses: Record<"root", string>;

14
node_modules/@mui/x-date-pickers/internals/components/pickersToolbarTextClasses.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersToolbarTextUtilityClass = getPickersToolbarTextUtilityClass;
exports.pickersToolbarTextClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickersToolbarTextUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersToolbarText', slot);
}
const pickersToolbarTextClasses = exports.pickersToolbarTextClasses = (0, _generateUtilityClasses.default)('MuiPickersToolbarText', ['root']);