@mui/x-date-pickers 8.0.0-beta.2 → 8.0.0

package/modern/MultiSectionDigitalClock/MultiSectionDigitalClock.js

@@ -1,513 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["ampm", "timeSteps", "autoFocus", "slots", "slotProps", "value", "defaultValue", "referenceDate", "disableIgnoringDatePartForTimeValidation", "maxTime", "minTime", "disableFuture", "disablePast", "minutesStep", "shouldDisableTime", "onChange", "view", "views", "openTo", "onViewChange", "focusedView", "onFocusedViewChange", "className", "classes", "disabled", "readOnly", "skipDisabled", "timezone"];
-import * as React from 'react';
-import clsx from 'clsx';
-import PropTypes from 'prop-types';
-import { useRtl } from '@mui/system/RtlProvider';
-import { styled, useThemeProps } from '@mui/material/styles';
-import useEventCallback from '@mui/utils/useEventCallback';
-import composeClasses from '@mui/utils/composeClasses';
-import { usePickerTranslations } from "../hooks/usePickerTranslations.js";
-import { useUtils, useNow } from "../internals/hooks/useUtils.js";
-import { convertValueToMeridiem, createIsAfterIgnoreDatePart } from "../internals/utils/time-utils.js";
-import { useViews } from "../internals/hooks/useViews.js";
-import { useMeridiemMode } from "../internals/hooks/date-helpers-hooks.js";
-import { PickerViewRoot } from "../internals/components/PickerViewRoot/index.js";
-import { getMultiSectionDigitalClockUtilityClass } from "./multiSectionDigitalClockClasses.js";
-import { MultiSectionDigitalClockSection } from "./MultiSectionDigitalClockSection.js";
-import { getHourSectionOptions, getTimeSectionOptions } from "./MultiSectionDigitalClock.utils.js";
-import { useControlledValue } from "../internals/hooks/useControlledValue.js";
-import { singleItemValueManager } from "../internals/utils/valueManagers.js";
-import { useClockReferenceDate } from "../internals/hooks/useClockReferenceDate.js";
-import { formatMeridiem } from "../internals/utils/date-utils.js";
-import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const useUtilityClasses = classes => {
-  const slots = {
-    root: ['root']
-  };
-  return composeClasses(slots, getMultiSectionDigitalClockUtilityClass, classes);
-};
-const MultiSectionDigitalClockRoot = styled(PickerViewRoot, {
-  name: 'MuiMultiSectionDigitalClock',
-  slot: 'Root',
-  overridesResolver: (_, styles) => styles.root
-})(({
-  theme
-}) => ({
-  flexDirection: 'row',
-  width: '100%',
-  borderBottom: `1px solid ${(theme.vars || theme).palette.divider}`
-}));
-/**
- * Demos:
- *
- * - [TimePicker](https://mui.com/x/react-date-pickers/time-picker/)
- * - [DigitalClock](https://mui.com/x/react-date-pickers/digital-clock/)
- *
- * API:
- *
- * - [MultiSectionDigitalClock API](https://mui.com/x/api/date-pickers/multi-section-digital-clock/)
- */
-export const MultiSectionDigitalClock = /*#__PURE__*/React.forwardRef(function MultiSectionDigitalClock(inProps, ref) {
-  const utils = useUtils();
-  const isRtl = useRtl();
-  const props = useThemeProps({
-    props: inProps,
-    name: 'MuiMultiSectionDigitalClock'
-  });
-  const {
-      ampm = utils.is12HourCycleInCurrentLocale(),
-      timeSteps: inTimeSteps,
-      autoFocus,
-      slots,
-      slotProps,
-      value: valueProp,
-      defaultValue,
-      referenceDate: referenceDateProp,
-      disableIgnoringDatePartForTimeValidation = false,
-      maxTime,
-      minTime,
-      disableFuture,
-      disablePast,
-      minutesStep = 1,
-      shouldDisableTime,
-      onChange,
-      view: inView,
-      views: inViews = ['hours', 'minutes'],
-      openTo,
-      onViewChange,
-      focusedView: inFocusedView,
-      onFocusedViewChange,
-      className,
-      classes: classesProp,
-      disabled,
-      readOnly,
-      skipDisabled = false,
-      timezone: timezoneProp
-    } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
-  const {
-    value,
-    handleValueChange: handleRawValueChange,
-    timezone
-  } = useControlledValue({
-    name: 'MultiSectionDigitalClock',
-    timezone: timezoneProp,
-    value: valueProp,
-    defaultValue,
-    referenceDate: referenceDateProp,
-    onChange,
-    valueManager: singleItemValueManager
-  });
-  const translations = usePickerTranslations();
-  const now = useNow(timezone);
-  const timeSteps = React.useMemo(() => _extends({
-    hours: 1,
-    minutes: 5,
-    seconds: 5
-  }, inTimeSteps), [inTimeSteps]);
-  const valueOrReferenceDate = useClockReferenceDate({
-    value,
-    referenceDate: referenceDateProp,
-    utils,
-    props,
-    timezone
-  });
-  const handleValueChange = useEventCallback((newValue, selectionState, selectedView) => handleRawValueChange(newValue, selectionState, selectedView));
-  const views = React.useMemo(() => {
-    if (!ampm || !inViews.includes('hours')) {
-      return inViews;
-    }
-    return inViews.includes('meridiem') ? inViews : [...inViews, 'meridiem'];
-  }, [ampm, inViews]);
-  const {
-    view,
-    setValueAndGoToNextView,
-    focusedView
-  } = useViews({
-    view: inView,
-    views,
-    openTo,
-    onViewChange,
-    onChange: handleValueChange,
-    focusedView: inFocusedView,
-    onFocusedViewChange
-  });
-  const handleMeridiemValueChange = useEventCallback(newValue => {
-    setValueAndGoToNextView(newValue, 'finish', 'meridiem');
-  });
-  const {
-    meridiemMode,
-    handleMeridiemChange
-  } = useMeridiemMode(valueOrReferenceDate, ampm, handleMeridiemValueChange, 'finish');
-  const isTimeDisabled = React.useCallback((rawValue, viewType) => {
-    const isAfter = createIsAfterIgnoreDatePart(disableIgnoringDatePartForTimeValidation, utils);
-    const shouldCheckPastEnd = viewType === 'hours' || viewType === 'minutes' && views.includes('seconds');
-    const containsValidTime = ({
-      start,
-      end
-    }) => {
-      if (minTime && isAfter(minTime, end)) {
-        return false;
-      }
-      if (maxTime && isAfter(start, maxTime)) {
-        return false;
-      }
-      if (disableFuture && isAfter(start, now)) {
-        return false;
-      }
-      if (disablePast && isAfter(now, shouldCheckPastEnd ? end : start)) {
-        return false;
-      }
-      return true;
-    };
-    const isValidValue = (timeValue, step = 1) => {
-      if (timeValue % step !== 0) {
-        return false;
-      }
-      if (shouldDisableTime) {
-        switch (viewType) {
-          case 'hours':
-            return !shouldDisableTime(utils.setHours(valueOrReferenceDate, timeValue), 'hours');
-          case 'minutes':
-            return !shouldDisableTime(utils.setMinutes(valueOrReferenceDate, timeValue), 'minutes');
-          case 'seconds':
-            return !shouldDisableTime(utils.setSeconds(valueOrReferenceDate, timeValue), 'seconds');
-          default:
-            return false;
-        }
-      }
-      return true;
-    };
-    switch (viewType) {
-      case 'hours':
-        {
-          const valueWithMeridiem = convertValueToMeridiem(rawValue, meridiemMode, ampm);
-          const dateWithNewHours = utils.setHours(valueOrReferenceDate, valueWithMeridiem);
-          if (utils.getHours(dateWithNewHours) !== valueWithMeridiem) {
-            return true;
-          }
-          const start = utils.setSeconds(utils.setMinutes(dateWithNewHours, 0), 0);
-          const end = utils.setSeconds(utils.setMinutes(dateWithNewHours, 59), 59);
-          return !containsValidTime({
-            start,
-            end
-          }) || !isValidValue(valueWithMeridiem);
-        }
-      case 'minutes':
-        {
-          const dateWithNewMinutes = utils.setMinutes(valueOrReferenceDate, rawValue);
-          const start = utils.setSeconds(dateWithNewMinutes, 0);
-          const end = utils.setSeconds(dateWithNewMinutes, 59);
-          return !containsValidTime({
-            start,
-            end
-          }) || !isValidValue(rawValue, minutesStep);
-        }
-      case 'seconds':
-        {
-          const dateWithNewSeconds = utils.setSeconds(valueOrReferenceDate, rawValue);
-          const start = dateWithNewSeconds;
-          const end = dateWithNewSeconds;
-          return !containsValidTime({
-            start,
-            end
-          }) || !isValidValue(rawValue);
-        }
-      default:
-        throw new Error('not supported');
-    }
-  }, [ampm, valueOrReferenceDate, disableIgnoringDatePartForTimeValidation, maxTime, meridiemMode, minTime, minutesStep, shouldDisableTime, utils, disableFuture, disablePast, now, views]);
-  const buildViewProps = React.useCallback(viewToBuild => {
-    switch (viewToBuild) {
-      case 'hours':
-        {
-          return {
-            onChange: hours => {
-              const valueWithMeridiem = convertValueToMeridiem(hours, meridiemMode, ampm);
-              setValueAndGoToNextView(utils.setHours(valueOrReferenceDate, valueWithMeridiem), 'finish', 'hours');
-            },
-            items: getHourSectionOptions({
-              now,
-              value,
-              ampm,
-              utils,
-              isDisabled: hours => isTimeDisabled(hours, 'hours'),
-              timeStep: timeSteps.hours,
-              resolveAriaLabel: translations.hoursClockNumberText,
-              valueOrReferenceDate
-            })
-          };
-        }
-      case 'minutes':
-        {
-          return {
-            onChange: minutes => {
-              setValueAndGoToNextView(utils.setMinutes(valueOrReferenceDate, minutes), 'finish', 'minutes');
-            },
-            items: getTimeSectionOptions({
-              value: utils.getMinutes(valueOrReferenceDate),
-              utils,
-              isDisabled: minutes => isTimeDisabled(minutes, 'minutes'),
-              resolveLabel: minutes => utils.format(utils.setMinutes(now, minutes), 'minutes'),
-              timeStep: timeSteps.minutes,
-              hasValue: !!value,
-              resolveAriaLabel: translations.minutesClockNumberText
-            })
-          };
-        }
-      case 'seconds':
-        {
-          return {
-            onChange: seconds => {
-              setValueAndGoToNextView(utils.setSeconds(valueOrReferenceDate, seconds), 'finish', 'seconds');
-            },
-            items: getTimeSectionOptions({
-              value: utils.getSeconds(valueOrReferenceDate),
-              utils,
-              isDisabled: seconds => isTimeDisabled(seconds, 'seconds'),
-              resolveLabel: seconds => utils.format(utils.setSeconds(now, seconds), 'seconds'),
-              timeStep: timeSteps.seconds,
-              hasValue: !!value,
-              resolveAriaLabel: translations.secondsClockNumberText
-            })
-          };
-        }
-      case 'meridiem':
-        {
-          const amLabel = formatMeridiem(utils, 'am');
-          const pmLabel = formatMeridiem(utils, 'pm');
-          return {
-            onChange: handleMeridiemChange,
-            items: [{
-              value: 'am',
-              label: amLabel,
-              isSelected: () => !!value && meridiemMode === 'am',
-              isFocused: () => !!valueOrReferenceDate && meridiemMode === 'am',
-              ariaLabel: amLabel
-            }, {
-              value: 'pm',
-              label: pmLabel,
-              isSelected: () => !!value && meridiemMode === 'pm',
-              isFocused: () => !!valueOrReferenceDate && meridiemMode === 'pm',
-              ariaLabel: pmLabel
-            }]
-          };
-        }
-      default:
-        throw new Error(`Unknown view: ${viewToBuild} found.`);
-    }
-  }, [now, value, ampm, utils, timeSteps.hours, timeSteps.minutes, timeSteps.seconds, translations.hoursClockNumberText, translations.minutesClockNumberText, translations.secondsClockNumberText, meridiemMode, setValueAndGoToNextView, valueOrReferenceDate, isTimeDisabled, handleMeridiemChange]);
-  const viewsToRender = React.useMemo(() => {
-    if (!isRtl) {
-      return views;
-    }
-    const digitViews = views.filter(v => v !== 'meridiem');
-    digitViews.reverse();
-    if (views.includes('meridiem')) {
-      digitViews.push('meridiem');
-    }
-    return digitViews;
-  }, [isRtl, views]);
-  const viewTimeOptions = React.useMemo(() => {
-    return views.reduce((result, currentView) => {
-      return _extends({}, result, {
-        [currentView]: buildViewProps(currentView)
-      });
-    }, {});
-  }, [views, buildViewProps]);
-  const {
-    ownerState
-  } = usePickerPrivateContext();
-  const classes = useUtilityClasses(classesProp);
-  return /*#__PURE__*/_jsx(MultiSectionDigitalClockRoot, _extends({
-    ref: ref,
-    className: clsx(classes.root, className),
-    ownerState: ownerState,
-    role: "group"
-  }, other, {
-    children: viewsToRender.map(timeView => /*#__PURE__*/_jsx(MultiSectionDigitalClockSection, {
-      items: viewTimeOptions[timeView].items,
-      onChange: viewTimeOptions[timeView].onChange,
-      active: view === timeView,
-      autoFocus: autoFocus ?? focusedView === timeView,
-      disabled: disabled,
-      readOnly: readOnly,
-      slots: slots,
-      slotProps: slotProps,
-      skipDisabled: skipDisabled,
-      "aria-label": translations.selectViewText(timeView)
-    }, timeView))
-  }));
-});
-process.env.NODE_ENV !== "production" ? MultiSectionDigitalClock.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  /**
-   * 12h/24h view for hour selection clock.
-   * @default utils.is12HourCycleInCurrentLocale()
-   */
-  ampm: PropTypes.bool,
-  /**
-   * If `true`, the main element is focused during the first mount.
-   * This main element is:
-   * - the element chosen by the visible view if any (i.e: the selected day on the `day` view).
-   * - the `input` element if there is a field rendered.
-   */
-  autoFocus: PropTypes.bool,
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes: PropTypes.object,
-  className: PropTypes.string,
-  /**
-   * The default selected value.
-   * Used when the component is not controlled.
-   */
-  defaultValue: PropTypes.object,
-  /**
-   * If `true`, the component is disabled.
-   * When disabled, the value cannot be changed and no interaction is possible.
-   * @default false
-   */
-  disabled: PropTypes.bool,
-  /**
-   * If `true`, disable values after the current date for date components, time for time components and both for date time components.
-   * @default false
-   */
-  disableFuture: PropTypes.bool,
-  /**
-   * Do not ignore date part when validating min/max time.
-   * @default false
-   */
-  disableIgnoringDatePartForTimeValidation: PropTypes.bool,
-  /**
-   * If `true`, disable values before the current date for date components, time for time components and both for date time components.
-   * @default false
-   */
-  disablePast: PropTypes.bool,
-  /**
-   * Controlled focused view.
-   */
-  focusedView: PropTypes.oneOf(['hours', 'meridiem', 'minutes', 'seconds']),
-  /**
-   * Maximal selectable time.
-   * The date part of the object will be ignored unless `props.disableIgnoringDatePartForTimeValidation === true`.
-   */
-  maxTime: PropTypes.object,
-  /**
-   * Minimal selectable time.
-   * The date part of the object will be ignored unless `props.disableIgnoringDatePartForTimeValidation === true`.
-   */
-  minTime: PropTypes.object,
-  /**
-   * Step over minutes.
-   * @default 1
-   */
-  minutesStep: PropTypes.number,
-  /**
-   * Callback fired when the value changes.
-   * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
-   * @template TView The view type. Will be one of date or time views.
-   * @param {TValue} value The new value.
-   * @param {PickerSelectionState | undefined} selectionState Indicates if the date selection is complete.
-   * @param {TView | undefined} selectedView Indicates the view in which the selection has been made.
-   */
-  onChange: PropTypes.func,
-  /**
-   * Callback fired on focused view change.
-   * @template TView
-   * @param {TView} view The new view to focus or not.
-   * @param {boolean} hasFocus `true` if the view should be focused.
-   */
-  onFocusedViewChange: PropTypes.func,
-  /**
-   * Callback fired on view change.
-   * @template TView
-   * @param {TView} view The new view.
-   */
-  onViewChange: PropTypes.func,
-  /**
-   * The default visible view.
-   * Used when the component view is not controlled.
-   * Must be a valid option from `views` list.
-   */
-  openTo: PropTypes.oneOf(['hours', 'meridiem', 'minutes', 'seconds']),
-  /**
-   * If `true`, the component is read-only.
-   * When read-only, the value cannot be changed but the user can interact with the interface.
-   * @default false
-   */
-  readOnly: PropTypes.bool,
-  /**
-   * The date used to generate the new value when both `value` and `defaultValue` are empty.
-   * @default The closest valid time using the validation props, except callbacks such as `shouldDisableTime`.
-   */
-  referenceDate: PropTypes.object,
-  /**
-   * Disable specific time.
-   * @param {PickerValidDate} value The value to check.
-   * @param {TimeView} view The clock type of the timeValue.
-   * @returns {boolean} If `true` the time will be disabled.
-   */
-  shouldDisableTime: PropTypes.func,
-  /**
-   * If `true`, disabled digital clock items will not be rendered.
-   * @default false
-   */
-  skipDisabled: PropTypes.bool,
-  /**
-   * The props used for each component slot.
-   * @default {}
-   */
-  slotProps: PropTypes.object,
-  /**
-   * Overrideable component slots.
-   * @default {}
-   */
-  slots: PropTypes.object,
-  /**
-   * The system prop that allows defining system overrides as well as additional CSS styles.
-   */
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
-  /**
-   * The time steps between two time unit options.
-   * For example, if `timeStep.minutes = 8`, then the available minute options will be `[0, 8, 16, 24, 32, 40, 48, 56]`.
-   * @default{ hours: 1, minutes: 5, seconds: 5 }
-   */
-  timeSteps: PropTypes.shape({
-    hours: PropTypes.number,
-    minutes: PropTypes.number,
-    seconds: PropTypes.number
-  }),
-  /**
-   * Choose which timezone to use for the value.
-   * Example: "default", "system", "UTC", "America/New_York".
-   * If you pass values from other timezones to some props, they will be converted to this timezone before being used.
-   * @see See the {@link https://mui.com/x/react-date-pickers/timezone/ timezones documentation} for more details.
-   * @default The timezone of the `value` or `defaultValue` prop is defined, 'default' otherwise.
-   */
-  timezone: PropTypes.string,
-  /**
-   * The selected value.
-   * Used when the component is controlled.
-   */
-  value: PropTypes.object,
-  /**
-   * The visible view.
-   * Used when the component view is controlled.
-   * Must be a valid option from `views` list.
-   */
-  view: PropTypes.oneOf(['hours', 'meridiem', 'minutes', 'seconds']),
-  /**
-   * Available views.
-   * @default ['hours', 'minutes']
-   */
-  views: PropTypes.arrayOf(PropTypes.oneOf(['hours', 'meridiem', 'minutes', 'seconds']).isRequired)
-} : void 0;

