@tylertech/forge 2.0.0 → 2.1.0

package/dist/esm/chunks/chunk.NQOD2XB3.js

@@ -0,0 +1,840 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import {
+  OPTION_GROUP_CONSTANTS
+} from "./chunk.P7NOYP4O.js";
+import {
+  OPTION_CONSTANTS
+} from "./chunk.Y2TDQIA4.js";
+import {
+  ListDropdownAware
+} from "./chunk.ST3R6JEE.js";
+import {
+  ListDropdown,
+  ListDropdownAwareFoundation
+} from "./chunk.D4XU5MZN.js";
+import {
+  POPUP_CONSTANTS
+} from "./chunk.5EEEKOOK.js";
+import {
+  BaseAdapter
+} from "./chunk.KZATVOA6.js";
+import {
+  FoundationProperty
+} from "./chunk.MMIZOYAS.js";
+import {
+  removeElement
+} from "./chunk.4JURZYE4.js";
+import {
+  coerceBoolean,
+  isDeepEqual,
+  isDefined,
+  isObject,
+  randomChars
+} from "./chunk.MEFT5FQC.js";
+import {
+  __decorateClass,
+  __spreadValues
+} from "./chunk.LM5TVNZY.js";
+
+// dist/build/lib/staging/src/select/core/base-select-constants.ts
+var observedAttributes = {
+  VALUE: "value",
+  MULTIPLE: "multiple",
+  OBSERVE_SCROLL: "observe-scroll",
+  OBSERVE_SCROLL_THRESHOLD: "observe-scroll-threshold",
+  POPUP_CLASSES: "popup-classes",
+  OPTION_LIMIT: "option-limit",
+  SYNC_POPUP_WIDTH: "sync-popup-width"
+};
+var attributes = __spreadValues({}, observedAttributes);
+var events = {
+  CHANGE: "change"
+};
+var BASE_SELECT_CONSTANTS = {
+  attributes,
+  events
+};
+
+// dist/build/lib/staging/src/select/core/select-utils.ts
+var SelectOptionType = /* @__PURE__ */ ((SelectOptionType2) => {
+  SelectOptionType2[SelectOptionType2["Option"] = 0] = "Option";
+  SelectOptionType2[SelectOptionType2["Group"] = 1] = "Group";
+  return SelectOptionType2;
+})(SelectOptionType || {});
+function isSelectOptionType(options, type) {
+  const isOptionGroups = options.some((o) => isOptionGroupObject(o));
+  const isOptionTypes = options.some((o) => isOptionObject(o));
+  return isOptionGroups && type === 1 /* Group */ || isOptionTypes && type === 0 /* Option */;
+}
+function isOptionGroupObject(o) {
+  return isDefined(o) && isObject(o) && o.hasOwnProperty("options") && o.hasOwnProperty("text");
+}
+function isOptionObject(o) {
+  return isDefined(o) && isObject(o) && o.hasOwnProperty("label") && o.hasOwnProperty("value");
+}
+
+// dist/build/lib/staging/src/select/core/base-select-foundation.ts
+var BaseSelectFoundation = class extends ListDropdownAwareFoundation {
+  constructor(_adapter) {
+    super();
+    this._adapter = _adapter;
+    this._options = [];
+    this._value = [];
+    this._multiple = false;
+    this._open = false;
+    this._selectedValues = [];
+    this._selectedLabels = [];
+    this._selectedIndexes = [];
+    this._filterString = "";
+    this._focusListener = (evt) => this._onFocus(evt);
+    this._blurListener = (evt) => this._onBlur(evt);
+    this._clickListener = (evt) => this._onClick(evt);
+    this._keydownListener = (evt) => this._onKeydown(evt);
+    this._optionsChangedListener = (options) => this._onOptionsChanged(options);
+    this._activeChangeListener = (id) => this._onActiveOptionChanged(id);
+    this._dropdownScrollEndListener = () => this._onDropdownScrollEnd();
+    this._dismissListener = () => this._onDismiss();
+    this._identifier = randomChars();
+  }
+  _onFocus(evt) {
+  }
+  initialize() {
+    this._optionListenerDestructor = this._adapter.setOptionsListener(this._optionsChangedListener);
+    this._initializeValue();
+  }
+  initializeTarget() {
+    this._adapter.initializeAccessibility();
+    this._adapter.setMultiple(this._multiple);
+    this._adapter.addClickListener(this._clickListener);
+    this._adapter.addTargetListener("blur", this._blurListener);
+    this._adapter.addTargetListener("focus", this._focusListener);
+    this._adapter.addTargetListener("keydown", this._keydownListener);
+  }
+  disconnect() {
+    this._adapter.removeClickListener(this._clickListener);
+    this._adapter.removeTargetListener("blur", this._blurListener);
+    this._adapter.removeTargetListener("focus", this._focusListener);
+    this._adapter.removeTargetListener("keydown", this._keydownListener);
+    if (this._open) {
+      this._closeDropdown();
+    }
+    if (this._optionListenerDestructor) {
+      this._optionListenerDestructor();
+    }
+  }
+  appendOptions(options) {
+    this._adapter.setOptions(options, false);
+    if (this._open) {
+      this._adapter.appendDropdownOptions(options);
+    }
+  }
+  selectAll() {
+    if (this._multiple) {
+      this.value = this._flatOptions.map((o) => o.value);
+    }
+  }
+  deselectAll() {
+    if (this._multiple) {
+      this.value = [];
+    }
+  }
+  get _flatOptions() {
+    if (isSelectOptionType(this._options, 1 /* Group */)) {
+      return [].concat.apply([], this._options.map((g) => g.options));
+    }
+    return this._options;
+  }
+  get _nonDividerOptions() {
+    return this._flatOptions.filter((o) => !o.divider);
+  }
+  _initializeValue() {
+    const options = this._options.length && this._options || this._adapter.getOptions();
+    if (isDefined(this._value) && options.length) {
+      this._applyValue(this._value);
+    }
+  }
+  _onClick(evt) {
+    if (evt.button !== 0) {
+      return;
+    }
+    if (!this._open) {
+      this._openDropdown();
+    } else {
+      this._closeDropdown();
+    }
+  }
+  _onBlur(evt) {
+    if (this._adapter.isFocusWithinPopup(evt.relatedTarget)) {
+      return;
+    }
+    if (this._open) {
+      this._closeDropdown();
+    }
+  }
+  _openDropdown() {
+    this._options = this._adapter.getOptions();
+    if (!this._flatOptions.length) {
+      return;
+    }
+    this._open = true;
+    const config = {
+      options: this._options,
+      multiple: this._multiple,
+      selectedValues: [...this._selectedValues],
+      id: this._identifier,
+      optionBuilder: this._optionBuilder,
+      syncWidth: this._syncPopupWidth,
+      observeScroll: this._observeScroll,
+      observeScrollThreshold: this._observeScrollThreshold,
+      scrollEndListener: this._dropdownScrollEndListener,
+      activeChangeCallback: this._activeChangeListener,
+      targetWidthCallback: this._targetWidthCallback,
+      popupClasses: this._popupClasses,
+      optionLimit: this._optionLimit,
+      headerBuilder: this._popupHeaderBuilder,
+      footerBuilder: this._popupFooterBuilder,
+      closeCallback: () => this._closeDropdown(),
+      selectCallback: (value) => {
+        const flatOptions = this._flatOptions;
+        const option = flatOptions.find((o) => o.value === value);
+        if (option) {
+          const index = flatOptions.indexOf(option);
+          this._onSelect(option, index, true);
+        }
+      }
+    };
+    this._adapter.open(config);
+    this._adapter.setDismissListener(this._dismissListener);
+  }
+  _closeDropdown() {
+    this._open = false;
+    this._adapter.close();
+  }
+  async _onSelect(option, optionIndex, closeDropdown = true) {
+    return new Promise(async (resolve) => {
+      if (this._valueChanging) {
+        return Promise.resolve(false);
+      }
+      const value = option ? option.value : "";
+      const label = option ? option.label : "";
+      const prevSelectedValues = [...this._selectedValues];
+      const prevSelectedLabels = [...this._selectedLabels];
+      const prevSelectedIndexes = [...this._selectedIndexes];
+      if (this._multiple) {
+        if (this._selectedValues.includes(value)) {
+          const index = this._selectedValues.indexOf(value);
+          this._selectedValues.splice(index, 1);
+          this._selectedLabels.splice(index, 1);
+          this._selectedIndexes.splice(index, 1);
+        } else {
+          this._selectedValues.push(value);
+          this._selectedLabels.push(label);
+          this._selectedIndexes.push(optionIndex);
+        }
+      } else {
+        if (isDefined(value)) {
+          this._selectedValues[0] = value;
+          this._selectedLabels[0] = label;
+          this._selectedIndexes[0] = optionIndex;
+        } else {
+          this._selectedValues = [];
+          this._selectedLabels = [];
+          this._selectedIndexes = [];
+        }
+      }
+      const rollbackValue = () => {
+        this._selectedValues = [...prevSelectedValues];
+        this._selectedLabels = [...prevSelectedLabels];
+        this._selectedIndexes = [...prevSelectedIndexes];
+      };
+      const applyValue = () => {
+        this._value = [...this._selectedValues];
+        if (this._multiple) {
+          const isSelected = this._selectedIndexes.includes(optionIndex);
+          this._adapter.toggleOptionMultiple(optionIndex, isSelected);
+        }
+        this._applySelection();
+      };
+      const data = this.multiple ? [...this._selectedValues] : this._selectedValues[0];
+      if (this._open && closeDropdown && !this._multiple) {
+        this._closeDropdown();
+      }
+      if (typeof this._beforeValueChange === "function") {
+        this._valueChanging = Promise.resolve(this._beforeValueChange.call(null, data));
+        const shouldContinue = await this._valueChanging;
+        this._valueChanging = void 0;
+        if (!shouldContinue) {
+          rollbackValue();
+          return resolve(false);
+        }
+      }
+      const cancelled = !this._adapter.emitHostEvent(BASE_SELECT_CONSTANTS.events.CHANGE, data, true, true);
+      if (!cancelled) {
+        applyValue();
+      } else {
+        rollbackValue();
+      }
+      resolve(!cancelled);
+    });
+  }
+  _selectActiveOption() {
+    const activeOptionIndex = this._adapter.getActiveOptionIndex();
+    if (activeOptionIndex >= 0 && this._nonDividerOptions[activeOptionIndex]) {
+      this._onSelect(this._nonDividerOptions[activeOptionIndex], activeOptionIndex);
+    }
+  }
+  _reset() {
+    this._selectedValues = [];
+    this._selectedLabels = [];
+    this._selectedIndexes = [];
+  }
+  _applyValue(value) {
+    this._selectedValues = [];
+    this._selectedLabels = [];
+    this._options = this._adapter.getOptions();
+    if (!Array.isArray(value)) {
+      value = [value];
+    }
+    this._value = [];
+    for (const val of value) {
+      if (!this._value.includes(val)) {
+        this._value.push(val);
+      }
+      const option = this._flatOptions.find((o) => isDeepEqual(o.value, val));
+      if (option) {
+        this._selectedValues.push(option.value);
+        this._selectedLabels.push(option.label);
+      }
+    }
+    this._selectedIndexes = this._selectedValues.map((val) => this._flatOptions.findIndex((o) => o.value === val));
+    this._adapter.patchSelectedValues(this._selectedValues);
+  }
+  _onDismiss() {
+    this._closeDropdown();
+  }
+  _getSelectedText() {
+    if (typeof this._selectedTextBuilder === "function") {
+      const selectedOptions = this._flatOptions.filter((o) => this._selectedValues.includes(o.value));
+      return this._selectedTextBuilder(selectedOptions);
+    }
+    if (this._multiple) {
+      if (this._selectedLabels.length) {
+        return `${this._selectedLabels.length} ${this._selectedLabels.length === 1 ? "option" : "options"} selected`;
+      } else {
+        return "";
+      }
+    }
+    return this._selectedLabels.filter((v) => v && v.length).join(" ").trim();
+  }
+  _onKeydown(evt) {
+    const isEscapeKey = evt.key === "Escape" || evt.keyCode === 27;
+    const isEnter = evt.key === "Enter" || evt.keyCode === 13;
+    const isSpace = evt.key === "Space" || evt.keyCode === 32;
+    const isArrowDown = evt.key === "ArrowDown" || evt.keyCode === 40;
+    const isArrowUp = evt.key === "ArrowUp" || evt.keyCode === 38;
+    const isFilterableCharacter = evt.keyCode >= 48 && evt.keyCode <= 90;
+    const isHomeKey = evt.key === "Home" || evt.keyCode === 36;
+    const isEndKey = evt.key === "End" || evt.keyCode === 35;
+    const isTabKey = evt.key === "Tab";
+    if (isTabKey && this._open && !this._multiple) {
+      this._selectActiveOption();
+      return;
+    }
+    if (!isFilterableCharacter && this._filterTimeout) {
+      window.clearTimeout(this._filterTimeout);
+      this._filterString = "";
+      this._filterTimeout = void 0;
+    }
+    if (isEscapeKey) {
+      evt.preventDefault();
+      if (this._open) {
+        this._closeDropdown();
+        return;
+      }
+    }
+    if (isSpace) {
+      evt.preventDefault();
+      if (!this._open) {
+        this._openDropdown();
+      } else {
+        this._closeDropdown();
+      }
+    } else if (isEnter) {
+      if (this._open) {
+        evt.stopPropagation();
+        evt.preventDefault();
+        this._options = this._adapter.getOptions();
+        this._selectActiveOption();
+      }
+    } else if (isArrowUp || isArrowDown) {
+      evt.preventDefault();
+      if (this._multiple && !this._open) {
+        this._openDropdown();
+        this._adapter.activateFirstOption();
+        return;
+      }
+      if (this._flatOptions.length === 0) {
+        return;
+      }
+      let optionIndex = 0;
+      if (this._open) {
+        optionIndex = this._adapter.getActiveOptionIndex();
+        if (optionIndex === -1) {
+          optionIndex = this._getFirstSelectedOptionIndex();
+        }
+      } else {
+        optionIndex = this._getFirstSelectedOptionIndex();
+      }
+      if (isArrowUp) {
+        optionIndex = this._getPreviousHighlightableOptionIndex(optionIndex, this._nonDividerOptions);
+      } else {
+        optionIndex = this._getNextHighlightableOptionIndex(optionIndex, this._nonDividerOptions);
+      }
+      if (this._open) {
+        this._adapter.highlightActiveOption(optionIndex);
+      } else {
+        this._onSelect(this._nonDividerOptions[optionIndex], optionIndex);
+      }
+    } else if (isHomeKey) {
+      if (this._open) {
+        evt.preventDefault();
+        this._adapter.highlightActiveOption(this._nonDividerOptions.findIndex((o) => !o.disabled));
+      }
+    } else if (isEndKey) {
+      if (this._open) {
+        evt.preventDefault();
+        const options = this._nonDividerOptions;
+        for (let i = options.length - 1; i >= 0; i--) {
+          if (!options[i].disabled) {
+            this._adapter.highlightActiveOption(i);
+            break;
+          }
+        }
+      }
+    } else if (isFilterableCharacter) {
+      this._filter(evt.key);
+    }
+  }
+  _getFirstSelectedOptionIndex() {
+    return this._nonDividerOptions.findIndex((option) => this._selectedValues.includes(option.value));
+  }
+  _getPreviousHighlightableOptionIndex(startIndex, options) {
+    let index = startIndex;
+    if (index <= 0) {
+      index = options.length - 1;
+    } else {
+      index--;
+    }
+    if (options[index].disabled) {
+      return this._getPreviousHighlightableOptionIndex(index, options);
+    }
+    return index;
+  }
+  _getNextHighlightableOptionIndex(startIndex, options) {
+    let index = startIndex;
+    if (index === options.length - 1) {
+      index = 0;
+    } else {
+      index++;
+    }
+    if (options[index].disabled) {
+      return this._getNextHighlightableOptionIndex(index, options);
+    }
+    return index;
+  }
+  _filter(key) {
+    if (this._filterTimeout) {
+      window.clearTimeout(this._filterTimeout);
+      this._filterTimeout = void 0;
+    }
+    this._filterString += key;
+    this._filterTimeout = window.setTimeout(() => {
+      this._filterString = "";
+      this._filterTimeout = void 0;
+    }, 300);
+    this._options = this._adapter.getOptions();
+    const matchedOption = this._flatOptions.find((option) => !option.disabled && option.label.toLowerCase().startsWith(this._filterString));
+    if (matchedOption) {
+      const optionIndex = this._flatOptions.indexOf(matchedOption);
+      if (this._open) {
+        this._adapter.highlightActiveOption(optionIndex);
+      } else if (!this._multiple) {
+        this._onSelect(matchedOption, optionIndex, false);
+      }
+    }
+  }
+  _onOptionsChanged(options) {
+    this._options = options;
+    this._applyValue(this._value);
+  }
+  _onActiveOptionChanged(id) {
+    this._adapter.updateActiveDescendant(id);
+  }
+  get value() {
+    return this._multiple ? [...this._selectedValues] : this._selectedValues[0];
+  }
+  set value(value) {
+    let _value;
+    if (Array.isArray(value)) {
+      _value = [...value];
+    } else {
+      _value = value;
+    }
+    this._applyValue(_value);
+  }
+  get selectedIndex() {
+    return this._multiple ? [...this._selectedIndexes] : this._selectedIndexes[0];
+  }
+  set selectedIndex(indexes) {
+    this._options = this._adapter.getOptions();
+    let indicies;
+    if (Array.isArray(indexes)) {
+      indicies = [...indexes];
+    } else {
+      indicies = [indexes];
+    }
+    indicies.sort();
+    if (this.multiple) {
+      this.value = indicies.map((index) => this._flatOptions[index]).filter((o) => o).map((o) => o.value);
+    } else {
+      const option = this._flatOptions[indicies[indicies.length - 1]];
+      if (!option) {
+        return;
+      }
+      this.value = option.value;
+    }
+  }
+  get options() {
+    return this._adapter.getOptions();
+  }
+  set options(value) {
+    let _value;
+    if (isSelectOptionType(value, 1 /* Group */)) {
+      _value = value.map((v) => __spreadValues({}, v));
+    } else {
+      _value = value.map((v) => __spreadValues({}, v));
+    }
+    this._options = _value;
+    this._adapter.setOptions(_value);
+    this._initializeValue();
+    if (this._open) {
+      this._adapter.setDropdownOptions(_value);
+    }
+  }
+  get multiple() {
+    return this._multiple;
+  }
+  set multiple(value) {
+    if (this._multiple !== value) {
+      this._multiple = value;
+      this._reset();
+      if (this._open) {
+        this._closeDropdown();
+      }
+      this._adapter.setMultiple(this._multiple);
+    }
+  }
+  get open() {
+    return this._open;
+  }
+  set open(value) {
+    if (this._open !== value) {
+      if (value) {
+        this._openDropdown();
+      } else {
+        this._closeDropdown();
+      }
+    }
+  }
+  get optionBuilder() {
+    return this._optionBuilder;
+  }
+  set optionBuilder(value) {
+    this._optionBuilder = value;
+  }
+  get selectedTextBuilder() {
+    return this._selectedTextBuilder;
+  }
+  set selectedTextBuilder(fn) {
+    this._selectedTextBuilder = fn;
+  }
+  get observeScroll() {
+    return this._observeScroll;
+  }
+  set observeScroll(value) {
+    this._observeScroll = value;
+  }
+  get observeScrollThreshold() {
+    return this._observeScrollThreshold;
+  }
+  set observeScrollThreshold(value) {
+    this._observeScrollThreshold = value;
+  }
+  get syncPopupWidth() {
+    return this._syncPopupWidth;
+  }
+  set syncPopupWidth(value) {
+    this._syncPopupWidth = value;
+  }
+  get optionLimit() {
+    return this._optionLimit;
+  }
+  set optionLimit(value) {
+    this._optionLimit = value;
+  }
+  get popupClasses() {
+    return this._popupClasses;
+  }
+  set popupClasses(value) {
+    this._popupClasses = value;
+  }
+  get popupHeaderBuilder() {
+    return this._popupHeaderBuilder;
+  }
+  set popupHeaderBuilder(value) {
+    this._popupHeaderBuilder = value;
+  }
+  get popupFooterBuilder() {
+    return this._popupFooterBuilder;
+  }
+  set popupFooterBuilder(value) {
+    this._popupFooterBuilder = value;
+  }
+  get popupElement() {
+    return this._adapter.popupElement;
+  }
+  get beforeValueChange() {
+    return this._beforeValueChange;
+  }
+  set beforeValueChange(value) {
+    this._beforeValueChange = value;
+  }
+};
+
+// dist/build/lib/staging/src/select/core/base-select.ts
+var BaseSelectComponent = class extends ListDropdownAware {
+  constructor() {
+    super();
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    super.attributeChangedCallback(name, oldValue, newValue);
+    switch (name) {
+      case BASE_SELECT_CONSTANTS.attributes.MULTIPLE:
+        this.multiple = coerceBoolean(newValue);
+        break;
+      case BASE_SELECT_CONSTANTS.attributes.VALUE:
+        this.value = newValue;
+        break;
+    }
+  }
+  appendOptions(options) {
+    this._foundation.appendOptions(options);
+  }
+  selectAll() {
+    this._foundation.selectAll();
+  }
+  deselectAll() {
+    this._foundation.deselectAll();
+  }
+  connectedCallback() {
+    this._foundation.initialize();
+  }
+  disconnectedCallback() {
+    this._foundation.disconnect();
+  }
+};
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "value", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "selectedIndex", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "options", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "multiple", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "open", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "optionBuilder", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "selectedTextBuilder", 2);
+__decorateClass([
+  FoundationProperty()
+], BaseSelectComponent.prototype, "beforeValueChange", 2);
+__decorateClass([
+  FoundationProperty({ set: false })
+], BaseSelectComponent.prototype, "popupElement", 2);
+
+// dist/build/lib/staging/src/select/core/base-select-adapter.ts
+var BaseSelectAdapter = class extends BaseAdapter {
+  constructor(component) {
+    super(component);
+  }
+  get popupElement() {
+    var _a;
+    return (_a = this._listDropdown) == null ? void 0 : _a.dropdownElement;
+  }
+  getOptions() {
+    const optionGroupElements = Array.from(this._component.querySelectorAll(OPTION_GROUP_CONSTANTS.elementName));
+    if (optionGroupElements.length) {
+      return optionGroupElements.map((optionGroupElement) => {
+        const optionElements = Array.from(optionGroupElement.querySelectorAll(OPTION_CONSTANTS.elementName));
+        const options = this._createOptionsFromElements(optionElements);
+        return { text: optionGroupElement.label, options };
+      });
+    } else {
+      const optionElements = Array.from(this._component.querySelectorAll(OPTION_CONSTANTS.elementName));
+      return this._createOptionsFromElements(optionElements);
+    }
+  }
+  _createOptionsFromElements(optionElements) {
+    return optionElements.map((o) => {
+      let optionClass = o.hasAttribute(OPTION_CONSTANTS.attributes.OPTION_CLASS) ? o.getAttribute(OPTION_CONSTANTS.attributes.OPTION_CLASS) : o.optionClass;
+      if (typeof optionClass === "string") {
+        optionClass = optionClass.split(" ");
+      }
+      return {
+        label: o.hasAttribute(OPTION_CONSTANTS.attributes.LABEL) ? o.getAttribute(OPTION_CONSTANTS.attributes.LABEL) : isDefined(o.label) ? o.label : o.innerText,
+        value: o.hasAttribute(OPTION_CONSTANTS.attributes.VALUE) ? o.getAttribute(OPTION_CONSTANTS.attributes.VALUE) : o.value,
+        disabled: o.hasAttribute(OPTION_CONSTANTS.attributes.DISABLED),
+        divider: o.hasAttribute(OPTION_CONSTANTS.attributes.DIVIDER),
+        optionClass,
+        leadingIcon: o.hasAttribute(OPTION_CONSTANTS.attributes.LEADING_ICON) ? o.getAttribute(OPTION_CONSTANTS.attributes.LEADING_ICON) : o.leadingIcon,
+        leadingIconClass: o.hasAttribute(OPTION_CONSTANTS.attributes.LEADING_ICON_CLASS) ? o.getAttribute(OPTION_CONSTANTS.attributes.LEADING_ICON_CLASS) : o.leadingIconClass,
+        leadingIconType: o.hasAttribute(OPTION_CONSTANTS.attributes.LEADING_ICON_TYPE) ? o.getAttribute(OPTION_CONSTANTS.attributes.LEADING_ICON_TYPE) : o.leadingIconType,
+        trailingIcon: o.hasAttribute(OPTION_CONSTANTS.attributes.TRAILING_ICON) ? o.getAttribute(OPTION_CONSTANTS.attributes.TRAILING_ICON) : o.trailingIcon,
+        trailingIconClass: o.hasAttribute(OPTION_CONSTANTS.attributes.TRAILING_ICON_CLASS) ? o.getAttribute(OPTION_CONSTANTS.attributes.TRAILING_ICON_CLASS) : o.trailingIconClass,
+        trailingIconType: o.hasAttribute(OPTION_CONSTANTS.attributes.TRAILING_ICON_TYPE) ? o.getAttribute(OPTION_CONSTANTS.attributes.TRAILING_ICON_TYPE) : o.trailingIconType,
+        leadingBuilder: o.leadingBuilder,
+        trailingBuilder: o.trailingBuilder
+      };
+    });
+  }
+  open(config) {
+    this._listDropdown = new ListDropdown(this._targetElement, config);
+    this._listDropdown.open();
+  }
+  close() {
+    if (this._listDropdown) {
+      this._listDropdown.close();
+      this._listDropdown.destroy();
+      this._listDropdown = void 0;
+    }
+  }
+  setDismissListener(listener) {
+    if (!this._listDropdown || !this._listDropdown.dropdownElement) {
+      return;
+    }
+    const dropdownElement = this._listDropdown.dropdownElement;
+    if (dropdownElement.targetElement) {
+      dropdownElement.targetElement.addEventListener(POPUP_CONSTANTS.events.BLUR, listener);
+    }
+  }
+  toggleOptionMultiple(index, isSelected) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.toggleOptionMultiple(index, isSelected);
+  }
+  getActiveOptionIndex() {
+    var _a, _b;
+    return (_b = (_a = this._listDropdown) == null ? void 0 : _a.getActiveOptionIndex()) != null ? _b : -1;
+  }
+  activateSelectedOption() {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.activateSelectedOption();
+  }
+  activateFirstOption() {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.activateFirstOption();
+  }
+  highlightActiveOption(index) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.activateOption(index);
+  }
+  patchSelectedValues(selectedValues) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.setSelectedValues(selectedValues);
+  }
+  setOptionsListener(listener) {
+    const observer = new MutationObserver(() => listener(this.getOptions()));
+    observer.observe(this._component, { childList: true, subtree: true });
+    return () => observer.disconnect();
+  }
+  setOptions(options, clear = true) {
+    if (clear) {
+      this._clearOptions();
+    }
+    for (const opt of options) {
+      if (isOptionGroupObject(opt)) {
+        const optionGroupElement = this._createOptionGroupElement(opt);
+        for (const option of opt.options) {
+          const optionElement = this._createOptionElement(option);
+          optionGroupElement.appendChild(optionElement);
+        }
+        this._component.appendChild(optionGroupElement);
+      } else {
+        const optionElement = this._createOptionElement(opt);
+        this._component.appendChild(optionElement);
+      }
+    }
+  }
+  appendDropdownOptions(options) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.appendOptions(options);
+  }
+  setDropdownOptions(options) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.setOptions(options);
+  }
+  scrollSelectedOptionIntoView() {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.scrollSelectedOptionIntoView();
+  }
+  isFocusWithinPopup(target) {
+    if (!this._listDropdown || !this._listDropdown.dropdownElement) {
+      return false;
+    }
+    return this._listDropdown.dropdownElement.contains(target);
+  }
+  _clearOptions() {
+    const existingOptionGroupElements = Array.from(this._component.querySelectorAll(OPTION_GROUP_CONSTANTS.elementName));
+    existingOptionGroupElements.forEach((optGroup) => removeElement(optGroup));
+    const existingOptionElements = Array.from(this._component.querySelectorAll(OPTION_CONSTANTS.elementName));
+    existingOptionElements.forEach((o) => removeElement(o));
+  }
+  _createOptionGroupElement(group) {
+    const optionGroupElement = document.createElement(OPTION_GROUP_CONSTANTS.elementName);
+    optionGroupElement.label = group.text || "";
+    return optionGroupElement;
+  }
+  _createOptionElement(option) {
+    const optionElement = document.createElement(OPTION_CONSTANTS.elementName);
+    optionElement.value = option.value;
+    optionElement.textContent = option.label;
+    if (option.disabled) {
+      optionElement.disabled = option.disabled;
+    }
+    return optionElement;
+  }
+};
+
+export {
+  BASE_SELECT_CONSTANTS,
+  SelectOptionType,
+  isSelectOptionType,
+  isOptionGroupObject,
+  isOptionObject,
+  BaseSelectFoundation,
+  BaseSelectComponent,
+  BaseSelectAdapter
+};
+//# sourceMappingURL=chunk.NQOD2XB3.js.map