@knime/scripting-editor 0.0.119 → 0.0.120

package/dist/MultimodeTwinlistControl-P0Bj7FYU-Dtq_ciIX.js

@@ -0,0 +1,513 @@
+import { defineComponent as J, toRef as P, ref as Q, computed as p, markRaw as Y, createBlock as w, openBlock as h, unref as f, mergeProps as _, createSlots as Z, withCtx as u, createElementVNode as S, normalizeClass as q, createVNode as c, toDisplayString as U, resolveComponent as m, createElementBlock as D, createCommentVNode as x, renderSlot as k, normalizeProps as M, guardReactiveProps as B } from "vue";
+import { X as O, u as $, s as ee } from "./parameters-TDvh_VJm.js";
+import { i as te } from "./index-Blg1O3Fz-CGafpkU1.js";
+import { t as ae, c as le } from "./usePossibleValues-CJPCrHNK-DHhG_gUy.js";
+import { w as se, f as ne, E as ie, q as oe } from "./TwinlistLoadingInfo-BFWX5bru-CmUU5ze0.js";
+import { j as de } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_0aa76d2b_lang-McCAyYfA-BvrNkbR6.js";
+import { i as z } from "./useSearch-hpyYQ_6y-BgGbVTm1.js";
+import { O as re } from "./Checkboxes-Qc7Wn4p8-B8qRgy0F.js";
+import { O as ue } from "./ValueSwitch-BmW_v2r_-DCcRA3Nu.js";
+const pe = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function ce(e, l) {
+  return h(), D("svg", pe, [...l[0] || (l[0] = [
+    S("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1)
+  ])]);
+}
+const me = { render: ce }, he = {
+  manual: "Manual",
+  wildcard: "Wildcard",
+  regex: "Regex",
+  type: "Type"
+}, ye = {
+  name: "MultiModeTwinlist",
+  components: {
+    Label: ee,
+    FilterIcon: me,
+    SearchInput: ie,
+    Checkboxes: re,
+    ValueSwitch: ue,
+    Twinlist: ne
+  },
+  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(e) {
+    const { includedValues: l } = oe(
+      P(e, "manualSelection")
+    );
+    return { manuallySelected: l };
+  },
+  data() {
+    return {
+      invalidPossibleValueIds: /* @__PURE__ */ new Set()
+    };
+  },
+  computed: {
+    possibleValueIds() {
+      return this.possibleValues.map(({ id: e }) => e);
+    },
+    possibleTypes() {
+      const e = this.possibleValues.map(({ type: t }) => t).filter(Boolean), l = e.map((t) => t.id);
+      return [...this.additionalPossibleTypes.filter(
+        (t) => t && !l.includes(t.id)
+      ), ...e].filter((t) => t && t.id !== "").filter(
+        // remove duplicates
+        (t, o, b) => o === b.findIndex((i) => i.id === t.id && i.text === t.text)
+      );
+    },
+    matchingValueIds() {
+      return this.possibleValues.filter((e) => this.itemMatches(e)).map((e) => e.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 : z[this.mode].normalize(
+        this.mode === "type" ? this.selectedTypes : this.pattern,
+        this.caseSensitivePattern
+      );
+    },
+    possibleModes() {
+      let e = Object.entries(he).map(([l, t]) => ({ id: l, text: t }));
+      return this.withTypes || (e = e.filter((l) => l.id !== "type")), e;
+    }
+  },
+  watch: {
+    selectedValues: {
+      immediate: !0,
+      handler(e, l) {
+        !l || e === null || (e.length !== l.length || l.some((t, o) => t !== e[o])) && this.$emit("update:selected", this.selectedValues);
+      }
+    }
+  },
+  methods: {
+    onManualInput(e) {
+      this.mode === "manual" && this.$emit("update:manualSelection", e);
+    },
+    onPatternInput(e) {
+      this.$emit("update:pattern", e);
+    },
+    onTypeInput(e) {
+      this.$emit("update:selectedTypes", e, this.possibleTypes);
+    },
+    onModeChange(e) {
+      this.$emit("update:mode", e);
+    },
+    onToggleCaseSensitivePattern(e) {
+      this.$emit("update:caseSensitivePattern", e);
+    },
+    onToggleInversePattern(e) {
+      this.$emit("update:inversePattern", e);
+    },
+    validate() {
+      return this.$refs.twinlist.validate();
+    },
+    hasSelection() {
+      var e;
+      return !!((e = this.selectedValues) != null && e.length);
+    },
+    itemMatches(e) {
+      var l;
+      return z[this.mode].test(
+        this.mode === "type" ? (l = e.type) == null ? void 0 : l.id : e.text,
+        this.normalizedSearchTerm,
+        this.caseSensitivePattern,
+        this.inversePattern
+      );
+    }
+  }
+};
+function ve(e, l, t, o, b, i) {
+  const g = m("ValueSwitch"), y = m("Label"), V = m("FilterIcon"), T = m("SearchInput"), I = m("Checkboxes"), v = m("Twinlist");
+  return h(), D("div", {
+    class: q(["multi-mode-twinlist", { disabled: t.disabled }])
+  }, [
+    t.showMode ? (h(), w(y, {
+      key: 0,
+      active: t.withModeLabel,
+      text: t.modeLabel,
+      class: "label"
+    }, {
+      default: u(({ labelForId: d }) => [
+        c(g, {
+          id: d,
+          ref: "mode",
+          compact: t.compact,
+          "model-value": t.mode,
+          disabled: t.disabled,
+          "possible-values": i.possibleModes,
+          "onUpdate:modelValue": i.onModeChange
+        }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : x("", !0),
+    t.mode === "regex" || t.mode === "wildcard" ? (h(), w(y, {
+      key: 1,
+      active: t.withPatternLabel,
+      text: t.patternLabel,
+      class: "label"
+    }, {
+      default: u(({ labelForId: d }) => [
+        c(T, {
+          id: d,
+          ref: "search",
+          "model-value": t.pattern,
+          label: t.patternLabel,
+          "initial-case-sensitive-search": t.caseSensitivePattern,
+          "initial-inverse-search": t.inversePattern,
+          placeholder: "Pattern",
+          "show-case-sensitive-search-button": "",
+          "show-inverse-search-button": "",
+          disabled: t.disabled,
+          tooltips: {
+            inverseSearch: "Move matching to other side"
+          },
+          compact: t.compact,
+          "onUpdate:modelValue": i.onPatternInput,
+          onToggleCaseSensitiveSearch: i.onToggleCaseSensitivePattern,
+          onToggleInverseSearch: i.onToggleInversePattern
+        }, {
+          icon: u(() => [
+            c(V)
+          ]),
+          _: 1
+        }, 8, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : x("", !0),
+    t.mode === "type" && i.possibleTypes.length > 0 ? (h(), w(y, {
+      key: 2,
+      active: t.withTypesLabel,
+      text: t.typesLabel,
+      class: "label"
+    }, {
+      default: u(() => [
+        c(I, {
+          "model-value": t.selectedTypes,
+          "possible-values": i.possibleTypes,
+          disabled: t.disabled,
+          "onUpdate:modelValue": i.onTypeInput
+        }, {
+          label: u((d) => [
+            k(e.$slots, "type", M(B(d)), void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
+      ]),
+      _: 3
+    }, 8, ["active", "text"])) : x("", !0),
+    c(v, _(e.$attrs, {
+      ref: "twinlist",
+      disabled: i.selectionDisabled,
+      "show-search": t.mode === "manual" && t.showSearch,
+      "model-value": i.twinlistModelValue,
+      "possible-values": t.possibleValues,
+      compact: t.compact,
+      "onUpdate:modelValue": i.onManualInput
+    }), {
+      option: u((d) => [
+        k(e.$slots, "option", M(B(d)), void 0, !0)
+      ]),
+      _: 3
+    }, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
+  ], 2);
+}
+const be = /* @__PURE__ */ O(ye, [["render", ve], ["__scopeId", "data-v-a4487686"]]), fe = { class: "data-type-text" }, we = /* @__PURE__ */ J({
+  __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(e) {
+    const l = e;
+    let t = () => {
+    };
+    const o = (a) => {
+      const n = te(l.control.data, a);
+      l.changeValue(n), t == null || t(n.manualFilter);
+    }, b = (a) => {
+      o({ selected: a });
+    }, i = (a) => {
+      if (a !== null)
+        if ("includedValues" in a) {
+          const { includedValues: n, excludedValues: r, includeUnknownValues: s } = a;
+          if (!n || !r)
+            return;
+          o({
+            manualFilter: {
+              manuallySelected: n,
+              manuallyDeselected: r,
+              includeUnknownColumns: s
+            }
+          });
+        } else
+          o({ manualFilter: { manuallySelected: a } });
+    }, g = (a) => {
+      o({ patternFilter: { pattern: a } });
+    }, y = (a) => {
+      o({ mode: a.toUpperCase() });
+    }, V = (a, n) => {
+      o({ typeFilter: { selectedTypes: a, typeDisplays: n } });
+    }, T = (a) => {
+      o({ patternFilter: { isInverted: a } });
+    }, I = (a) => {
+      o({ patternFilter: { isCaseSensitive: a } });
+    }, { possibleValues: v } = ae(
+      P(l, "control")
+    ), d = Q([]), { selectedAndDeselected: C, setCurrentManualFilter: R } = de({
+      data: p(() => l.control.data),
+      possibleValueIds: p(
+        () => {
+          var a;
+          return ((a = v.value) == null ? void 0 : a.map(({ id: n }) => n)) ?? null;
+        }
+      )
+    });
+    t = R;
+    const A = p(() => {
+      const { selected: a, deselected: n } = C.value;
+      return l.showUnknownValues ? {
+        includedValues: a,
+        excludedValues: n,
+        includeUnknownValues: l.control.data.manualFilter.includeUnknownColumns
+      } : a;
+    }), E = p(
+      () => C.value.selected === null ? Y(se) : null
+    ), j = (a) => typeof a > "u" ? {} : a.reduce(
+      (n, { id: r, text: s }) => ({ ...n, [r]: s }),
+      {}
+    ), N = () => {
+      const a = l.control.data.typeFilter;
+      if (!a)
+        return [];
+      const n = a.selectedTypes, r = j(
+        a.typeDisplays
+      );
+      return n.map((s) => ({
+        id: s,
+        text: r[s] || s
+      }));
+    };
+    d.value = N();
+    const H = p(
+      () => {
+        var a, n;
+        return !!((n = (a = v.value) == null ? void 0 : a[0]) != null && n.hasOwnProperty("type"));
+      }
+    ), { excludedLabel: W, includedLabel: X } = le(
+      P(l, "control")
+    ), G = p(() => W ?? l.twinlistLeftLabel), K = p(() => X ?? l.twinlistRightLabel);
+    return (a, n) => {
+      var r;
+      return h(), w(f(be), _(a.$attrs, {
+        id: e.labelForId,
+        disabled: e.disabled,
+        "with-types": e.showTypeFilter,
+        "selected-types": (r = e.control.data.typeFilter) == null ? void 0 : r.selectedTypes,
+        "additional-possible-types": d.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": A.value,
+        "include-unknown-values": e.control.data.manualFilter.includeUnknownColumns,
+        "mode-label": "Selection mode",
+        "possible-values": f(v) ?? [],
+        size: e.twinlistSize,
+        "left-label": G.value,
+        "right-label": K.value,
+        "is-valid": e.isValid,
+        compact: "",
+        "show-resize-handle": "",
+        "onUpdate:selected": b,
+        "onUpdate:manualSelection": i,
+        "onUpdate:pattern": g,
+        "onUpdate:mode": y,
+        "onUpdate:selectedTypes": V,
+        "onUpdate:inversePattern": T,
+        "onUpdate:caseSensitivePattern": I
+      }), Z({ _: 2 }, [
+        H.value ? {
+          name: "option",
+          fn: u(({ slotItem: s }) => {
+            var F, L;
+            return [
+              S("div", {
+                class: q(["data-type-entry", { invalid: s.invalid }])
+              }, [
+                c(f($), {
+                  "icon-name": (F = s == null ? void 0 : s.type) == null ? void 0 : F.id,
+                  "icon-title": (L = s == null ? void 0 : s.type) == null ? void 0 : L.text,
+                  size: "small"
+                }, null, 8, ["icon-name", "icon-title"]),
+                S("span", null, U(s.text), 1)
+              ], 2)
+            ];
+          }),
+          key: "0"
+        } : void 0,
+        e.showTypeFilter ? {
+          name: "type",
+          fn: u(({ slotItem: s }) => [
+            c(f($), {
+              "icon-name": s.id,
+              "icon-title": s.text,
+              size: "small"
+            }, null, 8, ["icon-name", "icon-title"]),
+            S("span", fe, U(s.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"]);
+    };
+  }
+}), Le = /* @__PURE__ */ O(we, [["__scopeId", "data-v-0aa76d2b"]]);
+export {
+  Le as default
+};

package/dist/MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_0aa76d2b_lang-McCAyYfA-BvrNkbR6.js

@@ -0,0 +1,64 @@
+import { ref as v, watch as m } from "vue";
+import { o as p, p as k } from "./index-Blg1O3Fz-CGafpkU1.js";
+const x = ({
+  knownValuesSide: a,
+  possibleValueIds: t,
+  unknownValuesSide: u
+}) => {
+  const l = new Set(a.previous), n = new Set(t), s = (e) => p(e, n);
+  u.setNext([
+    ...s(u.previous),
+    ...p(t, l)
+  ]), a.setNext([
+    ...s(a.previous),
+    ...k(t, l)
+  ]);
+}, N = ({
+  data: a,
+  possibleValueIds: t
+}) => {
+  const u = v({
+    selected: null,
+    deselected: null
+  }), l = v(null), n = (e) => {
+    l.value = e;
+  }, s = () => {
+    if (!l.value || !t.value)
+      return;
+    let e, o;
+    const { manuallyDeselected: w, manuallySelected: S, includeUnknownColumns: i } = l.value, r = {
+      previous: w,
+      setNext: (d) => {
+        e = d;
+      }
+    }, c = {
+      previous: S,
+      setNext: (d) => {
+        o = d;
+      }
+    }, V = i ? r : c, f = i ? c : r;
+    x({
+      possibleValueIds: t.value,
+      knownValuesSide: V,
+      unknownValuesSide: f
+    }), u.value = {
+      selected: o,
+      deselected: e
+    };
+  };
+  return m(
+    () => a.value.manualFilter,
+    (e) => {
+      Object.is(l.value, e) ? u.value = {
+        selected: e.manuallySelected,
+        deselected: e.manuallyDeselected
+      } : (l.value = e, s());
+    },
+    { immediate: !0 }
+  ), m(() => t.value, s, {
+    immediate: !0
+  }), { selectedAndDeselected: u, setCurrentManualFilter: n };
+};
+export {
+  N as j
+};