@fewangsit/wangsvue 1.5.219-alpha.2 → 1.5.219-alpha.3

package/dialogselecttree/index.es.js

@@ -1,317 +0,0 @@
-import { defineComponent, mergeModels, useModel, inject, ref, computed, watch, createBlock, openBlock, unref, createSlots, withCtx, createVNode, mergeProps, renderSlot, createElementVNode, createElementBlock, createCommentVNode, normalizeClass, toDisplayString, Fragment, renderList, withDirectives, vShow } from "vue";
-import { g as getNestedPropertyValue } from "../utils/object.util.es.js";
-import { _ as _sfc_main$5 } from "../button/index.es.js";
-import { _ as _sfc_main$1 } from "../dialog/index.es.js";
-import { _ as _sfc_main$2 } from "../tree/index.es.js";
-import { _ as _sfc_main$3 } from "../treesearchinput/index.es.js";
-import { _ as _sfc_main$4 } from "../validatormessage/index.es.js";
-const _hoisted_1 = {
-  class: "flex flex-col gap-3 items-start w-full",
-  "data-wv-section": "header-wrapper"
-};
-const _hoisted_2 = {
-  key: 0,
-  class: "list-inside w-full overflow-auto max-h-20",
-  "data-wv-section": "dialog-select-tree-lists"
-};
-const _hoisted_3 = {
-  class: "flex gap-1 items-center justify-end",
-  "data-wv-section": "footer-button"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "DialogSelectTree",
-  props: /* @__PURE__ */ mergeModels({
-    fetchTree: {},
-    params: {},
-    visible: { type: Boolean },
-    type: { default: "group" },
-    autoSelectAll: { type: Boolean },
-    header: {},
-    subHeader: { default: void 0 },
-    selectionMode: { default: "checkbox" },
-    allowEmptySelection: { type: Boolean, default: true },
-    keys: { default: void 0 },
-    lists: { default: void 0 },
-    listLabel: { default: void 0 },
-    disableNodeAll: { type: Boolean, default: false },
-    exactDisableKey: {},
-    disableKeys: {},
-    exactDisableKeys: {},
-    disableNodeWhen: { type: Function, default: void 0 },
-    readonly: { type: Boolean },
-    showDisposableGroups: { type: Boolean },
-    flattenDisposableNode: { type: Boolean },
-    excludedKeys: {},
-    hidden: { type: Boolean },
-    propagateSelection: { type: Boolean },
-    selectedKeys: {},
-    selectedTreeNodes: {},
-    useOption: { type: Boolean },
-    listLabelsNoOption: {},
-    treeNodeMenus: {},
-    selectLastNode: { type: Boolean },
-    includeNodeAllKey: { type: Boolean },
-    selectDisposableOnly: { type: Boolean },
-    shouldEmitEventOnChange: { type: Boolean },
-    level: {},
-    value: {},
-    expandedKeys: {},
-    selectionKeys: {},
-    metaKeySelection: { type: Boolean },
-    loading: { type: Boolean },
-    loadingIcon: {},
-    loadingMode: {},
-    filterText: {},
-    filterBy: {},
-    filterMode: {},
-    filterPlaceholder: {},
-    filterLocale: {},
-    highlightOnSelect: { type: Boolean },
-    scrollHeight: {},
-    ariaLabel: {},
-    ariaLabelledby: {},
-    pt: {},
-    ptOptions: {},
-    unstyled: { type: Boolean },
-    exactDisableNodeWhen: {},
-    nodeSelectedWhen: {}
-  }, {
-    "visible": { type: Boolean, ...{ default: false } },
-    "visibleModifiers": {}
-  }),
-  emits: /* @__PURE__ */ mergeModels(["select", "hide"], ["update:visible"]),
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    const visible = useModel(__props, "visible");
-    const DialogPreset = inject("preset", {}).dialog;
-    const treeComponent = ref();
-    const treeFilter = ref("");
-    const invalidSelectionMessage = ref("");
-    const selectedTreeNodes = ref([]);
-    const selectedTreeKeys = ref();
-    const selectedNode = ref();
-    const selectDisposableOnly = ref(false);
-    const temporarySelectedTreeKeys = ref();
-    const temporarySelectedNode = ref();
-    const dialogHeader = computed(() => {
-      if (props.header) return props.header;
-      return props.type === "group" ? "Select Group" : "Select Category";
-    });
-    const onButtonSelectClicked = (close = true) => {
-      selectedTreeKeys.value = temporarySelectedTreeKeys.value;
-      selectedNode.value = temporarySelectedNode.value;
-      if (Object.keys(selectedTreeKeys.value ?? {}).length) {
-        emit("select", {
-          keys: selectedTreeKeys.value,
-          selectedNodes: selectedTreeNodes.value,
-          singleNode: selectedNode.value
-        });
-        visible.value = !close;
-      } else if (props.allowEmptySelection) {
-        emit("select", {
-          keys: [],
-          selectedNodes: void 0,
-          singleNode: void 0
-        });
-        visible.value = !close;
-      } else if (!props.allowEmptySelection) {
-        invalidSelectionMessage.value = "You must pick a " + props.type.toLowerCase();
-      }
-    };
-    watch(visible, (show) => {
-      temporarySelectedTreeKeys.value = show ? selectedTreeKeys.value : void 0;
-      temporarySelectedNode.value = show ? selectedNode.value : void 0;
-      if (show && props.keys && !temporarySelectedTreeKeys.value) {
-        temporarySelectedTreeKeys.value = props.keys;
-      }
-    });
-    watch(
-      treeComponent,
-      (tree) => {
-        if (tree && props.showDisposableGroups) {
-          tree.showDisposableGroups = true;
-          selectDisposableOnly.value = true;
-        }
-      },
-      { deep: true }
-    );
-    watch(
-      selectedTreeNodes,
-      () => {
-        if (props.hidden) {
-          onButtonSelectClicked(false);
-        }
-      },
-      { once: true }
-    );
-    watch(
-      () => props.keys,
-      () => {
-        selectedTreeKeys.value = props.keys;
-      }
-    );
-    __expose({ treeComponent });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(_sfc_main$1, {
-        visible: visible.value,
-        "onUpdate:visible": _cache[7] || (_cache[7] = ($event) => visible.value = $event),
-        modal: !_ctx.hidden,
-        pt: {
-          root: {
-            class: [
-              ...unref(DialogPreset).root({ state: {} }).class,
-              "!w-[400px]",
-              { "!hidden": _ctx.hidden }
-            ]
-          },
-          header: {
-            class: "relative"
-          },
-          icons: {
-            class: "absolute top-0 right-0"
-          },
-          content: {
-            class: [
-              ...unref(DialogPreset).content({ state: {}, instance: {} }).class,
-              "pr-1.5 focus-visible:outline-none"
-            ]
-          },
-          footer: {
-            class: [
-              {
-                "flex justify-end items-center gap-1": _ctx.allowEmptySelection,
-                "flex justify-end items-end flex-col gap-1": !_ctx.allowEmptySelection
-              }
-            ]
-          }
-        },
-        onHide: _cache[8] || (_cache[8] = ($event) => _ctx.$emit("hide")),
-        onShow: _cache[9] || (_cache[9] = ($event) => invalidSelectionMessage.value = ""),
-        "data-wv-name": "dialogselecttree"
-      }, createSlots({
-        header: withCtx(() => {
-          var _a;
-          return [
-            renderSlot(_ctx.$slots, "header", {
-              dialogHeader: dialogHeader.value,
-              filter: treeFilter.value,
-              isLoading: !!((_a = treeComponent.value) == null ? void 0 : _a.isLoading),
-              listLabel: _ctx.listLabel,
-              lists: _ctx.lists,
-              subHeader: _ctx.subHeader,
-              updateFilter: (filter) => treeFilter.value = filter
-            }, () => {
-              var _a2;
-              return [
-                createElementVNode("div", _hoisted_1, [
-                  createElementVNode("h3", {
-                    class: normalizeClass([...unref(DialogPreset).title.class, "!leading-6"])
-                  }, toDisplayString(dialogHeader.value), 3),
-                  _ctx.lists ? (openBlock(), createElementBlock("ul", _hoisted_2, [
-                    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.lists, (list, index) => {
-                      return openBlock(), createElementBlock("li", {
-                        key: index,
-                        class: "text-xs leading-[16.39px] tracking-[0.02em] font-medium text-general-800 list-disc ps-[6px]"
-                      }, toDisplayString(_ctx.listLabel && typeof list !== "string" ? unref(getNestedPropertyValue)(list, _ctx.listLabel) : list), 1);
-                    }), 128))
-                  ])) : createCommentVNode("", true),
-                  _ctx.subHeader ? (openBlock(), createElementBlock("h4", {
-                    key: 1,
-                    class: normalizeClass([...unref(DialogPreset).title.class, "!leading-6 text-sm"])
-                  }, toDisplayString(_ctx.subHeader), 3)) : createCommentVNode("", true),
-                  !((_a2 = treeComponent.value) == null ? void 0 : _a2.isLoading) ? (openBlock(), createBlock(_sfc_main$3, {
-                    key: 2,
-                    modelValue: treeFilter.value,
-                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => treeFilter.value = $event),
-                    class: "w-full"
-                  }, null, 8, ["modelValue"])) : createCommentVNode("", true)
-                ])
-              ];
-            })
-          ];
-        }),
-        default: withCtx(() => [
-          createVNode(_sfc_main$2, mergeProps({
-            ref_key: "treeComponent",
-            ref: treeComponent
-          }, props, {
-            "selected-keys": temporarySelectedTreeKeys.value,
-            "onUpdate:selectedKeys": [
-              _cache[1] || (_cache[1] = ($event) => temporarySelectedTreeKeys.value = $event),
-              _cache[4] || (_cache[4] = ($event) => invalidSelectionMessage.value = "")
-            ],
-            "selected-tree-nodes": selectedTreeNodes.value,
-            "onUpdate:selectedTreeNodes": _cache[2] || (_cache[2] = ($event) => selectedTreeNodes.value = $event),
-            "auto-select-all": _ctx.autoSelectAll,
-            "disable-keys": _ctx.disableKeys,
-            "disable-node-all": _ctx.disableNodeAll,
-            "disable-node-when": _ctx.disableNodeWhen,
-            "exact-disable-key": _ctx.exactDisableKey,
-            "exact-disable-keys": _ctx.exactDisableKeys,
-            "excluded-keys": _ctx.excludedKeys,
-            "fetch-tree": _ctx.fetchTree,
-            filter: treeFilter.value,
-            "flatten-disposable-node": _ctx.flattenDisposableNode,
-            params: _ctx.params,
-            "propagate-selection": _ctx.propagateSelection,
-            readonly: props.readonly,
-            "select-disposable-only": selectDisposableOnly.value,
-            "selection-mode": _ctx.selectionMode,
-            type: props.type,
-            onNodeSelect: _cache[3] || (_cache[3] = ($event) => temporarySelectedNode.value = $event)
-          }), createSlots({ _: 2 }, [
-            _ctx.$slots.treenode ? {
-              name: "default",
-              fn: withCtx(({ node, checked, disabled }) => [
-                renderSlot(_ctx.$slots, "treenode", {
-                  checked,
-                  disabled,
-                  node
-                })
-              ]),
-              key: "0"
-            } : void 0
-          ]), 1040, ["selected-keys", "selected-tree-nodes", "auto-select-all", "disable-keys", "disable-node-all", "disable-node-when", "exact-disable-key", "exact-disable-keys", "excluded-keys", "fetch-tree", "filter", "flatten-disposable-node", "params", "propagate-selection", "readonly", "select-disposable-only", "selection-mode", "type"])
-        ]),
-        _: 2
-      }, [
-        !props.readonly ? {
-          name: "footer",
-          fn: withCtx(() => [
-            renderSlot(_ctx.$slots, "footer", {}, () => {
-              var _a;
-              return [
-                !_ctx.allowEmptySelection ? withDirectives((openBlock(), createBlock(_sfc_main$4, {
-                  key: 0,
-                  format: false,
-                  message: invalidSelectionMessage.value
-                }, null, 8, ["message"])), [
-                  [vShow, !!invalidSelectionMessage.value]
-                ]) : createCommentVNode("", true),
-                createElementVNode("div", _hoisted_3, [
-                  createVNode(_sfc_main$5, {
-                    onClick: _cache[5] || (_cache[5] = ($event) => visible.value = false),
-                    label: "Cancel",
-                    severity: "secondary",
-                    text: ""
-                  }),
-                  createVNode(_sfc_main$5, {
-                    disabled: (_a = treeComponent.value) == null ? void 0 : _a.isLoading,
-                    onClick: _cache[6] || (_cache[6] = ($event) => onButtonSelectClicked(true)),
-                    label: "Select",
-                    severity: "success"
-                  }, null, 8, ["disabled"])
-                ])
-              ];
-            })
-          ]),
-          key: "0"
-        } : void 0
-      ]), 1032, ["visible", "modal", "pt"]);
-    };
-  }
-});
-export {
-  _sfc_main as _
-};

