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

package/esm/models/fields.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { PickerValue, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { FieldRef, PickerFieldSlotProps } from '@mui/x-date-pickers/models';
+import type { UseMultiInputRangeFieldTextFieldProps } from '../hooks/useMultiInputRangeField';
+export type { FieldRangeSection } from '@mui/x-date-pickers/internals';
+export type FieldType = 'single-input' | 'multi-input';
+/**
+ * Props the `textField` slot of the multi input field can receive when used inside a picker.
+ */
+export type MultiInputFieldSlotTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean = true> = UseMultiInputRangeFieldTextFieldProps<TEnableAccessibleFieldDOMStructure, {
+  label?: React.ReactNode;
+  focused?: boolean;
+}>;
+/**
+ * Props the `root` slot of the multi input field can receive when used inside a picker.
+ */
+export interface MultiInputFieldSlotRootProps {
+  onBlur?: React.FocusEventHandler;
+}
+export interface MultiInputFieldRefs {
+  unstableStartFieldRef?: React.Ref<FieldRef<PickerValue>>;
+  unstableEndFieldRef?: React.Ref<FieldRef<PickerValue>>;
+}
+export interface RangeFieldSeparatorProps {
+  /**
+   * String displayed between the start and the end dates.
+   * @default "–"
+   */
+  dateSeparator?: string;
+}
+/**
+ * Props the `slotProps.field` of a range picker component can receive.
+ */
+export type PickerRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> = PickerFieldSlotProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure> & RangeFieldSeparatorProps;

package/esm/models/fields.js

@@ -0,0 +1 @@
+export {};

package/esm/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./fields.js";
+export * from "./range.js";
+export * from "./validation.js";
+export type { RangePosition } from '@mui/x-date-pickers/internals';

package/esm/models/index.js

@@ -0,0 +1,4 @@
+export * from "./fields.js";
+export * from "./range.js";
+export * from "./validation.js";
+export {};

package/esm/models/range.d.ts

@@ -0,0 +1,2 @@
+import { PickerValidDate } from '@mui/x-date-pickers/models';
+export type DateRange<TDate extends PickerValidDate> = [TDate | null, TDate | null];

package/esm/models/range.js

@@ -0,0 +1 @@
+export {};

package/esm/models/validation.d.ts

@@ -0,0 +1,6 @@
+import { DateTimeValidationError, DateValidationError, TimeValidationError } from '@mui/x-date-pickers/models';
+type RangeValidation<ItemError extends string | null> = [ItemError | 'invalidRange', ItemError | 'invalidRange'];
+export type DateRangeValidationError = RangeValidation<DateValidationError>;
+export type TimeRangeValidationError = RangeValidation<TimeValidationError>;
+export type DateTimeRangeValidationError = RangeValidation<DateTimeValidationError>;
+export {};

package/esm/models/validation.js

@@ -0,0 +1 @@
+export {};

package/esm/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/esm/themeAugmentation/components.d.ts

@@ -0,0 +1,79 @@
+import { ComponentsProps, ComponentsOverrides } from '@mui/material/styles';
+export interface PickersProComponents<Theme = unknown> {
+  MuiDateRangeCalendar?: {
+    defaultProps?: ComponentsProps['MuiDateRangeCalendar'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateRangeCalendar'];
+  };
+  MuiDateRangePickerDay?: {
+    defaultProps?: ComponentsProps['MuiDateRangePickerDay'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateRangePickerDay'];
+  };
+  MuiDateTimeRangePickerTabs?: {
+    defaultProps?: ComponentsProps['MuiDateTimeRangePickerTabs'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateTimeRangePickerTabs'];
+  };
+  MuiDateRangePickerToolbar?: {
+    defaultProps?: ComponentsProps['MuiDateRangePickerToolbar'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateRangePickerToolbar'];
+  };
+  MuiDateTimeRangePickerToolbar?: {
+    defaultProps?: ComponentsProps['MuiDateTimeRangePickerToolbar'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateTimeRangePickerToolbar'];
+  };
+  MuiPickersRangeCalendarHeader?: {
+    defaultProps?: ComponentsProps['MuiPickersRangeCalendarHeader'];
+  };
+
+  // Multi input range fields
+  MuiMultiInputDateRangeField?: {
+    defaultProps?: ComponentsProps['MuiMultiInputDateRangeField'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiMultiInputDateRangeField'];
+  };
+  MuiMultiInputDateTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiMultiInputDateTimeRangeField'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiMultiInputDateTimeRangeField'];
+  };
+  MuiMultiInputTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiMultiInputTimeRangeField'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiMultiInputTimeRangeField'];
+  };
+
+  // Single input range fields
+  MuiSingleInputDateRangeField?: {
+    defaultProps?: ComponentsProps['MuiSingleInputDateRangeField'];
+  };
+  MuiSingleInputDateTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiSingleInputDateTimeRangeField'];
+  };
+  MuiSingleInputTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiSingleInputTimeRangeField'];
+  };
+
+  // Date Range Pickers
+  MuiDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDateRangePicker'];
+  };
+  MuiDesktopDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDesktopDateRangePicker'];
+  };
+  MuiMobileDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiMobileDateRangePicker'];
+  };
+  MuiStaticDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiStaticDateRangePicker'];
+  };
+
+  // Date Time Range Pickers
+  MuiDateTimeRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDateTimeRangePicker'];
+  };
+  MuiDesktopDateTimeRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDesktopDateTimeRangePicker'];
+  };
+  MuiMobileDateTimeRangePicker?: {
+    defaultProps?: ComponentsProps['MuiMobileDateTimeRangePicker'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface Components<Theme = unknown> extends PickersProComponents<Theme> {}
+}

package/esm/themeAugmentation/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@mui/x-date-pickers/themeAugmentation';
+export type * from './overrides';
+export type * from './props';
+export type * from './components';

package/esm/themeAugmentation/index.js

@@ -0,0 +1 @@
+export * from '@mui/x-date-pickers/themeAugmentation';

package/esm/themeAugmentation/overrides.d.ts

@@ -0,0 +1,27 @@
+import { DateRangePickerDayClassKey } from "../DateRangePickerDay/index.js";
+import { DateRangeCalendarClassKey } from "../DateRangeCalendar/index.js";
+import { DateRangePickerToolbarClassKey } from "../DateRangePicker/index.js";
+import { DateTimeRangePickerTabsClassKey, DateTimeRangePickerToolbarClassKey } from "../DateTimeRangePicker/index.js";
+import { MultiInputDateRangeFieldClassKey } from "../MultiInputDateRangeField/index.js";
+import { MultiInputDateTimeRangeFieldClassKey } from "../MultiInputDateTimeRangeField/index.js";
+import { MultiInputTimeRangeFieldClassKey } from "../MultiInputTimeRangeField/index.js";
+
+// prettier-ignore
+export interface PickersProComponentNameToClassKey {
+  MuiDateRangeCalendar: DateRangeCalendarClassKey;
+  MuiDateRangePickerDay: DateRangePickerDayClassKey;
+  MuiDateRangePickerToolbar: DateRangePickerToolbarClassKey;
+  MuiDateTimeRangePickerTabs: DateTimeRangePickerTabsClassKey;
+  MuiDateTimeRangePickerToolbar: DateTimeRangePickerToolbarClassKey;
+
+  // Multi input range fields
+  MuiMultiInputDateRangeField: MultiInputDateRangeFieldClassKey;
+  MuiMultiInputDateTimeRangeField: MultiInputDateTimeRangeFieldClassKey;
+  MuiMultiInputTimeRangeField: MultiInputTimeRangeFieldClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends PickersProComponentNameToClassKey {}
+}
+
+// disable automatic export
+export {};

package/esm/themeAugmentation/props.d.ts

@@ -0,0 +1,54 @@
+import { DateRangePickerDayProps } from "../DateRangePickerDay/index.js";
+import { DateRangeCalendarProps } from "../DateRangeCalendar/index.js";
+import { DateRangePickerProps } from "../DateRangePicker/index.js";
+import { ExportedDateRangePickerToolbarProps } from "../DateRangePicker/DateRangePickerToolbar.js";
+import { DesktopDateRangePickerProps } from "../DesktopDateRangePicker/index.js";
+import { MobileDateRangePickerProps } from "../MobileDateRangePicker/index.js";
+import { StaticDateRangePickerProps } from "../StaticDateRangePicker/index.js";
+import { MultiInputDateRangeFieldProps } from "../MultiInputDateRangeField/index.js";
+import { MultiInputDateTimeRangeFieldProps } from "../MultiInputDateTimeRangeField/index.js";
+import { MultiInputTimeRangeFieldProps } from "../MultiInputTimeRangeField/index.js";
+import { SingleInputDateRangeFieldProps } from "../SingleInputDateRangeField/index.js";
+import { SingleInputDateTimeRangeFieldProps } from "../SingleInputDateTimeRangeField/index.js";
+import { SingleInputTimeRangeFieldProps } from "../SingleInputTimeRangeField/index.js";
+import { DateTimeRangePickerProps } from "../DateTimeRangePicker/index.js";
+import { DesktopDateTimeRangePickerProps } from "../DesktopDateTimeRangePicker/index.js";
+import { MobileDateTimeRangePickerProps } from "../MobileDateTimeRangePicker/index.js";
+import { ExportedDateTimeRangePickerTabsProps } from "../DateTimeRangePicker/DateTimeRangePickerTabs.js";
+import { ExportedDateTimeRangePickerToolbarProps } from "../DateTimeRangePicker/DateTimeRangePickerToolbar.js";
+import { ExportedPickersRangeCalendarHeaderProps } from "../PickersRangeCalendarHeader/index.js";
+export interface PickersProComponentsPropsList {
+  MuiDateRangeCalendar: DateRangeCalendarProps;
+  MuiDateRangePickerDay: DateRangePickerDayProps;
+  MuiDateTimeRangePickerTabs: ExportedDateTimeRangePickerTabsProps;
+  MuiDateRangePickerToolbar: ExportedDateRangePickerToolbarProps;
+  MuiDateTimeRangePickerToolbar: ExportedDateTimeRangePickerToolbarProps;
+  MuiPickersRangeCalendarHeader: ExportedPickersRangeCalendarHeaderProps;
+
+  // Multi input range fields
+  MuiMultiInputDateRangeField: MultiInputDateRangeFieldProps<any>;
+  MuiMultiInputDateTimeRangeField: MultiInputDateTimeRangeFieldProps<any>;
+  MuiMultiInputTimeRangeField: MultiInputTimeRangeFieldProps<any>;
+
+  // Single input range fields
+  MuiSingleInputDateRangeField: SingleInputDateRangeFieldProps<any>;
+  MuiSingleInputDateTimeRangeField: SingleInputDateTimeRangeFieldProps<any>;
+  MuiSingleInputTimeRangeField: SingleInputTimeRangeFieldProps<any>;
+
+  // Date Range Pickers
+  MuiDateRangePicker: DateRangePickerProps<any>;
+  MuiDesktopDateRangePicker: DesktopDateRangePickerProps<any>;
+  MuiMobileDateRangePicker: MobileDateRangePickerProps<any>;
+  MuiStaticDateRangePicker: StaticDateRangePickerProps;
+
+  // Date Time Range Pickers
+  MuiDateTimeRangePicker: DateTimeRangePickerProps<any>;
+  MuiDesktopDateTimeRangePicker: DesktopDateTimeRangePickerProps<any>;
+  MuiMobileDateTimeRangePicker: MobileDateTimeRangePickerProps<any>;
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends PickersProComponentsPropsList {}
+}
+
+// disable automatic export
+export {};

package/esm/validation/index.d.ts

@@ -0,0 +1,6 @@
+export { validateDateRange } from "./validateDateRange.js";
+export type { ValidateDateRangeProps } from './validateDateRange';
+export { validateTimeRange } from "./validateTimeRange.js";
+export type { ValidateTimeRangeProps } from './validateTimeRange';
+export { validateDateTimeRange } from "./validateDateTimeRange.js";
+export type { ValidateDateTimeRangeProps } from './validateDateTimeRange';

package/esm/validation/index.js

@@ -0,0 +1,3 @@
+export { validateDateRange } from "./validateDateRange.js";
+export { validateTimeRange } from "./validateTimeRange.js";
+export { validateDateTimeRange } from "./validateDateTimeRange.js";

package/esm/validation/validateDateRange.d.ts

@@ -0,0 +1,18 @@
+import type { MakeRequired } from '@mui/x-internals/types';
+import { Validator } from '@mui/x-date-pickers/validation';
+import { BaseDateValidationProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { DayRangeValidationProps } from "../internals/models/dateRange.js";
+import { DateRangeValidationError } from "../models/index.js";
+/**
+ * Validation props used by the Date Range Picker, Date Range Field and Date Range Calendar components.
+ */
+export interface ExportedValidateDateRangeProps extends DayRangeValidationProps, BaseDateValidationProps {}
+/**
+ * Validation props as received by the validateDateRange method.
+ */
+export interface ValidateDateRangeProps extends MakeRequired<ExportedValidateDateRangeProps, ValidateDateRangePropsToDefault> {}
+/**
+ * Name of the props that should be defaulted before being passed to the validateDateRange method.
+ */
+export type ValidateDateRangePropsToDefault = keyof BaseDateValidationProps;
+export declare const validateDateRange: Validator<PickerRangeValue, DateRangeValidationError, ValidateDateRangeProps>;

package/esm/validation/validateDateRange.js

@@ -0,0 +1,59 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["shouldDisableDate"];
+import { validateDate } from '@mui/x-date-pickers/validation';
+import { isRangeValid } from "../internals/utils/date-utils.js";
+import { rangeValueManager } from "../internals/utils/valueManagers.js";
+
+/**
+ * Validation props used by the Date Range Picker, Date Range Field and Date Range Calendar components.
+ */
+
+/**
+ * Validation props as received by the validateDateRange method.
+ */
+
+/**
+ * Name of the props that should be defaulted before being passed to the validateDateRange method.
+ */
+
+export const validateDateRange = ({
+  adapter,
+  value,
+  timezone,
+  props
+}) => {
+  const [start, end] = value;
+  const {
+      shouldDisableDate
+    } = props,
+    otherProps = _objectWithoutPropertiesLoose(props, _excluded);
+  const dateValidations = [validateDate({
+    adapter,
+    value: start,
+    timezone,
+    props: _extends({}, otherProps, {
+      shouldDisableDate: day => !!shouldDisableDate?.(day, 'start')
+    })
+  }), validateDate({
+    adapter,
+    value: end,
+    timezone,
+    props: _extends({}, otherProps, {
+      shouldDisableDate: day => !!shouldDisableDate?.(day, 'end')
+    })
+  })];
+  if (dateValidations[0] || dateValidations[1]) {
+    return dateValidations;
+  }
+
+  // for partial input
+  if (start === null || end === null) {
+    return [null, null];
+  }
+  if (!isRangeValid(adapter.utils, value)) {
+    return ['invalidRange', 'invalidRange'];
+  }
+  return [null, null];
+};
+validateDateRange.valueManager = rangeValueManager;

package/esm/validation/validateDateTimeRange.d.ts

@@ -0,0 +1,15 @@
+import { DateTimeValidationProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { Validator } from '@mui/x-date-pickers/validation';
+import { DateTimeRangeValidationError } from "../models/index.js";
+import { ExportedValidateDateRangeProps, ValidateDateRangeProps, ValidateDateRangePropsToDefault } from "./validateDateRange.js";
+import { ExportedValidateTimeRangeProps, ValidateTimeRangeProps, ValidateTimeRangePropsToDefault } from "./validateTimeRange.js";
+/**
+ * Validation props used by the Date Time Range Picker and Date Time Range Field.
+ */
+export interface ExportedValidateDateTimeRangeProps extends ExportedValidateDateRangeProps, ExportedValidateTimeRangeProps, DateTimeValidationProps {}
+/**
+ * Validation props as received by the validateDateTimeRange method.
+ */
+export interface ValidateDateTimeRangeProps extends ValidateDateRangeProps, ValidateTimeRangeProps {}
+export type ValidateDateTimeRangePropsToDefault = ValidateDateRangePropsToDefault | ValidateTimeRangePropsToDefault;
+export declare const validateDateTimeRange: Validator<PickerRangeValue, DateTimeRangeValidationError, ValidateDateTimeRangeProps>;

package/esm/validation/validateDateTimeRange.js

@@ -0,0 +1,55 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["shouldDisableDate"];
+import { validateDateTime } from '@mui/x-date-pickers/validation';
+import { isRangeValid } from "../internals/utils/date-utils.js";
+import { rangeValueManager } from "../internals/utils/valueManagers.js";
+
+/**
+ * Validation props used by the Date Time Range Picker and Date Time Range Field.
+ */
+
+/**
+ * Validation props as received by the validateDateTimeRange method.
+ */
+
+export const validateDateTimeRange = ({
+  adapter,
+  value,
+  timezone,
+  props
+}) => {
+  const [start, end] = value;
+  const {
+      shouldDisableDate
+    } = props,
+    otherProps = _objectWithoutPropertiesLoose(props, _excluded);
+  const dateTimeValidations = [validateDateTime({
+    adapter,
+    value: start,
+    timezone,
+    props: _extends({}, otherProps, {
+      shouldDisableDate: day => !!shouldDisableDate?.(day, 'start')
+    })
+  }), validateDateTime({
+    adapter,
+    value: end,
+    timezone,
+    props: _extends({}, otherProps, {
+      shouldDisableDate: day => !!shouldDisableDate?.(day, 'end')
+    })
+  })];
+  if (dateTimeValidations[0] || dateTimeValidations[1]) {
+    return dateTimeValidations;
+  }
+
+  // for partial input
+  if (start === null || end === null) {
+    return [null, null];
+  }
+  if (!isRangeValid(adapter.utils, value)) {
+    return ['invalidRange', 'invalidRange'];
+  }
+  return [null, null];
+};
+validateDateTimeRange.valueManager = rangeValueManager;

package/esm/validation/validateTimeRange.d.ts

@@ -0,0 +1,17 @@
+import type { MakeRequired } from '@mui/x-internals/types';
+import { Validator } from '@mui/x-date-pickers/validation';
+import { TimeValidationProps, BaseTimeValidationProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { TimeRangeValidationError } from "../models/index.js";
+/**
+ * Validation props used by the Time Range Picker and Time Range Field.
+ */
+export interface ExportedValidateTimeRangeProps extends BaseTimeValidationProps, TimeValidationProps {}
+/**
+ * Validation props as received by the validateTimeRange method.
+ */
+export interface ValidateTimeRangeProps extends MakeRequired<ExportedValidateTimeRangeProps, ValidateTimeRangePropsToDefault> {}
+/**
+ * Name of the props that should be defaulted before being passed to the validateTimeRange method.
+ */
+export type ValidateTimeRangePropsToDefault = keyof BaseTimeValidationProps;
+export declare const validateTimeRange: Validator<PickerRangeValue, TimeRangeValidationError, ValidateTimeRangeProps>;

package/{node → esm}/validation/validateTimeRange.js

@@ -1,12 +1,7 @@
-"use strict";
+import { validateTime } from '@mui/x-date-pickers/validation';
+import { isRangeValid } from "../internals/utils/date-utils.js";
+import { rangeValueManager } from "../internals/utils/valueManagers.js";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validateTimeRange = void 0;
-var _validation = require("@mui/x-date-pickers/validation");
-var _dateUtils = require("../internals/utils/date-utils");
-var _valueManagers = require("../internals/utils/valueManagers");
 /**
  * Validation props used by the Time Range Picker and Time Range Field.
  */
@@ -19,19 +14,19 @@ var _valueManagers = require("../internals/utils/valueManagers");
  * Name of the props that should be defaulted before being passed to the validateTimeRange method.
  */
 
-const validateTimeRange = ({
+export const validateTimeRange = ({
   adapter,
   value,
   timezone,
   props
 }) => {
   const [start, end] = value;
-  const dateTimeValidations = [(0, _validation.validateTime)({
+  const dateTimeValidations = [validateTime({
     adapter,
     value: start,
     timezone,
     props
-  }), (0, _validation.validateTime)({
+  }), validateTime({
     adapter,
     value: end,
     timezone,
@@ -45,10 +40,9 @@ const validateTimeRange = ({
   if (start === null || end === null) {
     return [null, null];
   }
-  if (!(0, _dateUtils.isRangeValid)(adapter.utils, value)) {
+  if (!isRangeValid(adapter.utils, value)) {
     return ['invalidRange', 'invalidRange'];
   }
   return [null, null];
 };
-exports.validateTimeRange = validateTimeRange;
-validateTimeRange.valueManager = _valueManagers.rangeValueManager;
+validateTimeRange.valueManager = rangeValueManager;

package/hooks/index.d.ts

@@ -1,2 +1,3 @@
-export { usePickerRangePositionContext } from './usePickerRangePositionContext';
-export { useMultiInputRangeField as unstable_useMultiInputRangeField } from './useMultiInputRangeField';
+export { usePickerRangePositionContext } from "./usePickerRangePositionContext.js";
+export { useMultiInputRangeField as unstable_useMultiInputRangeField } from "./useMultiInputRangeField/index.js";
+export type { UseMultiInputRangeFieldTextFieldProps } from './useMultiInputRangeField';

package/hooks/index.js

@@ -1,2 +1,19 @@
-export { usePickerRangePositionContext } from "./usePickerRangePositionContext.js";
-export { useMultiInputRangeField as unstable_useMultiInputRangeField } from "./useMultiInputRangeField/index.js";
+"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/hooks/useMultiInputRangeField/index.d.ts

@@ -1 +1,2 @@
-export { useMultiInputRangeField } from './useMultiInputRangeField';
+export { useMultiInputRangeField } from "./useMultiInputRangeField.js";
+export type { UseMultiInputRangeFieldTextFieldProps } from './useMultiInputRangeField';

package/hooks/useMultiInputRangeField/index.js

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

package/hooks/useMultiInputRangeField/useMultiInputRangeField.d.ts

@@ -1,5 +1,7 @@
-import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldResponse } from '@mui/x-date-pickers/internals';
-import { PickerAnyRangeManager } from '../../internals/models/managers';
+import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldReturnValue } from '@mui/x-date-pickers/internals';
+import { UseTextFieldBaseForwardedProps } from "./useTextFieldProps.js";
+import { PickerAnyRangeManager } from "../../internals/models/managers.js";
+import { UseMultiInputRangeFieldRootPropsReturnValue } from "./useMultiInputRangeFieldRootProps.js";
 /**
  * Basic example:
  *
@@ -12,42 +14,59 @@ import { PickerAnyRangeManager } from '../../internals/models/managers';
  * function MultiInputField(props) {
  *   const manager = useDateRangeManager();
  *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
- *   const { startDate, endDate } = useMultiInputRangeField({
+ *   const response = useMultiInputRangeField({
  *     manager,
  *     internalProps,
- *     startForwardedProps: forwardedProps,
- *     endForwardedProps: forwardedProps,
+ *     startTextFieldProps: {},
+ *     endTextFieldProps: {},
+ *     rootProps: forwardedProps,
  *   });
  *
  *   return (
- *     <Box {...forwardedProps}>
- *       <PickersTextField {...startDate} />
+ *     <Box {...response.root}>
+ *       <PickersTextField {...response.startTextField} />
  *       <span>{' – '}</span>
- *       <PickersTextField {...endDate} />
+ *       <PickersTextField {...response.endTextField} />
  *     </Box>
  *   );
  * }
  * ```
  *
- * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {UseMultiInputRangeFieldParameters<TManager, TTextFieldProps>} 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.
+ * @param {TTextFieldProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TTextFieldProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TTextFieldProps>} The props to pass to the start and the end components.
  */
-export declare function useMultiInputRangeField<TManager extends PickerAnyRangeManager, TForwardedProps extends {
-    [key: string]: any;
-}>(parameters: UseMultiInputRangeFieldParameters<TManager, TForwardedProps>): UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>;
-interface UseMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
-    manager: TManager;
-    internalProps: PickerManagerFieldInternalProps<TManager>;
-    startForwardedProps: TForwardedProps;
-    endForwardedProps: TForwardedProps;
+export declare function useMultiInputRangeField<TManager extends PickerAnyRangeManager, TTextFieldProps extends UseTextFieldBaseForwardedProps, TRootProps extends {
+  [key: string]: any;
+}>(parameters: UseMultiInputRangeFieldParameters<TManager, TTextFieldProps, TRootProps>): UseMultiInputRangeFieldReturnValue<TManager, TTextFieldProps, TRootProps>;
+interface UseMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager, TTextFieldProps extends {
+  [key: string]: any;
+}, TRootProps extends {
+  [key: string]: any;
+}> {
+  manager: TManager;
+  internalProps: PickerManagerFieldInternalProps<TManager>;
+  rootProps: TRootProps;
+  startTextFieldProps: TTextFieldProps;
+  endTextFieldProps: TTextFieldProps;
 }
-interface UseMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
-    startDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
-    endDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
-    enableAccessibleFieldDOMStructure: PickerManagerEnableAccessibleFieldDOMStructure<TManager>;
+interface UseMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager, TTextFieldProps extends {
+  [key: string]: any;
+}, TRootProps extends {
+  [key: string]: any;
+}> {
+  root: UseMultiInputRangeFieldRootPropsReturnValue<TRootProps>;
+  startTextField: UseMultiInputRangeFieldTextFieldProps<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TTextFieldProps>;
+  endTextField: UseMultiInputRangeFieldTextFieldProps<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TTextFieldProps>;
+  enableAccessibleFieldDOMStructure: PickerManagerEnableAccessibleFieldDOMStructure<TManager>;
 }
-export {};
+export type UseMultiInputRangeFieldTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean, TForwardedProps extends UseTextFieldBaseForwardedProps> = Omit<UseFieldReturnValue<TEnableAccessibleFieldDOMStructure, TForwardedProps & {
+  onKeyDown: React.KeyboardEventHandler;
+  onClick: React.MouseEventHandler;
+  onFocus: React.FocusEventHandler;
+  id: string;
+}>, 'onClear' | 'clearable' | 'openPickerAriaLabel'>;
+export {};