@vonage/vivid 3.52.0 → 3.54.0

package/shared/definition56.js

@@ -1,10 +1,218 @@
-import { a as attr, F as FoundationElement, D as DOM, h as html, r as registerFactory } from './index.js';
-import { P as Popup, p as popupRegistries } from './definition61.js';
-import { b as anchored, a as anchorSlotTemplateFactory } from './anchored.js';
+import { F as FoundationElement, a as attr, D as DOM, n as nullableNumberConverter, o as observable, h as html, r as registerFactory } from './index.js';
+import { T as TextField, a as textFieldRegistries } from './definition55.js';
+import { P as Popup, p as popupRegistries } from './definition63.js';
+import { B as Button, a as buttonRegistries } from './definition11.js';
+import './affix.js';
+import { e as errorText, f as formElements, a as FormElementHelperText } from './index2.js';
+import { L as Localized } from './localized.js';
+import { T as TrappedFocus } from './trapped-focus.js';
+import { a as applyMixinsWithObservables } from './applyMixinsWithObservables.js';
+import { F as FormAssociated } from './form-associated.js';
+import { r as ref } from './ref.js';
+import { s as slotted } from './slotted.js';
 import { w as when } from './when.js';
+import { r as repeat } from './repeat.js';
 import { c as classNames } from './class-names.js';
 
