@vonage/vivid 4.16.2 → 4.18.0

package/shared/time-selection-picker.template.js

@@ -0,0 +1,767 @@
+import { h as html, V as VividElement, o as observable, f as defineVividComponent, a as attr, O as Observable, i as defaultExecutionContext, D as DOM, n as nullableNumberConverter, v as volatile } from './vivid-element.js';
+import { T as TrappedFocus, a as PickerField } from './picker-field.template.js';
+import { S as SingleValuePicker } from './single-value-picker.js';
+import { e as errorText, f as formElements } from './form-elements.js';
+import { a as applyMixinsWithObservables } from './applyMixinsWithObservables.js';
+import { s as scrollIntoView } from './scrollIntoView.js';
+import { w as when } from './when.js';
+import { r as repeat } from './repeat.js';
+import { c as classNames } from './class-names.js';
+import { L as Localized } from './localized.js';
+import { r as ref } from './ref.js';
+
+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 compareTimeStr = (a, b) => a > b ? 1 : a < b ? -1 : 0;
+const hoursAs12hClock = (hour) => hour % 12 || 12;
+
+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;
+};
+
+const HoursColumn = {
+  id: "hours",
+  getLabel: (x) => x.locale.timePicker.hoursLabel,
+  getOptions: (x) => getHoursOptions(
+    x.min,
+    x.max,
+    x.clock === "12h" ? MeridiesColumn.getSelectedOptionValue(x) ?? MeridiesColumn.getOptions(x)[0].value : void 0
+  ),
+  getSelectedOptionValue: (x) => x.value ? parseTimeStr(x.value).hourStr : void 0,
+  updatedValue: (x, optionValue) => {
+    if (x.value) {
+      const { minuteStr, secondStr } = parseTimeStr(x.value);
+      return `${optionValue}:${minuteStr}:${secondStr}`;
+    } else {
+      return `${optionValue}:00:00`;
+    }
+  }
+};
+const MinutesColumn = {
+  id: "minutes",
+  getLabel: (x) => x.locale.timePicker.minutesLabel,
+  getOptions: (x) => getMinutesOptions(x.minutesStep, x.value, x.min, x.max),
+  getSelectedOptionValue: (x) => x.value ? parseTimeStr(x.value).minuteStr : void 0,
+  updatedValue: (x, optionValue) => {
+    if (x.value) {
+      const { hourStr, secondStr } = parseTimeStr(x.value);
+      return `${hourStr}:${optionValue}:${secondStr}`;
+    } else {
+      return `00:${optionValue}:00`;
+    }
+  }
+};
+const SecondsColumn = {
+  id: "seconds",
+  getLabel: (x) => x.locale.timePicker.secondsLabel,
+  getOptions: (x) => getSecondsOptions(x.secondsStep, x.value, x.min, x.max),
+  getSelectedOptionValue: (x) => x.value ? parseTimeStr(x.value).secondStr : void 0,
+  updatedValue: (x, optionValue) => {
+    if (x.value) {
+      const { hourStr, minuteStr } = parseTimeStr(x.value);
+      return `${hourStr}:${minuteStr}:${optionValue}`;
+    } else {
+      return `00:00:${optionValue}`;
+    }
+  }
+};
+const MeridiesColumn = {
+  id: "meridies",
+  getLabel: (x) => x.locale.timePicker.meridiesLabel,
+  getOptions: (x) => getMeridiesOptions(x.min, x.max),
+  getSelectedOptionValue: (x) => x.value ? parseTimeStr(x.value).meridiem : void 0,
+  updatedValue: (x, optionValue) => {
+    if (x.value) {
+      const { hours, minuteStr, secondStr } = parseTimeStr(x.value);
+      let adjustedHours = hours;
+      if (optionValue === "AM" && hours >= 12) {
+        adjustedHours -= 12;
+      } else if (optionValue === "PM" && hours < 12) {
+        adjustedHours += 12;
+      }
+      return `${formatTimePart(adjustedHours)}:${minuteStr}:${secondStr}`;
+    } else {
+      if (optionValue === "AM") {
+        return "00:00:00";
+      } else {
+        return "12:00:00";
+      }
+    }
+  }
+};
+
+const shouldDisplaySecondsPicker = (x) => x.secondsStep !== void 0;
+const shouldDisplay12hClock = (x) => x.clock === "12h";
+const onPickerOptionClick = (x, column, optionValue) => {
+  emitChange(x, column.updatedValue(x, optionValue));
+  scrollToOption(x, column.id, optionValue, "start");
+  const nextPickerEl = x.shadowRoot.querySelector(
+    `#${column.id} + .picker`
+  );
+  if (nextPickerEl) {
+    nextPickerEl.focus();
+  } else {
+    x.$emit("last-column-selected", void 0, {
+      bubbles: false
+    });
+  }
+};
+const onPickerKeyDown = (x, column, event) => {
+  const options = column.getOptions(x);
+  const selectedValue = column.getSelectedOptionValue(x);
+  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;
+    emitChange(x, column.updatedValue(x, newValue));
+    scrollToOption(x, column.id, newValue, "nearest");
+  }
+  return true;
+};
+const scrollToOption = (x, picker, optionValue, position) => {
+  const element = x.shadowRoot.querySelector(
+    `#${picker}-${optionValue}`
+  );
+  if (!element) {
+    return;
+  }
+  scrollIntoView(element, element.parentElement, position);
+};
+const onBaseKeyDown = (x, event) => {
+  if (event.key === "Tab") {
+    const focusableElements = x.shadowRoot.querySelectorAll(".picker");
+    const terminalElement = event.shiftKey ? focusableElements[0] : focusableElements[focusableElements.length - 1];
+    if (x.shadowRoot.activeElement !== terminalElement) {
+      TrappedFocus.ignoreEvent(event);
+    }
+  }
+  return true;
+};
+const emitChange = (x, time) => {
+  x.$emit("change", time, { bubbles: false, composed: false });
+};
+const renderPicker = (column) => {
+  return html`<ul
+		id="${column.id}"
+		class="picker"
+		role="listbox"
+		tabindex="0"
+		aria-label="${column.getLabel}"
+		aria-activedescendant="${(x) => column.getSelectedOptionValue(x) ? `${column.id}-${column.getSelectedOptionValue(x)}` : void 0}"
+		@keydown="${(x, c) => onPickerKeyDown(x, column, c.event)}"
+	>
+		${repeat(
+    (x) => column.getOptions(x),
+    html`<li
+				id="${(x) => `${column.id}-${x.value}`}"
+				class="${(x, c) => classNames("option", [
+      "selected",
+      column.getSelectedOptionValue(c.parent) === x.value
+    ])}"
+				aria-selected="${(x, c) => column.getSelectedOptionValue(c.parent) === x.value}"
+				role="option"
+				@click="${(x, c) => onPickerOptionClick(c.parent, column, x.value)}"
+			>
+				${(x) => x.label}
+			</li>`
+  )}
+	</ul>`;
+};
+const InlineTimePickerTemplate = () => {
+  return html`<div
+		class="time-pickers"
+		@keydown="${(x, { event }) => onBaseKeyDown(x, event)}"
+	>
+		${renderPicker(HoursColumn)} ${renderPicker(MinutesColumn)}
+		${when(shouldDisplaySecondsPicker, renderPicker(SecondsColumn))}
+		${when(shouldDisplay12hClock, renderPicker(MeridiesColumn))}
+	</div>`;
+};
+
+var __defProp$2 = Object.defineProperty;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$2(target, key, result);
+  return result;
+};
+class InlineTimePicker extends VividElement {
+  constructor() {
+    super(...arguments);
+    this.minutesStep = 1;
+    this.clock = "24h";
+  }
+  valueChanged(_, newValue) {
+    if (newValue !== void 0 && !isValidTimeStr(newValue)) {
+      this.value = void 0;
+    }
+  }
+  scrollSelectedOptionsToTop() {
+    if (HoursColumn.getSelectedOptionValue(this)) {
+      scrollToOption(
+        this,
+        "hours",
+        HoursColumn.getSelectedOptionValue(this),
+        "start"
+      );
+    }
+    if (MinutesColumn.getSelectedOptionValue(this)) {
+      scrollToOption(
+        this,
+        "minutes",
+        MinutesColumn.getSelectedOptionValue(this),
+        "start"
+      );
+    }
+    if (shouldDisplaySecondsPicker(this) && SecondsColumn.getSelectedOptionValue(this)) {
+      scrollToOption(
+        this,
+        "seconds",
+        SecondsColumn.getSelectedOptionValue(this),
+        "start"
+      );
+    }
+    if (shouldDisplay12hClock(this) && MeridiesColumn.getSelectedOptionValue(this)) {
+      scrollToOption(
+        this,
+        "meridies",
+        MeridiesColumn.getSelectedOptionValue(this),
+        "start"
+      );
+    }
+  }
+  focus(options) {
+    const firstFocusableElement = this.shadowRoot.querySelector(
+      ".picker"
+    );
+    firstFocusableElement.focus(options);
+  }
+}
+__decorateClass$2([
+  observable
+], InlineTimePicker.prototype, "value");
+__decorateClass$2([
+  observable
+], InlineTimePicker.prototype, "minutesStep");
+__decorateClass$2([
+  observable
+], InlineTimePicker.prototype, "secondsStep");
+__decorateClass$2([
+  observable
+], InlineTimePicker.prototype, "clock");
+__decorateClass$2([
+  observable
+], InlineTimePicker.prototype, "min");
+__decorateClass$2([
+  observable
+], InlineTimePicker.prototype, "max");
+applyMixinsWithObservables(InlineTimePicker, Localized);
+
+const styles = ":host{display:inline-block}.time-pickers{display:flex;overflow:hidden;justify-content:center;padding:4px;block-size:calc(28px * var(--_inline-time-picker-num-options-visible) + 4px * (var(--_inline-time-picker-num-options-visible) - 1));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}.time-pickers .picker:hover{overflow-y:auto}.time-pickers .picker:after{display:block;flex-shrink:0;block-size:calc(28px * (var(--_inline-time-picker-num-options-visible) - 1) + 4px * (var(--_inline-time-picker-num-options-visible) - 1 - 1));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 .option{--_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 .option{--_appearance-color-text: var(--_connotation-color-firm);--_appearance-color-fill: transparent;--_appearance-color-outline: transparent}.time-pickers .option: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 .option: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 .option: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 .option: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 .option: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}.time-pickers .option{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}";
+
+const inlineTimePickerDefinition = defineVividComponent(
+  "inline-time-picker",
+  InlineTimePicker,
+  InlineTimePickerTemplate,
+  [],
+  {
+    styles,
+    shadowOptions: {
+      delegatesFocus: true
+    }
+  }
+);
+
+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(":");
+};
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+const TimeSelectionPicker = (Base) => {
+  class TimeSelectionPickerElement extends Base {
+    constructor() {
+      super(...arguments);
+      this.minutesStep = null;
+      this.secondsStep = null;
+      // Reformat the presentation value when the clock changes
+      this.#clockChangeHandler = {
+        handleChange: () => {
+          if (this.value) {
+            this._presentationValue = this._toPresentationValue(this.value);
+          }
+        }
+      };
+    }
+    // --- Core ---
+    /**
+     * @internal
+     */
+    get _displaySeconds() {
+      return this.secondsStep !== null;
+    }
+    get _use12hClock() {
+      return this.clock ? this.clock === "12h" : this.locale.timePicker.defaultTo12HourClock;
+    }
+    /**
+     * @internal
+     */
+    get _timePlaceholder() {
+      let format = "hh:mm";
+      if (this._displaySeconds) {
+        format += ":ss";
+      }
+      if (this._use12hClock) {
+        format += " aa";
+      }
+      return format;
+    }
+    #clockChangeHandler;
+    #clockChangeObserver;
+    #startObservingClockChanges() {
+      this.#clockChangeObserver = Observable.binding(
+        () => this._use12hClock,
+        this.#clockChangeHandler
+      );
+      this.#clockChangeObserver.observe(this, defaultExecutionContext);
+    }
+    #stopObservingClockChanges() {
+      this.#clockChangeObserver.disconnect();
+    }
+    /**
+     * @internal
+     */
+    connectedCallback() {
+      super.connectedCallback();
+      this.#startObservingClockChanges();
+    }
+    /**
+     * @internal
+     */
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this.#stopObservingClockChanges();
+    }
+    // --- Picker button ---
+    /**
+     * @internal
+     */
+    _onPickerButtonClick() {
+      super._onPickerButtonClick();
+      if (this._popupOpen) {
+        DOM.processUpdates();
+        this._inlineTimePickerEl.scrollSelectedOptionsToTop();
+      }
+    }
+    // --- Inline time picker ---
+    /**
+     * @internal
+     */
+    _onInlineTimePickerChange(event) {
+      this._updateValueDueToUserInteraction(
+        this._withUpdatedTime(event.detail)
+      );
+    }
+    /**
+     * @internal
+     */
+    _onInlineTimePickerLastColumnSelected() {
+      this._closePopup();
+    }
+  }
+  __decorateClass$1([
+    attr({ attribute: "minutes-step", converter: nullableNumberConverter })
+  ], TimeSelectionPickerElement.prototype, "minutesStep", 2);
+  __decorateClass$1([
+    attr({ attribute: "seconds-step", converter: nullableNumberConverter })
+  ], TimeSelectionPickerElement.prototype, "secondsStep", 2);
+  __decorateClass$1([
+    attr
+  ], TimeSelectionPickerElement.prototype, "clock", 2);
+  __decorateClass$1([
+    volatile
+  ], TimeSelectionPickerElement.prototype, "_use12hClock", 1);
+  return TimeSelectionPickerElement;
+};
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+const ValidTimeFilter = {
+  fromView: (value) => {
+    if (value && isValidTimeStr(value)) {
+      return value;
+    }
+    return "";
+  },
+  toView(value) {
+    return value;
+  }
+};
+let TimePicker = class extends TimeSelectionPicker(
+  SingleValuePicker(PickerField)
+) {
+  // --- Core ---
+  constructor() {
+    super();
+    /**
+     * @internal
+     */
+    this._isValidValue = isValidTimeStr;
+    this.min = "";
+    this.max = "";
+    this.proxy.type = "time";
+    this.proxy.step = "1";
+  }
+  /**
+   * @internal
+   */
+  _toPresentationValue(value) {
+    return formatPresentationTime(
+      value,
+      this._displaySeconds,
+      this._use12hClock
+    );
+  }
+  /**
+   * @internal
+   */
+  _parsePresentationValue(presentationValue) {
+    return parsePresentationTime(presentationValue, this._use12hClock);
+  }
+  /**
+   * @internal
+   */
+  get _timeValue() {
+    return this.value;
+  }
+  /**
+   * @internal
+   */
+  _withUpdatedTime(timeStr) {
+    return timeStr;
+  }
+  /**
+   * @internal
+   */
+  get _resolvedMinTime() {
+    return this.min || null;
+  }
+  /**
+   * @internal
+   */
+  get _resolvedMaxTime() {
+    return this.max || null;
+  }
+  /**
+   * @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();
+    }
+  }
+  // --- Text field ---
+  /**
+   * @internal
+   */
+  get _textFieldPlaceholder() {
+    return this._timePlaceholder;
+  }
+  // --- Picker button ---
+  /**
+   * @internal
+   */
+  get _pickerButtonIcon() {
+    return "clock-line";
+  }
+  /**
+   * @internal
+   */
+  get _pickerButtonLabel() {
+    if (this.value) {
+      return this.locale.timePicker.changeTimeLabel(
+        this._toPresentationValue(this.value)
+      );
+    }
+    return this.locale.timePicker.chooseTimeLabel;
+  }
+  /**
+   * @internal
+   */
+  _onPickerButtonClick() {
+    super._onPickerButtonClick();
+    if (this._popupOpen) {
+      DOM.processUpdates();
+      this._focusableElsWithinDialog()[0].focus();
+    }
+  }
+  // --- Dialog ---
+  /**
+   * @internal
+   */
+  get _dialogLabel() {
+    return this.locale.timePicker.chooseTimeLabel;
+  }
+  /**
+   * @internal
+   */
+  _focusableElsWithinDialog() {
+    return this._dialogEl.querySelectorAll(
+      "#inline-time-picker, .vwc-button"
+    );
+  }
+  // --- Validation ---
+  /**
+   * @internal
+   */
+  _getCustomValidationError() {
+    if (this._isPresentationValueInvalid()) {
+      return this.locale.timePicker.invalidTimeError;
+    }
+    return null;
+  }
+};
+__decorateClass([
+  attr({ converter: ValidTimeFilter })
+], TimePicker.prototype, "min", 2);
+__decorateClass([
+  attr({ converter: ValidTimeFilter })
+], TimePicker.prototype, "max", 2);
+TimePicker = __decorateClass([
+  errorText,
+  formElements
+], TimePicker);
+
+const TimeSelectionPickerTemplate = (context, numOptionsVisible) => {
+  const inlineTimePickerTag = context.tagFor(InlineTimePicker);
+  return html`
+		<${inlineTimePickerTag}
+			id='inline-time-picker'
+			${ref("_inlineTimePickerEl")}
+			style="--_inline-time-picker-num-options-visible: ${() => numOptionsVisible}"
+			tabindex='1'
+			:value='${(x) => x._timeValue || void 0}'
+			:clock='${(x) => x._use12hClock ? "12h" : "24h"}'
+			:min='${(x) => x._resolvedMinTime || void 0}'
+			:max='${(x) => x._resolvedMaxTime || void 0}'
+			:minutesStep='${(x) => x.minutesStep ?? 1}'
+			:secondsStep='${(x) => x.secondsStep ?? void 0}'
+			@change='${(x, c) => x._onInlineTimePickerChange(c.event)}'
+			@last-column-selected='${(x) => x._onInlineTimePickerLastColumnSelected()}'
+		>
+		</${inlineTimePickerTag}>
+	`;
+};
+
+export { TimePicker as T, ValidTimeFilter as V, TimeSelectionPickerTemplate as a, isValidTimeStr as b, TimeSelectionPicker as c, compareTimeStr as d, formatPresentationTime as f, inlineTimePickerDefinition as i, parsePresentationTime as p };