@pisell/date-picker 1.0.0

package/lib/internals/hooks/useEnrichedRangePickerFieldProps.js

@@ -0,0 +1,244 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internals/hooks/useEnrichedRangePickerFieldProps.ts
+var useEnrichedRangePickerFieldProps_exports = {};
+__export(useEnrichedRangePickerFieldProps_exports, {
+  useEnrichedRangePickerFieldProps: () => useEnrichedRangePickerFieldProps
+});
+module.exports = __toCommonJS(useEnrichedRangePickerFieldProps_exports);
+var React = __toESM(require("react"));
+var import_utils = require("@mui/base/utils");
+var import_useEventCallback = __toESM(require("@mui/utils/useEventCallback"));
+var import_useForkRef = __toESM(require("@mui/utils/useForkRef"));
+var import_internals = require("@mui/x-date-pickers/internals");
+var useMultiInputFieldSlotProps = ({
+  wrapperVariant,
+  open,
+  actions,
+  readOnly,
+  labelId,
+  disableOpenPicker,
+  onBlur,
+  rangePosition,
+  onRangePositionChange,
+  localeText: inLocaleText,
+  pickerSlotProps,
+  pickerSlots,
+  fieldProps
+}) => {
+  const localeText = (0, import_internals.useLocaleText)();
+  const startRef = React.useRef(null);
+  const endRef = React.useRef(null);
+  React.useEffect(() => {
+    var _a, _b;
+    if (!open) {
+      return;
+    }
+    if (rangePosition === "start") {
+      (_a = startRef.current) == null ? void 0 : _a.focus();
+    } else if (rangePosition === "end") {
+      (_b = endRef.current) == null ? void 0 : _b.focus();
+    }
+  }, [rangePosition, open]);
+  const openRangeStartSelection = (event) => {
+    event.stopPropagation();
+    onRangePositionChange("start");
+    if (!readOnly && !disableOpenPicker) {
+      actions.onOpen();
+    }
+  };
+  const openRangeEndSelection = (event) => {
+    event.stopPropagation();
+    onRangePositionChange("end");
+    if (!readOnly && !disableOpenPicker) {
+      actions.onOpen();
+    }
+  };
+  const handleFocusStart = () => {
+    if (open) {
+      onRangePositionChange("start");
+    }
+  };
+  const handleFocusEnd = () => {
+    if (open) {
+      onRangePositionChange("end");
+    }
+  };
+  const slots = {
+    textField: pickerSlots == null ? void 0 : pickerSlots.textField,
+    root: pickerSlots == null ? void 0 : pickerSlots.fieldRoot,
+    separator: pickerSlots == null ? void 0 : pickerSlots.fieldSeparator,
+    ...fieldProps.slots
+  };
+  const slotProps = {
+    ...fieldProps.slotProps,
+    textField: (ownerState) => {
+      let inputProps;
+      if (ownerState.position === "start") {
+        inputProps = {
+          inputRef: startRef,
+          label: (inLocaleText == null ? void 0 : inLocaleText.start) ?? localeText.start,
+          onKeyDown: (0, import_internals.onSpaceOrEnter)(openRangeStartSelection),
+          onFocus: handleFocusStart,
+          focused: open ? rangePosition === "start" : void 0,
+          // registering `onClick` listener on the root element as well to correctly handle cases where user is clicking on `label`
+          // which has `pointer-events: none` and due to DOM structure the `input` does not catch the click event
+          ...!readOnly && !fieldProps.disabled && { onClick: openRangeStartSelection },
+          ...wrapperVariant === "mobile" && { readOnly: true }
+        };
+      } else {
+        inputProps = {
+          inputRef: endRef,
+          label: (inLocaleText == null ? void 0 : inLocaleText.end) ?? localeText.end,
+          onKeyDown: (0, import_internals.onSpaceOrEnter)(openRangeEndSelection),
+          onFocus: handleFocusEnd,
+          focused: open ? rangePosition === "end" : void 0,
+          // registering `onClick` listener on the root element as well to correctly handle cases where user is clicking on `label`
+          // which has `pointer-events: none` and due to DOM structure the `input` does not catch the click event
+          ...!readOnly && !fieldProps.disabled && { onClick: openRangeEndSelection },
+          ...wrapperVariant === "mobile" && { readOnly: true }
+        };
+      }
+      return {
+        ...labelId != null && { id: `${labelId}-${ownerState.position}` },
+        ...inputProps,
+        ...(0, import_utils.resolveComponentProps)(pickerSlotProps == null ? void 0 : pickerSlotProps.textField, ownerState)
+      };
+    },
+    root: (ownerState) => {
+      const rootProps = {
+        onBlur
+      };
+      return {
+        ...rootProps,
+        ...(0, import_utils.resolveComponentProps)(pickerSlotProps == null ? void 0 : pickerSlotProps.fieldRoot, ownerState)
+      };
+    },
+    separator: pickerSlotProps == null ? void 0 : pickerSlotProps.fieldSeparator
+  };
+  const enrichedFieldProps = { ...fieldProps, slots, slotProps };
+  return enrichedFieldProps;
+};
+var useSingleInputFieldSlotProps = ({
+  wrapperVariant,
+  open,
+  actions,
+  readOnly,
+  inputRef: inInputRef,
+  labelId,
+  disableOpenPicker,
+  label,
+  onBlur,
+  rangePosition,
+  onRangePositionChange,
+  singleInputFieldRef,
+  pickerSlots,
+  pickerSlotProps,
+  fieldProps
+}) => {
+  const inputRef = React.useRef(null);
+  const handleInputRef = (0, import_useForkRef.default)(inInputRef, inputRef);
+  const handleFieldRef = (0, import_useForkRef.default)(fieldProps.unstableFieldRef, singleInputFieldRef);
+  React.useEffect(() => {
+    var _a;
+    if (!open) {
+      return;
+    }
+    (_a = inputRef.current) == null ? void 0 : _a.focus();
+  }, [rangePosition, open]);
+  const updateRangePosition = () => {
+    var _a;
+    if (!singleInputFieldRef.current || inputRef.current !== (0, import_internals.getActiveElement)(document)) {
+      return;
+    }
+    const sections = singleInputFieldRef.current.getSections();
+    const activeSectionIndex = (_a = singleInputFieldRef.current) == null ? void 0 : _a.getActiveSectionIndex();
+    const domRangePosition = activeSectionIndex == null || activeSectionIndex < sections.length / 2 ? "start" : "end";
+    if (domRangePosition != null && domRangePosition !== rangePosition) {
+      onRangePositionChange(domRangePosition);
+    }
+  };
+  const handleSelectedSectionsChange = (0, import_useEventCallback.default)(
+    (selectedSections) => {
+      var _a;
+      setTimeout(updateRangePosition);
+      (_a = fieldProps.onSelectedSectionsChange) == null ? void 0 : _a.call(fieldProps, selectedSections);
+    }
+  );
+  const openPicker = (event) => {
+    event.stopPropagation();
+    if (!readOnly && !disableOpenPicker) {
+      actions.onOpen();
+    }
+  };
+  const slots = {
+    ...fieldProps.slots,
+    textField: pickerSlots == null ? void 0 : pickerSlots.textField
+  };
+  const slotProps = {
+    ...fieldProps.slotProps,
+    textField: pickerSlotProps == null ? void 0 : pickerSlotProps.textField
+  };
+  const enrichedFieldProps = {
+    ...fieldProps,
+    slots,
+    slotProps,
+    label,
+    unstableFieldRef: handleFieldRef,
+    inputRef: handleInputRef,
+    onKeyDown: (0, import_internals.onSpaceOrEnter)(openPicker, fieldProps.onKeyDown),
+    onSelectedSectionsChange: handleSelectedSectionsChange,
+    onBlur,
+    focused: open,
+    ...labelId != null && { id: labelId },
+    ...wrapperVariant === "mobile" && { readOnly: true },
+    // registering `onClick` listener on the root element as well to correctly handle cases where user is clicking on `label`
+    // which has `pointer-events: none` and due to DOM structure the `input` does not catch the click event
+    ...!readOnly && !fieldProps.disabled && { onClick: openPicker }
+  };
+  return enrichedFieldProps;
+};
+var useEnrichedRangePickerFieldProps = (params) => {
+  if (process.env.NODE_ENV !== "production") {
+    const fieldTypeRef = React.useRef(params.fieldType);
+    if (params.fieldType !== fieldTypeRef.current) {
+      console.error(
+        "Should not switch between a multi input field and a single input field on a range picker."
+      );
+    }
+  }
+  if (params.fieldType === "multi-input") {
+    return useMultiInputFieldSlotProps(params);
+  }
+  return useSingleInputFieldSlotProps(params);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEnrichedRangePickerFieldProps
+});

