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

19
node_modules/@mui/x-date-pickers/PickersTextField/PickersFilledInput/PickersFilledInput.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
import * as React from 'react';
import { PickersInputBaseProps } from "../PickersInputBase/index.js";
import { PickerTextFieldOwnerState } from "../../models/fields.js";
export interface PickersFilledInputProps extends PickersInputBaseProps {
disableUnderline?: boolean;
hiddenLabel?: boolean;
}
export interface PickerFilledInputOwnerState extends PickerTextFieldOwnerState {
/**
* `true` if the input has an underline, `false` otherwise.
*/
inputHasUnderline: boolean;
hiddenLabel?: boolean;
}
/**
* @ignore - internal component.
*/
declare const PickersFilledInput: React.ForwardRefExoticComponent<Omit<PickersFilledInputProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
export { PickersFilledInput };

312
node_modules/@mui/x-date-pickers/PickersTextField/PickersFilledInput/PickersFilledInput.js generated vendored Normal file
View file

@ -0,0 +1,312 @@
"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.PickersFilledInput = void 0;
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var React = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _styles = require("@mui/material/styles");
var _system = require("@mui/system");
var _refType = _interopRequireDefault(require("@mui/utils/refType"));
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _pickersFilledInputClasses = require("./pickersFilledInputClasses");
var _PickersInputBase = require("../PickersInputBase");
var _PickersInputBase2 = require("../PickersInputBase/PickersInputBase");
var _usePickerTextFieldOwnerState = require("../usePickerTextFieldOwnerState");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["label", "autoFocus", "disableUnderline", "hiddenLabel", "classes"];
const PickersFilledInputRoot = (0, _styles.styled)(_PickersInputBase2.PickersInputBaseRoot, {
name: 'MuiPickersFilledInput',
slot: 'Root',
shouldForwardProp: prop => (0, _system.shouldForwardProp)(prop) && prop !== 'disableUnderline'
})(({
theme
}) => {
const light = theme.palette.mode === 'light';
const bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
const backgroundColor = light ? 'rgba(0, 0, 0, 0.06)' : 'rgba(255, 255, 255, 0.09)';
const hoverBackground = light ? 'rgba(0, 0, 0, 0.09)' : 'rgba(255, 255, 255, 0.13)';
const disabledBackground = light ? 'rgba(0, 0, 0, 0.12)' : 'rgba(255, 255, 255, 0.12)';
return {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor,
borderTopLeftRadius: (theme.vars || theme).shape.borderRadius,
borderTopRightRadius: (theme.vars || theme).shape.borderRadius,
transition: theme.transitions.create('background-color', {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
}),
'&:hover': {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.hoverBg : hoverBackground,
// Reset on touch devices, it doesn't add specificity
'@media (hover: none)': {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor
}
},
[`&.${_pickersFilledInputClasses.pickersFilledInputClasses.focused}`]: {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor
},
[`&.${_pickersFilledInputClasses.pickersFilledInputClasses.disabled}`]: {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.disabledBg : disabledBackground
},
variants: [...Object.keys((theme.vars ?? theme).palette)
// @ts-ignore
.filter(key => (theme.vars ?? theme).palette[key].main).map(color => ({
props: {
inputColor: color,
disableUnderline: false
},
style: {
'&::after': {
// @ts-ignore
borderBottom: `2px solid ${(theme.vars || theme).palette[color]?.main}`
}
}
})), {
props: {
disableUnderline: false
},
style: {
'&::after': {
left: 0,
bottom: 0,
// Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
content: '""',
position: 'absolute',
right: 0,
transform: 'scaleX(0)',
transition: theme.transitions.create('transform', {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
}),
pointerEvents: 'none' // Transparent to the hover style.
},
[`&.${_pickersFilledInputClasses.pickersFilledInputClasses.focused}:after`]: {
// translateX(0) is a workaround for Safari transform scale bug
// See https://github.com/mui/material-ui/issues/31766
transform: 'scaleX(1) translateX(0)'
},
[`&.${_pickersFilledInputClasses.pickersFilledInputClasses.error}`]: {
'&:before, &:after': {
borderBottomColor: (theme.vars || theme).palette.error.main
}
},
'&::before': {
borderBottom: `1px solid ${theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / ${theme.vars.opacity.inputUnderline})` : bottomLineColor}`,
left: 0,
bottom: 0,
// Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
content: '"\\00a0"',
position: 'absolute',
right: 0,
transition: theme.transitions.create('border-bottom-color', {
duration: theme.transitions.duration.shorter
}),
pointerEvents: 'none' // Transparent to the hover style.
},
[`&:hover:not(.${_pickersFilledInputClasses.pickersFilledInputClasses.disabled}, .${_pickersFilledInputClasses.pickersFilledInputClasses.error}):before`]: {
borderBottom: `1px solid ${(theme.vars || theme).palette.text.primary}`
},
[`&.${_pickersFilledInputClasses.pickersFilledInputClasses.disabled}:before`]: {
borderBottomStyle: 'dotted'
}
}
}, {
props: {
hasStartAdornment: true
},
style: {
paddingLeft: 12
}
}, {
props: {
hasEndAdornment: true
},
style: {
paddingRight: 12
}
}]
};
});
const PickersFilledSectionsContainer = (0, _styles.styled)(_PickersInputBase2.PickersInputBaseSectionsContainer, {
name: 'MuiPickersFilledInput',
slot: 'sectionsContainer',
shouldForwardProp: prop => (0, _system.shouldForwardProp)(prop) && prop !== 'hiddenLabel'
})({
paddingTop: 25,
paddingRight: 12,
paddingBottom: 8,
paddingLeft: 12,
variants: [{
props: {
inputSize: 'small'
},
style: {
paddingTop: 21,
paddingBottom: 4
}
}, {
props: {
hasStartAdornment: true
},
style: {
paddingLeft: 0
}
}, {
props: {
hasEndAdornment: true
},
style: {
paddingRight: 0
}
}, {
props: {
hiddenLabel: true
},
style: {
paddingTop: 16,
paddingBottom: 17
}
}, {
props: {
hiddenLabel: true,
inputSize: 'small'
},
style: {
paddingTop: 8,
paddingBottom: 9
}
}]
});
const useUtilityClasses = (classes, ownerState) => {
const {
inputHasUnderline
} = ownerState;
const slots = {
root: ['root', inputHasUnderline && 'underline'],
input: ['input']
};
const composedClasses = (0, _composeClasses.default)(slots, _pickersFilledInputClasses.getPickersFilledInputUtilityClass, classes);
return (0, _extends2.default)({}, classes, composedClasses);
};
/**
* @ignore - internal component.
*/
const PickersFilledInput = exports.PickersFilledInput = /*#__PURE__*/React.forwardRef(function PickersFilledInput(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersFilledInput'
});
const {
label,
disableUnderline = false,
hiddenLabel = false,
classes: classesProp
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const pickerTextFieldOwnerState = (0, _usePickerTextFieldOwnerState.usePickerTextFieldOwnerState)();
const ownerState = (0, _extends2.default)({}, pickerTextFieldOwnerState, {
inputHasUnderline: !disableUnderline
});
const classes = useUtilityClasses(classesProp, ownerState);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickersInputBase.PickersInputBase, (0, _extends2.default)({
slots: {
root: PickersFilledInputRoot,
input: PickersFilledSectionsContainer
},
slotProps: {
root: {
disableUnderline
},
input: {
hiddenLabel
}
}
}, other, {
label: label,
classes: classes,
ref: ref,
ownerState: ownerState
}));
});
if (process.env.NODE_ENV !== "production") PickersFilledInput.displayName = "PickersFilledInput";
process.env.NODE_ENV !== "production" ? PickersFilledInput.propTypes = {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the TypeScript types and run "pnpm proptypes" |
// ----------------------------------------------------------------------
/**
* Is `true` if the current values equals the empty value.
* For a single item value, it means that `value === null`
* For a range value, it means that `value === [null, null]`
*/
areAllSectionsEmpty: _propTypes.default.bool.isRequired,
className: _propTypes.default.string,
component: _propTypes.default.elementType,
/**
* If true, the whole element is editable.
* Useful when all the sections are selected.
*/
contentEditable: _propTypes.default.bool.isRequired,
'data-multi-input': _propTypes.default.string,
disableUnderline: _propTypes.default.bool,
/**
* The elements to render.
* Each element contains the prop to edit a section of the value.
*/
elements: _propTypes.default.arrayOf(_propTypes.default.shape({
after: _propTypes.default.object.isRequired,
before: _propTypes.default.object.isRequired,
container: _propTypes.default.object.isRequired,
content: _propTypes.default.object.isRequired
})).isRequired,
endAdornment: _propTypes.default.node,
fullWidth: _propTypes.default.bool,
hiddenLabel: _propTypes.default.bool,
id: _propTypes.default.string,
inputProps: _propTypes.default.object,
inputRef: _refType.default,
label: _propTypes.default.node,
margin: _propTypes.default.oneOf(['dense', 'none', 'normal']),
name: _propTypes.default.string,
onChange: _propTypes.default.func.isRequired,
onClick: _propTypes.default.func.isRequired,
onInput: _propTypes.default.func.isRequired,
onKeyDown: _propTypes.default.func.isRequired,
onPaste: _propTypes.default.func.isRequired,
ownerState: _propTypes.default /* @typescript-to-proptypes-ignore */.any,
readOnly: _propTypes.default.bool,
renderSuffix: _propTypes.default.func,
sectionListRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
current: _propTypes.default.shape({
getRoot: _propTypes.default.func.isRequired,
getSectionContainer: _propTypes.default.func.isRequired,
getSectionContent: _propTypes.default.func.isRequired,
getSectionIndexFromDOMElement: _propTypes.default.func.isRequired
})
})]),
/**
* The props used for each component slot.
* @default {}
*/
slotProps: _propTypes.default.object,
/**
* The components used for each slot inside.
*
* @default {}
*/
slots: _propTypes.default.object,
startAdornment: _propTypes.default.node,
style: _propTypes.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
value: _propTypes.default.string.isRequired
} : void 0;
PickersFilledInput.muiName = 'Input';

4
node_modules/@mui/x-date-pickers/PickersTextField/PickersFilledInput/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export { PickersFilledInput } from "./PickersFilledInput.js";
export type { PickersFilledInputProps } from "./PickersFilledInput.js";
export type { PickersFilledInputClasses, PickersFilledInputClassKey } from "./pickersFilledInputClasses.js";
export { getPickersFilledInputUtilityClass, pickersFilledInputClasses } from "./pickersFilledInputClasses.js";

25
node_modules/@mui/x-date-pickers/PickersTextField/PickersFilledInput/index.js generated vendored Normal file
View file

@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickersFilledInput", {
enumerable: true,
get: function () {
return _PickersFilledInput.PickersFilledInput;
}
});
Object.defineProperty(exports, "getPickersFilledInputUtilityClass", {
enumerable: true,
get: function () {
return _pickersFilledInputClasses.getPickersFilledInputUtilityClass;
}
});
Object.defineProperty(exports, "pickersFilledInputClasses", {
enumerable: true,
get: function () {
return _pickersFilledInputClasses.pickersFilledInputClasses;
}
});
var _PickersFilledInput = require("./PickersFilledInput");
var _pickersFilledInputClasses = require("./pickersFilledInputClasses");

25
node_modules/@mui/x-date-pickers/PickersTextField/PickersFilledInput/pickersFilledInputClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,25 @@
import { PickersInputBaseClasses } from "../PickersInputBase/index.js";
export interface PickersFilledInputClasses extends PickersInputBaseClasses {
/** Styles applied to the root element unless `disableUnderline={true}`. */
underline: string;
}
export type PickersFilledInputClassKey = keyof PickersFilledInputClasses;
export declare function getPickersFilledInputUtilityClass(slot: string): string;
export declare const pickersFilledInputClasses: {
root: string;
input: string;
underline: string;
sectionContent: string;
disabled: string;
readOnly: string;
focused: string;
error: string;
inputSizeSmall: string;
notchedOutline: string;
sectionsContainer: string;
sectionBefore: string;
sectionAfter: string;
adornedStart: string;
adornedEnd: string;
activeBar: string;
};

16
node_modules/@mui/x-date-pickers/PickersTextField/PickersFilledInput/pickersFilledInputClasses.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersFilledInputUtilityClass = getPickersFilledInputUtilityClass;
exports.pickersFilledInputClasses = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _PickersInputBase = require("../PickersInputBase");
function getPickersFilledInputUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersFilledInput', slot);
}
const pickersFilledInputClasses = exports.pickersFilledInputClasses = (0, _extends2.default)({}, _PickersInputBase.pickersInputBaseClasses, (0, _generateUtilityClasses.default)('MuiPickersFilledInput', ['root', 'underline', 'input']));

17
node_modules/@mui/x-date-pickers/PickersTextField/PickersInput/PickersInput.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
import * as React from 'react';
import { PickersInputBaseProps } from "../PickersInputBase/index.js";
import { PickerTextFieldOwnerState } from "../../models/fields.js";
export interface PickersInputProps extends PickersInputBaseProps {
disableUnderline?: boolean;
}
export interface PickerInputOwnerState extends PickerTextFieldOwnerState {
/**
* `true` if the input has an underline, `false` otherwise.
*/
inputHasUnderline: boolean;
}
/**
* @ignore - internal component.
*/
declare const PickersInput: React.ForwardRefExoticComponent<Omit<PickersInputProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
export { PickersInput };

230
node_modules/@mui/x-date-pickers/PickersTextField/PickersInput/PickersInput.js generated vendored Normal file
View file

@ -0,0 +1,230 @@
"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.PickersInput = void 0;
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var React = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _styles = require("@mui/material/styles");
var _createStyled = require("@mui/system/createStyled");
var _refType = _interopRequireDefault(require("@mui/utils/refType"));
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _pickersInputClasses = require("./pickersInputClasses");
var _PickersInputBase = require("../PickersInputBase");
var _PickersInputBase2 = require("../PickersInputBase/PickersInputBase");
var _usePickerTextFieldOwnerState = require("../usePickerTextFieldOwnerState");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["label", "autoFocus", "disableUnderline", "ownerState", "classes"];
const PickersInputRoot = (0, _styles.styled)(_PickersInputBase2.PickersInputBaseRoot, {
name: 'MuiPickersInput',
slot: 'Root',
shouldForwardProp: prop => (0, _createStyled.shouldForwardProp)(prop) && prop !== 'disableUnderline'
})(({
theme
}) => {
const light = theme.palette.mode === 'light';
let bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
if (theme.vars) {
bottomLineColor = `rgba(${theme.vars.palette.common.onBackgroundChannel} / ${theme.vars.opacity.inputUnderline})`;
}
return {
'label + &': {
marginTop: 16
},
variants: [...Object.keys((theme.vars ?? theme).palette)
// @ts-ignore
.filter(key => (theme.vars ?? theme).palette[key].main).map(color => ({
props: {
inputColor: color,
inputHasUnderline: true
},
style: {
'&::after': {
// @ts-ignore
borderBottom: `2px solid ${(theme.vars || theme).palette[color].main}`
}
}
})), {
props: {
inputHasUnderline: true
},
style: {
'&::after': {
background: 'red',
left: 0,
bottom: 0,
// Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
content: '""',
position: 'absolute',
right: 0,
transform: 'scaleX(0)',
transition: theme.transitions.create('transform', {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
}),
pointerEvents: 'none' // Transparent to the hover style.
},
[`&.${_pickersInputClasses.pickersInputClasses.focused}:after`]: {
// translateX(0) is a workaround for Safari transform scale bug
// See https://github.com/mui/material-ui/issues/31766
transform: 'scaleX(1) translateX(0)'
},
[`&.${_pickersInputClasses.pickersInputClasses.error}`]: {
'&:before, &:after': {
borderBottomColor: (theme.vars || theme).palette.error.main
}
},
'&::before': {
borderBottom: `1px solid ${bottomLineColor}`,
left: 0,
bottom: 0,
// Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
content: '"\\00a0"',
position: 'absolute',
right: 0,
transition: theme.transitions.create('border-bottom-color', {
duration: theme.transitions.duration.shorter
}),
pointerEvents: 'none' // Transparent to the hover style.
},
[`&:hover:not(.${_pickersInputClasses.pickersInputClasses.disabled}, .${_pickersInputClasses.pickersInputClasses.error}):before`]: {
borderBottom: `2px solid ${(theme.vars || theme).palette.text.primary}`,
// Reset on touch devices, it doesn't add specificity
'@media (hover: none)': {
borderBottom: `1px solid ${bottomLineColor}`
}
},
[`&.${_pickersInputClasses.pickersInputClasses.disabled}:before`]: {
borderBottomStyle: 'dotted'
}
}
}]
};
});
const useUtilityClasses = (classes, ownerState) => {
const {
inputHasUnderline
} = ownerState;
const slots = {
root: ['root', !inputHasUnderline && 'underline'],
input: ['input']
};
const composedClasses = (0, _composeClasses.default)(slots, _pickersInputClasses.getPickersInputUtilityClass, classes);
return (0, _extends2.default)({}, classes, composedClasses);
};
/**
* @ignore - internal component.
*/
const PickersInput = exports.PickersInput = /*#__PURE__*/React.forwardRef(function PickersInput(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersInput'
});
const {
label,
disableUnderline = false,
classes: classesProp
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const pickerTextFieldOwnerState = (0, _usePickerTextFieldOwnerState.usePickerTextFieldOwnerState)();
const ownerState = (0, _extends2.default)({}, pickerTextFieldOwnerState, {
inputHasUnderline: !disableUnderline
});
const classes = useUtilityClasses(classesProp, ownerState);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickersInputBase.PickersInputBase, (0, _extends2.default)({
slots: {
root: PickersInputRoot
},
slotProps: {
root: {
disableUnderline
}
}
}, other, {
ownerState: ownerState,
label: label,
classes: classes,
ref: ref
}));
});
if (process.env.NODE_ENV !== "production") PickersInput.displayName = "PickersInput";
process.env.NODE_ENV !== "production" ? PickersInput.propTypes = {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the TypeScript types and run "pnpm proptypes" |
// ----------------------------------------------------------------------
/**
* Is `true` if the current values equals the empty value.
* For a single item value, it means that `value === null`
* For a range value, it means that `value === [null, null]`
*/
areAllSectionsEmpty: _propTypes.default.bool.isRequired,
className: _propTypes.default.string,
component: _propTypes.default.elementType,
/**
* If true, the whole element is editable.
* Useful when all the sections are selected.
*/
contentEditable: _propTypes.default.bool.isRequired,
'data-multi-input': _propTypes.default.string,
disableUnderline: _propTypes.default.bool,
/**
* The elements to render.
* Each element contains the prop to edit a section of the value.
*/
elements: _propTypes.default.arrayOf(_propTypes.default.shape({
after: _propTypes.default.object.isRequired,
before: _propTypes.default.object.isRequired,
container: _propTypes.default.object.isRequired,
content: _propTypes.default.object.isRequired
})).isRequired,
endAdornment: _propTypes.default.node,
fullWidth: _propTypes.default.bool,
id: _propTypes.default.string,
inputProps: _propTypes.default.object,
inputRef: _refType.default,
label: _propTypes.default.node,
margin: _propTypes.default.oneOf(['dense', 'none', 'normal']),
name: _propTypes.default.string,
onChange: _propTypes.default.func.isRequired,
onClick: _propTypes.default.func.isRequired,
onInput: _propTypes.default.func.isRequired,
onKeyDown: _propTypes.default.func.isRequired,
onPaste: _propTypes.default.func.isRequired,
ownerState: _propTypes.default /* @typescript-to-proptypes-ignore */.any,
readOnly: _propTypes.default.bool,
renderSuffix: _propTypes.default.func,
sectionListRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
current: _propTypes.default.shape({
getRoot: _propTypes.default.func.isRequired,
getSectionContainer: _propTypes.default.func.isRequired,
getSectionContent: _propTypes.default.func.isRequired,
getSectionIndexFromDOMElement: _propTypes.default.func.isRequired
})
})]),
/**
* The props used for each component slot.
* @default {}
*/
slotProps: _propTypes.default.object,
/**
* The components used for each slot inside.
*
* @default {}
*/
slots: _propTypes.default.object,
startAdornment: _propTypes.default.node,
style: _propTypes.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
value: _propTypes.default.string.isRequired
} : void 0;
PickersInput.muiName = 'Input';

4
node_modules/@mui/x-date-pickers/PickersTextField/PickersInput/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export { PickersInput } from "./PickersInput.js";
export type { PickersInputProps } from "./PickersInput.js";
export type { PickersInputClasses, PickersInputClassKey } from "./pickersInputClasses.js";
export { getPickersInputUtilityClass, pickersInputClasses } from "./pickersInputClasses.js";

25
node_modules/@mui/x-date-pickers/PickersTextField/PickersInput/index.js generated vendored Normal file
View file

@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickersInput", {
enumerable: true,
get: function () {
return _PickersInput.PickersInput;
}
});
Object.defineProperty(exports, "getPickersInputUtilityClass", {
enumerable: true,
get: function () {
return _pickersInputClasses.getPickersInputUtilityClass;
}
});
Object.defineProperty(exports, "pickersInputClasses", {
enumerable: true,
get: function () {
return _pickersInputClasses.pickersInputClasses;
}
});
var _PickersInput = require("./PickersInput");
var _pickersInputClasses = require("./pickersInputClasses");

25
node_modules/@mui/x-date-pickers/PickersTextField/PickersInput/pickersInputClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,25 @@
import { PickersInputBaseClasses } from "../PickersInputBase/index.js";
export interface PickersInputClasses extends PickersInputBaseClasses {
/** Styles applied to the root element unless `disableUnderline={true}`. */
underline: string;
}
export type PickersInputClassKey = keyof PickersInputClasses;
export declare function getPickersInputUtilityClass(slot: string): string;
export declare const pickersInputClasses: {
root: string;
input: string;
underline: string;
sectionContent: string;
disabled: string;
readOnly: string;
focused: string;
error: string;
inputSizeSmall: string;
notchedOutline: string;
sectionsContainer: string;
sectionBefore: string;
sectionAfter: string;
adornedStart: string;
adornedEnd: string;
activeBar: string;
};

16
node_modules/@mui/x-date-pickers/PickersTextField/PickersInput/pickersInputClasses.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersInputUtilityClass = getPickersInputUtilityClass;
exports.pickersInputClasses = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _PickersInputBase = require("../PickersInputBase");
function getPickersInputUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersFilledInput', slot);
}
const pickersInputClasses = exports.pickersInputClasses = (0, _extends2.default)({}, _PickersInputBase.pickersInputBaseClasses, (0, _generateUtilityClasses.default)('MuiPickersInput', ['root', 'underline', 'input']));

14
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/PickersInputBase.d.ts generated vendored Normal file
View file

@ -0,0 +1,14 @@
import * as React from 'react';
import { PickersInputBaseProps } from "./PickersInputBase.types.js";
import { PickerTextFieldOwnerState } from "../../models/fields.js";
export declare const PickersInputBaseRoot: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & {
ownerState: PickerTextFieldOwnerState;
}, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | keyof React.ClassAttributes<HTMLDivElement>>, {}>;
export declare const PickersInputBaseSectionsContainer: import("@emotion/styled").StyledComponent<Pick<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | keyof React.ClassAttributes<HTMLDivElement>>, keyof React.HTMLAttributes<HTMLDivElement> | keyof React.ClassAttributes<HTMLDivElement> | keyof import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & {
ownerState: PickerTextFieldOwnerState;
}, {}, {}>;
/**
* @ignore - internal component.
*/
declare const PickersInputBase: React.ForwardRefExoticComponent<Omit<PickersInputBaseProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
export { PickersInputBase };

490
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/PickersInputBase.js generated vendored Normal file
View file

@ -0,0 +1,490 @@
"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.PickersInputBaseSectionsContainer = exports.PickersInputBaseRoot = exports.PickersInputBase = void 0;
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var React = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _FormControl = require("@mui/material/FormControl");
var _styles = require("@mui/material/styles");
var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
var _refType = _interopRequireDefault(require("@mui/utils/refType"));
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _capitalize = _interopRequireDefault(require("@mui/utils/capitalize"));
var _useSlotProps = _interopRequireDefault(require("@mui/utils/useSlotProps"));
var _visuallyHidden = _interopRequireDefault(require("@mui/utils/visuallyHidden"));
var _pickersInputBaseClasses = require("./pickersInputBaseClasses");
var _PickersSectionList = require("../../PickersSectionList");
var _usePickerTextFieldOwnerState = require("../usePickerTextFieldOwnerState");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["elements", "areAllSectionsEmpty", "defaultValue", "label", "value", "onChange", "id", "autoFocus", "endAdornment", "startAdornment", "renderSuffix", "slots", "slotProps", "contentEditable", "tabIndex", "onInput", "onPaste", "onKeyDown", "fullWidth", "name", "readOnly", "inputProps", "inputRef", "sectionListRef", "onFocus", "onBlur", "classes", "ownerState"];
const round = value => Math.round(value * 1e5) / 1e5;
const PickersInputBaseRoot = exports.PickersInputBaseRoot = (0, _styles.styled)('div', {
name: 'MuiPickersInputBase',
slot: 'Root'
})(({
theme
}) => (0, _extends2.default)({}, theme.typography.body1, {
color: (theme.vars || theme).palette.text.primary,
cursor: 'text',
padding: 0,
display: 'flex',
justifyContent: 'flex-start',
alignItems: 'center',
position: 'relative',
boxSizing: 'border-box',
// Prevent padding issue with fullWidth.
letterSpacing: `${round(0.15 / 16)}em`,
variants: [{
props: {
isInputInFullWidth: true
},
style: {
width: '100%'
}
}]
}));
const PickersInputBaseSectionsContainer = exports.PickersInputBaseSectionsContainer = (0, _styles.styled)(_PickersSectionList.Unstable_PickersSectionListRoot, {
name: 'MuiPickersInputBase',
slot: 'SectionsContainer'
})(({
theme
}) => ({
padding: '4px 0 5px',
fontFamily: theme.typography.fontFamily,
fontSize: 'inherit',
lineHeight: '1.4375em',
// 23px
flexGrow: 1,
outline: 'none',
display: 'flex',
flexWrap: 'nowrap',
overflow: 'hidden',
letterSpacing: 'inherit',
// Baseline behavior
width: '182px',
variants: [{
props: {
fieldDirection: 'rtl'
},
style: {
justifyContent: 'end'
}
}, {
props: {
inputSize: 'small'
},
style: {
paddingTop: 1
}
}, {
props: {
hasStartAdornment: false,
isFieldFocused: false,
isFieldValueEmpty: true
},
style: {
color: 'currentColor',
opacity: 0
}
}, {
props: {
hasStartAdornment: false,
isFieldFocused: false,
isFieldValueEmpty: true,
inputHasLabel: false
},
style: theme.vars ? {
opacity: theme.vars.opacity.inputPlaceholder
} : {
opacity: theme.palette.mode === 'light' ? 0.42 : 0.5
}
}, {
props: {
hasStartAdornment: false,
isFieldFocused: false,
isFieldValueEmpty: true,
inputHasLabel: true,
isLabelShrunk: true
},
style: theme.vars ? {
opacity: theme.vars.opacity.inputPlaceholder
} : {
opacity: theme.palette.mode === 'light' ? 0.42 : 0.5
}
}]
}));
const PickersInputBaseSection = (0, _styles.styled)(_PickersSectionList.Unstable_PickersSectionListSection, {
name: 'MuiPickersInputBase',
slot: 'Section'
})(({
theme
}) => ({
fontFamily: theme.typography.fontFamily,
fontSize: 'inherit',
letterSpacing: 'inherit',
lineHeight: '1.4375em',
// 23px
display: 'inline-block',
whiteSpace: 'nowrap'
}));
const PickersInputBaseSectionContent = (0, _styles.styled)(_PickersSectionList.Unstable_PickersSectionListSectionContent, {
name: 'MuiPickersInputBase',
slot: 'SectionContent',
overridesResolver: (props, styles) => styles.content // FIXME: Inconsistent naming with slot
})(({
theme
}) => ({
fontFamily: theme.typography.fontFamily,
lineHeight: '1.4375em',
// 23px
letterSpacing: 'inherit',
width: 'fit-content',
outline: 'none'
}));
const PickersInputBaseSectionSeparator = (0, _styles.styled)(_PickersSectionList.Unstable_PickersSectionListSectionSeparator, {
name: 'MuiPickersInputBase',
slot: 'Separator'
})(() => ({
whiteSpace: 'pre',
letterSpacing: 'inherit'
}));
const PickersInputBaseInput = (0, _styles.styled)('input', {
name: 'MuiPickersInputBase',
slot: 'Input',
overridesResolver: (props, styles) => styles.hiddenInput // FIXME: Inconsistent naming with slot
})((0, _extends2.default)({}, _visuallyHidden.default));
const PickersInputBaseActiveBar = (0, _styles.styled)('div', {
name: 'MuiPickersInputBase',
slot: 'ActiveBar'
})(({
theme,
ownerState
}) => ({
display: 'none',
position: 'absolute',
height: 2,
bottom: 2,
borderTopLeftRadius: 2,
borderTopRightRadius: 2,
transition: theme.transitions.create(['width', 'left'], {
duration: theme.transitions.duration.shortest
}),
backgroundColor: (theme.vars || theme).palette.primary.main,
'[data-active-range-position="start"] &, [data-active-range-position="end"] &': {
display: 'block'
},
'[data-active-range-position="start"] &': {
left: ownerState.sectionOffsets[0]
},
'[data-active-range-position="end"] &': {
left: ownerState.sectionOffsets[1]
}
}));
const useUtilityClasses = (classes, ownerState) => {
const {
isFieldFocused,
isFieldDisabled,
isFieldReadOnly,
hasFieldError,
inputSize,
isInputInFullWidth,
inputColor,
hasStartAdornment,
hasEndAdornment
} = ownerState;
const slots = {
root: ['root', isFieldFocused && !isFieldDisabled && 'focused', isFieldDisabled && 'disabled', isFieldReadOnly && 'readOnly', hasFieldError && 'error', isInputInFullWidth && 'fullWidth', `color${(0, _capitalize.default)(inputColor)}`, inputSize === 'small' && 'inputSizeSmall', hasStartAdornment && 'adornedStart', hasEndAdornment && 'adornedEnd'],
notchedOutline: ['notchedOutline'],
input: ['input'],
sectionsContainer: ['sectionsContainer'],
sectionContent: ['sectionContent'],
sectionBefore: ['sectionBefore'],
sectionAfter: ['sectionAfter'],
activeBar: ['activeBar']
};
return (0, _composeClasses.default)(slots, _pickersInputBaseClasses.getPickersInputBaseUtilityClass, classes);
};
function resolveSectionElementWidth(sectionElement, rootRef, index, dateRangePosition) {
if (sectionElement.content.id) {
const activeSectionElements = rootRef.current?.querySelectorAll(`[data-sectionindex="${index}"] [data-range-position="${dateRangePosition}"]`);
if (activeSectionElements) {
return Array.from(activeSectionElements).reduce((currentActiveBarWidth, element) => {
return currentActiveBarWidth + element.offsetWidth;
}, 0);
}
}
return 0;
}
function resolveSectionWidthAndOffsets(elements, rootRef) {
let activeBarWidth = 0;
const activeRangePosition = rootRef.current?.getAttribute('data-active-range-position');
if (activeRangePosition === 'end') {
for (let i = elements.length - 1; i >= elements.length / 2; i -= 1) {
activeBarWidth += resolveSectionElementWidth(elements[i], rootRef, i, 'end');
}
} else {
for (let i = 0; i < elements.length / 2; i += 1) {
activeBarWidth += resolveSectionElementWidth(elements[i], rootRef, i, 'start');
}
}
return {
activeBarWidth,
sectionOffsets: [rootRef.current?.querySelector(`[data-sectionindex="0"]`)?.offsetLeft || 0, rootRef.current?.querySelector(`[data-sectionindex="${elements.length / 2}"]`)?.offsetLeft || 0]
};
}
/**
* @ignore - internal component.
*/
const PickersInputBase = exports.PickersInputBase = /*#__PURE__*/React.forwardRef(function PickersInputBase(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersInputBase'
});
const {
elements,
areAllSectionsEmpty,
value,
onChange,
id,
endAdornment,
startAdornment,
renderSuffix,
slots,
slotProps,
contentEditable,
tabIndex,
onInput,
onPaste,
onKeyDown,
name,
readOnly,
inputProps,
inputRef,
sectionListRef,
onFocus,
onBlur,
classes: classesProp,
ownerState: ownerStateProp
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const ownerStateContext = (0, _usePickerTextFieldOwnerState.usePickerTextFieldOwnerState)();
const rootRef = React.useRef(null);
const activeBarRef = React.useRef(null);
const sectionOffsetsRef = React.useRef([]);
const handleRootRef = (0, _useForkRef.default)(ref, rootRef);
const handleInputRef = (0, _useForkRef.default)(inputProps?.ref, inputRef);
const muiFormControl = (0, _FormControl.useFormControl)();
if (!muiFormControl) {
throw new Error('MUI X: PickersInputBase should always be used inside a PickersTextField component');
}
const ownerState = ownerStateProp ?? ownerStateContext;
const handleInputFocus = event => {
muiFormControl.onFocus?.(event);
onFocus?.(event);
};
const handleHiddenInputFocus = event => {
handleInputFocus(event);
};
const handleKeyDown = event => {
onKeyDown?.(event);
if (event.key === 'Enter' && !event.defaultMuiPrevented) {
// Do nothing if it's a multi input field
if (rootRef.current?.dataset.multiInput) {
return;
}
const closestForm = rootRef.current?.closest('form');
const submitTrigger = closestForm?.querySelector('[type="submit"]');
if (!closestForm || !submitTrigger) {
// do nothing if there is no form or no submit button (trigger)
return;
}
event.preventDefault();
// native input trigger submit with the `submitter` field set
closestForm.requestSubmit(submitTrigger);
}
};
const handleInputBlur = event => {
muiFormControl.onBlur?.(event);
onBlur?.(event);
};
React.useEffect(() => {
if (muiFormControl) {
muiFormControl.setAdornedStart(Boolean(startAdornment));
}
}, [muiFormControl, startAdornment]);
React.useEffect(() => {
if (!muiFormControl) {
return;
}
if (areAllSectionsEmpty) {
muiFormControl.onEmpty();
} else {
muiFormControl.onFilled();
}
}, [muiFormControl, areAllSectionsEmpty]);
const classes = useUtilityClasses(classesProp, ownerState);
const InputRoot = slots?.root || PickersInputBaseRoot;
const inputRootProps = (0, _useSlotProps.default)({
elementType: InputRoot,
externalSlotProps: slotProps?.root,
externalForwardedProps: other,
additionalProps: {
'aria-invalid': muiFormControl.error,
ref: handleRootRef
},
className: classes.root,
ownerState
});
const InputSectionsContainer = slots?.input || PickersInputBaseSectionsContainer;
const isSingleInputRange = elements.some(element => element.content['data-range-position'] !== undefined);
React.useEffect(() => {
if (!isSingleInputRange || !ownerState.isPickerOpen) {
return;
}
const {
activeBarWidth,
sectionOffsets
} = resolveSectionWidthAndOffsets(elements, rootRef);
sectionOffsetsRef.current = [sectionOffsets[0], sectionOffsets[1]];
if (activeBarRef.current) {
activeBarRef.current.style.width = `${activeBarWidth}px`;
}
}, [elements, isSingleInputRange, ownerState.isPickerOpen]);
return /*#__PURE__*/(0, _jsxRuntime.jsxs)(InputRoot, (0, _extends2.default)({}, inputRootProps, {
children: [startAdornment, /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickersSectionList.Unstable_PickersSectionList, {
sectionListRef: sectionListRef,
elements: elements,
contentEditable: contentEditable,
tabIndex: tabIndex,
className: classes.sectionsContainer,
onFocus: handleInputFocus,
onBlur: handleInputBlur,
onInput: onInput,
onPaste: onPaste,
onKeyDown: handleKeyDown,
slots: {
root: InputSectionsContainer,
section: PickersInputBaseSection,
sectionContent: PickersInputBaseSectionContent,
sectionSeparator: PickersInputBaseSectionSeparator
},
slotProps: {
root: (0, _extends2.default)({}, slotProps?.input, {
ownerState
}),
sectionContent: {
className: _pickersInputBaseClasses.pickersInputBaseClasses.sectionContent
},
sectionSeparator: ({
separatorPosition
}) => ({
className: separatorPosition === 'before' ? _pickersInputBaseClasses.pickersInputBaseClasses.sectionBefore : _pickersInputBaseClasses.pickersInputBaseClasses.sectionAfter
})
}
}), endAdornment, renderSuffix ? renderSuffix((0, _extends2.default)({}, muiFormControl)) : null, /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersInputBaseInput, (0, _extends2.default)({
name: name,
className: classes.input,
value: value,
onChange: onChange,
id: id,
"aria-hidden": "true",
tabIndex: -1,
readOnly: readOnly,
required: muiFormControl.required,
disabled: muiFormControl.disabled
// Hidden input element cannot be focused, trigger the root focus instead
// This allows to maintain the ability to do `inputRef.current.focus()` to focus the field
,
onFocus: handleHiddenInputFocus
}, inputProps, {
ref: handleInputRef
})), isSingleInputRange && /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersInputBaseActiveBar, {
className: classes.activeBar,
ref: activeBarRef,
ownerState: {
sectionOffsets: sectionOffsetsRef.current
}
})]
}));
});
if (process.env.NODE_ENV !== "production") PickersInputBase.displayName = "PickersInputBase";
process.env.NODE_ENV !== "production" ? PickersInputBase.propTypes = {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the TypeScript types and run "pnpm proptypes" |
// ----------------------------------------------------------------------
/**
* Is `true` if the current values equals the empty value.
* For a single item value, it means that `value === null`
* For a range value, it means that `value === [null, null]`
*/
areAllSectionsEmpty: _propTypes.default.bool.isRequired,
className: _propTypes.default.string,
component: _propTypes.default.elementType,
/**
* If true, the whole element is editable.
* Useful when all the sections are selected.
*/
contentEditable: _propTypes.default.bool.isRequired,
'data-multi-input': _propTypes.default.string,
/**
* The elements to render.
* Each element contains the prop to edit a section of the value.
*/
elements: _propTypes.default.arrayOf(_propTypes.default.shape({
after: _propTypes.default.object.isRequired,
before: _propTypes.default.object.isRequired,
container: _propTypes.default.object.isRequired,
content: _propTypes.default.object.isRequired
})).isRequired,
endAdornment: _propTypes.default.node,
fullWidth: _propTypes.default.bool,
id: _propTypes.default.string,
inputProps: _propTypes.default.object,
inputRef: _refType.default,
label: _propTypes.default.node,
margin: _propTypes.default.oneOf(['dense', 'none', 'normal']),
name: _propTypes.default.string,
onChange: _propTypes.default.func.isRequired,
onClick: _propTypes.default.func.isRequired,
onInput: _propTypes.default.func.isRequired,
onKeyDown: _propTypes.default.func.isRequired,
onPaste: _propTypes.default.func.isRequired,
ownerState: _propTypes.default /* @typescript-to-proptypes-ignore */.any,
readOnly: _propTypes.default.bool,
renderSuffix: _propTypes.default.func,
sectionListRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
current: _propTypes.default.shape({
getRoot: _propTypes.default.func.isRequired,
getSectionContainer: _propTypes.default.func.isRequired,
getSectionContent: _propTypes.default.func.isRequired,
getSectionIndexFromDOMElement: _propTypes.default.func.isRequired
})
})]),
/**
* The props used for each component slot.
* @default {}
*/
slotProps: _propTypes.default.object,
/**
* The components used for each slot inside.
*
* @default {}
*/
slots: _propTypes.default.object,
startAdornment: _propTypes.default.node,
style: _propTypes.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
value: _propTypes.default.string.isRequired
} : void 0;

62
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/PickersInputBase.types.d.ts generated vendored Normal file
View file

@ -0,0 +1,62 @@
import * as React from 'react';
import { BoxProps } from '@mui/material/Box';
import { MuiEvent } from '@mui/x-internals/types';
import { PickersSectionListProps } from "../../PickersSectionList/index.js";
import { PickerTextFieldOwnerState } from "../../models/fields.js";
export interface PickersInputPropsUsedByField extends Pick<PickersSectionListProps, 'elements' | 'sectionListRef' | 'contentEditable' | 'tabIndex'> {
/**
* Is `true` if the current values equals the empty value.
* For a single item value, it means that `value === null`
* For a range value, it means that `value === [null, null]`
*/
areAllSectionsEmpty: boolean;
onClick: React.MouseEventHandler<HTMLDivElement>;
onKeyDown: React.EventHandler<MuiEvent<React.KeyboardEvent<HTMLDivElement>>>;
onInput: React.FormEventHandler<HTMLDivElement>;
onPaste: React.ClipboardEventHandler<HTMLDivElement>;
endAdornment?: React.ReactNode;
startAdornment?: React.ReactNode;
value: string;
onChange: React.ChangeEventHandler<HTMLInputElement>;
label?: React.ReactNode;
id?: string;
fullWidth?: boolean;
readOnly?: boolean;
name?: string;
inputProps?: React.HTMLAttributes<HTMLInputElement> & {
ref?: React.Ref<HTMLInputElement>;
};
inputRef?: React.Ref<HTMLInputElement>;
}
export interface PickersInputBaseProps extends Omit<BoxProps, keyof PickersInputPropsUsedByField>, PickersInputPropsUsedByField {
ownerState?: PickerTextFieldOwnerState;
margin?: 'dense' | 'none' | 'normal';
renderSuffix?: (state: {
disabled?: boolean;
error?: boolean;
filled?: boolean;
focused?: boolean;
margin?: 'dense' | 'none' | 'normal';
required?: boolean;
adornedStart?: boolean;
}) => React.ReactNode;
ref?: React.Ref<HTMLDivElement>;
/**
* The components used for each slot inside.
*
* @default {}
*/
slots?: {
root?: React.ElementType;
input?: React.ElementType;
};
/**
* The props used for each component slot.
* @default {}
*/
slotProps?: {
root?: any;
input?: any;
};
'data-multi-input'?: string;
}

5
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/PickersInputBase.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/PickersTextField/PickersInputBase/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export { PickersInputBase } from "./PickersInputBase.js";
export type { PickersInputBaseProps } from "./PickersInputBase.types.js";
export { pickersInputBaseClasses, getPickersInputBaseUtilityClass } from "./pickersInputBaseClasses.js";
export type { PickersInputBaseClasses, PickersInputBaseClassKey } from "./pickersInputBaseClasses.js";

25
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/index.js generated vendored Normal file
View file

@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickersInputBase", {
enumerable: true,
get: function () {
return _PickersInputBase.PickersInputBase;
}
});
Object.defineProperty(exports, "getPickersInputBaseUtilityClass", {
enumerable: true,
get: function () {
return _pickersInputBaseClasses.getPickersInputBaseUtilityClass;
}
});
Object.defineProperty(exports, "pickersInputBaseClasses", {
enumerable: true,
get: function () {
return _pickersInputBaseClasses.pickersInputBaseClasses;
}
});
var _PickersInputBase = require("./PickersInputBase");
var _pickersInputBaseClasses = require("./pickersInputBaseClasses");

35
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/pickersInputBaseClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,35 @@
export interface PickersInputBaseClasses {
/** Styles applied to the root element. */
root: string;
/** Styles applied to the root element if focused. */
focused: string;
/** State class applied to the root element if `disabled=true`. */
disabled: string;
/** State class applied to the root element if `readOnly=true`. */
readOnly: string;
/** State class applied to the root element if `error=true`. */
error: string;
/** State class applied to the root element if `size=small`. */
inputSizeSmall: string;
/** Styles applied to the NotchedOutline element. */
notchedOutline: string;
/** Styles applied to the real hidden input element. */
input: string;
/** Styles applied to the container of the sections. */
sectionsContainer: string;
/** Styles applied to the content of a section. */
sectionContent: string;
/** Styles applied to the separator before a section. */
sectionBefore: string;
/** Styles applied to the separator after a section. */
sectionAfter: string;
/** Styles applied to the root if there is a startAdornment present. */
adornedStart: string;
/** Styles applied to the root if there is an endAdornment present. */
adornedEnd: string;
/** Styles applied to the active section bar. */
activeBar: string;
}
export type PickersInputBaseClassKey = keyof PickersInputBaseClasses;
export declare function getPickersInputBaseUtilityClass(slot: string): string;
export declare const pickersInputBaseClasses: Record<keyof PickersInputBaseClasses, string>;

14
node_modules/@mui/x-date-pickers/PickersTextField/PickersInputBase/pickersInputBaseClasses.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.getPickersInputBaseUtilityClass = getPickersInputBaseUtilityClass;
exports.pickersInputBaseClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickersInputBaseUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersInputBase', slot);
}
const pickersInputBaseClasses = exports.pickersInputBaseClasses = (0, _generateUtilityClasses.default)('MuiPickersInputBase', ['root', 'focused', 'disabled', 'error', 'notchedOutline', 'sectionContent', 'sectionBefore', 'sectionAfter', 'adornedStart', 'adornedEnd', 'input', 'inputSizeSmall', 'activeBar']);

11
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/Outline.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import * as React from 'react';
interface OutlineProps extends React.HTMLAttributes<HTMLFieldSetElement> {
notched: boolean;
shrink: boolean;
label: React.ReactNode;
}
/**
* @ignore - internal component.
*/
export default function Outline(props: OutlineProps): React.JSX.Element;
export {};

144
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/Outline.js generated vendored Normal file
View file

@ -0,0 +1,144 @@
"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.default = Outline;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _styles = require("@mui/material/styles");
var _createStyled = require("@mui/system/createStyled");
var _usePickerTextFieldOwnerState = require("../usePickerTextFieldOwnerState");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["children", "className", "label", "notched", "shrink"];
const OutlineRoot = (0, _styles.styled)('fieldset', {
name: 'MuiPickersOutlinedInput',
slot: 'NotchedOutline'
})(({
theme
}) => {
const borderColor = theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)';
return {
textAlign: 'left',
position: 'absolute',
bottom: 0,
right: 0,
top: -5,
left: 0,
margin: 0,
padding: '0 8px',
pointerEvents: 'none',
borderRadius: 'inherit',
borderStyle: 'solid',
borderWidth: 1,
overflow: 'hidden',
minWidth: '0%',
borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
};
});
const OutlineLabel = (0, _styles.styled)('span')(({
theme
}) => ({
fontFamily: theme.typography.fontFamily,
fontSize: 'inherit'
}));
const OutlineLegend = (0, _styles.styled)('legend', {
shouldForwardProp: prop => (0, _createStyled.shouldForwardProp)(prop) && prop !== 'notched'
})(({
theme
}) => ({
float: 'unset',
// Fix conflict with bootstrap
width: 'auto',
// Fix conflict with bootstrap
overflow: 'hidden',
// Fix Horizontal scroll when label too long
variants: [{
props: {
inputHasLabel: false
},
style: {
padding: 0,
lineHeight: '11px',
// sync with `height` in `legend` styles
transition: theme.transitions.create('width', {
duration: 150,
easing: theme.transitions.easing.easeOut
})
}
}, {
props: {
inputHasLabel: true
},
style: {
display: 'block',
// Fix conflict with normalize.css and sanitize.css
padding: 0,
height: 11,
// sync with `lineHeight` in `legend` styles
fontSize: '0.75em',
visibility: 'hidden',
maxWidth: 0.01,
transition: theme.transitions.create('max-width', {
duration: 50,
easing: theme.transitions.easing.easeOut
}),
whiteSpace: 'nowrap',
'& > span': {
paddingLeft: 5,
paddingRight: 5,
display: 'inline-block',
opacity: 0,
visibility: 'visible'
}
}
}, {
props: {
inputHasLabel: true,
notched: true
},
style: {
maxWidth: '100%',
transition: theme.transitions.create('max-width', {
duration: 100,
easing: theme.transitions.easing.easeOut,
delay: 50
})
}
}]
}));
/**
* @ignore - internal component.
*/
function Outline(props) {
const {
className,
label,
notched
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const ownerState = (0, _usePickerTextFieldOwnerState.usePickerTextFieldOwnerState)();
return /*#__PURE__*/(0, _jsxRuntime.jsx)(OutlineRoot, (0, _extends2.default)({
"aria-hidden": true,
className: className
}, other, {
ownerState: ownerState,
children: /*#__PURE__*/(0, _jsxRuntime.jsx)(OutlineLegend, {
ownerState: ownerState,
notched: notched,
children: label ? /*#__PURE__*/(0, _jsxRuntime.jsx)(OutlineLabel, {
children: label
}) :
/*#__PURE__*/
// notranslate needed while Google Translate will not fix zero-width space issue
(0, _jsxRuntime.jsx)(OutlineLabel, {
className: "notranslate",
children: "\u200B"
})
})
}));
}

10
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/PickersOutlinedInput.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import * as React from 'react';
import { PickersInputBaseProps } from "../PickersInputBase/index.js";
export interface PickersOutlinedInputProps extends PickersInputBaseProps {
notched?: boolean;
}
/**
* @ignore - internal component.
*/
declare const PickersOutlinedInput: React.ForwardRefExoticComponent<Omit<PickersOutlinedInputProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
export { PickersOutlinedInput };

205
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/PickersOutlinedInput.js generated vendored Normal file
View file

@ -0,0 +1,205 @@
"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.PickersOutlinedInput = void 0;
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var React = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _FormControl = require("@mui/material/FormControl");
var _styles = require("@mui/material/styles");
var _refType = _interopRequireDefault(require("@mui/utils/refType"));
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _pickersOutlinedInputClasses = require("./pickersOutlinedInputClasses");
var _Outline = _interopRequireDefault(require("./Outline"));
var _PickersInputBase = require("../PickersInputBase");
var _PickersInputBase2 = require("../PickersInputBase/PickersInputBase");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["label", "autoFocus", "ownerState", "classes", "notched"];
const PickersOutlinedInputRoot = (0, _styles.styled)(_PickersInputBase2.PickersInputBaseRoot, {
name: 'MuiPickersOutlinedInput',
slot: 'Root'
})(({
theme
}) => {
const borderColor = theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)';
return {
padding: '0 14px',
borderRadius: (theme.vars || theme).shape.borderRadius,
[`&:hover .${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette.text.primary
},
// Reset on touch devices, it doesn't add specificity
'@media (hover: none)': {
[`&:hover .${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.notchedOutline}`]: {
borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
}
},
[`&.${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.focused} .${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.notchedOutline}`]: {
borderStyle: 'solid',
borderWidth: 2
},
[`&.${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.disabled}`]: {
[`& .${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette.action.disabled
},
'*': {
color: (theme.vars || theme).palette.action.disabled
}
},
[`&.${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.error} .${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette.error.main
},
variants: Object.keys((theme.vars ?? theme).palette)
// @ts-ignore
.filter(key => (theme.vars ?? theme).palette[key]?.main ?? false).map(color => ({
props: {
inputColor: color
},
style: {
[`&.${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.focused}:not(.${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.error}) .${_pickersOutlinedInputClasses.pickersOutlinedInputClasses.notchedOutline}`]: {
// @ts-ignore
borderColor: (theme.vars || theme).palette[color].main
}
}
}))
};
});
const PickersOutlinedInputSectionsContainer = (0, _styles.styled)(_PickersInputBase2.PickersInputBaseSectionsContainer, {
name: 'MuiPickersOutlinedInput',
slot: 'SectionsContainer'
})({
padding: '16.5px 0',
variants: [{
props: {
inputSize: 'small'
},
style: {
padding: '8.5px 0'
}
}]
});
const useUtilityClasses = classes => {
const slots = {
root: ['root'],
notchedOutline: ['notchedOutline'],
input: ['input']
};
const composedClasses = (0, _composeClasses.default)(slots, _pickersOutlinedInputClasses.getPickersOutlinedInputUtilityClass, classes);
return (0, _extends2.default)({}, classes, composedClasses);
};
/**
* @ignore - internal component.
*/
const PickersOutlinedInput = exports.PickersOutlinedInput = /*#__PURE__*/React.forwardRef(function PickersOutlinedInput(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersOutlinedInput'
});
const {
label,
classes: classesProp,
notched
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const muiFormControl = (0, _FormControl.useFormControl)();
const classes = useUtilityClasses(classesProp);
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickersInputBase.PickersInputBase, (0, _extends2.default)({
slots: {
root: PickersOutlinedInputRoot,
input: PickersOutlinedInputSectionsContainer
},
renderSuffix: state => /*#__PURE__*/(0, _jsxRuntime.jsx)(_Outline.default, {
shrink: Boolean(notched || state.adornedStart || state.focused || state.filled),
notched: Boolean(notched || state.adornedStart || state.focused || state.filled),
className: classes.notchedOutline,
label: label != null && label !== '' && muiFormControl?.required ? /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
children: [label, "\u2009", '*']
}) : label
})
}, other, {
label: label,
classes: classes,
ref: ref
}));
});
if (process.env.NODE_ENV !== "production") PickersOutlinedInput.displayName = "PickersOutlinedInput";
process.env.NODE_ENV !== "production" ? PickersOutlinedInput.propTypes = {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the TypeScript types and run "pnpm proptypes" |
// ----------------------------------------------------------------------
/**
* Is `true` if the current values equals the empty value.
* For a single item value, it means that `value === null`
* For a range value, it means that `value === [null, null]`
*/
areAllSectionsEmpty: _propTypes.default.bool.isRequired,
className: _propTypes.default.string,
component: _propTypes.default.elementType,
/**
* If true, the whole element is editable.
* Useful when all the sections are selected.
*/
contentEditable: _propTypes.default.bool.isRequired,
'data-multi-input': _propTypes.default.string,
/**
* The elements to render.
* Each element contains the prop to edit a section of the value.
*/
elements: _propTypes.default.arrayOf(_propTypes.default.shape({
after: _propTypes.default.object.isRequired,
before: _propTypes.default.object.isRequired,
container: _propTypes.default.object.isRequired,
content: _propTypes.default.object.isRequired
})).isRequired,
endAdornment: _propTypes.default.node,
fullWidth: _propTypes.default.bool,
id: _propTypes.default.string,
inputProps: _propTypes.default.object,
inputRef: _refType.default,
label: _propTypes.default.node,
margin: _propTypes.default.oneOf(['dense', 'none', 'normal']),
name: _propTypes.default.string,
notched: _propTypes.default.bool,
onChange: _propTypes.default.func.isRequired,
onClick: _propTypes.default.func.isRequired,
onInput: _propTypes.default.func.isRequired,
onKeyDown: _propTypes.default.func.isRequired,
onPaste: _propTypes.default.func.isRequired,
ownerState: _propTypes.default /* @typescript-to-proptypes-ignore */.any,
readOnly: _propTypes.default.bool,
renderSuffix: _propTypes.default.func,
sectionListRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
current: _propTypes.default.shape({
getRoot: _propTypes.default.func.isRequired,
getSectionContainer: _propTypes.default.func.isRequired,
getSectionContent: _propTypes.default.func.isRequired,
getSectionIndexFromDOMElement: _propTypes.default.func.isRequired
})
})]),
/**
* The props used for each component slot.
* @default {}
*/
slotProps: _propTypes.default.object,
/**
* The components used for each slot inside.
*
* @default {}
*/
slots: _propTypes.default.object,
startAdornment: _propTypes.default.node,
style: _propTypes.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
value: _propTypes.default.string.isRequired
} : void 0;
PickersOutlinedInput.muiName = 'Input';

