@mui/x-date-pickers-pro 8.0.0-alpha.1 → 8.0.0-alpha.10

package/node/SingleInputTimeRangeField/useSingleInputTimeRangeField.js

@@ -1,32 +1,31 @@
 "use strict";
 'use client';
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useSingleInputTimeRangeField = void 0;
-var React = _interopRequireWildcard(require("react"));
 var _internals = require("@mui/x-date-pickers/internals");
 var _hooks = require("@mui/x-date-pickers/hooks");
-var _valueManagers = require("../internals/utils/valueManagers");
-var _validation = require("../validation");
-const useSingleInputTimeRangeField = inProps => {
-  const props = (0, _internals.useDefaultizedTimeField)(inProps);
+var _managers = require("../managers");
+const useSingleInputTimeRangeField = props => {
+  const manager = (0, _managers.useTimeRangeManager)(props);
   const {
     forwardedProps,
     internalProps
   } = (0, _hooks.useSplitFieldProps)(props, 'time');
-  const fieldValueManager = React.useMemo(() => (0, _valueManagers.getRangeFieldValueManager)({
-    dateSeparator: internalProps.dateSeparator
-  }), [internalProps.dateSeparator]);
+  const internalPropsWithDefaults = (0, _internals.useFieldInternalPropsWithDefaults)({
+    manager,
+    internalProps
+  });
   return (0, _internals.useField)({
     forwardedProps,
-    internalProps,
-    valueManager: _valueManagers.rangeValueManager,
-    fieldValueManager,
-    validator: _validation.validateTimeRange,
-    valueType: 'time'
+    internalProps: internalPropsWithDefaults,
+    valueManager: manager.internal_valueManager,
+    fieldValueManager: manager.internal_fieldValueManager,
+    validator: manager.validator,
+    valueType: manager.valueType,
+    getOpenPickerButtonAriaLabel: manager.internal_getOpenPickerButtonAriaLabel
   });
 };
 exports.useSingleInputTimeRangeField = useSingleInputTimeRangeField;

package/node/StaticDateRangePicker/StaticDateRangePicker.js

@@ -48,11 +48,11 @@ const StaticDateRangePicker = exports.StaticDateRangePicker = /*#__PURE__*/React
   const {
     renderPicker
   } = (0, _useStaticRangePicker.useStaticRangePicker)({
+    ref,
     props,
     valueManager: _valueManagers.rangeValueManager,
     valueType: 'date',
-    validator: _validation.validateDateRange,
-    ref
+    validator: _validation.validateDateRange
   });
   return renderPicker();
 });

package/node/dateRangeViewRenderers/dateRangeViewRenderers.js

