@knime/jsonforms 1.8.6 → 1.8.7

package/dist/LoadingDropdown-OAZ94jZa.js

@@ -0,0 +1,75 @@
+import { defineComponent as k, computed as s, openBlock as o, createBlock as r, unref as n, mergeProps as I, withCtx as y, createCommentVNode as b, createElementBlock as p, normalizeClass as N, Fragment as i, createVNode as L, createElementVNode as V, toDisplayString as d, createTextVNode as T } from "vue";
+import { D as f } from "./index-CUSP9syR.js";
+import { D as w } from "./Dropdown-DgLzYs1N.js";
+import { L as D } from "./LoadingIcon-BK8jfTsz.js";
+import { _ as B } from "./SectionHeading.vue_vue_type_style_index_0_scoped_c541eb08_lang-BLqdGTB-.js";
+const C = /* @__PURE__ */ k({
+  __name: "LoadingDropdown",
+  props: {
+    possibleValues: {},
+    modelValue: {},
+    id: {},
+    ariaLabel: {},
+    disabled: { type: Boolean }
+  },
+  setup(v) {
+    const l = v, u = s(() => {
+      const { possibleValues: e } = l;
+      return e === null ? "Loading" : e.length > 0 ? "No value selected" : "No values present";
+    }), x = s(() => l.possibleValues === null ? "" : l.modelValue), _ = s(
+      () => l.possibleValues?.some((e) => e.type !== void 0)
+    ), g = s(
+      () => l.disabled || l.possibleValues === null || l.possibleValues.length === 0
+    ), c = s(() => l.possibleValues === null ? [] : _.value ? l.possibleValues.map((e) => ({
+      ...e,
+      slotData: {
+        text: e.text,
+        ...e.type && { typeId: e.type.id, typeText: e.type.text }
+      }
+    })) : l.possibleValues);
+    return (e, z) => (o(), r(n(w), I({ ...e.$props, ...e.$attrs }, {
+      "model-value": x.value,
+      disabled: g.value,
+      "possible-values": c.value ?? [],
+      placeholder: u.value,
+      compact: ""
+    }), {
+      option: y(({ slotData: t, selectedValue: m, isMissing: a, expanded: h } = {
+        slotData: {}
+      }) => [
+        h || m !== "" || a ? (o(), p("div", {
+          key: 0,
+          class: N([
+            "data-type-entry",
+            { missing: a, "with-type": a || t.typeId }
+          ])
+        }, [
+          a ? (o(), p(i, { key: 0 }, [
+            L(n(f), { size: "small" }),
+            V("span", null, "(MISSING) " + d(m), 1)
+          ], 64)) : (o(), p(i, { key: 1 }, [
+            t.typeId ? (o(), r(n(f), {
+              key: 0,
+              "icon-name": t.typeId,
+              "icon-title": t.typeText,
+              size: "small"
+            }, null, 8, ["icon-name", "icon-title"])) : b("", !0),
+            V("span", null, d(t.text), 1)
+          ], 64))
+        ], 2)) : (o(), p(i, { key: 1 }, [
+          T(d(u.value), 1)
+        ], 64))
+      ]),
+      "icon-right": y(() => [
+        c.value === null ? (o(), r(n(D), {
+          key: 0,
+          class: "loading-icon"
+        })) : b("", !0)
+      ]),
+      _: 1
+    }, 16, ["model-value", "disabled", "possible-values", "placeholder"]));
+  }
+}), F = /* @__PURE__ */ B(C, [["__scopeId", "data-v-c41aeae4"]]);
+export {
+  F as L
+};

package/dist/LoadingIcon-BK8jfTsz.js

@@ -0,0 +1,18 @@
+import { h as r, defineComponent as c, openBlock as s, createBlock as i, unref as a } from "vue";
+import { R as d } from "./reload-BVbCGubF.js";
+import { _ } from "./SectionHeading.vue_vue_type_style_index_0_scoped_c541eb08_lang-BLqdGTB-.js";
+const p = (t, o) => ({
+  render() {
+    const e = t.render({}, []), n = r("title", o);
+    return n.ns = "svg", e.children.unshift(n), e;
+  }
+}), l = /* @__PURE__ */ c({
+  __name: "LoadingIcon",
+  setup(t) {
+    const o = p(d, "Loading…");
+    return (e, n) => (s(), i(a(o)));
+  }
+}), u = /* @__PURE__ */ _(l, [["__scopeId", "data-v-6b552b81"]]);
+export {
+  u as L
+};

