@tylertech/forge 2.0.0 → 2.1.0

package/dist/esm/chunks/chunk.2FXYTBYG.js

@@ -0,0 +1,1450 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import {
+  DialogComponent
+} from "./chunk.KI3IHPS2.js";
+import {
+  TEXT_FIELD_CONSTANTS,
+  TextFieldComponentDelegate
+} from "./chunk.Q4YMHFRY.js";
+import {
+  ListDropdown
+} from "./chunk.D4XU5MZN.js";
+import {
+  ListComponent
+} from "./chunk.4UKSUUTX.js";
+import {
+  ListItemComponent
+} from "./chunk.G6FY472A.js";
+import {
+  PopupComponent
+} from "./chunk.5EEEKOOK.js";
+import {
+  ICON_BUTTON_CONSTANTS,
+  IconButtonComponent
+} from "./chunk.7Y4NHCJH.js";
+import {
+  tylIconClose
+} from "./chunk.GS2AXUCN.js";
+import {
+  Platform
+} from "./chunk.BYN27JXZ.js";
+import {
+  ICON_CONSTANTS,
+  IconComponent,
+  IconRegistry
+} from "./chunk.P43Z3YAS.js";
+import {
+  FormFieldComponentDelegate
+} from "./chunk.HZISALRH.js";
+import {
+  TimeInputMask
+} from "./chunk.WIYLQTSX.js";
+import {
+  TWELVE_HOUR_TIME_REGEX,
+  TWENTY_FOUR_HOUR_TIME_REGEX,
+  isSupportedTimeFormat,
+  tokenize12HourTimeString,
+  tokenize24HourTimeString,
+  tryCoerceTimeString
+} from "./chunk.52F6VUCF.js";
+import {
+  BaseAdapter
+} from "./chunk.KZATVOA6.js";
+import {
+  FoundationProperty
+} from "./chunk.MMIZOYAS.js";
+import {
+  COMPONENT_NAME_PREFIX,
+  CustomElement
+} from "./chunk.35U3UPDV.js";
+import {
+  BaseComponent
+} from "./chunk.VK6LIH3B.js";
+import {
+  attachShadowTemplate,
+  defineCustomElement,
+  emitEvent,
+  getShadowElement
+} from "./chunk.K2PCTUVN.js";
+import {
+  ensureChild,
+  getActiveElement,
+  toggleAttribute
+} from "./chunk.4JURZYE4.js";
+import {
+  coerceBoolean,
+  coerceNumber,
+  debounce,
+  randomChars
+} from "./chunk.MEFT5FQC.js";
+import {
+  __decorateClass,
+  __spreadValues
+} from "./chunk.LM5TVNZY.js";
+
+// node_modules/@tylertech/tyler-icons/extended/index.js
+var tylIconClockOutline = {
+  name: "clock_outline",
+  data: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 20a8 8 0 008-8 8 8 0 00-8-8 8 8 0 00-8 8 8 8 0 008 8m0-18a10 10 0 0110 10 10 10 0 01-10 10C6.47 22 2 17.5 2 12A10 10 0 0112 2m.5 5v5.25l4.5 2.67-.75 1.23L11 13V7h1.5z"/></svg>'
+};
+
+// dist/build/lib/staging/src/time-picker/time-picker-constants.ts
+var elementName = `${COMPONENT_NAME_PREFIX}time-picker`;
+var attributes = {
+  TOGGLE: "forge-time-picker-toggle",
+  VALUE: "value",
+  OPEN: "open",
+  ALLOW_SECONDS: "allow-seconds",
+  MASKED: "masked",
+  SHOW_MASK_FORMAT: "show-mask-format",
+  USE_24_HOUR_TIME: "use-24-hour-time",
+  ALLOW_INVALID_TIME: "allow-invalid-time",
+  MIN: "min",
+  MAX: "max",
+  START_TIME: "start-time",
+  STEP: "step",
+  ALLOW_INPUT: "allow-input",
+  SHOW_NOW: "show-now",
+  DISABLED: "disabled",
+  POPUP_CLASSES: "popup-classes",
+  ALLOW_DROPDOWN: "allow-dropdown"
+};
+var selectors = {
+  INPUT: "input, input[forge-time-picker-input]",
+  TOGGLE: `[${attributes.TOGGLE}]`
+};
+var events = {
+  OPEN: `${elementName}-open`,
+  CLOSE: `${elementName}-close`,
+  INPUT: `${elementName}-input`,
+  CHANGE: `${elementName}-change`
+};
+var numbers = {
+  DEFAULT_MINUTE_STEP: 60,
+  MAX_DAY_MILLIS: 864e5,
+  MAX_DAY_MINUTES: 1440
+};
+var TIME_PICKER_CONSTANTS = {
+  elementName,
+  attributes,
+  selectors,
+  events,
+  numbers
+};
+
+// dist/build/lib/staging/src/time-picker/time-picker-adapter.ts
+var TimePickerAdapter = class extends BaseAdapter {
+  constructor(component) {
+    super(component);
+  }
+  initialize() {
+    this._inputElement = this._component.querySelector(TIME_PICKER_CONSTANTS.selectors.INPUT);
+  }
+  initializeMask(options) {
+    if (this._inputMask) {
+      this._inputMask.destroy();
+    }
+    this._inputMask = new TimeInputMask(this._inputElement, options);
+  }
+  destroy() {
+    this._targetElement = void 0;
+    this._toggleElement = void 0;
+    this._inputElement = void 0;
+  }
+  destroyMask() {
+    if (this._inputMask) {
+      this._inputMask.destroy();
+      this._inputMask = void 0;
+    }
+  }
+  initializeAccessibility(identifier) {
+    this._inputElement.setAttribute("autocomplete", "off");
+    this._inputElement.setAttribute("autocorrect", "off");
+    this._inputElement.setAttribute("autocapitalize", "off");
+    this._inputElement.setAttribute("spellcheck", "false");
+    this._inputElement.setAttribute("role", "combobox");
+    this._inputElement.setAttribute("aria-live", "assertive");
+    this._inputElement.setAttribute("aria-atomic", "true");
+    this._inputElement.setAttribute("aria-haspopup", "true");
+    this._inputElement.setAttribute("aria-expanded", "false");
+  }
+  addInputListener(type, listener, capture) {
+    this._inputElement.addEventListener(type, listener, { capture });
+  }
+  removeInputListener(type, listener, capture) {
+    if (this._inputElement) {
+      this._inputElement.removeEventListener(type, listener, { capture });
+    }
+  }
+  addToggleListener(type, listener) {
+    if (this._toggleElement) {
+      this._toggleElement.addEventListener(type, listener);
+    }
+  }
+  removeToggleListener(type, listener) {
+    if (this._toggleElement) {
+      this._toggleElement.removeEventListener(type, listener);
+    }
+  }
+  hasInputElement() {
+    return !!this._inputElement;
+  }
+  tryCreateToggle() {
+    const textField = this._component.querySelector(TEXT_FIELD_CONSTANTS.elementName);
+    const toggleElement = this._component.querySelector(TIME_PICKER_CONSTANTS.selectors.TOGGLE);
+    if (textField) {
+      const existingIconButton = textField.querySelector(`${ICON_BUTTON_CONSTANTS.elementName}[slot=trailing]`);
+      if (existingIconButton || toggleElement) {
+        this._toggleElement = existingIconButton || toggleElement;
+        return;
+      }
+      const iconButtonElement = document.createElement(ICON_BUTTON_CONSTANTS.elementName);
+      iconButtonElement.slot = "trailing";
+      iconButtonElement.dense = true;
+      iconButtonElement.densityLevel = 3;
+      iconButtonElement.style.marginRight = "4px";
+      const buttonElement = document.createElement("button");
+      buttonElement.type = "button";
+      buttonElement.tabIndex = -1;
+      buttonElement.setAttribute("aria-label", "Toggle time dropdown");
+      const iconElement = document.createElement(ICON_CONSTANTS.elementName);
+      iconElement.name = "clock_outline";
+      buttonElement.appendChild(iconElement);
+      iconButtonElement.appendChild(buttonElement);
+      textField.appendChild(iconButtonElement);
+      this._toggleElement = iconButtonElement;
+    } else if (toggleElement) {
+      this._toggleElement = toggleElement;
+    }
+  }
+  tryFocusInput() {
+    this._inputElement.select();
+  }
+  tryBlurInput() {
+    this._inputElement.blur();
+  }
+  selectInputText() {
+    this._inputElement.select();
+  }
+  isInputDisabled() {
+    return this._inputElement.disabled;
+  }
+  isInputFocused() {
+    return getActiveElement() === this._inputElement;
+  }
+  setInputValue(value, emitEvents) {
+    if (this._inputElement.value === value) {
+      return;
+    }
+    this._inputElement.value = value;
+    if (this._inputMask) {
+      this._inputMask.update();
+    }
+    if (emitEvents) {
+      this._emitInputEvent("change");
+      this._emitInputEvent("input");
+    }
+  }
+  getInputValue() {
+    return this._inputMask ? this._inputMask.maskedValue : this._inputElement.value;
+  }
+  setDisabled(isDisabled) {
+    this._inputElement.disabled = isDisabled;
+    this._inputElement.setAttribute("aria-disabled", isDisabled.toString());
+    this.setToggleDisabled(isDisabled);
+  }
+  attachDropdown(config) {
+    this._listDropdown = new ListDropdown(this._inputElement, config);
+    this._listDropdown.open();
+    this._inputElement.setAttribute("aria-controls", `list-dropdown-popup-${config.id}`);
+  }
+  detachDropdown() {
+    if (this._listDropdown) {
+      this._listDropdown.close();
+      this._listDropdown.destroy();
+      this._listDropdown = void 0;
+    }
+    this._inputElement.removeAttribute("aria-controls");
+  }
+  propagateKey(key) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.handleKey(key);
+  }
+  setActiveDescendant(id) {
+    toggleAttribute(this._inputElement, !!id, "aria-activedescendant", id);
+  }
+  getTargetElementWidth(selector) {
+    const targetElement = this._getTargetElement(selector);
+    return targetElement.getBoundingClientRect().width;
+  }
+  _emitInputEvent(type) {
+    this._inputElement.dispatchEvent(new Event(type));
+  }
+  emitInputEvent(type, data) {
+    emitEvent(this._inputElement, type, data);
+  }
+  setInputReadonly(value) {
+    this._inputElement.readOnly = value;
+  }
+  setToggleDisabled(value) {
+    if (this._toggleElement) {
+      this._toggleElement.setAttribute("aria-disabled", value.toString());
+      if ("disabled" in this._toggleElement) {
+        this._toggleElement.disabled = value;
+      } else {
+        const button = this._toggleElement.querySelector("button");
+        if (button) {
+          button.disabled = value;
+        }
+      }
+    }
+  }
+  activateFirstOption() {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.activateFirstOption();
+  }
+  getActiveOption() {
+    var _a;
+    return (_a = this._listDropdown) == null ? void 0 : _a.getActiveOption();
+  }
+  _getTargetElement(selector) {
+    if (this._targetElement) {
+      return this._targetElement;
+    }
+    this._targetElement = selector ? this._component.querySelector(selector) || this._getDefaultTargetElement() : this._getDefaultTargetElement();
+    return this._targetElement;
+  }
+  _getDefaultTargetElement() {
+    const textField = this._component.querySelector(TEXT_FIELD_CONSTANTS.elementName);
+    if (textField && textField.shadowRoot) {
+      const textFieldRoot = getShadowElement(textField, TEXT_FIELD_CONSTANTS.selectors.ROOT);
+      if (textFieldRoot) {
+        return textFieldRoot;
+      }
+    }
+    return this._component;
+  }
+};
+
+// dist/build/lib/staging/src/time-picker/time-picker-utils.ts
+function timeStringToMillis(time, use24HourTime, allowSeconds) {
+  if (!time || /^\s*$/.test(time)) {
+    return null;
+  }
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  if (TWENTY_FOUR_HOUR_TIME_REGEX.test(time)) {
+    const tokens = tokenize24HourTimeString(time);
+    hours = +tokens.hours || 0;
+    minutes = +tokens.minutes || 0;
+    seconds = +tokens.seconds || 0;
+  } else if (TWELVE_HOUR_TIME_REGEX.test(time)) {
+    const tokens = tokenize12HourTimeString(time);
+    hours = +tokens.hours || 0;
+    minutes = +tokens.minutes || 0;
+    seconds = +tokens.seconds || 0;
+    if (hours === 12 && tokens.meridiem === "AM") {
+      hours = 0;
+    }
+    if (hours < 12 && tokens.meridiem === "PM") {
+      hours += 12;
+    }
+  } else {
+    return null;
+  }
+  return hoursToMillis(hours) + minutesToMillis(minutes) + (allowSeconds ? secondsToMillis(seconds) : 0);
+}
+function millisToTimeString(value, use24HourTime, allowSeconds) {
+  if (typeof value !== "number" || value < 0) {
+    return null;
+  }
+  let hours = Math.min(millisToHours(value), 23);
+  const minutes = Math.min(millisToMinutesClamped(value), 59);
+  const totalMinutes = value / (1e3 * 60);
+  const meridiem = totalMinutes < 720 ? "AM" : "PM";
+  if (!use24HourTime) {
+    hours = hours <= 12 ? hours : hours - 12;
+    if (hours === 0) {
+      hours = 12;
+    }
+  }
+  let time = `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+  if (allowSeconds) {
+    const seconds = Math.min(millisToSecondsClamped(value), 59);
+    time += `:${String(seconds).padStart(2, "0")}`;
+  }
+  if (!use24HourTime) {
+    time += ` ${meridiem}`;
+  }
+  return time;
+}
+function millisToHours(millis) {
+  return Math.abs(Math.floor(millis / (1e3 * 60 * 60)));
+}
+function millisToMinutesClamped(millis) {
+  return Math.abs(Math.floor(millisToMinutes(millis) % 60));
+}
+function millisToMinutes(millis) {
+  return millis / (1e3 * 60);
+}
+function millisToSecondsClamped(millis) {
+  return Math.abs(Math.floor(millisToSeconds(millis) % 60));
+}
+function millisToSeconds(millis) {
+  return millis / 1e3;
+}
+function hoursToMillis(hours) {
+  return hours * 60 * 60 * 1e3;
+}
+function minutesToMillis(minutes) {
+  return minutes * 60 * 1e3;
+}
+function secondsToMillis(seconds) {
+  return seconds * 1e3;
+}
+function stripSecondsFromMillis(millis) {
+  return millis - secondsToMillis(millisToSecondsClamped(millis));
+}
+function getCurrentTimeOfDayMillis(allowSeconds) {
+  const date = new Date();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  return hoursToMillis(hours) + minutesToMillis(minutes) + (allowSeconds ? secondsToMillis(date.getSeconds()) : 0);
+}
+function mergeDateWithTime(date, time, useSeconds = false) {
+  if (!date) {
+    date = new Date();
+  }
+  const millis = timeStringToMillis(time, true, useSeconds);
+  if (!millis) {
+    date.setHours(0, 0, 0);
+    return date;
+  }
+  let hours = millisToHours(millis);
+  const twentyThreeHoursInMillis = 828e5;
+  if (hours > twentyThreeHoursInMillis) {
+    hours = twentyThreeHoursInMillis;
+  } else if (hours < 0) {
+    hours = 0;
+  }
+  const minutes = millisToMinutesClamped(millis);
+  const seconds = useSeconds ? millisToSecondsClamped(millis) : 0;
+  date.setHours(hours, minutes, seconds);
+  return date;
+}
+
+// dist/build/lib/staging/src/time-picker/time-picker-foundation.ts
+var TimePickerFoundation = class {
+  constructor(_adapter) {
+    this._adapter = _adapter;
+    this._value = null;
+    this._masked = true;
+    this._use24HourTime = false;
+    this._showMaskFormat = false;
+    this._min = null;
+    this._max = null;
+    this._restrictedTimes = [];
+    this._startTime = null;
+    this._step = TIME_PICKER_CONSTANTS.numbers.DEFAULT_MINUTE_STEP;
+    this._allowInput = true;
+    this._open = false;
+    this._allowSeconds = false;
+    this._allowInvalidTime = false;
+    this._showNow = false;
+    this._customOptions = [];
+    this._disabled = false;
+    this._popupClasses = [];
+    this._allowDropdown = true;
+    this._isInitialized = false;
+    this._identifier = randomChars();
+    this._inputListener = (evt) => this._onInput(evt);
+    this._inputKeydownListener = (evt) => this._onInputKeydown(evt);
+    this._toggleMousedownListener = (evt) => this._onToggleMousedown(evt);
+    this._inputFocusListener = (evt) => this._onInputFocus(evt);
+    this._inputBlurListener = (evt) => this._onInputBlur(evt);
+    this._inputMousedownListener = (evt) => this._onInputMousedown(evt);
+  }
+  initialize() {
+    this._adapter.initialize();
+    if (!this._adapter.hasInputElement()) {
+      throw new Error("Unable to locate <input> element to attach to.");
+    }
+    this._adapter.initializeAccessibility(this._identifier);
+    if (!this._value) {
+      const inputValue = this._adapter.getInputValue();
+      this._setValue(this._convertTimeStringToMillis(inputValue, this._use24HourTime, this._allowSeconds));
+    }
+    this._adapter.addInputListener("focus", this._inputFocusListener);
+    this._adapter.addInputListener("blur", this._inputBlurListener);
+    this._adapter.addInputListener("keydown", this._inputKeydownListener, true);
+    this._formatInputValue(false);
+    if (typeof this._value === "number") {
+      this._applyValue(this._value, false);
+    }
+    this._applyAllowInput();
+    this._applyAllowDropdown();
+    this._applyDisabled();
+    this._applyMask();
+    this._isInitialized = true;
+  }
+  disconnect() {
+    this._isInitialized = false;
+    this._adapter.removeInputListener("input", this._inputListener);
+    this._adapter.removeInputListener("focus", this._inputFocusListener);
+    this._adapter.removeInputListener("blur", this._inputBlurListener);
+    this._adapter.removeToggleListener("mousedown", this._toggleMousedownListener);
+    this._adapter.removeInputListener("keydown", this._inputKeydownListener, true);
+    if (this._masked) {
+      this._adapter.destroyMask();
+    }
+    this._closeDropdown();
+    this._adapter.destroy();
+  }
+  _onInput(evt) {
+    this._handleInput(this._adapter.getInputValue());
+  }
+  _onInputKeydown(evt) {
+    if (evt.shiftKey) {
+      switch (evt.code) {
+        case "Backspace":
+        case "Delete":
+          evt.preventDefault();
+          const result = this._trySetValue(null);
+          if (result) {
+            this._formatInputValue();
+          }
+          return;
+      }
+    }
+    switch (evt.code) {
+      case "Tab":
+        if (this._open) {
+          this._selectActiveOption();
+        }
+        break;
+      case "Esc":
+      case "Escape":
+        if (this._open) {
+          evt.preventDefault();
+          this._closeDropdown(true);
+        }
+        break;
+      case "Down":
+      case "ArrowDown":
+        if (this._allowDropdown) {
+          evt.preventDefault();
+          if (!this._open) {
+            this._openDropdown();
+            this._adapter.activateFirstOption();
+          } else {
+            this._adapter.propagateKey(evt.code);
+          }
+        }
+        break;
+      case "Up":
+      case "ArrowUp":
+        if (this._allowDropdown) {
+          evt.preventDefault();
+          if (this._open) {
+            this._adapter.propagateKey(evt.code);
+          } else {
+          }
+        }
+        break;
+      case "Enter":
+      case "Home":
+      case "End":
+        if (this._open) {
+          if (evt.code === "Enter") {
+            evt.stopPropagation();
+          }
+          evt.preventDefault();
+          this._adapter.propagateKey(evt.code);
+        }
+        break;
+      case "KeyN":
+        evt.preventDefault();
+        const nowMillis = getCurrentTimeOfDayMillis(this._allowSeconds);
+        if (this._value !== nowMillis) {
+          const timeString = millisToTimeString(nowMillis, true, this._allowSeconds);
+          const canContinue = this._emitChangeEvent(timeString);
+          if (canContinue) {
+            this._applyValue(nowMillis);
+            this._selectInputText();
+          }
+        }
+        break;
+    }
+  }
+  _selectActiveOption() {
+    const activeOption = this._adapter.getActiveOption();
+    if (activeOption) {
+      this._onSelect(activeOption.value);
+    }
+  }
+  _onToggleMousedown(evt) {
+    if (this._disabled || !this.allowDropdown) {
+      return;
+    }
+    evt.stopPropagation();
+    if (this._adapter.isInputDisabled()) {
+      return;
+    }
+    evt.preventDefault();
+    if (this._open) {
+      this._closeDropdown(true);
+    } else {
+      if (!Platform.isMobile) {
+        this._adapter.tryFocusInput();
+      } else {
+        this._adapter.tryBlurInput();
+      }
+      this._openDropdown();
+    }
+  }
+  _onInputFocus(evt) {
+    if (this._allowInput) {
+      this._adapter.selectInputText();
+    }
+  }
+  _onInputBlur(evt) {
+    this._formatInputValue();
+    if (this._open && !this._adapter.isInputFocused()) {
+      this._closeDropdown(true);
+    }
+  }
+  _onInputMousedown(evt) {
+    if (!this._allowInput && !this._open) {
+      this._openDropdown();
+      this._adapter.tryFocusInput();
+      window.requestAnimationFrame(() => this._adapter.selectInputText());
+    }
+  }
+  _applyDisabled() {
+    this._adapter.setDisabled(this._disabled);
+  }
+  _applyMask() {
+    if (this._masked && this._allowInput) {
+      const options = {
+        showMaskFormat: this._showMaskFormat,
+        use24HourTime: this._use24HourTime,
+        showSeconds: this._allowSeconds,
+        prepareCallback: this._prepareMaskCallback,
+        onChange: debounce((value) => this._handleInput(value), 0, true)
+      };
+      this._adapter.initializeMask(options);
+    } else {
+      this._adapter.destroyMask();
+      this._formatInputValue();
+    }
+  }
+  _applyAllowInput() {
+    this._adapter.setInputReadonly(!this._allowInput);
+    if (this._allowInput) {
+      this._adapter.removeInputListener("mousedown", this._inputMousedownListener);
+      if (!this._masked) {
+        this._adapter.addInputListener("input", this._inputListener);
+      }
+    } else {
+      this._adapter.addInputListener("mousedown", this._inputMousedownListener);
+      this._adapter.removeInputListener("input", this._inputListener);
+    }
+  }
+  _applyAllowDropdown() {
+    this._adapter.setToggleDisabled(!this._allowDropdown);
+    if (this._allowDropdown) {
+      this._adapter.removeToggleListener("mousedown", this._toggleMousedownListener);
+      this._adapter.tryCreateToggle();
+      this._adapter.addToggleListener("mousedown", this._toggleMousedownListener);
+    } else if (this._open) {
+      this._closeDropdown(true);
+    }
+  }
+  _applyAllowSeconds() {
+    const originalValue = this._value;
+    if (!this._allowSeconds) {
+      if (typeof this._value !== "number") {
+        return;
+      }
+      this._setValue(stripSecondsFromMillis(this._value));
+      if (this._isInitialized && originalValue !== this._value) {
+        const timeString = millisToTimeString(this._value, true, false);
+        this._emitChangeEvent(timeString);
+      }
+    } else if (this._isInitialized && originalValue !== this._value) {
+      const timeString = millisToTimeString(this._value, true, true);
+      this._emitChangeEvent(timeString);
+    }
+  }
+  _handleInput(value) {
+    const rawValue = value;
+    if (!this._allowInput) {
+      return;
+    }
+    if (this._open) {
+      this._closeDropdown(true);
+    }
+    value = tryCoerceTimeString(value, this._use24HourTime, this._allowSeconds);
+    if (typeof this._coercionCallback === "function") {
+      value = this._coercionCallback.call(null, rawValue, value, this._allowSeconds);
+    }
+    if (!this._isValidTimeFormat(value)) {
+      value = "";
+    }
+    let millis;
+    if (!this._masked && typeof this._parseCallback === "function") {
+      millis = this._parseCallback.call(null, value);
+    } else {
+      millis = this._convertTimeStringToMillis(value, this._use24HourTime, this._allowSeconds);
+    }
+    millis = this._validateMillis(millis);
+    this._trySetValue(millis);
+  }
+  _emitChangeEvent(value, force = false) {
+    return this._adapter.emitHostEvent(TIME_PICKER_CONSTANTS.events.CHANGE, value, true, !force);
+  }
+  _trySetValue(millis) {
+    if (millis === this._value) {
+      return false;
+    }
+    const timeString = millisToTimeString(millis, true, this._allowSeconds);
+    if (this._masked) {
+      this._adapter.emitInputEvent(TIME_PICKER_CONSTANTS.events.INPUT, timeString);
+    }
+    if (this._value !== millis) {
+      const canContinue = this._emitChangeEvent(timeString);
+      if (canContinue) {
+        this._setValue(millis);
+        return true;
+      }
+    }
+    return false;
+  }
+  _setValue(value) {
+    this._value = this._normalizeTimeValue(value);
+  }
+  _validateMillis(millis) {
+    if (typeof millis === "number") {
+      const isBelowMin = typeof this._min === "number" && millis < this._min;
+      const isAboveMax = typeof this._max === "number" && millis > this._max;
+      if (isBelowMin || isAboveMax) {
+        millis = null;
+      }
+    }
+    if (typeof millis === "number" && this._restrictedTimes.length) {
+      if (this._restrictedTimes.includes(millis)) {
+        millis = null;
+      }
+    }
+    return millis;
+  }
+  _isValidTimeFormat(value) {
+    if (!this._masked && typeof this._validationCallback === "function") {
+      return this._validationCallback.call(this, value);
+    }
+    return isSupportedTimeFormat(value);
+  }
+  _isValidInputValue(value) {
+    return TWENTY_FOUR_HOUR_TIME_REGEX.test(value);
+  }
+  _onSelect(value) {
+    this._closeDropdown(true);
+    if (!value.isCustom && value.metadata === "now") {
+      value.time = getCurrentTimeOfDayMillis(this._allowSeconds);
+    }
+    if (value.isCustom) {
+      if (typeof value.customCallback === "function") {
+        const result = value.customCallback.call(null, value.metadata);
+        if (typeof result !== "number") {
+          throw new Error("Custom options must provide a time of day value in milliseconds.");
+        }
+        value.time = result;
+      } else {
+        throw new Error("You must implement a `toMilliseconds` callback that returns the time value to use for this custom option.");
+      }
+    }
+    if (this._value === value.time) {
+      return;
+    }
+    const timeString = millisToTimeString(value.time, true, this._allowSeconds);
+    const canContinue = this._emitChangeEvent(timeString);
+    if (!canContinue) {
+      return;
+    }
+    this._applyValue(value.time);
+    this._selectInputText();
+  }
+  _selectInputText() {
+    window.requestAnimationFrame(() => {
+      window.requestAnimationFrame(() => {
+        if (this._adapter.isInputFocused()) {
+          this._adapter.selectInputText();
+        }
+      });
+    });
+  }
+  _applyValue(value, emitEvents = true) {
+    this._setValue(value);
+    const formattedValue = this._formatValue(this._value);
+    if (this._adapter.getInputValue() !== formattedValue) {
+      this._adapter.setInputValue(formattedValue, emitEvents);
+    }
+  }
+  _normalizeTimeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    } else if (value < 0) {
+      return 0;
+    } else if (value > TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MILLIS) {
+      return TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MILLIS;
+    }
+    return value;
+  }
+  _openDropdown() {
+    if (!this.allowDropdown) {
+      return;
+    }
+    this._formatInputValue();
+    this._open = true;
+    this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.OPEN);
+    const options = this._generateTimeOptions();
+    const selectableOptions = options.filter((o) => !o.divider && !o.disabled);
+    let selectedValues = [];
+    let activeStartIndex;
+    if (this._value !== null) {
+      const optionIndex = this._findClosestOptionIndex(this._value, selectableOptions);
+      if (optionIndex >= 0) {
+        const isExactMatch = selectableOptions[optionIndex].value.time === this._value;
+        if (isExactMatch) {
+          selectedValues = [selectableOptions[optionIndex].value];
+        } else {
+          activeStartIndex = optionIndex;
+        }
+      }
+    } else if (typeof this._startTime === "number") {
+      const optionIndex = this._findClosestOptionIndex(this._startTime, selectableOptions);
+      if (optionIndex >= 0 && optionIndex < selectableOptions.length) {
+        activeStartIndex = optionIndex;
+      }
+    }
+    const config = {
+      id: `forge-time-picker-${this._identifier}`,
+      selectedValues,
+      syncWidth: true,
+      activeStartIndex,
+      popupClasses: this._popupClasses,
+      popupStatic: true,
+      type: "standard" /* Standard */,
+      options,
+      selectCallback: (value) => this._onSelect(value),
+      closeCallback: () => this._closeDropdown(true),
+      activeChangeCallback: (id) => this._adapter.setActiveDescendant(id),
+      targetWidthCallback: () => this._adapter.getTargetElementWidth(this._popupTarget)
+    };
+    this._adapter.attachDropdown(config);
+    this._adapter.emitHostEvent(TIME_PICKER_CONSTANTS.events.OPEN, void 0, false);
+  }
+  _closeDropdown(emitCloseEvent = false) {
+    this._open = false;
+    this._adapter.removeHostAttribute(TIME_PICKER_CONSTANTS.attributes.OPEN);
+    this._adapter.detachDropdown();
+    if (emitCloseEvent) {
+      this._adapter.emitHostEvent(TIME_PICKER_CONSTANTS.events.CLOSE, true, false);
+    }
+  }
+  _findClosestOptionIndex(value, options) {
+    const closestItem = options.reduce((prev, curr) => {
+      return Math.abs((curr.value.time || 0) - value) < Math.abs((prev.value.time || 0) - value) ? curr : prev;
+    });
+    return options.indexOf(closestItem);
+  }
+  _formatInputValue(emitEvents = true) {
+    const inputValue = this._adapter.getInputValue();
+    if (this._allowInvalidTime && !this._masked && inputValue && !this._value) {
+      return;
+    }
+    const formattedValue = this._formatValue(this._value);
+    if (inputValue !== formattedValue) {
+      this._adapter.setInputValue(formattedValue, emitEvents);
+    }
+  }
+  _generateTimeOptions() {
+    const minMinutes = this._min !== null ? Math.max(millisToMinutes(this._min), 0) : 0;
+    const maxMinutes = this._max !== null ? Math.min(millisToMinutes(this._max), TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MINUTES) : TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MINUTES;
+    const minuteStep = this._step;
+    const times = [];
+    let leadingOptions = [];
+    for (let totalMinutes = minMinutes; totalMinutes <= maxMinutes; totalMinutes += minuteStep) {
+      if (totalMinutes === TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MINUTES) {
+        break;
+      }
+      const millis = minutesToMillis(totalMinutes);
+      const disabled = this._restrictedTimes.includes(millis);
+      const label = millisToTimeString(millis, this._use24HourTime, false) || "";
+      const value = { time: millis };
+      times.push({ label, value, disabled });
+    }
+    const firstPmIndex = times.findIndex((t) => t.value.time / 1e3 / 60 >= 720);
+    if (firstPmIndex >= 0 && firstPmIndex < times.length - 1) {
+      times.splice(firstPmIndex, 0, { label: "", value: null, divider: true });
+    }
+    if (this._showNow) {
+      const value = { time: null, metadata: "now" };
+      leadingOptions.push({ label: "Now", value });
+    }
+    if (Array.isArray(this._customOptions) && this._customOptions.length) {
+      const options = this._customOptions.map((o) => {
+        const value = { time: null, metadata: o.value, isCustom: true, customCallback: o.toMilliseconds };
+        return { label: o.label, value };
+      });
+      leadingOptions = [...leadingOptions, ...options];
+    }
+    if (leadingOptions.length) {
+      times.splice(0, 0, { label: "", value: null, divider: true });
+      leadingOptions.forEach((o, index) => times.splice(index, 0, o));
+    }
+    return times;
+  }
+  _convertTimeStringToMillis(value, use24HourTime, allowSeconds) {
+    if (!value || !this._isValidTimeFormat(value)) {
+      value = "";
+    }
+    return timeStringToMillis(value, use24HourTime, allowSeconds);
+  }
+  _formatValue(value) {
+    if (!this._masked && typeof this._formatCallback === "function") {
+      return this._formatCallback.call(null, value, this._use24HourTime, this._allowSeconds);
+    }
+    return millisToTimeString(this._value, this._use24HourTime, this._allowSeconds) || "";
+  }
+  _warnInvalidFormat(value) {
+    console.warn(`The specified value "${value}" does not conform to the required format. The format is "HH:mm", "HH:mm:ss" where HH is 00-23, mm is 00-59, and ss is 00-59.`);
+  }
+  get open() {
+    return this._open;
+  }
+  set open(value) {
+    if (this._open !== value) {
+      if (this._isInitialized) {
+        this._open = value;
+        if (this._open) {
+          this._openDropdown();
+        } else {
+          this._closeDropdown();
+        }
+      }
+    }
+  }
+  get masked() {
+    return this._masked;
+  }
+  set masked(value) {
+    if (this._masked !== value) {
+      this._masked = value;
+      if (this._isInitialized) {
+        if (this._masked) {
+          this._adapter.removeInputListener("input", this._inputListener);
+          this._applyMask();
+        } else {
+          this._adapter.destroyMask();
+          this._formatInputValue();
+          this._adapter.addInputListener("input", this._inputListener);
+        }
+      }
+    }
+  }
+  get showMaskFormat() {
+    return this._showMaskFormat;
+  }
+  set showMaskFormat(value) {
+    if (this._showMaskFormat !== value) {
+      this._showMaskFormat = value;
+      if (this._isInitialized) {
+        this._applyMask();
+      }
+    }
+  }
+  get allowSeconds() {
+    return this._allowSeconds;
+  }
+  set allowSeconds(value) {
+    if (this._allowSeconds !== value) {
+      this._allowSeconds = !!value;
+      this._applyAllowSeconds();
+      if (this._isInitialized) {
+        this._applyMask();
+        this._formatInputValue();
+      }
+      this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.ALLOW_SECONDS, `${!!value}`);
+    }
+  }
+  get use24HourTime() {
+    return this._use24HourTime;
+  }
+  set use24HourTime(value) {
+    if (this._use24HourTime !== value) {
+      this._use24HourTime = !!value;
+      if (this._isInitialized) {
+        this._adapter.destroyMask();
+        this._formatInputValue();
+        this._applyMask();
+      }
+      this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.USE_24_HOUR_TIME, `${!!value}`);
+    }
+  }
+  get allowInvalidTime() {
+    return this._allowInvalidTime;
+  }
+  set allowInvalidTime(value) {
+    if (this._allowInvalidTime !== value) {
+      this._allowInvalidTime = !!value;
+      this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.ALLOW_INVALID_TIME, `${!!value}`);
+    }
+  }
+  get value() {
+    return millisToTimeString(this._value, true, this._allowSeconds);
+  }
+  set value(value) {
+    if (value && !this._isValidInputValue(value)) {
+      this._warnInvalidFormat(value);
+      return;
+    }
+    const millis = this._validateMillis(this._convertTimeStringToMillis(value, true, true));
+    this._setValue(millis);
+    if (this._isInitialized) {
+      this._applyValue(this._value);
+    }
+  }
+  get min() {
+    return millisToTimeString(this._min, true, this._allowSeconds);
+  }
+  set min(value) {
+    if (this._min !== value) {
+      if (value && !this._isValidInputValue(value)) {
+        this._warnInvalidFormat(value);
+        return;
+      }
+      this._min = this._convertTimeStringToMillis(value, true, this._allowSeconds);
+      const millis = this._validateMillis(this._value);
+      this._setValue(millis);
+      if (this._isInitialized) {
+        this._applyValue(millis);
+      }
+    }
+  }
+  get max() {
+    return millisToTimeString(this._max, true, this._allowSeconds);
+  }
+  set max(value) {
+    if (this._max !== value) {
+      if (value && !this._isValidInputValue(value)) {
+        this._warnInvalidFormat(value);
+        return;
+      }
+      this._max = this._convertTimeStringToMillis(value, true, this._allowSeconds);
+      const millis = this._validateMillis(this._value);
+      this._setValue(millis);
+      if (this._isInitialized) {
+        this._applyValue(millis);
+      }
+    }
+  }
+  get restrictedTimes() {
+    return this._restrictedTimes.map((t) => millisToTimeString(t, true, this._allowSeconds)).filter((v) => typeof v === "string");
+  }
+  set restrictedTimes(value) {
+    if (!Array.isArray(value)) {
+      value = [];
+    }
+    this._restrictedTimes = value.filter((v) => typeof v === "string").map((v) => this._convertTimeStringToMillis(v, true, true)).filter((v) => typeof v === "number");
+  }
+  get startTime() {
+    return millisToTimeString(this._startTime, true, this._allowSeconds);
+  }
+  set startTime(value) {
+    if (this._startTime !== value) {
+      if (value && !this._isValidInputValue(value)) {
+        this._warnInvalidFormat(value);
+        return;
+      }
+      this._startTime = this._convertTimeStringToMillis(value, true, this._allowSeconds);
+    }
+  }
+  get step() {
+    return this._step;
+  }
+  set step(value) {
+    this._step = value;
+  }
+  get allowInput() {
+    return this._allowInput;
+  }
+  set allowInput(value) {
+    if (this._allowInput !== value) {
+      this._allowInput = value;
+      if (this._isInitialized) {
+        this._applyAllowInput();
+        this._applyMask();
+      }
+    }
+  }
+  get popupTarget() {
+    return this._popupTarget;
+  }
+  set popupTarget(value) {
+    if (this._popupTarget !== value) {
+      this._popupTarget = value;
+    }
+  }
+  get showNow() {
+    return this._showNow;
+  }
+  set showNow(value) {
+    if (this._showNow !== value) {
+      this._showNow = value;
+    }
+  }
+  get customOptions() {
+    return this._customOptions;
+  }
+  set customOptions(value) {
+    this._customOptions = Array.isArray(value) ? value : [];
+  }
+  set validationCallback(cb) {
+    this._validationCallback = cb;
+    if (this._isInitialized) {
+      this._applyMask();
+    }
+  }
+  set parseCallback(cb) {
+    this._parseCallback = cb;
+  }
+  set formatCallback(cb) {
+    this._formatCallback = cb;
+  }
+  set coercionCallback(cb) {
+    this._coercionCallback = cb;
+  }
+  set prepareMaskCallback(cb) {
+    this._prepareMaskCallback = cb;
+    if (this._isInitialized) {
+      this._applyMask();
+    }
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  set disabled(value) {
+    if (this._disabled !== value) {
+      this._disabled = !!value;
+      if (this._isInitialized) {
+        this._applyDisabled();
+      }
+      this._adapter.toggleHostAttribute(TIME_PICKER_CONSTANTS.attributes.DISABLED, this._disabled);
+    }
+  }
+  get popupClasses() {
+    if (Array.isArray(this._popupClasses)) {
+      return [...this._popupClasses];
+    }
+    return this._popupClasses;
+  }
+  set popupClasses(value) {
+    if (Array.isArray(value)) {
+      this._popupClasses = [...value];
+    } else {
+      this._popupClasses = [value];
+    }
+  }
+  get allowDropdown() {
+    return this._allowDropdown;
+  }
+  set allowDropdown(value) {
+    if (this._allowDropdown !== value) {
+      this._allowDropdown = value;
+      if (this._isInitialized) {
+        this._applyAllowDropdown();
+      }
+    }
+  }
+};
+
+// dist/build/lib/staging/src/time-picker/time-picker.ts
+var template = "<template><slot></slot></template>";
+var styles = ":host{display:block}:host([hidden]){display:none}";
+var TimePickerComponent = class extends BaseComponent {
+  constructor() {
+    super();
+    IconRegistry.define([tylIconClockOutline, tylIconClose]);
+    attachShadowTemplate(this, template, styles);
+    this._foundation = new TimePickerFoundation(new TimePickerAdapter(this));
+  }
+  static get observedAttributes() {
+    return [
+      TIME_PICKER_CONSTANTS.attributes.VALUE,
+      TIME_PICKER_CONSTANTS.attributes.OPEN,
+      TIME_PICKER_CONSTANTS.attributes.ALLOW_SECONDS,
+      TIME_PICKER_CONSTANTS.attributes.MASKED,
+      TIME_PICKER_CONSTANTS.attributes.SHOW_MASK_FORMAT,
+      TIME_PICKER_CONSTANTS.attributes.USE_24_HOUR_TIME,
+      TIME_PICKER_CONSTANTS.attributes.ALLOW_INVALID_TIME,
+      TIME_PICKER_CONSTANTS.attributes.MIN,
+      TIME_PICKER_CONSTANTS.attributes.MAX,
+      TIME_PICKER_CONSTANTS.attributes.START_TIME,
+      TIME_PICKER_CONSTANTS.attributes.STEP,
+      TIME_PICKER_CONSTANTS.attributes.ALLOW_INPUT,
+      TIME_PICKER_CONSTANTS.attributes.SHOW_NOW,
+      TIME_PICKER_CONSTANTS.attributes.DISABLED,
+      TIME_PICKER_CONSTANTS.attributes.POPUP_CLASSES,
+      TIME_PICKER_CONSTANTS.attributes.ALLOW_DROPDOWN
+    ];
+  }
+  connectedCallback() {
+    if (this.querySelector(TIME_PICKER_CONSTANTS.selectors.INPUT)) {
+      this._foundation.initialize();
+    } else {
+      ensureChild(this, TIME_PICKER_CONSTANTS.selectors.INPUT).then(() => this._foundation.initialize());
+    }
+  }
+  disconnectedCallback() {
+    this._foundation.disconnect();
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    switch (name) {
+      case TIME_PICKER_CONSTANTS.attributes.VALUE:
+        this.value = newValue;
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.OPEN:
+        this.open = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.ALLOW_SECONDS:
+        this.allowSeconds = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.MASKED:
+        this.masked = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.SHOW_MASK_FORMAT:
+        this.showMaskFormat = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.USE_24_HOUR_TIME:
+        this.use24HourTime = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.ALLOW_INVALID_TIME:
+        this.allowInvalidTime = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.SHOW_NOW:
+        this.showNow = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.MIN:
+        this.min = newValue;
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.MAX:
+        this.max = newValue;
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.START_TIME:
+        this.startTime = newValue;
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.STEP:
+        this.step = coerceNumber(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.ALLOW_INPUT:
+        this.allowInput = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.DISABLED:
+        this.disabled = coerceBoolean(newValue);
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.POPUP_CLASSES:
+        this.popupClasses = newValue;
+        break;
+      case TIME_PICKER_CONSTANTS.attributes.ALLOW_DROPDOWN:
+        this.allowDropdown = coerceBoolean(newValue);
+        break;
+    }
+  }
+};
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "value", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "open", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "allowSeconds", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "masked", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "showMaskFormat", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "use24HourTime", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "allowInvalidTime", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "min", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "max", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "restrictedTimes", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "startTime", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "step", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "allowInput", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "showNow", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "customOptions", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "validationCallback", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "parseCallback", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "formatCallback", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "coercionCallback", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "prepareMaskCallback", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "disabled", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "popupClasses", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "allowDropdown", 2);
+__decorateClass([
+  FoundationProperty()
+], TimePickerComponent.prototype, "popupTarget", 2);
+TimePickerComponent = __decorateClass([
+  CustomElement({
+    name: TIME_PICKER_CONSTANTS.elementName,
+    dependencies: [
+      ListComponent,
+      ListItemComponent,
+      IconButtonComponent,
+      IconComponent,
+      PopupComponent,
+      IconComponent,
+      DialogComponent
+    ]
+  })
+], TimePickerComponent);
+
+// dist/build/lib/staging/src/time-picker/time-picker-component-delegate.ts
+var TimePickerComponentDelegate = class extends FormFieldComponentDelegate {
+  constructor(config) {
+    super(config);
+  }
+  _build() {
+    const timePicker = document.createElement(TIME_PICKER_CONSTANTS.elementName);
+    this._attachTextField(timePicker);
+    return timePicker;
+  }
+  get inputElement() {
+    return this._textFieldDelegate.inputElement;
+  }
+  get textFieldElement() {
+    return this._textFieldDelegate.element;
+  }
+  get value() {
+    return this._element.value;
+  }
+  set value(value) {
+    this._element.value = value;
+  }
+  get disabled() {
+    return this._element.disabled;
+  }
+  set disabled(value) {
+    this._element.disabled = value;
+  }
+  get invalid() {
+    return this._textFieldDelegate.invalid || false;
+  }
+  set invalid(value) {
+    this._textFieldDelegate.invalid = value;
+  }
+  onChange(listener) {
+    this._element.addEventListener(TIME_PICKER_CONSTANTS.events.CHANGE, (evt) => {
+      var _a;
+      return listener((_a = evt.detail) != null ? _a : "");
+    });
+  }
+  onInput(listener) {
+    if (this._element.masked) {
+      this._element.addEventListener(TIME_PICKER_CONSTANTS.events.INPUT, (evt) => {
+        var _a;
+        return listener((_a = evt.detail) != null ? _a : "");
+      });
+    } else {
+      this._textFieldDelegate.inputElement.addEventListener("input", (evt) => listener(evt.target.value));
+    }
+  }
+  onFocus(listener) {
+    this._textFieldDelegate.inputElement.addEventListener("focus", (evt) => listener(evt));
+  }
+  onBlur(listener) {
+    this._textFieldDelegate.inputElement.addEventListener("blur", (evt) => listener(evt));
+  }
+  _attachTextField(component) {
+    var _a, _b, _c, _d;
+    const textFieldConfig = {
+      props: __spreadValues({}, (_b = (_a = this._config.options) == null ? void 0 : _a.textFieldDelegateConfig) == null ? void 0 : _b.props),
+      options: __spreadValues({}, (_d = (_c = this._config.options) == null ? void 0 : _c.textFieldDelegateConfig) == null ? void 0 : _d.options)
+    };
+    this._textFieldDelegate = new TextFieldComponentDelegate(textFieldConfig);
+    component.appendChild(this._textFieldDelegate.element);
+  }
+};
+
+// dist/build/lib/staging/src/time-picker/index.ts
+function defineTimePickerComponent() {
+  defineCustomElement(TimePickerComponent);
+}
+
+export {
+  TIME_PICKER_CONSTANTS,
+  TimePickerAdapter,
+  timeStringToMillis,
+  millisToTimeString,
+  millisToHours,
+  millisToMinutesClamped,
+  millisToMinutes,
+  millisToSecondsClamped,
+  millisToSeconds,
+  hoursToMillis,
+  minutesToMillis,
+  secondsToMillis,
+  stripSecondsFromMillis,
+  getCurrentTimeOfDayMillis,
+  mergeDateWithTime,
+  TimePickerFoundation,
+  TimePickerComponent,
+  TimePickerComponentDelegate,
+  defineTimePickerComponent
+};
+//# sourceMappingURL=chunk.2FXYTBYG.js.map