@@ -26,9 +26,6 @@ const renderDateRangeViewCalendar = ({
   shouldDisableDate,
   reduceAnimations,
   onMonthChange,
-  rangePosition,
-  defaultRangePosition,
-  onRangePositionChange,
   calendars,
   currentMonthCalendarPosition,
   slots,
@@ -65,9 +62,6 @@ const renderDateRangeViewCalendar = ({
   shouldDisableDate: shouldDisableDate,
   reduceAnimations: reduceAnimations,
   onMonthChange: onMonthChange,
-  rangePosition: rangePosition,
-  defaultRangePosition: defaultRangePosition,
-  onRangePositionChange: onRangePositionChange,
   calendars: calendars,
   currentMonthCalendarPosition: currentMonthCalendarPosition,
   slots: slots,

package/node/hooks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "unstable_useMultiInputRangeField", {
+  enumerable: true,
+  get: function () {
+    return _useMultiInputRangeField.useMultiInputRangeField;
+  }
+});
+Object.defineProperty(exports, "usePickerRangePositionContext", {
+  enumerable: true,
+  get: function () {
+    return _usePickerRangePositionContext.usePickerRangePositionContext;
+  }
+});
+var _usePickerRangePositionContext = require("./usePickerRangePositionContext");
+var _useMultiInputRangeField = require("./useMultiInputRangeField");

package/node/hooks/useMultiInputRangeField/index.js

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

package/node/hooks/useMultiInputRangeField/useMultiInputRangeField.js

@@ -0,0 +1,155 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultiInputRangeField = useMultiInputRangeField;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _internals = require("@mui/x-date-pickers/internals");
+var _validation = require("@mui/x-date-pickers/validation");
+var _useMultiInputRangeFieldTextFieldProps = require("./useMultiInputRangeFieldTextFieldProps");
+var _useMultiInputRangeFieldSelectedSections = require("./useMultiInputRangeFieldSelectedSections");
+/**
+ * Basic example:
+ *
+ * ```tsx
+ * import Box from '@mui/material/Box';
+ * import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
+ * import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+ * import { useDateRangeManager } from '@mui/x-date-pickers-pro/managers';
+ *
+ * function MultiInputField(props) {
+ *   const manager = useDateRangeManager();
+ *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
+ *   const { startDate, endDate } = useMultiInputRangeField({
+ *     manager,
+ *     internalProps,
+ *     startForwardedProps: forwardedProps,
+ *     endForwardedProps: forwardedProps,
+ *   });
+ *
+ *   return (
+ *     <Box {...forwardedProps}>
+ *       <PickersTextField {...startDate} />
+ *       <span>{' – '}</span>
+ *       <PickersTextField {...endDate} />
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {TManager} parameters.manager The manager of the field.
+ * @param {PickerManagerFieldInternalProps<TManager>} parameters.internalProps The internal props of the field.
+ * @param {TForwardedProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TForwardedProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>} The props to pass to the start and the end components.
+ */
+function useMultiInputRangeField(parameters) {
+  const {
+    manager,
+    internalProps,
+    startForwardedProps,
+    endForwardedProps
+  } = parameters;
+  const internalPropsWithDefaults = (0, _internals.useFieldInternalPropsWithDefaults)({
+    manager,
+    internalProps
+  });
+  const {
+    value: valueProp,
+    defaultValue,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    onChange,
+    disabled,
+    readOnly,
+    selectedSections,
+    onSelectedSectionsChange,
+    timezone: timezoneProp,
+    enableAccessibleFieldDOMStructure,
+    autoFocus,
+    referenceDate,
+    unstableStartFieldRef,
+    unstableEndFieldRef
+  } = internalPropsWithDefaults;
+  const {
+    value,
+    handleValueChange,
+    timezone
+  } = (0, _internals.useControlledValueWithTimezone)({
+    name: 'useMultiInputRangeField',
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    referenceDate,
+    onChange,
+    valueManager: manager.internal_valueManager
+  });
+  const {
+    validationError,
+    getValidationErrorForNewValue
+  } = (0, _validation.useValidation)({
+    props: internalPropsWithDefaults,
+    value,
+    timezone,
+    validator: manager.validator,
+    onError: internalPropsWithDefaults.onError
+  });
+  const buildChangeHandler = index => {
+    return (newSingleValue, rawContext) => {
+      const newRange = index === 0 ? [newSingleValue, value[1]] : [value[0], newSingleValue];
+      const context = (0, _extends2.default)({}, rawContext, {
+        validationError: getValidationErrorForNewValue(newRange)
+      });
+      handleValueChange(newRange, context);
+    };
+  };
+  const handleStartDateChange = (0, _useEventCallback.default)(buildChangeHandler(0));
+  const handleEndDateChange = (0, _useEventCallback.default)(buildChangeHandler(1));
+  const selectedSectionsResponse = (0, _useMultiInputRangeFieldSelectedSections.useMultiInputRangeFieldSelectedSections)({
+    selectedSections,
+    onSelectedSectionsChange,
+    unstableStartFieldRef,
+    unstableEndFieldRef
+  });
+  const sharedProps = {
+    disabled,
+    readOnly,
+    timezone,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    enableAccessibleFieldDOMStructure
+  };
+  const startDateProps = (0, _useMultiInputRangeFieldTextFieldProps.useMultiInputRangeFieldTextFieldProps)({
+    valueType: manager.valueType,
+    fieldProps: (0, _extends2.default)({
+      error: !!validationError[0]
+    }, startForwardedProps, selectedSectionsResponse.start, sharedProps, {
+      value: valueProp === undefined ? undefined : valueProp[0],
+      defaultValue: defaultValue === undefined ? undefined : defaultValue[0],
+      onChange: handleStartDateChange,
+      autoFocus // Do not add on end field.
+    })
+  });
+  const endDateProps = (0, _useMultiInputRangeFieldTextFieldProps.useMultiInputRangeFieldTextFieldProps)({
+    valueType: manager.valueType,
+    fieldProps: (0, _extends2.default)({
+      error: !!validationError[1]
+    }, endForwardedProps, selectedSectionsResponse.end, sharedProps, {
+      value: valueProp === undefined ? undefined : valueProp[1],
+      defaultValue: defaultValue === undefined ? undefined : defaultValue[1],
+      onChange: handleEndDateChange
+    })
+  });
+  return {
+    startDate: startDateProps,
+    endDate: endDateProps,
+    enableAccessibleFieldDOMStructure
+  };
+}

package/node/{internals/hooks/useMultiInputFieldSelectedSections.js → hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.js}

@@ -1,18 +1,19 @@
 "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.useMultiInputFieldSelectedSections = void 0;
+exports.useMultiInputRangeFieldSelectedSections = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
 var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
-const useMultiInputFieldSelectedSections = params => {
+const useMultiInputRangeFieldSelectedSections = parameters => {
   const unstableEndFieldRef = React.useRef(null);
-  const handleUnstableEndFieldRef = (0, _useForkRef.default)(params.unstableEndFieldRef, unstableEndFieldRef);
-  const [startSelectedSection, setStartSelectedSection] = React.useState(params.selectedSections ?? null);
+  const handleUnstableEndFieldRef = (0, _useForkRef.default)(parameters.unstableEndFieldRef, unstableEndFieldRef);
+  const [startSelectedSection, setStartSelectedSection] = React.useState(parameters.selectedSections ?? null);
   const [endSelectedSection, setEndSelectedSection] = React.useState(null);
   const getActiveField = () => {
     if (unstableEndFieldRef.current && unstableEndFieldRef.current.isFieldFocused()) {
@@ -23,27 +24,27 @@ const useMultiInputFieldSelectedSections = params => {
   const handleStartSelectedSectionChange = (0, _useEventCallback.default)(newSelectedSections => {
     setStartSelectedSection(newSelectedSections);
     if (getActiveField() === 'start') {
-      params.onSelectedSectionsChange?.(newSelectedSections);
+      parameters.onSelectedSectionsChange?.(newSelectedSections);
     }
   });
   const handleEndSelectedSectionChange = (0, _useEventCallback.default)(newSelectedSections => {
     setEndSelectedSection(newSelectedSections);
     if (getActiveField() === 'end') {
-      params.onSelectedSectionsChange?.(newSelectedSections);
+      parameters.onSelectedSectionsChange?.(newSelectedSections);
     }
   });
   const activeField = getActiveField();
   return {
     start: {
-      unstableFieldRef: params.unstableStartFieldRef,
-      selectedSections: activeField === 'start' && params.selectedSections !== undefined ? params.selectedSections : startSelectedSection,
+      unstableFieldRef: parameters.unstableStartFieldRef,
+      selectedSections: activeField === 'start' && parameters.selectedSections !== undefined ? parameters.selectedSections : startSelectedSection,
       onSelectedSectionsChange: handleStartSelectedSectionChange
     },
     end: {
       unstableFieldRef: handleUnstableEndFieldRef,
-      selectedSections: activeField === 'end' && params.selectedSections !== undefined ? params.selectedSections : endSelectedSection,
+      selectedSections: activeField === 'end' && parameters.selectedSections !== undefined ? parameters.selectedSections : endSelectedSection,
       onSelectedSectionsChange: handleEndSelectedSectionChange
     }
   };
 };
-exports.useMultiInputFieldSelectedSections = useMultiInputFieldSelectedSections;
+exports.useMultiInputRangeFieldSelectedSections = useMultiInputRangeFieldSelectedSections;

package/node/hooks/useMultiInputRangeField/useMultiInputRangeFieldTextFieldProps.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultiInputRangeFieldTextFieldProps = useMultiInputRangeFieldTextFieldProps;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _managers = require("@mui/x-date-pickers/managers");
+var _hooks = require("@mui/x-date-pickers/hooks");
+var _internals = require("@mui/x-date-pickers/internals");
+const _excluded = ["clearable", "onClear"];
+/**
+ * @ignore - internal hook.
+ */
+function useMultiInputRangeFieldTextFieldProps(parameters) {
+  const {
+    fieldProps,
+    valueType
+  } = parameters;
+  let useManager;
+  switch (valueType) {
+    case 'date':
+      {
+        useManager = _managers.useDateManager;
+        break;
+      }
+    case 'time':
+      {
+        useManager = _managers.useTimeManager;
+        break;
+      }
+    case 'date-time':
+      {
+        useManager = _managers.useDateTimeManager;
+        break;
+      }
+    default:
+      {
+        throw new Error(`Unknown valueType: ${valueType}`);
+      }
+  }
+  const manager = useManager({
+    enableAccessibleFieldDOMStructure: fieldProps.enableAccessibleFieldDOMStructure
+  });
+  const {
+    forwardedProps,
+    internalProps
+  } = (0, _hooks.useSplitFieldProps)(fieldProps, 'date');
+  const internalPropsWithDefaults = (0, _internals.useFieldInternalPropsWithDefaults)({
+    manager,
+    internalProps
+  });
+  const _ref = (0, _internals.useField)({
+      forwardedProps,
+      internalProps: internalPropsWithDefaults,
+      valueManager: manager.internal_valueManager,
+      fieldValueManager: manager.internal_fieldValueManager,
+      validator: manager.validator,
+      valueType: manager.valueType,
+      // TODO v8: Add a real aria label before moving the opening logic to the field on range pickers.
+      getOpenPickerButtonAriaLabel: () => ''
+    }),
+    fieldResponse = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+  return fieldResponse;
+}

package/node/hooks/usePickerRangePositionContext.js

@@ -0,0 +1,22 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickerRangePositionContext = void 0;
+exports.usePickerRangePositionContext = usePickerRangePositionContext;
+var React = _interopRequireWildcard(require("react"));
+const PickerRangePositionContext = exports.PickerRangePositionContext = /*#__PURE__*/React.createContext(null);
+
+/**
+ * Returns information about the range position of the picker that wraps the current component.
+ */
+function usePickerRangePositionContext() {
+  const value = React.useContext(PickerRangePositionContext);
+  if (value == null) {
+    throw new Error(['MUI X: The `usePickerRangePositionContext` can only be called in components that are used inside a picker component'].join('\n'));
+  }
+  return value;
+}

package/node/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers-pro v8.0.0-alpha.1
+ * @mui/x-date-pickers-pro v8.0.0-alpha.10
  *
  * @license MUI X Commercial
  * This source code is licensed under the commercial license found in the
@@ -219,6 +219,17 @@ Object.keys(_models).forEach(function (key) {
     }
   });
 });
+var _hooks = require("./hooks");
+Object.keys(_hooks).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _hooks[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _hooks[key];
+    }
+  });
+});
 var _validation = require("./validation");
 Object.keys(_validation).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -229,4 +240,15 @@ Object.keys(_validation).forEach(function (key) {
       return _validation[key];
     }
   });
+});
+var _managers = require("./managers");
+Object.keys(_managers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _managers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _managers[key];
+    }
+  });
 });