Added Statistics calculation

Statistics now show calculated values

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/Outline.d.ts

@@ -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 {};

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/Outline.js

@@ -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"
+      })
+    })
+  }));
+}

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/PickersOutlinedInput.d.ts

@@ -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 };

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/PickersOutlinedInput.js

@@ -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';

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/index.d.ts

@@ -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";

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/index.js

@@ -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");

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/pickersOutlinedInputClasses.d.ts

@@ -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;
+};

node_modules/@mui/x-date-pickers/PickersTextField/PickersOutlinedInput/pickersOutlinedInputClasses.js

@@ -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']));