@tenancy.nz/datepicker 1.3.4

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickerFieldUI.cjs

@@ -0,0 +1,389 @@
+'use strict';
+
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var objectWithoutPropertiesLoose = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var React = require('react');
+var MuiTextField = require('@mui/material/TextField');
+var IconButton = require('@mui/material/IconButton');
+var MuiInputAdornment = require('@mui/material/InputAdornment');
+var version = require('@mui/material/version');
+var useFieldOwnerState = require('../hooks/useFieldOwnerState.cjs');
+var index = require('../../icons/index.cjs');
+var useNullablePickerContext = require('../hooks/useNullablePickerContext.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var useSlotProps = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.cjs');
+var usePickerTranslations = require('../../hooks/usePickerTranslations.cjs');
+var useEventCallback = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.cjs');
+var PickersTextField = require('../../PickersTextField/PickersTextField.cjs');
+var useForkRef = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useForkRef/useForkRef.cjs');
+var resolveComponentProps = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/resolveComponentProps/resolveComponentProps.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const _excluded = ["enableAccessibleFieldDOMStructure"],
+  _excluded2 = ["InputProps", "readOnly", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
+  _excluded3 = ["onPaste", "onKeyDown", "inputMode", "readOnly", "InputProps", "inputProps", "inputRef", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
+  _excluded4 = ["ownerState"],
+  _excluded5 = ["ownerState"],
+  _excluded6 = ["ownerState"],
+  _excluded7 = ["ownerState"],
+  _excluded8 = ["InputProps", "inputProps"];
+const noop = () => {};
+const cleanFieldResponse = _ref => {
+  let {
+      enableAccessibleFieldDOMStructure
+    } = _ref,
+    fieldResponse = objectWithoutPropertiesLoose.default(_ref, _excluded);
+  if (enableAccessibleFieldDOMStructure) {
+    const {
+        InputProps,
+        readOnly,
+        onClear,
+        clearable,
+        clearButtonPosition,
+        openPickerButtonPosition,
+        openPickerAriaLabel
+      } = fieldResponse,
+      other = objectWithoutPropertiesLoose.default(fieldResponse, _excluded2);
+    const mergedInputProps = version.major >= 6 && other?.slotProps?.input ? mergeSlotProps(other?.slotProps?.input, InputProps) : noop;
+    return {
+      clearable,
+      onClear,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel,
+      textFieldProps: _extends.default({}, other, version.major >= 6 && other?.slotProps?.input ? {
+        slotProps: _extends.default({}, other?.slotProps, {
+          input: ownerState => _extends.default({}, resolveComponentProps.default(mergedInputProps, ownerState), {
+            readOnly
+          })
+        })
+      } : {
+        InputProps: _extends.default({}, InputProps ?? {}, {
+          readOnly
+        })
+      })
+    };
+  }
+  const {
+      onPaste,
+      onKeyDown,
+      inputMode,
+      readOnly,
+      InputProps,
+      inputProps,
+      inputRef,
+      onClear,
+      clearable,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel
+    } = fieldResponse,
+    other = objectWithoutPropertiesLoose.default(fieldResponse, _excluded3);
+  const mergedInputProps = version.major >= 6 && other?.slotProps?.input ? mergeSlotProps(other?.slotProps?.input, InputProps) : noop;
+  const mergedHtmlInputProps = version.major >= 6 && other?.slotProps?.htmlInput ? mergeSlotProps(other?.slotProps?.htmlInput, inputProps) : noop;
+  return {
+    clearable,
+    onClear,
+    clearButtonPosition,
+    openPickerButtonPosition,
+    openPickerAriaLabel,
+    textFieldProps: _extends.default({}, other, version.major >= 6 && (other?.slotProps?.input || other?.slotProps?.htmlInput) ? {
+      slotProps: _extends.default({}, other?.slotProps, {
+        input: ownerState => _extends.default({}, resolveComponentProps.default(mergedInputProps, ownerState), {
+          readOnly
+        }),
+        htmlInput: ownerState => _extends.default({}, resolveComponentProps.default(mergedHtmlInputProps, ownerState), {
+          inputMode,
+          onPaste,
+          onKeyDown,
+          ref: inputRef
+        })
+      })
+    } : {
+      InputProps: _extends.default({}, InputProps ?? {}, {
+        readOnly
+      }),
+      inputProps: _extends.default({}, inputProps ?? {}, {
+        inputMode,
+        onPaste,
+        onKeyDown,
+        ref: inputRef
+      })
+    })
+  };
+};
+const PickerFieldUIContext = /*#__PURE__*/React__namespace.createContext({
+  slots: {},
+  slotProps: {},
+  inputRef: undefined
+});
+
+/**
+ * Adds the button to open the Picker and the button to clear the value of the field.
+ * @ignore - internal component.
+ */
+if (process.env.NODE_ENV !== "production") PickerFieldUIContext.displayName = "PickerFieldUIContext";
+function PickerFieldUI(props) {
+  const {
+    fieldResponse,
+    defaultOpenPickerIcon
+  } = props;
+  const translations = usePickerTranslations.usePickerTranslations();
+  const pickerContext = useNullablePickerContext.useNullablePickerContext();
+  const pickerFieldUIContext = React__namespace.useContext(PickerFieldUIContext);
+  const {
+    textFieldProps,
+    onClear,
+    clearable,
+    openPickerAriaLabel,
+    clearButtonPosition: clearButtonPositionProp = 'end',
+    openPickerButtonPosition: openPickerButtonPositionProp = 'end'
+  } = cleanFieldResponse(fieldResponse);
+  const ownerState = useFieldOwnerState.useFieldOwnerState(textFieldProps);
+  const handleClickOpeningButton = useEventCallback.default(event => {
+    event.preventDefault();
+    pickerContext?.setOpen(prev => !prev);
+  });
+  const triggerStatus = pickerContext ? pickerContext.triggerStatus : 'hidden';
+  const clearButtonPosition = clearable ? clearButtonPositionProp : null;
+  const openPickerButtonPosition = triggerStatus !== 'hidden' ? openPickerButtonPositionProp : null;
+  const TextField = pickerFieldUIContext.slots.textField ?? (fieldResponse.enableAccessibleFieldDOMStructure === false ? MuiTextField : PickersTextField.PickersTextField);
+  const InputAdornment = pickerFieldUIContext.slots.inputAdornment ?? MuiInputAdornment;
+  const _useSlotProps = useSlotProps.default({
+      elementType: InputAdornment,
+      externalSlotProps: pickerFieldUIContext.slotProps.inputAdornment,
+      additionalProps: {
+        position: 'start'
+      },
+      ownerState: _extends.default({}, ownerState, {
+        position: 'start'
+      })
+    }),
+    startInputAdornmentProps = objectWithoutPropertiesLoose.default(_useSlotProps, _excluded4);
+  const _useSlotProps2 = useSlotProps.default({
+      elementType: InputAdornment,
+      externalSlotProps: pickerFieldUIContext.slotProps.inputAdornment,
+      additionalProps: {
+        position: 'end'
+      },
+      ownerState: _extends.default({}, ownerState, {
+        position: 'end'
+      })
+    }),
+    endInputAdornmentProps = objectWithoutPropertiesLoose.default(_useSlotProps2, _excluded5);
+  const OpenPickerButton = pickerFieldUIContext.slots.openPickerButton ?? IconButton;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps3 = useSlotProps.default({
+      elementType: OpenPickerButton,
+      externalSlotProps: pickerFieldUIContext.slotProps.openPickerButton,
+      additionalProps: {
+        disabled: triggerStatus === 'disabled',
+        onClick: handleClickOpeningButton,
+        'aria-label': openPickerAriaLabel,
+        edge:
+        // open button is always rendered at the edge
+        textFieldProps.variant !== 'standard' ? openPickerButtonPosition : false
+      },
+      ownerState
+    }),
+    openPickerButtonProps = objectWithoutPropertiesLoose.default(_useSlotProps3, _excluded6);
+  const OpenPickerIcon = pickerFieldUIContext.slots.openPickerIcon ?? defaultOpenPickerIcon;
+  const openPickerIconProps = useSlotProps.default({
+    elementType: OpenPickerIcon,
+    externalSlotProps: pickerFieldUIContext.slotProps.openPickerIcon,
+    ownerState
+  });
+  const ClearButton = pickerFieldUIContext.slots.clearButton ?? IconButton;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps4 = useSlotProps.default({
+      elementType: ClearButton,
+      externalSlotProps: pickerFieldUIContext.slotProps.clearButton,
+      className: 'clearButton',
+      additionalProps: {
+        title: translations.fieldClearLabel,
+        tabIndex: -1,
+        onClick: onClear,
+        disabled: fieldResponse.disabled || fieldResponse.readOnly,
+        edge:
+        // clear button can only be at the edge if it's position differs from the open button
+        textFieldProps.variant !== 'standard' && clearButtonPosition !== openPickerButtonPosition ? clearButtonPosition : false
+      },
+      ownerState
+    }),
+    clearButtonProps = objectWithoutPropertiesLoose.default(_useSlotProps4, _excluded7);
+  const ClearIcon = pickerFieldUIContext.slots.clearIcon ?? index.ClearIcon;
+  const clearIconProps = useSlotProps.default({
+    elementType: ClearIcon,
+    externalSlotProps: pickerFieldUIContext.slotProps.clearIcon,
+    additionalProps: {
+      fontSize: 'small'
+    },
+    ownerState
+  });
+  textFieldProps.ref = useForkRef.default(textFieldProps.ref, pickerContext?.rootRef);
+  const additionalTextFieldInputProps = {};
+  const textFieldInputProps = resolveComponentProps.default((version.major >= 6 && textFieldProps?.slotProps?.input) ?? textFieldProps.InputProps, ownerState);
+  if (pickerContext) {
+    additionalTextFieldInputProps.ref = pickerContext.triggerRef;
+  }
+  if (!textFieldInputProps?.startAdornment && (clearButtonPosition === 'start' || openPickerButtonPosition === 'start')) {
+    additionalTextFieldInputProps.startAdornment = /*#__PURE__*/jsxRuntime.jsxs(InputAdornment, _extends.default({}, startInputAdornmentProps, {
+      children: [openPickerButtonPosition === 'start' && /*#__PURE__*/jsxRuntime.jsx(OpenPickerButton, _extends.default({}, openPickerButtonProps, {
+        children: /*#__PURE__*/jsxRuntime.jsx(OpenPickerIcon, _extends.default({}, openPickerIconProps))
+      })), clearButtonPosition === 'start' && /*#__PURE__*/jsxRuntime.jsx(ClearButton, _extends.default({}, clearButtonProps, {
+        children: /*#__PURE__*/jsxRuntime.jsx(ClearIcon, _extends.default({}, clearIconProps))
+      }))]
+    }));
+  }
+  if (!textFieldInputProps?.endAdornment && (clearButtonPosition === 'end' || openPickerButtonPosition === 'end')) {
+    additionalTextFieldInputProps.endAdornment = /*#__PURE__*/jsxRuntime.jsxs(InputAdornment, _extends.default({}, endInputAdornmentProps, {
+      children: [clearButtonPosition === 'end' && /*#__PURE__*/jsxRuntime.jsx(ClearButton, _extends.default({}, clearButtonProps, {
+        children: /*#__PURE__*/jsxRuntime.jsx(ClearIcon, _extends.default({}, clearIconProps))
+      })), openPickerButtonPosition === 'end' && /*#__PURE__*/jsxRuntime.jsx(OpenPickerButton, _extends.default({}, openPickerButtonProps, {
+        children: /*#__PURE__*/jsxRuntime.jsx(OpenPickerIcon, _extends.default({}, openPickerIconProps))
+      }))]
+    }));
+  }
+  // handle the case of showing custom `inputAdornment` for Field components
+  if (!additionalTextFieldInputProps?.endAdornment && !additionalTextFieldInputProps?.startAdornment && pickerFieldUIContext.slots.inputAdornment) {
+    additionalTextFieldInputProps.endAdornment = /*#__PURE__*/jsxRuntime.jsx(InputAdornment, _extends.default({}, endInputAdornmentProps));
+  }
+  if (clearButtonPosition != null) {
+    textFieldProps.sx = [{
+      '& .clearButton': {
+        opacity: 1
+      },
+      '@media (pointer: fine)': {
+        '& .clearButton': {
+          opacity: 0
+        },
+        '&:hover, &:focus-within': {
+          '.clearButton': {
+            opacity: 1
+          }
+        }
+      }
+    }, ...(Array.isArray(textFieldProps.sx) ? textFieldProps.sx : [textFieldProps.sx])];
+  }
+  const resolvedTextFieldInputProps = version.major >= 6 && textFieldProps?.slotProps?.input ? resolveComponentProps.default(mergeSlotProps(textFieldInputProps, additionalTextFieldInputProps), ownerState) : _extends.default({}, textFieldInputProps, additionalTextFieldInputProps);
+
+  // We need to resolve the `inputProps` since we are messing with those props in this component.
+  textFieldProps.inputProps = version.major >= 6 && textFieldProps?.slotProps?.htmlInput ? resolveComponentProps.default(textFieldProps.slotProps.htmlInput, ownerState) : textFieldProps.inputProps;
+
+  // Remove the `input` slotProps to avoid them overriding the manually resolved `InputProps`.
+  // Relevant on `materialMajor >= 6` since `slotProps` would take precedence.
+  delete textFieldProps?.slotProps?.input;
+  if (fieldResponse.enableAccessibleFieldDOMStructure) {
+    // Remove the `slotProps` on `PickersTextField` as they are not supported.
+    delete textFieldProps?.slotProps;
+  }
+  return /*#__PURE__*/jsxRuntime.jsx(TextField, _extends.default({}, textFieldProps, {
+    InputProps: resolvedTextFieldInputProps
+  }));
+}
+function mergeSlotProps(slotPropsA, slotPropsB) {
+  if (!slotPropsA) {
+    return slotPropsB;
+  }
+  if (!slotPropsB) {
+    return slotPropsA;
+  }
+  return ownerState => {
+    return _extends.default({}, resolveComponentProps.default(slotPropsB, ownerState), resolveComponentProps.default(slotPropsA, ownerState));
+  };
+}
+
+/**
+ * The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
+ * Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
+ */
+function useFieldTextFieldProps(parameters) {
+  const {
+    ref,
+    externalForwardedProps,
+    slotProps
+  } = parameters;
+  const pickerFieldUIContext = React__namespace.useContext(PickerFieldUIContext);
+  const pickerContext = useNullablePickerContext.useNullablePickerContext();
+  const ownerState = useFieldOwnerState.useFieldOwnerState(externalForwardedProps);
+  const {
+      InputProps,
+      inputProps
+    } = externalForwardedProps,
+    otherExternalForwardedProps = objectWithoutPropertiesLoose.default(externalForwardedProps, _excluded8);
+  const textFieldProps = useSlotProps.default({
+    elementType: PickersTextField.PickersTextField,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.textField, slotProps?.textField),
+    externalForwardedProps: otherExternalForwardedProps,
+    additionalProps: {
+      ref,
+      sx: pickerContext?.rootSx,
+      label: pickerContext?.label,
+      name: pickerContext?.name,
+      className: pickerContext?.rootClassName,
+      inputRef: pickerFieldUIContext.inputRef
+    },
+    ownerState
+  });
+
+  // TODO: Remove when mui/material-ui#35088 will be merged
+  textFieldProps.inputProps = _extends.default({}, inputProps, textFieldProps.inputProps);
+  textFieldProps.InputProps = _extends.default({}, InputProps, textFieldProps.InputProps);
+  return textFieldProps;
+}
+function PickerFieldUIContextProvider(props) {
+  const {
+    slots = {},
+    slotProps = {},
+    inputRef,
+    children
+  } = props;
+  const contextValue = React__namespace.useMemo(() => ({
+    inputRef,
+    slots: {
+      openPickerButton: slots.openPickerButton,
+      openPickerIcon: slots.openPickerIcon,
+      textField: slots.textField,
+      inputAdornment: slots.inputAdornment,
+      clearIcon: slots.clearIcon,
+      clearButton: slots.clearButton
+    },
+    slotProps: {
+      openPickerButton: slotProps.openPickerButton,
+      openPickerIcon: slotProps.openPickerIcon,
+      textField: slotProps.textField,
+      inputAdornment: slotProps.inputAdornment,
+      clearIcon: slotProps.clearIcon,
+      clearButton: slotProps.clearButton
+    }
+  }), [inputRef, slots.openPickerButton, slots.openPickerIcon, slots.textField, slots.inputAdornment, slots.clearIcon, slots.clearButton, slotProps.openPickerButton, slotProps.openPickerIcon, slotProps.textField, slotProps.inputAdornment, slotProps.clearIcon, slotProps.clearButton]);
+  return /*#__PURE__*/jsxRuntime.jsx(PickerFieldUIContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}
+
+exports.PickerFieldUI = PickerFieldUI;
+exports.PickerFieldUIContext = PickerFieldUIContext;
+exports.PickerFieldUIContextProvider = PickerFieldUIContextProvider;
+exports.cleanFieldResponse = cleanFieldResponse;
+exports.mergeSlotProps = mergeSlotProps;
+exports.useFieldTextFieldProps = useFieldTextFieldProps;