@bigbinary/neeto-atoms 1.0.144 → 1.1.0

package/dist/cjs/{DatePicker-D8GQGON2.js → DatePicker-aGLz-3Bz.js}

@@ -5,7 +5,7 @@ var React = require('react');
 var primitives_Calendar = require('./primitives/Calendar.js');
 var primitives_Popover = require('./primitives/Popover.js');
 var utils$1 = require('./utils-BhM0B89p.js');
-var TimePickerPanel = require('./TimePickerPanel-DvVRLqeM.js');
+var utils$2 = require('./utils-S4yTubWZ.js');
 var pureDayjs = require('dayjs');
 var customParseFormat = require('dayjs/plugin/customParseFormat');
 var utils = require('@bigbinary/neeto-commons-frontend/utils');
@@ -14,11 +14,15 @@ var primitives_Button = require('./primitives/Button.js');
 var primitives_Field = require('./primitives/Field.js');
 var createLucideIcon = require('./createLucideIcon-D0tRgV6l.js');
 var x = require('./x-Brw3FJst.js');
+var reactI18next = require('react-i18next');
+var primitives_Label = require('./primitives/Label.js');
+var primitives_Switch = require('./primitives/Switch.js');
 var chevronLeft = require('./chevron-left-BldoOh5p.js');
 var chevronRight = require('./chevron-right-0jNdwX2Q.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var React__default = /*#__PURE__*/_interopDefault(React);
 var pureDayjs__default = /*#__PURE__*/_interopDefault(pureDayjs);
 var customParseFormat__default = /*#__PURE__*/_interopDefault(customParseFormat);
 
@@ -30,16 +34,32 @@ var customParseFormat__default = /*#__PURE__*/_interopDefault(customParseFormat)
  */
 
 
-const __iconNode = [
+const __iconNode$1 = [
   ["path", { d: "M8 2v4", key: "1cmpym" }],
   ["path", { d: "M16 2v4", key: "4m81vk" }],
   ["rect", { width: "18", height: "18", x: "3", y: "4", rx: "2", key: "1hopcy" }],
   ["path", { d: "M3 10h18", key: "8toen8" }]
 ];
-const Calendar = createLucideIcon.createLucideIcon("calendar", __iconNode);
+const Calendar = createLucideIcon.createLucideIcon("calendar", __iconNode$1);
+
+/**
+ * @license lucide-react v0.577.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+
+const __iconNode = [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
+  ["path", { d: "M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20", key: "13o1zl" }],
+  ["path", { d: "M2 12h20", key: "9i4pu4" }]
+];
+const Globe = createLucideIcon.createLucideIcon("globe", __iconNode);
 
 const DEFAULT_DATE_FORMAT = "dd/MM/yyyy";
-const DEFAULT_TIME_FORMAT = "HH:mm:ss";
+const DEFAULT_TIME_FORMAT = "hh:mm A";
+const CALENDAR_NAVIGATION_YEAR_RANGE = 100;
 const INITIAL_TIME_VALUE = {
   hours: 0,
   minutes: 0,
@@ -109,6 +129,33 @@ const getInitialCalendarMonth = (value, defaultValue, type) => {
 };
 const normalizeToDayjsFormat = (fmt) => fmt.replace(/\byyyy\b/g, "YYYY").replace(/\byy\b/g, "YY").replace(/\bdd\b/g, "DD").replace(/\bd\b/g, "D");
 const normalizeToDateFnsFormat = (fmt) => fmt.replace(/YYYY/g, "yyyy").replace(/YY/g, "yy").replace(/DD/g, "dd").replace(/\bD\b/g, "d");
+const roundToMinuteStep = (date, step) => {
+  const rounded = new Date(date);
+  const minutes = Math.min(
+    60 - step,
+    Math.round(date.getMinutes() / step) * step
+  );
+  rounded.setMinutes(minutes, 0, 0);
+  return rounded;
+};
+const getTimezoneLabel = (timezone) => {
+  const zone = timezone === "utc" ? "UTC" : utils.dayjs().$x?.$timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  try {
+    const zoneName = (timeZoneName) => new Intl.DateTimeFormat("en-US", { timeZone: zone, timeZoneName }).formatToParts(/* @__PURE__ */ new Date()).find((part) => part.type === "timeZoneName")?.value;
+    const name = zoneName("long") ?? zone;
+    const offset = (zoneName("longOffset") ?? "GMT").replace("GMT", "UTC").replace(/([+-])0?(\d+):00$/, "$1$2").replace(/([+-])0(\d)/, "$1$2");
+    return `${name} (${offset === "UTC" ? "UTC+0" : offset})`;
+  } catch {
+    return zone;
+  }
+};
+const roundUpToMinuteStep = (date, step) => {
+  const rounded = new Date(date);
+  const hasSeconds = date.getSeconds() > 0 || date.getMilliseconds() > 0;
+  const minutes = date.getMinutes() + (hasSeconds ? 1 : 0);
+  rounded.setMinutes(Math.ceil(minutes / step) * step, 0, 0);
+  return rounded;
+};
 const formatDate = (date, formatStr) => {
   if (!date) return "";
   try {
@@ -267,6 +314,7 @@ const DatePickerFooter = ({
   timezone,
   onTimezoneChange,
   nowDisabled,
+  showNow = true,
   onNow,
   onOk,
   okLabel = "OK",
@@ -281,7 +329,7 @@ const DatePickerFooter = ({
         className
       ),
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx(
+        showNow && /* @__PURE__ */ jsxRuntime.jsx(
           primitives_Button.Button,
           {
             variant: "ghost",
@@ -441,6 +489,443 @@ const DatePickerTrigger = React.forwardRef(
 );
 DatePickerTrigger.displayName = "DatePickerTrigger";
 
+const SEGMENT_KEYS = ["hour", "minute", "period"];
+const EMPTY_SEGMENT = { text: "", done: false, auto: false };
+const segment = (text, done, auto = false) => ({
+  text,
+  done,
+  auto
+});
+const clampIndex = (index) => Math.max(0, Math.min(2, index));
+const withSegment = (state, key, value) => ({ ...state, [key]: value });
+const snapMinute = (minutes, step = 1) => utils$2.padNumber(Math.min(60 - step, Math.round(Number(minutes) / step) * step));
+const emptySegmentedTime = () => ({
+  hour: EMPTY_SEGMENT,
+  minute: EMPTY_SEGMENT,
+  period: EMPTY_SEGMENT,
+  active: 0
+});
+const segmentedTimeFromValue = (value, step = 1) => {
+  const { hour12, period } = utils$2.to12Hour(value.hours);
+  return {
+    hour: segment(String(hour12), true),
+    minute: segment(snapMinute(value.minutes, step), true),
+    period: segment(period, true),
+    active: 0
+  };
+};
+const isSegmentedTimeEmpty = (state) => SEGMENT_KEYS.every((key) => state[key].text === "");
+const getSegmentedTimeError = (state) => {
+  if (isSegmentedTimeEmpty(state)) return "timeRequired";
+  if (!state.hour.text) return "hourRequired";
+  if (!state.minute.text) return "minuteRequired";
+  if (!state.period.text) return "periodRequired";
+  return null;
+};
+const segmentedTimeToValue = (state) => {
+  if (getSegmentedTimeError(state)) return null;
+  return {
+    hours: utils$2.to24Hour(Number(state.hour.text), state.period.text),
+    minutes: Number(state.minute.text),
+    seconds: 0
+  };
+};
+const finishSegment = (state, key, step) => {
+  const { text } = state[key];
+  if (!text) return state;
+  if (key === "hour" && text === "0") {
+    return withSegment(state, "hour", EMPTY_SEGMENT);
+  }
+  if (key === "minute" && text.length === 1) {
+    return withSegment(
+      state,
+      "minute",
+      segment(snapMinute(text, step), true, true)
+    );
+  }
+  return withSegment(state, key, { ...state[key], done: true });
+};
+const finishActiveSegment = (state, step = 1) => finishSegment(state, SEGMENT_KEYS[state.active], step);
+const focusSegment = (state, index, step = 1) => {
+  const next = clampIndex(index);
+  const finished = next > state.active ? finishActiveSegment(state, step) : state;
+  return { ...finished, active: next };
+};
+const focusFirstEmptySegment = (state) => {
+  const index = SEGMENT_KEYS.findIndex((key) => !state[key].text);
+  return { ...state, active: index === -1 ? 2 : index };
+};
+const nextSegment = (state, step = 1) => state[SEGMENT_KEYS[state.active]].text ? focusSegment(state, state.active + 1, step) : state;
+const previousSegment = (state) => focusSegment(state, state.active - 1);
+const typeDigit = (state, digit, step = 1) => {
+  const advance = (next, index) => focusSegment(next, index, step);
+  const key = SEGMENT_KEYS[state.active];
+  if (key === "period") return state;
+  const current = state[key];
+  const text = current.done ? "" : current.text;
+  if (key === "hour") {
+    if (text === "") {
+      if (digit === "0" || digit === "1") {
+        return withSegment(state, "hour", segment(digit, false));
+      }
+      return advance(withSegment(state, "hour", segment(digit, true)), 1);
+    }
+    if (text === "1") {
+      if ("012".includes(digit)) {
+        return advance(
+          withSegment(state, "hour", segment(`1${digit}`, true)),
+          1
+        );
+      }
+      const moved = advance(withSegment(state, "hour", segment("1", true)), 1);
+      return typeDigit(moved, digit, step);
+    }
+    if (digit === "0") return state;
+    return advance(withSegment(state, "hour", segment(digit, true)), 1);
+  }
+  if (text === "") {
+    if (digit >= "6") {
+      return advance(
+        withSegment(
+          state,
+          "minute",
+          segment(snapMinute(digit, step), true, true)
+        ),
+        2
+      );
+    }
+    return withSegment(state, "minute", segment(digit, false));
+  }
+  return advance(
+    withSegment(state, "minute", segment(snapMinute(text + digit, step), true)),
+    2
+  );
+};
+const typePeriod = (state, letter, step = 1) => withSegment(
+  focusSegment(state, 2, step),
+  "period",
+  segment(letter === "a" ? "AM" : "PM", true)
+);
+const togglePeriod = (state) => withSegment(
+  state,
+  "period",
+  segment(state.period.text === "AM" ? "PM" : "AM", true)
+);
+const stepSegment = (state, direction, step = 1) => {
+  const key = SEGMENT_KEYS[state.active];
+  if (key === "hour") {
+    const hour = Number(state.hour.text) || (direction > 0 ? 0 : 1);
+    const next = (hour - 1 + direction + 12) % 12 + 1;
+    return withSegment(state, "hour", segment(String(next), true));
+  }
+  if (key === "minute") {
+    const minute = state.minute.text === "" ? direction > 0 ? -step : 0 : Number(state.minute.text);
+    const stepped = direction > 0 ? Math.floor(minute / step) * step + step : Math.ceil(minute / step) * step - step;
+    return withSegment(
+      state,
+      "minute",
+      segment(utils$2.padNumber((stepped + 60) % 60), true)
+    );
+  }
+  return togglePeriod(state);
+};
+const backspace = (state) => {
+  const moveBack = state[SEGMENT_KEYS[state.active]].text === "" && state.active > 0;
+  const active = moveBack ? clampIndex(state.active - 1) : state.active;
+  const key = SEGMENT_KEYS[active];
+  const current = state[key];
+  const text = key === "period" || current.auto ? "" : current.text.slice(0, -1);
+  return { ...withSegment(state, key, segment(text, false)), active };
+};
+const parsePastedTime = (text, step = 1) => {
+  const match = text.trim().toLowerCase().match(/^(\d{1,2}):?(\d{2})?\s*([ap])?\.?m?\.?$/);
+  if (!match) return null;
+  let hours = Number(match[1]);
+  const minutes = Number(match[2] ?? 0);
+  const period = match[3];
+  if (minutes > 59) return null;
+  if (period) {
+    if (hours < 1 || hours > 12) return null;
+    hours = hours % 12 + (period === "p" ? 12 : 0);
+  } else if (hours > 23) {
+    return null;
+  }
+  return { hours, minutes: Number(snapMinute(minutes, step)), seconds: 0 };
+};
+
+const PLACEHOLDERS = ["hh", "mm", "--"];
+const SegmentedTimeInput = ({
+  value,
+  minuteStep,
+  onChange,
+  onErrorChange,
+  invalid = false,
+  disabled = false,
+  autoFocus = false,
+  "aria-describedby": ariaDescribedBy
+}) => {
+  const { t } = reactI18next.useTranslation();
+  const fieldRef = React.useRef(null);
+  const step = minuteStep ?? 1;
+  const [time, setTime] = React.useState(
+    () => segmentedTimeFromValue(value, step)
+  );
+  const lastEmittedRef = React.useRef(value);
+  React.useEffect(() => {
+    if (utils$2.timeValueEquals(value, lastEmittedRef.current)) return;
+    lastEmittedRef.current = value;
+    setTime(segmentedTimeFromValue(value, step));
+  }, [value]);
+  const error = getSegmentedTimeError(time);
+  React.useEffect(() => {
+    onErrorChange(error);
+  }, [error, onErrorChange]);
+  React.useEffect(() => {
+    const snapped = segmentedTimeToValue(time);
+    if (snapped && !utils$2.timeValueEquals(snapped, value)) {
+      lastEmittedRef.current = snapped;
+      onChange(snapped);
+    }
+  }, []);
+  React.useEffect(() => {
+    if (autoFocus) fieldRef.current?.focus();
+  }, [autoFocus]);
+  const update = (next) => {
+    setTime(next);
+    const nextValue = segmentedTimeToValue(next);
+    if (!nextValue || utils$2.timeValueEquals(nextValue, lastEmittedRef.current)) {
+      return;
+    }
+    lastEmittedRef.current = nextValue;
+    onChange(nextValue);
+  };
+  const consume = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  const handleKeyDown = (event) => {
+    const { key } = event;
+    if (key === "Tab") {
+      if (!event.shiftKey || time.active !== 2) return;
+      consume(event);
+      update(togglePeriod(time));
+      return;
+    }
+    if ((event.metaKey || event.ctrlKey) && key === "Backspace") {
+      consume(event);
+      update(emptySegmentedTime());
+      return;
+    }
+    if (event.metaKey || event.ctrlKey || event.altKey) return;
+    let next = null;
+    if (/^[0-9]$/.test(key)) next = typeDigit(time, key, step);
+    else if (/^[ap]$/i.test(key)) {
+      next = typePeriod(time, key.toLowerCase(), step);
+    } else if (/^m$/i.test(key))
+      next = time;
+    else if (key === ":" || key === " " || key === "ArrowRight") {
+      next = nextSegment(time, step);
+    } else if (key === "ArrowLeft") next = previousSegment(time);
+    else if (key === "ArrowUp") next = stepSegment(time, 1, step);
+    else if (key === "ArrowDown") next = stepSegment(time, -1, step);
+    else if (key === "Backspace" || key === "Delete") next = backspace(time);
+    if (!next) return;
+    consume(event);
+    update(next);
+  };
+  const handlePaste = (event) => {
+    event.preventDefault();
+    const pasted = parsePastedTime(event.clipboardData.getData("text"), step);
+    if (pasted) update({ ...segmentedTimeFromValue(pasted, step), active: 2 });
+  };
+  const handleMouseDown = (event) => {
+    if (disabled) return;
+    const segmentEl = event.target.closest(
+      "[data-segment]"
+    );
+    if (segmentEl) {
+      event.preventDefault();
+      fieldRef.current?.focus();
+      update(focusSegment(time, Number(segmentEl.dataset.segment), step));
+      return;
+    }
+    update(focusFirstEmptySegment(time));
+  };
+  const segmentText = (index) => {
+    const { text, done } = time[SEGMENT_KEYS[index]];
+    if (!text) return PLACEHOLDERS[index];
+    return index < 2 && !done ? `${text}_` : text;
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: fieldRef,
+      role: "group",
+      tabIndex: disabled ? -1 : 0,
+      "aria-label": t("neetoatoms.datePicker.timeField", "Time"),
+      "aria-describedby": ariaDescribedBy,
+      "aria-invalid": invalid || void 0,
+      "aria-disabled": disabled || void 0,
+      "data-testid": "datepicker-time-input",
+      className: utils$1.cn(
+        "group/time flex h-9 w-full cursor-text items-center rounded-md border border-input bg-transparent px-3 text-sm tabular-nums outline-none select-none",
+        "focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50",
+        invalid && "border-destructive",
+        disabled && "pointer-events-none cursor-not-allowed opacity-50"
+      ),
+      onBlur: () => update(finishActiveSegment(time, step)),
+      onKeyDown: handleKeyDown,
+      onMouseDown: handleMouseDown,
+      onPaste: handlePaste,
+      children: SEGMENT_KEYS.map((key, index) => /* @__PURE__ */ jsxRuntime.jsxs(React__default.default.Fragment, { children: [
+        index === 1 && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, className: "px-0.5 text-muted-foreground", children: ":" }),
+        index === 2 && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, className: "w-1" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            "data-segment": index,
+            "data-testid": `datepicker-time-${key}`,
+            className: utils$1.cn(
+              "min-w-[2ch] px-0.5 text-center whitespace-pre",
+              !time[key].text && "text-muted-foreground",
+              index === time.active && "group-focus/time:shadow-[inset_0_-1.5px_0_var(--color-muted-foreground)]"
+            ),
+            children: segmentText(index)
+          }
+        )
+      ] }, key))
+    }
+  );
+};
+SegmentedTimeInput.displayName = "SegmentedTimeInput";
+
+const ERROR_DEFAULTS = {
+  timeRequired: "Enter a time, or turn off Add time.",
+  hourRequired: "Enter an hour.",
+  minuteRequired: "Enter minutes.",
+  periodRequired: "Type a or p for AM or PM."
+};
+const stepExamples = (step) => {
+  const pad = (minutes) => `1:${String(minutes).padStart(2, "0")}`;
+  if (step * 2 >= 60) return [pad(0), pad(step)];
+  return [pad(step), pad(30 % step === 0 && step < 30 ? 30 : step * 2)];
+};
+const TimeSection = ({
+  value,
+  minuteStep,
+  onChange,
+  onErrorChange,
+  showError,
+  optional,
+  hasTime,
+  onHasTimeChange,
+  timezoneLabel,
+  disabled = false,
+  className
+}) => {
+  const { t } = reactI18next.useTranslation();
+  const id = React.useId();
+  const switchId = `datepicker-add-time-${id}`;
+  const hintId = `datepicker-time-hint-${id}`;
+  const errorId = `datepicker-time-error-${id}`;
+  const [error, setError] = React.useState(null);
+  const [focusOnMount, setFocusOnMount] = React.useState(false);
+  const handleErrorChange = React.useCallback(
+    (nextError) => {
+      setError(nextError);
+      onErrorChange(!!nextError);
+    },
+    [onErrorChange]
+  );
+  const handleHasTimeChange = (checked) => {
+    setFocusOnMount(checked);
+    if (!checked) {
+      setError(null);
+      onErrorChange(false);
+    }
+    onHasTimeChange(checked);
+  };
+  const isTimeOn = !optional || hasTime;
+  const showHint = (minuteStep ?? 1) > 1;
+  const errorMessage = isTimeOn && showError && error ? t(`neetoatoms.datePicker.errors.${error}`, ERROR_DEFAULTS[error]) : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: utils$1.cn("flex flex-col gap-2", className), children: [
+    optional && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        primitives_Label.Label,
+        {
+          htmlFor: switchId,
+          className: "flex items-center gap-2 font-medium",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(utils$2.Clock, { "aria-hidden": true, className: "size-4 text-muted-foreground" }),
+            t("neetoatoms.datePicker.addTime", "Add time")
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        primitives_Switch.Switch,
+        {
+          id: switchId,
+          checked: hasTime,
+          "data-testid": "datepicker-add-time-switch",
+          disabled,
+          onCheckedChange: handleHasTimeChange
+        }
+      )
+    ] }),
+    isTimeOn && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        SegmentedTimeInput,
+        {
+          "aria-describedby": [showHint ? hintId : null, errorMessage ? errorId : null].filter(Boolean).join(" ") || void 0,
+          autoFocus: focusOnMount,
+          disabled,
+          invalid: !!errorMessage,
+          minuteStep,
+          value,
+          onChange,
+          onErrorChange: handleErrorChange
+        }
+      ),
+      showHint && /* @__PURE__ */ jsxRuntime.jsx(
+        "p",
+        {
+          id: hintId,
+          className: "text-xs text-muted-foreground",
+          "data-testid": "datepicker-time-hint",
+          children: t("neetoatoms.datePicker.timeHint", {
+            step: minuteStep,
+            first: stepExamples(minuteStep)[0],
+            second: stepExamples(minuteStep)[1],
+            defaultValue: "Only {{step}}-minute steps are allowed, like {{first}} or {{second}}."
+          })
+        }
+      ),
+      errorMessage && /* @__PURE__ */ jsxRuntime.jsx(
+        "p",
+        {
+          id: errorId,
+          className: "text-xs text-destructive",
+          "data-testid": "datepicker-time-error",
+          role: "alert",
+          children: errorMessage
+        }
+      ),
+      timezoneLabel && /* @__PURE__ */ jsxRuntime.jsxs(
+        "p",
+        {
+          className: "mt-1 flex items-center gap-2 text-xs text-muted-foreground",
+          "data-testid": "datepicker-timezone",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(Globe, { "aria-hidden": true, className: "size-3.5 shrink-0" }),
+            timezoneLabel
+          ]
+        }
+      )
+    ] })
+  ] });
+};
+TimeSection.displayName = "TimeSection";
+
 const MonthPicker = ({
   value,
   displayedYear,
@@ -509,11 +994,12 @@ const RangeCalendar = ({
   selected,
   onSelect,
   disabled,
-  fromDate,
-  toDate,
+  startMonth,
+  endMonth,
   onHoverIn,
   onHoverOut,
-  numberOfMonths = 2
+  numberOfMonths = 2,
+  className
 }) => /* @__PURE__ */ jsxRuntime.jsx("div", { onMouseOver: onHoverIn, onMouseLeave: onHoverOut, children: /* @__PURE__ */ jsxRuntime.jsx(
   primitives_Calendar.Calendar,
   {
@@ -522,14 +1008,17 @@ const RangeCalendar = ({
     captionLayout: "dropdown",
     today: todayDate,
     weekStartsOn,
-    className: "[&_[data-outside][data-selected=true]]:!bg-transparent [&_[data-outside][data-selected=true]]:after:!bg-transparent [&_[data-outside]_button]:!bg-transparent [&_[data-outside]_button]:!text-muted-foreground",
+    className: utils$1.cn(
+      "[&_[data-outside][data-selected=true]]:!bg-transparent [&_[data-outside][data-selected=true]]:after:!bg-transparent [&_[data-outside]_button]:!bg-transparent [&_[data-outside]_button]:!text-muted-foreground",
+      className
+    ),
     month,
     onMonthChange,
     selected,
     onSelect,
     disabled,
-    ...fromDate && { fromDate },
-    ...toDate && { toDate }
+    startMonth,
+    endMonth
   }
 ) });
 
@@ -696,6 +1185,11 @@ const YearPicker = ({
   ] });
 };
 
+const TIME_SECTION_CLASS_NAME = "w-0 min-w-full border-t border-border px-3 py-3";
+const SHOW_TIME_CALENDAR_CLASS_NAME = "[--cell-size:--spacing(8.125)]";
+const DEFAULT_ADDED_TIME = { hours: 12, minutes: 0, seconds: 0 };
+const noop = () => {
+};
 const DatePicker = React.forwardRef(
   ({
     value,
@@ -706,8 +1200,10 @@ const DatePicker = React.forwardRef(
     dateFormat = DEFAULT_DATE_FORMAT,
     timeFormat = DEFAULT_TIME_FORMAT,
     showTime = false,
-    timePickerFormat,
-    showSeconds = false,
+    showNow = true,
+    minuteStep,
+    timeOptional = true,
+    hasTime: hasTimeProp,
     minDate,
     maxDate,
     disabledDate,
@@ -720,6 +1216,7 @@ const DatePicker = React.forwardRef(
     allowClear = true,
     required = false,
     timezone,
+    timezoneLabel: timezoneLabelProp,
     onTimezoneChange,
     onOk,
     needConfirm = false,
@@ -744,7 +1241,7 @@ const DatePicker = React.forwardRef(
     const popoverContentId = React.useRef(
       `datepicker-popover-${generatedId}`
     ).current;
-    const { open, setOpen } = TimePickerPanel.useControlledOpen(openProp, onOpenChange);
+    const { open, setOpen } = utils$2.useControlledOpen(openProp, onOpenChange);
     const [internalValue, setInternalValue] = React.useState(
       coerceDateValue(defaultValue, type) ?? null
     );
@@ -754,6 +1251,15 @@ const DatePicker = React.forwardRef(
     const [pendingDate, setPendingDate] = React.useState(null);
     const [pendingTime, setPendingTime] = React.useState(INITIAL_TIME_VALUE);
     const [pendingTimeTo, setPendingTimeTo] = React.useState(INITIAL_TIME_VALUE);
+    const [hasTimeError, setHasTimeError] = React.useState(false);
+    const [isTimeErrorRequested, setIsTimeErrorRequested] = React.useState(false);
+    const isTimeOptional = showTime && timeOptional && type === "date";
+    const [internalHasTime, setInternalHasTime] = React.useState(
+      () => hasTimeProp ?? (value ?? defaultValue) != null
+    );
+    const committedHasTime = showTime && (!isTimeOptional || (hasTimeProp ?? internalHasTime));
+    const [pendingHasTime, setPendingHasTime] = React.useState(committedHasTime);
+    const isPendingTimeOn = showTime && (!isTimeOptional || pendingHasTime);
     const currentValue = React.useMemo(
       () => value !== void 0 ? coerceDateValue(value, type) : internalValue,
       [value, type, internalValue]
@@ -766,10 +1272,13 @@ const DatePicker = React.forwardRef(
       () => toNativeDate(maxDate) ?? void 0,
       [maxDate]
     );
-    const displayFormat = getDisplayFormat(dateFormat, timeFormat, showTime);
+    const displayFormat = getDisplayFormat(
+      dateFormat,
+      timeFormat,
+      committedHasTime
+    );
     const sizeConfig = SIZE_CONFIG[size];
-    const maskEnabled = TimePickerPanel.isFixedWidthFormat(displayFormat);
-    const effectiveTimePickerFormat = timePickerFormat ?? (/\ba\b/i.test(timeFormat) ? "12" : "24");
+    const maskEnabled = utils$2.isFixedWidthFormat(displayFormat);
     const defaultPlaceholder = getDatePlaceholder(
       dateFormat,
       timeFormat,
@@ -777,11 +1286,11 @@ const DatePicker = React.forwardRef(
       type
     );
     const maskTemplate = React.useMemo(
-      () => maskEnabled ? type === "range" ? TimePickerPanel.buildRangeMaskTemplate(displayFormat) : TimePickerPanel.buildMaskTemplate(displayFormat) : null,
+      () => maskEnabled ? type === "range" ? utils$2.buildRangeMaskTemplate(displayFormat) : utils$2.buildMaskTemplate(displayFormat) : null,
       [displayFormat, type, maskEnabled]
     );
     const singleDateLen = React.useMemo(
-      () => TimePickerPanel.buildMaskTemplate(displayFormat).pattern.length,
+      () => utils$2.buildMaskTemplate(displayFormat).pattern.length,
       [displayFormat]
     );
     const calendarDisabled = React.useCallback(
@@ -806,38 +1315,46 @@ const DatePicker = React.forwardRef(
       return `${from} - ${to}`;
     }, [currentValue, displayFormat, type]);
     const [inputText, setInputText] = React.useState(() => getDisplayText());
-    const commitValue = (date) => {
+    const emitChange = (changed, formatted, withTime) => {
+      if (isTimeOptional) onChange?.(changed, formatted, { hasTime: withTime });
+      else onChange?.(changed, formatted);
+    };
+    const commitValue = (date, withTime = committedHasTime) => {
       if (date === null) {
         setInternalValue(null);
+        setInternalHasTime(false);
         if (type === "range") {
-          onChange?.([null, null], ["", ""]);
+          emitChange([null, null], ["", ""], false);
         } else {
-          onChange?.(null, "");
+          emitChange(null, "", false);
         }
         setInputText("");
         return;
       }
+      const commitFormat = getDisplayFormat(dateFormat, timeFormat, withTime);
       const toSerializableDayjs = (d) => {
         const userTzDayjs = toUserTzDayjs(d);
-        if (showTime) return userTzDayjs;
+        if (withTime) return userTzDayjs;
         return userTzDayjs.hour(12).minute(0).second(0).millisecond(0);
       };
       if (Array.isArray(date)) {
         setInternalValue(date);
         const formatted2 = [
-          formatDate(date[0], displayFormat),
-          formatDate(date[1], displayFormat)
+          formatDate(date[0], commitFormat),
+          formatDate(date[1], commitFormat)
         ];
-        onChange?.(
+        emitChange(
           [toSerializableDayjs(date[0]), toSerializableDayjs(date[1])],
-          formatted2
+          formatted2,
+          withTime
         );
         setInputText(`${formatted2[0]} - ${formatted2[1]}`);
         return;
       }
       setInternalValue(date);
-      const formatted = formatDate(date, displayFormat);
-      onChange?.(toSerializableDayjs(date), formatted);
+      setInternalHasTime(withTime);
+      const formatted = formatDate(date, commitFormat);
+      emitChange(toSerializableDayjs(date), formatted, withTime);
       setInputText(formatted);
     };
     const {
@@ -897,30 +1414,33 @@ const DatePicker = React.forwardRef(
     };
     const commitPendingOnClose = React.useCallback(() => {
       const hasOkButton = showTime || needConfirm;
-      if (!hasOkButton || !pendingDate) {
+      if (!hasOkButton || !pendingDate || isPendingTimeOn && hasTimeError) {
         setInputText(getDisplayText());
         return;
       }
-      const finalDate = showTime ? applyTimeToDate(pendingDate, pendingTime) : pendingDate;
+      const finalDate = isPendingTimeOn ? applyTimeToDate(pendingDate, pendingTime) : pendingDate;
       const currentSingle = type === "date" ? currentValue : null;
-      const isSame = currentSingle && finalDate.getTime() === currentSingle.getTime();
+      const isSame = currentSingle && isPendingTimeOn === committedHasTime && finalDate.getTime() === currentSingle.getTime();
       if (isSame) {
         setInputText(getDisplayText());
         return;
       }
-      commitValue(finalDate);
+      commitValue(finalDate, isPendingTimeOn);
     }, [
       showTime,
       needConfirm,
       pendingDate,
       pendingTime,
+      isPendingTimeOn,
+      committedHasTime,
       type,
       currentValue,
       getDisplayText,
-      onChange
+      onChange,
+      hasTimeError
     ]);
     const closePopover = React.useCallback(() => {
-      if (type === "range" && pendingRange?.[0] && pendingRange?.[1]) {
+      if (type === "range" && pendingRange?.[0] && pendingRange?.[1] && !(showTime && hasTimeError)) {
         const [fromBase, toBase] = orderRange(
           pendingRange[0],
           pendingRange[1]
@@ -941,9 +1461,10 @@ const DatePicker = React.forwardRef(
       pendingTime,
       pendingTimeTo,
       showTime,
-      resetTransientState
+      resetTransientState,
+      hasTimeError
     ]);
-    TimePickerPanel.useOutsideClickClose({
+    utils$2.useOutsideClickClose({
       enabled: open,
       containerRef,
       popoverElementId: popoverContentId,
@@ -952,26 +1473,32 @@ const DatePicker = React.forwardRef(
     const openPopover = () => {
       setOpen(true);
       resetTransientState();
+      setIsTimeErrorRequested(false);
       if (type === "range") {
         const rangeVal = currentValue;
         const fromDate = rangeVal?.[0] ?? null;
         const toDate = rangeVal?.[1] ?? null;
         setPendingDate(null);
         setPendingTime(
-          fromDate ? TimePickerPanel.dateToTimeValue(fromDate) : INITIAL_TIME_VALUE
+          fromDate ? utils$2.dateToTimeValue(fromDate) : INITIAL_TIME_VALUE
         );
-        setPendingTimeTo(toDate ? TimePickerPanel.dateToTimeValue(toDate) : INITIAL_TIME_VALUE);
+        setPendingTimeTo(toDate ? utils$2.dateToTimeValue(toDate) : INITIAL_TIME_VALUE);
         return;
       }
       const dateVal = currentValue;
+      setPendingHasTime(committedHasTime);
       if (!dateVal) {
         setPendingDate(null);
-        setPendingTime(INITIAL_TIME_VALUE);
+        setPendingTime(
+          isTimeOptional ? DEFAULT_ADDED_TIME : INITIAL_TIME_VALUE
+        );
         return;
       }
       setCalendarMonth(dateVal);
       setPendingDate(dateVal);
-      setPendingTime(TimePickerPanel.dateToTimeValue(dateVal));
+      setPendingTime(
+        committedHasTime || !isTimeOptional ? utils$2.dateToTimeValue(dateVal) : DEFAULT_ADDED_TIME
+      );
     };
     const handleDateSelect = (selected) => {
       if (!selected) return;
@@ -984,13 +1511,15 @@ const DatePicker = React.forwardRef(
       setOpen(false);
     };
     const handleNow = () => {
-      const now = toBrowserLocalDate(/* @__PURE__ */ new Date());
+      const now = toBrowserLocalDate(
+        showTime && minuteStep ? roundUpToMinuteStep(/* @__PURE__ */ new Date(), minuteStep) : /* @__PURE__ */ new Date()
+      );
       if (calendarDisabled(now)) return;
       setCalendarMonth(now);
       if (type === "range") {
         handleRangeSelect(void 0, now);
         if (showTime) {
-          const nowTime = TimePickerPanel.dateToTimeValue(now);
+          const nowTime = utils$2.dateToTimeValue(now);
           if (rangeSelectionStep === "from") setPendingTime(nowTime);
           else setPendingTimeTo(nowTime);
         }
@@ -998,13 +1527,18 @@ const DatePicker = React.forwardRef(
       }
       if (showTime || needConfirm) {
         setPendingDate(now);
-        setPendingTime(TimePickerPanel.dateToTimeValue(now));
+        setPendingTime(utils$2.dateToTimeValue(now));
+        if (isTimeOptional) setPendingHasTime(true);
         return;
       }
       commitValue(now);
       setOpen(false);
     };
     const handleOk = () => {
+      if (isPendingTimeOn && hasTimeError) {
+        setIsTimeErrorRequested(true);
+        return;
+      }
       if (type === "range" && (showTime || needConfirm)) {
         const committedRange = currentValue;
         const fromValue = pendingRange?.[0] ?? committedRange?.[0] ?? null;
@@ -1023,7 +1557,7 @@ const DatePicker = React.forwardRef(
           const [fromBase, toBase] = orderRange(fromValue, toValue);
           const fromFinal = showTime ? applyTimeToDate(fromBase, pendingTime) : fromBase;
           const toFinal = showTime ? applyTimeToDate(toBase, pendingTimeTo) : toBase;
-          commitValue([fromFinal, toFinal]);
+          commitValue([fromFinal, toFinal], showTime);
           onOk?.([fromFinal, toFinal]);
           resetTransientState();
           setOpen(false);
@@ -1032,8 +1566,8 @@ const DatePicker = React.forwardRef(
         return;
       }
       if (pendingDate) {
-        const finalDate = showTime ? applyTimeToDate(pendingDate, pendingTime) : pendingDate;
-        commitValue(finalDate);
+        const finalDate = isPendingTimeOn ? applyTimeToDate(pendingDate, pendingTime) : pendingDate;
+        commitValue(finalDate, isPendingTimeOn);
         onOk?.(finalDate);
       }
       setOpen(false);
@@ -1046,7 +1580,7 @@ const DatePicker = React.forwardRef(
     const handleInputChange = (e) => {
       let text = e.target.value;
       if (maskTemplate) {
-        const masked = TimePickerPanel.applyMask(
+        const masked = utils$2.applyMask(
           text,
           maskTemplate,
           inputText,
@@ -1067,7 +1601,7 @@ const DatePicker = React.forwardRef(
       setCalendarMonth(parsed);
       if (showTime || needConfirm) {
         setPendingDate(parsed);
-        setPendingTime(TimePickerPanel.dateToTimeValue(parsed));
+        setPendingTime(utils$2.dateToTimeValue(parsed));
         return;
       }
       commitValue(parsed);
@@ -1088,10 +1622,21 @@ const DatePicker = React.forwardRef(
           maskEnabled,
           singleDateLen
         );
-        if (range) commitValue(range);
+        if (range) {
+          commitValue(
+            showTime && minuteStep ? [
+              roundToMinuteStep(range[0], minuteStep),
+              roundToMinuteStep(range[1], minuteStep)
+            ] : range
+          );
+        }
       } else {
         const parsed = parseDate(inputText, displayFormat);
-        if (parsed) commitValue(parsed);
+        if (parsed) {
+          commitValue(
+            committedHasTime && minuteStep ? roundToMinuteStep(parsed, minuteStep) : parsed
+          );
+        }
       }
       setOpen(false);
     };
@@ -1105,16 +1650,38 @@ const DatePicker = React.forwardRef(
     React.useEffect(() => {
       if (!open) setInputText(getDisplayText());
     }, [getDisplayText, open]);
-    TimePickerPanel.useCursorRestore([{ inputRef, cursorRef: cursorPosRef }]);
+    utils$2.useCursorRestore([{ inputRef, cursorRef: cursorPosRef }]);
     React.useEffect(() => {
       if (!open || type !== "date") return;
       const dateVal = currentValue;
       if (dateVal instanceof Date) setCalendarMonth(dateVal);
     }, [open]);
+    const timezoneLabel = showTime && !onTimezoneChange ? (timezoneLabelProp ?? getTimezoneLabel(timezone)) || null : null;
     const hasField = !!(label || error || helpText);
     const testIdPrefix = fieldIds.buildTestIdPrefix(dataTestId, label);
     const showFooter = showTime || needConfirm || !!onTimezoneChange;
     const todayDate = toBrowserLocalDate(/* @__PURE__ */ new Date());
+    const handleHasTimeChange = (checked) => {
+      setPendingHasTime(checked);
+      setIsTimeErrorRequested(false);
+      if (!checked) setHasTimeError(false);
+      if (checked && !pendingDate && !calendarDisabled(todayDate)) {
+        setPendingDate(todayDate);
+        setCalendarMonth(todayDate);
+      }
+    };
+    const defaultStartMonth = new Date(
+      todayDate.getFullYear() - CALENDAR_NAVIGATION_YEAR_RANGE,
+      0,
+      1
+    );
+    const defaultEndMonth = new Date(
+      todayDate.getFullYear() + CALENDAR_NAVIGATION_YEAR_RANGE,
+      11,
+      1
+    );
+    const calendarStartMonth = normalizedMinDate ?? (calendarMonth < defaultStartMonth ? calendarMonth : defaultStartMonth);
+    const calendarEndMonth = normalizedMaxDate ?? (calendarMonth > defaultEndMonth ? calendarMonth : defaultEndMonth);
     const handleGridPickerSelect = (date) => {
       commitValue(date);
       setOpen(false);
@@ -1201,99 +1768,110 @@ const DatePicker = React.forwardRef(
               onPointerDownOutside: (e) => e.preventDefault(),
               onInteractOutside: (e) => e.preventDefault(),
               children: [
-                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: utils$1.cn("flex", showTime && "flex-row"), children: [
-                  type === "date" && picker === "month" ? /* @__PURE__ */ jsxRuntime.jsx(
-                    MonthPicker,
-                    {
-                      value: currentValue ?? null,
-                      displayedYear: calendarMonth.getFullYear(),
-                      onYearChange: (year) => setCalendarMonth(
-                        new Date(year, calendarMonth.getMonth(), 1)
-                      ),
-                      onSelect: handleGridPickerSelect,
-                      isDisabled: (date) => isMonthDisabled(date, normalizedMinDate, normalizedMaxDate)
-                    }
-                  ) : type === "date" && picker === "year" ? /* @__PURE__ */ jsxRuntime.jsx(
-                    YearPicker,
-                    {
-                      value: currentValue ?? null,
-                      displayedYear: calendarMonth.getFullYear(),
-                      onYearChange: (year) => setCalendarMonth(new Date(year, 0, 1)),
-                      onSelect: handleGridPickerSelect,
-                      isDisabled: (date) => isYearDisabled(date, normalizedMinDate, normalizedMaxDate)
-                    }
-                  ) : type === "date" ? /* @__PURE__ */ jsxRuntime.jsx(
-                    primitives_Calendar.Calendar,
-                    {
-                      mode: "single",
-                      captionLayout: "dropdown",
-                      today: todayDate,
-                      month: calendarMonth,
-                      onMonthChange: setCalendarMonth,
-                      selected: calendarSelected(),
-                      onSelect: handleSingleDateSelectWithPicker,
-                      disabled: calendarDisabled,
-                      weekStartsOn,
-                      classNames: weekRowHoverClassName ? { week: utils$1.cn("mt-2 flex w-full", weekRowHoverClassName) } : void 0,
-                      ...weekHighlightProps,
-                      ...normalizedMinDate && { fromDate: normalizedMinDate },
-                      ...normalizedMaxDate && { toDate: normalizedMaxDate }
-                    }
-                  ) : showTime ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                    /* @__PURE__ */ jsxRuntime.jsx(
-                      RangeCalendar,
-                      {
-                        todayDate,
-                        weekStartsOn,
-                        month: calendarMonth,
-                        onMonthChange: setCalendarMonth,
-                        selected: memoizedRangeSelected,
-                        onSelect: handleRangeSelect,
-                        disabled: calendarDisabled,
-                        fromDate: normalizedMinDate,
-                        toDate: normalizedMaxDate,
-                        onHoverIn: handleHoverIn,
-                        onHoverOut: handleHoverOut,
-                        numberOfMonths: 1
-                      }
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex", children: type === "date" && picker === "month" ? /* @__PURE__ */ jsxRuntime.jsx(
+                  MonthPicker,
+                  {
+                    value: currentValue ?? null,
+                    displayedYear: calendarMonth.getFullYear(),
+                    onYearChange: (year) => setCalendarMonth(
+                      new Date(year, calendarMonth.getMonth(), 1)
                     ),
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-inline-start border-border pt-2", children: /* @__PURE__ */ jsxRuntime.jsx(
-                      TimePickerPanel.TimePickerPanel,
-                      {
-                        value: rangeSelectionStep === "from" ? pendingTime : pendingTimeTo,
-                        onChange: rangeSelectionStep === "from" ? setPendingTime : setPendingTimeTo,
-                        format: effectiveTimePickerFormat,
-                        showSeconds,
-                        disabled
-                      }
-                    ) })
-                  ] }) : /* @__PURE__ */ jsxRuntime.jsx(
-                    RangeCalendar,
-                    {
-                      todayDate,
-                      weekStartsOn,
-                      month: calendarMonth,
-                      onMonthChange: setCalendarMonth,
-                      selected: memoizedRangeSelected,
-                      onSelect: handleRangeSelect,
-                      disabled: calendarDisabled,
-                      fromDate: normalizedMinDate,
-                      toDate: normalizedMaxDate,
-                      onHoverIn: handleHoverIn,
-                      onHoverOut: handleHoverOut
-                    }
-                  ),
-                  showTime && type !== "range" && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-inline-start border-border", children: /* @__PURE__ */ jsxRuntime.jsx(
-                    TimePickerPanel.TimePickerPanel,
-                    {
-                      value: pendingTime,
-                      onChange: setPendingTime,
-                      format: effectiveTimePickerFormat,
-                      showSeconds,
-                      disabled
-                    }
-                  ) })
-                ] }),
+                    onSelect: handleGridPickerSelect,
+                    isDisabled: (date) => isMonthDisabled(date, normalizedMinDate, normalizedMaxDate)
+                  }
+                ) : type === "date" && picker === "year" ? /* @__PURE__ */ jsxRuntime.jsx(
+                  YearPicker,
+                  {
+                    value: currentValue ?? null,
+                    displayedYear: calendarMonth.getFullYear(),
+                    onYearChange: (year) => setCalendarMonth(new Date(year, 0, 1)),
+                    onSelect: handleGridPickerSelect,
+                    isDisabled: (date) => isYearDisabled(date, normalizedMinDate, normalizedMaxDate)
+                  }
+                ) : type === "date" ? /* @__PURE__ */ jsxRuntime.jsx(
+                  primitives_Calendar.Calendar,
+                  {
+                    className: utils$1.cn(showTime && SHOW_TIME_CALENDAR_CLASS_NAME),
+                    mode: "single",
+                    captionLayout: "dropdown",
+                    today: todayDate,
+                    month: calendarMonth,
+                    onMonthChange: setCalendarMonth,
+                    selected: calendarSelected(),
+                    onSelect: handleSingleDateSelectWithPicker,
+                    disabled: calendarDisabled,
+                    weekStartsOn,
+                    classNames: weekRowHoverClassName ? { week: utils$1.cn("mt-2 flex w-full", weekRowHoverClassName) } : void 0,
+                    ...weekHighlightProps,
+                    startMonth: calendarStartMonth,
+                    endMonth: calendarEndMonth
+                  }
+                ) : showTime ? /* @__PURE__ */ jsxRuntime.jsx(
+                  RangeCalendar,
+                  {
+                    className: SHOW_TIME_CALENDAR_CLASS_NAME,
+                    todayDate,
+                    weekStartsOn,
+                    month: calendarMonth,
+                    onMonthChange: setCalendarMonth,
+                    selected: memoizedRangeSelected,
+                    onSelect: handleRangeSelect,
+                    disabled: calendarDisabled,
+                    startMonth: calendarStartMonth,
+                    endMonth: calendarEndMonth,
+                    onHoverIn: handleHoverIn,
+                    onHoverOut: handleHoverOut,
+                    numberOfMonths: 1
+                  }
+                ) : /* @__PURE__ */ jsxRuntime.jsx(
+                  RangeCalendar,
+                  {
+                    todayDate,
+                    weekStartsOn,
+                    month: calendarMonth,
+                    onMonthChange: setCalendarMonth,
+                    selected: memoizedRangeSelected,
+                    onSelect: handleRangeSelect,
+                    disabled: calendarDisabled,
+                    startMonth: calendarStartMonth,
+                    endMonth: calendarEndMonth,
+                    onHoverIn: handleHoverIn,
+                    onHoverOut: handleHoverOut
+                  }
+                ) }),
+                showTime && type === "range" && /* @__PURE__ */ jsxRuntime.jsx(
+                  TimeSection,
+                  {
+                    className: TIME_SECTION_CLASS_NAME,
+                    disabled,
+                    hasTime: true,
+                    optional: false,
+                    showError: isTimeErrorRequested,
+                    timezoneLabel,
+                    value: rangeSelectionStep === "from" ? pendingTime : pendingTimeTo,
+                    onChange: rangeSelectionStep === "from" ? setPendingTime : setPendingTimeTo,
+                    minuteStep,
+                    onErrorChange: setHasTimeError,
+                    onHasTimeChange: noop
+                  },
+                  rangeSelectionStep
+                ),
+                showTime && type !== "range" && /* @__PURE__ */ jsxRuntime.jsx(
+                  TimeSection,
+                  {
+                    className: TIME_SECTION_CLASS_NAME,
+                    disabled,
+                    hasTime: pendingHasTime,
+                    optional: isTimeOptional,
+                    showError: isTimeErrorRequested,
+                    timezoneLabel,
+                    value: pendingTime,
+                    onChange: setPendingTime,
+                    minuteStep,
+                    onErrorChange: setHasTimeError,
+                    onHasTimeChange: handleHasTimeChange
+                  }
+                ),
                 showFooter && /* @__PURE__ */ jsxRuntime.jsx(
                   DatePickerFooter,
                   {
@@ -1302,6 +1880,7 @@ const DatePicker = React.forwardRef(
                     timezone,
                     onTimezoneChange,
                     nowDisabled: calendarDisabled(todayDate),
+                    showNow,
                     onNow: handleNow,
                     onOk: handleOk,
                     okLabel: type === "range" && (showTime || needConfirm) && rangeSelectionStep === "from" ? "Next" : "OK"
@@ -1338,4 +1917,4 @@ const DatePicker = React.forwardRef(
 DatePicker.displayName = "DatePicker";
 
 exports.DatePicker = DatePicker;
-//# sourceMappingURL=DatePicker-D8GQGON2.js.map
+//# sourceMappingURL=DatePicker-aGLz-3Bz.js.map