@knime/jsonforms 1.15.1 → 1.15.2

package/dist/ManualTwinlistControl-QbonJ1LT.js

@@ -0,0 +1,79 @@
+import { defineComponent as C, toRef as d, computed as a, markRaw as I, createBlock as k, openBlock 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-DXZusnxu.js";
+import { T as z, a as M } from "./TwinlistLoadingInfo-DbxgK_4I.js";
+import { u as x } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_2c8e8d82_lang-Cal28Ekk.js";
+import { _ as B } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-1WZC8AqN.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) => (F(), k(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-D6JvhoAd.js

@@ -0,0 +1,31 @@
+import { defineComponent as s, toRef as n, createBlock as t, openBlock as d, unref as o } from "vue";
+import { u as r } from "./usePossibleValues-DXZusnxu.js";
+import { M as u } from "./MultiselectListBox-DPzM2Ttt.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) => (d(), t(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-2Rotlohs.js

@@ -0,0 +1,499 @@
+import { createElementBlock as z, openBlock as b, createElementVNode as g, toRef as L, resolveComponent as y, normalizeClass as D, createBlock as T, createCommentVNode as I, createVNode as h, withCtx as c, renderSlot as _, normalizeProps as U, guardReactiveProps as k, mergeProps as R, defineComponent as K, ref as Q, computed as m, markRaw as X, unref as w, createSlots as Y, toDisplayString as x } from "vue";
+import { D as F } from "./index-DVwliH8a.js";
+import { m as Z } from "./index-Blg1O3Fz.js";
+import { u as $, a as ee } from "./usePossibleValues-DXZusnxu.js";
+import { a as te, S as ae, u as le, T as ne } from "./TwinlistLoadingInfo-DbxgK_4I.js";
+import { u as se } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_2c8e8d82_lang-Cal28Ekk.js";
+import { f as B } from "./useSearch-hpyYQ_6y.js";
+import { C as ie } from "./Checkboxes-Dc2mE1E7.js";
+import { y as oe, _ as A } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-1WZC8AqN.js";
+import { V as de } from "./ValueSwitch-DZ5vEThg.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 b(), z("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(
+      L(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, f) => s === f.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 f = y("ValueSwitch"), u = y("Label"), S = y("FilterIcon"), V = y("SearchInput"), C = y("Checkboxes"), v = y("Twinlist");
+  return b(), z("div", {
+    class: D(["multi-mode-twinlist", { disabled: a.disabled }])
+  }, [
+    a.showMode ? (b(), T(u, {
+      key: 0,
+      active: a.withModeLabel,
+      text: a.modeLabel,
+      class: "label"
+    }, {
+      default: c(({ labelForId: r }) => [
+        h(f, {
+          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"])) : I("", !0),
+    a.mode === "regex" || a.mode === "wildcard" ? (b(), 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"])) : I("", !0),
+    a.mode === "type" && s.possibleTypes.length > 0 ? (b(), 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) => [
+            _(t.$slots, "type", U(k(r)), void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
+      ]),
+      _: 3
+    }, 8, ["active", "text"])) : I("", !0),
+    h(v, R(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) => [
+        _(t.$slots, "option", U(k(r)), void 0, !0)
+      ]),
+      _: 3
+    }, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
+  ], 2);
+}
+const ye = /* @__PURE__ */ A(me, [["render", he], ["__scopeId", "data-v-b53c11fe"]]), be = { class: "data-type-text" }, fe = /* @__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" }
+  },
+  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 } });
+    }, f = (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 } = $(
+      L(l, "control")
+    ), r = Q([]), { selectedAndDeselected: M, setCurrentManualFilter: q } = se({
+      data: m(() => l.control.data),
+      possibleValueIds: m(
+        () => v.value?.map(({ id: e }) => e) ?? null
+      )
+    });
+    a = q;
+    const E = m(() => {
+      const { selected: e, deselected: o } = M.value;
+      return l.showUnknownValues ? {
+        includedValues: e,
+        excludedValues: o,
+        includeUnknownValues: l.control.data.manualFilter.includeUnknownColumns
+      } : e;
+    }), O = m(
+      () => M.value.selected === null ? X(ne) : null
+    ), j = (e) => typeof e > "u" ? {} : e.reduce(
+      (o, { id: i, text: p }) => ({ ...o, [i]: p }),
+      {}
+    ), N = () => {
+      const e = l.control.data.typeFilter;
+      if (!e)
+        return [];
+      const o = e.selectedTypes, i = j(
+        e.typeDisplays
+      );
+      return o.map((p) => ({
+        id: p,
+        text: i[p] || p
+      }));
+    };
+    r.value = N();
+    const P = m(
+      () => !!v.value?.[0]?.hasOwnProperty("type")
+    ), { excludedLabel: H, includedLabel: W } = ee(
+      L(l, "control")
+    ), G = m(() => H ?? l.twinlistLeftLabel), J = m(() => W ?? l.twinlistRightLabel);
+    return (e, o) => (b(), T(w(ye), R(e.$attrs, {
+      id: e.labelForId,
+      disabled: e.disabled,
+      "with-types": P.value,
+      "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": O.value,
+      "inverse-pattern": e.control.data.patternFilter.isInverted,
+      "manual-selection": E.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": f,
+      "onUpdate:mode": u,
+      "onUpdate:selectedTypes": S,
+      "onUpdate:inversePattern": V,
+      "onUpdate:caseSensitivePattern": C
+    }), Y({ _: 2 }, [
+      P.value ? {
+        name: "option",
+        fn: c(({ slotItem: i }) => [
+          g("div", {
+            class: D(["data-type-entry", { invalid: i.invalid }])
+          }, [
+            h(w(F), {
+              "icon-name": i?.type?.id,
+              "icon-title": i?.type?.text,
+              size: "small"
+            }, null, 8, ["icon-name", "icon-title"]),
+            g("span", null, x(i.text), 1)
+          ], 2)
+        ]),
+        key: "0"
+      } : void 0,
+      P.value ? {
+        name: "type",
+        fn: c(({ slotItem: i }) => [
+          h(w(F), {
+            "icon-name": i.id,
+            "icon-title": i.text,
+            size: "small"
+          }, null, 8, ["icon-name", "icon-title"]),
+          g("span", be, x(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__ */ A(fe, [["__scopeId", "data-v-2c8e8d82"]]);
+export {
+  Me as default
+};

package/dist/{MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_bd2eaa56_lang-pnMOUiIt.js → MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_2c8e8d82_lang-Cal28Ekk.js}

@@ -1,6 +1,7 @@
 import { ref as v, watch as m } from "vue";
 import { g as S, a as g } from "./index-Blg1O3Fz.js";
-import "./TwinlistLoadingInfo-Cy6HY-97.js";
+/* empty css               */
+import "./TwinlistLoadingInfo-DbxgK_4I.js";
 const w = ({
   knownValuesSide: s,
   possibleValueIds: l,
@@ -14,7 +15,7 @@ const w = ({
     ...u(s.previous),
     ...g(l, t)
   ]);
-}, F = ({
+}, j = ({
   data: s,
   possibleValueIds: l
 }) => {
@@ -27,13 +28,13 @@ const w = ({
     if (!t.value || !l.value)
       return;
     let e, o;
-    const { manuallyDeselected: f, manuallySelected: p, includeUnknownColumns: r } = t.value, i = {
-      previous: f,
+    const { manuallyDeselected: p, manuallySelected: f, includeUnknownColumns: r } = t.value, i = {
+      previous: p,
       setNext: (c) => {
         e = c;
       }
     }, d = {
-      previous: p,
+      previous: f,
       setNext: (c) => {
         o = c;
       }
@@ -61,5 +62,5 @@ const w = ({
   }), { selectedAndDeselected: n, setCurrentManualFilter: a };
 };
 export {
-  F as u
+  j as u
 };