package/modern/MultiSectionDigitalClock/MultiSectionDigitalClock.types.d.ts

@@ -1,48 +0,0 @@
-import * as React from 'react';
-import { SlotComponentProps } from '@mui/utils';
-import MenuItem from '@mui/material/MenuItem';
-import { MultiSectionDigitalClockClasses } from "./multiSectionDigitalClockClasses.js";
-import { BaseClockProps, ExportedBaseClockProps, MultiSectionDigitalClockOnlyProps } from "../internals/models/props/time.js";
-import { MultiSectionDigitalClockSectionProps } from "./MultiSectionDigitalClockSection.js";
-import { TimeViewWithMeridiem } from "../internals/models/index.js";
-export interface MultiSectionDigitalClockOption<TSectionValue extends number | string> {
-  isDisabled?: (value: TSectionValue) => boolean;
-  isSelected: (value: TSectionValue) => boolean;
-  isFocused: (value: TSectionValue) => boolean;
-  label: string;
-  value: TSectionValue;
-  ariaLabel: string;
-}
-export interface ExportedMultiSectionDigitalClockProps extends ExportedBaseClockProps, MultiSectionDigitalClockOnlyProps {}
-export interface MultiSectionDigitalClockViewProps<TSectionValue extends number | string> extends Pick<MultiSectionDigitalClockSectionProps<TSectionValue>, 'onChange' | 'items'> {}
-export interface MultiSectionDigitalClockSlots {
-  /**
-   * Component responsible for rendering a single multi section digital clock section item.
-   * @default MenuItem from '@mui/material'
-   */
-  digitalClockSectionItem?: React.ElementType;
-}
-export interface MultiSectionDigitalClockSlotProps {
-  digitalClockSectionItem?: SlotComponentProps<typeof MenuItem, {}, Record<string, any>>;
-}
-export interface MultiSectionDigitalClockProps extends ExportedMultiSectionDigitalClockProps, BaseClockProps<TimeViewWithMeridiem> {
-  /**
-   * Available views.
-   * @default ['hours', 'minutes']
-   */
-  views?: readonly TimeViewWithMeridiem[];
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes?: Partial<MultiSectionDigitalClockClasses>;
-  /**
-   * Overrideable component slots.
-   * @default {}
-   */
-  slots?: MultiSectionDigitalClockSlots;
-  /**
-   * The props used for each component slot.
-   * @default {}
-   */
-  slotProps?: MultiSectionDigitalClockSlotProps;
-}

