npm - @tenancy.nz/datepicker - Versions diffs - 1.3.4 - Mend

@tenancy.nz/datepicker 1.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (361) hide show

package/dist/esm/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/useMobilePicker/useMobilePicker.js ADDED Viewed

@@ -0,0 +1,91 @@
+import _extends from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import { PickersModalDialog } from '../../components/PickersModalDialog.js';
+import { PickerProvider } from '../../components/PickerProvider.js';
+import { createNonRangePickerStepNavigation } from '../../utils/createNonRangePickerStepNavigation.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { usePicker } from '../usePicker/usePicker.js';
+import useSlotProps from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js';
+import { PickersLayout } from '../../../PickersLayout/PickersLayout.js';
+const _excluded = ["props", "steps"],
+  _excluded2 = ["ownerState"];
+const useMobilePicker = _ref => {
+  let {
+      props,
+      steps
+    } = _ref,
+    pickerParams = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const {
+    slots,
+    slotProps: innerSlotProps,
+    label,
+    inputRef,
+    localeText
+  } = props;
+  const getStepNavigation = createNonRangePickerStepNavigation({
+    steps
+  });
+  const {
+    providerProps,
+    renderCurrentView,
+    ownerState
+  } = usePicker(_extends({}, pickerParams, {
+    props,
+    localeText,
+    autoFocusView: true,
+    viewContainerRole: 'dialog',
+    variant: 'mobile',
+    getStepNavigation
+  }));
+  const labelId = providerProps.privateContextValue.labelId;
+  const isToolbarHidden = innerSlotProps?.toolbar?.hidden ?? false;
+  const Field = slots.field;
+  const _useSlotProps = useSlotProps({
+      elementType: Field,
+      externalSlotProps: innerSlotProps?.field,
+      additionalProps: _extends({}, isToolbarHidden && {
+        id: labelId
+      }),
+      ownerState
+    }),
+    fieldProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded2);
+  const Layout = slots.layout ?? PickersLayout;
+  let labelledById = labelId;
+  if (isToolbarHidden) {
+    if (label) {
+      labelledById = `${labelId}-label`;
+    } else {
+      labelledById = undefined;
+    }
+  }
+  const slotProps = _extends({}, innerSlotProps, {
+    toolbar: _extends({}, innerSlotProps?.toolbar, {
+      titleId: labelId
+    }),
+    mobilePaper: _extends({
+      'aria-labelledby': labelledById
+    }, innerSlotProps?.mobilePaper)
+  });
+  const renderPicker = () => /*#__PURE__*/jsxs(PickerProvider, _extends({}, providerProps, {
+    children: [/*#__PURE__*/jsx(Field, _extends({}, fieldProps, {
+      slots: _extends({}, slots, fieldProps.slots),
+      slotProps: _extends({}, slotProps, fieldProps.slotProps),
+      inputRef: inputRef
+    })), /*#__PURE__*/jsx(PickersModalDialog, {
+      slots: slots,
+      slotProps: slotProps,
+      children: /*#__PURE__*/jsx(Layout, _extends({}, slotProps?.layout, {
+        slots: slots,
+        slotProps: slotProps,
+        children: renderCurrentView()
+      }))
+    })]
+  }));
+  if (process.env.NODE_ENV !== "production") renderPicker.displayName = "renderPicker";
+  return {
+    renderPicker
+  };
+};
+export { useMobilePicker };

@@ -0,0 +1,9 @@
+import * as React from 'react';
+const PickerFieldPrivateContext = /*#__PURE__*/React.createContext(null);
+if (process.env.NODE_ENV !== "production") PickerFieldPrivateContext.displayName = "PickerFieldPrivateContext";
+function useNullableFieldPrivateContext() {
+  return React.useContext(PickerFieldPrivateContext);
+}
+export { PickerFieldPrivateContext, useNullableFieldPrivateContext };

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { PickerContext } from '../../hooks/usePickerContext.js';
+/**
+ * Returns the context passed by the Picker wrapping the current component.
+ * If the context is not found, returns `null`.
+ */
+const useNullablePickerContext = () => React.useContext(PickerContext);
+export { useNullablePickerContext };

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { arrayIncludes } from '../../../utils/utils.js';
+import useEnhancedEffect from '../../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js';
+function getOrientation() {
+  if (typeof window === 'undefined') {
+    return 'portrait';
+  }
+  if (window.screen && window.screen.orientation && window.screen.orientation.angle) {
+    return Math.abs(window.screen.orientation.angle) === 90 ? 'landscape' : 'portrait';
+  }
+  // Support IOS safari
+  if (window.orientation) {
+    return Math.abs(Number(window.orientation)) === 90 ? 'landscape' : 'portrait';
+  }
+  return 'portrait';
+}
+function useOrientation(views, customOrientation) {
+  const [orientation, setOrientation] = React.useState(getOrientation);
+  useEnhancedEffect(() => {
+    const eventHandler = () => {
+      setOrientation(getOrientation());
+    };
+    window.addEventListener('orientationchange', eventHandler);
+    return () => {
+      window.removeEventListener('orientationchange', eventHandler);
+    };
+  }, []);
+  if (arrayIncludes(views, ['hours', 'minutes', 'seconds'])) {
+    // could not display 13:34:44 in landscape mode
+    return 'portrait';
+  }
+  return customOrientation ?? orientation;
+}
+export { useOrientation };