4
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export { PickersOutlinedInput } from "./PickersOutlinedInput.js";
export type { PickersOutlinedInputProps } from "./PickersOutlinedInput.js";
export type { PickersOutlinedInputClasses, PickersOutlinedInputClassKey } from "./pickersOutlinedInputClasses.js";
export { getPickersOutlinedInputUtilityClass, pickersOutlinedInputClasses } from "./pickersOutlinedInputClasses.js";

25
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/index.js generated vendored Normal file
View file

@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "PickersOutlinedInput", {
enumerable: true,
get: function () {
return _PickersOutlinedInput.PickersOutlinedInput;
}
});
Object.defineProperty(exports, "getPickersOutlinedInputUtilityClass", {
enumerable: true,
get: function () {
return _pickersOutlinedInputClasses.getPickersOutlinedInputUtilityClass;
}
});
Object.defineProperty(exports, "pickersOutlinedInputClasses", {
enumerable: true,
get: function () {
return _pickersOutlinedInputClasses.pickersOutlinedInputClasses;
}
});
var _PickersOutlinedInput = require("./PickersOutlinedInput");
var _pickersOutlinedInputClasses = require("./pickersOutlinedInputClasses");

24
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/pickersOutlinedInputClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,24 @@
import { PickersInputBaseClasses } from "../PickersInputBase/index.js";
export interface PickersOutlinedInputClasses extends PickersInputBaseClasses {
/** Styles applied to the NotchedOutline element. */
notchedOutline: string;
}
export type PickersOutlinedInputClassKey = keyof PickersOutlinedInputClasses;
export declare function getPickersOutlinedInputUtilityClass(slot: string): string;
export declare const pickersOutlinedInputClasses: {
root: string;
input: string;
notchedOutline: string;
sectionContent: string;
disabled: string;
readOnly: string;
focused: string;
error: string;
inputSizeSmall: string;
sectionsContainer: string;
sectionBefore: string;
sectionAfter: string;
adornedStart: string;
adornedEnd: string;
activeBar: string;
};

