@mui/x-date-pickers 5.0.0-alpha.0

package/node/internals/components/PickersPopper.js

@@ -0,0 +1,287 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickersPopper = void 0;
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Grow = _interopRequireDefault(require("@mui/material/Grow"));
+
+var _Paper = _interopRequireDefault(require("@mui/material/Paper"));
+
+var _Popper = _interopRequireDefault(require("@mui/material/Popper"));
+
+var _Unstable_TrapFocus = _interopRequireDefault(require("@mui/material/Unstable_TrapFocus"));
+
+var _utils = require("@mui/material/utils");
+
+var _styles = require("@mui/material/styles");
+
+var _Button = _interopRequireDefault(require("@mui/material/Button"));
+
+var _DialogActions = _interopRequireDefault(require("@mui/material/DialogActions"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["onClick", "onTouchStart"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const PickersPopperRoot = (0, _styles.styled)(_Popper.default)(({
+  theme
+}) => ({
+  zIndex: theme.zIndex.modal
+}));
+const PickersPopperPaper = (0, _styles.styled)(_Paper.default)(({
+  ownerState
+}) => (0, _extends2.default)({
+  transformOrigin: 'top center',
+  outline: 0
+}, ownerState.placement === 'top' && {
+  transformOrigin: 'bottom center'
+}));
+const PickersPopperAction = (0, _styles.styled)(_DialogActions.default)(({
+  ownerState
+}) => (0, _extends2.default)({}, ownerState.clearable ? {
+  justifyContent: 'flex-start',
+  '& > *:first-of-type': {
+    marginRight: 'auto'
+  }
+} : {
+  padding: 0
+}));
+
+function clickedRootScrollbar(event, doc) {
+  return doc.documentElement.clientWidth < event.clientX || doc.documentElement.clientHeight < event.clientY;
+}
+
+/**
+ * Based on @mui/material/ClickAwayListener without the customization.
+ * We can probably strip away even more since children won't be portaled.
+ * @param {boolean} active Only listen to clicks when the popper is opened.
+ * @param {(event: MouseEvent | TouchEvent) => void} onClickAway The callback to call when clicking outside the popper.
+ * @returns {Array} The ref and event handler to listen to the outside clicks.
+ */
+function useClickAwayListener(active, onClickAway) {
+  const movedRef = React.useRef(false);
+  const syntheticEventRef = React.useRef(false);
+  const nodeRef = React.useRef(null);
+  const activatedRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!active) {
+      return undefined;
+    } // Ensure that this hook is not "activated" synchronously.
+    // https://github.com/facebook/react/issues/20074
+
+
+    function armClickAwayListener() {
+      activatedRef.current = true;
+    }
+
+    document.addEventListener('mousedown', armClickAwayListener, true);
+    document.addEventListener('touchstart', armClickAwayListener, true);
+    return () => {
+      document.removeEventListener('mousedown', armClickAwayListener, true);
+      document.removeEventListener('touchstart', armClickAwayListener, true);
+      activatedRef.current = false;
+    };
+  }, [active]); // The handler doesn't take event.defaultPrevented into account:
+  //
+  // event.preventDefault() is meant to stop default behaviors like
+  // clicking a checkbox to check it, hitting a button to submit a form,
+  // and hitting left arrow to move the cursor in a text input etc.
+  // Only special HTML elements have these default behaviors.
+
+  const handleClickAway = (0, _utils.useEventCallback)(event => {
+    if (!activatedRef.current) {
+      return;
+    } // Given developers can stop the propagation of the synthetic event,
+    // we can only be confident with a positive value.
+
+
+    const insideReactTree = syntheticEventRef.current;
+    syntheticEventRef.current = false;
+    const doc = (0, _utils.ownerDocument)(nodeRef.current); // 1. IE11 support, which trigger the handleClickAway even after the unbind
+    // 2. The child might render null.
+    // 3. Behave like a blur listener.
+
+    if (!nodeRef.current || // is a TouchEvent?
+    'clientX' in event && clickedRootScrollbar(event, doc)) {
+      return;
+    } // Do not act if user performed touchmove
+
+
+    if (movedRef.current) {
+      movedRef.current = false;
+      return;
+    }
+
+    let insideDOM; // If not enough, can use https://github.com/DieterHolvoet/event-propagation-path/blob/master/propagationPath.js
+
+    if (event.composedPath) {
+      insideDOM = event.composedPath().indexOf(nodeRef.current) > -1;
+    } else {
+      insideDOM = !doc.documentElement.contains(event.target) || nodeRef.current.contains(event.target);
+    }
+
+    if (!insideDOM && !insideReactTree) {
+      onClickAway(event);
+    }
+  }); // Keep track of mouse/touch events that bubbled up through the portal.
+
+  const handleSynthetic = () => {
+    syntheticEventRef.current = true;
+  };
+
+  React.useEffect(() => {
+    if (active) {
+      const doc = (0, _utils.ownerDocument)(nodeRef.current);
+
+      const handleTouchMove = () => {
+        movedRef.current = true;
+      };
+
+      doc.addEventListener('touchstart', handleClickAway);
+      doc.addEventListener('touchmove', handleTouchMove);
+      return () => {
+        doc.removeEventListener('touchstart', handleClickAway);
+        doc.removeEventListener('touchmove', handleTouchMove);
+      };
+    }
+
+    return undefined;
+  }, [active, handleClickAway]);
+  React.useEffect(() => {
+    // TODO This behavior is not tested automatically
+    // It's unclear whether this is due to different update semantics in test (batched in act() vs discrete on click).
+    // Or if this is a timing related issues due to different Transition components
+    // Once we get rid of all the manual scheduling (e.g. setTimeout(update, 0)) we can revisit this code+test.
+    if (active) {
+      const doc = (0, _utils.ownerDocument)(nodeRef.current);
+      doc.addEventListener('click', handleClickAway);
+      return () => {
+        doc.removeEventListener('click', handleClickAway); // cleanup `handleClickAway`
+
+        syntheticEventRef.current = false;
+      };
+    }
+
+    return undefined;
+  }, [active, handleClickAway]);
+  return [nodeRef, handleSynthetic, handleSynthetic];
+}
+
+const PickersPopper = props => {
+  const {
+    anchorEl,
+    children,
+    containerRef = null,
+    onClose,
+    onClear,
+    clearable = false,
+    clearText = 'Clear',
+    open,
+    PopperProps,
+    role,
+    TransitionComponent = _Grow.default,
+    TrapFocusProps,
+    PaperProps = {}
+  } = props;
+  React.useEffect(() => {
+    function handleKeyDown(nativeEvent) {
+      // IE11, Edge (prior to using Bink?) use 'Esc'
+      if (nativeEvent.key === 'Escape' || nativeEvent.key === 'Esc') {
+        onClose();
+      }
+    }
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [onClose]);
+  const lastFocusedElementRef = React.useRef(null);
+  React.useEffect(() => {
+    if (role === 'tooltip') {
+      return;
+    }
+
+    if (open) {
+      lastFocusedElementRef.current = document.activeElement;
+    } else if (lastFocusedElementRef.current && lastFocusedElementRef.current instanceof HTMLElement) {
+      lastFocusedElementRef.current.focus();
+    }
+  }, [open, role]);
+  const [clickAwayRef, onPaperClick, onPaperTouchStart] = useClickAwayListener(open, onClose);
+  const paperRef = React.useRef(null);
+  const handleRef = (0, _utils.useForkRef)(paperRef, containerRef);
+  const handlePaperRef = (0, _utils.useForkRef)(handleRef, clickAwayRef);
+  const ownerState = props;
+  const {
+    onClick: onPaperClickProp,
+    onTouchStart: onPaperTouchStartProp
+  } = PaperProps,
+        otherPaperProps = (0, _objectWithoutPropertiesLoose2.default)(PaperProps, _excluded);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersPopperRoot, (0, _extends2.default)({
+    transition: true,
+    role: role,
+    open: open,
+    anchorEl: anchorEl,
+    ownerState: ownerState
+  }, PopperProps, {
+    children: ({
+      TransitionProps,
+      placement
+    }) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_Unstable_TrapFocus.default, (0, _extends2.default)({
+      open: open,
+      disableAutoFocus: true,
+      disableEnforceFocus: role === 'tooltip',
+      isEnabled: () => true
+    }, TrapFocusProps, {
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(TransitionComponent, (0, _extends2.default)({}, TransitionProps, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(PickersPopperPaper, (0, _extends2.default)({
+          tabIndex: -1,
+          elevation: 8,
+          ref: handlePaperRef,
+          onClick: event => {
+            onPaperClick(event);
+
+            if (onPaperClickProp) {
+              onPaperClickProp(event);
+            }
+          },
+          onTouchStart: event => {
+            onPaperTouchStart(event);
+
+            if (onPaperTouchStartProp) {
+              onPaperTouchStartProp(event);
+            }
+          },
+          ownerState: (0, _extends2.default)({}, ownerState, {
+            placement
+          })
+        }, otherPaperProps, {
+          children: [children, /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersPopperAction, {
+            ownerState: ownerState,
+            children: clearable && /*#__PURE__*/(0, _jsxRuntime.jsx)(_Button.default, {
+              onClick: onClear,
+              children: clearText
+            })
+          })]
+        }))
+      }))
+    }))
+  }));
+};
+
+exports.PickersPopper = PickersPopper;

