@knime/jsonforms 1.14.3 → 1.15.1

package/dist/LoadingIcon-RPBUjTO3.js

@@ -0,0 +1,23 @@
+import { h as r, defineComponent as c, createBlock as s, openBlock as i } from "vue";
+import { R as a } from "./reload-57Xc2t-6.js";
+import { _ as p } from "./SectionHeading.vue_vue_type_style_index_0_scoped_f06e9b7d_lang-B5ALSUVO.js";
+const d = (t, o) => ({
+  render() {
+    const n = t.render({}, []), e = r("title", o);
+    return e.ns = "svg", n.children.unshift(e), n;
+  }
+}), _ = /* @__PURE__ */ c({
+  __name: "LoadingIcon",
+  setup(t, { expose: o }) {
+    o();
+    const e = { ReloadIconWithTitle: d(a, "Loading…") };
+    return Object.defineProperty(e, "__isScriptSetup", { enumerable: !1, value: !0 }), e;
+  }
+});
+function l(t, o, n, e, m, u) {
+  return i(), s(e.ReloadIconWithTitle);
+}
+const h = /* @__PURE__ */ p(_, [["render", l], ["__scopeId", "data-v-903d05c8"], ["__file", "/Users/albrecht/Documents/KNIME/git/webapps-common/packages/components/src/components/LoadingIcon/LoadingIcon.vue"]]);
+export {
+  h as L
+};

package/dist/ManualTwinlistControl-DGW-7a2Q.js

@@ -0,0 +1,90 @@
+import { defineComponent as v, toRef as g, computed as a, markRaw as I, createBlock as F, openBlock as M, mergeProps as T } from "vue";
+import { m as k } from "./index-Blg1O3Fz.js";
+import { u as S, a as x } from "./usePossibleValues-DTVXBGRC.js";
+import { T as L, a as q } from "./TwinlistLoadingInfo-Cy6HY-97.js";
+import { u as U } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_bd2eaa56_lang-pnMOUiIt.js";
+import { _ as z } from "./SectionHeading.vue_vue_type_style_index_0_scoped_f06e9b7d_lang-B5ALSUVO.js";
+const D = /* @__PURE__ */ v({
+  __name: "ManualTwinlistControl",
+  props: {
+    control: { type: Object, required: !0 },
+    handleChange: { type: Function, required: !0 },
+    changeValue: { type: Function, required: !0 },
+    disabled: { type: Boolean, required: !0 },
+    isValid: { type: Boolean, required: !0 },
+    onRegisterValidation: { type: Function, required: !0 },
+    labelForId: { type: String, required: !0 }
+  },
+  setup(s, { expose: r }) {
+    r();
+    const l = s;
+    let e;
+    const o = (n) => {
+      const t = k(l.control.data, n);
+      l.changeValue(t), e?.(t);
+    }, u = (n) => {
+      if (n !== null)
+        if ("includedValues" in n) {
+          const { includedValues: t, excludedValues: f, includeUnknownValues: y } = n;
+          if (!t || !f)
+            return;
+          o({
+            manuallySelected: t,
+            manuallyDeselected: f,
+            includeUnknownColumns: y
+          });
+        } else
+          o({ manuallySelected: n });
+    }, { possibleValues: d } = S(
+      g(l, "control")
+    ), { selectedAndDeselected: i, setCurrentManualFilter: c } = U({
+      data: a(() => ({ manualFilter: l.control.data })),
+      possibleValueIds: a(
+        () => d.value?.map(({ id: n }) => n) ?? null
+      )
+    });
+    e = c;
+    const w = a(() => {
+      const { selected: n, deselected: t } = i.value;
+      return {
+        includedValues: n,
+        excludedValues: t,
+        includeUnknownValues: l.control.data.includeUnknownColumns
+      };
+    }), h = a(
+      () => i.value.selected === null ? I(L) : null
+    ), { excludedLabel: m, includedLabel: p } = x(
+      g(l, "control")
+    ), _ = a(() => m ?? "Excludes"), V = a(() => p ?? "Includes"), C = a(
+      () => l.control.uischema.options?.twinlistSize
+    ), b = { props: l, get setManualFilterOnChange() {
+      return e;
+    }, set setManualFilterOnChange(n) {
+      e = n;
+    }, onChangeTwinlist: o, onManualSelectionChange: u, possibleValues: d, selectedAndDeselected: i, setCurrentManualFilter: c, manualSelection: w, loadingInfo: h, excludedLabel: m, includedLabel: p, leftLabel: _, rightLabel: V, twinlistSize: C, get Twinlist() {
+      return q;
+    } };
+    return Object.defineProperty(b, "__isScriptSetup", { enumerable: !1, value: !0 }), b;
+  }
+});
+function O(s, r, l, e, o, u) {
+  return M(), F(e.Twinlist, T(s.$attrs, {
+    id: l.labelForId,
+    "show-search": "",
+    disabled: l.disabled,
+    "empty-state-component": e.loadingInfo,
+    "model-value": e.manualSelection,
+    "possible-values": e.possibleValues ?? [],
+    size: e.twinlistSize,
+    "left-label": e.leftLabel,
+    "right-label": e.rightLabel,
+    "is-valid": l.isValid,
+    compact: "",
+    "show-resize-handle": "",
+    "onUpdate:modelValue": e.onManualSelectionChange
+  }), null, 16, ["id", "disabled", "empty-state-component", "model-value", "possible-values", "size", "left-label", "right-label", "is-valid"]);
+}
+const K = /* @__PURE__ */ z(D, [["render", O], ["__scopeId", "data-v-a15ed4d5"], ["__file", "/Users/albrecht/Documents/KNIME/git/webapps-common/packages/jsonforms/src/uiComponents/twinlist/ManualTwinlistControl.vue"]]);
+export {
+  K as default
+};

