@watermarkinsights/ripple 3.12.0 → 3.13.0-9

package/dist/collection/components/wm-select/wm-select.js

@@ -1,6 +1,6 @@
 import { h, Component, Element, Event, Listen, Prop, State, Watch, Host } from "@stencil/core";
 import { forceUpdate } from "@stencil/core";
-import { generateId, getTextDir, shouldOpenUp, intl } from "../../global/functions";
+import { generateId, getTextDir, shouldOpenUp, intl, debounce } from "../../global/functions";
 export class Select {
   constructor() {
     this.disabled = false;
@@ -9,11 +9,17 @@ export class Select {
     this.requiredField = false;
     this.errorMessage = "";
     this.multiple = false;
+    this.search = false;
     this.placeholder = intl.formatMessage({
       id: "select.multiPlaceholder",
       defaultMessage: "Make a selection",
       description: "Placeholder text. Use imperative",
     });
+    this.searchPlaceholder = intl.formatMessage({
+      id: "select.searchPlaceholder",
+      defaultMessage: "Search",
+      description: "Placeholder text. Use imperative",
+    });
     this.allSelectedMessage = intl.formatMessage({
       id: "select.allSelected",
       defaultMessage: "All selected",
@@ -25,21 +31,68 @@ export class Select {
     });
     this.isTabbing = false;
     this.isExpanded = false;
+    this.announcement = "";
     this.keysSoFar = "";
     this.searchIndex = 0;
     this.keyClear = null;
     this.openUp = false;
+    //////////////////////////////////////
+    //////////////////////////////////////
     // for multiselect button text
     this.overflowCount = 0;
-    this.displayedItems = [];
-    this.allSelected = false;
+    this.displayedOptions = [];
+    this.debouncedSearch = debounce(() => {
+      this.wmSelectSearchChanged.emit({ searchTerm: this.searchTerm });
+      if (this.filteredOptions.length) {
+        this.announce(this.resultsFoundMessage);
+      }
+      else {
+        this.announce(this.noResultsFoundMessage);
+      }
+    }, 150);
   }
-  get childItems() {
+  get childOptions() {
     return Array.from(this.el.querySelectorAll("wm-option"));
   }
-  get selectedItems() {
+  get duplicateOptions() {
+    return Array.from(this.el.shadowRoot.querySelectorAll("wm-option"));
+  }
+  get allOptionEls() {
+    // this includes both slotted wm-options and internally created wm-options
+    return this.duplicateOptions.concat(this.childOptions);
+  }
+  get visibleOptionEls() {
+    return this.allOptionEls.filter((option) => !option.classList.contains("hidden") && !option.classList.contains("filtered-out"));
+  }
+  //////////////////////////////////////
+  // for search variants
+  get searchTerm() {
+    return this.searchFieldEl ? this.searchFieldEl.value : "";
+  }
+  get filteredOptions() {
+    return this.childOptions.filter((option) => { var _a; return (_a = option.textContent) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(this.searchTerm); });
+  }
+  get selectedOptions() {
     return Array.from(this.el.querySelectorAll("wm-option")).filter((x) => x.selected);
   }
+  get allSelected() {
+    return this.childOptions.filter((option) => option.selected).length === this.childOptions.length;
+  }
+  //////////////////////////////////////
+  get resultsFoundMessage() {
+    return intl.formatMessage({
+      id: "select.searchResultsFound",
+      defaultMessage: "{numResults, plural, one {1 option found} other {# options found}}",
+      description: "The message read by the screen reader, indicating how many results a search returned",
+    }, { numResults: this.filteredOptions.length });
+  }
+  get noResultsFoundMessage() {
+    return intl.formatMessage({
+      id: "select.noSearchResults",
+      defaultMessage: "No results found. Please try your search again.",
+      description: "The message displayed when no options pass the search filter",
+    });
+  }
   toggleTabbingOn() {
     this.isTabbing = true;
   }
@@ -48,14 +101,11 @@ export class Select {
   }
   handleOptionSelection(ev) {
     if (!this.multiple) {
-      // ensure only one option is selected at a time
-      this.childItems
-        // remove selected on any other option
-        .filter((option) => option != ev.target && !!option.selected)
-        .map((option) => (option.selected = false));
-    }
-    this.focusItem(ev.target);
-    this.selectItem(ev.target);
+      // ensure only one option is selected at a time, unselect all other options
+      this.childOptions.forEach((option) => (option.selected = option === ev.detail));
+    }
+    this.focusOption(ev.detail);
+    this.selectOption(ev.detail);
     if (!this.multiple) {
       this.close();
     }
@@ -65,28 +115,24 @@ export class Select {
     this.close();
   }
   handleChildUp(ev) {
-    this.moveUp(ev.target);
+    this.moveUp(ev.detail);
   }
   handleChildDown(ev) {
-    this.moveDown(ev.target);
-  }
-  moveToFirstItem() {
-    this.focusItem(this.childItems[0]);
+    this.moveDown(ev.detail);
   }
-  moveToLastItem() {
-    this.focusItem(this.childItems[this.childItems.length - 1]);
+  moveToFirstOption() {
+    this.focusOption(this.visibleOptionEls[0]);
   }
-  handleTabKey() {
-    this.close(false);
+  moveToLastOption() {
+    this.focusOption(this.visibleOptionEls[this.visibleOptionEls.length - 1]);
   }
   closePopupOnEscape() {
     this.close();
   }
   handleOptionBlur(ev) {
-    const toElOrChild = ev.detail.relatedTarget === this.el || this.el.contains(ev.detail.relatedTarget);
     // if the Option is blurred to something other than the component emit a blur event with the appropriate relatedTarget
     // keeps our component's blur events accurate, and closes when focusing browser address bar
-    if (!toElOrChild) {
+    if (!this.isElOrChild(ev.detail.relatedTarget)) {
       const event = new CustomEvent("blur");
       // @ts-ignore
       event.relatedTarget = ev.detail.relatedTarget;
@@ -94,18 +140,23 @@ export class Select {
     }
   }
   handleClick(ev) {
-    const isElOrChild = ev.target === this.el || this.el.contains(ev.target);
-    if (!isElOrChild && this.isExpanded) {
+    if (!this.isElOrChild(ev.target)) {
       this.close();
     }
   }
   handleButtonBlur(ev) {
-    const toElOrChild = ev.relatedTarget === this.el || this.el.contains(ev.relatedTarget);
-    if (toElOrChild) {
+    if (this.isElOrChild(ev.relatedTarget)) {
       // do not emit a blur event when opening the dropdown and focusing the Options
       ev.stopPropagation();
     }
   }
+  handleSearchFieldBlur(ev) {
+    this.searchFieldWrapperEl.classList.remove("focus");
+    if (this.isElOrChild(ev.relatedTarget)) {
+      // do not emit a blur event when moving from searchfield to options
+      ev.stopPropagation();
+    }
+  }
   handleKey(ev) {
     switch (ev.key) {
       case "ArrowDown":
@@ -135,137 +186,236 @@ export class Select {
     if (document.body.classList.contains("wmcl-user-is-tabbing")) {
       this.toggleTabbingOn();
     }
+    // set initial selections
+    if (this.selectedOptions.length > 0) {
+      this.selectedOptions.forEach((x) => {
+        this.displayedOptions.push(x);
+      });
+      // single Select only, pre-select if no default option from dev
+    }
+    else if (!this.multiple) {
+      this.selectOption(this.allOptionEls[0]);
+    }
   }
   componentDidLoad() {
     this.wmSelectDidLoad.emit();
-    if (!this.childItems.length) {
-      throw new Error("wm-select should have wm-option elements as children.");
-    }
-    if (this.multiple && this.childItems.filter((x) => x.subinfo).length > 0) {
+    if (this.multiple && this.allOptionEls.filter((x) => x.subinfo).length > 0) {
       throw new Error("wm-select with the multiple prop cannot have subinfo options");
     }
     if (this.multiple && !this.placeholder) {
       throw new Error("wm-select with the multiple prop needs to also use the placeholder prop.");
     }
-    // set initial selections / button text
-    if (this.selectedItems.length > 0) {
-      this.selectedItems.forEach((x) => this.displayedItems.push(x));
-      this.setButtonText();
-      // single Select only, pre-select if no default option from dev
-    }
-    else if (!this.multiple) {
-      this.selectItem(this.childItems[0]);
-    }
-    this.optionsEl.classList.add("hidden");
+    this.dropdownEl.classList.add("hidden");
     forceUpdate(this.el);
     // Dev can overwrite the max-height rule set in the Sass file
     if (this.maxHeight) {
-      this.optionsEl.style.maxHeight = this.maxHeight;
+      this.dropdownEl.style.maxHeight = this.maxHeight;
+    }
+    const mutationObserver = new MutationObserver(() => this.handleSelectedMutation());
+    mutationObserver.observe(this.el, {
+      attributes: true,
+      attributeFilter: ["selected"],
+      subtree: true,
+    });
+    if (this.multiple) {
+      this.updateOptionVisibility();
+    }
+    this.setButtonText();
+  }
+  componentWillUpdate() {
+    if (this.multiple) {
+      // find last visible duplicate option and apply .last class
+      const visibleDuplicateOptions = this.visibleOptionEls.filter((option) => option.classList.contains("duplicate"));
+      visibleDuplicateOptions.forEach((option, idx) => {
+        if (idx === visibleDuplicateOptions.length - 1) {
+          option.classList.add("last");
+        }
+        else {
+          option.classList.remove("last");
+        }
+      });
     }
   }
+  handleSelectedMutation() {
+    // dispatch change event after selected options change
+    // mutation observer prevents emitting event when an already selected option is selected again
+    const event = new CustomEvent("change");
+    // @ts-ignore
+    this.el.dispatchEvent(event);
+  }
   moveUp(el) {
-    const prevEl = el.previousElementSibling;
+    const prevEl = this.visibleOptionEls[this.visibleOptionEls.indexOf(el) - 1];
     if (prevEl) {
       // scroll option to top of dropdown if partially obscured / out of view
-      if (prevEl.getBoundingClientRect().top < this.optionsEl.getBoundingClientRect().top) {
-        this.optionsEl.scrollTop =
-          prevEl.getBoundingClientRect().top - this.optionsEl.getBoundingClientRect().top + this.optionsEl.scrollTop;
+      if (prevEl.getBoundingClientRect().top < this.dropdownEl.getBoundingClientRect().top) {
+        this.scrollOptionToTop(prevEl);
       }
-      this.focusItem(prevEl);
+      this.focusOption(prevEl);
+    }
+    else if (this.search) {
+      // if top of list and search variant, focus search field
+      this.searchFieldEl.focus();
     }
     else {
-      this.focusItem(this.childItems[this.childItems.length - 1]);
+      // if top of list, focus last element
+      this.focusOption(this.visibleOptionEls[this.visibleOptionEls.length - 1]);
     }
   }
   moveDown(el) {
-    const nextEl = el.nextElementSibling;
-    if (nextEl && nextEl.tagName !== "INPUT") {
+    const nextEl = this.visibleOptionEls[this.visibleOptionEls.indexOf(el) + 1];
+    if (nextEl) {
       // scroll option to bottom of dropdown if partially obscured / out of view
-      if (nextEl.getBoundingClientRect().bottom > this.optionsEl.getBoundingClientRect().bottom) {
-        this.optionsEl.scrollTop =
-          nextEl.getBoundingClientRect().bottom -
-            this.optionsEl.getBoundingClientRect().top +
-            this.optionsEl.scrollTop -
-            this.optionsEl.offsetHeight;
+      if (nextEl.getBoundingClientRect().bottom > this.dropdownEl.getBoundingClientRect().bottom) {
+        this.scrollOptionToBottom(nextEl);
       }
-      this.focusItem(nextEl);
+      this.focusOption(nextEl);
     }
     else {
-      this.focusItem(this.childItems[0]);
+      // if end of list, focus first option in all variants
+      this.focusOption(this.visibleOptionEls[0]);
     }
   }
-  open(itemToSelect) {
+  scrollOptionToTop(option) {
+    this.dropdownEl.scrollTop =
+      option.getBoundingClientRect().top - this.dropdownEl.getBoundingClientRect().top + this.dropdownEl.scrollTop;
+  }
+  scrollOptionToBottom(option) {
+    this.dropdownEl.scrollTop =
+      option.getBoundingClientRect().bottom -
+        this.dropdownEl.getBoundingClientRect().top +
+        this.dropdownEl.scrollTop -
+        this.dropdownEl.offsetHeight;
+  }
+  open(optionToSelect) {
     if (!this.disabled) {
       const elHeight = this.el.clientHeight;
       const buttonHeight = this.buttonEl.clientHeight;
-      this.openUp = shouldOpenUp(this.el, this.optionsEl, 
+      this.openUp = shouldOpenUp(this.el, this.dropdownEl, 
       // when opening up, dropdown covers both label and button
       elHeight, 
       // when opening down, dropdown covers only the button
       buttonHeight);
       this.isExpanded = true;
-      this.optionsEl.classList.remove("hidden");
+      this.dropdownEl.classList.remove("hidden");
       window.requestAnimationFrame(() => {
-        if (this.selectedItems.length > 0) {
-          if (itemToSelect === "next") {
-            this.moveDown(this.selectedItems[this.selectedItems.length - 1]);
-          }
-          else if (itemToSelect === "previous") {
-            this.moveUp(this.selectedItems[0]);
-          }
-          else {
-            this.focusItem(this.selectedItems[0]);
-          }
-        }
-        else {
-          this.focusItem(this.childItems[0]);
+        switch (optionToSelect) {
+          case "next":
+            // search variant focuses search field
+            // all others focus option "after" last selected option  (this can be the first option)
+            if (this.search) {
+              this.searchFieldEl.focus();
+              this.dropdownEl.scrollTop = 0;
+            }
+            else {
+              this.moveDown(this.visibleOptionEls.filter((x) => x.selected).slice(-1)[0]);
+            }
+            break;
+          case "previous":
+            // search variant focuses last option
+            // all others focus option "above" first selected option (this can be the last option)
+            if (this.search) {
+              this.focusOption(this.visibleOptionEls[this.visibleOptionEls.length - 1]);
+            }
+            else {
+              this.moveUp(this.visibleOptionEls.filter((x) => x.selected)[0]);
+            }
+            break;
+          default:
+            // search variant focuses search field
+            // all others focus the selected option
+            // if no option is selected (empty multiselect), focuses first option
+            if (this.search) {
+              this.searchFieldEl.focus();
+              this.dropdownEl.scrollTop = 0;
+            }
+            else if (this.selectedOptions.length > 0) {
+              this.focusOption(this.visibleOptionEls.filter((x) => x.selected)[0]);
+            }
+            else {
+              this.focusOption(this.visibleOptionEls[0]);
+            }
+            break;
         }
       });
     }
   }
   close(returnFocus = true) {
-    this.isExpanded = false;
-    this.childItems.map((i) => (i.focused = false));
-    window.setTimeout(() => {
-      this.optionsEl.classList.add("hidden");
-      // Returns focus to button after popup closes (no need if user is tabbing)
-      // Delay is necessary for screenreader to get new expanded state before focus
-      // window.requestAnimationFrame is probably enough, but since we are already using setTimeout it may as well be here
-      // also UX wise, it makes sense for the button to only be focused after the animation is complete
-      if (returnFocus) {
-        this.el.focus();
+    if (this.isExpanded) {
+      this.isExpanded = false;
+      this.allOptionEls.map((i) => (i.focused = false));
+      window.setTimeout(() => {
+        this.dropdownEl.classList.add("hidden");
+        if (this.multiple) {
+          this.updateOptionVisibility();
+        }
+        // clear search field, reset filtered / bolded state of wm-options
+        if (this.search) {
+          this.searchFieldEl.value = "";
+          this.wmSelectSearchChanged.emit({ searchTerm: this.searchTerm });
+        }
+        // Returns focus to button after popup closes (no need if user is tabbing)
+        // Delay is necessary for screenreader to get new expanded state before focus
+        // window.requestAnimationFrame is probably enough, but since we are already using setTimeout it may as well be here
+        // also UX wise, it makes sense for the button to only be focused after the animation is complete
+        if (returnFocus) {
+          this.el.focus();
+        }
+      }, 150);
+    }
+  }
+  updateOptionVisibility() {
+    // this runs for search multiselects, where selected options are rendered at the top of the dropdown list
+    // slotted wm-options are hidden if selected, and duplicate wm-options are made visible if selected
+    this.childOptions.forEach((option, idx) => {
+      const duplicateOption = this.duplicateOptions[idx];
+      if (option.selected) {
+        option.classList.add("hidden");
+        duplicateOption.classList.remove("hidden");
       }
-    }, 150);
+      else {
+        option.classList.remove("hidden");
+        duplicateOption.classList.add("hidden");
+      }
+    });
   }
-  focusItem(item) {
-    this.childItems.forEach((i) => (i.focused = i === item));
+  focusOption(option) {
+    this.allOptionEls.forEach((i) => (i.focused = i === option));
+    option.focus();
   }
-  selectItem(item) {
-    if (this.multiple) {
-      item.selected = !item.selected;
+  selectOption(option) {
+    // this function does not necessarily change an options selected property to true
+    // in cases of multiselect, it toggles the selected property
+    if (option.classList.contains("duplicate")) {
+      // if clicking on a duplicate option, toggle selected property of real one, then rerender
+      const correspondingOption = this.findCorrespondingOption(option);
+      correspondingOption.selected = !correspondingOption.selected;
+      forceUpdate(this.el);
+    }
+    else if (this.multiple) {
+      option.selected = !option.selected;
     }
     else {
-      this.childItems.forEach((i) => (i.selected = i === item));
+      this.allOptionEls.forEach((x) => (x.selected = x === option));
     }
     this.setButtonText();
   }
-  findAndFocusItem(ev) {
+  findAndFocusOption(ev) {
     const character = ev.detail.toUpperCase();
     if (!this.keysSoFar) {
-      for (var i = 0; i < this.childItems.length; i++) {
-        if (this.childItems[i].focused) {
+      for (var i = 0; i < this.allOptionEls.length; i++) {
+        if (this.allOptionEls[i].focused) {
           this.searchIndex = i;
         }
       }
     }
     this.keysSoFar += character;
     this.clearKeysSoFarAfterDelay();
-    var nextMatch = this.findMatchInRange(this.childItems, this.searchIndex + 1, this.childItems.length);
+    var nextMatch = this.findMatchInRange(this.allOptionEls, this.searchIndex + 1, this.allOptionEls.length);
     if (!nextMatch) {
-      nextMatch = this.findMatchInRange(this.childItems, 0, this.searchIndex);
+      nextMatch = this.findMatchInRange(this.allOptionEls, 0, this.searchIndex);
     }
     if (nextMatch) {
-      this.focusItem(nextMatch);
+      this.focusOption(nextMatch);
     }
   }
   clearKeysSoFarAfterDelay() {
@@ -279,8 +429,8 @@ export class Select {
     }.bind(this), 500);
   }
   findMatchInRange(list, startIndex, endIndex) {
-    // Find the first item starting with the keysSoFar substring, searching in
-    // the specified range of items
+    // Find the first option starting with the keysSoFar substring, searching in
+    // the specified range of options
     for (var n = startIndex; n < endIndex; n++) {
       var label = list[n].textContent;
       if (label && label.toUpperCase().indexOf(this.keysSoFar) === 0) {
@@ -289,6 +439,19 @@ export class Select {
     }
     return null;
   }
+  findCorrespondingOption(el) {
+    // if duplicate, returns the child wm-option
+    // if child wm-option, returns duplicate
+    const isDuplicate = el.classList.contains("duplicate");
+    return isDuplicate
+      ? this.childOptions[this.duplicateOptions.indexOf(el)]
+      : this.duplicateOptions[this.childOptions.indexOf(el)];
+  }
+  isElOrChild(el) {
+    var _a;
+    // determines whether or not the element is the component, a child of the component, or exists within the component's shadowroot
+    return el === this.el || this.el.contains(el) || ((_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.contains(el));
+  }
   exposeErrors() {
     // When the error changes, a new id is set for the error container and the button's aria-describedby attribute is updated accordingly. This is to make sure the screen reader announces teh updated errors in Firefox. See this longstanding bug: https://bugzilla.mozilla.org/show_bug.cgi?id=493683
     const newId = generateId();
@@ -306,9 +469,30 @@ export class Select {
       this.wmComponentBlurred.emit(); // deprecated
     }
   }
+  handleSearchFieldKeyDown(ev) {
+    switch (ev.key) {
+      case "ArrowDown":
+        ev.preventDefault();
+        if (this.visibleOptionEls.length) {
+          this.focusOption(this.visibleOptionEls[0]);
+        }
+        break;
+      case "ArrowUp":
+        ev.preventDefault();
+        if (this.visibleOptionEls.length) {
+          this.focusOption(this.visibleOptionEls[this.visibleOptionEls.length - 1]);
+        }
+        break;
+      case "Escape":
+        ev.preventDefault();
+        this.close();
+        break;
+    }
+  }
   setButtonText() {
-    this.displayedItems = this.childItems.filter((x) => x.selected);
-    this.allSelected = this.displayedItems.length === this.childItems.length;
+    this.displayedOptions = this.childOptions
+      .filter((x) => x.selected)
+      .map((y) => (!y.classList.contains("hidden") ? y : this.findCorrespondingOption(y)));
     // handle overflow + counter for multiselect
     if (this.multiple) {
       // this is a fixed measurement accounting for the max width of a 3 character overflow counter
@@ -318,34 +502,41 @@ export class Select {
       const paddingLeft = parseInt(computedStyle.getPropertyValue("padding-left").slice(0, -2));
       const paddingRight = parseInt(computedStyle.getPropertyValue("padding-right").slice(0, -2));
       const availableSpace = this.buttonEl.clientWidth - paddingLeft - paddingRight - overflowCounterWidth;
-      let optionsWidths = this.displayedItems.map((x) => x.shadowRoot.querySelector(".option-wrapper").clientWidth);
+      let optionsWidths = this.displayedOptions.map((x) => x.shadowRoot.querySelector(".option-wrapper").clientWidth);
       let optionsTotalWidth = optionsWidths.reduce((acc, x) => acc + x, 0);
       this.overflowCount = 0;
-      while (optionsTotalWidth > availableSpace && this.displayedItems.length > 1) {
+      while (optionsTotalWidth > availableSpace && this.displayedOptions.length > 1) {
         this.overflowCount++;
         optionsTotalWidth -= optionsWidths[optionsWidths.length - 1];
         optionsWidths.pop();
-        this.displayedItems.pop();
+        this.displayedOptions.pop();
       }
     }
   }
+  announce(message) {
+    // \u00A0 is a non-breaking space character, which causes the message to be read as a new one
+    if (this.liveRegionEl.textContent === message) {
+      message += "\u00A0";
+    }
+    this.announcement = message;
+  }
   renderButtonText() {
-    if (this.multiple && this.displayedItems.length < 1) {
+    if (this.multiple && this.displayedOptions.length < 1) {
       return h("span", null, this.placeholder);
     }
     else if (this.multiple && this.allSelected && this.overflowCount > 0) {
       return this.allSelectedMessage;
     }
     else {
-      return this.displayedItems.map((x, idx) => (h("span", null,
+      return this.displayedOptions.map((x, idx) => (h("span", null,
         idx > 0 ? ", " : "",
         x.textContent)));
     }
   }
   renderSubinfo() {
     // multiselects cannot have subinfo for options
-    if (!this.multiple && this.selectedItems.length > 0 && this.selectedItems[0].subinfo) {
-      return h("span", { class: "subinfo" }, this.selectedItems[0].subinfo);
+    if (!this.multiple && this.selectedOptions.length > 0 && this.selectedOptions[0].subinfo) {
+      return h("span", { class: "subinfo" }, this.selectedOptions[0].subinfo);
     }
   }
   renderOverflowCount() {
@@ -356,6 +547,20 @@ export class Select {
           this.overflowCount)));
     }
   }
+  renderSearchField() {
+    return (h("div", { class: "search" },
+      h("div", { class: "searchfield-wrapper", ref: (el) => (this.searchFieldWrapperEl = el) },
+        h("div", { class: "icon" }),
+        h("input", { ref: (el) => (this.searchFieldEl = el), class: "searchfield", role: "combobox", "aria-controls": `list-${this.uid}`, "aria-expanded": this.isExpanded ? "true" : "false", onKeyDown: (ev) => this.handleSearchFieldKeyDown(ev), onFocus: () => this.searchFieldWrapperEl.classList.add("focus"), onBlur: (ev) => this.handleSearchFieldBlur(ev), onInput: () => this.debouncedSearch(), placeholder: this.searchPlaceholder }))));
+  }
+  renderSearchFailedMessage() {
+    return h("div", { class: "search-results-message" }, this.noResultsFoundMessage);
+  }
+  renderDuplicateOptions() {
+    return Array.from(this.el.children).map((option) => {
+      return (h("wm-option", { class: "duplicate", selected: option.selected }, option.textContent));
+    });
+  }
   render() {
     const buttonProps = {
       id: `selectbtn-${this.uid}`,
@@ -375,17 +580,22 @@ export class Select {
             this.requiredField ? (h("span", { class: "required" },
               h("span", { class: "sr-only" }, this.requiredMessage),
               h("span", { "aria-hidden": "true" }, "*"))) : (""))),
-        h("div", { class: "dropdown" },
-          h("button", Object.assign({}, buttonProps, { class: `displayedoption ${this.isTabbing ? "user-is-tabbing" : ""}`, ref: (el) => (this.buttonEl = el), onBlur: (ev) => this.handleButtonBlur(ev) }),
-            h("span", { class: this.selectedItems.length > 0 && this.selectedItems.filter((x) => x.subinfo).length > 0
+        h("div", { class: "button-wrapper" },
+          h("button", Object.assign({}, buttonProps, { class: `displayedoption ${this.isTabbing ? "user-is-tabbing" : ""}`, ref: (el) => (this.buttonEl = el), onBlur: (ev) => this.handleButtonBlur(ev), onFocus: () => this.close() }),
+            h("span", { class: this.selectedOptions.length > 0 && this.selectedOptions.filter((x) => x.subinfo).length > 0
                 ? "overflowcontrol hassubinfo"
                 : "overflowcontrol" },
               h("span", { class: "button-text" }, this.renderButtonText()),
               this.renderSubinfo()),
             this.renderOverflowCount()),
-          h("div", { class: `options ${this.isExpanded ? "open" : ""} ${this.openUp ? "upwards" : ""}`, id: `list-${this.uid}`, tabindex: -1, role: "listbox", "aria-multiselectable": this.multiple ? "true" : null, "aria-labelledby": `label-${this.uid}`, ref: (el) => (this.optionsEl = el) },
-            h("slot", null)),
-          this.renderErrorContainer()))));
+          h("div", { class: `dropdown ${this.isExpanded ? "open" : ""} ${this.openUp ? "upwards" : ""}`, ref: (el) => (this.dropdownEl = el) },
+            this.search && this.renderSearchField(),
+            h("div", { id: `list-${this.uid}`, tabindex: -1, role: "listbox", "aria-multiselectable": this.multiple ? "true" : null, "aria-labelledby": `label-${this.uid}` },
+              this.search && this.filteredOptions.length === 0 && this.renderSearchFailedMessage(),
+              this.multiple && this.renderDuplicateOptions(),
+              h("slot", null))),
+          this.renderErrorContainer(),
+          h("div", { "aria-live": "polite", class: "sr-only", ref: (el) => (this.liveRegionEl = el) }, this.announcement)))));
   }
   static get is() { return "wm-select"; }
   static get encapsulation() { return "shadow"; }
@@ -538,6 +748,24 @@ export class Select {
       "reflect": false,
       "defaultValue": "false"
     },
+    "search": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "search",
+      "reflect": false,
+      "defaultValue": "false"
+    },
     "placeholder": {
       "type": "string",
       "mutable": false,
@@ -556,6 +784,24 @@ export class Select {
       "reflect": false,
       "defaultValue": "intl.formatMessage({\r\n    id: \"select.multiPlaceholder\",\r\n    defaultMessage: \"Make a selection\",\r\n    description: \"Placeholder text. Use imperative\",\r\n  })"
     },
+    "searchPlaceholder": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "search-placeholder",
+      "reflect": false,
+      "defaultValue": "intl.formatMessage({\r\n    id: \"select.searchPlaceholder\",\r\n    defaultMessage: \"Search\",\r\n    description: \"Placeholder text. Use imperative\",\r\n  })"
+    },
     "allSelectedMessage": {
       "type": "string",
       "mutable": false,
@@ -577,7 +823,8 @@ export class Select {
   }; }
   static get states() { return {
     "isTabbing": {},
-    "isExpanded": {}
+    "isExpanded": {},
+    "announcement": {}
   }; }
   static get events() { return [{
       "method": "wmSelectDidLoad",
@@ -624,6 +871,25 @@ export class Select {
         "resolved": "void",
         "references": {}
       }
+    }, {
+      "method": "wmSelectSearchChanged",
+      "name": "wmSelectSearchChanged",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "Object",
+        "resolved": "Object",
+        "references": {
+          "Object": {
+            "location": "global"
+          }
+        }
+      }
     }]; }
   static get elementRef() { return "el"; }
   static get watchers() { return [{
@@ -668,19 +934,13 @@ export class Select {
       "passive": false
     }, {
       "name": "wmHomeKeyPressed",
-      "method": "moveToFirstItem",
+      "method": "moveToFirstOption",
       "target": undefined,
       "capture": false,
       "passive": false
     }, {
       "name": "wmEndKeyPressed",
-      "method": "moveToLastItem",
-      "target": undefined,
-      "capture": false,
-      "passive": false
-    }, {
-      "name": "wmTabKeyPressed",
-      "method": "handleTabKey",
+      "method": "moveToLastOption",
       "target": undefined,
       "capture": false,
       "passive": false
@@ -710,7 +970,7 @@ export class Select {
       "passive": false
     }, {
       "name": "wmLetterPressed",
-      "method": "findAndFocusItem",
+      "method": "findAndFocusOption",
       "target": undefined,
       "capture": false,
       "passive": false