@tagplus/components 5.3.2 → 5.3.4

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

@@ -1,446 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-"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

@@ -1,204 +0,0 @@
-"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;