@knime/jsonforms 1.21.0 → 1.21.1

package/dist/MultimodeTwinlistControl-Cx8g1mbI.js

@@ -1,598 +0,0 @@
-import { resolveComponent as f, openBlock as m, createElementBlock as S, normalizeClass as M, Fragment as J, renderList as Q, createBlock as g, withCtx as c, renderSlot as k, createTextVNode as X, toDisplayString as I, createElementVNode as V, toRef as L, createVNode as b, createCommentVNode as P, normalizeProps as _, guardReactiveProps as B, mergeProps as A, defineComponent as Y, ref as Z, computed as y, markRaw as $, unref as T, createSlots as ee } from "vue";
-import { _ as U, a5 as te, a3 as z } from "./SimpleButtonControl.vue_vue_type_style_index_0_scoped_17a4a240_lang-D4snRy74.js";
-import { m as ae } from "./index-Blg1O3Fz.js";
-import { u as le, a as ne } from "./usePossibleValues-CdNvUspy.js";
-import { a as se, S as ie, u as oe, T as de } from "./TwinlistLoadingInfo-BwuYp151.js";
-import { u as re } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_0aa76d2b_lang-De2_vatY.js";
-import { f as D } from "./useSearch-hpyYQ_6y.js";
-import { C as ue } from "./Checkbox-uBRF2ZKG.js";
-import { V as ce } from "./ValueSwitch-BuQf-fpg.js";
-const me = {
-  name: "Checkboxes",
-  components: {
-    Checkbox: ue
-  },
-  props: {
-    /**
-     * List of possible values. Each item must have an `id` and a `text` property.
-     * @example
-     * [{
-     *   id: 'pdf',
-     *   text: 'PDF'
-     * }, {
-     *   id: 'XLS',
-     *   text: 'Excel',
-     * }]
-     */
-    possibleValues: {
-      type: Array,
-      default: () => [],
-      validator(e) {
-        return Array.isArray(e) ? e.every(
-          (a) => a.hasOwnProperty("id") && a.hasOwnProperty("text")
-        ) : !1;
-      }
-    },
-    /**
-     * Controls the alignment
-     */
-    alignment: {
-      type: String,
-      default: "horizontal",
-      validator(e) {
-        return ["horizontal", "vertical"].includes(e);
-      }
-    },
-    disabled: {
-      type: Boolean,
-      default: !1
-    },
-    isValid: {
-      default: !0,
-      type: Boolean
-    },
-    /**
-     * selected value (which is a list of ids of entries)
-     */
-    modelValue: {
-      type: Array,
-      default: () => []
-    }
-  },
-  emits: ["update:modelValue"],
-  methods: {
-    validate() {
-      const e = !this.possibleValues.some((a) => a.invalid);
-      return {
-        isValid: e,
-        errorMessage: e ? null : "One or more of the selected items is invalid."
-      };
-    },
-    onUpdateModelValue(e, a) {
-      let t = Array.from(this.modelValue);
-      a ? t.indexOf(e) === -1 && t.push(e) : t = t.filter((o) => o !== e), consola.trace("Checkboxes value changed to", t), this.$emit("update:modelValue", t);
-    },
-    /**
-     * Is at least one checkbox checked?
-     * @returns {boolean}
-     */
-    hasSelection() {
-      return this.$refs.boxes.some((e) => e.isChecked());
-    }
-  }
-};
-function pe(e, a, t, o, s, n) {
-  const p = f("Checkbox");
-  return m(), S("div", {
-    class: M(["checkboxes", t.alignment])
-  }, [
-    (m(!0), S(J, null, Q(t.possibleValues, (i) => (m(), g(p, {
-      ref_for: !0,
-      ref: "boxes",
-      key: `checkboxes-${i.id}`,
-      "model-value": t.modelValue.indexOf(i.id) > -1,
-      title: i.text,
-      invalid: i.invalid,
-      disabled: t.disabled,
-      class: "box",
-      "onUpdate:modelValue": (v) => n.onUpdateModelValue(i.id, v)
-    }, {
-      default: c(() => [
-        k(e.$slots, "label", { slotItem: i }, () => [
-          X(I(i.text), 1)
-        ], !0)
-      ]),
-      _: 2
-    }, 1032, ["model-value", "title", "invalid", "disabled", "onUpdate:modelValue"]))), 128))
-  ], 2);
-}
-const he = /* @__PURE__ */ U(me, [["render", pe], ["__scopeId", "data-v-c83ea4f7"]]), ye = {
-  xmlns: "http://www.w3.org/2000/svg",
-  fill: "none",
-  stroke: "#000",
-  "stroke-linejoin": "round",
-  viewBox: "0 0 32 32"
-};
-function fe(e, a) {
-  return m(), S("svg", ye, [...a[0] || (a[0] = [
-    V("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1)
-  ])]);
-}
-const be = { render: fe }, ve = {
-  manual: "Manual",
-  wildcard: "Wildcard",
-  regex: "Regex",
-  type: "Type"
-}, we = {
-  name: "MultiModeTwinlist",
-  components: {
-    Label: te,
-    FilterIcon: be,
-    SearchInput: ie,
-    Checkboxes: he,
-    ValueSwitch: ce,
-    Twinlist: se
-  },
-  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: a } = oe(
-      L(e, "manualSelection")
-    );
-    return { manuallySelected: a };
-  },
-  data() {
-    return {
-      invalidPossibleValueIds: /* @__PURE__ */ new Set()
-    };
-  },
-  computed: {
-    possibleValueIds() {
-      return this.possibleValues.map(({ id: e }) => e);
-    },
-    possibleTypes() {
-      const e = this.possibleValues.map(({ type: s }) => s).filter(Boolean), a = e.map((s) => s.id);
-      return [...this.additionalPossibleTypes.filter(
-        (s) => s && !a.includes(s.id)
-      ), ...e].filter((s) => s && s.id !== "").filter(
-        // remove duplicates
-        (s, n, p) => n === p.findIndex((i) => i.id === s.id && i.text === s.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 : D[this.mode].normalize(
-        this.mode === "type" ? this.selectedTypes : this.pattern,
-        this.caseSensitivePattern
-      );
-    },
-    possibleModes() {
-      let e = Object.entries(ve).map(([a, t]) => ({ id: a, text: t }));
-      return this.withTypes || (e = e.filter((a) => a.id !== "type")), e;
-    }
-  },
-  watch: {
-    selectedValues: {
-      immediate: !0,
-      handler(e, a) {
-        !a || e === null || (e.length !== a.length || a.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() {
-      return !!this.selectedValues?.length;
-    },
-    itemMatches(e) {
-      return D[this.mode].test(
-        this.mode === "type" ? e.type?.id : e.text,
-        this.normalizedSearchTerm,
-        this.caseSensitivePattern,
-        this.inversePattern
-      );
-    }
-  }
-};
-function ge(e, a, t, o, s, n) {
-  const p = f("ValueSwitch"), i = f("Label"), v = f("FilterIcon"), x = f("SearchInput"), C = f("Checkboxes"), w = f("Twinlist");
-  return m(), S("div", {
-    class: M(["multi-mode-twinlist", { disabled: t.disabled }])
-  }, [
-    t.showMode ? (m(), g(i, {
-      key: 0,
-      active: t.withModeLabel,
-      text: t.modeLabel,
-      class: "label"
-    }, {
-      default: c(({ labelForId: u }) => [
-        b(p, {
-          id: u,
-          ref: "mode",
-          compact: t.compact,
-          "model-value": t.mode,
-          disabled: t.disabled,
-          "possible-values": n.possibleModes,
-          "onUpdate:modelValue": n.onModeChange
-        }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
-      ]),
-      _: 1
-    }, 8, ["active", "text"])) : P("", !0),
-    t.mode === "regex" || t.mode === "wildcard" ? (m(), g(i, {
-      key: 1,
-      active: t.withPatternLabel,
-      text: t.patternLabel,
-      class: "label"
-    }, {
-      default: c(({ labelForId: u }) => [
-        b(x, {
-          id: u,
-          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": n.onPatternInput,
-          onToggleCaseSensitiveSearch: n.onToggleCaseSensitivePattern,
-          onToggleInverseSearch: n.onToggleInversePattern
-        }, {
-          icon: c(() => [
-            b(v)
-          ]),
-          _: 1
-        }, 8, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
-      ]),
-      _: 1
-    }, 8, ["active", "text"])) : P("", !0),
-    t.mode === "type" && n.possibleTypes.length > 0 ? (m(), g(i, {
-      key: 2,
-      active: t.withTypesLabel,
-      text: t.typesLabel,
-      class: "label"
-    }, {
-      default: c(() => [
-        b(C, {
-          "model-value": t.selectedTypes,
-          "possible-values": n.possibleTypes,
-          disabled: t.disabled,
-          "onUpdate:modelValue": n.onTypeInput
-        }, {
-          label: c((u) => [
-            k(e.$slots, "type", _(B(u)), void 0, !0)
-          ]),
-          _: 3
-        }, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
-      ]),
-      _: 3
-    }, 8, ["active", "text"])) : P("", !0),
-    b(w, A(e.$attrs, {
-      ref: "twinlist",
-      disabled: n.selectionDisabled,
-      "show-search": t.mode === "manual" && t.showSearch,
-      "model-value": n.twinlistModelValue,
-      "possible-values": t.possibleValues,
-      compact: t.compact,
-      "onUpdate:modelValue": n.onManualInput
-    }), {
-      option: c((u) => [
-        k(e.$slots, "option", _(B(u)), void 0, !0)
-      ]),
-      _: 3
-    }, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
-  ], 2);
-}
-const Te = /* @__PURE__ */ U(we, [["render", ge], ["__scopeId", "data-v-a4487686"]]), Ve = { class: "data-type-text" }, Se = /* @__PURE__ */ Y({
-  __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 a = e;
-    let t = () => {
-    };
-    const o = (l) => {
-      const r = ae(a.control.data, l);
-      a.changeValue(r), t?.(r.manualFilter);
-    }, s = (l) => {
-      o({ selected: l });
-    }, n = (l) => {
-      if (l !== null)
-        if ("includedValues" in l) {
-          const { includedValues: r, excludedValues: d, includeUnknownValues: h } = l;
-          if (!r || !d)
-            return;
-          o({
-            manualFilter: {
-              manuallySelected: r,
-              manuallyDeselected: d,
-              includeUnknownColumns: h
-            }
-          });
-        } else
-          o({ manualFilter: { manuallySelected: l } });
-    }, p = (l) => {
-      o({ patternFilter: { pattern: l } });
-    }, i = (l) => {
-      o({ mode: l.toUpperCase() });
-    }, v = (l, r) => {
-      o({ typeFilter: { selectedTypes: l, typeDisplays: r } });
-    }, x = (l) => {
-      o({ patternFilter: { isInverted: l } });
-    }, C = (l) => {
-      o({ patternFilter: { isCaseSensitive: l } });
-    }, { possibleValues: w } = le(
-      L(a, "control")
-    ), u = Z([]), { selectedAndDeselected: F, setCurrentManualFilter: O } = re({
-      data: y(() => a.control.data),
-      possibleValueIds: y(
-        () => w.value?.map(({ id: l }) => l) ?? null
-      )
-    });
-    t = O;
-    const R = y(() => {
-      const { selected: l, deselected: r } = F.value;
-      return a.showUnknownValues ? {
-        includedValues: l,
-        excludedValues: r,
-        includeUnknownValues: a.control.data.manualFilter.includeUnknownColumns
-      } : l;
-    }), q = y(
-      () => F.value.selected === null ? $(de) : null
-    ), E = (l) => typeof l > "u" ? {} : l.reduce(
-      (r, { id: d, text: h }) => ({ ...r, [d]: h }),
-      {}
-    ), N = () => {
-      const l = a.control.data.typeFilter;
-      if (!l)
-        return [];
-      const r = l.selectedTypes, d = E(
-        l.typeDisplays
-      );
-      return r.map((h) => ({
-        id: h,
-        text: d[h] || h
-      }));
-    };
-    u.value = N();
-    const j = y(
-      () => !!w.value?.[0]?.hasOwnProperty("type")
-    ), { excludedLabel: H, includedLabel: K } = ne(
-      L(a, "control")
-    ), W = y(() => H ?? a.twinlistLeftLabel), G = y(() => K ?? a.twinlistRightLabel);
-    return (l, r) => (m(), g(T(Te), A(l.$attrs, {
-      id: e.labelForId,
-      disabled: e.disabled,
-      "with-types": e.showTypeFilter,
-      "selected-types": e.control.data.typeFilter?.selectedTypes,
-      "additional-possible-types": u.value,
-      pattern: e.control.data.patternFilter.pattern,
-      mode: e.control.data.mode.toLowerCase(),
-      "case-sensitive-pattern": e.control.data.patternFilter.isCaseSensitive,
-      "empty-state-component": q.value,
-      "inverse-pattern": e.control.data.patternFilter.isInverted,
-      "manual-selection": R.value,
-      "include-unknown-values": e.control.data.manualFilter.includeUnknownColumns,
-      "mode-label": "Selection mode",
-      "possible-values": T(w) ?? [],
-      size: e.twinlistSize,
-      "left-label": W.value,
-      "right-label": G.value,
-      "is-valid": e.isValid,
-      compact: "",
-      "show-resize-handle": "",
-      "onUpdate:selected": s,
-      "onUpdate:manualSelection": n,
-      "onUpdate:pattern": p,
-      "onUpdate:mode": i,
-      "onUpdate:selectedTypes": v,
-      "onUpdate:inversePattern": x,
-      "onUpdate:caseSensitivePattern": C
-    }), ee({ _: 2 }, [
-      j.value ? {
-        name: "option",
-        fn: c(({ slotItem: d }) => [
-          V("div", {
-            class: M(["data-type-entry", { invalid: d.invalid }])
-          }, [
-            b(T(z), {
-              "icon-name": d?.type?.id,
-              "icon-title": d?.type?.text,
-              size: "small"
-            }, null, 8, ["icon-name", "icon-title"]),
-            V("span", null, I(d.text), 1)
-          ], 2)
-        ]),
-        key: "0"
-      } : void 0,
-      e.showTypeFilter ? {
-        name: "type",
-        fn: c(({ slotItem: d }) => [
-          b(T(z), {
-            "icon-name": d.id,
-            "icon-title": d.text,
-            size: "small"
-          }, null, 8, ["icon-name", "icon-title"]),
-          V("span", Ve, I(d.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"]));
-  }
-}), _e = /* @__PURE__ */ U(Se, [["__scopeId", "data-v-0aa76d2b"]]);
-export {
-  _e as default
-};