-const styles = ":host{display:var(--_popup-display, inline)}:host([slotted-anchor]){--_popup-display: contents}.content-wrapper{width:var(--toggletip-inline-size, auto);padding:16px}.headline{font:var(--vvd-typography-base-bold)}.action-items{display:flex;justify-content:flex-end;gap:10px}::slotted([slot=action-items]){margin-block-start:16px}\n";
+const styles = ":host{display:inline-block}.base,.control{inline-size:100%}.dialog{display:inline-flex;flex-direction:column}.dialog .footer{display:flex;align-items:center;justify-content:flex-end;padding:8px;border-top:1px solid var(--vvd-color-neutral-200);gap:8px}.time-pickers{display:flex;overflow:hidden;padding:4px;block-size:188px;gap:4px}.time-pickers .picker{position:relative;display:flex;overflow:hidden;flex-direction:column;padding:0;border-radius:4px;margin:0;gap:4px;inline-size:50px;list-style:none;scrollbar-width:thin}.time-pickers .picker:hover{overflow-y:auto}.time-pickers .picker:after{display:block;flex-shrink:0;block-size:156px;content:\"\"}.time-pickers .picker:focus-visible{--focus-stroke-gap-color: transparent;--focus-inset: -2px;box-shadow:inset 0 0 0 3px var(--focus-stroke-gap-color, currentColor);outline:2px solid var(--focus-stroke-color, var(--vvd-color-canvas-text));outline-offset:calc(-2px - var(--focus-inset, 0px))}.time-pickers .item{display:flex;flex-shrink:0;align-items:center;justify-content:center;border-radius:4px;background-color:var(--_appearance-color-fill);block-size:28px;color:var(--_appearance-color-text);cursor:pointer;font:var(--vvd-typography-base);inline-size:50px}.time-pickers .item{--_connotation-color-primary: var(--vvd-time-picker-accent-primary, var(--vvd-color-canvas-text));--_connotation-color-firm: var(--vvd-time-picker-accent-firm, var(--vvd-color-canvas-text));--_connotation-color-faint: var(--vvd-time-picker-accent-faint, var(--vvd-color-neutral-50));--_connotation-color-soft: var(--vvd-time-picker-accent-soft, var(--vvd-color-neutral-100));--_connotation-color-dim: var(--vvd-time-picker-accent-dim, var(--vvd-color-neutral-200));--_connotation-color-pale: var(--vvd-time-picker-accent-pale, var(--vvd-color-neutral-300))}.time-pickers .item{--_appearance-color-text: var(--_connotation-color-firm);--_appearance-color-fill: transparent;--_appearance-color-outline: transparent}.time-pickers .item:where(.hover,:hover):where(:not(.disabled,:disabled,.readonly)){--_appearance-color-text: var(--_connotation-color-firm);--_appearance-color-fill: var(--_connotation-color-faint);--_appearance-color-outline: transparent}.time-pickers .item:where(.active,:active):where(:not(.disabled,:disabled)){--_appearance-color-text: var(--_connotation-color-firm);--_appearance-color-fill: var(--_connotation-color-soft);--_appearance-color-outline: transparent}.time-pickers .item:where(.selected):where(:not(.disabled,:disabled)){--_appearance-color-text: var(--_connotation-color-firm);--_appearance-color-fill: var(--_connotation-color-soft);--_appearance-color-outline: transparent}.time-pickers .item:where(.selected):where(.hover,:hover):where(:not(.disabled,:disabled,.readonly)){--_appearance-color-text: var(--_connotation-color-firm);--_appearance-color-fill: var(--_connotation-color-dim);--_appearance-color-outline: transparent}.time-pickers .item:where(.selected):where(.disabled,:disabled){--_appearance-color-text: var(--vvd-color-neutral-300);--_appearance-color-fill: var(--vvd-color-neutral-200);--_appearance-color-outline: transparent}\n";
+
+class _TimePicker extends FoundationElement {
+}
+class FormAssociatedTimePicker extends FormAssociated(_TimePicker) {
+  constructor() {
+    super(...arguments);
+    this.proxy = document.createElement("input");
+  }
+}
+
+const isValidTimeStr = (timeStr) => {
+  const parts = timeStr.split(":");
+  if (parts.length !== 3) {
+    return false;
+  }
+  const [hours, minutes, seconds] = parts;
+  if (hours.length !== 2 || minutes.length !== 2 || seconds.length !== 2) {
+    return false;
+  }
+  const hoursNum = parseInt(hours, 10);
+  const minutesNum = parseInt(minutes, 10);
+  const secondsNum = parseInt(seconds, 10);
+  if (isNaN(hoursNum) || isNaN(minutesNum) || isNaN(secondsNum)) {
+    return false;
+  }
+  if (hoursNum < 0 || hoursNum > 23) {
+    return false;
+  }
+  if (minutesNum < 0 || minutesNum > 59) {
+    return false;
+  }
+  if (secondsNum < 0 || secondsNum > 59) {
+    return false;
+  }
+  return true;
+};
+const parseTimePart = (partStr) => Number.parseInt(partStr, 10);
+const formatTimePart = (part) => part.toString().padStart(2, "0");
+const parseTimeStr = (timeStr) => {
+  const [hoursStr, minutesStr, secondsStr] = timeStr.split(":");
+  const hours = parseTimePart(hoursStr);
+  const minutes = parseTimePart(minutesStr);
+  const seconds = parseTimePart(secondsStr);
+  return {
+    hourStr: hoursStr,
+    hours,
+    minuteStr: minutesStr,
+    minutes,
+    secondStr: secondsStr,
+    seconds,
+    meridiem: hours < 12 ? "AM" : "PM"
+  };
+};
+const hoursAs12hClock = (hour) => hour % 12 || 12;
+
+const formatPresentationTime = (timeStr, includeSeconds, use12HourClock) => {
+  const time = parseTimeStr(timeStr);
+  const hoursStr = formatTimePart(
+    use12HourClock ? hoursAs12hClock(time.hours) : time.hours
+  );
+  let result = `${hoursStr}:${time.minuteStr}`;
+  if (includeSeconds) {
+    result += `:${time.secondStr}`;
+  }
+  if (use12HourClock) {
+    result += ` ${time.meridiem}`;
+  }
+  return result;
+};
+const isDigit = (char) => char >= "0" && char <= "9";
+const parsePresentationTime = (input, use12HourClock) => {
+  const cleanedInput = input.toLowerCase();
+  const numerals = [];
+  let meridiem;
+  for (let i = 0; i < cleanedInput.length; i++) {
+    const char = cleanedInput[i];
+    if (char === "a" && cleanedInput[i + 1] === "m") {
+      i++;
+      meridiem = "AM";
+    }
+    if (char === "p" && cleanedInput[i + 1] === "m") {
+      i++;
+      meridiem = "PM";
+    }
+    if (isDigit(char)) {
+      let numeral = char;
+      while (isDigit(cleanedInput[i + 1])) {
+        i++;
+        numeral += cleanedInput[i];
+      }
+      numerals.push(Number.parseInt(numeral, 10));
+    }
+  }
+  if (numerals.length === 0 || numerals.length > 3) {
+    throw new Error("Invalid time format");
+  }
+  if (meridiem && (numerals[0] < 1 || numerals[0] > 12)) {
+    throw new Error("Invalid time format");
+  }
+  if (meridiem || use12HourClock) {
+    if (numerals[0] === 12) {
+      numerals[0] = 0;
+    }
+  }
+  if (meridiem === "PM") {
+    numerals[0] = numerals[0] + 12;
+  }
+  const [hours, minutes = 0, seconds = 0] = numerals;
+  if (hours > 23 || minutes > 59 || seconds > 59) {
+    throw new Error("Invalid value");
+  }
+  return [hours, minutes, seconds].map(formatTimePart).join(":");
+};
+
+const fallsIntoMeridiem = (meridiem, hour) => meridiem === "AM" && hour < 12 || meridiem === "PM" && hour >= 12;
+const getHoursOptions = (min, max, forMeridiem) => {
+  const result = [];
+  const minHour = min ? parseTimeStr(min).hours : 0;
+  const maxHour = max ? parseTimeStr(max).hours : 23;
+  for (let i = minHour; i <= maxHour; i++) {
+    if (forMeridiem && !fallsIntoMeridiem(forMeridiem, i)) {
+      continue;
+    }
+    result.push({
+      value: formatTimePart(i),
+      label: formatTimePart(forMeridiem ? hoursAs12hClock(i) : i)
+    });
+  }
+  return result;
+};
+const getMinutesOptions = (step, value, min, max) => {
+  const result = [];
+  let minMinute = 0;
+  let maxMinute = 59;
+  if (min) {
+    const { hourStr: minHourStr, minutes: minMinutes } = parseTimeStr(min);
+    if (value && parseTimeStr(value).hourStr === minHourStr) {
+      minMinute = minMinutes;
+    }
+  }
+  if (max) {
+    const { hourStr: maxHourStr, minutes: maxMinutes } = parseTimeStr(max);
+    if (value && parseTimeStr(value).hourStr === maxHourStr) {
+      maxMinute = maxMinutes;
+    }
+  }
+  for (let i = minMinute; i <= maxMinute; i += Math.max(1, step ?? 1)) {
+    const minutes = formatTimePart(i);
+    result.push({
+      value: minutes,
+      label: minutes
+    });
+  }
+  return result;
+};
+const getSecondsOptions = (step, value, min, max) => {
+  const result = [];
+  let minSecond = 0;
+  let maxSecond = 59;
+  if (min) {
+    const minTime = parseTimeStr(min);
+    if (value && (parseTimeStr(value).hourStr === minTime.hourStr && parseTimeStr(value).minuteStr) === minTime.minuteStr) {
+      minSecond = minTime.seconds;
+    }
+  }
+  if (max) {
+    const maxTime = parseTimeStr(max);
+    if (value && (parseTimeStr(value).hourStr === maxTime.hourStr && parseTimeStr(value).minuteStr) === maxTime.minuteStr) {
+      maxSecond = maxTime.seconds;
+    }
+  }
+  for (let i = minSecond; i <= maxSecond; i += Math.max(1, step)) {
+    const seconds = formatTimePart(i);
+    result.push({
+      value: seconds,
+      label: seconds
+    });
+  }
+  return result;
+};
+const getMeridiesOptions = (min, max) => {
+  const result = [];
+  const hideAM = min ? parseTimeStr(min).meridiem === "PM" : false;
+  if (!hideAM) {
+    result.push({
+      value: "AM",
+      label: "AM"
+    });
+  }
+  const hidePM = max ? parseTimeStr(max).meridiem === "AM" : false;
+  if (!hidePM) {
+    result.push({
+      value: "PM",
+      label: "PM"
+    });
+  }
+  return result;
+};
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -34,142 +242,645 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _ANCHOR_ARIA_LABEL_SUFFIX, _setupAnchor, setupAnchor_fn, _updateAnchor, updateAnchor_fn, _cleanupAnchor, cleanupAnchor_fn, _openIfClosed, _updateListeners, updateListeners_fn, _closeOnClickOutside, _closeOnEscape;
-let Toggletip = class extends FoundationElement {
+var _getFocusableEls, _updateValueDueToUserInteraction, updateValueDueToUserInteraction_fn, _onFocusIn, _onFocusOut, _dismissOnClickOutside, _openPopupIfPossible, openPopupIfPossible_fn, _scrollToItem, scrollToItem_fn;
+const ValidTimeFilter = {
+  fromView: (value) => {
+    if (value && isValidTimeStr(value)) {
+      return value;
+    }
+    return "";
+  },
+  toView(value) {
+    return value;
+  }
+};
+let TimePicker = class extends FormAssociatedTimePicker {
   constructor() {
-    super(...arguments);
-    __privateAdd(this, _setupAnchor);
-    __privateAdd(this, _updateAnchor);
-    __privateAdd(this, _cleanupAnchor);
-    __privateAdd(this, _updateListeners);
-    __privateAdd(this, _ANCHOR_ARIA_LABEL_SUFFIX, " ; Show more information");
-    this.alternate = false;
-    this.placement = "right";
-    this.open = false;
-    __privateAdd(this, _openIfClosed, () => {
-      if (!this.open)
-        DOM.queueUpdate(() => this.open = true);
+    super();
+    __privateAdd(this, _updateValueDueToUserInteraction);
+    __privateAdd(this, _openPopupIfPossible);
+    __privateAdd(this, _scrollToItem);
+    this.readOnly = false;
+    this.minutesStep = null;
+    this.secondsStep = null;
+    __privateAdd(this, _getFocusableEls, () => this.shadowRoot.querySelectorAll(`
+			.dialog [tabindex="0"],
+			.dialog .vwc-button:not(:disabled)
+		`));
+    __privateAdd(this, _onFocusIn, () => {
+      this.$emit("focus", void 0, { bubbles: false });
     });
-    __privateAdd(this, _closeOnClickOutside, (e) => {
-      const clickedOutside = !this.contains(e.target);
-      const clickedOnAnchor = this._anchorEl?.contains(e.target);
-      if (clickedOutside || clickedOnAnchor)
-        this.open = false;
+    __privateAdd(this, _onFocusOut, () => {
+      this.$emit("blur", void 0, { bubbles: false });
     });
-    __privateAdd(this, _closeOnEscape, (e) => {
-      if (e.key === "Escape")
-        this.open = false;
+    this._popupOpen = false;
+    __privateAdd(this, _dismissOnClickOutside, (event) => {
+      if (!this._popupOpen) {
+        return;
+      }
+      const path = event.composedPath();
+      const elementsToIgnoreClicksOn = [this._dialogEl, this._clockButtonEl];
+      if (!elementsToIgnoreClicksOn.some((element) => path.includes(element))) {
+        this._closePopup(false);
+      }
     });
+    this._presentationValue = "";
+    this.value = "";
+    this.min = "";
+    this.max = "";
+    this.proxy.type = "time";
+    this.proxy.step = "1";
   }
-  openChanged(oldValue, newValue) {
-    if (oldValue === void 0)
-      return;
-    if (newValue) {
-      this.setAttribute("role", "status");
-    } else {
-      this.removeAttribute("role");
+  /**
+   * @internal
+   */
+  readOnlyChanged() {
+    if (this.proxy instanceof HTMLInputElement) {
+      this.proxy.readOnly = this.readOnly;
+      this.validate();
+    }
+  }
+  /**
+   * @internal
+   */
+  minChanged(_, newMin) {
+    if (this.proxy instanceof HTMLInputElement) {
+      this.proxy.min = newMin;
+      this.validate();
+    }
+  }
+  /**
+   * @internal
+   */
+  maxChanged(_, newMax) {
+    if (this.proxy instanceof HTMLInputElement) {
+      this.proxy.max = newMax;
+      this.validate();
     }
-    __privateMethod(this, _updateListeners, updateListeners_fn).call(this);
-    if (this._anchorEl) {
-      __privateMethod(this, _updateAnchor, updateAnchor_fn).call(this, this._anchorEl);
+  }
+  // --- Core ---
+  /**
+   * @internal
+   */
+  get _displaySeconds() {
+    return this.secondsStep !== null;
+  }
+  /**
+   * @internal
+   */
+  get _use12hClock() {
+    return this.clock ? this.clock === "12h" : this.locale.timePicker.defaultTo12HourClock;
+  }
+  /**
+   * @internal
+   */
+  valueChanged(previous, next) {
+    super.valueChanged(previous, next);
+    if (this.value) {
+      if (!isValidTimeStr(this.value)) {
+        this.value = "";
+        return;
+      }
+      this._presentationValue = formatPresentationTime(
+        this.value,
+        this._displaySeconds,
+        this._use12hClock
+      );
+    } else {
+      this._presentationValue = "";
     }
   }
   connectedCallback() {
     super.connectedCallback();
-    __privateMethod(this, _updateListeners, updateListeners_fn).call(this);
+    document.addEventListener("click", __privateGet(this, _dismissOnClickOutside));
+    this.addEventListener("focusin", __privateGet(this, _onFocusIn));
+    this.addEventListener("focusout", __privateGet(this, _onFocusOut));
   }
   disconnectedCallback() {
     super.disconnectedCallback();
-    __privateMethod(this, _updateListeners, updateListeners_fn).call(this);
+    document.removeEventListener("click", __privateGet(this, _dismissOnClickOutside));
+    this.removeEventListener("focusin", __privateGet(this, _onFocusIn));
+    this.removeEventListener("focusout", __privateGet(this, _onFocusOut));
   }
   /**
    * @internal
    */
-  _anchorElChanged(oldValue, newValue) {
-    if (oldValue)
-      __privateMethod(this, _cleanupAnchor, cleanupAnchor_fn).call(this, oldValue);
-    if (newValue)
-      __privateMethod(this, _setupAnchor, setupAnchor_fn).call(this, newValue);
+  _closePopup(restoreFocusToTextField = true) {
+    this._popupOpen = false;
+    if (restoreFocusToTextField) {
+      this._textFieldEl.focus();
+    }
+  }
+  /**
+   * On keydown anywhere in the time picker.
+   * @internal
+   */
+  _onBaseKeyDown(event) {
+    if (event.key === "Escape") {
+      this._closePopup();
+      return false;
+    }
+    if (this._trappedFocus(event, __privateGet(this, _getFocusableEls))) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * @internal
+   */
+  _presentationValueChanged() {
+    this.dirtyValue = true;
+    this.validate();
+  }
+  /**
+   * @internal
+   */
+  get _textFieldPlaceholder() {
+    let format = "hh:mm";
+    if (this._displaySeconds) {
+      format += ":ss";
+    }
+    if (this._use12hClock) {
+      format += " aa";
+    }
+    return format;
+  }
+  /**
+   * @internal
+   */
+  _onTextFieldInput(event) {
+    const textField = event.currentTarget;
+    this._presentationValue = textField.value;
+  }
+  /**
+   * @internal
+   */
+  _onTextFieldChange() {
+    if (this._presentationValue === "") {
+      __privateMethod(this, _updateValueDueToUserInteraction, updateValueDueToUserInteraction_fn).call(this, "");
+      return;
+    }
+    try {
+      __privateMethod(this, _updateValueDueToUserInteraction, updateValueDueToUserInteraction_fn).call(this, parsePresentationTime(this._presentationValue, this._use12hClock));
+    } catch (_) {
+      return;
+    }
+  }
+  // --- Clock button ---
+  /**
+   * @internal
+   */
+  get _clockButtonLabel() {
+    if (this.value) {
+      return this.locale.timePicker.changeTimeLabel(
+        formatPresentationTime(
+          this.value,
+          this._displaySeconds,
+          this._use12hClock
+        )
+      );
+    }
+    return this.locale.timePicker.chooseTimeLabel;
+  }
+  /**
+   * @internal
+   */
+  _onClockButtonClick() {
+    if (this._popupOpen) {
+      this._closePopup();
+    } else {
+      __privateMethod(this, _openPopupIfPossible, openPopupIfPossible_fn).call(this);
+      DOM.processUpdates();
+      if (this._selectedHour) {
+        __privateMethod(this, _scrollToItem, scrollToItem_fn).call(this, "hours", this._selectedHour, "start");
+      }
+      if (this._selectedMinute) {
+        __privateMethod(this, _scrollToItem, scrollToItem_fn).call(this, "minutes", this._selectedMinute, "start");
+      }
+      if (this._displaySeconds && this._selectedSecond) {
+        __privateMethod(this, _scrollToItem, scrollToItem_fn).call(this, "seconds", this._selectedSecond, "start");
+      }
+      if (this._use12hClock && this._selectedMeridiem) {
+        __privateMethod(this, _scrollToItem, scrollToItem_fn).call(this, "meridies", this._selectedMeridiem, "start");
+      }
+      __privateGet(this, _getFocusableEls).call(this)[0].focus();
+    }
+  }
+  // --- Pickers ---
+  /**
+   * @internal
+   */
+  get _hours() {
+    return getHoursOptions(
+      this.min,
+      this.max,
+      this._use12hClock ? this._selectedMeridiem ?? this._meridies[0].value : void 0
+    );
+  }
+  /**
+   * @internal
+   */
+  get _selectedHour() {
+    return this.value ? parseTimeStr(this.value).hourStr : void 0;
+  }
+  /**
+   * @internal
+   */
+  set _selectedHour(value) {
+    if (this.value) {
+      const { minuteStr, secondStr } = parseTimeStr(this.value);
+      this.value = `${value}:${minuteStr}:${secondStr}`;
+    } else {
+      this.value = `${value}:00:00`;
+    }
+  }
+  /**
+   * @internal
+   */
+  get _minutes() {
+    return getMinutesOptions(this.minutesStep, this.value, this.min, this.max);
+  }
+  /**
+   * @internal
+   */
+  get _selectedMinute() {
+    return this.value ? parseTimeStr(this.value).minuteStr : void 0;
+  }
+  /**
+   * @internal
+   */
+  set _selectedMinute(value) {
+    if (this.value) {
+      const { hourStr, secondStr } = parseTimeStr(this.value);
+      this.value = `${hourStr}:${value}:${secondStr}`;
+    } else {
+      this.value = `00:${value}:00`;
+    }
+  }
+  /**
+   * @internal
+   */
+  get _seconds() {
+    return getSecondsOptions(this.secondsStep, this.value, this.min, this.max);
+  }
+  /**
+   * @internal
+   */
+  get _selectedSecond() {
+    return this.value ? parseTimeStr(this.value).secondStr : void 0;
+  }
+  /**
+   * @internal
+   */
+  set _selectedSecond(value) {
+    if (this.value) {
+      const { hourStr, minuteStr } = parseTimeStr(this.value);
+      this.value = `${hourStr}:${minuteStr}:${value}`;
+    } else {
+      this.value = `00:00:${value}`;
+    }
+  }
+  /**
+   * @internal
+   */
+  get _meridies() {
+    return getMeridiesOptions(this.min, this.max);
+  }
+  /**
+   * @internal
+   */
+  get _selectedMeridiem() {
+    return this.value ? parseTimeStr(this.value).meridiem : void 0;
+  }
+  /**
+   * @internal
+   */
+  set _selectedMeridiem(value) {
+    if (this.value) {
+      const { hours, minuteStr, secondStr } = parseTimeStr(this.value);
+      let adjustedHours = hours;
+      if (value === "AM" && hours >= 12) {
+        adjustedHours -= 12;
+      } else if (value === "PM" && hours < 12) {
+        adjustedHours += 12;
+      }
+      this.value = `${formatTimePart(adjustedHours)}:${minuteStr}:${secondStr}`;
+    } else {
+      if (value === "AM") {
+        this.value = "00:00:00";
+      } else {
+        this.value = "12:00:00";
+      }
+    }
+  }
+  /**
+   * @internal
+   */
+  _onPickerKeyDown(picker, options, selectedValue, setSelectedValue, event) {
+    const offset = {
+      ArrowUp: -1,
+      ArrowDown: 1
+    }[event.key];
+    if (offset) {
+      event.preventDefault();
+      const index = options.findIndex((h) => h.value === selectedValue);
+      const newRawIndex = index === -1 ? 0 : index + offset;
+      const newIndex = (newRawIndex + options.length) % options.length;
+      const newValue = options[newIndex].value;
+      setSelectedValue(newValue);
+      __privateMethod(this, _scrollToItem, scrollToItem_fn).call(this, picker, newValue, "nearest");
+      __privateMethod(this, _updateValueDueToUserInteraction, updateValueDueToUserInteraction_fn).call(this, this.value);
+    }
+    return true;
+  }
+  /**
+   * @internal
+   */
+  _onPickerItemClick(picker, setSelectedValue, value) {
+    setSelectedValue(value);
+    __privateMethod(this, _scrollToItem, scrollToItem_fn).call(this, picker, value, "start");
+    __privateMethod(this, _updateValueDueToUserInteraction, updateValueDueToUserInteraction_fn).call(this, this.value);
+    const nextPickerEl = this.shadowRoot.querySelector(
+      `#${picker} + .picker`
+    );
+    if (nextPickerEl) {
+      nextPickerEl.focus();
+    } else {
+      this._closePopup();
+    }
+  }
+  // --- Dialog footer ---
+  /**
+   * @internal
+   */
+  _onOkClick() {
+    this._closePopup();
+  }
+  /**
+   * @internal
+   */
+  _onClearClick() {
+    __privateMethod(this, _updateValueDueToUserInteraction, updateValueDueToUserInteraction_fn).call(this, "");
+    this._closePopup();
+  }
+  // --- Validation ---
+  /**
+   * @internal
+   */
+  validate() {
+    if (this.proxy) {
+      this.proxy.setCustomValidity(this._getCustomValidationError() ?? "");
+    }
+    super.validate(this._textFieldEl?.querySelector("input") ?? void 0);
+  }
+  /**
+   * @internal
+   */
+  _getCustomValidationError() {
+    if (this._isPresentationValueInvalid()) {
+      return this.locale.timePicker.invalidTimeError;
+    }
+    return null;
+  }
+  /**
+   * @internal
+   */
+  _isPresentationValueInvalid() {
+    if (this._presentationValue === "") {
+      return false;
+    }
+    try {
+      parsePresentationTime(this._presentationValue, this._use12hClock);
+      return false;
+    } catch (_) {
+      return true;
+    }
   }
 };
-_ANCHOR_ARIA_LABEL_SUFFIX = new WeakMap();
-_setupAnchor = new WeakSet();
-setupAnchor_fn = function(a) {
-  a.addEventListener("click", __privateGet(this, _openIfClosed), true);
-  a.ariaLabel = (a.ariaLabel ?? "") + __privateGet(this, _ANCHOR_ARIA_LABEL_SUFFIX);
-  __privateMethod(this, _updateAnchor, updateAnchor_fn).call(this, a);
-};
-_updateAnchor = new WeakSet();
-updateAnchor_fn = function(a) {
-  a.setAttribute("aria-expanded", this.open.toString());
+_getFocusableEls = new WeakMap();
+_updateValueDueToUserInteraction = new WeakSet();
+updateValueDueToUserInteraction_fn = function(newValue) {
+  this.value = newValue;
+  this.$emit("change");
+  this.$emit("input");
 };
-_cleanupAnchor = new WeakSet();
-cleanupAnchor_fn = function(a) {
-  a.removeEventListener("click", __privateGet(this, _openIfClosed), true);
-  if (a.ariaLabel)
-    a.ariaLabel = a.ariaLabel.replace(__privateGet(this, _ANCHOR_ARIA_LABEL_SUFFIX), "");
+_onFocusIn = new WeakMap();
+_onFocusOut = new WeakMap();
+_dismissOnClickOutside = new WeakMap();
+_openPopupIfPossible = new WeakSet();
+openPopupIfPossible_fn = function() {
+  if (!this.readOnly) {
+    this._popupOpen = true;
+  }
 };
-_openIfClosed = new WeakMap();
-_updateListeners = new WeakSet();
-updateListeners_fn = function() {
-  document.removeEventListener("click", __privateGet(this, _closeOnClickOutside));
-  document.removeEventListener("keydown", __privateGet(this, _closeOnEscape));
-  if (this.open && this.isConnected) {
-    document.addEventListener("click", __privateGet(this, _closeOnClickOutside));
-    document.addEventListener("keydown", __privateGet(this, _closeOnEscape));
+_scrollToItem = new WeakSet();
+scrollToItem_fn = function(picker, selectedValue, position) {
+  const element = this.shadowRoot.querySelector(
+    `#${picker}-${selectedValue}`
+  );
+  if (!element) {
+    return;
+  }
+  const parent = element.parentElement;
+  switch (position) {
+    case "start":
+      parent.scrollTop = element.offsetTop;
+      break;
+    case "nearest":
+      if (element.offsetTop < parent.scrollTop) {
+        parent.scrollTop = element.offsetTop;
+      }
+      if (element.offsetTop + element.offsetHeight > parent.scrollTop + parent.offsetHeight) {
+        parent.scrollTop = element.offsetTop + element.offsetHeight - parent.offsetHeight;
+      }
+      break;
   }
 };
-_closeOnClickOutside = new WeakMap();
-_closeOnEscape = new WeakMap();
+__decorateClass([
+  attr({ attribute: "readonly", mode: "boolean" })
+], TimePicker.prototype, "readOnly", 2);
+__decorateClass([
+  attr({ attribute: "minutes-step", converter: nullableNumberConverter })
+], TimePicker.prototype, "minutesStep", 2);
+__decorateClass([
+  attr({ attribute: "seconds-step", converter: nullableNumberConverter })
+], TimePicker.prototype, "secondsStep", 2);
 __decorateClass([
   attr
-], Toggletip.prototype, "headline", 2);
+], TimePicker.prototype, "clock", 2);
 __decorateClass([
-  attr({ mode: "boolean" })
-], Toggletip.prototype, "alternate", 2);
+  attr({ converter: ValidTimeFilter })
+], TimePicker.prototype, "min", 2);
 __decorateClass([
-  attr({ mode: "fromView" })
-], Toggletip.prototype, "placement", 2);
+  attr({ converter: ValidTimeFilter })
+], TimePicker.prototype, "max", 2);
 __decorateClass([
-  attr({ mode: "boolean" })
-], Toggletip.prototype, "open", 2);
-Toggletip = __decorateClass([
-  anchored
-], Toggletip);
+  observable
+], TimePicker.prototype, "_popupOpen", 2);
+__decorateClass([
+  observable
+], TimePicker.prototype, "_presentationValue", 2);
+TimePicker = __decorateClass([
+  errorText,
+  formElements
+], TimePicker);
+applyMixinsWithObservables(
+  TimePicker,
+  Localized,
+  FormElementHelperText,
+  TrappedFocus
+);
 
-const getClasses = (_) => classNames("control");
-const ToggletipTemplate = (context) => {
-  const popup = context.tagFor(Popup);
-  const anchorSlotTemplate = anchorSlotTemplateFactory();
+const renderPicker = (id, getLabel, getSelected, setSelected, getOptions) => {
   return html`
-		${anchorSlotTemplate}
-		<${popup}
-			class="${getClasses}"
-			arrow
-			:anchor="${(x) => x._anchorEl}"
-			:open="${(x) => x.open}"
-			?alternate="${(x) => !x.alternate}"
-			placement="${(x) => x.placement}"
-			exportparts="vvd-theme-alternate"
+		<ul
+			id="${id}"
+			class="picker"
+			role="listbox"
+			tabindex="0"
+			aria-label="${getLabel}"
+			aria-activedescendant="${(x) => getSelected(x) ? `${id}-${getSelected(x)}` : void 0}"
+			@keydown="${(x, c) => x._onPickerKeyDown(
+    id,
+    getOptions(x),
+    getSelected(x),
+    setSelected(x),
+    c.event
+  )}"
 		>
-			<div class="content-wrapper">
-				${when(
-    (x) => x.headline,
-    html`<header class="headline">${(x) => x.headline}</header>`
+			${repeat(
+    getOptions,
+    html`
+					<li
+						id="${(x) => `${id}-${x.value}`}"
+						class="${(x, c) => classNames("item", [
+      "selected",
+      getSelected(c.parent) === x.value
+    ])}"
+						role="option"
+						aria-selected="${(x, c) => getSelected(c.parent) === x.value}"
+						@click="${(x, c) => c.parent._onPickerItemClick(id, setSelected(c.parent), x.value)}"
+					>
+						${(x) => x.label}
+					</li>
+				`
   )}
-				<slot></slot>
-				<footer class="action-items"><slot name="action-items"></slot></footer>
-			</div>
-		</${popup}>
+		</ul>
 	`;
 };
+const TimePickerTemplate = (context, _) => {
+  const popupTag = context.tagFor(Popup);
+  const textFieldTag = context.tagFor(TextField);
+  const buttonTag = context.tagFor(Button);
+  return html`<div class="base" @keydown="${(x, { event }) => x._onBaseKeyDown(event)}">
+		<${textFieldTag} id="text-field"
+										 ${ref("_textFieldEl")}
+										 class="control"
+										 label="${(x) => x.label}"
+										 helper-text="${(x) => x.helperText}"
+										 error-text="${(x) => x.errorValidationMessage}"
+										 placeholder="${(x) => x._textFieldPlaceholder}"
+										 current-value="${(x) => x._presentationValue}"
+										 ?disabled="${(x) => x.disabled}"
+										 ?readonly="${(x) => x.readOnly}"
+										 @input="${(x, c) => x._onTextFieldInput(c.event)}"
+										 @change="${(x) => x._onTextFieldChange()}"
+		>
+			<slot
+				slot="${(x) => x._helperTextSlottedContent?.length ? "helper-text" : void 0}"
+				name="helper-text"
+				${slotted("_helperTextSlottedContent")}
+			></slot>
+			<${buttonTag}
+				id="clock-button"
+				${ref("_clockButtonEl")}
+				slot="action-items"
+				size="condensed"
+				icon="clock-line"
+				appearance="ghost"
+				?disabled="${(x) => x.disabled || x.readOnly}"
+				aria-label="${(x) => x._clockButtonLabel}"
+				@click="${(x) => x._onClockButtonClick()}"
+			></${buttonTag}>
+		</${textFieldTag}>
+		<${popupTag}
+					?open="${(x) => x._popupOpen}"
+					:anchor="${(x) => x._textFieldEl}"
+					placement="bottom-start"
+					class="popup">
+			<div class="dialog" role="dialog" ${ref(
+    "_dialogEl"
+  )} aria-modal="true" aria-label="${(x) => x.locale.timePicker.chooseTimeLabel}">
+				<div class="time-pickers">
+					${renderPicker(
+    "hours",
+    (x) => x.locale.timePicker.hoursLabel,
+    (x) => x._selectedHour,
+    (x) => (v) => x._selectedHour = v,
+    (x) => x._hours
+  )}
+					${renderPicker(
+    "minutes",
+    (x) => x.locale.timePicker.minutesLabel,
+    (x) => x._selectedMinute,
+    (x) => (v) => x._selectedMinute = v,
+    (x) => x._minutes
+  )}
+					${when(
+    (x) => x._displaySeconds,
+    renderPicker(
+      "seconds",
+      (x) => x.locale.timePicker.secondsLabel,
+      (x) => x._selectedSecond,
+      (x) => (v) => x._selectedSecond = v,
+      (x) => x._seconds
+    )
+  )}
+					${when(
+    (x) => x._use12hClock,
+    renderPicker(
+      "meridies",
+      (x) => x.locale.timePicker.meridiesLabel,
+      (x) => x._selectedMeridiem,
+      (x) => (v) => x._selectedMeridiem = v,
+      (x) => x._meridies
+    )
+  )}
+				</div>
+				<div class="footer">
+					<${buttonTag}
+						class="vwc-button"
+						size="condensed"
+						label="${(x) => x.locale.timePicker.clearLabel}"
+						@click="${(x) => x._onClearClick()}"
+					></${buttonTag}>
+					<${buttonTag}
+						class="vwc-button"
+						size="condensed"
+						appearance="filled"
+						label="${(x) => x.locale.timePicker.okLabel}"
+						@click="${(x) => x._onOkClick()}"
+					></${buttonTag}>
+				</div>
+			</div>
+		</${popupTag}>
+	</div>`;
+};
 
-const toggletipDefinition = Toggletip.compose({
-  baseName: "toggletip",
-  template: ToggletipTemplate,
-  styles
+const timePickerDefinition = TimePicker.compose({
+  baseName: "time-picker",
+  template: TimePickerTemplate,
+  styles,
+  shadowOptions: {
+    delegatesFocus: true
+  }
 });
-const toggletipRegistries = [toggletipDefinition(), ...popupRegistries];
-const registerToggletip = registerFactory(toggletipRegistries);
+const timePickerRegistries = [
+  timePickerDefinition(),
+  ...textFieldRegistries,
+  ...popupRegistries,
+  ...buttonRegistries
+];
+const registerTimePicker = registerFactory(timePickerRegistries);
 
-export { toggletipRegistries as a, registerToggletip as r, toggletipDefinition as t };
+export { timePickerRegistries as a, registerTimePicker as r, timePickerDefinition as t };