16
node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/pickersOutlinedInputClasses.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getPickersOutlinedInputUtilityClass = getPickersOutlinedInputUtilityClass;
exports.pickersOutlinedInputClasses = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _PickersInputBase = require("../PickersInputBase");
function getPickersOutlinedInputUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersOutlinedInput', slot);
}
const pickersOutlinedInputClasses = exports.pickersOutlinedInputClasses = (0, _extends2.default)({}, _PickersInputBase.pickersInputBaseClasses, (0, _generateUtilityClasses.default)('MuiPickersOutlinedInput', ['root', 'notchedOutline', 'input']));

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

@ -0,0 +1,3 @@
import * as React from 'react';
declare const PickersTextField: React.ForwardRefExoticComponent<(Omit<import("./PickersTextField.types.js").PickersStandardTextFieldProps, "ref"> | Omit<import("./PickersTextField.types.js").PickersOutlinedTextFieldProps, "ref"> | Omit<import("./PickersTextField.types.js").PickersFilledTextFieldProps, "ref">) & React.RefAttributes<HTMLDivElement>>;
export { PickersTextField };

302
node_modules/@mui/x-date-pickers/PickersTextField/PickersTextField.js generated vendored Normal file
View file

@ -0,0 +1,302 @@
"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.PickersTextField = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var React = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _clsx = _interopRequireDefault(require("clsx"));
var _styles = require("@mui/material/styles");
var _refType = _interopRequireDefault(require("@mui/utils/refType"));
var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
var _useId = _interopRequireDefault(require("@mui/utils/useId"));
var _InputLabel = _interopRequireDefault(require("@mui/material/InputLabel"));
var _FormHelperText = _interopRequireDefault(require("@mui/material/FormHelperText"));
var _FormControl = _interopRequireDefault(require("@mui/material/FormControl"));
var _pickersTextFieldClasses = require("./pickersTextFieldClasses");
var _PickersOutlinedInput = require("./PickersOutlinedInput");
var _PickersFilledInput = require("./PickersFilledInput");
var _PickersInput = require("./PickersInput");
var _useFieldOwnerState = require("../internals/hooks/useFieldOwnerState");
var _usePickerTextFieldOwnerState = require("./usePickerTextFieldOwnerState");
var _jsxRuntime = require("react/jsx-runtime");
const _excluded = ["onFocus", "onBlur", "className", "classes", "color", "disabled", "error", "variant", "required", "hiddenLabel", "InputProps", "inputProps", "inputRef", "sectionListRef", "elements", "areAllSectionsEmpty", "onClick", "onKeyDown", "onKeyUp", "onPaste", "onInput", "endAdornment", "startAdornment", "tabIndex", "contentEditable", "focused", "value", "onChange", "fullWidth", "id", "name", "helperText", "FormHelperTextProps", "label", "InputLabelProps", "data-active-range-position"];
const VARIANT_COMPONENT = {
standard: _PickersInput.PickersInput,
filled: _PickersFilledInput.PickersFilledInput,
outlined: _PickersOutlinedInput.PickersOutlinedInput
};
const PickersTextFieldRoot = (0, _styles.styled)(_FormControl.default, {
name: 'MuiPickersTextField',
slot: 'Root'
})({
maxWidth: '100%'
});
const useUtilityClasses = (classes, ownerState) => {
const {
isFieldFocused,
isFieldDisabled,
isFieldRequired
} = ownerState;
const slots = {
root: ['root', isFieldFocused && !isFieldDisabled && 'focused', isFieldDisabled && 'disabled', isFieldRequired && 'required']
};
return (0, _composeClasses.default)(slots, _pickersTextFieldClasses.getPickersTextFieldUtilityClass, classes);
};
const PickersTextField = exports.PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTextField(inProps, ref) {
const props = (0, _styles.useThemeProps)({
props: inProps,
name: 'MuiPickersTextField'
});
const {
// Props used by FormControl
onFocus,
onBlur,
className,
classes: classesProp,
color = 'primary',
disabled = false,
error = false,
variant = 'outlined',
required = false,
hiddenLabel = false,
// Props used by PickersInput
InputProps,
inputProps,
inputRef,
sectionListRef,
elements,
areAllSectionsEmpty,
onClick,
onKeyDown,
onKeyUp,
onPaste,
onInput,
endAdornment,
startAdornment,
tabIndex,
contentEditable,
focused,
value,
onChange,
fullWidth,
id: idProp,
name,
// Props used by FormHelperText
helperText,
FormHelperTextProps,
// Props used by InputLabel
label,
InputLabelProps,
// @ts-ignore
'data-active-range-position': dataActiveRangePosition
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
const rootRef = React.useRef(null);
const handleRootRef = (0, _useForkRef.default)(ref, rootRef);
const id = (0, _useId.default)(idProp);
const helperTextId = helperText && id ? `${id}-helper-text` : undefined;
const inputLabelId = label && id ? `${id}-label` : undefined;
const fieldOwnerState = (0, _useFieldOwnerState.useFieldOwnerState)({
disabled: props.disabled,
required: props.required,
readOnly: InputProps?.readOnly
});
const ownerState = React.useMemo(() => (0, _extends2.default)({}, fieldOwnerState, {
isFieldValueEmpty: areAllSectionsEmpty,
isFieldFocused: focused ?? false,
hasFieldError: error ?? false,
inputSize: props.size ?? 'medium',
inputColor: color ?? 'primary',
isInputInFullWidth: fullWidth ?? false,
hasStartAdornment: Boolean(startAdornment ?? InputProps?.startAdornment),
hasEndAdornment: Boolean(endAdornment ?? InputProps?.endAdornment),
inputHasLabel: !!label,
isLabelShrunk: Boolean(InputLabelProps?.shrink)
}), [fieldOwnerState, areAllSectionsEmpty, focused, error, props.size, color, fullWidth, startAdornment, endAdornment, InputProps?.startAdornment, InputProps?.endAdornment, label, InputLabelProps?.shrink]);
const classes = useUtilityClasses(classesProp, ownerState);
const PickersInputComponent = VARIANT_COMPONENT[variant];
const inputAdditionalProps = {};
if (variant === 'outlined') {
if (InputLabelProps && typeof InputLabelProps.shrink !== 'undefined') {
inputAdditionalProps.notched = InputLabelProps.shrink;
}
inputAdditionalProps.label = label;
} else if (variant === 'filled') {
inputAdditionalProps.hiddenLabel = hiddenLabel;
}
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_usePickerTextFieldOwnerState.PickerTextFieldOwnerStateContext.Provider, {
value: ownerState,
children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(PickersTextFieldRoot, (0, _extends2.default)({
className: (0, _clsx.default)(classes.root, className),
ref: handleRootRef,
focused: focused,
disabled: disabled,
variant: variant,
error: error,
color: color,
fullWidth: fullWidth,
required: required,
ownerState: ownerState
}, other, {
children: [label != null && label !== '' && /*#__PURE__*/(0, _jsxRuntime.jsx)(_InputLabel.default, (0, _extends2.default)({
htmlFor: id,
id: inputLabelId
}, InputLabelProps, {
children: label
})), /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersInputComponent, (0, _extends2.default)({
elements: elements,
areAllSectionsEmpty: areAllSectionsEmpty,
onClick: onClick,
onKeyDown: onKeyDown,
onKeyUp: onKeyUp,
onInput: onInput,
onPaste: onPaste,
onFocus: onFocus,
onBlur: onBlur,
endAdornment: endAdornment,
startAdornment: startAdornment,
tabIndex: tabIndex,
contentEditable: contentEditable,
value: value,
onChange: onChange,
id: id,
fullWidth: fullWidth,
inputProps: inputProps,
inputRef: inputRef,
sectionListRef: sectionListRef,
label: label,
name: name,
role: "group",
"aria-labelledby": inputLabelId,
"aria-describedby": helperTextId,
"aria-live": helperTextId ? 'polite' : undefined,
"data-active-range-position": dataActiveRangePosition
}, inputAdditionalProps, InputProps)), helperText && /*#__PURE__*/(0, _jsxRuntime.jsx)(_FormHelperText.default, (0, _extends2.default)({
id: helperTextId
}, FormHelperTextProps, {
children: helperText
}))]
}))
});
});
if (process.env.NODE_ENV !== "production") PickersTextField.displayName = "PickersTextField";
process.env.NODE_ENV !== "production" ? PickersTextField.propTypes = {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the TypeScript types and run "pnpm proptypes" |
// ----------------------------------------------------------------------
/**
* Is `true` if the current values equals the empty value.
* For a single item value, it means that `value === null`
* For a range value, it means that `value === [null, null]`
*/
areAllSectionsEmpty: _propTypes.default.bool.isRequired,
className: _propTypes.default.string,
/**
* The color of the component.
* It supports both default and custom theme colors, which can be added as shown in the
* [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
* @default 'primary'
*/
color: _propTypes.default.oneOf(['error', 'info', 'primary', 'secondary', 'success', 'warning']),
component: _propTypes.default.elementType,
/**
* If true, the whole element is editable.
* Useful when all the sections are selected.
*/
contentEditable: _propTypes.default.bool.isRequired,
disabled: _propTypes.default.bool.isRequired,
/**
* The elements to render.
* Each element contains the prop to edit a section of the value.
*/
elements: _propTypes.default.arrayOf(_propTypes.default.shape({
after: _propTypes.default.object.isRequired,
before: _propTypes.default.object.isRequired,
container: _propTypes.default.object.isRequired,
content: _propTypes.default.object.isRequired
})).isRequired,
endAdornment: _propTypes.default.node,
error: _propTypes.default.bool.isRequired,
/**
* If `true`, the component is displayed in focused state.
*/
focused: _propTypes.default.bool,
FormHelperTextProps: _propTypes.default.object,
fullWidth: _propTypes.default.bool,
/**
* The helper text content.
*/
helperText: _propTypes.default.node,
/**
* If `true`, the label is hidden.
* This is used to increase density for a `FilledInput`.
* Be sure to add `aria-label` to the `input` element.
* @default false
*/
hiddenLabel: _propTypes.default.bool,
id: _propTypes.default.string,
InputLabelProps: _propTypes.default.object,
inputProps: _propTypes.default.object,
/**
* Props applied to the Input element.
* It will be a [`FilledInput`](/material-ui/api/filled-input/),
* [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
* component depending on the `variant` prop value.
*/
InputProps: _propTypes.default.object,
inputRef: _refType.default,
label: _propTypes.default.node,
/**
* If `dense` or `normal`, will adjust vertical spacing of this and contained components.
* @default 'none'
*/
margin: _propTypes.default.oneOf(['dense', 'none', 'normal']),
name: _propTypes.default.string,
onBlur: _propTypes.default.func.isRequired,
onChange: _propTypes.default.func.isRequired,
onClick: _propTypes.default.func.isRequired,
onFocus: _propTypes.default.func.isRequired,
onInput: _propTypes.default.func.isRequired,
onKeyDown: _propTypes.default.func.isRequired,
onPaste: _propTypes.default.func.isRequired,
readOnly: _propTypes.default.bool,
/**
* If `true`, the label will indicate that the `input` is required.
* @default false
*/
required: _propTypes.default.bool,
sectionListRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
current: _propTypes.default.shape({
getRoot: _propTypes.default.func.isRequired,
getSectionContainer: _propTypes.default.func.isRequired,
getSectionContent: _propTypes.default.func.isRequired,
getSectionIndexFromDOMElement: _propTypes.default.func.isRequired
})
})]),
/**
* The size of the component.
* @default 'medium'
*/
size: _propTypes.default.oneOf(['medium', 'small']),
startAdornment: _propTypes.default.node,
style: _propTypes.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
value: _propTypes.default.string.isRequired,
/**
* The variant to use.
* @default 'outlined'
*/
variant: _propTypes.default.oneOf(['filled', 'outlined', 'standard'])
} : void 0;