package/lib/internals/hooks/useMobileRangePicker/index.d.ts

@@ -0,0 +1,3 @@
+export { useMobileRangePicker } from './useMobileRangePicker';
+export type { UseMobileRangePickerSlotsComponent, UseMobileRangePickerSlotsComponentsProps, MobileRangeOnlyPickerProps, } from './useMobileRangePicker.types';
+//# sourceMappingURL=index.d.ts.map

package/lib/internals/hooks/useMobileRangePicker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EACV,kCAAkC,EAClC,wCAAwC,EACxC,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC"}

package/lib/internals/hooks/useMobileRangePicker/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internals/hooks/useMobileRangePicker/index.ts
+var useMobileRangePicker_exports = {};
+__export(useMobileRangePicker_exports, {
+  useMobileRangePicker: () => import_useMobileRangePicker.useMobileRangePicker
+});
+module.exports = __toCommonJS(useMobileRangePicker_exports);
+var import_useMobileRangePicker = require("./useMobileRangePicker");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMobileRangePicker
+});

package/lib/internals/hooks/useMobileRangePicker/useMobileRangePicker.d.ts

@@ -0,0 +1,6 @@
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals/models';
+import { UseMobileRangePickerParams, UseMobileRangePickerProps } from './useMobileRangePicker.types';
+export declare const useMobileRangePicker: <TDate, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseMobileRangePickerProps<TDate, TView, any, TExternalProps>>({ props, ...pickerParams }: UseMobileRangePickerParams<TDate, TView, TExternalProps>) => {
+    renderPicker: () => JSX.Element;
+};
+//# sourceMappingURL=useMobileRangePicker.d.ts.map

