@revolugo/elements 5.5.3 → 5.5.4-beta.0

package/dist/revolugo.vselect.UcLk_jBF.min.js

@@ -0,0 +1,859 @@
+import { _ as r } from "./revolugo.vtextfield.D2qOTbGQ.min.js";
+import { _ as y } from "./revolugo.vchip.BcIMSmkF.min.js";
+import { _ as b } from "./revolugo.vmenu.CtMz9t6s.min.js";
+import { r as p, C as S } from "./revolugo.vuetify.yojzDMFk.min.js";
+import { V as f } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { _ } from "./revolugo.index.sTY3URQu.min.js";
+import { C as u, T as g, c as m, m as v } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { C as T, s as h, p as k, t as I, k as l } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { _ as D } from "./revolugo.parsed-props.B_x1Ob04.min.js";
+import { a as V, V as A } from "./revolugo.index.DTZNxZHf.min.js";
+import { a as d, _ as M } from "./revolugo.vlistitem.CrJxrMpP.min.js";
+import { V as E } from "./revolugo.vinput.CDpcVlCU.min.js";
+import { C as w } from "./revolugo.index.CQC_pZJn.min.js";
+import { D as L } from "./revolugo.index.A8BtC3Nq.min.js";
+function C(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const t = import.meta.url, s = t.slice(0, t.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(s);
+      for (const i of REVOLUGO_ELEMENTS_STYLES.components)
+        i(s);
+      if (e.indexOf("fonts") >= 0) {
+        const i = document.createElement("link");
+        i.rel = "stylesheet", linK.href = s, document.head.appendChild(i);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+const O = f.extend({
+  name: "v-simple-checkbox",
+  functional: !0,
+  directives: {
+    Ripple: p
+  },
+  props: {
+    ...u.options.props,
+    ...g.options.props,
+    disabled: Boolean,
+    ripple: {
+      type: Boolean,
+      default: !0
+    },
+    value: Boolean,
+    indeterminate: Boolean,
+    indeterminateIcon: {
+      type: String,
+      default: "$checkboxIndeterminate"
+    },
+    onIcon: {
+      type: String,
+      default: "$checkboxOn"
+    },
+    offIcon: {
+      type: String,
+      default: "$checkboxOff"
+    }
+  },
+  render(e, {
+    props: t,
+    data: s,
+    listeners: i
+  }) {
+    const n = [];
+    let a = t.offIcon;
+    if (t.indeterminate ? a = t.indeterminateIcon : t.value && (a = t.onIcon), n.push(e(_, u.options.methods.setTextColor(t.value && t.color, {
+      props: {
+        disabled: t.disabled,
+        dark: t.dark,
+        light: t.light
+      }
+    }), a)), t.ripple && !t.disabled) {
+      const o = e("div", u.options.methods.setTextColor(t.color, {
+        staticClass: "v-input--selection-controls__ripple",
+        directives: [{
+          def: p,
+          name: "ripple",
+          value: {
+            center: !0
+          }
+        }]
+      }));
+      n.push(o);
+    }
+    return e("div", m(s, {
+      class: {
+        "v-simple-checkbox": !0,
+        "v-simple-checkbox--disabled": t.disabled
+      },
+      on: {
+        click: (o) => {
+          o.stopPropagation(), s.on && s.on.input && !t.disabled && T(s.on.input).forEach((c) => c(!t.value));
+        }
+      }
+    }), [e("div", {
+      staticClass: "v-input--selection-controls__input"
+    }, n)]);
+  }
+}), B = v(
+  g
+  /* @vue/component */
+).extend({
+  name: "v-subheader",
+  props: {
+    inset: Boolean
+  },
+  render(e) {
+    return e("div", {
+      staticClass: "v-subheader",
+      class: {
+        "v-subheader--inset": this.inset,
+        ...this.themeClasses
+      },
+      attrs: this.$attrs,
+      on: this.$listeners
+    }, this.$slots.default);
+  }
+}), P = f.extend({
+  name: "v-list-item-action",
+  functional: !0,
+  render(e, {
+    data: t,
+    children: s = []
+  }) {
+    return t.staticClass = t.staticClass ? `v-list-item__action ${t.staticClass}` : "v-list-item__action", s.filter((n) => n.isComment === !1 && n.text !== " ").length > 1 && (t.staticClass += " v-list-item__action--stack"), e("div", t, s);
+  }
+}), x = v(u, g).extend({
+  name: "v-select-list",
+  // https://github.com/vuejs/vue/issues/6872
+  directives: {
+    ripple: p
+  },
+  props: {
+    action: Boolean,
+    dense: Boolean,
+    hideSelected: Boolean,
+    items: {
+      type: Array,
+      default: () => []
+    },
+    itemDisabled: {
+      type: [String, Array, Function],
+      default: "disabled"
+    },
+    itemText: {
+      type: [String, Array, Function],
+      default: "text"
+    },
+    itemValue: {
+      type: [String, Array, Function],
+      default: "value"
+    },
+    noDataText: String,
+    noFilter: Boolean,
+    searchInput: null,
+    selectedItems: {
+      type: Array,
+      default: () => []
+    }
+  },
+  computed: {
+    parsedItems() {
+      return this.selectedItems.map((e) => this.getValue(e));
+    },
+    tileActiveClass() {
+      return Object.keys(this.setTextColor(this.color).class || {}).join(" ");
+    },
+    staticNoDataTile() {
+      const e = {
+        attrs: {
+          role: void 0
+        },
+        on: {
+          mousedown: (t) => t.preventDefault()
+          // Prevent onBlur from being called
+        }
+      };
+      return this.$createElement(d, e, [this.genTileContent(this.noDataText)]);
+    }
+  },
+  methods: {
+    genAction(e, t) {
+      return this.$createElement(P, [this.$createElement(O, {
+        props: {
+          color: this.color,
+          value: t,
+          ripple: !1
+        },
+        on: {
+          input: () => this.$emit("select", e)
+        }
+      })]);
+    },
+    genDivider(e) {
+      return this.$createElement(D, {
+        props: e
+      });
+    },
+    genFilteredText(e) {
+      if (e = e || "", !this.searchInput || this.noFilter)
+        return e;
+      const {
+        start: t,
+        middle: s,
+        end: i
+      } = this.getMaskedCharacters(e);
+      return [t, this.genHighlight(s), i];
+    },
+    genHeader(e) {
+      return this.$createElement(B, {
+        props: e
+      }, e.header);
+    },
+    genHighlight(e) {
+      return this.$createElement("span", {
+        staticClass: "v-list-item__mask"
+      }, e);
+    },
+    getMaskedCharacters(e) {
+      const t = (this.searchInput || "").toString().toLocaleLowerCase(), s = e.toLocaleLowerCase().indexOf(t);
+      if (s < 0)
+        return {
+          start: e,
+          middle: "",
+          end: ""
+        };
+      const i = e.slice(0, s), n = e.slice(s, s + t.length), a = e.slice(s + t.length);
+      return {
+        start: i,
+        middle: n,
+        end: a
+      };
+    },
+    genTile({
+      item: e,
+      index: t,
+      disabled: s = null,
+      value: i = !1
+    }) {
+      i || (i = this.hasItem(e)), e === Object(e) && (s = s !== null ? s : this.getDisabled(e));
+      const n = {
+        attrs: {
+          // Default behavior in list does not
+          // contain aria-selected by default
+          "aria-selected": String(i),
+          id: `list-item-${this._uid}-${t}`,
+          role: "option"
+        },
+        on: {
+          mousedown: (c) => {
+            c.preventDefault();
+          },
+          click: () => s || this.$emit("select", e)
+        },
+        props: {
+          activeClass: this.tileActiveClass,
+          disabled: s,
+          ripple: !0,
+          inputValue: i
+        }
+      };
+      if (!this.$scopedSlots.item)
+        return this.$createElement(d, n, [this.action && !this.hideSelected && this.items.length > 0 ? this.genAction(e, i) : null, this.genTileContent(e, t)]);
+      const a = this, o = this.$scopedSlots.item({
+        parent: a,
+        item: e,
+        attrs: {
+          ...n.attrs,
+          ...n.props
+        },
+        on: n.on
+      });
+      return this.needsTile(o) ? this.$createElement(d, n, o) : o;
+    },
+    genTileContent(e, t = 0) {
+      return this.$createElement(V, [this.$createElement(A, [this.genFilteredText(this.getText(e))])]);
+    },
+    hasItem(e) {
+      return this.parsedItems.indexOf(this.getValue(e)) > -1;
+    },
+    needsTile(e) {
+      return e.length !== 1 || e[0].componentOptions == null || e[0].componentOptions.Ctor.options.name !== "v-list-item";
+    },
+    getDisabled(e) {
+      return !!h(e, this.itemDisabled, !1);
+    },
+    getText(e) {
+      return String(h(e, this.itemText, e));
+    },
+    getValue(e) {
+      return h(e, this.itemValue, this.getText(e));
+    }
+  },
+  render() {
+    const e = [], t = this.items.length;
+    for (let s = 0; s < t; s++) {
+      const i = this.items[s];
+      this.hideSelected && this.hasItem(i) || (i == null ? e.push(this.genTile({
+        item: i,
+        index: s
+      })) : i.header ? e.push(this.genHeader(i)) : i.divider ? e.push(this.genDivider(i)) : e.push(this.genTile({
+        item: i,
+        index: s
+      })));
+    }
+    return e.length || e.push(this.$slots["no-data"] || this.staticNoDataTile), this.$slots["prepend-item"] && e.unshift(this.$slots["prepend-item"]), this.$slots["append-item"] && e.push(this.$slots["append-item"]), this.$createElement(M, {
+      staticClass: "v-select-list",
+      class: this.themeClasses,
+      attrs: {
+        role: "listbox",
+        tabindex: -1
+      },
+      props: {
+        dense: this.dense
+      }
+    }, e);
+  }
+}), F = f.extend({
+  name: "filterable",
+  props: {
+    noDataText: {
+      type: String,
+      default: "$vuetify.noDataText"
+    }
+  }
+}), $ = {
+  closeOnClick: !1,
+  closeOnContentClick: !1,
+  disableKeys: !0,
+  openOnClick: !1,
+  maxHeight: 304
+}, H = v(r, w, L, F), ee = H.extend().extend({
+  name: "v-select",
+  directives: {
+    ClickOutside: S
+  },
+  props: {
+    appendIcon: {
+      type: String,
+      default: "$dropdown"
+    },
+    attach: {
+      type: null,
+      default: !1
+    },
+    cacheItems: Boolean,
+    chips: Boolean,
+    clearable: Boolean,
+    deletableChips: Boolean,
+    disableLookup: Boolean,
+    eager: Boolean,
+    hideSelected: Boolean,
+    items: {
+      type: Array,
+      default: () => []
+    },
+    itemColor: {
+      type: String,
+      default: "primary"
+    },
+    itemDisabled: {
+      type: [String, Array, Function],
+      default: "disabled"
+    },
+    itemText: {
+      type: [String, Array, Function],
+      default: "text"
+    },
+    itemValue: {
+      type: [String, Array, Function],
+      default: "value"
+    },
+    menuProps: {
+      type: [String, Array, Object],
+      default: () => $
+    },
+    multiple: Boolean,
+    openOnClear: Boolean,
+    returnObject: Boolean,
+    smallChips: Boolean
+  },
+  data() {
+    return {
+      cachedItems: this.cacheItems ? this.items : [],
+      menuIsBooted: !1,
+      isMenuActive: !1,
+      lastItem: 20,
+      // As long as a value is defined, show it
+      // Otherwise, check if multiple
+      // to determine which default to provide
+      lazyValue: this.value !== void 0 ? this.value : this.multiple ? [] : void 0,
+      selectedIndex: -1,
+      selectedItems: [],
+      keyboardLookupPrefix: "",
+      keyboardLookupLastTime: 0
+    };
+  },
+  computed: {
+    /* All items that the select has */
+    allItems() {
+      return this.filterDuplicates(this.cachedItems.concat(this.items));
+    },
+    classes() {
+      return {
+        ...r.options.computed.classes.call(this),
+        "v-select": !0,
+        "v-select--chips": this.hasChips,
+        "v-select--chips--small": this.smallChips,
+        "v-select--is-menu-active": this.isMenuActive,
+        "v-select--is-multi": this.multiple
+      };
+    },
+    /* Used by other components to overwrite */
+    computedItems() {
+      return this.allItems;
+    },
+    computedOwns() {
+      return `list-${this._uid}`;
+    },
+    computedCounterValue() {
+      var e;
+      const t = this.multiple ? this.selectedItems : ((e = this.getText(this.selectedItems[0])) !== null && e !== void 0 ? e : "").toString();
+      return typeof this.counterValue == "function" ? this.counterValue(t) : t.length;
+    },
+    directives() {
+      return this.isFocused ? [{
+        name: "click-outside",
+        value: {
+          handler: this.blur,
+          closeConditional: this.closeConditional,
+          include: () => this.getOpenDependentElements()
+        }
+      }] : void 0;
+    },
+    dynamicHeight() {
+      return "auto";
+    },
+    hasChips() {
+      return this.chips || this.smallChips;
+    },
+    hasSlot() {
+      return !!(this.hasChips || this.$scopedSlots.selection);
+    },
+    isDirty() {
+      return this.selectedItems.length > 0;
+    },
+    listData() {
+      const e = this.$vnode && this.$vnode.context.$options._scopeId;
+      return {
+        attrs: {
+          ...e ? {
+            [e]: !0
+          } : {},
+          id: this.computedOwns
+        },
+        props: {
+          action: this.multiple,
+          color: this.itemColor,
+          dense: this.dense,
+          hideSelected: this.hideSelected,
+          items: this.virtualizedItems,
+          itemDisabled: this.itemDisabled,
+          itemText: this.itemText,
+          itemValue: this.itemValue,
+          noDataText: this.$vuetify.lang.t(this.noDataText),
+          selectedItems: this.selectedItems
+        },
+        on: {
+          select: this.selectItem
+        },
+        scopedSlots: {
+          item: this.$scopedSlots.item
+        }
+      };
+    },
+    staticList() {
+      return (this.$slots["no-data"] || this.$slots["prepend-item"] || this.$slots["append-item"]) && k("assert: staticList should not be called if slots are used"), this.$createElement(x, this.listData);
+    },
+    virtualizedItems() {
+      return this.$_menuProps.auto ? this.computedItems : this.computedItems.slice(0, this.lastItem);
+    },
+    menuCanShow: () => !0,
+    $_menuProps() {
+      let e = typeof this.menuProps == "string" ? this.menuProps.split(",") : this.menuProps;
+      return Array.isArray(e) && (e = e.reduce((t, s) => (t[s.trim()] = !0, t), {})), {
+        ...$,
+        eager: this.eager,
+        value: this.menuCanShow && this.isMenuActive,
+        nudgeBottom: e.offsetY ? 1 : 0,
+        ...e
+      };
+    }
+  },
+  watch: {
+    internalValue(e) {
+      this.initialValue = e, this.setSelectedItems(), this.multiple && this.$nextTick(() => {
+        var t;
+        (t = this.$refs.menu) === null || t === void 0 || t.updateDimensions();
+      }), this.hideSelected && this.$nextTick(() => {
+        this.onScroll();
+      });
+    },
+    isMenuActive(e) {
+      window.setTimeout(() => this.onMenuActiveChange(e));
+    },
+    items: {
+      immediate: !0,
+      handler(e) {
+        this.cacheItems && this.$nextTick(() => {
+          this.cachedItems = this.filterDuplicates(this.cachedItems.concat(e));
+        }), this.setSelectedItems();
+      }
+    }
+  },
+  methods: {
+    /** @public */
+    blur(e) {
+      r.options.methods.blur.call(this, e), this.isMenuActive = !1, this.isFocused = !1, this.selectedIndex = -1, this.setMenuIndex(-1);
+    },
+    /** @public */
+    activateMenu() {
+      !this.isInteractive || this.isMenuActive || (this.isMenuActive = !0);
+    },
+    clearableCallback() {
+      this.setValue(this.multiple ? [] : null), this.setMenuIndex(-1), this.$nextTick(() => this.$refs.input && this.$refs.input.focus()), this.openOnClear && (this.isMenuActive = !0);
+    },
+    closeConditional(e) {
+      return this.isMenuActive ? !this._isDestroyed && // Click originates from outside the menu content
+      // Multiple selects don't close when an item is clicked
+      (!this.getContent() || !this.getContent().contains(e.target)) && // Click originates from outside the element
+      this.$el && !this.$el.contains(e.target) && e.target !== this.$el : !0;
+    },
+    filterDuplicates(e) {
+      const t = /* @__PURE__ */ new Map();
+      for (let s = 0; s < e.length; ++s) {
+        const i = e[s];
+        if (i == null)
+          continue;
+        if (i.header || i.divider) {
+          t.set(i, i);
+          continue;
+        }
+        const n = this.getValue(i);
+        !t.has(n) && t.set(n, i);
+      }
+      return Array.from(t.values());
+    },
+    findExistingIndex(e) {
+      const t = this.getValue(e);
+      return (this.internalValue || []).findIndex((s) => this.valueComparator(this.getValue(s), t));
+    },
+    getContent() {
+      return this.$refs.menu && this.$refs.menu.$refs.content;
+    },
+    genChipSelection(e, t) {
+      const s = this.isDisabled || this.getDisabled(e), i = !s && this.isInteractive;
+      return this.$createElement(y, {
+        staticClass: "v-chip--select",
+        attrs: {
+          tabindex: -1
+        },
+        props: {
+          close: this.deletableChips && i,
+          disabled: s,
+          inputValue: t === this.selectedIndex,
+          small: this.smallChips
+        },
+        on: {
+          click: (n) => {
+            i && (n.stopPropagation(), this.selectedIndex = t);
+          },
+          "click:close": () => this.onChipInput(e)
+        },
+        key: JSON.stringify(this.getValue(e))
+      }, this.getText(e));
+    },
+    genCommaSelection(e, t, s) {
+      const i = t === this.selectedIndex && this.computedColor, n = this.isDisabled || this.getDisabled(e);
+      return this.$createElement("div", this.setTextColor(i, {
+        staticClass: "v-select__selection v-select__selection--comma",
+        class: {
+          "v-select__selection--disabled": n
+        },
+        key: JSON.stringify(this.getValue(e))
+      }), `${this.getText(e)}${s ? "" : ", "}`);
+    },
+    genDefaultSlot() {
+      const e = this.genSelections(), t = this.genInput();
+      return Array.isArray(e) ? e.push(t) : (e.children = e.children || [], e.children.push(t)), [this.genFieldset(), this.$createElement("div", {
+        staticClass: "v-select__slot",
+        directives: this.directives
+      }, [this.genLabel(), this.prefix ? this.genAffix("prefix") : null, e, this.suffix ? this.genAffix("suffix") : null, this.genClearIcon(), this.genIconSlot(), this.genHiddenInput()]), this.genMenu(), this.genProgress()];
+    },
+    genIcon(e, t, s) {
+      const i = E.options.methods.genIcon.call(this, e, t, s);
+      return e === "append" && (i.children[0].data = m(i.children[0].data, {
+        attrs: {
+          tabindex: i.children[0].componentOptions.listeners && "-1",
+          "aria-hidden": "true",
+          "aria-label": void 0
+        }
+      })), i;
+    },
+    genInput() {
+      const e = r.options.methods.genInput.call(this);
+      return delete e.data.attrs.name, e.data = m(e.data, {
+        domProps: {
+          value: null
+        },
+        attrs: {
+          readonly: !0,
+          type: "text",
+          "aria-readonly": String(this.isReadonly),
+          "aria-activedescendant": I(this.$refs.menu, "activeTile.id"),
+          autocomplete: I(e.data, "attrs.autocomplete", "off"),
+          placeholder: !this.isDirty && (this.persistentPlaceholder || this.isFocused || !this.hasLabel) ? this.placeholder : void 0
+        },
+        on: {
+          keypress: this.onKeyPress
+        }
+      }), e;
+    },
+    genHiddenInput() {
+      return this.$createElement("input", {
+        domProps: {
+          value: this.lazyValue
+        },
+        attrs: {
+          type: "hidden",
+          name: this.attrs$.name
+        }
+      });
+    },
+    genInputSlot() {
+      const e = r.options.methods.genInputSlot.call(this);
+      return e.data.attrs = {
+        ...e.data.attrs,
+        role: "button",
+        "aria-haspopup": "listbox",
+        "aria-expanded": String(this.isMenuActive),
+        "aria-owns": this.computedOwns
+      }, e;
+    },
+    genList() {
+      return this.$slots["no-data"] || this.$slots["prepend-item"] || this.$slots["append-item"] ? this.genListWithSlot() : this.staticList;
+    },
+    genListWithSlot() {
+      const e = ["prepend-item", "no-data", "append-item"].filter((t) => this.$slots[t]).map((t) => this.$createElement("template", {
+        slot: t
+      }, this.$slots[t]));
+      return this.$createElement(x, {
+        ...this.listData
+      }, e);
+    },
+    genMenu() {
+      const e = this.$_menuProps;
+      return e.activator = this.$refs["input-slot"], "attach" in e || (// TODO: make this a computed property or helper or something
+      this.attach === "" || // If used as a boolean prop (<v-menu attach>)
+      this.attach === !0 || // If bound to a boolean (<v-menu :attach="true">)
+      this.attach === "attach" ? e.attach = this.$el : e.attach = this.attach), this.$createElement(b, {
+        attrs: {
+          role: void 0
+        },
+        props: e,
+        on: {
+          input: (t) => {
+            this.isMenuActive = t, this.isFocused = t;
+          },
+          scroll: this.onScroll
+        },
+        ref: "menu"
+      }, [this.genList()]);
+    },
+    genSelections() {
+      let e = this.selectedItems.length;
+      const t = new Array(e);
+      let s;
+      for (this.$scopedSlots.selection ? s = this.genSlotSelection : this.hasChips ? s = this.genChipSelection : s = this.genCommaSelection; e--; )
+        t[e] = s(this.selectedItems[e], e, e === t.length - 1);
+      return this.$createElement("div", {
+        staticClass: "v-select__selections"
+      }, t);
+    },
+    genSlotSelection(e, t) {
+      return this.$scopedSlots.selection({
+        attrs: {
+          class: "v-chip--select"
+        },
+        parent: this,
+        item: e,
+        index: t,
+        select: (s) => {
+          s.stopPropagation(), this.selectedIndex = t;
+        },
+        selected: t === this.selectedIndex,
+        disabled: !this.isInteractive
+      });
+    },
+    getMenuIndex() {
+      return this.$refs.menu ? this.$refs.menu.listIndex : -1;
+    },
+    getDisabled(e) {
+      return h(e, this.itemDisabled, !1);
+    },
+    getText(e) {
+      return h(e, this.itemText, e);
+    },
+    getValue(e) {
+      return h(e, this.itemValue, this.getText(e));
+    },
+    onBlur(e) {
+      e && this.$emit("blur", e);
+    },
+    onChipInput(e) {
+      this.multiple ? this.selectItem(e) : this.setValue(null), this.selectedItems.length === 0 ? this.isMenuActive = !0 : this.isMenuActive = !1, this.selectedIndex = -1;
+    },
+    onClick(e) {
+      this.isInteractive && (this.isAppendInner(e.target) || (this.isMenuActive = !0), this.isFocused || (this.isFocused = !0, this.$emit("focus")), this.$emit("click", e));
+    },
+    onEscDown(e) {
+      e.preventDefault(), this.isMenuActive && (e.stopPropagation(), this.isMenuActive = !1);
+    },
+    onKeyPress(e) {
+      if (this.multiple || !this.isInteractive || this.disableLookup || e.key.length > 1 || e.ctrlKey || e.metaKey || e.altKey)
+        return;
+      const t = 1e3, s = performance.now();
+      s - this.keyboardLookupLastTime > t && (this.keyboardLookupPrefix = ""), this.keyboardLookupPrefix += e.key.toLowerCase(), this.keyboardLookupLastTime = s;
+      const i = this.allItems.findIndex((a) => {
+        var o;
+        return ((o = this.getText(a)) !== null && o !== void 0 ? o : "").toString().toLowerCase().startsWith(this.keyboardLookupPrefix);
+      }), n = this.allItems[i];
+      i !== -1 && (this.lastItem = Math.max(this.lastItem, i + 5), this.setValue(this.returnObject ? n : this.getValue(n)), this.$nextTick(() => this.$refs.menu.getTiles()), setTimeout(() => this.setMenuIndex(i)));
+    },
+    onKeyDown(e) {
+      if (this.isReadonly && e.keyCode !== l.tab)
+        return;
+      const t = e.keyCode, s = this.$refs.menu;
+      if (this.$emit("keydown", e), !!s) {
+        if (this.isMenuActive && [l.up, l.down, l.home, l.end, l.enter].includes(t) && this.$nextTick(() => {
+          s.changeListIndex(e), this.$emit("update:list-index", s.listIndex);
+        }), [l.enter, l.space].includes(t) && this.activateMenu(), !this.isMenuActive && [l.up, l.down, l.home, l.end].includes(t))
+          return this.onUpDown(e);
+        if (t === l.esc)
+          return this.onEscDown(e);
+        if (t === l.tab)
+          return this.onTabDown(e);
+        if (t === l.space)
+          return this.onSpaceDown(e);
+      }
+    },
+    onMenuActiveChange(e) {
+      if (this.multiple && !e || this.getMenuIndex() > -1)
+        return;
+      const t = this.$refs.menu;
+      if (!(!t || !this.isDirty)) {
+        this.$refs.menu.getTiles();
+        for (let s = 0; s < t.tiles.length; s++)
+          if (t.tiles[s].getAttribute("aria-selected") === "true") {
+            this.setMenuIndex(s);
+            break;
+          }
+      }
+    },
+    onMouseUp(e) {
+      this.hasMouseDown && e.which !== 3 && this.isInteractive && this.isAppendInner(e.target) && this.$nextTick(() => this.isMenuActive = !this.isMenuActive), r.options.methods.onMouseUp.call(this, e);
+    },
+    onScroll() {
+      if (!this.isMenuActive)
+        requestAnimationFrame(() => {
+          const e = this.getContent();
+          e && (e.scrollTop = 0);
+        });
+      else {
+        if (this.lastItem > this.computedItems.length)
+          return;
+        this.getContent().scrollHeight - (this.getContent().scrollTop + this.getContent().clientHeight) < 200 && (this.lastItem += 20);
+      }
+    },
+    onSpaceDown(e) {
+      e.preventDefault();
+    },
+    onTabDown(e) {
+      const t = this.$refs.menu;
+      if (!t)
+        return;
+      const s = t.activeTile;
+      !this.multiple && s && this.isMenuActive ? (e.preventDefault(), e.stopPropagation(), s.click()) : this.blur(e);
+    },
+    onUpDown(e) {
+      const t = this.$refs.menu;
+      if (!t)
+        return;
+      if (e.preventDefault(), this.multiple)
+        return this.activateMenu();
+      const s = e.keyCode;
+      t.isBooted = !0, window.requestAnimationFrame(() => {
+        if (t.getTiles(), !t.hasClickableTiles)
+          return this.activateMenu();
+        switch (s) {
+          case l.up:
+            t.prevTile();
+            break;
+          case l.down:
+            t.nextTile();
+            break;
+          case l.home:
+            t.firstTile();
+            break;
+          case l.end:
+            t.lastTile();
+            break;
+        }
+        this.selectItem(this.allItems[this.getMenuIndex()]);
+      });
+    },
+    selectItem(e) {
+      if (!this.multiple)
+        this.setValue(this.returnObject ? e : this.getValue(e)), this.isMenuActive = !1;
+      else {
+        const t = (this.internalValue || []).slice(), s = this.findExistingIndex(e);
+        if (s !== -1 ? t.splice(s, 1) : t.push(e), this.setValue(t.map((i) => this.returnObject ? i : this.getValue(i))), this.hideSelected)
+          this.setMenuIndex(-1);
+        else {
+          const i = this.allItems.indexOf(e);
+          ~i && (this.$nextTick(() => this.$refs.menu.getTiles()), setTimeout(() => this.setMenuIndex(i)));
+        }
+      }
+    },
+    setMenuIndex(e) {
+      this.$refs.menu && (this.$refs.menu.listIndex = e);
+    },
+    setSelectedItems() {
+      const e = [], t = !this.multiple || !Array.isArray(this.internalValue) ? [this.internalValue] : this.internalValue;
+      for (const s of t) {
+        const i = this.allItems.findIndex((n) => this.valueComparator(this.getValue(n), this.getValue(s)));
+        i > -1 && e.push(this.allItems[i]);
+      }
+      this.selectedItems = e;
+    },
+    setValue(e) {
+      this.valueComparator(e, this.internalValue) || (this.internalValue = e, this.$emit("change", e));
+    },
+    isAppendInner(e) {
+      const t = this.$refs["append-inner"];
+      return t && (t === e || t.contains(e));
+    }
+  }
+});
+C("css/revolugo.vselect.DljSkk6y.css");
+export {
+  ee as _,
+  $ as d
+};
+//# sourceMappingURL=revolugo.vselect.UcLk_jBF.min.js.map