@knime/jsonforms 1.11.4 → 1.12.1

package/dist/MultimodeTwinlistControl-CwPCFa9I.js

@@ -1,526 +0,0 @@
-import { openBlock as f, createElementBlock as k, createElementVNode as H, toRef as P, resolveComponent as y, normalizeClass as W, createBlock as I, withCtx as V, createVNode as g, createCommentVNode as M, mergeProps as B, ref as L, watch as U, defineComponent as G, computed as h, markRaw as J, unref as _ } from "vue";
-import { g as x, a as K, m as Q } from "./index-Blg1O3Fz.js";
-import { u as X, a as Y } from "./usePossibleValues-DY3q9YuR.js";
-import { S as Z, a as $, u as ee, T as te } from "./TwinlistLoadingInfo-D6z3t2c9.js";
-import { f as F } from "./useSearch-hpyYQ_6y.js";
-import { C as le } from "./Checkboxes-C8MYjELb.js";
-import { v as ae, _ as z } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-CLPIgtdX.js";
-import { V as ne } from "./ValueSwitch-D6Wu1NDa.js";
-const se = {
-  xmlns: "http://www.w3.org/2000/svg",
-  fill: "none",
-  stroke: "#000",
-  "stroke-linejoin": "round",
-  viewBox: "0 0 32 32"
-};
-function ie(e, a) {
-  return f(), k("svg", se, a[0] || (a[0] = [
-    H("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1)
-  ]));
-}
-const oe = { render: ie }, de = {
-  manual: "Manual",
-  wildcard: "Wildcard",
-  regex: "Regex",
-  type: "Type"
-}, ue = {
-  name: "MultiModeTwinlist",
-  components: {
-    Label: ae,
-    FilterIcon: oe,
-    SearchInput: Z,
-    Checkboxes: le,
-    ValueSwitch: ne,
-    Twinlist: $
-  },
-  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 } = ee(
-      P(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: i }) => i).filter(Boolean), a = e.map((i) => i.id);
-      return [...this.additionalPossibleTypes.filter(
-        (i) => i && !a.includes(i.id)
-      ), ...e].filter((i) => i && i.id !== "").filter(
-        // remove duplicates
-        (i, s, d) => s === d.findIndex((u) => u.id === i.id && u.text === i.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 : F[this.mode].normalize(
-        this.mode === "type" ? this.selectedTypes : this.pattern,
-        this.caseSensitivePattern
-      );
-    },
-    possibleModes() {
-      let e = Object.entries(de).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, n) => t !== e[n])) && 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 t;
-      return F[this.mode].test(
-        this.mode === "type" ? (t = e.type) == null ? void 0 : t.id : e.text,
-        this.normalizedSearchTerm,
-        this.caseSensitivePattern,
-        this.inversePattern
-      );
-    }
-  }
-};
-function re(e, a, t, n, i, s) {
-  const d = y("ValueSwitch"), u = y("Label"), b = y("FilterIcon"), w = y("SearchInput"), v = y("Checkboxes"), p = y("Twinlist");
-  return f(), k("div", {
-    class: W(["multi-mode-twinlist", { disabled: t.disabled }])
-  }, [
-    t.showMode ? (f(), I(u, {
-      key: 0,
-      active: t.withModeLabel,
-      text: t.modeLabel,
-      class: "label"
-    }, {
-      default: V(({ labelForId: r }) => [
-        g(d, {
-          id: r,
-          ref: "mode",
-          compact: t.compact,
-          "model-value": t.mode,
-          disabled: t.disabled,
-          "possible-values": s.possibleModes,
-          "onUpdate:modelValue": s.onModeChange
-        }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
-      ]),
-      _: 1
-    }, 8, ["active", "text"])) : M("", !0),
-    t.mode === "regex" || t.mode === "wildcard" ? (f(), I(u, {
-      key: 1,
-      active: t.withPatternLabel,
-      text: t.patternLabel,
-      class: "label"
-    }, {
-      default: V(({ labelForId: r }) => [
-        g(w, {
-          id: r,
-          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": s.onPatternInput,
-          onToggleCaseSensitiveSearch: s.onToggleCaseSensitivePattern,
-          onToggleInverseSearch: s.onToggleInversePattern
-        }, {
-          icon: V(() => [
-            g(b)
-          ]),
-          _: 2
-        }, 1032, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
-      ]),
-      _: 1
-    }, 8, ["active", "text"])) : M("", !0),
-    t.mode === "type" && s.possibleTypes.length > 0 ? (f(), I(u, {
-      key: 2,
-      active: t.withTypesLabel,
-      text: t.typesLabel,
-      class: "label"
-    }, {
-      default: V(() => [
-        g(v, {
-          "model-value": t.selectedTypes,
-          "possible-values": s.possibleTypes,
-          disabled: t.disabled,
-          "onUpdate:modelValue": s.onTypeInput
-        }, null, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
-      ]),
-      _: 1
-    }, 8, ["active", "text"])) : M("", !0),
-    g(p, B(e.$attrs, {
-      ref: "twinlist",
-      disabled: s.selectionDisabled,
-      "show-search": t.mode === "manual" && t.showSearch,
-      "model-value": s.twinlistModelValue,
-      "possible-values": t.possibleValues,
-      compact: t.compact,
-      "onUpdate:modelValue": s.onManualInput
-    }), null, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
-  ], 2);
-}
-const ce = /* @__PURE__ */ z(ue, [["render", re], ["__scopeId", "data-v-e5a6658e"]]), pe = ({
-  knownValuesSide: e,
-  possibleValueIds: a,
-  unknownValuesSide: t
-}) => {
-  const n = new Set(e.previous), i = new Set(a), s = (d) => x(d, i);
-  t.setNext([
-    ...s(t.previous),
-    ...x(a, n)
-  ]), e.setNext([
-    ...s(e.previous),
-    ...K(a, n)
-  ]);
-}, me = ({
-  data: e,
-  possibleValueIds: a
-}) => {
-  const t = L({
-    selected: null,
-    deselected: null
-  }), n = L(null), i = (d) => {
-    n.value = d;
-  }, s = () => {
-    if (!n.value || !a.value)
-      return;
-    let d, u;
-    const { manuallyDeselected: b, manuallySelected: w, includeUnknownColumns: v } = n.value, p = {
-      previous: b,
-      setNext: (S) => {
-        d = S;
-      }
-    }, r = {
-      previous: w,
-      setNext: (S) => {
-        u = S;
-      }
-    }, T = v ? p : r, C = v ? r : p;
-    pe({
-      possibleValueIds: a.value,
-      knownValuesSide: T,
-      unknownValuesSide: C
-    }), t.value = {
-      selected: u,
-      deselected: d
-    };
-  };
-  return U(
-    () => e.value.manualFilter,
-    (d) => {
-      Object.is(n.value, d) ? t.value = {
-        selected: d.manuallySelected,
-        deselected: d.manuallyDeselected
-      } : (n.value = d, s());
-    },
-    { immediate: !0 }
-  ), U(() => a.value, s, {
-    immediate: !0
-  }), { selectedAndDeselected: t, setCurrentManualFilter: i };
-}, he = /* @__PURE__ */ G({
-  __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(e) {
-    const a = e;
-    let t;
-    const n = (l) => {
-      const o = Q(a.control.data, l);
-      a.changeValue(o), t == null || t(o.manualFilter);
-    }, i = (l) => {
-      n({ selected: l });
-    }, s = (l) => {
-      if (l !== null)
-        if ("includedValues" in l) {
-          const { includedValues: o, excludedValues: c, includeUnknownValues: m } = l;
-          if (!o || !c)
-            return;
-          n({
-            manualFilter: {
-              manuallySelected: o,
-              manuallyDeselected: c,
-              includeUnknownColumns: m
-            }
-          });
-        } else
-          n({ manualFilter: { manuallySelected: l } });
-    }, d = (l) => {
-      n({ patternFilter: { pattern: l } });
-    }, u = (l) => {
-      n({ mode: l.toUpperCase() });
-    }, b = (l, o) => {
-      n({ typeFilter: { selectedTypes: l, typeDisplays: o } });
-    }, w = (l) => {
-      n({ patternFilter: { isInverted: l } });
-    }, v = (l) => {
-      n({ patternFilter: { isCaseSensitive: l } });
-    }, { possibleValues: p } = X(
-      P(a, "control")
-    ), r = L([]), { selectedAndDeselected: T, setCurrentManualFilter: C } = me({
-      data: h(() => a.control.data),
-      possibleValueIds: h(
-        () => {
-          var l;
-          return ((l = p.value) == null ? void 0 : l.map(({ id: o }) => o)) ?? null;
-        }
-      )
-    });
-    t = C;
-    const S = h(() => {
-      const { selected: l, deselected: o } = T.value;
-      return a.showUnknownValues ? {
-        includedValues: l,
-        excludedValues: o,
-        includeUnknownValues: a.control.data.manualFilter.includeUnknownColumns
-      } : l;
-    }), D = h(
-      () => T.value.selected === null ? J(te) : null
-    ), N = (l) => typeof l > "u" ? {} : l.reduce(
-      (o, { id: c, text: m }) => ({ ...o, [c]: m }),
-      {}
-    ), A = () => {
-      const l = a.control.data.typeFilter;
-      if (!l)
-        return [];
-      const o = l.selectedTypes, c = N(
-        l.typeDisplays
-      );
-      return o.map((m) => ({
-        id: m,
-        text: c[m] || m
-      }));
-    };
-    r.value = A();
-    const R = h(
-      () => {
-        var l, o;
-        return !!((o = (l = p.value) == null ? void 0 : l[0]) != null && o.hasOwnProperty("type"));
-      }
-    ), { excludedLabel: j, includedLabel: q } = Y(
-      P(a, "control")
-    ), E = h(() => j ?? a.twinlistLeftLabel), O = h(() => q ?? a.twinlistRightLabel);
-    return (l, o) => {
-      var c;
-      return f(), I(_(ce), B(l.$attrs, {
-        id: l.labelForId,
-        disabled: l.disabled,
-        "with-types": R.value,
-        "selected-types": (c = l.control.data.typeFilter) == null ? void 0 : c.selectedTypes,
-        "additional-possible-types": r.value,
-        pattern: l.control.data.patternFilter.pattern,
-        mode: l.control.data.mode.toLowerCase(),
-        "case-sensitive-pattern": l.control.data.patternFilter.isCaseSensitive,
-        "empty-state-component": D.value,
-        "inverse-pattern": l.control.data.patternFilter.isInverted,
-        "manual-selection": S.value,
-        "include-unknown-values": l.control.data.manualFilter.includeUnknownColumns,
-        "mode-label": "Selection mode",
-        "possible-values": _(p) ?? [],
-        size: l.twinlistSize,
-        "left-label": E.value,
-        "right-label": O.value,
-        "is-valid": l.isValid,
-        compact: "",
-        "show-resize-handle": "",
-        "onUpdate:selected": i,
-        "onUpdate:manualSelection": s,
-        "onUpdate:pattern": d,
-        "onUpdate:mode": u,
-        "onUpdate:selectedTypes": b,
-        "onUpdate:inversePattern": w,
-        "onUpdate:caseSensitivePattern": v
-      }), 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"]);
-    };
-  }
-}), Ve = /* @__PURE__ */ z(he, [["__scopeId", "data-v-52473411"]]);
-export {
-  Ve as default
-};

package/dist/SettingsSubPanel-CjuhpEr4.js

@@ -1,5 +0,0 @@
-import { _ as s, x as a } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-CLPIgtdX.js";
-const _ = /* @__PURE__ */ s(a, [["__scopeId", "data-v-110037e2"]]);
-export {
-  _ as S
-};

package/dist/SingleSelectControl-LrEUX41i.js

@@ -1,58 +0,0 @@
-import { defineComponent as v, computed as r, openBlock as I, createBlock as y } from "vue";
-import { u as F } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-CLPIgtdX.js";
-import { L as P } from "./LoadingDropdown-DRC0PUle.js";
-const i = "__special__", a = "__regular__", B = /* @__PURE__ */ v({
-  __name: "SingleSelectControl",
-  props: {
-    control: {},
-    handleChange: { type: Function },
-    changeValue: { type: Function },
-    disabled: { type: Boolean },
-    isValid: { type: Boolean },
-    onRegisterValidation: { type: Function },
-    labelForId: {}
-  },
-  setup(u) {
-    const t = u, d = r(
-      () => t.control.uischema.options.choicesProvider
-    ), p = r(
-      () => t.control.uischema.options.specialChoices
-    ), n = F(
-      d,
-      null
-    ), l = (e) => `${i}${e}`, c = (e) => `${a}${e}`, h = ({
-      id: e,
-      text: o
-    }) => ({
-      id: l(e),
-      text: o,
-      isSpecial: !0
-    }), m = ({
-      id: e,
-      text: o
-    }) => ({
-      id: c(e),
-      text: o
-    }), f = r(() => n.value === null ? null : p.value.map(h).concat(n.value.map(m))), C = (e) => {
-      if (!e.startsWith(a) && !e.startsWith(i))
-        throw new Error(`Expected id to start with ${a}`);
-    }, g = (e) => e ? (C(e), e.startsWith(i) ? { specialChoice: e.slice(i.length) } : { regularChoice: e.slice(a.length) }) : null, b = (e) => typeof e > "u" || e === null ? "" : "regularChoice" in e && e.regularChoice ? c(e.regularChoice) : "specialChoice" in e && e.specialChoice ? l(e.specialChoice) : "", s = r({
-      get: () => b(t.control.data),
-      set: (e) => {
-        t.changeValue(g(e));
-      }
-    });
-    return (e, o) => (I(), y(P, {
-      id: e.labelForId,
-      modelValue: s.value,
-      "onUpdate:modelValue": o[0] || (o[0] = (_) => s.value = _),
-      "possible-values": f.value,
-      ariaLabel: e.control.label,
-      disabled: e.disabled,
-      compact: ""
-    }, null, 8, ["id", "modelValue", "possible-values", "ariaLabel", "disabled"]));
-  }
-});
-export {
-  B as default
-};

package/dist/toString-DzEZi8fD.js

@@ -1,25 +0,0 @@
-import { S as s, n as g } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-CLPIgtdX.js";
-import { i as l } from "./isArray-WzO_os3q.js";
-function p(n, r) {
-  for (var t = -1, i = n == null ? 0 : n.length, o = Array(i); ++t < i; )
-    o[t] = r(n[t], t, n);
-  return o;
-}
-var e = s ? s.prototype : void 0, f = e ? e.toString : void 0;
-function m(n) {
-  if (typeof n == "string")
-    return n;
-  if (l(n))
-    return p(n, m) + "";
-  if (g(n))
-    return f ? f.call(n) : "";
-  var r = n + "";
-  return r == "0" && 1 / n == -1 / 0 ? "-0" : r;
-}
-function S(n) {
-  return n == null ? "" : m(n);
-}
-export {
-  p as a,
-  S as t
-};

package/dist/useBuiltinValidations-hN9BsKJH.js

@@ -1,52 +0,0 @@
-import { computed as r } from "vue";
-import { u as d } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-CLPIgtdX.js";
-const l = (e = {}) => e.validations ?? [], c = (e = {}) => (e.validationProviders ?? []).map(
-  (i) => d(i, null)
-), s = (e, i) => {
-  const n = e.map(
-    ({ id: t, parameters: o, errorMessage: a }) => ({
-      validate: i[t](o),
-      errorMessage: a
-    })
-  );
-  return (t) => ({
-    errors: n.filter(({ validate: o }) => !o(t)).map(({ errorMessage: o }) => o)
-  });
-}, u = (e, i) => e === null ? null : s([e], i), m = (e, i, n, t) => {
-  if (e.length) {
-    const o = s(e, n);
-    t(o);
-  }
-  i.length && i.map(
-    (a) => r(() => u(a.value, n))
-  ).forEach(t);
-}, h = ({
-  validations: e,
-  providedValidations: i
-}) => {
-  const n = e.reduce(
-    (t, o) => ({ ...t, [o.id]: o.parameters }),
-    {}
-  );
-  return r(
-    () => i.map((t) => t.value).filter((t) => t !== null).reduce(
-      (t, o) => ({
-        ...t,
-        // @ts-expect-error - we know that validation is not null here
-        [o.id]: o.parameters
-      }),
-      n
-    )
-  );
-}, f = (e, i) => {
-  const n = i.control.uischema.options, t = l(n), o = c(n);
-  return m(
-    t,
-    o,
-    e,
-    i.onRegisterValidation
-  ), h({ validations: t, providedValidations: o });
-};
-export {
-  f as u
-};

package/dist/usePossibleValues-DY3q9YuR.js

@@ -1,26 +0,0 @@
-import { computed as a } from "vue";
-import { u as c } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-CLPIgtdX.js";
-const t = (s) => {
-  var e;
-  const u = a(
-    () => {
-      var o;
-      return (o = s.value.uischema.options) == null ? void 0 : o.choicesProvider;
-    }
-  );
-  return { possibleValues: c(
-    u,
-    ((e = s.value.uischema.options) == null ? void 0 : e.possibleValues) ?? null
-  ) };
-}, n = (s) => {
-  var l, e;
-  const u = a(() => s.value.uischema.options);
-  return {
-    includedLabel: ((l = u.value) == null ? void 0 : l.includedLabel) ?? "Includes",
-    excludedLabel: ((e = u.value) == null ? void 0 : e.excludedLabel) ?? "Excludes"
-  };
-};
-export {
-  n as a,
-  t as u
-};