package/lib/internals/hooks/useMobileRangePicker/useMobileRangePicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMobileRangePicker.d.ts","sourceRoot":"","sources":["useMobileRangePicker.tsx"],"names":[],"mappings":"AAgBA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAEL,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,8BAA8B,CAAC;AAStC,eAAO,MAAM,oBAAoB;;CAiKhC,CAAC"}

package/lib/internals/hooks/useMobileRangePicker/useMobileRangePicker.js

@@ -0,0 +1,173 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internals/hooks/useMobileRangePicker/useMobileRangePicker.tsx
+var useMobileRangePicker_exports = {};
+__export(useMobileRangePicker_exports, {
+  useMobileRangePicker: () => useMobileRangePicker
+});
+module.exports = __toCommonJS(useMobileRangePicker_exports);
+var React = __toESM(require("react"));
+var import_utils = require("@mui/base/utils");
+var import_LocalizationProvider = require("@mui/x-date-pickers/LocalizationProvider");
+var import_PickersLayout = require("@mui/x-date-pickers/PickersLayout");
+var import_internals = require("@mui/x-date-pickers/internals");
+var import_useId = __toESM(require("@mui/utils/useId"));
+var import_useEnrichedRangePickerFieldProps = require("../useEnrichedRangePickerFieldProps");
+var import_releaseInfo = require("../../utils/releaseInfo");
+var import_useRangePosition = require("../useRangePosition");
+var releaseInfo = (0, import_releaseInfo.getReleaseInfo)();
+var useMobileRangePicker = ({
+  props,
+  ...pickerParams
+}) => {
+  var _a;
+  const {
+    slots,
+    slotProps: innerSlotProps,
+    className,
+    sx,
+    format,
+    formatDensity,
+    timezone,
+    label,
+    inputRef,
+    readOnly,
+    disabled,
+    disableOpenPicker,
+    localeText
+  } = props;
+  const { rangePosition, onRangePositionChange, singleInputFieldRef } = (0, import_useRangePosition.useRangePosition)(props);
+  const labelId = (0, import_useId.default)();
+  const contextLocaleText = (0, import_internals.useLocaleText)();
+  const {
+    open,
+    actions,
+    layoutProps,
+    renderCurrentView,
+    fieldProps: pickerFieldProps
+  } = (0, import_internals.usePicker)({
+    ...pickerParams,
+    props,
+    wrapperVariant: "mobile",
+    autoFocusView: true,
+    additionalViewProps: {
+      rangePosition,
+      onRangePositionChange
+    }
+  });
+  const Field = slots.field;
+  const fieldType = Field.fieldType ?? "multi-input";
+  const fieldProps = (0, import_utils.useSlotProps)({
+    elementType: Field,
+    externalSlotProps: innerSlotProps == null ? void 0 : innerSlotProps.field,
+    additionalProps: {
+      ...pickerFieldProps,
+      readOnly: readOnly ?? true,
+      disabled,
+      className,
+      sx,
+      format,
+      formatDensity,
+      timezone,
+      ...fieldType === "single-input" && { inputRef }
+    },
+    ownerState: props
+  });
+  const isToolbarHidden = ((_a = innerSlotProps == null ? void 0 : innerSlotProps.toolbar) == null ? void 0 : _a.hidden) ?? false;
+  const enrichedFieldProps = (0, import_useEnrichedRangePickerFieldProps.useEnrichedRangePickerFieldProps)({
+    wrapperVariant: "mobile",
+    fieldType,
+    open,
+    actions,
+    readOnly,
+    labelId,
+    disableOpenPicker,
+    label,
+    localeText,
+    rangePosition,
+    onRangePositionChange,
+    singleInputFieldRef,
+    pickerSlots: slots,
+    pickerSlotProps: innerSlotProps,
+    fieldProps
+  });
+  const slotPropsForLayout = {
+    ...innerSlotProps,
+    toolbar: {
+      ...innerSlotProps == null ? void 0 : innerSlotProps.toolbar,
+      titleId: labelId,
+      rangePosition,
+      onRangePositionChange
+    }
+  };
+  const Layout = (slots == null ? void 0 : slots.layout) ?? import_PickersLayout.PickersLayout;
+  const finalLocaleText = {
+    ...contextLocaleText,
+    ...localeText
+  };
+  let labelledById = labelId;
+  if (isToolbarHidden) {
+    const labels = [];
+    if (fieldType === "multi-input") {
+      if (finalLocaleText.start) {
+        labels.push(`${labelId}-start-label`);
+      }
+      if (finalLocaleText.end) {
+        labels.push(`${labelId}-end-label`);
+      }
+    } else if (label != null) {
+      labels.push(`${labelId}-label`);
+    }
+    labelledById = labels.length > 0 ? labels.join(" ") : void 0;
+  }
+  const slotProps = {
+    ...innerSlotProps,
+    mobilePaper: {
+      "aria-labelledby": labelledById,
+      ...innerSlotProps == null ? void 0 : innerSlotProps.mobilePaper
+    }
+  };
+  const renderPicker = () => /* @__PURE__ */ React.createElement(import_LocalizationProvider.LocalizationProvider, { localeText }, /* @__PURE__ */ React.createElement(Field, { ...enrichedFieldProps }), /* @__PURE__ */ React.createElement(import_internals.PickersModalDialog, { ...actions, open, slots, slotProps }, /* @__PURE__ */ React.createElement(
+    Layout,
+    {
+      ...layoutProps,
+      ...slotProps == null ? void 0 : slotProps.layout,
+      slots,
+      slotProps: slotPropsForLayout
+    },
+    renderCurrentView()
+  )));
+  return {
+    renderPicker
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMobileRangePicker
+});