67
node_modules/@mui/x-date-pickers/PickersTextField/PickersTextField.types.d.ts generated vendored Normal file
View file

@ -0,0 +1,67 @@
import * as React from 'react';
import { FormControlProps } from '@mui/material/FormControl';
import { FormHelperTextProps } from '@mui/material/FormHelperText';
import { InputLabelProps } from '@mui/material/InputLabel';
import { TextFieldVariants } from '@mui/material/TextField';
import { PickersInputPropsUsedByField } from "./PickersInputBase/PickersInputBase.types.js";
import type { PickersInputProps } from "./PickersInput/index.js";
import type { PickersOutlinedInputProps } from "./PickersOutlinedInput/index.js";
import type { PickersFilledInputProps } from "./PickersFilledInput/index.js";
interface PickersTextFieldPropsUsedByField {
onFocus: React.FocusEventHandler<HTMLDivElement>;
onBlur: React.FocusEventHandler<HTMLDivElement>;
disabled: boolean;
error: boolean;
}
export interface PickersBaseTextFieldProps extends PickersInputPropsUsedByField, PickersTextFieldPropsUsedByField, Omit<FormControlProps, keyof PickersInputPropsUsedByField | keyof PickersTextFieldPropsUsedByField> {
FormHelperTextProps?: Partial<FormHelperTextProps>;
InputLabelProps?: Partial<InputLabelProps>;
/**
* The helper text content.
*/
helperText?: React.ReactNode;
}
export interface PickersStandardTextFieldProps extends PickersBaseTextFieldProps {
/**
* The variant to use.
* @default 'outlined'
*/
variant?: 'standard';
/**
* Props applied to the Input element.
* It will be a [`FilledInput`](/material-ui/api/filled-input/),
* [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
* component depending on the `variant` prop value.
*/
InputProps?: Partial<PickersInputProps>;
}
export interface PickersOutlinedTextFieldProps extends PickersBaseTextFieldProps {
/**
* The variant to use.
* @default 'outlined'
*/
variant?: 'outlined';
/**
* Props applied to the Input element.
* It will be a [`FilledInput`](/material-ui/api/filled-input/),
* [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
* component depending on the `variant` prop value.
*/
InputProps?: Partial<PickersOutlinedInputProps>;
}
export interface PickersFilledTextFieldProps extends PickersBaseTextFieldProps {
/**
* The variant to use.
* @default 'outlined'
*/
variant?: 'filled';
/**
* Props applied to the Input element.
* It will be a [`FilledInput`](/material-ui/api/filled-input/),
* [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
* component depending on the `variant` prop value.
*/
InputProps?: Partial<PickersFilledInputProps>;
}
export type PickersTextFieldProps<Variant extends TextFieldVariants = TextFieldVariants> = Variant extends 'filled' ? PickersFilledTextFieldProps : Variant extends 'standard' ? PickersStandardTextFieldProps : PickersOutlinedTextFieldProps;
export {};

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

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

