@tagplus/components 5.2.19 → 5.3.0

package/dist/lib/src/components/Autosuggest/Autosuggest.vue.js

@@ -0,0 +1,446 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const core = require("./core.js");
+const autosuggestProps = require("./autosuggest-props.js");
+;/* empty css                  */
+const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const autosuggestDefinition = core.default("TpAutosuggest", autosuggestProps.default);
+const _sfc_main = vue.defineComponent(autosuggestDefinition);
+const _hoisted_1 = {
+  ref: "selectionRef",
+  class: "el-select__selection"
+};
+const _hoisted_2 = {
+  class: /* @__PURE__ */ vue.normalizeClass(["el-select__input-wrapper"])
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "el-input el-input-group el-input-group--append el-input-group--prepend el-select__input"
+};
+const _hoisted_4 = { class: "el-input-group__prepend" };
+const _hoisted_5 = { class: "el-input__wrapper" };
+const _hoisted_6 = ["id", "size", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label", "name"];
+const _hoisted_7 = { class: "el-input-group__append" };
+const _hoisted_8 = ["id"];
+const _hoisted_9 = {
+  key: 1,
+  class: "el-input el-select__input is-disabled"
+};
+const _hoisted_10 = { class: "el-input__wrapper" };
+const _hoisted_11 = ["id"];
+const _hoisted_12 = {
+  key: 0,
+  class: "el-select-dropdown__loading"
+};
+const _hoisted_13 = {
+  key: 1,
+  class: "el-select-dropdown__empty"
+};
+const _hoisted_14 = {
+  key: 2,
+  class: "el-select-dropdown__footer"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_divider = vue.resolveComponent("el-divider");
+  const _component_el_tag = vue.resolveComponent("el-tag");
+  const _component_el_tooltip = vue.resolveComponent("el-tooltip");
+  const _component_el_icon = vue.resolveComponent("el-icon");
+  const _component_ArrowDown = vue.resolveComponent("ArrowDown");
+  const _component_el_row = vue.resolveComponent("el-row");
+  const _component_el_option = vue.resolveComponent("el-option");
+  const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
+  const _component_el_select_menu = vue.resolveComponent("el-select-menu");
+  const _directive_click_outside = vue.resolveDirective("click-outside");
+  return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
+    ref: "selectRef",
+    class: vue.normalizeClass(["tp-autosuggest", _ctx.nsSelect.b(), _ctx.nsSelect.m(_ctx.selectSize)]),
+    onMouseenter: _cache[14] || (_cache[14] = ($event) => _ctx.states.inputHovering = true),
+    onMouseleave: _cache[15] || (_cache[15] = ($event) => _ctx.states.inputHovering = false),
+    onClick: _cache[16] || (_cache[16] = vue.withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"]))
+  }, [
+    vue.createVNode(_component_el_tooltip, {
+      ref: "tooltipRef",
+      visible: _ctx.dropdownMenuVisible,
+      placement: _ctx.placement,
+      teleported: _ctx.teleported,
+      "popper-options": _ctx.popperOptions,
+      "popper-class": ["el-select__popper", _ctx.popperClass],
+      "fallback-placements": ["bottom-start", "top-start", "right", "left"],
+      effect: _ctx.effect,
+      pure: "",
+      trigger: "click",
+      transition: `${_ctx.nsSelect.namespace.value}-zoom-in-top`,
+      "stop-popper-mouse-event": false,
+      "gpu-acceleration": false,
+      persistent: _ctx.persistent,
+      onBeforeShow: _ctx.handleMenuEnter,
+      onHide: _cache[13] || (_cache[13] = ($event) => _ctx.states.isBeforeHide = false)
+    }, {
+      default: vue.withCtx(() => {
+        var _a;
+        return [
+          vue.createElementVNode("div", {
+            ref: "wrapperRef",
+            class: vue.normalizeClass([
+              _ctx.nsSelect.is("focused", _ctx.isFocused),
+              _ctx.nsSelect.is("hovering", _ctx.states.inputHovering),
+              _ctx.nsSelect.is("disabled", _ctx.selectDisabled)
+            ])
+          }, [
+            vue.createElementVNode("div", _hoisted_1, [
+              vue.createElementVNode("div", _hoisted_2, [
+                !_ctx.selectDisabled ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+                  vue.createElementVNode("div", _hoisted_4, [
+                    _cache[17] || (_cache[17] = vue.createElementVNode("div", { class: "tp-autosuggest-input-prepend-icon" }, [
+                      vue.createElementVNode("em", { class: "far fa-search" })
+                    ], -1)),
+                    vue.createVNode(_component_el_divider, {
+                      direction: "vertical",
+                      class: "tp-autosuggest-vertical-divider"
+                    })
+                  ]),
+                  vue.createElementVNode("div", _hoisted_5, [
+                    _ctx.multiple ? vue.renderSlot(_ctx.$slots, "tag", { key: 0 }, () => [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.showTagList, (item) => {
+                        return vue.openBlock(), vue.createElementBlock("div", {
+                          key: _ctx.getValueKey(item),
+                          class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
+                        }, [
+                          vue.createVNode(_component_el_tag, {
+                            closable: !_ctx.selectDisabled && !item.isDisabled,
+                            size: _ctx.collapseTagSize,
+                            type: _ctx.tagType,
+                            "disable-transitions": "",
+                            style: vue.normalizeStyle(_ctx.tagStyle),
+                            onClose: ($event) => _ctx.deleteTag($event, item)
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createElementVNode("span", {
+                                class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
+                              }, vue.toDisplayString(item.currentLabel), 3)
+                            ]),
+                            _: 2
+                          }, 1032, ["closable", "size", "type", "style", "onClose"])
+                        ], 2);
+                      }), 128)),
+                      _ctx.collapseTags && _ctx.states.selected.length > _ctx.maxCollapseTags ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
+                        key: 0,
+                        ref: "tagTooltipRef",
+                        disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
+                        "fallback-placements": ["bottom", "top", "right", "left"],
+                        effect: _ctx.effect,
+                        placement: "bottom",
+                        teleported: _ctx.teleported
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.createElementVNode("div", {
+                            ref: "collapseItemRef",
+                            class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
+                          }, [
+                            vue.createVNode(_component_el_tag, {
+                              closable: false,
+                              size: _ctx.collapseTagSize,
+                              type: _ctx.tagType,
+                              "disable-transitions": "",
+                              style: vue.normalizeStyle(_ctx.collapseTagStyle)
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createElementVNode("span", {
+                                  class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
+                                }, " + " + vue.toDisplayString(_ctx.states.selected.length - _ctx.maxCollapseTags), 3)
+                              ]),
+                              _: 1
+                            }, 8, ["size", "type", "style"])
+                          ], 2)
+                        ]),
+                        content: vue.withCtx(() => [
+                          vue.createElementVNode("div", {
+                            ref: "tagMenuRef",
+                            class: vue.normalizeClass(_ctx.nsSelect.e("selection"))
+                          }, [
+                            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.collapseTagList, (item) => {
+                              return vue.openBlock(), vue.createElementBlock("div", {
+                                key: _ctx.getValueKey(item),
+                                class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
+                              }, [
+                                vue.createVNode(_component_el_tag, {
+                                  class: "in-tooltip",
+                                  closable: !_ctx.selectDisabled && !item.isDisabled,
+                                  size: _ctx.collapseTagSize,
+                                  type: _ctx.tagType,
+                                  "disable-transitions": "",
+                                  onClose: ($event) => _ctx.deleteTag($event, item)
+                                }, {
+                                  default: vue.withCtx(() => [
+                                    vue.createElementVNode("span", {
+                                      class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
+                                    }, vue.toDisplayString(item.currentLabel), 3)
+                                  ]),
+                                  _: 2
+                                }, 1032, ["closable", "size", "type", "onClose"])
+                              ], 2);
+                            }), 128))
+                          ], 2)
+                        ]),
+                        _: 1
+                      }, 8, ["disabled", "effect", "teleported"])) : vue.createCommentVNode("", true)
+                    ], true) : vue.createCommentVNode("", true),
+                    vue.withDirectives(vue.createElementVNode("input", {
+                      id: `${_ctx.myId}-input`,
+                      ref: "inputRef",
+                      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.states.inputValue = $event),
+                      type: "text",
+                      class: vue.normalizeClass(["el-select__input el-input__inner", [_ctx.nsSelect.is(_ctx.selectSize)]]),
+                      autocomplete: "off",
+                      size: _ctx.selectSize,
+                      style: vue.normalizeStyle(_ctx.inputStyle),
+                      role: "combobox",
+                      spellcheck: "false",
+                      "aria-activedescendant": ((_a = _ctx.hoverOption) == null ? void 0 : _a.id) || "",
+                      "aria-controls": _ctx.contentId,
+                      "aria-expanded": _ctx.dropdownMenuVisible,
+                      "aria-label": _ctx.ariaLabel,
+                      "aria-autocomplete": "none",
+                      "aria-haspopup": "listbox",
+                      name: _ctx.name,
+                      onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
+                      onBlur: _cache[2] || (_cache[2] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
+                      onKeydown: [
+                        _cache[3] || (_cache[3] = vue.withKeys(vue.withModifiers(($event) => _ctx.navigateOptions("next"), ["stop", "prevent"]), ["down"])),
+                        _cache[4] || (_cache[4] = vue.withKeys(vue.withModifiers(($event) => _ctx.navigateOptions("prev"), ["stop", "prevent"]), ["up"])),
+                        _cache[5] || (_cache[5] = vue.withKeys(vue.withModifiers((...args) => _ctx.handleEsc && _ctx.handleEsc(...args), ["stop", "prevent"]), ["esc"])),
+                        _cache[6] || (_cache[6] = vue.withKeys(vue.withModifiers((...args) => _ctx.selectOption && _ctx.selectOption(...args), ["stop", "prevent"]), ["enter"])),
+                        _cache[7] || (_cache[7] = vue.withKeys(vue.withModifiers((...args) => _ctx.deletePrevTag && _ctx.deletePrevTag(...args), ["stop"]), ["delete"]))
+                      ],
+                      onCompositionstart: _cache[8] || (_cache[8] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
+                      onCompositionupdate: _cache[9] || (_cache[9] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
+                      onCompositionend: _cache[10] || (_cache[10] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
+                      onInput: _cache[11] || (_cache[11] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
+                      onClick: _cache[12] || (_cache[12] = vue.withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"]))
+                    }, null, 46, _hoisted_6), [
+                      [vue.vModelText, _ctx.states.inputValue]
+                    ]),
+                    _ctx.shouldShowPlaceholder ? (vue.openBlock(), vue.createElementBlock("div", {
+                      key: 1,
+                      class: vue.normalizeClass([
+                        _ctx.nsSelect.e("selected-item"),
+                        _ctx.nsSelect.e("placeholder"),
+                        _ctx.nsSelect.is("transparent", !_ctx.hasModelValue || _ctx.expanded && !_ctx.states.inputValue)
+                      ])
+                    }, [
+                      vue.createElementVNode("span", null, vue.toDisplayString(_ctx.currentPlaceholder), 1)
+                    ], 2)) : vue.createCommentVNode("", true)
+                  ]),
+                  vue.createElementVNode("div", _hoisted_7, [
+                    _ctx.states.selectedLabel ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
+                      key: 0,
+                      id: `${_ctx.myId}-btn-clear`,
+                      class: "tp-autosuggest-clear-icon fa fa-times-circle",
+                      onClick: vue.withModifiers(_ctx.clearTags, ["stop", "prevent"])
+                    }, null, 8, ["id", "onClick"])) : vue.createCommentVNode("", true),
+                    vue.createVNode(_component_el_row, {
+                      justify: _ctx.states.selectedLabel ? "space-between" : "end",
+                      align: "middle"
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_el_row, {
+                          align: "middle",
+                          justify: "space-around",
+                          class: "el-input__close"
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.createVNode(_component_el_divider, {
+                              direction: "vertical",
+                              class: "tp-autosuggest-vertical-divider"
+                            }),
+                            !_ctx.showClose ? (vue.openBlock(), vue.createElementBlock("div", {
+                              key: 0,
+                              id: `${_ctx.myId}-btn-close`,
+                              class: "tp-btn-close"
+                            }, [
+                              vue.createVNode(_component_el_icon, {
+                                class: vue.normalizeClass(["el-select__caret", "el-select__icon", _ctx.iconReverse])
+                              }, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(_component_ArrowDown)
+                                ]),
+                                _: 1
+                              }, 8, ["class"])
+                            ], 8, _hoisted_8)) : vue.createCommentVNode("", true)
+                          ]),
+                          _: 1
+                        })
+                      ]),
+                      _: 1
+                    }, 8, ["justify"])
+                  ])
+                ])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_9, [
+                  vue.createElementVNode("div", _hoisted_10, [
+                    _ctx.multiple ? vue.renderSlot(_ctx.$slots, "tag", { key: 0 }, () => [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.showTagList, (item) => {
+                        return vue.openBlock(), vue.createElementBlock("div", {
+                          key: _ctx.getValueKey(item),
+                          class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
+                        }, [
+                          vue.createVNode(_component_el_tag, {
+                            closable: false,
+                            size: _ctx.collapseTagSize,
+                            type: _ctx.tagType,
+                            "disable-transitions": "",
+                            style: vue.normalizeStyle(_ctx.tagStyle)
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createElementVNode("span", {
+                                class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
+                              }, vue.toDisplayString(item.currentLabel), 3)
+                            ]),
+                            _: 2
+                          }, 1032, ["size", "type", "style"])
+                        ], 2);
+                      }), 128)),
+                      _ctx.collapseTags && _ctx.states.selected.length > _ctx.maxCollapseTags ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
+                        key: 0,
+                        ref: "tagTooltipRef",
+                        disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
+                        "fallback-placements": ["bottom", "top", "right", "left"],
+                        effect: _ctx.effect,
+                        placement: "bottom",
+                        teleported: _ctx.teleported
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.createElementVNode("div", {
+                            ref: "collapseItemRef",
+                            class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
+                          }, [
+                            vue.createVNode(_component_el_tag, {
+                              closable: false,
+                              size: _ctx.collapseTagSize,
+                              type: _ctx.tagType,
+                              "disable-transitions": "",
+                              style: vue.normalizeStyle(_ctx.collapseTagStyle)
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createElementVNode("span", {
+                                  class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
+                                }, " + " + vue.toDisplayString(_ctx.states.selected.length - _ctx.maxCollapseTags), 3)
+                              ]),
+                              _: 1
+                            }, 8, ["size", "type", "style"])
+                          ], 2)
+                        ]),
+                        content: vue.withCtx(() => [
+                          vue.createElementVNode("div", {
+                            ref: "tagMenuRef",
+                            class: vue.normalizeClass(_ctx.nsSelect.e("selection"))
+                          }, [
+                            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.collapseTagList, (item) => {
+                              return vue.openBlock(), vue.createElementBlock("div", {
+                                key: _ctx.getValueKey(item),
+                                class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
+                              }, [
+                                vue.createVNode(_component_el_tag, {
+                                  class: "in-tooltip",
+                                  closable: false,
+                                  size: _ctx.collapseTagSize,
+                                  type: _ctx.tagType,
+                                  "disable-transitions": ""
+                                }, {
+                                  default: vue.withCtx(() => [
+                                    vue.createElementVNode("span", {
+                                      class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
+                                    }, vue.toDisplayString(item.currentLabel), 3)
+                                  ]),
+                                  _: 2
+                                }, 1032, ["size", "type"])
+                              ], 2);
+                            }), 128))
+                          ], 2)
+                        ]),
+                        _: 1
+                      }, 8, ["disabled", "effect", "teleported"])) : vue.createCommentVNode("", true)
+                    ], true) : vue.createCommentVNode("", true),
+                    _ctx.shouldShowPlaceholder ? (vue.openBlock(), vue.createElementBlock("div", {
+                      key: 1,
+                      class: vue.normalizeClass([
+                        _ctx.nsSelect.e("selected-item"),
+                        _ctx.nsSelect.e("placeholder"),
+                        _ctx.nsSelect.is("transparent", !_ctx.hasModelValue || _ctx.expanded && !_ctx.states.inputValue)
+                      ])
+                    }, [
+                      vue.createElementVNode("span", null, vue.toDisplayString(_ctx.currentPlaceholder), 1)
+                    ], 2)) : vue.createCommentVNode("", true)
+                  ])
+                ]))
+              ])
+            ], 512)
+          ], 2)
+        ];
+      }),
+      content: vue.withCtx(() => [
+        vue.createVNode(_component_el_select_menu, { ref: "menuRef" }, {
+          default: vue.withCtx(() => [
+            vue.withDirectives(vue.createVNode(_component_el_scrollbar, {
+              id: _ctx.contentId,
+              ref: "scrollbarRef",
+              tag: "ul",
+              "wrap-class": "el-select-dropdown__wrap",
+              "view-class": "el-select-dropdown__list",
+              class: vue.normalizeClass([_ctx.nsSelect.is("empty", _ctx.filteredOptionsCount === 0)]),
+              role: "listbox",
+              "aria-label": _ctx.ariaLabel,
+              "aria-orientation": "vertical"
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.suggestionsList, (item, i) => {
+                  return vue.openBlock(), vue.createBlock(_component_el_option, {
+                    id: `${_ctx.myId}-option-${i}`,
+                    key: i,
+                    label: item[_ctx.labelKey],
+                    value: item[_ctx.valueKey],
+                    item,
+                    created: item.created,
+                    class: vue.normalizeClass({ "created": item.created })
+                  }, {
+                    default: vue.withCtx(() => [
+                      item.created ? (vue.openBlock(), vue.createElementBlock("a", {
+                        key: 0,
+                        id: `${_ctx.myId}-btn-create`
+                      }, [
+                        _cache[18] || (_cache[18] = vue.createElementVNode("em", { class: "far fa-plus" }, null, -1)),
+                        vue.createTextVNode(" " + vue.toDisplayString(_ctx.newItem), 1)
+                      ], 8, _hoisted_11)) : vue.renderSlot(_ctx.$slots, "default", {
+                        key: 1,
+                        item
+                      }, void 0, true)
+                    ]),
+                    _: 2
+                  }, 1032, ["id", "label", "value", "item", "created", "class"]);
+                }), 128))
+              ]),
+              _: 3
+            }, 8, ["id", "class", "aria-label"]), [
+              [vue.vShow, _ctx.states.options.size > 0 && !_ctx.loading]
+            ]),
+            _ctx.$slots.loading && _ctx.loading ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_12, [
+              vue.renderSlot(_ctx.$slots, "loading", {}, void 0, true)
+            ])) : _ctx.loading || _ctx.filteredOptionsCount === 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_13, [
+              vue.renderSlot(_ctx.$slots, "empty", {}, () => [
+                vue.createElementVNode("span", null, vue.toDisplayString(_ctx.emptyText), 1)
+              ], true)
+            ])) : vue.createCommentVNode("", true),
+            _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_14, [
+              vue.renderSlot(_ctx.$slots, "footer", {}, void 0, true)
+            ])) : vue.createCommentVNode("", true)
+          ]),
+          _: 3
+        }, 512)
+      ]),
+      _: 3
+    }, 8, ["visible", "placement", "teleported", "popper-options", "popper-class", "effect", "transition", "persistent", "onBeforeShow"])
+  ], 34)), [
+    [_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
+  ]);
+}
+const Autosuggest = /* @__PURE__ */ _pluginVue_exportHelper.default(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-8f8ea081"]]);
+exports.default = Autosuggest;

package/dist/lib/src/components/Autosuggest/Multisuggest.vue.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const Autosuggest = require("./Autosuggest.vue.js");
+const core = require("./core.js");
+const multisuggestProps = require("./multisuggest-props.js");
+;/* empty css                   */
+const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const multisuggestDefinition = core.default("TpMultisuggest", multisuggestProps.default);
+const _sfc_main = vue.defineComponent(
+  {
+    ...multisuggestDefinition,
+    extends: Autosuggest.default
+  }
+);
+const Multisuggest = /* @__PURE__ */ _pluginVue_exportHelper.default(_sfc_main, [["__scopeId", "data-v-959c4f16"]]);
+exports.default = Multisuggest;

package/dist/lib/src/components/Autosuggest/autosuggest-props.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const enums = require("../../../node_modules/@popperjs/core/lib/enums.js");
+const autosuggestProps = {
+  /**
+   * @deprecated
+   * Faz o retorno do input imitar o comportamento antigo que voltava idValue/[...idValues] se recebesse modelValue Object/[...Objects]
+   * na versão nova vai sempre devolver o Objeto completo quando possível
+   */
+  legacyModel: {
+    type: Boolean,
+    default: false
+  },
+  /**
+  * @description native input id
+  */
+  id: String,
+  /**
+  * @description the name attribute of select input
+  */
+  name: String,
+  modelValue: {
+    type: [Array, String, Number, Boolean, Object],
+    default: ""
+  },
+  /**
+   * Lista ou Objeto contendo conjunto de itens como opções ou sugestões do componente
+   */
+  suggestions: {
+    type: [Array, Object],
+    required: true
+  },
+  /**
+   * Informa o campo correspondente em cada item referente ao valor sendo selecionado
+   */
+  valueKey: {
+    type: String,
+    default: "id"
+  },
+  /**
+   * Identificação do campo correspondente em cada item referente ao texto de exibição.
+   * Quando utilizado o slot de itens, este campo passa a não ser utilizado
+   */
+  labelKey: {
+    type: String,
+    default: "label"
+  },
+  /**
+  * @description placeholder, default is 'Select'
+  */
+  placeholder: {
+    type: String
+  },
+  /**
+   * Sobrescreve valor padrão do atributo no Select do ElementUI
+   */
+  defaultFirstOption: {
+    type: Boolean,
+    required: false,
+    default: true
+  },
+  /**
+   * Se a lista vai ser carregada no create ou o labelKey não venha por padrão na requisição loadOnCreate = true,
+   * caso deva ser carregada quando o usuário clica deixar vazio ou false.
+   */
+  loadOnCreate: {
+    type: Boolean,
+    required: false,
+    default: true
+  },
+  /**
+   * Método que realiza a busca dos registros remotos para as opções.
+   *
+   * *IMPORTANTE*: deve considerar o "valueKey" nas consultas
+   * pois o valor selecionado será baseado nas opções remotas carregadas ao criar o componente.
+   */
+  remoteMethod: {
+    type: Function,
+    required: true
+  },
+  /**
+   * Informa a mensagem de cadastrar novo item
+   */
+  msgNewItem: {
+    type: String,
+    required: false,
+    default: "Cadastrar novo item"
+  },
+  /**
+  * @description whether Select is disabled
+  */
+  disabled: Boolean,
+  /**
+  * @description whether creating new items is allowed. To use this, `filterable` must be true
+  */
+  allowCreate: Boolean,
+  /**
+  * @description whether Select is loading data from server
+  */
+  loading: Boolean,
+  /**
+  * @description custom class name for Select's dropdown
+  */
+  popperClass: {
+    type: String,
+    default: ""
+  },
+  /**
+  * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+  */
+  popperOptions: {
+    type: Object,
+    default: () => ({})
+  },
+  /**
+  * @description displayed text while loading data from server, default is 'Loading'
+  */
+  loadingText: String,
+  /**
+  * @description displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
+  */
+  noMatchText: String,
+  /**
+  * @description displayed text when there is no options, you can also use slot `empty`, default is 'No data'
+  */
+  noDataText: String,
+  /**
+  * @description tooltip theme, built-in theme: `dark` / `light`
+  */
+  effect: {
+    type: String,
+    default: "light"
+  },
+  /**
+  * @description tag type
+  */
+  tagType: { default: "info" },
+  /**
+   * @description position of dropdown
+   */
+  placement: {
+    type: String,
+    values: enums.placements,
+    default: "bottom-start"
+  },
+  /**
+   * @tagplus
+   * Sobrescrito para ter o padrão true
+   * @description whether to collapse tags to a text when multiple selecting
+  */
+  collapseTags: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * @tagplus
+   * Sobrescrito para ter o padrão true
+   * @description whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
+  */
+  collapseTagsTooltip: {
+    type: Boolean,
+    default: true
+  },
+  /**
+  * @description the max tags number to be shown. To use this, `collapse-tags` must be true
+  */
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  /**
+  * @description whether select dropdown is teleported to the body
+  */
+  teleported: {
+    type: Boolean,
+    default: true
+  },
+  /**
+  * @description when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
+  */
+  persistent: {
+    type: Boolean,
+    default: true
+  },
+  /**
+  * @description native input aria-label
+  */
+  ariaLabel: {
+    type: String,
+    default: void 0
+  },
+  multiple: {
+    type: Boolean,
+    default: false
+  },
+  /**
+  * @description maximum number of options user can select when `multiple` is `true`. No limit when set to 0
+  */
+  multipleLimit: {
+    type: Number,
+    default: 0
+  }
+};
+exports.default = autosuggestProps;