package/lib/internals/hooks/useMobileRangePicker/useMobileRangePicker.types.d.ts

@@ -0,0 +1,31 @@
+import { UsePickerParams, BasePickerProps, PickersModalDialogSlotsComponent, PickersModalDialogSlotsComponentsProps, ExportedBaseToolbarProps, UsePickerViewsProps, UncapitalizeObjectKeys, BaseNonStaticPickerProps, UsePickerValueNonStaticProps, UsePickerViewsNonStaticProps } from '@mui/x-date-pickers/internals';
+import { ExportedPickersLayoutSlotsComponent, ExportedPickersLayoutSlotsComponentsProps } from '@mui/x-date-pickers/PickersLayout';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals/models';
+import { DateRange, RangeFieldSection, BaseRangeNonStaticPickerProps } from '../../models';
+import { UseRangePositionProps, UseRangePositionResponse } from '../useRangePosition';
+import { RangePickerFieldSlotsComponent, RangePickerFieldSlotsComponentsProps } from '../useEnrichedRangePickerFieldProps';
+export interface UseMobileRangePickerSlotsComponent<TDate, TView extends DateOrTimeViewWithMeridiem> extends PickersModalDialogSlotsComponent, ExportedPickersLayoutSlotsComponent<DateRange<TDate>, TDate, TView>, RangePickerFieldSlotsComponent {
+}
+export interface UseMobileRangePickerSlotsComponentsProps<TDate, TView extends DateOrTimeViewWithMeridiem> extends PickersModalDialogSlotsComponentsProps, ExportedPickersLayoutSlotsComponentsProps<DateRange<TDate>, TDate, TView>, RangePickerFieldSlotsComponentsProps<TDate> {
+    toolbar?: ExportedBaseToolbarProps;
+}
+export interface MobileRangeOnlyPickerProps<TDate> extends BaseNonStaticPickerProps, UsePickerValueNonStaticProps<TDate | null, RangeFieldSection>, UsePickerViewsNonStaticProps, BaseRangeNonStaticPickerProps, UseRangePositionProps {
+}
+export interface UseMobileRangePickerProps<TDate, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<any, TView, any, any>> extends MobileRangeOnlyPickerProps<TDate>, BasePickerProps<DateRange<TDate>, TDate, TView, TError, TExternalProps, MobileRangePickerAdditionalViewProps> {
+    /**
+     * Overridable component slots.
+     * @default {}
+     */
+    slots: UncapitalizeObjectKeys<UseMobileRangePickerSlotsComponent<TDate, TView>>;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     */
+    slotProps?: UseMobileRangePickerSlotsComponentsProps<TDate, TView>;
+}
+export interface MobileRangePickerAdditionalViewProps extends Pick<UseRangePositionResponse, 'rangePosition' | 'onRangePositionChange'> {
+}
+export interface UseMobileRangePickerParams<TDate, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseMobileRangePickerProps<TDate, TView, any, TExternalProps>> extends Pick<UsePickerParams<DateRange<TDate>, TDate, TView, RangeFieldSection, TExternalProps, MobileRangePickerAdditionalViewProps>, 'valueManager' | 'valueType' | 'validator'> {
+    props: TExternalProps;
+}
+//# sourceMappingURL=useMobileRangePicker.types.d.ts.map

