@itfin/components 1.0.76 → 1.0.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itfin/components",
-  "version": "1.0.76",
+  "version": "1.0.80",
   "main": "dist/itfin-components.umd.js",
   "unpkg": "dist/itfin-components.common.js",
   "author": "Vitalii Savchuk <esvit666@gmail.com>",

package/src/components/modal/Modal.vue

@@ -7,7 +7,9 @@
     >
       <div class="modal-content itf-append-context" ref="content">
         <div class="modal-header">
-          <h5 class="modal-title" :id="modalId">{{title}}</h5>
+          <slot name="title">
+            <h5 class="modal-title" :id="modalId">{{title}}</h5>
+          </slot>
           <itf-button icon data-bs-dismiss="modal" aria-label="Close" class="btn-close"></itf-button>
         </div>
         <div class="modal-body" v-if="value">
@@ -96,7 +98,7 @@ class itfModal extends Vue {
       setTimeout(() => {
         this.modalEl.show();
         modalStack.push(this);
-      }, 500);
+      }, modalStack.length ? 500 : 0);
     } else {
       this.modalEl.hide();
       modalStack.pop();
@@ -104,7 +106,7 @@ class itfModal extends Vue {
         setTimeout(() => {
           modalStack[modalStack.length - 1].show();
           modalStack[modalStack.length - 1].bindEvents();
-        }, 500);
+        }, modalStack.length ? 500 : 0);
       }
     }
   }