package/dist/ManualTwinlistControl-BQLjGmy3.js

@@ -0,0 +1,79 @@
+import { defineComponent as C, toRef as d, computed as a, markRaw as I, openBlock as k, createBlock as F, unref as c, mergeProps as T } from "vue";
+import { m as _ } from "./index-Blg1O3Fz.js";
+import { u as L, a as U } from "./usePossibleValues-C3V_0Qn_.js";
+import { T as z, a as M } from "./TwinlistLoadingInfo-BocQJbmS.js";
+import { u as x } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_a6fd4504_lang-BDJqwT00.js";
+import { _ as B } from "./SectionHeading.vue_vue_type_style_index_0_scoped_c541eb08_lang-BLqdGTB-.js";
+const D = /* @__PURE__ */ C({
+  __name: "ManualTwinlistControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(r) {
+    const n = r;
+    let o;
+    const t = (e) => {
+      const l = _(n.control.data, e);
+      n.changeValue(l), o?.(l);
+    }, p = (e) => {
+      if (e !== null)
+        if ("includedValues" in e) {
+          const { includedValues: l, excludedValues: u, includeUnknownValues: y } = e;
+          if (!l || !u)
+            return;
+          t({
+            manuallySelected: l,
+            manuallyDeselected: u,
+            includeUnknownColumns: y
+          });
+        } else
+          t({ manuallySelected: e });
+    }, { possibleValues: s } = L(
+      d(n, "control")
+    ), { selectedAndDeselected: i, setCurrentManualFilter: m } = x({
+      data: a(() => ({ manualFilter: n.control.data })),
+      possibleValueIds: a(
+        () => s.value?.map(({ id: e }) => e) ?? null
+      )
+    });
+    o = m;
+    const b = a(() => {
+      const { selected: e, deselected: l } = i.value;
+      return {
+        includedValues: e,
+        excludedValues: l,
+        includeUnknownValues: n.control.data.includeUnknownColumns
+      };
+    }), f = a(
+      () => i.value.selected === null ? I(z) : null
+    ), { excludedLabel: w, includedLabel: V } = U(
+      d(n, "control")
+    ), h = a(() => w ?? "Excludes"), v = a(() => V ?? "Includes"), g = a(
+      () => n.control.uischema.options?.twinlistSize
+    );
+    return (e, l) => (k(), F(c(M), T(e.$attrs, {
+      id: e.labelForId,
+      "show-search": "",
+      disabled: e.disabled,
+      "empty-state-component": f.value,
+      "model-value": b.value,
+      "possible-values": c(s) ?? [],
+      size: g.value,
+      "left-label": h.value,
+      "right-label": v.value,
+      "is-valid": e.isValid,
+      compact: "",
+      "show-resize-handle": "",
+      "onUpdate:modelValue": p
+    }), null, 16, ["id", "disabled", "empty-state-component", "model-value", "possible-values", "size", "left-label", "right-label", "is-valid"]));
+  }
+}), $ = /* @__PURE__ */ B(D, [["__scopeId", "data-v-3a892220"]]);
+export {
+  $ as default
+};

package/dist/MultiSelectListBoxControl-kqcoBl2C.js

@@ -0,0 +1,31 @@
+import { defineComponent as s, toRef as n, openBlock as t, createBlock as d, unref as o } from "vue";
+import { u as r } from "./usePossibleValues-C3V_0Qn_.js";
+import { M as u } from "./MultiselectListBox-YT94gLy1.js";
+const V = /* @__PURE__ */ s({
+  __name: "MultiSelectListBoxControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(l) {
+    const a = l, { possibleValues: i } = r(n(a, "control"));
+    return (e, p) => (t(), d(o(u), {
+      id: e.labelForId,
+      "possible-values": o(i) || [],
+      disabled: e.disabled,
+      "model-value": e.control.data,
+      "is-valid": e.isValid,
+      ariaLabel: e.control.label,
+      size: e.control.uischema.options?.size,
+      "onUpdate:modelValue": e.changeValue
+    }, null, 8, ["id", "possible-values", "disabled", "model-value", "is-valid", "ariaLabel", "size", "onUpdate:modelValue"]));
+  }
+});
+export {
+  V as default
+};