package/lib/internals/hooks/useMobileRangePicker/useMobileRangePicker.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMobileRangePicker.types.d.ts","sourceRoot":"","sources":["useMobileRangePicker.types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,eAAe,EACf,gCAAgC,EAChC,sCAAsC,EACtC,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,mCAAmC,EACnC,yCAAyC,EAC1C,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAC3F,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EACL,8BAA8B,EAC9B,oCAAoC,EACrC,MAAM,qCAAqC,CAAC;AAE7C,MAAM,WAAW,kCAAkC,CAAC,KAAK,EAAE,KAAK,SAAS,0BAA0B,CACjG,SAAQ,gCAAgC,EACtC,mCAAmC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,EACnE,8BAA8B;CAAG;AAErC,MAAM,WAAW,wCAAwC,CACvD,KAAK,EACL,KAAK,SAAS,0BAA0B,CACxC,SAAQ,sCAAsC,EAC5C,yCAAyC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,EACzE,oCAAoC,CAAC,KAAK,CAAC;IAC7C,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACpC;AAED,MAAM,WAAW,0BAA0B,CAAC,KAAK,CAC/C,SAAQ,wBAAwB,EAC9B,4BAA4B,CAAC,KAAK,GAAG,IAAI,EAAE,iBAAiB,CAAC,EAC7D,4BAA4B,EAC5B,6BAA6B,EAC7B,qBAAqB;CAAG;AAE5B,MAAM,WAAW,yBAAyB,CACxC,KAAK,EACL,KAAK,SAAS,0BAA0B,EACxC,MAAM,EACN,cAAc,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CAChE,SAAQ,0BAA0B,CAAC,KAAK,CAAC,EACvC,eAAe,CACb,SAAS,CAAC,KAAK,CAAC,EAChB,KAAK,EACL,KAAK,EACL,MAAM,EACN,cAAc,EACd,oCAAoC,CACrC;IACH;;;OAGG;IACH,KAAK,EAAE,sBAAsB,CAAC,kCAAkC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IAChF;;;OAGG;IACH,SAAS,CAAC,EAAE,wCAAwC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,oCACf,SAAQ,IAAI,CAAC,wBAAwB,EAAE,eAAe,GAAG,uBAAuB,CAAC;CAAG;AAEtF,MAAM,WAAW,0BAA0B,CACzC,KAAK,EACL,KAAK,SAAS,0BAA0B,EACxC,cAAc,SAAS,yBAAyB,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,cAAc,CAAC,CACnF,SAAQ,IAAI,CACV,eAAe,CACb,SAAS,CAAC,KAAK,CAAC,EAChB,KAAK,EACL,KAAK,EACL,iBAAiB,EACjB,cAAc,EACd,oCAAoC,CACrC,EACD,cAAc,GAAG,WAAW,GAAG,WAAW,CAC3C;IACD,KAAK,EAAE,cAAc,CAAC;CACvB"}