8
node_modules/@mui/x-date-pickers/PickersTextField/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,8 @@
export { PickersTextField } from "./PickersTextField.js";
export type { PickersTextFieldProps } from "./PickersTextField.types.js";
export { pickersTextFieldClasses, getPickersTextFieldUtilityClass } from "./pickersTextFieldClasses.js";
export type { PickersTextFieldClasses, PickersTextFieldClassKey } from "./pickersTextFieldClasses.js";
export * from "./PickersInput/index.js";
export * from "./PickersFilledInput/index.js";
export * from "./PickersOutlinedInput/index.js";
export * from "./PickersInputBase/index.js";

78
node_modules/@mui/x-date-pickers/PickersTextField/index.js generated vendored Normal file
View file

@ -0,0 +1,78 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _exportNames = {
PickersTextField: true,
pickersTextFieldClasses: true,
getPickersTextFieldUtilityClass: true
};
Object.defineProperty(exports, "PickersTextField", {
enumerable: true,
get: function () {
return _PickersTextField.PickersTextField;
}
});
Object.defineProperty(exports, "getPickersTextFieldUtilityClass", {
enumerable: true,
get: function () {
return _pickersTextFieldClasses.getPickersTextFieldUtilityClass;
}
});
Object.defineProperty(exports, "pickersTextFieldClasses", {
enumerable: true,
get: function () {
return _pickersTextFieldClasses.pickersTextFieldClasses;
}
});
var _PickersTextField = require("./PickersTextField");
var _pickersTextFieldClasses = require("./pickersTextFieldClasses");
var _PickersInput = require("./PickersInput");
Object.keys(_PickersInput).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _PickersInput[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _PickersInput[key];
}
});
});
var _PickersFilledInput = require("./PickersFilledInput");
Object.keys(_PickersFilledInput).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _PickersFilledInput[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _PickersFilledInput[key];
}
});
});
var _PickersOutlinedInput = require("./PickersOutlinedInput");
Object.keys(_PickersOutlinedInput).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _PickersOutlinedInput[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _PickersOutlinedInput[key];
}
});
});
var _PickersInputBase = require("./PickersInputBase");
Object.keys(_PickersInputBase).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _PickersInputBase[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _PickersInputBase[key];
}
});
});

