@ultraviolet/ui 1.83.2 → 1.84.1

package/dist/components/TimeInputV2/index.cjs

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("@emotion/react/jsx-runtime");
+const _styled = require("@emotion/styled/base");
+const Icon = require("@ultraviolet/icons");
+const React = require("react");
+const index$2 = require("../Button/index.cjs");
+const index = require("../Stack/index.cjs");
+const index$1 = require("../Text/index.cjs");
+const constants = require("./constants.cjs");
+const helpers = require("./helpers.cjs");
+const _interopDefaultCompat = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const _styled__default = /* @__PURE__ */ _interopDefaultCompat(_styled);
+function _EMOTION_STRINGIFIED_CSS_ERROR__() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+const TimeInputWrapper = /* @__PURE__ */ _styled__default.default(index.Stack, process.env.NODE_ENV === "production" ? {
+  target: "e8pjt8k3"
+} : {
+  target: "e8pjt8k3",
+  label: "TimeInputWrapper"
+})("display:flex;cursor:text;padding:", ({
+  theme
+}) => theme.space[1], ";box-shadow:none;background:", ({
+  theme
+}) => theme.colors.neutral.background, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";border:1px solid ", ({
+  theme
+}) => theme.colors.neutral.border, ';&:not([data-disabled="true"]):not([data-readonly="true"]):active{border-color:', ({
+  theme
+}) => theme.colors.primary.borderHover, ";box-shadow:", ({
+  theme
+}) => theme.shadows.focusPrimary, ';}&[data-disabled="false"]:hover,[data-disabled="false"]:focus{border-color:', ({
+  theme
+}) => theme.colors.primary.borderHover, ";outline:none;}&:focus-within{border-color:", ({
+  theme
+}) => theme.colors.primary.borderHover, ";}&[data-size='small']{height:", ({
+  theme
+}) => theme.sizing[constants.INPUT_SIZE_HEIGHT.small], ";padding-left:", ({
+  theme
+}) => theme.space[1], ";}&[data-size='medium']{height:", ({
+  theme
+}) => theme.sizing[constants.INPUT_SIZE_HEIGHT.medium], ";}&[data-size='large']{height:", ({
+  theme
+}) => theme.sizing[constants.INPUT_SIZE_HEIGHT.large], ";}&[data-readonly='true']{background:", ({
+  theme
+}) => theme.colors.neutral.backgroundWeak, ";border-color:", ({
+  theme
+}) => theme.colors.neutral.border, ";cursor:default;}&[data-disabled='true']{background:", ({
+  theme
+}) => theme.colors.neutral.backgroundDisabled, ";border-color:", ({
+  theme
+}) => theme.colors.neutral.borderDisabled, ";cursor:not-allowed;user-select:none;}&[data-error='true']{border:1px solid ", ({
+  theme
+}) => theme.colors.danger.border, ';&:not([data-disabled="true"]):not([data-readonly="true"]):active{border-color:', ({
+  theme
+}) => theme.colors.danger.borderHover, ";box-shadow:", ({
+  theme
+}) => theme.shadows.focusDanger, ';}&:not([data-disabled="true"]):not([data-readonly="true"]):hover{border-color:', ({
+  theme
+}) => theme.colors.danger.borderHover, ";}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx"],"names":[],"mappings":"AAqCE","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { AlertCircleIcon, AsteriskIcon } from '@ultraviolet/icons'\nimport type { FocusEvent, ReactNode } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport type { LabelProp } from '../../types'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport {\n  DEFAULT_DATE,\n  DEFAULT_PLACEHOLDER,\n  INPUT_SIZE_HEIGHT,\n  TIME_KEYS,\n} from './constants'\nimport {\n  canConcat,\n  format,\n  getLastTypedChar,\n  getValueByType,\n  isAOrP,\n  isCompleteHour,\n  isNumber,\n  setValueByType,\n} from './helpers'\n\nexport type Time = {\n  h: string\n  m: string\n  s: string\n  period?: string\n}\n\nconst TimeInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-error': boolean\n}>`\n  display: flex;\n  cursor: text;\n  padding: ${({ theme }) => theme.space[1]};\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n\n  &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n  \n  &[data-disabled=\"false\"]:hover,\n  [data-disabled=\"false\"]:focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-size='small'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.small]};\n    padding-left: ${({ theme }) => theme.space[1]};\n  }\n\n  &[data-size='medium'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.medium]};\n  }\n\n  &[data-size='large'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.large]};\n  }\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-error='true'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n      box-shadow: ${({ theme }) => theme.shadows.focusDanger};\n    }\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):hover {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n    }\n  }\n`\n\nexport const Input = styled.input<{\n  'data-size': 'small' | 'medium' | 'large'\n  'data-period'?: boolean\n}>`\n  border: none;\n  outline: none;\n  background: transparent;\n  font-size: ${({ theme }) => theme.typography.bodySmall.fontSize};\n  width: ${({ theme }) => theme.sizing[312]};\n  height: ${({ theme }) => theme.sizing[300]};\n  text-align: center;\n  border-radius: ${({ theme }) => theme.radii.default};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  caret-color: transparent;\n\n  &[data-size='large'] {\n    font-size: ${({ theme }) => theme.typography.body.fontSize};\n  }\n\n  &:not(:disabled):hover {\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundHover};\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  &:not(:disabled):active, \n  :not(:disabled):focus{\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundStrong};\n    color:  ${({ theme }) => theme.colors.neutral.text};\n  }\n\n  &:read-only {\n    cursor: default;\n  }\n\n  &:disabled {\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-period=\"true\"] {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  ::-moz-selection {\n    background: none;\n  }\n\n  ::selection {\n    background: none;\n  }\n`\n\nconst CustomText = styled(Text)`\npadding-inline: ${({ theme }) => theme.space['0.25']};\n`\nconst StyledText = styled(Text)`\ncursor: text;\n`\n\ntype TimeInputProps = {\n  placeholder?: Time\n  value?: Date\n  clearable?: boolean\n  required?: boolean\n  labelDescription?: ReactNode\n  helper?: ReactNode\n  disabled?: boolean\n  readOnly?: boolean\n  error?: boolean | string\n  'data-testid'?: string\n  onChange?: (value: Date | undefined, valuePeriod?: string) => void\n  onBlur?: (event: FocusEvent<HTMLInputElement>) => void\n  onFocus?: (event: FocusEvent<HTMLInputElement>) => void\n  className?: string\n  id?: string\n  size?: 'small' | 'medium' | 'large'\n  timeFormat?: 12 | 24\n  /**\n   * Automatically focus on the element on render. Autofocus is applied to the hour input\n   */\n  autoFocus?: boolean\n} & LabelProp\n\n/**\n * A time input component that allows users to type a time in a 24 or 12-hour format.\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const TimeInputV2 = ({\n  label,\n  timeFormat = 24,\n  value,\n  clearable,\n  required,\n  labelDescription,\n  helper,\n  size = 'medium',\n  disabled = false,\n  readOnly = false,\n  error = false,\n  onChange,\n  onBlur,\n  onFocus,\n  className,\n  id,\n  autoFocus,\n  'data-testid': dataTestId,\n  placeholder = DEFAULT_PLACEHOLDER,\n  'aria-label': ariaLabel,\n}: TimeInputProps) => {\n  const defaultPeriod = useMemo(() => {\n    if (value) return value.getHours() >= 12 ? 'pm' : 'am'\n\n    return undefined\n  }, [value])\n\n  const [time, setTime] = useState(value)\n  const [period, setPeriod] = useState<'pm' | 'am' | undefined>(defaultPeriod)\n  const [filled, setFilled] = useState(\n    value ? { h: true, m: true, s: true } : { h: false, m: false, s: false },\n  ) // to not show 00 when there should be a placeholder\n\n  const refHours = useRef<HTMLInputElement>(null)\n  const refSeconds = useRef<HTMLInputElement>(null)\n  const refMinutes = useRef<HTMLInputElement>(null)\n  const refPeriod = useRef<HTMLInputElement>(null)\n\n  useEffect(() => {\n    if (value) {\n      setTime(value)\n\n      // without this condition, every time an input value changes, the other ones will be set to 0 if they used to be undefined\n      // instead of leaving them empty (and showing the placeholder)\n      if (value.getTime() !== time?.getTime()) {\n        setFilled({ h: true, m: true, s: true })\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [value])\n\n  const handleChangePeriod = (key: 'a' | 'p') => {\n    if (!time) {\n      setPeriod(`${key}m`)\n    } else if (key.toLowerCase() === 'a') {\n      if (time.getHours() >= 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() - 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('am')\n    } else {\n      if (time.getHours() < 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() + 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('pm')\n    }\n  }\n  const handleChange = (type: 'h' | 'm' | 's', key: number) => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const valueToChange = getValueByType(type, time)\n\n    if (canConcat(valueToChange, type, key, timeFormat)) {\n      const newValue = (valueToChange % 10) * 10 + key\n\n      setValueByType(type, newTime, newValue)\n    } else setValueByType(type, newTime, key)\n\n    const newValue = getValueByType(type, newTime)\n    // Focus to next input if the current input has a valid time\n    if (type === 's' && newTime && newValue >= 7 && timeFormat === 12) {\n      refPeriod.current?.focus()\n    } else if (type === 'm' && newTime && newValue >= 6) {\n      refSeconds.current?.focus()\n    }\n\n    if (type === 'h') {\n      if (isCompleteHour(timeFormat, newValue)) {\n        refMinutes.current?.focus()\n      }\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n\n    setFilled(newFilled)\n  }\n\n  // Increase time with arrow up\n  const handleIncrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 23 ? 0 : currentValue + 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 12 ? 1 : currentValue + 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 59 ? 0 : currentValue + 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Decrease time with arrow down\n  const handleDecrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 0 ? 23 : currentValue - 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 1 ? 12 : currentValue - 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 0 ? 59 : currentValue - 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Go to next input\n  const handleNext = (type: 'h' | 'm' | 's') => {\n    if (type === 'h') refMinutes.current?.focus()\n    if (type === 'm') refSeconds.current?.focus()\n    if (type === 's' && timeFormat === 12) refPeriod.current?.focus()\n  }\n\n  // Go to previous input\n  const handlePrevious = (type: 'h' | 'm' | 's') => {\n    if (type === 'm') refHours.current?.focus()\n    if (type === 's') refMinutes.current?.focus()\n  }\n\n  return (\n    <Stack gap={0.5} className={className}>\n      <Stack direction=\"row\" gap={1} alignItems=\"center\">\n        <StyledText\n          as=\"label\"\n          prominence=\"strong\"\n          sentiment=\"neutral\"\n          variant=\"body\"\n        >\n          {label}\n        </StyledText>\n        {required ? <AsteriskIcon size={8} sentiment=\"danger\" /> : null}\n        {labelDescription ? (\n          <StyledText as=\"label\" variant=\"bodySmall\">\n            {labelDescription}\n          </StyledText>\n        ) : null}\n      </Stack>\n      <TimeInputWrapper\n        data-readonly={readOnly}\n        data-disabled={disabled}\n        data-size={size}\n        data-error={!!error}\n        direction=\"row\"\n        alignItems=\"center\"\n        justifyContent=\"space-between\"\n        onBlur={onBlur}\n        onFocus={onFocus}\n        aria-required={required}\n        onClick={() => refHours.current?.focus()}\n        id={id}\n        data-testid={dataTestId}\n        aria-label={ariaLabel}\n      >\n        <Stack direction=\"row\">\n          {TIME_KEYS.map(type => {\n            const computedRef = () => {\n              if (type === 'h') return refHours\n              if (type === 'm') return refMinutes\n\n              return refSeconds\n            }\n            const fullName = () => {\n              if (type === 'h') return 'hours'\n              if (type === 'm') return 'minutes'\n\n              return 'seconds'\n            }\n\n            const computeMaxValue = () => {\n              if (type === 'h' && timeFormat === 12) return 12\n              if (type === 'h' && timeFormat === 24) return 23\n\n              return 59\n            }\n\n            return (\n              <Stack key={type} direction=\"row\">\n                <Input\n                  value={\n                    filled[type]\n                      ? format(getValueByType(type, time), type, timeFormat)\n                      : ''\n                  }\n                  placeholder={placeholder[type]}\n                  data-size={size}\n                  readOnly={readOnly}\n                  disabled={disabled}\n                  aria-label={ariaLabel}\n                  data-testid={`${fullName()}-input`}\n                  onClick={event => {\n                    event.stopPropagation()\n                  }}\n                  ref={computedRef()}\n                  role=\"spinbutton\"\n                  aria-valuemax={computeMaxValue()}\n                  aria-valuemin={type === 'h' && timeFormat === 12 ? 1 : 0}\n                  aria-valuenow={\n                    filled[type]\n                      ? Number.parseInt(\n                          format(getValueByType(type, time), type, timeFormat),\n                          10,\n                        )\n                      : undefined\n                  }\n                  onChange={event => {\n                    if (!readOnly && !disabled) {\n                      const key = getLastTypedChar(\n                        event.target.value,\n                        getValueByType(type, time),\n                      )\n                      if (isNumber(key)) {\n                        handleChange(type, Number.parseInt(key, 10))\n                      }\n                    }\n                  }}\n                  onKeyDown={event => {\n                    if (!readOnly && !disabled) {\n                      if (event.key === 'ArrowUp') {\n                        event.preventDefault()\n                        handleIncrease(type)\n                      } else if (event.key === 'ArrowDown') {\n                        event.preventDefault()\n                        handleDecrease(type)\n                      } else if (event.key === 'ArrowLeft') {\n                        event.preventDefault()\n                        handlePrevious(type)\n                      } else if (event.key === 'ArrowRight') {\n                        event.preventDefault()\n                        handleNext(type)\n                      }\n                    }\n                  }}\n                  autoFocus={autoFocus && type === 'h'}\n                />\n                {type === 's' ? null : (\n                  <CustomText\n                    as=\"span\"\n                    variant=\"body\"\n                    prominence=\"default\"\n                    sentiment=\"neutral\"\n                  >\n                    :\n                  </CustomText>\n                )}\n              </Stack>\n            )\n          })}\n          {timeFormat === 12 ? (\n            <Input\n              value={period?.toUpperCase()}\n              placeholder={placeholder.period ?? 'AM'}\n              data-size={size}\n              data-period\n              readOnly={readOnly}\n              disabled={disabled}\n              aria-label={ariaLabel}\n              data-testid=\"am-pm-input\"\n              onChange={event => {\n                if (!readOnly && !disabled) {\n                  const key = event.target.value.slice(-1)\n                  if (isAOrP(key)) handleChangePeriod(key as 'a' | 'p')\n                }\n              }}\n              onKeyDown={event => {\n                if (!readOnly && !disabled) {\n                  if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {\n                    event.preventDefault()\n                    handleChangePeriod(period === 'am' ? 'p' : 'a')\n                  } else if (event.key === 'ArrowLeft') {\n                    event.preventDefault()\n                    refSeconds.current?.focus()\n                  }\n                }\n              }}\n              ref={refPeriod}\n              onClick={event => event.stopPropagation()}\n              role=\"spinbutton\"\n              aria-valuemax={12}\n              aria-valuemin={0}\n              aria-valuenow={period === 'am' ? 0 : 12}\n              aria-valuetext={period}\n            />\n          ) : null}\n        </Stack>\n        {error || clearable ? (\n          <Stack direction=\"row\" alignItems=\"center\" gap=\"1\">\n            {error ? <AlertCircleIcon sentiment=\"danger\" /> : null}\n            {clearable ? (\n              <Button\n                aria-label=\"clear value\"\n                disabled={disabled || readOnly}\n                variant=\"ghost\"\n                size=\"small\"\n                icon=\"close\"\n                onClick={event => {\n                  event.stopPropagation()\n                  setTime(undefined)\n                  onChange?.(undefined)\n                }}\n                sentiment=\"neutral\"\n                data-testid=\"clear\"\n              />\n            ) : null}\n          </Stack>\n        ) : null}\n      </TimeInputWrapper>\n      {helper || error ? (\n        <Text\n          as=\"p\"\n          variant=\"caption\"\n          sentiment={error ? 'danger' : 'neutral'}\n          prominence={error ? 'default' : 'weak'}\n          disabled={disabled}\n        >\n          {error || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const Input = /* @__PURE__ */ _styled__default.default("input", process.env.NODE_ENV === "production" ? {
+  target: "e8pjt8k2"
+} : {
+  target: "e8pjt8k2",
+  label: "Input"
+})("border:none;outline:none;background:transparent;font-size:", ({
+  theme
+}) => theme.typography.bodySmall.fontSize, ";width:", ({
+  theme
+}) => theme.sizing[312], ";height:", ({
+  theme
+}) => theme.sizing[300], ";text-align:center;border-radius:", ({
+  theme
+}) => theme.radii.default, ";color:", ({
+  theme
+}) => theme.colors.neutral.text, ";caret-color:transparent;&[data-size='large']{font-size:", ({
+  theme
+}) => theme.typography.body.fontSize, ";}&:not(:disabled):hover{background-color:", ({
+  theme
+}) => theme.colors.neutral.backgroundHover, ";color:", ({
+  theme
+}) => theme.colors.neutral.textWeak, ";}&:not(:disabled):active,:not(:disabled):focus{background-color:", ({
+  theme
+}) => theme.colors.neutral.backgroundStrong, ";color:", ({
+  theme
+}) => theme.colors.neutral.text, ';}&:read-only{cursor:default;}&:disabled{cursor:not-allowed;user-select:none;}&[data-period="true"]{color:', ({
+  theme
+}) => theme.colors.neutral.textWeak, ";}::-moz-selection{background:none;}::selection{background:none;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx"],"names":[],"mappings":"AAwGE","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { AlertCircleIcon, AsteriskIcon } from '@ultraviolet/icons'\nimport type { FocusEvent, ReactNode } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport type { LabelProp } from '../../types'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport {\n  DEFAULT_DATE,\n  DEFAULT_PLACEHOLDER,\n  INPUT_SIZE_HEIGHT,\n  TIME_KEYS,\n} from './constants'\nimport {\n  canConcat,\n  format,\n  getLastTypedChar,\n  getValueByType,\n  isAOrP,\n  isCompleteHour,\n  isNumber,\n  setValueByType,\n} from './helpers'\n\nexport type Time = {\n  h: string\n  m: string\n  s: string\n  period?: string\n}\n\nconst TimeInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-error': boolean\n}>`\n  display: flex;\n  cursor: text;\n  padding: ${({ theme }) => theme.space[1]};\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n\n  &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n  \n  &[data-disabled=\"false\"]:hover,\n  [data-disabled=\"false\"]:focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-size='small'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.small]};\n    padding-left: ${({ theme }) => theme.space[1]};\n  }\n\n  &[data-size='medium'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.medium]};\n  }\n\n  &[data-size='large'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.large]};\n  }\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-error='true'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n      box-shadow: ${({ theme }) => theme.shadows.focusDanger};\n    }\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):hover {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n    }\n  }\n`\n\nexport const Input = styled.input<{\n  'data-size': 'small' | 'medium' | 'large'\n  'data-period'?: boolean\n}>`\n  border: none;\n  outline: none;\n  background: transparent;\n  font-size: ${({ theme }) => theme.typography.bodySmall.fontSize};\n  width: ${({ theme }) => theme.sizing[312]};\n  height: ${({ theme }) => theme.sizing[300]};\n  text-align: center;\n  border-radius: ${({ theme }) => theme.radii.default};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  caret-color: transparent;\n\n  &[data-size='large'] {\n    font-size: ${({ theme }) => theme.typography.body.fontSize};\n  }\n\n  &:not(:disabled):hover {\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundHover};\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  &:not(:disabled):active, \n  :not(:disabled):focus{\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundStrong};\n    color:  ${({ theme }) => theme.colors.neutral.text};\n  }\n\n  &:read-only {\n    cursor: default;\n  }\n\n  &:disabled {\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-period=\"true\"] {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  ::-moz-selection {\n    background: none;\n  }\n\n  ::selection {\n    background: none;\n  }\n`\n\nconst CustomText = styled(Text)`\npadding-inline: ${({ theme }) => theme.space['0.25']};\n`\nconst StyledText = styled(Text)`\ncursor: text;\n`\n\ntype TimeInputProps = {\n  placeholder?: Time\n  value?: Date\n  clearable?: boolean\n  required?: boolean\n  labelDescription?: ReactNode\n  helper?: ReactNode\n  disabled?: boolean\n  readOnly?: boolean\n  error?: boolean | string\n  'data-testid'?: string\n  onChange?: (value: Date | undefined, valuePeriod?: string) => void\n  onBlur?: (event: FocusEvent<HTMLInputElement>) => void\n  onFocus?: (event: FocusEvent<HTMLInputElement>) => void\n  className?: string\n  id?: string\n  size?: 'small' | 'medium' | 'large'\n  timeFormat?: 12 | 24\n  /**\n   * Automatically focus on the element on render. Autofocus is applied to the hour input\n   */\n  autoFocus?: boolean\n} & LabelProp\n\n/**\n * A time input component that allows users to type a time in a 24 or 12-hour format.\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const TimeInputV2 = ({\n  label,\n  timeFormat = 24,\n  value,\n  clearable,\n  required,\n  labelDescription,\n  helper,\n  size = 'medium',\n  disabled = false,\n  readOnly = false,\n  error = false,\n  onChange,\n  onBlur,\n  onFocus,\n  className,\n  id,\n  autoFocus,\n  'data-testid': dataTestId,\n  placeholder = DEFAULT_PLACEHOLDER,\n  'aria-label': ariaLabel,\n}: TimeInputProps) => {\n  const defaultPeriod = useMemo(() => {\n    if (value) return value.getHours() >= 12 ? 'pm' : 'am'\n\n    return undefined\n  }, [value])\n\n  const [time, setTime] = useState(value)\n  const [period, setPeriod] = useState<'pm' | 'am' | undefined>(defaultPeriod)\n  const [filled, setFilled] = useState(\n    value ? { h: true, m: true, s: true } : { h: false, m: false, s: false },\n  ) // to not show 00 when there should be a placeholder\n\n  const refHours = useRef<HTMLInputElement>(null)\n  const refSeconds = useRef<HTMLInputElement>(null)\n  const refMinutes = useRef<HTMLInputElement>(null)\n  const refPeriod = useRef<HTMLInputElement>(null)\n\n  useEffect(() => {\n    if (value) {\n      setTime(value)\n\n      // without this condition, every time an input value changes, the other ones will be set to 0 if they used to be undefined\n      // instead of leaving them empty (and showing the placeholder)\n      if (value.getTime() !== time?.getTime()) {\n        setFilled({ h: true, m: true, s: true })\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [value])\n\n  const handleChangePeriod = (key: 'a' | 'p') => {\n    if (!time) {\n      setPeriod(`${key}m`)\n    } else if (key.toLowerCase() === 'a') {\n      if (time.getHours() >= 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() - 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('am')\n    } else {\n      if (time.getHours() < 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() + 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('pm')\n    }\n  }\n  const handleChange = (type: 'h' | 'm' | 's', key: number) => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const valueToChange = getValueByType(type, time)\n\n    if (canConcat(valueToChange, type, key, timeFormat)) {\n      const newValue = (valueToChange % 10) * 10 + key\n\n      setValueByType(type, newTime, newValue)\n    } else setValueByType(type, newTime, key)\n\n    const newValue = getValueByType(type, newTime)\n    // Focus to next input if the current input has a valid time\n    if (type === 's' && newTime && newValue >= 7 && timeFormat === 12) {\n      refPeriod.current?.focus()\n    } else if (type === 'm' && newTime && newValue >= 6) {\n      refSeconds.current?.focus()\n    }\n\n    if (type === 'h') {\n      if (isCompleteHour(timeFormat, newValue)) {\n        refMinutes.current?.focus()\n      }\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n\n    setFilled(newFilled)\n  }\n\n  // Increase time with arrow up\n  const handleIncrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 23 ? 0 : currentValue + 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 12 ? 1 : currentValue + 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 59 ? 0 : currentValue + 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Decrease time with arrow down\n  const handleDecrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 0 ? 23 : currentValue - 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 1 ? 12 : currentValue - 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 0 ? 59 : currentValue - 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Go to next input\n  const handleNext = (type: 'h' | 'm' | 's') => {\n    if (type === 'h') refMinutes.current?.focus()\n    if (type === 'm') refSeconds.current?.focus()\n    if (type === 's' && timeFormat === 12) refPeriod.current?.focus()\n  }\n\n  // Go to previous input\n  const handlePrevious = (type: 'h' | 'm' | 's') => {\n    if (type === 'm') refHours.current?.focus()\n    if (type === 's') refMinutes.current?.focus()\n  }\n\n  return (\n    <Stack gap={0.5} className={className}>\n      <Stack direction=\"row\" gap={1} alignItems=\"center\">\n        <StyledText\n          as=\"label\"\n          prominence=\"strong\"\n          sentiment=\"neutral\"\n          variant=\"body\"\n        >\n          {label}\n        </StyledText>\n        {required ? <AsteriskIcon size={8} sentiment=\"danger\" /> : null}\n        {labelDescription ? (\n          <StyledText as=\"label\" variant=\"bodySmall\">\n            {labelDescription}\n          </StyledText>\n        ) : null}\n      </Stack>\n      <TimeInputWrapper\n        data-readonly={readOnly}\n        data-disabled={disabled}\n        data-size={size}\n        data-error={!!error}\n        direction=\"row\"\n        alignItems=\"center\"\n        justifyContent=\"space-between\"\n        onBlur={onBlur}\n        onFocus={onFocus}\n        aria-required={required}\n        onClick={() => refHours.current?.focus()}\n        id={id}\n        data-testid={dataTestId}\n        aria-label={ariaLabel}\n      >\n        <Stack direction=\"row\">\n          {TIME_KEYS.map(type => {\n            const computedRef = () => {\n              if (type === 'h') return refHours\n              if (type === 'm') return refMinutes\n\n              return refSeconds\n            }\n            const fullName = () => {\n              if (type === 'h') return 'hours'\n              if (type === 'm') return 'minutes'\n\n              return 'seconds'\n            }\n\n            const computeMaxValue = () => {\n              if (type === 'h' && timeFormat === 12) return 12\n              if (type === 'h' && timeFormat === 24) return 23\n\n              return 59\n            }\n\n            return (\n              <Stack key={type} direction=\"row\">\n                <Input\n                  value={\n                    filled[type]\n                      ? format(getValueByType(type, time), type, timeFormat)\n                      : ''\n                  }\n                  placeholder={placeholder[type]}\n                  data-size={size}\n                  readOnly={readOnly}\n                  disabled={disabled}\n                  aria-label={ariaLabel}\n                  data-testid={`${fullName()}-input`}\n                  onClick={event => {\n                    event.stopPropagation()\n                  }}\n                  ref={computedRef()}\n                  role=\"spinbutton\"\n                  aria-valuemax={computeMaxValue()}\n                  aria-valuemin={type === 'h' && timeFormat === 12 ? 1 : 0}\n                  aria-valuenow={\n                    filled[type]\n                      ? Number.parseInt(\n                          format(getValueByType(type, time), type, timeFormat),\n                          10,\n                        )\n                      : undefined\n                  }\n                  onChange={event => {\n                    if (!readOnly && !disabled) {\n                      const key = getLastTypedChar(\n                        event.target.value,\n                        getValueByType(type, time),\n                      )\n                      if (isNumber(key)) {\n                        handleChange(type, Number.parseInt(key, 10))\n                      }\n                    }\n                  }}\n                  onKeyDown={event => {\n                    if (!readOnly && !disabled) {\n                      if (event.key === 'ArrowUp') {\n                        event.preventDefault()\n                        handleIncrease(type)\n                      } else if (event.key === 'ArrowDown') {\n                        event.preventDefault()\n                        handleDecrease(type)\n                      } else if (event.key === 'ArrowLeft') {\n                        event.preventDefault()\n                        handlePrevious(type)\n                      } else if (event.key === 'ArrowRight') {\n                        event.preventDefault()\n                        handleNext(type)\n                      }\n                    }\n                  }}\n                  autoFocus={autoFocus && type === 'h'}\n                />\n                {type === 's' ? null : (\n                  <CustomText\n                    as=\"span\"\n                    variant=\"body\"\n                    prominence=\"default\"\n                    sentiment=\"neutral\"\n                  >\n                    :\n                  </CustomText>\n                )}\n              </Stack>\n            )\n          })}\n          {timeFormat === 12 ? (\n            <Input\n              value={period?.toUpperCase()}\n              placeholder={placeholder.period ?? 'AM'}\n              data-size={size}\n              data-period\n              readOnly={readOnly}\n              disabled={disabled}\n              aria-label={ariaLabel}\n              data-testid=\"am-pm-input\"\n              onChange={event => {\n                if (!readOnly && !disabled) {\n                  const key = event.target.value.slice(-1)\n                  if (isAOrP(key)) handleChangePeriod(key as 'a' | 'p')\n                }\n              }}\n              onKeyDown={event => {\n                if (!readOnly && !disabled) {\n                  if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {\n                    event.preventDefault()\n                    handleChangePeriod(period === 'am' ? 'p' : 'a')\n                  } else if (event.key === 'ArrowLeft') {\n                    event.preventDefault()\n                    refSeconds.current?.focus()\n                  }\n                }\n              }}\n              ref={refPeriod}\n              onClick={event => event.stopPropagation()}\n              role=\"spinbutton\"\n              aria-valuemax={12}\n              aria-valuemin={0}\n              aria-valuenow={period === 'am' ? 0 : 12}\n              aria-valuetext={period}\n            />\n          ) : null}\n        </Stack>\n        {error || clearable ? (\n          <Stack direction=\"row\" alignItems=\"center\" gap=\"1\">\n            {error ? <AlertCircleIcon sentiment=\"danger\" /> : null}\n            {clearable ? (\n              <Button\n                aria-label=\"clear value\"\n                disabled={disabled || readOnly}\n                variant=\"ghost\"\n                size=\"small\"\n                icon=\"close\"\n                onClick={event => {\n                  event.stopPropagation()\n                  setTime(undefined)\n                  onChange?.(undefined)\n                }}\n                sentiment=\"neutral\"\n                data-testid=\"clear\"\n              />\n            ) : null}\n          </Stack>\n        ) : null}\n      </TimeInputWrapper>\n      {helper || error ? (\n        <Text\n          as=\"p\"\n          variant=\"caption\"\n          sentiment={error ? 'danger' : 'neutral'}\n          prominence={error ? 'default' : 'weak'}\n          disabled={disabled}\n        >\n          {error || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const CustomText = /* @__PURE__ */ _styled__default.default(index$1.Text, process.env.NODE_ENV === "production" ? {
+  target: "e8pjt8k1"
+} : {
+  target: "e8pjt8k1",
+  label: "CustomText"
+})("padding-inline:", ({
+  theme
+}) => theme.space["0.25"], ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx"],"names":[],"mappings":"AAyJ+B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { AlertCircleIcon, AsteriskIcon } from '@ultraviolet/icons'\nimport type { FocusEvent, ReactNode } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport type { LabelProp } from '../../types'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport {\n  DEFAULT_DATE,\n  DEFAULT_PLACEHOLDER,\n  INPUT_SIZE_HEIGHT,\n  TIME_KEYS,\n} from './constants'\nimport {\n  canConcat,\n  format,\n  getLastTypedChar,\n  getValueByType,\n  isAOrP,\n  isCompleteHour,\n  isNumber,\n  setValueByType,\n} from './helpers'\n\nexport type Time = {\n  h: string\n  m: string\n  s: string\n  period?: string\n}\n\nconst TimeInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-error': boolean\n}>`\n  display: flex;\n  cursor: text;\n  padding: ${({ theme }) => theme.space[1]};\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n\n  &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n  \n  &[data-disabled=\"false\"]:hover,\n  [data-disabled=\"false\"]:focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-size='small'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.small]};\n    padding-left: ${({ theme }) => theme.space[1]};\n  }\n\n  &[data-size='medium'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.medium]};\n  }\n\n  &[data-size='large'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.large]};\n  }\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-error='true'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n      box-shadow: ${({ theme }) => theme.shadows.focusDanger};\n    }\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):hover {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n    }\n  }\n`\n\nexport const Input = styled.input<{\n  'data-size': 'small' | 'medium' | 'large'\n  'data-period'?: boolean\n}>`\n  border: none;\n  outline: none;\n  background: transparent;\n  font-size: ${({ theme }) => theme.typography.bodySmall.fontSize};\n  width: ${({ theme }) => theme.sizing[312]};\n  height: ${({ theme }) => theme.sizing[300]};\n  text-align: center;\n  border-radius: ${({ theme }) => theme.radii.default};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  caret-color: transparent;\n\n  &[data-size='large'] {\n    font-size: ${({ theme }) => theme.typography.body.fontSize};\n  }\n\n  &:not(:disabled):hover {\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundHover};\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  &:not(:disabled):active, \n  :not(:disabled):focus{\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundStrong};\n    color:  ${({ theme }) => theme.colors.neutral.text};\n  }\n\n  &:read-only {\n    cursor: default;\n  }\n\n  &:disabled {\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-period=\"true\"] {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  ::-moz-selection {\n    background: none;\n  }\n\n  ::selection {\n    background: none;\n  }\n`\n\nconst CustomText = styled(Text)`\npadding-inline: ${({ theme }) => theme.space['0.25']};\n`\nconst StyledText = styled(Text)`\ncursor: text;\n`\n\ntype TimeInputProps = {\n  placeholder?: Time\n  value?: Date\n  clearable?: boolean\n  required?: boolean\n  labelDescription?: ReactNode\n  helper?: ReactNode\n  disabled?: boolean\n  readOnly?: boolean\n  error?: boolean | string\n  'data-testid'?: string\n  onChange?: (value: Date | undefined, valuePeriod?: string) => void\n  onBlur?: (event: FocusEvent<HTMLInputElement>) => void\n  onFocus?: (event: FocusEvent<HTMLInputElement>) => void\n  className?: string\n  id?: string\n  size?: 'small' | 'medium' | 'large'\n  timeFormat?: 12 | 24\n  /**\n   * Automatically focus on the element on render. Autofocus is applied to the hour input\n   */\n  autoFocus?: boolean\n} & LabelProp\n\n/**\n * A time input component that allows users to type a time in a 24 or 12-hour format.\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const TimeInputV2 = ({\n  label,\n  timeFormat = 24,\n  value,\n  clearable,\n  required,\n  labelDescription,\n  helper,\n  size = 'medium',\n  disabled = false,\n  readOnly = false,\n  error = false,\n  onChange,\n  onBlur,\n  onFocus,\n  className,\n  id,\n  autoFocus,\n  'data-testid': dataTestId,\n  placeholder = DEFAULT_PLACEHOLDER,\n  'aria-label': ariaLabel,\n}: TimeInputProps) => {\n  const defaultPeriod = useMemo(() => {\n    if (value) return value.getHours() >= 12 ? 'pm' : 'am'\n\n    return undefined\n  }, [value])\n\n  const [time, setTime] = useState(value)\n  const [period, setPeriod] = useState<'pm' | 'am' | undefined>(defaultPeriod)\n  const [filled, setFilled] = useState(\n    value ? { h: true, m: true, s: true } : { h: false, m: false, s: false },\n  ) // to not show 00 when there should be a placeholder\n\n  const refHours = useRef<HTMLInputElement>(null)\n  const refSeconds = useRef<HTMLInputElement>(null)\n  const refMinutes = useRef<HTMLInputElement>(null)\n  const refPeriod = useRef<HTMLInputElement>(null)\n\n  useEffect(() => {\n    if (value) {\n      setTime(value)\n\n      // without this condition, every time an input value changes, the other ones will be set to 0 if they used to be undefined\n      // instead of leaving them empty (and showing the placeholder)\n      if (value.getTime() !== time?.getTime()) {\n        setFilled({ h: true, m: true, s: true })\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [value])\n\n  const handleChangePeriod = (key: 'a' | 'p') => {\n    if (!time) {\n      setPeriod(`${key}m`)\n    } else if (key.toLowerCase() === 'a') {\n      if (time.getHours() >= 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() - 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('am')\n    } else {\n      if (time.getHours() < 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() + 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('pm')\n    }\n  }\n  const handleChange = (type: 'h' | 'm' | 's', key: number) => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const valueToChange = getValueByType(type, time)\n\n    if (canConcat(valueToChange, type, key, timeFormat)) {\n      const newValue = (valueToChange % 10) * 10 + key\n\n      setValueByType(type, newTime, newValue)\n    } else setValueByType(type, newTime, key)\n\n    const newValue = getValueByType(type, newTime)\n    // Focus to next input if the current input has a valid time\n    if (type === 's' && newTime && newValue >= 7 && timeFormat === 12) {\n      refPeriod.current?.focus()\n    } else if (type === 'm' && newTime && newValue >= 6) {\n      refSeconds.current?.focus()\n    }\n\n    if (type === 'h') {\n      if (isCompleteHour(timeFormat, newValue)) {\n        refMinutes.current?.focus()\n      }\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n\n    setFilled(newFilled)\n  }\n\n  // Increase time with arrow up\n  const handleIncrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 23 ? 0 : currentValue + 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 12 ? 1 : currentValue + 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 59 ? 0 : currentValue + 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Decrease time with arrow down\n  const handleDecrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 0 ? 23 : currentValue - 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 1 ? 12 : currentValue - 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 0 ? 59 : currentValue - 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Go to next input\n  const handleNext = (type: 'h' | 'm' | 's') => {\n    if (type === 'h') refMinutes.current?.focus()\n    if (type === 'm') refSeconds.current?.focus()\n    if (type === 's' && timeFormat === 12) refPeriod.current?.focus()\n  }\n\n  // Go to previous input\n  const handlePrevious = (type: 'h' | 'm' | 's') => {\n    if (type === 'm') refHours.current?.focus()\n    if (type === 's') refMinutes.current?.focus()\n  }\n\n  return (\n    <Stack gap={0.5} className={className}>\n      <Stack direction=\"row\" gap={1} alignItems=\"center\">\n        <StyledText\n          as=\"label\"\n          prominence=\"strong\"\n          sentiment=\"neutral\"\n          variant=\"body\"\n        >\n          {label}\n        </StyledText>\n        {required ? <AsteriskIcon size={8} sentiment=\"danger\" /> : null}\n        {labelDescription ? (\n          <StyledText as=\"label\" variant=\"bodySmall\">\n            {labelDescription}\n          </StyledText>\n        ) : null}\n      </Stack>\n      <TimeInputWrapper\n        data-readonly={readOnly}\n        data-disabled={disabled}\n        data-size={size}\n        data-error={!!error}\n        direction=\"row\"\n        alignItems=\"center\"\n        justifyContent=\"space-between\"\n        onBlur={onBlur}\n        onFocus={onFocus}\n        aria-required={required}\n        onClick={() => refHours.current?.focus()}\n        id={id}\n        data-testid={dataTestId}\n        aria-label={ariaLabel}\n      >\n        <Stack direction=\"row\">\n          {TIME_KEYS.map(type => {\n            const computedRef = () => {\n              if (type === 'h') return refHours\n              if (type === 'm') return refMinutes\n\n              return refSeconds\n            }\n            const fullName = () => {\n              if (type === 'h') return 'hours'\n              if (type === 'm') return 'minutes'\n\n              return 'seconds'\n            }\n\n            const computeMaxValue = () => {\n              if (type === 'h' && timeFormat === 12) return 12\n              if (type === 'h' && timeFormat === 24) return 23\n\n              return 59\n            }\n\n            return (\n              <Stack key={type} direction=\"row\">\n                <Input\n                  value={\n                    filled[type]\n                      ? format(getValueByType(type, time), type, timeFormat)\n                      : ''\n                  }\n                  placeholder={placeholder[type]}\n                  data-size={size}\n                  readOnly={readOnly}\n                  disabled={disabled}\n                  aria-label={ariaLabel}\n                  data-testid={`${fullName()}-input`}\n                  onClick={event => {\n                    event.stopPropagation()\n                  }}\n                  ref={computedRef()}\n                  role=\"spinbutton\"\n                  aria-valuemax={computeMaxValue()}\n                  aria-valuemin={type === 'h' && timeFormat === 12 ? 1 : 0}\n                  aria-valuenow={\n                    filled[type]\n                      ? Number.parseInt(\n                          format(getValueByType(type, time), type, timeFormat),\n                          10,\n                        )\n                      : undefined\n                  }\n                  onChange={event => {\n                    if (!readOnly && !disabled) {\n                      const key = getLastTypedChar(\n                        event.target.value,\n                        getValueByType(type, time),\n                      )\n                      if (isNumber(key)) {\n                        handleChange(type, Number.parseInt(key, 10))\n                      }\n                    }\n                  }}\n                  onKeyDown={event => {\n                    if (!readOnly && !disabled) {\n                      if (event.key === 'ArrowUp') {\n                        event.preventDefault()\n                        handleIncrease(type)\n                      } else if (event.key === 'ArrowDown') {\n                        event.preventDefault()\n                        handleDecrease(type)\n                      } else if (event.key === 'ArrowLeft') {\n                        event.preventDefault()\n                        handlePrevious(type)\n                      } else if (event.key === 'ArrowRight') {\n                        event.preventDefault()\n                        handleNext(type)\n                      }\n                    }\n                  }}\n                  autoFocus={autoFocus && type === 'h'}\n                />\n                {type === 's' ? null : (\n                  <CustomText\n                    as=\"span\"\n                    variant=\"body\"\n                    prominence=\"default\"\n                    sentiment=\"neutral\"\n                  >\n                    :\n                  </CustomText>\n                )}\n              </Stack>\n            )\n          })}\n          {timeFormat === 12 ? (\n            <Input\n              value={period?.toUpperCase()}\n              placeholder={placeholder.period ?? 'AM'}\n              data-size={size}\n              data-period\n              readOnly={readOnly}\n              disabled={disabled}\n              aria-label={ariaLabel}\n              data-testid=\"am-pm-input\"\n              onChange={event => {\n                if (!readOnly && !disabled) {\n                  const key = event.target.value.slice(-1)\n                  if (isAOrP(key)) handleChangePeriod(key as 'a' | 'p')\n                }\n              }}\n              onKeyDown={event => {\n                if (!readOnly && !disabled) {\n                  if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {\n                    event.preventDefault()\n                    handleChangePeriod(period === 'am' ? 'p' : 'a')\n                  } else if (event.key === 'ArrowLeft') {\n                    event.preventDefault()\n                    refSeconds.current?.focus()\n                  }\n                }\n              }}\n              ref={refPeriod}\n              onClick={event => event.stopPropagation()}\n              role=\"spinbutton\"\n              aria-valuemax={12}\n              aria-valuemin={0}\n              aria-valuenow={period === 'am' ? 0 : 12}\n              aria-valuetext={period}\n            />\n          ) : null}\n        </Stack>\n        {error || clearable ? (\n          <Stack direction=\"row\" alignItems=\"center\" gap=\"1\">\n            {error ? <AlertCircleIcon sentiment=\"danger\" /> : null}\n            {clearable ? (\n              <Button\n                aria-label=\"clear value\"\n                disabled={disabled || readOnly}\n                variant=\"ghost\"\n                size=\"small\"\n                icon=\"close\"\n                onClick={event => {\n                  event.stopPropagation()\n                  setTime(undefined)\n                  onChange?.(undefined)\n                }}\n                sentiment=\"neutral\"\n                data-testid=\"clear\"\n              />\n            ) : null}\n          </Stack>\n        ) : null}\n      </TimeInputWrapper>\n      {helper || error ? (\n        <Text\n          as=\"p\"\n          variant=\"caption\"\n          sentiment={error ? 'danger' : 'neutral'}\n          prominence={error ? 'default' : 'weak'}\n          disabled={disabled}\n        >\n          {error || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const StyledText = /* @__PURE__ */ _styled__default.default(index$1.Text, process.env.NODE_ENV === "production" ? {
+  target: "e8pjt8k0"
+} : {
+  target: "e8pjt8k0",
+  label: "StyledText"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1jbm2s3",
+  styles: "cursor:text"
+} : {
+  name: "1jbm2s3",
+  styles: "cursor:text/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx"],"names":[],"mappings":"AA4J+B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TimeInputV2/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { AlertCircleIcon, AsteriskIcon } from '@ultraviolet/icons'\nimport type { FocusEvent, ReactNode } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport type { LabelProp } from '../../types'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport {\n  DEFAULT_DATE,\n  DEFAULT_PLACEHOLDER,\n  INPUT_SIZE_HEIGHT,\n  TIME_KEYS,\n} from './constants'\nimport {\n  canConcat,\n  format,\n  getLastTypedChar,\n  getValueByType,\n  isAOrP,\n  isCompleteHour,\n  isNumber,\n  setValueByType,\n} from './helpers'\n\nexport type Time = {\n  h: string\n  m: string\n  s: string\n  period?: string\n}\n\nconst TimeInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-error': boolean\n}>`\n  display: flex;\n  cursor: text;\n  padding: ${({ theme }) => theme.space[1]};\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n\n  &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n  \n  &[data-disabled=\"false\"]:hover,\n  [data-disabled=\"false\"]:focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-size='small'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.small]};\n    padding-left: ${({ theme }) => theme.space[1]};\n  }\n\n  &[data-size='medium'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.medium]};\n  }\n\n  &[data-size='large'] {\n    height: ${({ theme }) => theme.sizing[INPUT_SIZE_HEIGHT.large]};\n  }\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-error='true'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):active {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n      box-shadow: ${({ theme }) => theme.shadows.focusDanger};\n    }\n\n    &:not([data-disabled=\"true\"]):not([data-readonly=\"true\"]):hover {\n      border-color: ${({ theme }) => theme.colors.danger.borderHover};\n    }\n  }\n`\n\nexport const Input = styled.input<{\n  'data-size': 'small' | 'medium' | 'large'\n  'data-period'?: boolean\n}>`\n  border: none;\n  outline: none;\n  background: transparent;\n  font-size: ${({ theme }) => theme.typography.bodySmall.fontSize};\n  width: ${({ theme }) => theme.sizing[312]};\n  height: ${({ theme }) => theme.sizing[300]};\n  text-align: center;\n  border-radius: ${({ theme }) => theme.radii.default};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  caret-color: transparent;\n\n  &[data-size='large'] {\n    font-size: ${({ theme }) => theme.typography.body.fontSize};\n  }\n\n  &:not(:disabled):hover {\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundHover};\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  &:not(:disabled):active, \n  :not(:disabled):focus{\n    background-color: ${({ theme }) => theme.colors.neutral.backgroundStrong};\n    color:  ${({ theme }) => theme.colors.neutral.text};\n  }\n\n  &:read-only {\n    cursor: default;\n  }\n\n  &:disabled {\n    cursor: not-allowed;\n    user-select: none;\n  }\n\n  &[data-period=\"true\"] {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n\n  ::-moz-selection {\n    background: none;\n  }\n\n  ::selection {\n    background: none;\n  }\n`\n\nconst CustomText = styled(Text)`\npadding-inline: ${({ theme }) => theme.space['0.25']};\n`\nconst StyledText = styled(Text)`\ncursor: text;\n`\n\ntype TimeInputProps = {\n  placeholder?: Time\n  value?: Date\n  clearable?: boolean\n  required?: boolean\n  labelDescription?: ReactNode\n  helper?: ReactNode\n  disabled?: boolean\n  readOnly?: boolean\n  error?: boolean | string\n  'data-testid'?: string\n  onChange?: (value: Date | undefined, valuePeriod?: string) => void\n  onBlur?: (event: FocusEvent<HTMLInputElement>) => void\n  onFocus?: (event: FocusEvent<HTMLInputElement>) => void\n  className?: string\n  id?: string\n  size?: 'small' | 'medium' | 'large'\n  timeFormat?: 12 | 24\n  /**\n   * Automatically focus on the element on render. Autofocus is applied to the hour input\n   */\n  autoFocus?: boolean\n} & LabelProp\n\n/**\n * A time input component that allows users to type a time in a 24 or 12-hour format.\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const TimeInputV2 = ({\n  label,\n  timeFormat = 24,\n  value,\n  clearable,\n  required,\n  labelDescription,\n  helper,\n  size = 'medium',\n  disabled = false,\n  readOnly = false,\n  error = false,\n  onChange,\n  onBlur,\n  onFocus,\n  className,\n  id,\n  autoFocus,\n  'data-testid': dataTestId,\n  placeholder = DEFAULT_PLACEHOLDER,\n  'aria-label': ariaLabel,\n}: TimeInputProps) => {\n  const defaultPeriod = useMemo(() => {\n    if (value) return value.getHours() >= 12 ? 'pm' : 'am'\n\n    return undefined\n  }, [value])\n\n  const [time, setTime] = useState(value)\n  const [period, setPeriod] = useState<'pm' | 'am' | undefined>(defaultPeriod)\n  const [filled, setFilled] = useState(\n    value ? { h: true, m: true, s: true } : { h: false, m: false, s: false },\n  ) // to not show 00 when there should be a placeholder\n\n  const refHours = useRef<HTMLInputElement>(null)\n  const refSeconds = useRef<HTMLInputElement>(null)\n  const refMinutes = useRef<HTMLInputElement>(null)\n  const refPeriod = useRef<HTMLInputElement>(null)\n\n  useEffect(() => {\n    if (value) {\n      setTime(value)\n\n      // without this condition, every time an input value changes, the other ones will be set to 0 if they used to be undefined\n      // instead of leaving them empty (and showing the placeholder)\n      if (value.getTime() !== time?.getTime()) {\n        setFilled({ h: true, m: true, s: true })\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [value])\n\n  const handleChangePeriod = (key: 'a' | 'p') => {\n    if (!time) {\n      setPeriod(`${key}m`)\n    } else if (key.toLowerCase() === 'a') {\n      if (time.getHours() >= 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() - 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('am')\n    } else {\n      if (time.getHours() < 12) {\n        const newTime = new Date(time)\n        newTime.setHours(newTime.getHours() + 12)\n        setTime(newTime)\n        onChange?.(newTime)\n      }\n      setPeriod('pm')\n    }\n  }\n  const handleChange = (type: 'h' | 'm' | 's', key: number) => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const valueToChange = getValueByType(type, time)\n\n    if (canConcat(valueToChange, type, key, timeFormat)) {\n      const newValue = (valueToChange % 10) * 10 + key\n\n      setValueByType(type, newTime, newValue)\n    } else setValueByType(type, newTime, key)\n\n    const newValue = getValueByType(type, newTime)\n    // Focus to next input if the current input has a valid time\n    if (type === 's' && newTime && newValue >= 7 && timeFormat === 12) {\n      refPeriod.current?.focus()\n    } else if (type === 'm' && newTime && newValue >= 6) {\n      refSeconds.current?.focus()\n    }\n\n    if (type === 'h') {\n      if (isCompleteHour(timeFormat, newValue)) {\n        refMinutes.current?.focus()\n      }\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n\n    setFilled(newFilled)\n  }\n\n  // Increase time with arrow up\n  const handleIncrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 23 ? 0 : currentValue + 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 12 ? 1 : currentValue + 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 59 ? 0 : currentValue + 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Decrease time with arrow down\n  const handleDecrease = (type: 'h' | 'm' | 's') => {\n    const newTime = time ? new Date(time) : DEFAULT_DATE\n    const currentValue = getValueByType(type, newTime)\n\n    if (type === 'h' && timeFormat === 24) {\n      setValueByType(type, newTime, currentValue === 0 ? 23 : currentValue - 1)\n    } else if (type === 'h' && timeFormat === 12) {\n      setValueByType(type, newTime, currentValue === 1 ? 12 : currentValue - 1)\n    } else {\n      setValueByType(type, newTime, currentValue === 0 ? 59 : currentValue - 1)\n    }\n    const newFilled = { ...filled }\n    newFilled[type] = true\n\n    setTime(newTime)\n    onChange?.(newTime)\n    setFilled(newFilled)\n  }\n\n  // Go to next input\n  const handleNext = (type: 'h' | 'm' | 's') => {\n    if (type === 'h') refMinutes.current?.focus()\n    if (type === 'm') refSeconds.current?.focus()\n    if (type === 's' && timeFormat === 12) refPeriod.current?.focus()\n  }\n\n  // Go to previous input\n  const handlePrevious = (type: 'h' | 'm' | 's') => {\n    if (type === 'm') refHours.current?.focus()\n    if (type === 's') refMinutes.current?.focus()\n  }\n\n  return (\n    <Stack gap={0.5} className={className}>\n      <Stack direction=\"row\" gap={1} alignItems=\"center\">\n        <StyledText\n          as=\"label\"\n          prominence=\"strong\"\n          sentiment=\"neutral\"\n          variant=\"body\"\n        >\n          {label}\n        </StyledText>\n        {required ? <AsteriskIcon size={8} sentiment=\"danger\" /> : null}\n        {labelDescription ? (\n          <StyledText as=\"label\" variant=\"bodySmall\">\n            {labelDescription}\n          </StyledText>\n        ) : null}\n      </Stack>\n      <TimeInputWrapper\n        data-readonly={readOnly}\n        data-disabled={disabled}\n        data-size={size}\n        data-error={!!error}\n        direction=\"row\"\n        alignItems=\"center\"\n        justifyContent=\"space-between\"\n        onBlur={onBlur}\n        onFocus={onFocus}\n        aria-required={required}\n        onClick={() => refHours.current?.focus()}\n        id={id}\n        data-testid={dataTestId}\n        aria-label={ariaLabel}\n      >\n        <Stack direction=\"row\">\n          {TIME_KEYS.map(type => {\n            const computedRef = () => {\n              if (type === 'h') return refHours\n              if (type === 'm') return refMinutes\n\n              return refSeconds\n            }\n            const fullName = () => {\n              if (type === 'h') return 'hours'\n              if (type === 'm') return 'minutes'\n\n              return 'seconds'\n            }\n\n            const computeMaxValue = () => {\n              if (type === 'h' && timeFormat === 12) return 12\n              if (type === 'h' && timeFormat === 24) return 23\n\n              return 59\n            }\n\n            return (\n              <Stack key={type} direction=\"row\">\n                <Input\n                  value={\n                    filled[type]\n                      ? format(getValueByType(type, time), type, timeFormat)\n                      : ''\n                  }\n                  placeholder={placeholder[type]}\n                  data-size={size}\n                  readOnly={readOnly}\n                  disabled={disabled}\n                  aria-label={ariaLabel}\n                  data-testid={`${fullName()}-input`}\n                  onClick={event => {\n                    event.stopPropagation()\n                  }}\n                  ref={computedRef()}\n                  role=\"spinbutton\"\n                  aria-valuemax={computeMaxValue()}\n                  aria-valuemin={type === 'h' && timeFormat === 12 ? 1 : 0}\n                  aria-valuenow={\n                    filled[type]\n                      ? Number.parseInt(\n                          format(getValueByType(type, time), type, timeFormat),\n                          10,\n                        )\n                      : undefined\n                  }\n                  onChange={event => {\n                    if (!readOnly && !disabled) {\n                      const key = getLastTypedChar(\n                        event.target.value,\n                        getValueByType(type, time),\n                      )\n                      if (isNumber(key)) {\n                        handleChange(type, Number.parseInt(key, 10))\n                      }\n                    }\n                  }}\n                  onKeyDown={event => {\n                    if (!readOnly && !disabled) {\n                      if (event.key === 'ArrowUp') {\n                        event.preventDefault()\n                        handleIncrease(type)\n                      } else if (event.key === 'ArrowDown') {\n                        event.preventDefault()\n                        handleDecrease(type)\n                      } else if (event.key === 'ArrowLeft') {\n                        event.preventDefault()\n                        handlePrevious(type)\n                      } else if (event.key === 'ArrowRight') {\n                        event.preventDefault()\n                        handleNext(type)\n                      }\n                    }\n                  }}\n                  autoFocus={autoFocus && type === 'h'}\n                />\n                {type === 's' ? null : (\n                  <CustomText\n                    as=\"span\"\n                    variant=\"body\"\n                    prominence=\"default\"\n                    sentiment=\"neutral\"\n                  >\n                    :\n                  </CustomText>\n                )}\n              </Stack>\n            )\n          })}\n          {timeFormat === 12 ? (\n            <Input\n              value={period?.toUpperCase()}\n              placeholder={placeholder.period ?? 'AM'}\n              data-size={size}\n              data-period\n              readOnly={readOnly}\n              disabled={disabled}\n              aria-label={ariaLabel}\n              data-testid=\"am-pm-input\"\n              onChange={event => {\n                if (!readOnly && !disabled) {\n                  const key = event.target.value.slice(-1)\n                  if (isAOrP(key)) handleChangePeriod(key as 'a' | 'p')\n                }\n              }}\n              onKeyDown={event => {\n                if (!readOnly && !disabled) {\n                  if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {\n                    event.preventDefault()\n                    handleChangePeriod(period === 'am' ? 'p' : 'a')\n                  } else if (event.key === 'ArrowLeft') {\n                    event.preventDefault()\n                    refSeconds.current?.focus()\n                  }\n                }\n              }}\n              ref={refPeriod}\n              onClick={event => event.stopPropagation()}\n              role=\"spinbutton\"\n              aria-valuemax={12}\n              aria-valuemin={0}\n              aria-valuenow={period === 'am' ? 0 : 12}\n              aria-valuetext={period}\n            />\n          ) : null}\n        </Stack>\n        {error || clearable ? (\n          <Stack direction=\"row\" alignItems=\"center\" gap=\"1\">\n            {error ? <AlertCircleIcon sentiment=\"danger\" /> : null}\n            {clearable ? (\n              <Button\n                aria-label=\"clear value\"\n                disabled={disabled || readOnly}\n                variant=\"ghost\"\n                size=\"small\"\n                icon=\"close\"\n                onClick={event => {\n                  event.stopPropagation()\n                  setTime(undefined)\n                  onChange?.(undefined)\n                }}\n                sentiment=\"neutral\"\n                data-testid=\"clear\"\n              />\n            ) : null}\n          </Stack>\n        ) : null}\n      </TimeInputWrapper>\n      {helper || error ? (\n        <Text\n          as=\"p\"\n          variant=\"caption\"\n          sentiment={error ? 'danger' : 'neutral'}\n          prominence={error ? 'default' : 'weak'}\n          disabled={disabled}\n        >\n          {error || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const TimeInputV2 = ({
+  label,
+  timeFormat = 24,
+  value,
+  clearable,
+  required,
+  labelDescription,
+  helper,
+  size = "medium",
+  disabled = false,
+  readOnly = false,
+  error = false,
+  onChange,
+  onBlur,
+  onFocus,
+  className,
+  id,
+  autoFocus,
+  "data-testid": dataTestId,
+  placeholder = constants.DEFAULT_PLACEHOLDER,
+  "aria-label": ariaLabel
+}) => {
+  const defaultPeriod = React.useMemo(() => {
+    if (value) return value.getHours() >= 12 ? "pm" : "am";
+    return void 0;
+  }, [value]);
+  const [time, setTime] = React.useState(value);
+  const [period, setPeriod] = React.useState(defaultPeriod);
+  const [filled, setFilled] = React.useState(value ? {
+    h: true,
+    m: true,
+    s: true
+  } : {
+    h: false,
+    m: false,
+    s: false
+  });
+  const refHours = React.useRef(null);
+  const refSeconds = React.useRef(null);
+  const refMinutes = React.useRef(null);
+  const refPeriod = React.useRef(null);
+  React.useEffect(() => {
+    if (value) {
+      setTime(value);
+      if (value.getTime() !== time?.getTime()) {
+        setFilled({
+          h: true,
+          m: true,
+          s: true
+        });
+      }
+    }
+  }, [value]);
+  const handleChangePeriod = (key) => {
+    if (!time) {
+      setPeriod(`${key}m`);
+    } else if (key.toLowerCase() === "a") {
+      if (time.getHours() >= 12) {
+        const newTime = new Date(time);
+        newTime.setHours(newTime.getHours() - 12);
+        setTime(newTime);
+        onChange?.(newTime);
+      }
+      setPeriod("am");
+    } else {
+      if (time.getHours() < 12) {
+        const newTime = new Date(time);
+        newTime.setHours(newTime.getHours() + 12);
+        setTime(newTime);
+        onChange?.(newTime);
+      }
+      setPeriod("pm");
+    }
+  };
+  const handleChange = (type, key) => {
+    const newTime = time ? new Date(time) : constants.DEFAULT_DATE;
+    const valueToChange = helpers.getValueByType(type, time);
+    if (helpers.canConcat(valueToChange, type, key, timeFormat)) {
+      const newValue2 = valueToChange % 10 * 10 + key;
+      helpers.setValueByType(type, newTime, newValue2);
+    } else helpers.setValueByType(type, newTime, key);
+    const newValue = helpers.getValueByType(type, newTime);
+    if (type === "s" && newTime && newValue >= 7 && timeFormat === 12) {
+      refPeriod.current?.focus();
+    } else if (type === "m" && newTime && newValue >= 6) {
+      refSeconds.current?.focus();
+    }
+    if (type === "h") {
+      if (helpers.isCompleteHour(timeFormat, newValue)) {
+        refMinutes.current?.focus();
+      }
+    }
+    const newFilled = {
+      ...filled
+    };
+    newFilled[type] = true;
+    setTime(newTime);
+    onChange?.(newTime);
+    setFilled(newFilled);
+  };
+  const handleIncrease = (type) => {
+    const newTime = time ? new Date(time) : constants.DEFAULT_DATE;
+    const currentValue = helpers.getValueByType(type, newTime);
+    if (type === "h" && timeFormat === 24) {
+      helpers.setValueByType(type, newTime, currentValue === 23 ? 0 : currentValue + 1);
+    } else if (type === "h" && timeFormat === 12) {
+      helpers.setValueByType(type, newTime, currentValue === 12 ? 1 : currentValue + 1);
+    } else {
+      helpers.setValueByType(type, newTime, currentValue === 59 ? 0 : currentValue + 1);
+    }
+    const newFilled = {
+      ...filled
+    };
+    newFilled[type] = true;
+    setTime(newTime);
+    onChange?.(newTime);
+    setFilled(newFilled);
+  };
+  const handleDecrease = (type) => {
+    const newTime = time ? new Date(time) : constants.DEFAULT_DATE;
+    const currentValue = helpers.getValueByType(type, newTime);
+    if (type === "h" && timeFormat === 24) {
+      helpers.setValueByType(type, newTime, currentValue === 0 ? 23 : currentValue - 1);
+    } else if (type === "h" && timeFormat === 12) {
+      helpers.setValueByType(type, newTime, currentValue === 1 ? 12 : currentValue - 1);
+    } else {
+      helpers.setValueByType(type, newTime, currentValue === 0 ? 59 : currentValue - 1);
+    }
+    const newFilled = {
+      ...filled
+    };
+    newFilled[type] = true;
+    setTime(newTime);
+    onChange?.(newTime);
+    setFilled(newFilled);
+  };
+  const handleNext = (type) => {
+    if (type === "h") refMinutes.current?.focus();
+    if (type === "m") refSeconds.current?.focus();
+    if (type === "s" && timeFormat === 12) refPeriod.current?.focus();
+  };
+  const handlePrevious = (type) => {
+    if (type === "m") refHours.current?.focus();
+    if (type === "s") refMinutes.current?.focus();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(index.Stack, { gap: 0.5, className, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(index.Stack, { direction: "row", gap: 1, alignItems: "center", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(StyledText, { as: "label", prominence: "strong", sentiment: "neutral", variant: "body", children: label }),
+      required ? /* @__PURE__ */ jsxRuntime.jsx(Icon.AsteriskIcon, { size: 8, sentiment: "danger" }) : null,
+      labelDescription ? /* @__PURE__ */ jsxRuntime.jsx(StyledText, { as: "label", variant: "bodySmall", children: labelDescription }) : null
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(TimeInputWrapper, { "data-readonly": readOnly, "data-disabled": disabled, "data-size": size, "data-error": !!error, direction: "row", alignItems: "center", justifyContent: "space-between", onBlur, onFocus, "aria-required": required, onClick: () => refHours.current?.focus(), id, "data-testid": dataTestId, "aria-label": ariaLabel, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(index.Stack, { direction: "row", children: [
+        constants.TIME_KEYS.map((type) => {
+          const computedRef = () => {
+            if (type === "h") return refHours;
+            if (type === "m") return refMinutes;
+            return refSeconds;
+          };
+          const fullName = () => {
+            if (type === "h") return "hours";
+            if (type === "m") return "minutes";
+            return "seconds";
+          };
+          const computeMaxValue = () => {
+            if (type === "h" && timeFormat === 12) return 12;
+            if (type === "h" && timeFormat === 24) return 23;
+            return 59;
+          };
+          return /* @__PURE__ */ jsxRuntime.jsxs(index.Stack, { direction: "row", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(Input, { value: filled[type] ? helpers.format(helpers.getValueByType(type, time), type, timeFormat) : "", placeholder: placeholder[type], "data-size": size, readOnly, disabled, "aria-label": ariaLabel, "data-testid": `${fullName()}-input`, onClick: (event) => {
+              event.stopPropagation();
+            }, ref: computedRef(), role: "spinbutton", "aria-valuemax": computeMaxValue(), "aria-valuemin": type === "h" && timeFormat === 12 ? 1 : 0, "aria-valuenow": filled[type] ? Number.parseInt(helpers.format(helpers.getValueByType(type, time), type, timeFormat), 10) : void 0, onChange: (event) => {
+              if (!readOnly && !disabled) {
+                const key = helpers.getLastTypedChar(event.target.value, helpers.getValueByType(type, time));
+                if (helpers.isNumber(key)) {
+                  handleChange(type, Number.parseInt(key, 10));
+                }
+              }
+            }, onKeyDown: (event) => {
+              if (!readOnly && !disabled) {
+                if (event.key === "ArrowUp") {
+                  event.preventDefault();
+                  handleIncrease(type);
+                } else if (event.key === "ArrowDown") {
+                  event.preventDefault();
+                  handleDecrease(type);
+                } else if (event.key === "ArrowLeft") {
+                  event.preventDefault();
+                  handlePrevious(type);
+                } else if (event.key === "ArrowRight") {
+                  event.preventDefault();
+                  handleNext(type);
+                }
+              }
+            }, autoFocus: autoFocus && type === "h" }),
+            type === "s" ? null : /* @__PURE__ */ jsxRuntime.jsx(CustomText, { as: "span", variant: "body", prominence: "default", sentiment: "neutral", children: ":" })
+          ] }, type);
+        }),
+        timeFormat === 12 ? /* @__PURE__ */ jsxRuntime.jsx(Input, { value: period?.toUpperCase(), placeholder: placeholder.period ?? "AM", "data-size": size, "data-period": true, readOnly, disabled, "aria-label": ariaLabel, "data-testid": "am-pm-input", onChange: (event) => {
+          if (!readOnly && !disabled) {
+            const key = event.target.value.slice(-1);
+            if (helpers.isAOrP(key)) handleChangePeriod(key);
+          }
+        }, onKeyDown: (event) => {
+          if (!readOnly && !disabled) {
+            if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+              event.preventDefault();
+              handleChangePeriod(period === "am" ? "p" : "a");
+            } else if (event.key === "ArrowLeft") {
+              event.preventDefault();
+              refSeconds.current?.focus();
+            }
+          }
+        }, ref: refPeriod, onClick: (event) => event.stopPropagation(), role: "spinbutton", "aria-valuemax": 12, "aria-valuemin": 0, "aria-valuenow": period === "am" ? 0 : 12, "aria-valuetext": period }) : null
+      ] }),
+      error || clearable ? /* @__PURE__ */ jsxRuntime.jsxs(index.Stack, { direction: "row", alignItems: "center", gap: "1", children: [
+        error ? /* @__PURE__ */ jsxRuntime.jsx(Icon.AlertCircleIcon, { sentiment: "danger" }) : null,
+        clearable ? /* @__PURE__ */ jsxRuntime.jsx(index$2.Button, { "aria-label": "clear value", disabled: disabled || readOnly, variant: "ghost", size: "small", icon: "close", onClick: (event) => {
+          event.stopPropagation();
+          setTime(void 0);
+          onChange?.(void 0);
+        }, sentiment: "neutral", "data-testid": "clear" }) : null
+      ] }) : null
+    ] }),
+    helper || error ? /* @__PURE__ */ jsxRuntime.jsx(index$1.Text, { as: "p", variant: "caption", sentiment: error ? "danger" : "neutral", prominence: error ? "default" : "weak", disabled, children: error || helper }) : null
+  ] });
+};
+exports.Input = Input;
+exports.TimeInputV2 = TimeInputV2;