package/lib/internals/hooks/useMobileRangePicker/useMobileRangePicker.types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internals/hooks/useMobileRangePicker/useMobileRangePicker.types.ts
+var useMobileRangePicker_types_exports = {};
+module.exports = __toCommonJS(useMobileRangePicker_types_exports);

package/lib/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.d.ts

@@ -0,0 +1,4 @@
+import { UseMultiInputDateRangeFieldParams } from '../../../MultiInputDateRangeField/MultiInputDateRangeField.types';
+import type { UseMultiInputRangeFieldResponse } from './useMultiInputRangeField.types';
+export declare const useMultiInputDateRangeField: <TDate, TTextFieldSlotProps extends {}>({ sharedProps: inSharedProps, startTextFieldProps, startInputRef, unstableStartFieldRef, endTextFieldProps, endInputRef, unstableEndFieldRef, }: UseMultiInputDateRangeFieldParams<TDate, TTextFieldSlotProps>) => UseMultiInputRangeFieldResponse<TTextFieldSlotProps>;
+//# sourceMappingURL=useMultiInputDateRangeField.d.ts.map

package/lib/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMultiInputDateRangeField.d.ts","sourceRoot":"","sources":["useMultiInputDateRangeField.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,iCAAiC,EAAE,MAAM,kEAAkE,CAAC;AAOrH,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AAGvF,eAAO,MAAM,2BAA2B,iTA+HvC,CAAC"}

package/lib/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.js