@@ -0,0 +1,207 @@
+import _extends from '../../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import * as React from 'react';
+import { useControlledValue } from '../../useControlledValue.js';
+import { usePickerAdapter } from '../../../../hooks/usePickerAdapter.js';
+import { warnOnce } from '../../../../../../../../../@mui_x-internals@8.26.0_@types_react@19.1.9_react@18.3.1/node_modules/@mui/x-internals/esm/warning/warning.js';
+import { useValidation } from '../../../../validation/useValidation.js';
+import useEventCallback from '../../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js';
+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.useRef(defaultValueProp);
+  const {
+    current: isValueControlled
+  } = React.useRef(valueProp !== undefined);
+  const {
+    current: isOpenControlled
+  } = React.useRef(openProp !== undefined);
+  const adapter = usePickerAdapter();
+  if (process.env.NODE_ENV !== 'production') {
+    if (props.renderInput != null) {
+      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.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.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({
+    name: 'a picker component',
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    referenceDate,
+    onChange,
+    valueManager
+  });
+  const [state, setState] = React.useState(() => ({
+    open: false,
+    lastExternalValue: value,
+    clockShallowValue: undefined,
+    lastCommittedValue: value,
+    hasBeenModifiedSinceMount: false
+  }));
+  const {
+    getValidationErrorForNewValue
+  } = useValidation({
+    props,
+    validator,
+    timezone,
+    value,
+    onError: props.onError
+  });
+  const setOpen = useEventCallback(action => {
+    const newOpen = typeof action === 'function' ? action(state.open) : action;
+    if (!isOpenControlled) {
+      setState(prevState => _extends({}, prevState, {
+        open: newOpen
+      }));
+    }
+    if (newOpen && onOpen) {
+      onOpen();
+    }
+    if (!newOpen) {
+      onClose?.();
+    }
+  });
+  const setValue = useEventCallback((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({}, 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({}, prevState, {
+      lastExternalValue: value,
+      clockShallowValue: undefined,
+      hasBeenModifiedSinceMount: true
+    }));
+  }
+  const setValueFromView = useEventCallback((newValue, selectionState = 'partial') => {
+    // TODO: Expose a new method (private?) like `setView` that only updates the clock shallow value.
+    if (selectionState === 'shallow') {
+      setState(prev => _extends({}, 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.useEffect(() => {
+    if (isOpenControlled) {
+      if (openProp === undefined) {
+        throw new Error('You must not mix controlling and uncontrolled mode for `open` prop');
+      }
+      setState(prevState => _extends({}, prevState, {
+        open: openProp
+      }));
+    }
+  }, [isOpenControlled, openProp]);
+  const viewValue = React.useMemo(() => valueManager.cleanValue(adapter, state.clockShallowValue === undefined ? value : state.clockShallowValue), [adapter, valueManager, state.clockShallowValue, value]);
+  return {
+    timezone,
+    state,
+    setValue,
+    setValueFromView,
+    setOpen,
+    value,
+    viewValue
+  };
+}
+export { useValueAndOpenStates };

@@ -0,0 +1,324 @@
+import _extends from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import * as React from 'react';
+import { usePickerAdapter } from '../../../hooks/usePickerAdapter.js';
+import { useReduceAnimations } from '../useReduceAnimations.js';
+import { isTimeView } from '../../utils/time-utils.js';
+import { useViews } from '../useViews.js';
+import { useOrientation } from './hooks/useOrientation.js';
+import { useValueAndOpenStates } from './hooks/useValueAndOpenStates.js';
+import { jsx } from 'react/jsx-runtime';
+import useId from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useId/useId.js';
+import useForkRef from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useForkRef/useForkRef.js';
+import useEventCallback from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js';
+import useEnhancedEffect from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js';
+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(props, _excluded);
+  /**
+   * TODO: Improve how we generate the aria-label and aria-labelledby attributes.
+   */
+  const labelId = useId();
+  const adapter = usePickerAdapter();
+  const reduceAnimations = useReduceAnimations(reduceAnimationsProp);
+  const orientation = useOrientation(views, orientationProp);
+  const {
+    current: initialView
+  } = React.useRef(openTo ?? null);
+  /**
+   * Refs
+   */
+  const [triggerElement, triggerRef] = React.useState(null);
+  const popupRef = React.useRef(null);
+  const fieldRef = React.useRef(null);
+  const rootRefObject = React.useRef(null);
+  const rootRef = useForkRef(ref, rootRefObject);
+  const {
+    timezone,
+    state,
+    setOpen,
+    setValue,
+    setValueFromView,
+    value,
+    viewValue
+  } = useValueAndOpenStates({
+    props,
+    valueManager,
+    validator
+  });
+  const {
+    view,
+    setView,
+    defaultView,
+    focusedView,
+    setFocusedView,
+    setValueAndGoToNextView,
+    goToNextStep,
+    hasNextStep,
+    hasSeveralSteps
+  } = useViews({
+    view: viewProp,
+    views,
+    openTo,
+    onChange: setValueFromView,
+    onViewChange,
+    autoFocus: autoFocusView,
+    getStepNavigation
+  });
+  const clearValue = useEventCallback(() => setValue(valueManager.emptyValue, {
+    source: 'view'
+  }));
+  const setValueToToday = useEventCallback(() => setValue(valueManager.getTodayValue(adapter, timezone, valueType), {
+    source: 'view'
+  }));
+  const acceptValueChanges = useEventCallback(() => setValue(value, {
+    source: 'view'
+  }));
+  const cancelValueChanges = useEventCallback(() => setValue(state.lastCommittedValue, {
+    skipPublicationIfPristine: true,
+    source: 'view'
+  }));
+  const dismissViews = useEventCallback(() => {
+    setValue(value, {
+      skipPublicationIfPristine: true,
+      source: 'view'
+    });
+  });
+  const {
+    hasUIView,
+    viewModeLookup,
+    timeViewsCount
+  } = React.useMemo(() => views.reduce((acc, viewForReduce) => {
+    const viewMode = viewRenderers[viewForReduce] == null ? 'field' : 'UI';
+    acc.viewModeLookup[viewForReduce] = viewMode;
+    if (viewMode === 'UI') {
+      acc.hasUIView = true;
+      if (isTimeView(viewForReduce)) {
+        acc.timeViewsCount += 1;
+      }
+    }
+    return acc;
+  }, {
+    hasUIView: false,
+    viewModeLookup: {},
+    timeViewsCount: 0
+  }), [viewRenderers, views]);
+  const currentViewMode = viewModeLookup[view];
+  const getCurrentViewMode = useEventCallback(() => currentViewMode);
+  const [popperView, setPopperView] = React.useState(currentViewMode === 'UI' ? view : null);
+  if (popperView !== view && viewModeLookup[view] === 'UI') {
+    setPopperView(view);
+  }
+  useEnhancedEffect(() => {
+    // 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(() => {
+    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.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.useMemo(() => {
+    if (disableOpenPicker || !hasUIView) {
+      return 'hidden';
+    }
+    if (disabled || readOnly) {
+      return 'disabled';
+    }
+    return 'enabled';
+  }, [disableOpenPicker, hasUIView, disabled, readOnly]);
+  const wrappedGoToNextStep = useEventCallback(goToNextStep);
+  const defaultActionBarActions = React.useMemo(() => {
+    if (closeOnSelect && !hasSeveralSteps) {
+      return [];
+    }
+    return ['cancel', 'nextOrAccept'];
+  }, [closeOnSelect, hasSeveralSteps]);
+  const actionsContextValue = React.useMemo(() => ({
+    setValue,
+    setOpen,
+    clearValue,
+    setValueToToday,
+    acceptValueChanges,
+    cancelValueChanges,
+    setView,
+    goToNextStep: wrappedGoToNextStep
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges, setView, wrappedGoToNextStep]);
+  const contextValue = React.useMemo(() => _extends({}, 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.useMemo(() => ({
+    dismissViews,
+    ownerState,
+    hasUIView,
+    getCurrentViewMode,
+    rootRefObject,
+    labelId,
+    triggerElement,
+    viewContainerRole,
+    defaultActionBarActions,
+    onPopperExited
+  }), [dismissViews, ownerState, hasUIView, getCurrentViewMode, labelId, triggerElement, viewContainerRole, defaultActionBarActions, onPopperExited]);
+  const fieldPrivateContextValue = React.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({}, 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__*/jsx(RendererInterceptor, {
+        viewRenderers: viewRenderers,
+        popperView: popperView,
+        rendererProps: rendererProps
+      });
+    }
+    return renderer(rendererProps);
+  };
+  return {
+    providerProps: {
+      localeText,
+      contextValue,
+      privateContextValue,
+      actionsContextValue,
+      fieldPrivateContextValue,
+      isValidContextValue
+    },
+    renderCurrentView,
+    ownerState
+  };
+};
+export { usePicker };

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { PickerPrivateContext } from '../components/PickerProvider.js';
+/**
+ * Returns the private context passed by the Picker wrapping the current component.
+ */
+const usePickerPrivateContext = () => React.useContext(PickerPrivateContext);
+export { usePickerPrivateContext };