package/directives/focus.es.js

@@ -1,18 +0,0 @@
-import { nextTick } from "vue";
-const Focus = {
-  mounted: async (el) => {
-    const isInput = el.tagName.toLowerCase() === "input";
-    const isButton = el.tagName.toLowerCase() === "button";
-    nextTick(() => {
-      var _a;
-      if (isInput || isButton) {
-        el.focus();
-      } else {
-        (_a = el.querySelector("input")) == null ? void 0 : _a.focus();
-      }
-    });
-  }
-};
-export {
-  Focus as F
-};

package/directives/index.es.js

@@ -1,2 +0,0 @@
-import "vue";
-import "../vendor/primevue/tooltip/tooltip.esm.es.js";

package/directives/tooltip.es.js

@@ -1 +0,0 @@
-import "../vendor/primevue/tooltip/tooltip.esm.es.js";

package/dropdown/index.es.js

@@ -1,297 +0,0 @@
-import { defineComponent, onMounted, computed, inject, ref, shallowRef, reactive, watch, createBlock, openBlock, withCtx, createVNode, normalizeClass, createCommentVNode, unref, renderSlot, mergeProps, createSlots, normalizeProps, guardReactiveProps, createElementVNode, toDisplayString, createElementBlock, Fragment, createTextVNode, nextTick } from "vue";
-import { u as useField } from "../vendor/vee-validate/dist/vee-validate.esm.es.js";
-import { u as useWangsVueConfig } from "../plugins/WangsVue.es.js";
-import { f as filterOptions } from "../utils/filterOptions.util.es.js";
-import { m as mergePropsWithDefaults } from "../utils/mergePropsWithDefaults.util.es.js";
-import { a as formatVowelSoundLabel } from "../utils/textFormatter.util.es.js";
-import { s as script$1 } from "../vendor/primevue/dropdown/dropdown.esm.es.js";
-import { s as script } from "../vendor/primevue/inputgroupaddon/inputgroupaddon.esm.es.js";
-import { _ as _sfc_main$4 } from "../badge/index.es.js";
-import { _ as _sfc_main$1 } from "../fieldwrapper/index.es.js";
-import { _ as _sfc_main$3 } from "../icon/index.es.js";
-import { _ as _sfc_main$2 } from "../inputgroup/index.es.js";
-import { _ as _sfc_main$5 } from "../validatormessage/index.es.js";
-import { i as isEqual } from "../vendor/lodash-es/isEqual.es.js";
-import { c as cloneDeep } from "../vendor/lodash-es/cloneDeep.es.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "Dropdown",
-  props: {
-    modelValue: { type: [String, Number, Boolean, Object], default: void 0 },
-    initialValue: { type: [String, Number, Boolean, Object], default: void 0 },
-    label: {},
-    options: {},
-    allowNullOption: { type: Boolean, default: void 0 },
-    unselectOnReselect: { type: Boolean },
-    optionLabel: {},
-    optionValue: {},
-    valueType: { default: "plain" },
-    badgeValueProps: {},
-    inputBorder: {},
-    dataKey: {},
-    useValidator: { type: Boolean },
-    mandatory: { type: Boolean },
-    showOptionalText: { type: Boolean, default: void 0 },
-    validatorMessage: {},
-    formatValidatorMessage: { type: Boolean, default: true },
-    invalid: { type: Boolean },
-    fieldName: {},
-    placeholder: {},
-    loading: { type: Boolean },
-    fieldInfo: {},
-    disabled: { type: Boolean },
-    filter: { type: Boolean, default: true },
-    filterPlaceholder: {},
-    panelMaxContent: { type: Boolean, default: false }
-  },
-  emits: ["update:modelValue", "show", "fieldInfoClick"],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    onMounted(() => {
-      setValidator();
-    });
-    const { locale, defaultProps } = useWangsVueConfig("Dropdown");
-    const config = computed(() => mergePropsWithDefaults(props, defaultProps));
-    const Preset = inject("preset", {}).dropdown;
-    const InputGroupAddonPreset = inject(
-      "preset",
-      {}
-    ).inputgroupaddon;
-    const dropdown = ref();
-    const isShowOverlay = shallowRef(false);
-    const isClicked = shallowRef(false);
-    const invalidInput = computed(() => props.invalid || !!field.errorMessage);
-    const field = reactive({
-      value: props.initialValue !== void 0 ? props.initialValue : props.modelValue
-    });
-    const emptyErrorMessage = computed(() => {
-      var _a;
-      return locale.emptySelectionErrorMessage.replace("{label}", props.label).replace(
-        "{formattedLabel}",
-        (_a = formatVowelSoundLabel(props.label)) == null ? void 0 : _a.toLowerCase()
-      );
-    });
-    const visibleOptions = computed(() => filterOptions(props.options));
-    const dropdownPlaceholder = computed(() => {
-      var _a;
-      return props.loading ? locale.loadingPlaceholder : props.placeholder ?? ((_a = locale.inputPlaceholder) == null ? void 0 : _a.replace("{label}", props.label ?? "").replace("{lowercaseLabel}", (props.label ?? "").toLowerCase()));
-    });
-    const setValidator = () => {
-      if (props.useValidator) {
-        Object.assign(
-          field,
-          useField(props.fieldName ?? "dropdown", (value) => {
-            const hasValue = value != null && value !== "";
-            if (!hasValue && props.mandatory) {
-              if (typeof props.validatorMessage === "object" && "empty" in props.validatorMessage) {
-                return props.validatorMessage.empty;
-              }
-              return props.validatorMessage ?? emptyErrorMessage.value;
-            }
-            return nextTick(setValidatorMessage);
-          })
-        );
-        if (props.initialValue !== void 0) field.value = props.initialValue;
-        if (props.invalid) field.validate();
-      }
-    };
-    const setValidatorMessage = () => {
-      if (props.validatorMessage && props.invalid) {
-        return props.validatorMessage;
-      }
-      return true;
-    };
-    const updateFieldValue = (event) => {
-      const { value } = event;
-      if (props.unselectOnReselect) isClicked.value = true;
-      else emit("update:modelValue", value);
-    };
-    const getOptionLabel = () => {
-      if (props.optionValue) {
-        const matchOption = visibleOptions.value.find((op) => {
-          if (typeof op != "string") {
-            if (props.dataKey) {
-              return field.value[props.dataKey] === op[props.optionValue ?? ""][props.dataKey];
-            }
-            return isEqual(
-              cloneDeep(op[props.optionValue ?? ""]),
-              cloneDeep(field.value)
-            );
-          }
-        });
-        if (matchOption && typeof matchOption != "string") {
-          return matchOption[props.optionLabel ?? ""];
-        }
-      } else if (field.value && typeof field.value === "object" && props.optionLabel && props.optionLabel in field.value) {
-        return field.value[props.optionLabel];
-      }
-      return field.value;
-    };
-    const showOverlay = () => {
-      if (dropdown.value) dropdown.value.show();
-    };
-    watch(
-      () => props.initialValue,
-      (value) => {
-        field.value = value;
-      },
-      { once: true }
-    );
-    watch(
-      () => props.modelValue,
-      (value) => {
-        field.value = value;
-      }
-    );
-    watch(
-      () => field.value,
-      (newValue, oldValue) => {
-        setTimeout(() => {
-          if (props.unselectOnReselect && isClicked.value) {
-            if (isEqual(newValue, oldValue) && newValue !== void 0) {
-              field.value = void 0;
-            }
-            isClicked.value = false;
-            emit("update:modelValue", field.value);
-          }
-        }, 0);
-      }
-    );
-    __expose({
-      showOverlay
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(_sfc_main$1, {
-        info: _ctx.fieldInfo,
-        label: props.label,
-        mandatory: props.mandatory,
-        "show-optional-text": _ctx.showOptionalText,
-        onInfoClick: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("fieldInfoClick"))
-      }, {
-        default: withCtx(() => [
-          createVNode(_sfc_main$2, {
-            class: normalizeClass([
-              {
-                "grid grid-cols-[max-content,1fr,max-content]": _ctx.$slots["addon-left"] && _ctx.$slots["addon-right"],
-                "grid grid-cols-[1fr,max-content]": !_ctx.$slots["addon-left"] && _ctx.$slots["addon-right"],
-                "grid grid-cols-[max-content,1fr]": _ctx.$slots["addon-left"] && !_ctx.$slots["addon-right"]
-              }
-            ]),
-            disabled: props.disabled,
-            invalid: invalidInput.value,
-            ring: _ctx.inputBorder
-          }, {
-            default: withCtx(() => {
-              var _a, _b, _c, _d, _e;
-              return [
-                _ctx.$slots["addon-left"] ? (openBlock(), createBlock(unref(script), {
-                  key: 0,
-                  disabled: props.disabled
-                }, {
-                  default: withCtx(() => [
-                    renderSlot(_ctx.$slots, "addon-left")
-                  ]),
-                  _: 3
-                }, 8, ["disabled"])) : createCommentVNode("", true),
-                createVNode(unref(script$1), mergeProps({
-                  ref_key: "dropdown",
-                  ref: dropdown
-                }, props, {
-                  modelValue: field.value,
-                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => field.value = $event),
-                  "aria-describedby": props.label + "error",
-                  "filter-placeholder": props.filterPlaceholder || unref(locale).filterPlaceholder,
-                  invalid: invalidInput.value,
-                  options: visibleOptions.value,
-                  placeholder: dropdownPlaceholder.value,
-                  pt: {
-                    list: (_a = unref(Preset)) == null ? void 0 : _a.list({ props }),
-                    panel: (_b = unref(Preset)) == null ? void 0 : _b.panel({ props }),
-                    virtualScroller: (_c = unref(Preset)) == null ? void 0 : _c.virtualScroller({ props }),
-                    wrapper: (_d = unref(Preset)) == null ? void 0 : _d.wrapper({ props })
-                  },
-                  "virtual-scroller-options": ((_e = visibleOptions.value) == null ? void 0 : _e.length) > 10 ? { itemSize: 32 } : void 0,
-                  onChange: updateFieldValue,
-                  onHide: _cache[1] || (_cache[1] = ($event) => isShowOverlay.value = false),
-                  onShow: _cache[2] || (_cache[2] = ($event) => (_ctx.$emit("show"), isShowOverlay.value = true))
-                }), createSlots({
-                  dropdownicon: withCtx(() => [
-                    createVNode(_sfc_main$3, normalizeProps(guardReactiveProps(unref(Preset).dropdownicon({ state: { isShowOverlay: isShowOverlay.value } }))), null, 16)
-                  ]),
-                  loadingicon: withCtx(() => [
-                    createVNode(_sfc_main$3, normalizeProps(guardReactiveProps(unref(Preset).loadingicon)), null, 16)
-                  ]),
-                  filtericon: withCtx(() => [
-                    createVNode(_sfc_main$3, normalizeProps(guardReactiveProps(unref(Preset).filtericon)), null, 16)
-                  ]),
-                  _: 2
-                }, [
-                  _ctx.loading ? {
-                    name: "value",
-                    fn: withCtx(({ placeholder }) => [
-                      createElementVNode("span", normalizeProps(guardReactiveProps(unref(Preset).loadingplaceholder)), toDisplayString(placeholder), 17)
-                    ]),
-                    key: "0"
-                  } : {
-                    name: "value",
-                    fn: withCtx((slotProps) => [
-                      (config.value.allowNullOption ? slotProps.value !== void 0 : slotProps.value != null) ? renderSlot(_ctx.$slots, "value", {
-                        key: 0,
-                        originalValue: slotProps.value,
-                        value: getOptionLabel()
-                      }, () => [
-                        _ctx.valueType === "badge" ? (openBlock(), createBlock(_sfc_main$4, mergeProps({ key: 0 }, _ctx.badgeValueProps, {
-                          label: getOptionLabel()
-                        }), null, 16, ["label"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
-                          createTextVNode(toDisplayString(getOptionLabel()), 1)
-                        ], 64))
-                      ]) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
-                        createTextVNode(toDisplayString(slotProps.placeholder), 1)
-                      ], 64))
-                    ]),
-                    key: "1"
-                  },
-                  _ctx.$slots["option"] ? {
-                    name: "option",
-                    fn: withCtx(({ option }) => [
-                      renderSlot(_ctx.$slots, "option", { option })
-                    ]),
-                    key: "2"
-                  } : void 0
-                ]), 1040, ["modelValue", "aria-describedby", "filter-placeholder", "invalid", "options", "placeholder", "pt", "virtual-scroller-options"]),
-                _ctx.$slots["addon-right"] ? (openBlock(), createBlock(unref(script), {
-                  key: 1,
-                  pt: {
-                    root: unref(InputGroupAddonPreset).root({
-                      props: {
-                        class: [
-                          {
-                            "!text-general-200": props.disabled
-                          }
-                        ]
-                      }
-                    })
-                  }
-                }, {
-                  default: withCtx(() => [
-                    renderSlot(_ctx.$slots, "addon-right")
-                  ]),
-                  _: 3
-                }, 8, ["pt"])) : createCommentVNode("", true)
-              ];
-            }),
-            _: 3
-          }, 8, ["class", "disabled", "invalid", "ring"]),
-          createVNode(_sfc_main$5, {
-            id: props.label + "error",
-            message: field.errorMessage
-          }, null, 8, ["id", "message"])
-        ]),
-        _: 3
-      }, 8, ["info", "label", "mandatory", "show-optional-text"]);
-    };
-  }
-});
-export {
-  _sfc_main as _
-};