@@ -0,0 +1,142 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.ts
+var useMultiInputDateRangeField_exports = {};
+__export(useMultiInputDateRangeField_exports, {
+  useMultiInputDateRangeField: () => useMultiInputDateRangeField
+});
+module.exports = __toCommonJS(useMultiInputDateRangeField_exports);
+var import_useEventCallback = __toESM(require("@mui/utils/useEventCallback"));
+var import_DateField = require("@mui/x-date-pickers/DateField");
+var import_internals = require("@mui/x-date-pickers/internals");
+var import_useSingleInputDateRangeField = require("../../../SingleInputDateRangeField/useSingleInputDateRangeField");
+var import_validateDateRange = require("../../utils/validation/validateDateRange");
+var import_valueManagers = require("../../utils/valueManagers");
+var useMultiInputDateRangeField = ({
+  sharedProps: inSharedProps,
+  startTextFieldProps,
+  startInputRef,
+  unstableStartFieldRef,
+  endTextFieldProps,
+  endInputRef,
+  unstableEndFieldRef
+}) => {
+  const sharedProps = (0, import_useSingleInputDateRangeField.useDefaultizedDateRangeFieldProps)(
+    inSharedProps
+  );
+  const adapter = (0, import_internals.useLocalizationContext)();
+  const {
+    value: valueProp,
+    defaultValue,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    onChange,
+    disabled,
+    readOnly,
+    selectedSections,
+    onSelectedSectionsChange,
+    timezone: timezoneProp
+  } = sharedProps;
+  const { value, handleValueChange, timezone } = (0, import_internals.useControlledValueWithTimezone)({
+    name: "useMultiInputDateRangeField",
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    onChange,
+    valueManager: import_valueManagers.rangeValueManager
+  });
+  const buildChangeHandler = (index) => {
+    return (newDate, rawContext) => {
+      const newDateRange = index === 0 ? [newDate, value[1]] : [value[0], newDate];
+      const context = {
+        ...rawContext,
+        validationError: (0, import_validateDateRange.validateDateRange)({
+          adapter,
+          value: newDateRange,
+          props: { ...sharedProps, timezone }
+        })
+      };
+      handleValueChange(newDateRange, context);
+    };
+  };
+  const handleStartDateChange = (0, import_useEventCallback.default)(buildChangeHandler(0));
+  const handleEndDateChange = (0, import_useEventCallback.default)(buildChangeHandler(1));
+  const validationError = (0, import_internals.useValidation)(
+    { ...sharedProps, value, timezone },
+    import_validateDateRange.validateDateRange,
+    import_valueManagers.rangeValueManager.isSameError,
+    import_valueManagers.rangeValueManager.defaultErrorState
+  );
+  const startFieldProps = {
+    error: !!validationError[0],
+    ...startTextFieldProps,
+    disabled,
+    readOnly,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    timezone,
+    unstableFieldRef: unstableStartFieldRef,
+    value: valueProp === void 0 ? void 0 : valueProp[0],
+    defaultValue: defaultValue === void 0 ? void 0 : defaultValue[0],
+    onChange: handleStartDateChange,
+    selectedSections,
+    onSelectedSectionsChange
+  };
+  const endFieldProps = {
+    error: !!validationError[1],
+    ...endTextFieldProps,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    disabled,
+    readOnly,
+    timezone,
+    unstableFieldRef: unstableEndFieldRef,
+    value: valueProp === void 0 ? void 0 : valueProp[1],
+    defaultValue: defaultValue === void 0 ? void 0 : defaultValue[1],
+    onChange: handleEndDateChange,
+    selectedSections,
+    onSelectedSectionsChange
+  };
+  const startDateResponse = (0, import_DateField.unstable_useDateField)({
+    props: startFieldProps,
+    inputRef: startInputRef
+  });
+  const endDateResponse = (0, import_DateField.unstable_useDateField)({
+    props: endFieldProps,
+    inputRef: endInputRef
+  });
+  return { startDate: startDateResponse, endDate: endDateResponse };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMultiInputDateRangeField
+});