package/node/internals/components/PickersToolbar.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickersToolbar = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _clsx = _interopRequireDefault(require("clsx"));
+
+var _Grid = _interopRequireDefault(require("@mui/material/Grid"));
+
+var _Typography = _interopRequireDefault(require("@mui/material/Typography"));
+
+var _IconButton = _interopRequireDefault(require("@mui/material/IconButton"));
+
+var _styles = require("@mui/material/styles");
+
+var _material = require("@mui/material");
+
+var _icons = require("./icons");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const classes = (0, _material.generateUtilityClasses)('PrivatePickersToolbar', ['root', 'dateTitleContainer']);
+const PickersToolbarRoot = (0, _styles.styled)('div')(({
+  theme,
+  ownerState
+}) => (0, _extends2.default)({
+  display: 'flex',
+  flexDirection: 'column',
+  alignItems: 'flex-start',
+  justifyContent: 'space-between',
+  padding: theme.spacing(2, 3)
+}, ownerState.isLandscape && {
+  height: 'auto',
+  maxWidth: 160,
+  padding: 16,
+  justifyContent: 'flex-start',
+  flexWrap: 'wrap'
+}));
+const PickersToolbarGrid = (0, _styles.styled)(_Grid.default)({
+  flex: 1
+});
+
+const getViewTypeIcon = viewType => viewType === 'clock' ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_icons.Clock, {
+  color: "inherit"
+}) : /*#__PURE__*/(0, _jsxRuntime.jsx)(_icons.Calendar, {
+  color: "inherit"
+});
+
+function defaultGetKeyboardInputSwitchingButtonText(isKeyboardInputOpen, viewType) {
+  return isKeyboardInputOpen ? `text input view is open, go to ${viewType} view` : `${viewType} view is open, go to text input view`;
+}
+
+const PickersToolbar = /*#__PURE__*/React.forwardRef(function PickersToolbar(props, ref) {
+  const {
+    children,
+    className,
+    getMobileKeyboardInputViewButtonText = defaultGetKeyboardInputSwitchingButtonText,
+    isLandscape,
+    isMobileKeyboardViewOpen,
+    landscapeDirection = 'column',
+    penIconClassName,
+    toggleMobileKeyboardView,
+    toolbarTitle,
+    viewType = 'calendar'
+  } = props;
+  const ownerState = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(PickersToolbarRoot, {
+    ref: ref,
+    className: (0, _clsx.default)(classes.root, className),
+    ownerState: ownerState,
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Typography.default, {
+      color: "text.secondary",
+      variant: "overline",
+      children: toolbarTitle
+    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(PickersToolbarGrid, {
+      container: true,
+      justifyContent: "space-between",
+      className: classes.dateTitleContainer,
+      direction: isLandscape ? landscapeDirection : 'row',
+      alignItems: isLandscape ? 'flex-start' : 'flex-end',
+      children: [children, /*#__PURE__*/(0, _jsxRuntime.jsx)(_IconButton.default, {
+        onClick: toggleMobileKeyboardView,
+        className: penIconClassName,
+        color: "inherit",
+        "aria-label": getMobileKeyboardInputViewButtonText(isMobileKeyboardViewOpen, viewType),
+        children: isMobileKeyboardViewOpen ? getViewTypeIcon(viewType) : /*#__PURE__*/(0, _jsxRuntime.jsx)(_icons.Pen, {
+          color: "inherit"
+        })
+      })]
+    })]
+  });
+});
+exports.PickersToolbar = PickersToolbar;