@@ -131,12 +133,16 @@ class itfModal extends Vue {
 
   bindEvents() {
     this.preventEvents = false;
-    this.$refs.modal.addEventListener('hidden.bs.modal', this.onClose);
+    if (this.$refs.modal) {
+      this.$refs.modal.addEventListener('hidden.bs.modal', this.onClose);
+    }
   }
 
   unbindEvents() {
     this.preventEvents = true;
-    this.$refs.modal.removeEventListener('hidden.bs.modal', this.onClose);
+    if (this.$refs.modal) {
+      this.$refs.modal.removeEventListener('hidden.bs.modal', this.onClose);
+    }
   }
 
   show() {

package/src/components/segmented-control/SegmentedControl.vue

@@ -165,6 +165,8 @@ class itfSegmentedControl extends Vue {
   @Prop({ type: Boolean, default: false }) returnObject;
   @Prop({ type: Boolean, default: false }) disabled;
 
+  timers = [];
+
   get name () {
     return `sc${this._uid}`;
   }
@@ -210,20 +212,25 @@ class itfSegmentedControl extends Vue {
     updatePillPosition(this);
 
     function updatePillPosition (component) {
+      component.timers.forEach((timer) => {
+        clearTimeout(timer);
+      });
+      component.timers = [];
       component.$refs.input.forEach((elem, index) => {
         if (elem.checked) {
           component.$nextTick(() => moveBackgroundPillToElement(component, elem, index));
-          setTimeout(() => moveBackgroundPillToElement(component, elem, index), 500);
-          setTimeout(() => moveBackgroundPillToElement(component, elem, index), 750);
-          setTimeout(() => moveBackgroundPillToElement(component, elem, index), 1500);
-          setTimeout(() => moveBackgroundPillToElement(component, elem, index), 3000);
+          component.timers = [
+            setTimeout(() => moveBackgroundPillToElement(component, elem, index), 500),
+            setTimeout(() => moveBackgroundPillToElement(component, elem, index), 750),
+            setTimeout(() => moveBackgroundPillToElement(component, elem, index), 1500),
+            setTimeout(() => moveBackgroundPillToElement(component, elem, index), 3000)
+          ];
         }
       })
     }
 
     function moveBackgroundPillToElement (component, elem, index) {
       const slider = component.$refs.slider;
-      console.info('init 2', slider);
       if (slider) {
         slider.style.transform = 'translateX(' + (elem.offsetWidth * index) + 'px)';
       }

package/src/components/select/AirSelect.vue

@@ -0,0 +1,355 @@
+<template>
+  <div
+    class="select"
+    ref="selectRef"
+    :class="[variant]"
+    @keydown="handleFocusedSelectKeydown"
+  >
+    <div
+      class="valueContainer text-textDarkest"
+      :data-testid="name ? `select:${name}` : 'select'"
+      @click="activateDropdown"
+    >
+      <div class="placeholder" v-if="isValueEmpty">{{ placeholder }}</div>
+
+      <slot
+        v-if="!isValueEmpty && !multiple && customRender"
+        :option="getOption(localValue)"
+      />
+      <template v-else>
+        {{ getOptionLabel(localValue) }}
+      </template>
+
+      <div v-if="!isValueEmpty && multiple" class="valueMulti text-textDarkest">
+        <div
+          class="my-1 mx-1 flex items-center"
+          v-for="optionValue in localValue"
+          :key="optionValue"
+        >
+          <slot
+            v-if="customRender"
+            :option="getOption(optionValue)"
+            :value="optionValue"
+            :remove="removeOptionValue"
+          />
+          <div v-else class="valueMultiItem text-textDarkest" :style="getOptionColor(optionValue) ? `background-color: #${getOptionColor(optionValue)}; color: #fff` : ''">
+            <div class="valueMultiItemLabel">
+              {{ getOptionLabel(optionValue) }}
+            </div>
+            <div
+              @click="removeOptionValue(optionValue)"
+              class="valueMultiItemClose"
+            >
+              <svg class="icon" viewBox="0 0 24 24">
+                <path
+                  d="M16.192 6.344L11.949 10.586 7.707 6.344 6.293 7.758 10.535 12 6.293 16.242 7.707 17.656 11.949 13.414 16.192 17.656 17.606 16.242 13.364 12 17.606 7.758z"
+                />
+              </svg>
+            </div>
+          </div>
+        </div>
+
+        <div class="addMore m-1">
+          <svg
+            class="icon"
+            viewBox="0 0 24 24"
+            focusable="false"
+            role="presentation"
+          >
+            <path
+              d="M13 11V3.993A.997.997 0 0 0 12 3c-.556 0-1 .445-1 .993V11H3.993A.997.997 0 0 0 3 12c0 .557.445 1 .993 1H11v7.007c0 .548.448.993 1 .993.556 0 1-.445 1-.993V13h7.007A.997.997 0 0 0 21 12c0-.556-.445-1-.993-1H13z"
+              fill="currentColor"
+              fill-rule="evenodd"
+            ></path>
+          </svg>
+          <div class="font-medium">Add more</div>
+        </div>
+      </div>
+
+      <icon
+        v-if="(!multiple || isValueEmpty) && variant !== 'empty'"
+        class="ml-auto mr-1"
+        name="chevron_down"
+      ></icon>
+    </div>
+
+    <Dropdown
+      v-if="isDropdownOpen"
+      ref="dropdownRef"
+      isValueEmpty
+      :dropdownWidth="dropdownWidth"
+      :searchable="searchable"
+      :searchValue="searchValue"
+      :value="localValue"
+      :deactivateDropdown="deactivateDropdown"
+      :options="options"
+      :multiple="multiple"
+      :item-key="itemKey"
+      :item-text="itemText"
+      :withClearValue="withClearValue"
+      @change="handleChange"
+      @searchValueChange="handleSearchValueChange"
+    >
+      <template #option="{ option }">
+        <slot v-if="customRenderOption" name="option" :option="option" />
+        <slot v-else :option="option" />
+      </template>
+    </Dropdown>
+  </div>
+</template>
+
+<script>
+import { Component, Model, Prop, Ref } from 'vue-property-decorator';
+import Vue from 'vue';
+import Icon from '../icon/Icon.vue';
+import Dropdown from './Dropdown.vue';
+import { useOutsideClick } from './useOutsideClick';
+
+const { bind, unbind } = useOutsideClick();
+
+export default @Component({
+  name: 'itfAirSelect',
+  components: { Dropdown, Icon },
+})
+class itfAirSelect extends Vue {
+  @Model('input', { type: [Array, String, Number], default: undefined }) value;
+
+  @Prop({ type: Number, default: undefined }) dropdownWidth;
+
+  @Prop({ type: String, default: 'normal' }) variant;
+
+  @Prop({ type: String, default: 'value' }) itemKey;
+  @Prop({ type: String, default: 'label' }) itemText;
+  @Prop({ type: String, default: 'color' }) itemColor;
+
+  @Prop({ type: String, default: undefined }) name;
+
+  @Prop({ type: Boolean, default: false }) searchable;
+
+  @Prop({ type: [String, Array, Number], default: undefined }) defaultValue;
+
+  @Prop({ type: String, default: 'Select' }) placeholder;
+
+  @Prop({ type: Boolean, default: false }) invalid;
+
+  @Prop({ type: Array, required: true }) options;
+
+  @Prop({ type: Boolean, default: false }) multiple;
+
+  @Prop({ type: Boolean, default: false }) withClearValue;
+
+  @Prop({ type: Boolean, default: false }) customRender;
+  @Prop({ type: Boolean, default: false }) customRenderOption;
+
+  @Ref('selectRef') selectRef;
+
+  @Ref('dropdownRef') dropdownRef;
+
+  isDropdownOpen = false;
+
+  searchValue = '';
+
+  data() {
+    return {
+      stateValue: this.defaultValue || (this.multiple ? [] : null),
+    };
+  }
+
+  getOption(optionValue) {
+    return this.options.find((option) => option[this.itemKey] === optionValue);
+  }
+
+  getOptionLabel(optionValue) {
+    return (this.getOption(optionValue) || { [this.itemText]: '' })[this.itemText];
+  }
+
+  getOptionColor(optionValue) {
+    return (this.getOption(optionValue) || { [this.itemColor]: '' })[this.itemColor];
+  }
+
+  get isControlled() {
+    return this.value !== undefined;
+  }
+
+  get localValue() {
+    return this.isControlled ? this.value : this.stateValue;
+  }
+
+  preserveValueType(newValue) {
+    const areOptionValuesNumbers = this.options.some(
+      (option) => typeof option[this.itemKey] === 'number',
+    );
+    if (areOptionValuesNumbers) {
+      if (this.multiple) {
+        return (newValue).map(Number);
+      }
+      if (newValue) {
+        return Number(newValue);
+      }
+    }
+    return newValue;
+  }
+
+  handleChange(newValue) {
+    if (!this.isControlled) {
+      this.stateValue = this.preserveValueType(newValue);
+    }
+    this.$emit('input', this.preserveValueType(newValue));
+  }
+
+  removeOptionValue(optionValue) {
+    this.handleChange(this.localValue.filter((val) => val !== optionValue));
+  }
+
+  get isValueEmpty() {
+    return this.multiple ? !this.localValue.length : !this.getOption(this.localValue);
+  }
+
+  handleFocusedSelectKeydown(event) {
+    if (this.isDropdownOpen) return;
+    if (event.keyCode === 13) {
+      event.preventDefault();
+    }
+    if (event.keyCode !== 27 && event.keyCode !== 9 && !event.shiftKey) {
+      this.isDropdownOpen = true;
+    }
+  }
+
+  async deactivateDropdown() {
+    this.isDropdownOpen = false;
+    this.searchValue = '';
+    await this.$nextTick();
+    this.selectRef && this.selectRef.focus();
+  }
+
+  async activateDropdown() {
+    this.isDropdownOpen = true;
+    await this.$nextTick();
+    this.selectRef && this.selectRef.blur();
+    // eslint-disable-next-line
+    this.searchable && this.dropdownRef && this.dropdownRef.$refs.inputRef.focus()
+  }
+
+  handleSearchValueChange(newValue) {
+    this.searchValue = newValue;
+  }
+
+  mounted () {
+    bind(this.selectRef, this.deactivateDropdown);
+  }
+
+  beforeDestroy () {
+    unbind();
+  }
+}
+</script>
+
+<style lang="scss" scoped>
+.select {
+  position: relative;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 14px;
+  transition: background 0.1s;
+  &:focus {
+    outline: none;
+  }
+}
+.valueContainer {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  min-height: 32px;
+  justify-content: space-between;
+}
+.placeholder {
+  color: #8993a4;
+}
+.valueMulti {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  // padding-top: 5px;
+}
+.valueMultiItem {
+  height: 22px;
+  overflow: hidden;
+  border-radius: 3px;
+  display: flex;
+  align-items: center;
+  user-select: none;
+  background: #f0f0f0;
+  font-size: 14px;
+  .valueMultiItemLabel {
+    flex: auto;
+    padding: 0 4px;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    border-right: 1px solid #ddd;
+  }
+  .valueMultiItemClose {
+    border-left: none;
+    overflow: hidden;
+    padding: 0 2px;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    &:hover {
+      background: #ff4757;
+      color: white;
+    }
+    .icon {
+      width: 18px;
+      height: 18px;
+      fill: currentColor;
+    }
+  }
+}
+.addMore {
+  font-size: 12.5px;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  color: #0052cc;
+  &:hover,
+  &:visited,
+  &:active {
+    color: #0052cc;
+  }
+  &:hover {
+    text-decoration: underline;
+  }
+  .icon {
+    width: 16px;
+    height: 16px;
+    fill: currentColor;
+    margin-right: 2px;
+  }
+}
+.select.normal {
+  width: 100%;
+  padding-left: 0.5rem;
+  padding-right: 0.5rem;
+  border-width: 1px;
+  border-color: #dfe1e6;
+  background-color: #f4f5f7;
+  position: relative;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 14px;
+  -webkit-transition: background .1s;
+  transition: background .1s;
+}
+.select.normal:hover {
+  @apply bg-backgroundLight;
+}
+.select.normal:focus {
+  @apply border border-borderInputFocus bg-white text-borderInputFocus;
+  box-shadow: 0 0 0 1px currentColor;
+}
+.select.empty {
+  display: inline-block;
+}
+</style>

package/src/components/select/Dropdown.vue

@@ -0,0 +1,277 @@
+<template>
+  <div class="dropdown" :style="{ width: `${dropdownWidth}px` }">
+    <input
+      v-if="searchable"
+      class="dropdownInput"
+      type="text"
+      ref="inputRef"
+      placeholder="Search"
+      @input="handleSearchValueChange"
+      @keydown="handleInputKeyDown"
+    />
+
+    <div class="options" ref="optionsRef">
+      <div
+        class="option text-textDarkest"
+        v-for="option in filteredOptions"
+        :key="option[itemKey]"
+        :data-select-option-value="option[itemKey]"
+        :data-testid="`select-option:${option[itemText]}`"
+        @mouseenter="handleOptionMouseEnter"
+        @click="selectOptionValue(option[itemKey])"
+      >
+        <slot name="option" v-bind="option">{{ option[itemText] }}</slot>
+      </div>
+
+      <div
+        v-if="isOptionCreatable"
+        class="option text-textDarkest"
+        :data-create-option-label="{ searchValue }"
+        @mouseenter="handleOptionMouseEnter"
+        @click="createOption(searchValue)"
+      >
+        {{
+          isCreatingOption
+            ? `Creating "${searchValue}"...`
+            : `Create
+        "${searchValue}"`
+        }}
+      </div>
+    </div>
+
+    <div v-if="filteredOptions.length === 0" class="optionsNoResults">
+      No results
+    </div>
+  </div>
+</template>
+
+<script>
+import Vue from 'vue';
+import { Component, Prop, Ref } from 'vue-property-decorator';
+
+const activeOptionClass = 'select-option-is-active';
+
+export default @Component({
+  name: 'itfDropdown',
+  components: {}
+})
+class itfSegmentedControl extends Vue {
+  @Prop({ type: Number, default: undefined }) dropdownWidth;
+  @Prop({ type: [Array, String, Number], default: undefined }) value;
+  @Prop({ type: Boolean }) isValueEmpty;
+  @Prop({ type: Boolean }) searchable;
+  @Prop({ type: String, default: 'value' }) itemKey;
+  @Prop({ type: String, default: 'label' }) itemText;
+  @Prop({ type: String, default: '' }) searchValue;
+  @Prop({ type: Function, required: true }) deactivateDropdown;
+  @Prop({ type: Array, required: true }) options;
+  @Prop({ type: Function, default: undefined }) onCreate;
+  @Prop({ type: Boolean }) multiple;
+  @Prop({ type: Boolean }) withClearValue;
+
+  @Ref('optionsRef') optionsRef;
+  @Ref('inputRef') inputRef;
+
+  isCreatingOption = false;
+
+  get optionsFilteredBySearchValue() {
+    return this.options.filter((option) => option[this.itemText]
+      .toString()
+      .toLowerCase()
+      .includes(this.searchValue.toLowerCase()));
+  }
+
+  get filteredOptions() {
+    return this.multiple
+      ? this.optionsFilteredBySearchValue.filter(
+        (option) => !(this.value).includes(option[this.itemKey]),
+      )
+      : this.optionsFilteredBySearchValue.filter(
+        (option) => this.value !== option[this.itemKey],
+      );
+  }
+
+  get isOptionCreatable() {
+    return this.onCreate
+      && this.searchValue
+      && !this.options.map((option) => option[this.itemText]).includes(this.searchValue);
+  }
+
+  handleSearchValueChange(event) {
+    this.$emit('searchValueChange', (event.target)[this.itemKey]);
+  }
+
+  async getActiveOptionNode() {
+    await this.$nextTick();
+    return this.optionsRef
+      ? this.optionsRef.querySelector(`.${activeOptionClass}`)
+      : null;
+  }
+
+  selectOptionValue (optionValue) {
+    if (this.multiple) {
+      this.$emit('change', [
+        ...new Set([...(this.value), optionValue]),
+      ]);
+    } else {
+      this.deactivateDropdown();
+      this.$emit('change', optionValue);
+    }
+  }
+
+  createOption (newOptionLabel) {
+    this.isCreatingOption = true;
+    this.onCreate(
+      newOptionLabel,
+      (createdOptionValue) => {
+        this.isCreatingOption = false;
+        this.selectOptionValue(createdOptionValue);
+      },
+    );
+  };
+
+  async handleInputEnterKeyDown (event) {
+    event.preventDefault();
+    const $active = await this.getActiveOptionNode();
+    if (!$active) return;
+    const optionValueToSelect = $active.getAttribute(
+      'data-select-option-value',
+    );
+    const optionLabelToCreate = $active.getAttribute(
+      'data-create-option-label',
+    );
+    console.info($active, optionValueToSelect);
+    if (optionValueToSelect) {
+      this.selectOptionValue(optionValueToSelect);
+    } else if (optionLabelToCreate) {
+      this.createOption(optionLabelToCreate);
+    }
+  }
+
+  async handleInputArrowUpOrDownKeyDown (event) {
+    const $active = (await this.getActiveOptionNode());
+    const $options = this.optionsRef;
+    if (!$active || !$options) return;
+    const $optionsHeight = $options.getBoundingClientRect().height;
+    const $activeHeight = $active.getBoundingClientRect().height;
+    if (event.keyCode === 40) {
+      if ($options.lastElementChild === $active) {
+        $active.classList.remove(activeOptionClass);
+        $options.firstElementChild?.classList.add(activeOptionClass);
+        $options.scrollTop = 0;
+      } else {
+        $active.classList.remove(activeOptionClass);
+        $active.nextElementSibling?.classList.add(activeOptionClass);
+        if ($active.offsetTop > $options.scrollTop + $optionsHeight / 1.4) {
+          $options.scrollTop += $activeHeight;
+        }
+      }
+    } else if (event.keyCode === 38) {
+      if ($options.firstElementChild === $active) {
+        $active.classList.remove(activeOptionClass);
+        $options.lastElementChild?.classList.add(activeOptionClass);
+        $options.scrollTop = $options.scrollHeight;
+      } else {
+        $active.classList.remove(activeOptionClass);
+        $active.previousElementSibling?.classList.add(activeOptionClass);
+        if ($active.offsetTop < $options.scrollTop + $optionsHeight / 2.4) {
+          $options.scrollTop -= $activeHeight;
+        }
+      }
+    }
+  }
+
+  handleInputEscapeKeyDown(event) {
+    event.stopImmediatePropagation();
+    this.deactivateDropdown();
+  }
+
+  handleInputKeyDown(event) {
+    if (event.keyCode === 27) {
+      this.handleInputEscapeKeyDown(event);
+    } else if (event.keyCode === 13) {
+      this.handleInputEnterKeyDown(event);
+    } else if (event.keyCode === 40 || event.keyCode === 38) {
+      this.handleInputArrowUpOrDownKeyDown(event);
+    }
+  }
+
+  async handleOptionMouseEnter(event) {
+    const $active = await this.getActiveOptionNode();
+    if ($active) $active.classList.remove(activeOptionClass);
+    (event.currentTarget).classList.add(activeOptionClass);
+  }
+
+  async setFirstOptionAsActive() {
+    const $active = await this.getActiveOptionNode();
+    if (!this.optionsRef) return;
+    if ($active) $active.classList.remove(activeOptionClass);
+    if (this.optionsRef.firstElementChild) {
+      this.optionsRef.firstElementChild.classList.add(activeOptionClass);
+    }
+  }
+
+  mounted() {
+    this.setFirstOptionAsActive();
+  }
+}
+</script>
+
+<style scoped lang="scss">
+.dropdown {
+  z-index: 101;
+  position: absolute;
+  top: calc(100% + 4px);
+  left: -1px;
+  border-radius: 0 0 4px 4px;
+  background: #fff;
+  box-shadow: rgba(9, 30, 66, 0.25) 0px 4px 8px -2px,
+  rgba(9, 30, 66, 0.31) 0px 0px 1px;
+  width: 100%;
+}
+
+.dropdownInput {
+  padding: 10px 14px 8px;
+  width: 100%;
+  border: none;
+  color: #172b4d;
+  background: none;
+
+  &:focus {
+    outline: none;
+  }
+}
+
+.options {
+  padding: 5px 0;
+  max-height: 200px;
+  overflow-x: hidden;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  // &::-webkit-scrollbar {
+  //   width: 7px;
+  // }
+  // &::-webkit-scrollbar-track {
+  //   background: none;
+  // }
+  // &::-webkit-scrollbar-thumb {
+  //   // border-radius: 99px;
+  //   background: #d1d1d1;
+  // }
+}
+
+.option {
+  padding: 8px 14px;
+  word-break: break-word;
+  cursor: pointer;
+
+  &.select-option-is-active {
+    background: #e8ecee;
+  }
+}
+
+.optionsNoResults {
+  padding: 0px 15px 10px;
+  color: #8993a4;
+}
+</style>

package/src/components/select/Select.vue

@@ -195,12 +195,14 @@
   }
   &__dropdown-menu {
     background-color: $body-bg;
-    border: 2px solid $input-focus-border;
+    //border: 2px solid $input-focus-border;
+    border: 0 none;
     padding-left: 0.125rem !important;
     padding-right: 0.125rem !important;
     left: -2px;
     right: -2px;
     width: auto;
+    box-shadow: rgb(9 30 66 / 25%) 0px 4px 8px -2px, rgb(9 30 66 / 31%) 0px 0px 1px;
 
     @media (prefers-color-scheme: notdark) {
       background-color: $dark-body-bg;

package/src/components/select/index.stories.js

@@ -1,5 +1,7 @@
 import { storiesOf } from '@storybook/vue';
 import itfSelect from './Select.vue';
+import itfDropdown from './Dropdown';
+import itfSelect2 from './AirSelect';
 import itfForm from '../form/Form.vue';
 import itfLabel from '../form/Label.vue';
 import itfButton from '../button/Button.vue';
@@ -15,6 +17,8 @@ storiesOf('Common', module)
       itfLabel,
       itfButton,
       itfSelect,
+      itfSelect2,
+      itfDropdown,
       itfDatePicker,
       itfDateRangePicker
     },
@@ -29,11 +33,16 @@ storiesOf('Common', module)
         customDays: {
           '2021-10-21': { text: '🎉', class: 'test' }
         },
+        value: [],
         countries: [
           {code: 'CA', country: 'Canada'},
           {code: 'US', country: 'United states'},
           {code: 'UA', country: 'Ukraine'},
           {code: 'TEST', country: 'ASdasd sdas dasd sad sadas da ad asdsad ad d ada dsadsadsadasd sadsa das dasd asdasd asdas da '}
+        ],
+        issuePriorityOptions: [
+          { label: 'High', value: 1 },
+          { label: 'Low', value: 2 }
         ]
       }
     },
@@ -65,6 +74,25 @@ storiesOf('Common', module)
 
         <itf-form ref="form">
 
+          <itf-select2
+            multiple
+            searchable
+            variant="normal"
+            :dropdownWidth="300"
+            v-model="value"
+            :options="issuePriorityOptions"
+            customRender
+          >
+            <template #default="{ label, icon, color }">
+              <itf-button secondary>
+                <div class="flex items-center">
+                  <div class="pr-1 pl-2">
+                    {{ label }}
+                  </div>
+                </div>
+              </itf-button>
+            </template>
+          </itf-select2>
           <div class="row">
             <div class="col-6">
               <itf-label :rules="[$v.emptyValidation()]" :value="selected" label="From" required>

package/src/components/select/useOutsideClick.js

@@ -0,0 +1,36 @@
+export const useOutsideClick = () => {
+  const root = typeof document !== 'undefined' ? document.body : null;
+  let handleClickOutside = null;
+  let handleKeydown = null;
+
+  return {
+    bind(element, onOutsideClick) {
+      handleClickOutside = (e) => {
+        if (element && !element.contains(e.target)) {
+          onOutsideClick();
+        }
+      };
+      handleKeydown = (e) => {
+        if (e.key === 'Escape') {
+          onOutsideClick();
+        }
+      };
+      if (root) {
+        root.addEventListener(
+          'mousedown',
+          handleClickOutside,
+        );
+        root.addEventListener('keydown', handleKeydown);
+      }
+    },
+    unbind() {
+      if (root) {
+        root.removeEventListener(
+          'mousedown',
+          handleClickOutside,
+        );
+        root.removeEventListener('keydown', handleKeydown);
+      }
+    }
+  };
+};