package/dist/MultiSelectListBoxControl-BYHuC9jL.js

@@ -0,0 +1,48 @@
+import { defineComponent as r, toRef as a, createElementBlock as n, openBlock as s, Fragment as u, createCommentVNode as c, createVNode as d } from "vue";
+import { u as m } from "./usePossibleValues-DTVXBGRC.js";
+import { M as p } from "./MultiselectListBox-CfdPbcn1.js";
+import { _ as b } from "./SectionHeading.vue_vue_type_style_index_0_scoped_f06e9b7d_lang-B5ALSUVO.js";
+const _ = /* @__PURE__ */ r({
+  __name: "MultiSelectListBoxControl",
+  props: {
+    control: { type: Object, required: !0 },
+    handleChange: { type: Function, required: !0 },
+    changeValue: { type: Function, required: !0 },
+    disabled: { type: Boolean, required: !0 },
+    isValid: { type: Boolean, required: !0 },
+    onRegisterValidation: { type: Function, required: !0 },
+    labelForId: { type: String, required: !0 }
+  },
+  setup(l, { expose: i }) {
+    i();
+    const e = l, { possibleValues: t } = m(a(e, "control")), o = { props: e, possibleValues: t, get MultiselectListBox() {
+      return p;
+    } };
+    return Object.defineProperty(o, "__isScriptSetup", { enumerable: !1, value: !0 }), o;
+  }
+});
+function f(l, i, e, t, o, V) {
+  return s(), n(
+    u,
+    null,
+    [
+      c("  eslint-disable vue/attribute-hyphenation ariaLabel needs to be given like this for typescript to not complain "),
+      d(t.MultiselectListBox, {
+        id: e.labelForId,
+        "possible-values": t.possibleValues || [],
+        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"])
+    ],
+    2112
+    /* STABLE_FRAGMENT, DEV_ROOT_FRAGMENT */
+  );
+}
+const y = /* @__PURE__ */ b(_, [["render", f], ["__file", "/Users/albrecht/Documents/KNIME/git/webapps-common/packages/jsonforms/src/uiComponents/MultiSelectListBoxControl.vue"]]);
+export {
+  y as default
+};

package/dist/MultimodeTwinlistControl-oIvgI_FP.js

@@ -0,0 +1,486 @@
+import { createElementBlock as B, openBlock as h, createElementVNode as R, toRef as _, resolveComponent as p, normalizeClass as A, createBlock as v, createCommentVNode as V, createVNode as y, withCtx as b, mergeProps as q, defineComponent as K, ref as H, computed as c, markRaw as W } from "vue";
+import { m as G } from "./index-Blg1O3Fz.js";
+import { u as J, a as Q } from "./usePossibleValues-DTVXBGRC.js";
+import { a as X, S as Y, u as Z, T as $ } from "./TwinlistLoadingInfo-Cy6HY-97.js";
+import { u as ee } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_bd2eaa56_lang-pnMOUiIt.js";
+import { f as k } from "./useSearch-hpyYQ_6y.js";
+import { C as te } from "./Checkboxes-Bofcg7tl.js";
+import { y as ae, _ as D } from "./SectionHeading.vue_vue_type_style_index_0_scoped_f06e9b7d_lang-B5ALSUVO.js";
+import { V as le } from "./ValueSwitch-Ozmr1YfK.js";
+const ne = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function se(t, s) {
+  return h(), B("svg", ne, s[0] || (s[0] = [
+    R(
+      "path",
+      { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" },
+      null,
+      -1
+      /* CACHED */
+    )
+  ]));
+}
+const ie = { render: se }, oe = {
+  manual: "Manual",
+  wildcard: "Wildcard",
+  regex: "Regex",
+  type: "Type"
+}, de = {
+  name: "MultiModeTwinlist",
+  components: {
+    Label: ae,
+    FilterIcon: ie,
+    SearchInput: Y,
+    Checkboxes: te,
+    ValueSwitch: le,
+    Twinlist: X
+  },
+  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: s } = Z(
+      _(t, "manualSelection")
+    );
+    return { manuallySelected: s };
+  },
+  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), s = t.map((n) => n.id);
+      return [...this.additionalPossibleTypes.filter(
+        (n) => n && !s.includes(n.id)
+      ), ...t].filter((n) => n && n.id !== "").filter(
+        // remove duplicates
+        (n, i, f) => i === f.findIndex((d) => d.id === n.id && d.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 : k[this.mode].normalize(
+        this.mode === "type" ? this.selectedTypes : this.pattern,
+        this.caseSensitivePattern
+      );
+    },
+    possibleModes() {
+      let t = Object.entries(oe).map(([s, e]) => ({ id: s, text: e }));
+      return this.withTypes || (t = t.filter((s) => s.id !== "type")), t;
+    }
+  },
+  watch: {
+    selectedValues: {
+      immediate: !0,
+      handler(t, s) {
+        !s || t === null || (t.length !== s.length || s.some((e, l) => e !== t[l])) && 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 k[this.mode].test(
+        this.mode === "type" ? t.type?.id : t.text,
+        this.normalizedSearchTerm,
+        this.caseSensitivePattern,
+        this.inversePattern
+      );
+    }
+  }
+};
+function re(t, s, e, l, n, i) {
+  const f = p("ValueSwitch"), d = p("Label"), g = p("FilterIcon"), w = p("SearchInput"), T = p("Checkboxes"), S = p("Twinlist");
+  return h(), B(
+    "div",
+    {
+      class: A(["multi-mode-twinlist", { disabled: e.disabled }])
+    },
+    [
+      e.showMode ? (h(), v(d, {
+        key: 0,
+        active: e.withModeLabel,
+        text: e.modeLabel,
+        class: "label"
+      }, {
+        default: b(({ labelForId: r }) => [
+          y(f, {
+            id: r,
+            ref: "mode",
+            compact: e.compact,
+            "model-value": e.mode,
+            disabled: e.disabled,
+            "possible-values": i.possibleModes,
+            "onUpdate:modelValue": i.onModeChange
+          }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["active", "text"])) : V("v-if", !0),
+      e.mode === "regex" || e.mode === "wildcard" ? (h(), v(d, {
+        key: 1,
+        active: e.withPatternLabel,
+        text: e.patternLabel,
+        class: "label"
+      }, {
+        default: b(({ labelForId: r }) => [
+          y(w, {
+            id: r,
+            ref: "search",
+            "model-value": e.pattern,
+            label: e.patternLabel,
+            "initial-case-sensitive-search": e.caseSensitivePattern,
+            "initial-inverse-search": e.inversePattern,
+            placeholder: "Pattern",
+            "show-case-sensitive-search-button": "",
+            "show-inverse-search-button": "",
+            disabled: e.disabled,
+            tooltips: {
+              inverseSearch: "Move matching to other side"
+            },
+            compact: e.compact,
+            "onUpdate:modelValue": i.onPatternInput,
+            onToggleCaseSensitiveSearch: i.onToggleCaseSensitivePattern,
+            onToggleInverseSearch: i.onToggleInversePattern
+          }, {
+            icon: b(() => [
+              y(g)
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, 1032, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["active", "text"])) : V("v-if", !0),
+      e.mode === "type" && i.possibleTypes.length > 0 ? (h(), v(d, {
+        key: 2,
+        active: e.withTypesLabel,
+        text: e.typesLabel,
+        class: "label"
+      }, {
+        default: b(() => [
+          y(T, {
+            "model-value": e.selectedTypes,
+            "possible-values": i.possibleTypes,
+            disabled: e.disabled,
+            "onUpdate:modelValue": i.onTypeInput
+          }, null, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["active", "text"])) : V("v-if", !0),
+      y(S, q(t.$attrs, {
+        ref: "twinlist",
+        disabled: i.selectionDisabled,
+        "show-search": e.mode === "manual" && e.showSearch,
+        "model-value": i.twinlistModelValue,
+        "possible-values": e.possibleValues,
+        compact: e.compact,
+        "onUpdate:modelValue": i.onManualInput
+      }), null, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
+    ],
+    2
+    /* CLASS */
+  );
+}
+const ue = /* @__PURE__ */ D(de, [["render", re], ["__scopeId", "data-v-78d78d5f"], ["__file", "/Users/albrecht/Documents/KNIME/git/webapps-common/packages/components/src/components/forms/MultiModeTwinlist/MultiModeTwinlist.vue"]]), ce = /* @__PURE__ */ K({
+  __name: "MultimodeTwinlistControl",
+  props: {
+    control: { type: Object, required: !0 },
+    handleChange: { type: Function, required: !0 },
+    changeValue: { type: Function, required: !0 },
+    disabled: { type: Boolean, required: !0 },
+    isValid: { type: Boolean, required: !0 },
+    onRegisterValidation: { type: Function, required: !0 },
+    labelForId: { type: String, required: !0 },
+    twinlistSize: { type: Number, required: !1, default: 10 },
+    twinlistLeftLabel: { type: String, required: !1, default: "Excludes" },
+    showUnknownValues: { type: Boolean, required: !1, default: !1 },
+    twinlistRightLabel: { type: String, required: !1, default: "Includes" }
+  },
+  setup(t, { expose: s }) {
+    s();
+    const e = t;
+    let l = () => {
+    };
+    const n = (a) => {
+      const o = G(e.control.data, a);
+      e.changeValue(o), l?.(o.manualFilter);
+    }, i = (a) => {
+      n({ selected: a });
+    }, f = (a) => {
+      if (a !== null)
+        if ("includedValues" in a) {
+          const { includedValues: o, excludedValues: m, includeUnknownValues: u } = a;
+          if (!o || !m)
+            return;
+          n({
+            manualFilter: {
+              manuallySelected: o,
+              manuallyDeselected: m,
+              includeUnknownColumns: u
+            }
+          });
+        } else
+          n({ manualFilter: { manuallySelected: a } });
+    }, d = (a) => {
+      n({ patternFilter: { pattern: a } });
+    }, g = (a) => {
+      n({ mode: a.toUpperCase() });
+    }, w = (a, o) => {
+      n({ typeFilter: { selectedTypes: a, typeDisplays: o } });
+    }, T = (a) => {
+      n({ patternFilter: { isInverted: a } });
+    }, S = (a) => {
+      n({ patternFilter: { isCaseSensitive: a } });
+    }, { possibleValues: r } = J(
+      _(e, "control")
+    ), M = H([]), { selectedAndDeselected: C, setCurrentManualFilter: I } = ee({
+      data: c(() => e.control.data),
+      possibleValueIds: c(
+        () => r.value?.map(({ id: a }) => a) ?? null
+      )
+    });
+    l = I;
+    const z = c(() => {
+      const { selected: a, deselected: o } = C.value;
+      return e.showUnknownValues ? {
+        includedValues: a,
+        excludedValues: o,
+        includeUnknownValues: e.control.data.manualFilter.includeUnknownColumns
+      } : a;
+    }), O = c(
+      () => C.value.selected === null ? W($) : null
+    ), L = (a) => typeof a > "u" ? {} : a.reduce(
+      (o, { id: m, text: u }) => ({ ...o, [m]: u }),
+      {}
+    ), P = () => {
+      const a = e.control.data.typeFilter;
+      if (!a)
+        return [];
+      const o = a.selectedTypes, m = L(
+        a.typeDisplays
+      );
+      return o.map((u) => ({
+        id: u,
+        text: m[u] || u
+      }));
+    };
+    M.value = P();
+    const j = c(
+      () => !!r.value?.[0]?.hasOwnProperty("type")
+    ), { excludedLabel: x, includedLabel: F } = Q(
+      _(e, "control")
+    ), E = c(() => x ?? e.twinlistLeftLabel), N = c(() => F ?? e.twinlistRightLabel), U = { props: e, get setManualFilterOnChange() {
+      return l;
+    }, set setManualFilterOnChange(a) {
+      l = a;
+    }, onChangeTwinlist: n, onSelectedChange: i, onManualSelectionChange: f, onPatternChange: d, onModeChange: g, onSelectedTypesChange: w, onInversePatternChange: T, onCaseSensitiveChange: S, possibleValues: r, previouslySelectedTypes: M, selectedAndDeselected: C, setCurrentManualFilter: I, manualSelection: z, loadingInfo: O, typeDisplaysToMap: L, getPreviouslySelectedTypes: P, withTypes: j, excludedLabel: x, includedLabel: F, leftLabel: E, rightLabel: N, get MultiModeTwinList() {
+      return ue;
+    } };
+    return Object.defineProperty(U, "__isScriptSetup", { enumerable: !1, value: !0 }), U;
+  }
+});
+function me(t, s, e, l, n, i) {
+  return h(), v(l.MultiModeTwinList, q(t.$attrs, {
+    id: e.labelForId,
+    disabled: e.disabled,
+    "with-types": l.withTypes,
+    "selected-types": e.control.data.typeFilter?.selectedTypes,
+    "additional-possible-types": l.previouslySelectedTypes,
+    pattern: e.control.data.patternFilter.pattern,
+    mode: e.control.data.mode.toLowerCase(),
+    "case-sensitive-pattern": e.control.data.patternFilter.isCaseSensitive,
+    "empty-state-component": l.loadingInfo,
+    "inverse-pattern": e.control.data.patternFilter.isInverted,
+    "manual-selection": l.manualSelection,
+    "include-unknown-values": e.control.data.manualFilter.includeUnknownColumns,
+    "mode-label": "Selection mode",
+    "possible-values": l.possibleValues ?? [],
+    size: e.twinlistSize,
+    "left-label": l.leftLabel,
+    "right-label": l.rightLabel,
+    "is-valid": e.isValid,
+    compact: "",
+    "show-resize-handle": "",
+    "onUpdate:selected": l.onSelectedChange,
+    "onUpdate:manualSelection": l.onManualSelectionChange,
+    "onUpdate:pattern": l.onPatternChange,
+    "onUpdate:mode": l.onModeChange,
+    "onUpdate:selectedTypes": l.onSelectedTypesChange,
+    "onUpdate:inversePattern": l.onInversePatternChange,
+    "onUpdate:caseSensitivePattern": l.onCaseSensitiveChange
+  }), null, 16, ["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"]);
+}
+const Se = /* @__PURE__ */ D(ce, [["render", me], ["__scopeId", "data-v-bd2eaa56"], ["__file", "/Users/albrecht/Documents/KNIME/git/webapps-common/packages/jsonforms/src/uiComponents/twinlist/MultimodeTwinlistControl.vue"]]);
+export {
+  Se as default
+};

package/dist/{MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_37fe7036_lang-DGKMWtLi.js → MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_bd2eaa56_lang-pnMOUiIt.js}

@@ -1,6 +1,6 @@
 import { ref as v, watch as m } from "vue";
 import { g as S, a as g } from "./index-Blg1O3Fz.js";
-import "./TwinlistLoadingInfo-CQRx9cEu.js";
+import "./TwinlistLoadingInfo-Cy6HY-97.js";
 const w = ({
   knownValuesSide: s,
   possibleValueIds: l,