15
node_modules/@mui/x-date-pickers/PickersTextField/pickersTextFieldClasses.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
export interface PickersTextFieldClasses {
/** Styles applied to the root element. */
root: string;
/** Styles applied to the root element if focused. */
focused: string;
/** State class applied to the root element if `disabled=true`. */
disabled: string;
/** State class applied to the root element if `error=true`. */
error: string;
/** State class applied to the root element id `required=true` */
required: string;
}
export type PickersTextFieldClassKey = keyof PickersTextFieldClasses;
export declare function getPickersTextFieldUtilityClass(slot: string): string;
export declare const pickersTextFieldClasses: Record<keyof PickersTextFieldClasses, string>;

14
node_modules/@mui/x-date-pickers/PickersTextField/pickersTextFieldClasses.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.getPickersTextFieldUtilityClass = getPickersTextFieldUtilityClass;
exports.pickersTextFieldClasses = void 0;
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
function getPickersTextFieldUtilityClass(slot) {
return (0, _generateUtilityClass.default)('MuiPickersTextField', slot);
}
const pickersTextFieldClasses = exports.pickersTextFieldClasses = (0, _generateUtilityClasses.default)('MuiPickersTextField', ['root', 'focused', 'disabled', 'error', 'required']);

4
node_modules/@mui/x-date-pickers/PickersTextField/usePickerTextFieldOwnerState.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
import * as React from 'react';
import { PickerTextFieldOwnerState } from "../models/fields.js";
export declare const PickerTextFieldOwnerStateContext: React.Context<PickerTextFieldOwnerState | null>;
export declare const usePickerTextFieldOwnerState: () => PickerTextFieldOwnerState;

19
node_modules/@mui/x-date-pickers/PickersTextField/usePickerTextFieldOwnerState.js generated vendored Normal file
View file

@ -0,0 +1,19 @@
"use strict";
'use client';
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.usePickerTextFieldOwnerState = exports.PickerTextFieldOwnerStateContext = void 0;
var React = _interopRequireWildcard(require("react"));
const PickerTextFieldOwnerStateContext = exports.PickerTextFieldOwnerStateContext = /*#__PURE__*/React.createContext(null);
if (process.env.NODE_ENV !== "production") PickerTextFieldOwnerStateContext.displayName = "PickerTextFieldOwnerStateContext";
const usePickerTextFieldOwnerState = () => {
const value = React.useContext(PickerTextFieldOwnerStateContext);
if (value == null) {
throw new Error(['MUI X: The `usePickerTextFieldOwnerState` can only be called in components that are used inside a PickerTextField component'].join('\n'));
}
return value;
};
exports.usePickerTextFieldOwnerState = usePickerTextFieldOwnerState;