q2-tecton-elements 1.11.4 → 1.12.1

package/dist/collection/components/q2-option-list/index.js

@@ -0,0 +1,646 @@
+import { Component, Prop, h, Event, State, Element, Host, Method, Watch, Listen } from '@stencil/core';
+import { isEventFromElement, overrideFocus } from 'src/utils';
+export class Q2OptionList {
+  constructor() {
+    this.role = 'listbox';
+    this.direction = 'down';
+    this.selectedOptions = [];
+    this.scheduledAfterRender = [];
+    /// Event Handlers ///
+    this.keydownHandler = (event, ignoreSelectionEvents) => {
+      event.stopPropagation();
+      const { activeIndex, customSearch, allOptions } = this;
+      const { key, shiftKey } = event;
+      let newOption;
+      switch (key) {
+        case ' ':
+        case 'Enter':
+          if (ignoreSelectionEvents) {
+            this.setDefaultActiveElement();
+            break;
+          }
+          event.preventDefault();
+          newOption = allOptions.find(element => element.active);
+          if (!newOption || newOption.disabled)
+            break;
+          this.selectOption(newOption.value);
+          break;
+        case 'ArrowUp':
+          event.preventDefault();
+          const isFirstOption = activeIndex === 0;
+          if (isFirstOption)
+            break;
+          if (activeIndex === undefined) {
+            this.setDefaultActiveElement();
+          }
+          else {
+            const nextIndex = this.getNextVisibleIndex(-1);
+            if (nextIndex === -1)
+              break;
+            this.adjustActiveOptionAndScroll(nextIndex - activeIndex);
+          }
+          break;
+        case 'ArrowDown':
+          event.preventDefault();
+          const isLastOption = activeIndex === allOptions.length - 1;
+          if (isLastOption)
+            break;
+          if (activeIndex === undefined) {
+            this.setDefaultActiveElement();
+          }
+          else {
+            const nextIndex = this.getNextVisibleIndex(1);
+            if (nextIndex === -1)
+              break;
+            this.adjustActiveOptionAndScroll(nextIndex - activeIndex);
+          }
+          break;
+        case 'Home':
+          event.preventDefault();
+          this.openDropdownWithActiveElement(0);
+          break;
+        case 'End':
+          event.preventDefault();
+          this.openDropdownWithActiveElement(allOptions.length - 1);
+          break;
+        case 'PageUp':
+          event.preventDefault();
+          this.openDropdownWithActiveElement(Math.max(activeIndex - 10, 0));
+          break;
+        case 'PageDown':
+          event.preventDefault();
+          this.openDropdownWithActiveElement(Math.min(activeIndex + 10, allOptions.length - 1));
+          break;
+        case 'Tab':
+          if (ignoreSelectionEvents)
+            break;
+          if (shiftKey)
+            break;
+          newOption = allOptions.find(element => element.active);
+          if (!newOption || newOption.disabled)
+            return;
+          this.selectOption(newOption.value);
+          break;
+        case 'Esc':
+        case 'Escape':
+          if (this.noSelect)
+            this.setActiveElement(null);
+          this.open = false;
+          break;
+        default:
+          if (customSearch)
+            break;
+          if (!key.match(/^[A-Za-z0-9]$/))
+            break;
+          // search in non-searchable select: alpha-numeric only
+          this.searchAndFocus(key);
+          break;
+      }
+    };
+    this.focusoutHandler = (event) => {
+      const { relatedTarget } = event;
+      const isInDropdown = this.allOptions.includes(relatedTarget);
+      const isInLightDom = !isInDropdown && this.hostElement.contains(relatedTarget);
+      if (isInDropdown || isInLightDom) {
+        event.stopPropagation();
+      }
+    };
+    this.clickHandler = (event) => {
+      const target = event.target;
+      if (target.localName !== 'q2-option' || target.disabled) {
+        return;
+      }
+      this.selectOption(target.value);
+    };
+  }
+  /// LifeCycle Hooks ///
+  componentWillLoad() {
+    this.hasOptions = !!this.hostElement.querySelectorAll('q2-option').length;
+  }
+  componentDidLoad() {
+    overrideFocus(this.hostElement);
+    this.checkOptions();
+  }
+  componentDidRender() {
+    this.scheduledAfterRender.forEach(fn => fn());
+    this.scheduledAfterRender = [];
+  }
+  /// Getters ///
+  get allOptions() {
+    return this.getRootSlot(this.hostElement);
+  }
+  /// Helpers ///
+  checkOptions() {
+    const { noSelect, type, allOptions } = this;
+    if (!noSelect && !type)
+      return;
+    const optionRole = type === 'menu' ? 'menuitem' : 'option';
+    allOptions.forEach(option => {
+      if (noSelect)
+        option.noSelect = true;
+      if (type)
+        option.role = optionRole;
+    });
+  }
+  getRootSlot(element) {
+    var _a;
+    const slot = element.querySelector('slot');
+    const assignedElements = (_a = slot === null || slot === void 0 ? void 0 : slot.assignedElements()) !== null && _a !== void 0 ? _a : Array.from(element.children);
+    const hasAnotherSlot = !!assignedElements.length && assignedElements[0].tagName === 'SLOT';
+    if (hasAnotherSlot) {
+      return this.getRootSlot(assignedElements[0]);
+    }
+    else {
+      return assignedElements;
+    }
+  }
+  scrollToActiveOption() {
+    const activeOption = this.allOptions[this.activeIndex];
+    activeOption === null || activeOption === void 0 ? void 0 : activeOption.scrollIntoView({ block: 'nearest' });
+  }
+  resizeIframe() {
+    var _a, _b;
+    return (_b = (_a = window.TectonElements) === null || _a === void 0 ? void 0 : _a.resizeIframe) === null || _b === void 0 ? void 0 : _b.call(_a);
+  }
+  openDropdownWithActiveElement(activeIndex) {
+    if (this.disabled)
+      return;
+    this.activeIndex = activeIndex;
+    this.open = true;
+    this.setActiveOption();
+    this.setFocusedOption();
+    this.scheduledAfterRender.push(() => {
+      this.scrollToActiveOption();
+      this.resizeIframe();
+    });
+  }
+  getDefaultActiveIndex() {
+    const { allOptions } = this;
+    const firstSelected = allOptions.findIndex(element => element.selected);
+    if (firstSelected > -1)
+      return firstSelected;
+    const firstEnabled = allOptions.findIndex(element => !element.hidden);
+    if (firstEnabled > -1)
+      return firstEnabled;
+    return 0;
+  }
+  updateSingleOptionAttrs() {
+    var _a, _b;
+    const { allOptions, selectedOptions } = this;
+    const singleValue = (_b = (_a = selectedOptions[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
+    allOptions.forEach(element => {
+      element.selected = element.value === singleValue;
+    });
+  }
+  updateMultipleOptionAttrs() {
+    const { allOptions, selectedOptions } = this;
+    const selectedValues = selectedOptions.map(option => option.value);
+    allOptions.forEach(element => {
+      element.selected = selectedValues.includes(element.value);
+    });
+  }
+  setActiveOption() {
+    if (!this.open)
+      return;
+    const activeIndex = this.activeIndex;
+    this.allOptions.forEach((element, elementIndex) => {
+      element.active = activeIndex === elementIndex;
+    });
+  }
+  setFocusedOption() {
+    const option = this.allOptions[this.activeIndex];
+    if (!option)
+      return;
+    setTimeout(() => {
+      option.focus();
+    }, 25);
+  }
+  getNextVisibleIndex(direction) {
+    let index = this.activeIndex + direction;
+    while (index >= 0 && index <= this.allOptions.length - 1) {
+      const { display, visibility } = window.getComputedStyle(this.allOptions[index]);
+      if (display !== 'none' && visibility !== 'hidden') {
+        return index;
+      }
+      index = index + direction;
+    }
+    return -1;
+  }
+  selectOption(selectedValue) {
+    const option = this.allOptions.find(({ value }) => value === selectedValue);
+    const valueObject = {
+      value: selectedValue,
+      display: option.display || option.innerText.trim()
+    };
+    const { multiple, noSelect } = this;
+    let values;
+    if (multiple) {
+      const { selectedOptions = [] } = this;
+      const isAlreadySelected = !!selectedOptions.find(({ value }) => value === selectedValue);
+      if (isAlreadySelected) {
+        values = selectedOptions.filter(({ value }) => value !== selectedValue);
+      }
+      else {
+        values = [...selectedOptions, valueObject];
+      }
+    }
+    else {
+      values = [valueObject];
+    }
+    if (noSelect)
+      this.setActiveElement(null);
+    else
+      this.selectedOptions = values;
+    this.change.emit({ value: selectedValue, values });
+    if (multiple)
+      return;
+    this.open = false;
+  }
+  adjustActiveOptionAndScroll(numToAdd) {
+    this.activeIndex += numToAdd;
+    this.setActiveOption();
+    this.setFocusedOption();
+    this.scrollToActiveOption();
+  }
+  resetTimer() {
+    if (this.searchStringTimer) {
+      clearTimeout(this.searchStringTimer);
+    }
+    this.searchStringTimer = window.setTimeout(() => {
+      this.searchString = null;
+    }, 2000);
+  }
+  searchAndFocus(key) {
+    this.resetTimer();
+    let searchString = this.searchString ? `${this.searchString}${key}` : key;
+    searchString = searchString.replace(/[^0-9a-z]/gi, '');
+    this.searchString = searchString;
+    const searchRegEx = new RegExp(searchString, 'i');
+    const foundIndex = this.allOptions.findIndex(option => option.value === searchString || option.textContent.match(searchRegEx));
+    if (foundIndex === -1)
+      return;
+    this.setActiveElement(foundIndex);
+  }
+  /// Watchers ///
+  selectedOptionsUpdated() {
+    if (this.multiple) {
+      this.updateMultipleOptionAttrs();
+    }
+    else {
+      this.updateSingleOptionAttrs();
+    }
+  }
+  openChanged(newValue) {
+    this.optionListState.emit({ open: newValue });
+  }
+  /// Listeners ///
+  delegateFocus(event) {
+    if (!isEventFromElement(event, this.hostElement))
+      return;
+    this.open = true;
+    this.setDefaultActiveElement();
+  }
+  handleClick(event) {
+    event.stopPropagation();
+  }
+  /// Public Methods ///
+  toggle() {
+    const isOpen = !this.open;
+    this.open = isOpen;
+  }
+  setDefaultActiveElement() {
+    this.activeIndex = this.getDefaultActiveIndex();
+    this.setActiveOption();
+    this.setFocusedOption();
+  }
+  setActiveElement(index) {
+    this.activeIndex = index;
+    this.setActiveOption();
+    this.setFocusedOption();
+  }
+  handleExternalKeydown(event) {
+    const keysThatTriggerOpen = ['ArrowDown', 'ArrowUp', 'PageDown', 'PageUp', 'Home', 'End'];
+    if (keysThatTriggerOpen.includes(event.key)) {
+      this.open = true;
+    }
+    const keysThatTriggerDefault = ['ArrowDown', 'ArrowUp'];
+    if (keysThatTriggerDefault.includes(event.key)) {
+      event.preventDefault();
+      this.setDefaultActiveElement();
+    }
+    else {
+      this.keydownHandler(event, true);
+    }
+  }
+  /// DOM ///
+  render() {
+    return (h(Host, null,
+      h("div", { class: "content", ref: el => (this.contentElement = el), onFocusout: this.focusoutHandler },
+        h("div", { class: "options", role: this.type || 'listbox', onKeyDown: this.keydownHandler, onClick: this.clickHandler },
+          h("slot", null)))));
+  }
+  static get is() { return "q2-option-list"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["styles.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["styles.css"]
+  }; }
+  static get properties() { return {
+    "role": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "'listbox' | 'menu'",
+        "resolved": "\"listbox\" | \"menu\"",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "role",
+      "reflect": true,
+      "defaultValue": "'listbox'"
+    },
+    "direction": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "'up' | 'down'",
+        "resolved": "\"down\" | \"up\"",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "direction",
+      "reflect": true,
+      "defaultValue": "'down'"
+    },
+    "open": {
+      "type": "boolean",
+      "mutable": true,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "open",
+      "reflect": true
+    },
+    "customSearch": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "custom-search",
+      "reflect": true
+    },
+    "noSelect": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "no-select",
+      "reflect": true
+    },
+    "align": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "'left' | 'right'",
+        "resolved": "\"left\" | \"right\"",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "align",
+      "reflect": true
+    },
+    "selectedOptions": {
+      "type": "unknown",
+      "mutable": true,
+      "complexType": {
+        "original": "IOptionValue[]",
+        "resolved": "IOptionValue[]",
+        "references": {
+          "IOptionValue": {
+            "location": "local"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "defaultValue": "[]"
+    },
+    "multiple": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "multiple",
+      "reflect": true
+    },
+    "disabled": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "disabled",
+      "reflect": true
+    },
+    "type": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "'menu' | 'listbox'",
+        "resolved": "\"listbox\" | \"menu\"",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "type",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "hasOptions": {}
+  }; }
+  static get events() { return [{
+      "method": "change",
+      "name": "change",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "{ value: string; values: IOptionValue[] }",
+        "resolved": "{ value: string; values: IOptionValue[]; }",
+        "references": {
+          "IOptionValue": {
+            "location": "local"
+          }
+        }
+      }
+    }, {
+      "method": "optionListState",
+      "name": "optionListState",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "{ open: boolean }",
+        "resolved": "{ open: boolean; }",
+        "references": {}
+      }
+    }]; }
+  static get methods() { return {
+    "toggle": {
+      "complexType": {
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "references": {},
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "setDefaultActiveElement": {
+      "complexType": {
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "references": {},
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "setActiveElement": {
+      "complexType": {
+        "signature": "(index: number) => Promise<void>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {},
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "handleExternalKeydown": {
+      "complexType": {
+        "signature": "(event: KeyboardEvent) => Promise<void>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "KeyboardEvent": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    }
+  }; }
+  static get elementRef() { return "hostElement"; }
+  static get watchers() { return [{
+      "propName": "selectedOptions",
+      "methodName": "selectedOptionsUpdated"
+    }, {
+      "propName": "open",
+      "methodName": "openChanged"
+    }]; }
+  static get listeners() { return [{
+      "name": "focus",
+      "method": "delegateFocus",
+      "target": undefined,
+      "capture": false,
+      "passive": false
+    }, {
+      "name": "click",
+      "method": "handleClick",
+      "target": undefined,
+      "capture": false,
+      "passive": false
+    }]; }
+}