@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/hooks/usePicker/hooks/useValueAndOpenStates.cjs

@@ -0,0 +1,228 @@
+'use strict';
+
+var _extends = require('../../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var useControlledValue = require('../../useControlledValue.cjs');
+var usePickerAdapter = require('../../../../hooks/usePickerAdapter.cjs');
+var warning = require('../../../../../../../../../@mui_x-internals@8.26.0_@types_react@19.1.9_react@18.3.1/node_modules/@mui/x-internals/esm/warning/warning.cjs');
+var useValidation = require('../../../../validation/useValidation.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');
+
+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);
+
+function useValueAndOpenStates(parameters) {
+  const {
+    props,
+    valueManager,
+    validator
+  } = parameters;
+  const {
+    value: valueProp,
+    defaultValue: defaultValueProp,
+    onChange,
+    referenceDate,
+    timezone: timezoneProp,
+    onAccept,
+    closeOnSelect,
+    open: openProp,
+    onOpen,
+    onClose
+  } = props;
+  const {
+    current: defaultValue
+  } = React__namespace.useRef(defaultValueProp);
+  const {
+    current: isValueControlled
+  } = React__namespace.useRef(valueProp !== undefined);
+  const {
+    current: isOpenControlled
+  } = React__namespace.useRef(openProp !== undefined);
+  const adapter = usePickerAdapter.usePickerAdapter();
+  if (process.env.NODE_ENV !== 'production') {
+    if (props.renderInput != null) {
+      warning.warnOnce(['MUI X: The `renderInput` prop has been removed in version 6.0 of the Date and Time Pickers.', 'You can replace it with the `textField` component slot in most cases.', 'For more information, please have a look at the migration guide (https://mui.com/x/migration/migration-pickers-v5/#input-renderer-required-in-v5).']);
+    }
+  }
+
+  /* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
+  if (process.env.NODE_ENV !== 'production') {
+    React__namespace.useEffect(() => {
+      if (isValueControlled !== (valueProp !== undefined)) {
+        console.error([`MUI X: A component is changing the ${isValueControlled ? '' : 'un'}controlled value of a Picker to be ${isValueControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled value` + 'for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
+      }
+    }, [valueProp]);
+    React__namespace.useEffect(() => {
+      if (!isValueControlled && defaultValue !== defaultValueProp) {
+        console.error([`MUI X: A component is changing the defaultValue of an uncontrolled Picker after being initialized. ` + `To suppress this warning opt to use a controlled value.`].join('\n'));
+      }
+    }, [JSON.stringify(defaultValue)]);
+  }
+  /* eslint-enable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
+
+  const {
+    timezone,
+    value,
+    handleValueChange
+  } = useControlledValue.useControlledValue({
+    name: 'a picker component',
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    referenceDate,
+    onChange,
+    valueManager
+  });
+  const [state, setState] = React__namespace.useState(() => ({
+    open: false,
+    lastExternalValue: value,
+    clockShallowValue: undefined,
+    lastCommittedValue: value,
+    hasBeenModifiedSinceMount: false
+  }));
+  const {
+    getValidationErrorForNewValue
+  } = useValidation.useValidation({
+    props,
+    validator,
+    timezone,
+    value,
+    onError: props.onError
+  });
+  const setOpen = useEventCallback.default(action => {
+    const newOpen = typeof action === 'function' ? action(state.open) : action;
+    if (!isOpenControlled) {
+      setState(prevState => _extends.default({}, prevState, {
+        open: newOpen
+      }));
+    }
+    if (newOpen && onOpen) {
+      onOpen();
+    }
+    if (!newOpen) {
+      onClose?.();
+    }
+  });
+  const setValue = useEventCallback.default((newValue, options) => {
+    const {
+      changeImportance = 'accept',
+      skipPublicationIfPristine = false,
+      validationError,
+      shortcut,
+      source,
+      shouldClose = changeImportance === 'accept'
+    } = options ?? {};
+    let shouldFireOnChange;
+    let shouldFireOnAccept;
+    if (!skipPublicationIfPristine && !isValueControlled && !state.hasBeenModifiedSinceMount) {
+      // If the value is not controlled and the value has never been modified before,
+      // Then clicking on any value (including the one equal to `defaultValue`) should call `onChange` and `onAccept`
+      shouldFireOnChange = true;
+      shouldFireOnAccept = changeImportance === 'accept';
+    } else {
+      shouldFireOnChange = !valueManager.areValuesEqual(adapter, newValue, value);
+      shouldFireOnAccept = changeImportance === 'accept' && !valueManager.areValuesEqual(adapter, newValue, state.lastCommittedValue);
+    }
+    setState(prevState => _extends.default({}, prevState, {
+      // We reset the shallow value whenever we fire onChange.
+      clockShallowValue: shouldFireOnChange ? undefined : prevState.clockShallowValue,
+      lastCommittedValue: shouldFireOnAccept ? newValue : prevState.lastCommittedValue,
+      hasBeenModifiedSinceMount: true
+    }));
+    let cachedContext = null;
+    const getContext = () => {
+      if (!cachedContext) {
+        let inferredSource;
+        if (source) {
+          inferredSource = source;
+        } else if (shortcut) {
+          inferredSource = 'view';
+        } else {
+          // Default to unknown when not explicitly tagged by a picker call site
+          inferredSource = 'unknown';
+        }
+        cachedContext = {
+          validationError: validationError == null ? getValidationErrorForNewValue(newValue) : validationError,
+          source: inferredSource
+        };
+        if (shortcut) {
+          cachedContext.shortcut = shortcut;
+        }
+      }
+      return cachedContext;
+    };
+    if (shouldFireOnChange) {
+      handleValueChange(newValue, getContext());
+    }
+    if (shouldFireOnAccept && onAccept) {
+      onAccept(newValue, getContext());
+    }
+    if (shouldClose) {
+      setOpen(false);
+    }
+  });
+
+  // If `prop.value` changes, we update the state to reflect the new value
+  if (value !== state.lastExternalValue) {
+    setState(prevState => _extends.default({}, prevState, {
+      lastExternalValue: value,
+      clockShallowValue: undefined,
+      hasBeenModifiedSinceMount: true
+    }));
+  }
+  const setValueFromView = useEventCallback.default((newValue, selectionState = 'partial') => {
+    // TODO: Expose a new method (private?) like `setView` that only updates the clock shallow value.
+    if (selectionState === 'shallow') {
+      setState(prev => _extends.default({}, prev, {
+        clockShallowValue: newValue,
+        hasBeenModifiedSinceMount: true
+      }));
+      return;
+    }
+    setValue(newValue, {
+      changeImportance: selectionState === 'finish' && closeOnSelect ? 'accept' : 'set',
+      source: 'view'
+    });
+  });
+
+  // It is required to update inner state in useEffect in order to avoid situation when
+  // Our component is not mounted yet, but `open` state is set to `true` (for example initially opened)
+  React__namespace.useEffect(() => {
+    if (isOpenControlled) {
+      if (openProp === undefined) {
+        throw new Error('You must not mix controlling and uncontrolled mode for `open` prop');
+      }
+      setState(prevState => _extends.default({}, prevState, {
+        open: openProp
+      }));
+    }
+  }, [isOpenControlled, openProp]);
+  const viewValue = React__namespace.useMemo(() => valueManager.cleanValue(adapter, state.clockShallowValue === undefined ? value : state.clockShallowValue), [adapter, valueManager, state.clockShallowValue, value]);
+  return {
+    timezone,
+    state,
+    setValue,
+    setValueFromView,
+    setOpen,
+    value,
+    viewValue
+  };
+}
+
+exports.useValueAndOpenStates = useValueAndOpenStates;

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/hooks/usePicker/usePicker.cjs

@@ -0,0 +1,345 @@
+'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 usePickerAdapter = require('../../../hooks/usePickerAdapter.cjs');
+var useReduceAnimations = require('../useReduceAnimations.cjs');
+var timeUtils = require('../../utils/time-utils.cjs');
+var useViews = require('../useViews.cjs');
+var useOrientation = require('./hooks/useOrientation.cjs');
+var useValueAndOpenStates = require('./hooks/useValueAndOpenStates.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var useId = require('../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useId/useId.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 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 useEnhancedEffect = require('../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.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 = ["className", "sx"];
+const usePicker = ({
+  ref,
+  props,
+  valueManager,
+  valueType,
+  variant,
+  validator,
+  onPopperExited,
+  autoFocusView,
+  rendererInterceptor: RendererInterceptor,
+  localeText,
+  viewContainerRole,
+  getStepNavigation
+}) => {
+  const {
+    // View props
+    views,
+    view: viewProp,
+    openTo,
+    onViewChange,
+    viewRenderers,
+    reduceAnimations: reduceAnimationsProp,
+    orientation: orientationProp,
+    disableOpenPicker,
+    closeOnSelect,
+    // Form props
+    disabled,
+    readOnly,
+    // Field props
+    formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
+    format,
+    label,
+    // Other props
+    autoFocus,
+    name
+  } = props;
+  const {
+      className,
+      sx
+    } = props,
+    propsToForwardToView = objectWithoutPropertiesLoose.default(props, _excluded);
+
+  /**
+   * TODO: Improve how we generate the aria-label and aria-labelledby attributes.
+   */
+  const labelId = useId.default();
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const reduceAnimations = useReduceAnimations.useReduceAnimations(reduceAnimationsProp);
+  const orientation = useOrientation.useOrientation(views, orientationProp);
+  const {
+    current: initialView
+  } = React__namespace.useRef(openTo ?? null);
+
+  /**
+   * Refs
+   */
+  const [triggerElement, triggerRef] = React__namespace.useState(null);
+  const popupRef = React__namespace.useRef(null);
+  const fieldRef = React__namespace.useRef(null);
+  const rootRefObject = React__namespace.useRef(null);
+  const rootRef = useForkRef.default(ref, rootRefObject);
+  const {
+    timezone,
+    state,
+    setOpen,
+    setValue,
+    setValueFromView,
+    value,
+    viewValue
+  } = useValueAndOpenStates.useValueAndOpenStates({
+    props,
+    valueManager,
+    validator
+  });
+  const {
+    view,
+    setView,
+    defaultView,
+    focusedView,
+    setFocusedView,
+    setValueAndGoToNextView,
+    goToNextStep,
+    hasNextStep,
+    hasSeveralSteps
+  } = useViews.useViews({
+    view: viewProp,
+    views,
+    openTo,
+    onChange: setValueFromView,
+    onViewChange,
+    autoFocus: autoFocusView,
+    getStepNavigation
+  });
+  const clearValue = useEventCallback.default(() => setValue(valueManager.emptyValue, {
+    source: 'view'
+  }));
+  const setValueToToday = useEventCallback.default(() => setValue(valueManager.getTodayValue(adapter, timezone, valueType), {
+    source: 'view'
+  }));
+  const acceptValueChanges = useEventCallback.default(() => setValue(value, {
+    source: 'view'
+  }));
+  const cancelValueChanges = useEventCallback.default(() => setValue(state.lastCommittedValue, {
+    skipPublicationIfPristine: true,
+    source: 'view'
+  }));
+  const dismissViews = useEventCallback.default(() => {
+    setValue(value, {
+      skipPublicationIfPristine: true,
+      source: 'view'
+    });
+  });
+  const {
+    hasUIView,
+    viewModeLookup,
+    timeViewsCount
+  } = React__namespace.useMemo(() => views.reduce((acc, viewForReduce) => {
+    const viewMode = viewRenderers[viewForReduce] == null ? 'field' : 'UI';
+    acc.viewModeLookup[viewForReduce] = viewMode;
+    if (viewMode === 'UI') {
+      acc.hasUIView = true;
+      if (timeUtils.isTimeView(viewForReduce)) {
+        acc.timeViewsCount += 1;
+      }
+    }
+    return acc;
+  }, {
+    hasUIView: false,
+    viewModeLookup: {},
+    timeViewsCount: 0
+  }), [viewRenderers, views]);
+  const currentViewMode = viewModeLookup[view];
+  const getCurrentViewMode = useEventCallback.default(() => currentViewMode);
+  const [popperView, setPopperView] = React__namespace.useState(currentViewMode === 'UI' ? view : null);
+  if (popperView !== view && viewModeLookup[view] === 'UI') {
+    setPopperView(view);
+  }
+  useEnhancedEffect.default(() => {
+    // Handle case of Date Time Picker without time renderers
+    if (currentViewMode === 'field' && state.open) {
+      setOpen(false);
+      setTimeout(() => {
+        fieldRef?.current?.setSelectedSections(view);
+        // focusing the input before the range selection is done
+        // calling it outside of timeout results in an inconsistent behavior between Safari And Chrome
+        fieldRef?.current?.focusField(view);
+      });
+    }
+  }, [view]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEnhancedEffect.default(() => {
+    if (!state.open) {
+      return;
+    }
+    let newView = view;
+
+    // If the current view is a field view, go to the last popper view
+    if (currentViewMode === 'field' && popperView != null) {
+      newView = popperView;
+    }
+
+    // If the current view is not the default view and both are UI views
+    if (newView !== defaultView && viewModeLookup[newView] === 'UI' && viewModeLookup[defaultView] === 'UI') {
+      newView = defaultView;
+    }
+    if (newView !== view) {
+      setView(newView);
+    }
+    setFocusedView(newView, true);
+  }, [state.open]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const ownerState = React__namespace.useMemo(() => ({
+    isPickerValueEmpty: valueManager.areValuesEqual(adapter, value, valueManager.emptyValue),
+    isPickerOpen: state.open,
+    isPickerDisabled: props.disabled ?? false,
+    isPickerReadOnly: props.readOnly ?? false,
+    pickerOrientation: orientation,
+    pickerVariant: variant
+  }), [adapter, valueManager, value, state.open, orientation, variant, props.disabled, props.readOnly]);
+  const triggerStatus = React__namespace.useMemo(() => {
+    if (disableOpenPicker || !hasUIView) {
+      return 'hidden';
+    }
+    if (disabled || readOnly) {
+      return 'disabled';
+    }
+    return 'enabled';
+  }, [disableOpenPicker, hasUIView, disabled, readOnly]);
+  const wrappedGoToNextStep = useEventCallback.default(goToNextStep);
+  const defaultActionBarActions = React__namespace.useMemo(() => {
+    if (closeOnSelect && !hasSeveralSteps) {
+      return [];
+    }
+    return ['cancel', 'nextOrAccept'];
+  }, [closeOnSelect, hasSeveralSteps]);
+  const actionsContextValue = React__namespace.useMemo(() => ({
+    setValue,
+    setOpen,
+    clearValue,
+    setValueToToday,
+    acceptValueChanges,
+    cancelValueChanges,
+    setView,
+    goToNextStep: wrappedGoToNextStep
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges, setView, wrappedGoToNextStep]);
+  const contextValue = React__namespace.useMemo(() => _extends.default({}, actionsContextValue, {
+    value,
+    timezone,
+    open: state.open,
+    views,
+    view: popperView,
+    initialView,
+    disabled: disabled ?? false,
+    readOnly: readOnly ?? false,
+    autoFocus: autoFocus ?? false,
+    variant,
+    orientation,
+    popupRef,
+    reduceAnimations,
+    triggerRef,
+    triggerStatus,
+    hasNextStep,
+    fieldFormat: format ?? '',
+    name,
+    label,
+    rootSx: sx,
+    rootRef,
+    rootClassName: className
+  }), [actionsContextValue, value, rootRef, variant, orientation, reduceAnimations, disabled, readOnly, format, className, name, label, sx, triggerStatus, hasNextStep, timezone, state.open, popperView, views, initialView, autoFocus]);
+  const privateContextValue = React__namespace.useMemo(() => ({
+    dismissViews,
+    ownerState,
+    hasUIView,
+    getCurrentViewMode,
+    rootRefObject,
+    labelId,
+    triggerElement,
+    viewContainerRole,
+    defaultActionBarActions,
+    onPopperExited
+  }), [dismissViews, ownerState, hasUIView, getCurrentViewMode, labelId, triggerElement, viewContainerRole, defaultActionBarActions, onPopperExited]);
+  const fieldPrivateContextValue = React__namespace.useMemo(() => ({
+    formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
+    fieldRef
+  }), [formatDensity, enableAccessibleFieldDOMStructure, selectedSections, onSelectedSectionsChange, fieldRef]);
+  const isValidContextValue = testedValue => {
+    const error = validator({
+      adapter,
+      value: testedValue,
+      timezone,
+      props
+    });
+    return !valueManager.hasError(error);
+  };
+  const renderCurrentView = () => {
+    if (popperView == null) {
+      return null;
+    }
+    const renderer = viewRenderers[popperView];
+    if (renderer == null) {
+      return null;
+    }
+    const rendererProps = _extends.default({}, propsToForwardToView, {
+      views,
+      timezone,
+      value: viewValue,
+      onChange: setValueAndGoToNextView,
+      view: popperView,
+      onViewChange: setView,
+      showViewSwitcher: timeViewsCount > 1,
+      timeViewsCount
+    }, viewContainerRole === 'tooltip' ? {
+      focusedView: null,
+      onFocusedViewChange: () => {}
+    } : {
+      focusedView,
+      onFocusedViewChange: setFocusedView
+    });
+    if (RendererInterceptor) {
+      return /*#__PURE__*/jsxRuntime.jsx(RendererInterceptor, {
+        viewRenderers: viewRenderers,
+        popperView: popperView,
+        rendererProps: rendererProps
+      });
+    }
+    return renderer(rendererProps);
+  };
+  return {
+    providerProps: {
+      localeText,
+      contextValue,
+      privateContextValue,
+      actionsContextValue,
+      fieldPrivateContextValue,
+      isValidContextValue
+    },
+    renderCurrentView,
+    ownerState
+  };
+};
+
+exports.usePicker = usePicker;

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/hooks/usePickerPrivateContext.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var React = require('react');
+var PickerProvider = require('../components/PickerProvider.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);
+
+/**
+ * Returns the private context passed by the Picker wrapping the current component.
+ */
+const usePickerPrivateContext = () => React__namespace.useContext(PickerProvider.PickerPrivateContext);
+
+exports.usePickerPrivateContext = usePickerPrivateContext;

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/hooks/useReduceAnimations.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var useMediaQuery = require('@mui/material/useMediaQuery');
+
+const PREFERS_REDUCED_MOTION = '@media (prefers-reduced-motion: reduce)';
+
+// detect if user agent has Android version < 10 or iOS version < 13
+const mobileVersionMatches = typeof navigator !== 'undefined' && navigator.userAgent.match(/android\s(\d+)|OS\s(\d+)/i);
+const androidVersion = mobileVersionMatches && mobileVersionMatches[1] ? parseInt(mobileVersionMatches[1], 10) : null;
+const iOSVersion = mobileVersionMatches && mobileVersionMatches[2] ? parseInt(mobileVersionMatches[2], 10) : null;
+const slowAnimationDevices = androidVersion && androidVersion < 10 || iOSVersion && iOSVersion < 13 || false;
+function useReduceAnimations(customReduceAnimations) {
+  const prefersReduced = useMediaQuery(PREFERS_REDUCED_MOTION, {
+    defaultMatches: false
+  });
+  if (customReduceAnimations != null) {
+    return customReduceAnimations;
+  }
+  return prefersReduced || slowAnimationDevices;
+}
+
+exports.slowAnimationDevices = slowAnimationDevices;
+exports.useReduceAnimations = useReduceAnimations;

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/hooks/useToolbarOwnerState.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var index = require('../../../../../../../@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/RtlProvider/index.cjs');
+var usePickerPrivateContext = require('./usePickerPrivateContext.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);
+
+function useToolbarOwnerState() {
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext.usePickerPrivateContext();
+  const isRtl = index.useRtl();
+  return React__namespace.useMemo(() => _extends.default({}, pickerOwnerState, {
+    toolbarDirection: isRtl ? 'rtl' : 'ltr'
+  }), [pickerOwnerState, isRtl]);
+}
+
+exports.useToolbarOwnerState = useToolbarOwnerState;