package/node/internals/components/PickersToolbarButton.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickersToolbarButton = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Button = _interopRequireDefault(require("@mui/material/Button"));
+
+var _styles = require("@mui/material/styles");
+
+var _PickersToolbarText = require("./PickersToolbarText");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["align", "className", "selected", "typographyClassName", "value", "variant"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const PickersToolbarButtonRoot = (0, _styles.styled)(_Button.default)({
+  padding: 0,
+  minWidth: 16,
+  textTransform: 'none'
+});
+const PickersToolbarButton = /*#__PURE__*/React.forwardRef(function PickersToolbarButton(props, ref) {
+  const {
+    align,
+    className,
+    selected,
+    typographyClassName,
+    value,
+    variant
+  } = props,
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersToolbarButtonRoot, (0, _extends2.default)({
+    variant: "text",
+    ref: ref,
+    className: className
+  }, other, {
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickersToolbarText.PickersToolbarText, {
+      align: align,
+      className: typographyClassName,
+      variant: variant,
+      value: value,
+      selected: selected
+    })
+  }));
+});
+exports.PickersToolbarButton = PickersToolbarButton;

package/node/internals/components/PickersToolbarText.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickersToolbarText = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _clsx = _interopRequireDefault(require("clsx"));
+
+var _Typography = _interopRequireDefault(require("@mui/material/Typography"));
+
+var _styles = require("@mui/material/styles");
+
+var _material = require("@mui/material");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["className", "selected", "value"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const classes = (0, _material.generateUtilityClasses)('PrivatePickersToolbarText', ['selected']);
+const PickersToolbarTextRoot = (0, _styles.styled)(_Typography.default)(({
+  theme
+}) => ({
+  transition: theme.transitions.create('color'),
+  color: theme.palette.text.secondary,
+  [`&.${classes.selected}`]: {
+    color: theme.palette.text.primary
+  }
+}));
+const PickersToolbarText = /*#__PURE__*/React.forwardRef(function PickersToolbarText(props, ref) {
+  const {
+    className,
+    selected,
+    value
+  } = props,
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersToolbarTextRoot, (0, _extends2.default)({
+    ref: ref,
+    className: (0, _clsx.default)(className, selected && classes.selected),
+    component: "span"
+  }, other, {
+    children: value
+  }));
+});
+exports.PickersToolbarText = PickersToolbarText;