package/modern/MultiSectionDigitalClock/MultiSectionDigitalClock.types.js

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

package/modern/MultiSectionDigitalClock/MultiSectionDigitalClock.utils.d.ts

@@ -1,41 +0,0 @@
-import { MuiPickersAdapter, PickerValidDate } from "../models/index.js";
-import { MultiSectionDigitalClockOption } from "./MultiSectionDigitalClock.types.js";
-interface GetHoursSectionOptionsParameters {
-  now: PickerValidDate;
-  value: PickerValidDate | null;
-  utils: MuiPickersAdapter;
-  ampm: boolean;
-  isDisabled: (value: number) => boolean;
-  timeStep: number;
-  resolveAriaLabel: (value: string) => string;
-  valueOrReferenceDate: PickerValidDate;
-}
-export declare const getHourSectionOptions: ({
-  now,
-  value,
-  utils,
-  ampm,
-  isDisabled,
-  resolveAriaLabel,
-  timeStep,
-  valueOrReferenceDate
-}: GetHoursSectionOptionsParameters) => MultiSectionDigitalClockOption<number>[];
-interface GetTimeSectionOptionsParameters {
-  value: number | null;
-  utils: MuiPickersAdapter;
-  isDisabled: (value: number) => boolean;
-  timeStep: number;
-  resolveLabel: (value: number) => string;
-  hasValue?: boolean;
-  resolveAriaLabel: (value: string) => string;
-}
-export declare const getTimeSectionOptions: ({
-  value,
-  utils,
-  isDisabled,
-  timeStep,
-  resolveLabel,
-  resolveAriaLabel,
-  hasValue
-}: GetTimeSectionOptionsParameters) => MultiSectionDigitalClockOption<number>[];
-export {};