package/dist/components/TimeInputV2/index.d.ts

@@ -0,0 +1,44 @@
+import type { FocusEvent, ReactNode } from 'react';
+import type { LabelProp } from '../../types';
+export type Time = {
+    h: string;
+    m: string;
+    s: string;
+    period?: string;
+};
+export declare const Input: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: React.ElementType;
+} & {
+    'data-size': "small" | "medium" | "large";
+    'data-period'?: boolean;
+}, import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, {}>;
+type TimeInputProps = {
+    placeholder?: Time;
+    value?: Date;
+    clearable?: boolean;
+    required?: boolean;
+    labelDescription?: ReactNode;
+    helper?: ReactNode;
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: boolean | string;
+    'data-testid'?: string;
+    onChange?: (value: Date | undefined, valuePeriod?: string) => void;
+    onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
+    onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+    className?: string;
+    id?: string;
+    size?: 'small' | 'medium' | 'large';
+    timeFormat?: 12 | 24;
+    /**
+     * Automatically focus on the element on render. Autofocus is applied to the hour input
+     */
+    autoFocus?: boolean;
+} & LabelProp;
+/**
+ * A time input component that allows users to type a time in a 24 or 12-hour format.
+ * @experimental This component is experimental and may be subject to breaking changes in the future.
+ */
+export declare const TimeInputV2: ({ label, timeFormat, value, clearable, required, labelDescription, helper, size, disabled, readOnly, error, onChange, onBlur, onFocus, className, id, autoFocus, "data-testid": dataTestId, placeholder, "aria-label": ariaLabel, }: TimeInputProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};