package/node/internals/components/PureDateInput.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PureDateInput = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _utils = require("../utils/utils");
+
+var _useUtils = require("../hooks/useUtils");
+
+var _textFieldHelper = require("../utils/text-field-helper");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+// TODO: why is this called "Pure*" when it's not memoized? Does "Pure" mean "readonly"?
+const PureDateInput = /*#__PURE__*/React.forwardRef(function PureDateInput(props, ref) {
+  const {
+    disabled,
+    getOpenDialogAriaText = _textFieldHelper.getTextFieldAriaText,
+    inputFormat,
+    InputProps,
+    inputRef,
+    label,
+    openPicker: onOpen,
+    rawValue,
+    renderInput,
+    TextFieldProps = {},
+    validationError
+  } = props;
+  const utils = (0, _useUtils.useUtils)();
+  const PureDateInputProps = React.useMemo(() => (0, _extends2.default)({}, InputProps, {
+    readOnly: true
+  }), [InputProps]);
+  const inputValue = (0, _textFieldHelper.getDisplayDate)(utils, rawValue, inputFormat);
+  return renderInput((0, _extends2.default)({
+    label,
+    disabled,
+    ref,
+    inputRef,
+    error: validationError,
+    InputProps: PureDateInputProps,
+    inputProps: (0, _extends2.default)({
+      disabled,
+      readOnly: true,
+      'aria-readonly': true,
+      'aria-label': getOpenDialogAriaText(rawValue, utils),
+      value: inputValue
+    }, !props.readOnly && {
+      onClick: onOpen
+    }, {
+      onKeyDown: (0, _utils.onSpaceOrEnter)(onOpen)
+    })
+  }, TextFieldProps));
+});
+exports.PureDateInput = PureDateInput;
+PureDateInput.propTypes = {
+  getOpenDialogAriaText: _propTypes.default.func,
+  renderInput: _propTypes.default.func.isRequired
+};