package/modern/MultiSectionDigitalClock/MultiSectionDigitalClock.utils.js

@@ -1,76 +0,0 @@
-export const getHourSectionOptions = ({
-  now,
-  value,
-  utils,
-  ampm,
-  isDisabled,
-  resolveAriaLabel,
-  timeStep,
-  valueOrReferenceDate
-}) => {
-  const currentHours = value ? utils.getHours(value) : null;
-  const result = [];
-  const isSelected = (hour, overriddenCurrentHours) => {
-    const resolvedCurrentHours = overriddenCurrentHours ?? currentHours;
-    if (resolvedCurrentHours === null) {
-      return false;
-    }
-    if (ampm) {
-      if (hour === 12) {
-        return resolvedCurrentHours === 12 || resolvedCurrentHours === 0;
-      }
-      return resolvedCurrentHours === hour || resolvedCurrentHours - 12 === hour;
-    }
-    return resolvedCurrentHours === hour;
-  };
-  const isFocused = hour => {
-    return isSelected(hour, utils.getHours(valueOrReferenceDate));
-  };
-  const endHour = ampm ? 11 : 23;
-  for (let hour = 0; hour <= endHour; hour += timeStep) {
-    let label = utils.format(utils.setHours(now, hour), ampm ? 'hours12h' : 'hours24h');
-    const ariaLabel = resolveAriaLabel(parseInt(label, 10).toString());
-    label = utils.formatNumber(label);
-    result.push({
-      value: hour,
-      label,
-      isSelected,
-      isDisabled,
-      isFocused,
-      ariaLabel
-    });
-  }
-  return result;
-};
-export const getTimeSectionOptions = ({
-  value,
-  utils,
-  isDisabled,
-  timeStep,
-  resolveLabel,
-  resolveAriaLabel,
-  hasValue = true
-}) => {
-  const isSelected = timeValue => {
-    if (value === null) {
-      return false;
-    }
-    return hasValue && value === timeValue;
-  };
-  const isFocused = timeValue => {
-    return value === timeValue;
-  };
-  return [...Array.from({
-    length: Math.ceil(60 / timeStep)
-  }, (_, index) => {
-    const timeValue = timeStep * index;
-    return {
-      value: timeValue,
-      label: utils.formatNumber(resolveLabel(timeValue)),
-      isDisabled,
-      isSelected,
-      isFocused,
-      ariaLabel: resolveAriaLabel(timeValue.toString())
-    };
-  })];
-};