package/dist/MultimodeTwinlistControl-BSnI3Nv-.js

@@ -0,0 +1,500 @@
+import { openBlock as f, createElementBlock as x, createElementVNode as g, toRef as I, resolveComponent as y, normalizeClass as z, createBlock as T, withCtx as c, createVNode as h, createCommentVNode as P, renderSlot as M, normalizeProps as _, guardReactiveProps as F, mergeProps as D, defineComponent as K, ref as Q, computed as m, markRaw as X, unref as w, createSlots as Y, toDisplayString as U } from "vue";
+import { D as k } from "./index-CUSP9syR.js";
+import { m as Z } from "./index-Blg1O3Fz.js";
+import { u as $, a as ee } from "./usePossibleValues-C3V_0Qn_.js";
+import { a as te, S as ae, u as le, T as ne } from "./TwinlistLoadingInfo-BocQJbmS.js";
+import { u as se } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_a6fd4504_lang-BDJqwT00.js";
+import { f as B } from "./useSearch-hpyYQ_6y.js";
+import { C as ie } from "./Checkboxes-BmUZ2CDH.js";
+import { y as oe, _ as R } from "./SectionHeading.vue_vue_type_style_index_0_scoped_c541eb08_lang-BLqdGTB-.js";
+import { V as de } from "./ValueSwitch-BkHtM8g5.js";
+const re = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function ue(t, l) {
+  return f(), x("svg", re, l[0] || (l[0] = [
+    g("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1)
+  ]));
+}
+const ce = { render: ue }, pe = {
+  manual: "Manual",
+  wildcard: "Wildcard",
+  regex: "Regex",
+  type: "Type"
+}, me = {
+  name: "MultiModeTwinlist",
+  components: {
+    Label: oe,
+    FilterIcon: ce,
+    SearchInput: ae,
+    Checkboxes: ie,
+    ValueSwitch: de,
+    Twinlist: te
+  },
+  props: {
+    /**
+     * initial values
+     */
+    mode: {
+      type: String,
+      required: !1,
+      default: "manual"
+    },
+    manualSelection: {
+      type: [Object, Array, null],
+      default: () => []
+    },
+    pattern: {
+      type: String,
+      default: ""
+    },
+    caseSensitivePattern: {
+      default: !1,
+      type: Boolean
+    },
+    inversePattern: {
+      default: !1,
+      type: Boolean
+    },
+    withTypes: {
+      type: Boolean,
+      default: !0
+    },
+    selectedTypes: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * Hiding and disabling
+     */
+    showMode: {
+      default: !0,
+      type: Boolean
+    },
+    // enable search in case of manual selection
+    showSearch: {
+      default: !0,
+      type: Boolean
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    /**
+     * Labels
+     */
+    withModeLabel: {
+      default: !1,
+      type: Boolean
+    },
+    modeLabel: {
+      type: String,
+      required: !1,
+      default: "Selection mode"
+    },
+    withPatternLabel: {
+      default: !1,
+      type: Boolean
+    },
+    patternLabel: {
+      type: String,
+      required: !1,
+      default: "Pattern"
+    },
+    withTypesLabel: {
+      default: !1,
+      type: Boolean
+    },
+    typesLabel: {
+      type: String,
+      required: !1,
+      default: "Selected types"
+    },
+    /**
+     * List of possible values. Each item must have an `id` and a `text` property
+     * @example
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF'
+     * }, {
+     *   id: 'XLS',
+     *   text: 'Excel',
+     * }]
+     * For type selection, additionally, an element has to have a property `type` wich itself has properties
+     * `id` and `text`, e.g.
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF',
+     *   type: {
+     *     id: 'StringValue',
+     *     text: 'String'
+     *  }]
+     */
+    possibleValues: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * List of possible types which should be selectable but are not necessarily present in the possible values.
+     */
+    additionalPossibleTypes: {
+      type: Array,
+      default: () => []
+    },
+    compact: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    // Prop updates
+    "update:manualSelection",
+    "update:pattern",
+    "update:selectedTypes",
+    "update:mode",
+    "update:caseSensitivePattern",
+    "update:inversePattern",
+    // Non-prop update
+    "update:selected"
+  ],
+  setup(t) {
+    const { includedValues: l } = le(
+      I(t, "manualSelection")
+    );
+    return { manuallySelected: l };
+  },
+  data() {
+    return {
+      invalidPossibleValueIds: /* @__PURE__ */ new Set()
+    };
+  },
+  computed: {
+    possibleValueIds() {
+      return this.possibleValues.map(({ id: t }) => t);
+    },
+    possibleTypes() {
+      const t = this.possibleValues.map(({ type: n }) => n).filter(Boolean), l = t.map((n) => n.id);
+      return [...this.additionalPossibleTypes.filter(
+        (n) => n && !l.includes(n.id)
+      ), ...t].filter((n) => n && n.id !== "").filter(
+        // remove duplicates
+        (n, s, b) => s === b.findIndex((u) => u.id === n.id && u.text === n.text)
+      );
+    },
+    matchingValueIds() {
+      return this.possibleValues.filter((t) => this.itemMatches(t)).map((t) => t.id);
+    },
+    twinlistModelValue() {
+      return this.mode === "manual" ? this.manualSelection : this.matchingValueIds;
+    },
+    selectedValues() {
+      return this.mode === "manual" ? this.manuallySelected : this.matchingValueIds;
+    },
+    selectionDisabled() {
+      return this.disabled || this.mode !== "manual";
+    },
+    normalizedSearchTerm() {
+      return this.mode === "manual" ? null : B[this.mode].normalize(
+        this.mode === "type" ? this.selectedTypes : this.pattern,
+        this.caseSensitivePattern
+      );
+    },
+    possibleModes() {
+      let t = Object.entries(pe).map(([l, a]) => ({ id: l, text: a }));
+      return this.withTypes || (t = t.filter((l) => l.id !== "type")), t;
+    }
+  },
+  watch: {
+    selectedValues: {
+      immediate: !0,
+      handler(t, l) {
+        !l || t === null || (t.length !== l.length || l.some((a, d) => a !== t[d])) && this.$emit("update:selected", this.selectedValues);
+      }
+    }
+  },
+  methods: {
+    onManualInput(t) {
+      this.mode === "manual" && this.$emit("update:manualSelection", t);
+    },
+    onPatternInput(t) {
+      this.$emit("update:pattern", t);
+    },
+    onTypeInput(t) {
+      this.$emit("update:selectedTypes", t, this.possibleTypes);
+    },
+    onModeChange(t) {
+      this.$emit("update:mode", t);
+    },
+    onToggleCaseSensitivePattern(t) {
+      this.$emit("update:caseSensitivePattern", t);
+    },
+    onToggleInversePattern(t) {
+      this.$emit("update:inversePattern", t);
+    },
+    validate() {
+      return this.$refs.twinlist.validate();
+    },
+    hasSelection() {
+      return !!this.selectedValues?.length;
+    },
+    itemMatches(t) {
+      return B[this.mode].test(
+        this.mode === "type" ? t.type?.id : t.text,
+        this.normalizedSearchTerm,
+        this.caseSensitivePattern,
+        this.inversePattern
+      );
+    }
+  }
+};
+function he(t, l, a, d, n, s) {
+  const b = y("ValueSwitch"), u = y("Label"), S = y("FilterIcon"), V = y("SearchInput"), C = y("Checkboxes"), v = y("Twinlist");
+  return f(), x("div", {
+    class: z(["multi-mode-twinlist", { disabled: a.disabled }])
+  }, [
+    a.showMode ? (f(), T(u, {
+      key: 0,
+      active: a.withModeLabel,
+      text: a.modeLabel,
+      class: "label"
+    }, {
+      default: c(({ labelForId: r }) => [
+        h(b, {
+          id: r,
+          ref: "mode",
+          compact: a.compact,
+          "model-value": a.mode,
+          disabled: a.disabled,
+          "possible-values": s.possibleModes,
+          "onUpdate:modelValue": s.onModeChange
+        }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : P("", !0),
+    a.mode === "regex" || a.mode === "wildcard" ? (f(), T(u, {
+      key: 1,
+      active: a.withPatternLabel,
+      text: a.patternLabel,
+      class: "label"
+    }, {
+      default: c(({ labelForId: r }) => [
+        h(V, {
+          id: r,
+          ref: "search",
+          "model-value": a.pattern,
+          label: a.patternLabel,
+          "initial-case-sensitive-search": a.caseSensitivePattern,
+          "initial-inverse-search": a.inversePattern,
+          placeholder: "Pattern",
+          "show-case-sensitive-search-button": "",
+          "show-inverse-search-button": "",
+          disabled: a.disabled,
+          tooltips: {
+            inverseSearch: "Move matching to other side"
+          },
+          compact: a.compact,
+          "onUpdate:modelValue": s.onPatternInput,
+          onToggleCaseSensitiveSearch: s.onToggleCaseSensitivePattern,
+          onToggleInverseSearch: s.onToggleInversePattern
+        }, {
+          icon: c(() => [
+            h(S)
+          ]),
+          _: 2
+        }, 1032, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : P("", !0),
+    a.mode === "type" && s.possibleTypes.length > 0 ? (f(), T(u, {
+      key: 2,
+      active: a.withTypesLabel,
+      text: a.typesLabel,
+      class: "label"
+    }, {
+      default: c(() => [
+        h(C, {
+          "model-value": a.selectedTypes,
+          "possible-values": s.possibleTypes,
+          disabled: a.disabled,
+          "onUpdate:modelValue": s.onTypeInput
+        }, {
+          label: c((r) => [
+            M(t.$slots, "type", _(F(r)), void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
+      ]),
+      _: 3
+    }, 8, ["active", "text"])) : P("", !0),
+    h(v, D(t.$attrs, {
+      ref: "twinlist",
+      disabled: s.selectionDisabled,
+      "show-search": a.mode === "manual" && a.showSearch,
+      "model-value": s.twinlistModelValue,
+      "possible-values": a.possibleValues,
+      compact: a.compact,
+      "onUpdate:modelValue": s.onManualInput
+    }), {
+      option: c((r) => [
+        M(t.$slots, "option", _(F(r)), void 0, !0)
+      ]),
+      _: 3
+    }, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
+  ], 2);
+}
+const ye = /* @__PURE__ */ R(me, [["render", he], ["__scopeId", "data-v-a4487686"]]), fe = { class: "data-type-text" }, be = /* @__PURE__ */ K({
+  __name: "MultimodeTwinlistControl",
+  props: {
+    control: {},
+    handleChange: {},
+    changeValue: {},
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: {},
+    labelForId: {},
+    twinlistSize: { default: 10 },
+    twinlistLeftLabel: { default: "Excludes" },
+    showUnknownValues: { type: Boolean, default: !1 },
+    twinlistRightLabel: { default: "Includes" },
+    showTypeFilter: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const l = t;
+    let a = () => {
+    };
+    const d = (e) => {
+      const o = Z(l.control.data, e);
+      l.changeValue(o), a?.(o.manualFilter);
+    }, n = (e) => {
+      d({ selected: e });
+    }, s = (e) => {
+      if (e !== null)
+        if ("includedValues" in e) {
+          const { includedValues: o, excludedValues: i, includeUnknownValues: p } = e;
+          if (!o || !i)
+            return;
+          d({
+            manualFilter: {
+              manuallySelected: o,
+              manuallyDeselected: i,
+              includeUnknownColumns: p
+            }
+          });
+        } else
+          d({ manualFilter: { manuallySelected: e } });
+    }, b = (e) => {
+      d({ patternFilter: { pattern: e } });
+    }, u = (e) => {
+      d({ mode: e.toUpperCase() });
+    }, S = (e, o) => {
+      d({ typeFilter: { selectedTypes: e, typeDisplays: o } });
+    }, V = (e) => {
+      d({ patternFilter: { isInverted: e } });
+    }, C = (e) => {
+      d({ patternFilter: { isCaseSensitive: e } });
+    }, { possibleValues: v } = $(
+      I(l, "control")
+    ), r = Q([]), { selectedAndDeselected: L, setCurrentManualFilter: A } = se({
+      data: m(() => l.control.data),
+      possibleValueIds: m(
+        () => v.value?.map(({ id: e }) => e) ?? null
+      )
+    });
+    a = A;
+    const q = m(() => {
+      const { selected: e, deselected: o } = L.value;
+      return l.showUnknownValues ? {
+        includedValues: e,
+        excludedValues: o,
+        includeUnknownValues: l.control.data.manualFilter.includeUnknownColumns
+      } : e;
+    }), E = m(
+      () => L.value.selected === null ? X(ne) : null
+    ), O = (e) => typeof e > "u" ? {} : e.reduce(
+      (o, { id: i, text: p }) => ({ ...o, [i]: p }),
+      {}
+    ), j = () => {
+      const e = l.control.data.typeFilter;
+      if (!e)
+        return [];
+      const o = e.selectedTypes, i = O(
+        e.typeDisplays
+      );
+      return o.map((p) => ({
+        id: p,
+        text: i[p] || p
+      }));
+    };
+    r.value = j();
+    const N = m(
+      () => !!v.value?.[0]?.hasOwnProperty("type")
+    ), { excludedLabel: H, includedLabel: W } = ee(
+      I(l, "control")
+    ), G = m(() => H ?? l.twinlistLeftLabel), J = m(() => W ?? l.twinlistRightLabel);
+    return (e, o) => (f(), T(w(ye), D(e.$attrs, {
+      id: e.labelForId,
+      disabled: e.disabled,
+      "with-types": e.showTypeFilter,
+      "selected-types": e.control.data.typeFilter?.selectedTypes,
+      "additional-possible-types": r.value,
+      pattern: e.control.data.patternFilter.pattern,
+      mode: e.control.data.mode.toLowerCase(),
+      "case-sensitive-pattern": e.control.data.patternFilter.isCaseSensitive,
+      "empty-state-component": E.value,
+      "inverse-pattern": e.control.data.patternFilter.isInverted,
+      "manual-selection": q.value,
+      "include-unknown-values": e.control.data.manualFilter.includeUnknownColumns,
+      "mode-label": "Selection mode",
+      "possible-values": w(v) ?? [],
+      size: e.twinlistSize,
+      "left-label": G.value,
+      "right-label": J.value,
+      "is-valid": e.isValid,
+      compact: "",
+      "show-resize-handle": "",
+      "onUpdate:selected": n,
+      "onUpdate:manualSelection": s,
+      "onUpdate:pattern": b,
+      "onUpdate:mode": u,
+      "onUpdate:selectedTypes": S,
+      "onUpdate:inversePattern": V,
+      "onUpdate:caseSensitivePattern": C
+    }), Y({ _: 2 }, [
+      N.value ? {
+        name: "option",
+        fn: c(({ slotItem: i }) => [
+          g("div", {
+            class: z(["data-type-entry", { invalid: i.invalid }])
+          }, [
+            h(w(k), {
+              "icon-name": i?.type?.id,
+              "icon-title": i?.type?.text,
+              size: "small"
+            }, null, 8, ["icon-name", "icon-title"]),
+            g("span", null, U(i.text), 1)
+          ], 2)
+        ]),
+        key: "0"
+      } : void 0,
+      e.showTypeFilter ? {
+        name: "type",
+        fn: c(({ slotItem: i }) => [
+          h(w(k), {
+            "icon-name": i.id,
+            "icon-title": i.text,
+            size: "small"
+          }, null, 8, ["icon-name", "icon-title"]),
+          g("span", fe, U(i.text), 1)
+        ]),
+        key: "1"
+      } : void 0
+    ]), 1040, ["id", "disabled", "with-types", "selected-types", "additional-possible-types", "pattern", "mode", "case-sensitive-pattern", "empty-state-component", "inverse-pattern", "manual-selection", "include-unknown-values", "possible-values", "size", "left-label", "right-label", "is-valid"]));
+  }
+}), Me = /* @__PURE__ */ R(be, [["__scopeId", "data-v-a6fd4504"]]);
+export {
+  Me as default
+};