package/node/internals/components/icons/index.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Time = exports.Pen = exports.DateRange = exports.Clock = exports.Calendar = exports.ArrowRight = exports.ArrowLeft = exports.ArrowDropDown = void 0;
+
+var _utils = require("@mui/material/utils");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * @ignore - internal component.
+ */
+const ArrowDropDown = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+  d: "M7 10l5 5 5-5z"
+}), 'ArrowDropDown');
+/**
+ * @ignore - internal component.
+ */
+
+exports.ArrowDropDown = ArrowDropDown;
+const ArrowLeft = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+  d: "M15.41 16.59L10.83 12l4.58-4.59L14 6l-6 6 6 6 1.41-1.41z"
+}), 'ArrowLeft');
+/**
+ * @ignore - internal component.
+ */
+
+exports.ArrowLeft = ArrowLeft;
+const ArrowRight = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+  d: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z"
+}), 'ArrowRight');
+/**
+ * @ignore - internal component.
+ */
+
+exports.ArrowRight = ArrowRight;
+const Calendar = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+  d: "M17 12h-5v5h5v-5zM16 1v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2h-1V1h-2zm3 18H5V8h14v11z"
+}), 'Calendar');
+/**
+ * @ignore - internal component.
+ */
+
+exports.Calendar = Calendar;
+const Clock = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
+  children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+    d: "M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
+  }), /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+    d: "M12.5 7H11v6l5.25 3.15.75-1.23-4.5-2.67z"
+  })]
+}), 'Clock');
+/**
+ * @ignore - internal component.
+ */
+
+exports.Clock = Clock;
+const DateRange = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+  d: "M9 11H7v2h2v-2zm4 0h-2v2h2v-2zm4 0h-2v2h2v-2zm2-7h-1V2h-2v2H8V2H6v2H5c-1.11 0-1.99.9-1.99 2L3 20c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H5V9h14v11z"
+}), 'DateRange');
+/**
+ * @ignore - internal component.
+ */
+
+exports.DateRange = DateRange;
+const Pen = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+  d: "M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34a.9959.9959 0 00-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"
+}), 'Pen');
+/**
+ * @ignore - internal component.
+ */
+
+exports.Pen = Pen;
+const Time = (0, _utils.createSvgIcon)( /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
+  children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+    d: "M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
+  }), /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
+    d: "M12.5 7H11v6l5.25 3.15.75-1.23-4.5-2.67z"
+  })]
+}), 'Time');
+exports.Time = Time;