@knime/scripting-editor 0.0.123 → 0.0.124

package/dist/MultimodeTwinlistControl-jV_w7lgr-CGKr68Lk.js

@@ -1,613 +0,0 @@
-import { defineComponent as X, toRef as k, ref as G, computed as m, markRaw as Q, createBlock as V, openBlock as c, unref as g, mergeProps as R, createSlots as Z, withCtx as p, createElementVNode as S, normalizeClass as F, createVNode as y, toDisplayString as C, resolveComponent as h, createElementBlock as x, createCommentVNode as P, renderSlot as U, normalizeProps as $, guardReactiveProps as z, Fragment as ee, renderList as te, createTextVNode as ae } from "vue";
-import { Y as L, J as A } from "./TextControl-D38OA8zM-BYAu2w0I.js";
-import { i as le } from "./index-Blg1O3Fz-CGafpkU1.js";
-import { t as se, c as ie } from "./usePossibleValues-CRl5e6t8-nqJjfgjF.js";
-import { g as ne, w as oe, E as de, q as re } from "./TwinlistLoadingInfo-DScu9gNb-BI5GYwMW.js";
-import { j as ue } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_0aa76d2b_lang-6idDahSz-BvrNkbR6.js";
-import { i as O } from "./useSearch-hpyYQ_6y-BgGbVTm1.js";
-import { _ as pe } from "./Checkbox-DjZxP5CK-C2B2UhVz.js";
-import { F as ce } from "./Label-BPo4EJ9a-B0S2hdXE.js";
-import { O as me } from "./ValueSwitch-BKwWC7oO-Dwv2nQCW.js";
-const he = {
-  name: "Checkboxes",
-  components: {
-    Checkbox: pe
-  },
-  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 ye(e, a, t, o, v, n) {
-  const b = h("Checkbox");
-  return c(), x("div", {
-    class: F(["checkboxes", t.alignment])
-  }, [
-    (c(!0), x(ee, null, te(t.possibleValues, (d) => (c(), V(b, {
-      ref_for: !0,
-      ref: "boxes",
-      key: `checkboxes-${d.id}`,
-      "model-value": t.modelValue.indexOf(d.id) > -1,
-      title: d.text,
-      invalid: d.invalid,
-      disabled: t.disabled,
-      class: "box",
-      "onUpdate:modelValue": (f) => n.onUpdateModelValue(d.id, f)
-    }, {
-      default: p(() => [
-        U(e.$slots, "label", { slotItem: d }, () => [
-          ae(C(d.text), 1)
-        ], !0)
-      ]),
-      _: 2
-    }, 1032, ["model-value", "title", "invalid", "disabled", "onUpdate:modelValue"]))), 128))
-  ], 2);
-}
-const ve = /* @__PURE__ */ L(he, [["render", ye], ["__scopeId", "data-v-c83ea4f7"]]), be = {
-  xmlns: "http://www.w3.org/2000/svg",
-  fill: "none",
-  stroke: "#000",
-  "stroke-linejoin": "round",
-  viewBox: "0 0 32 32"
-};
-function fe(e, a) {
-  return c(), x("svg", be, [...a[0] || (a[0] = [
-    S("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1)
-  ])]);
-}
-const we = { render: fe }, Ve = {
-  manual: "Manual",
-  wildcard: "Wildcard",
-  regex: "Regex",
-  type: "Type"
-}, ge = {
-  name: "MultiModeTwinlist",
-  components: {
-    Label: ce,
-    FilterIcon: we,
-    SearchInput: de,
-    Checkboxes: ve,
-    ValueSwitch: me,
-    Twinlist: oe
-  },
-  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 } = re(
-      k(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: t }) => t).filter(Boolean), a = e.map((t) => t.id);
-      return [...this.additionalPossibleTypes.filter(
-        (t) => t && !a.includes(t.id)
-      ), ...e].filter((t) => t && t.id !== "").filter(
-        // remove duplicates
-        (t, o, v) => o === v.findIndex((n) => n.id === t.id && n.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 : O[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() {
-      var e;
-      return !!((e = this.selectedValues) != null && e.length);
-    },
-    itemMatches(e) {
-      var a;
-      return O[this.mode].test(
-        this.mode === "type" ? (a = e.type) == null ? void 0 : a.id : e.text,
-        this.normalizedSearchTerm,
-        this.caseSensitivePattern,
-        this.inversePattern
-      );
-    }
-  }
-};
-function Se(e, a, t, o, v, n) {
-  const b = h("ValueSwitch"), d = h("Label"), f = h("FilterIcon"), T = h("SearchInput"), I = h("Checkboxes"), w = h("Twinlist");
-  return c(), x("div", {
-    class: F(["multi-mode-twinlist", { disabled: t.disabled }])
-  }, [
-    t.showMode ? (c(), V(d, {
-      key: 0,
-      active: t.withModeLabel,
-      text: t.modeLabel,
-      class: "label"
-    }, {
-      default: p(({ labelForId: r }) => [
-        y(b, {
-          id: r,
-          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" ? (c(), V(d, {
-      key: 1,
-      active: t.withPatternLabel,
-      text: t.patternLabel,
-      class: "label"
-    }, {
-      default: p(({ labelForId: r }) => [
-        y(T, {
-          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": n.onPatternInput,
-          onToggleCaseSensitiveSearch: n.onToggleCaseSensitivePattern,
-          onToggleInverseSearch: n.onToggleInversePattern
-        }, {
-          icon: p(() => [
-            y(f)
-          ]),
-          _: 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 ? (c(), V(d, {
-      key: 2,
-      active: t.withTypesLabel,
-      text: t.typesLabel,
-      class: "label"
-    }, {
-      default: p(() => [
-        y(I, {
-          "model-value": t.selectedTypes,
-          "possible-values": n.possibleTypes,
-          disabled: t.disabled,
-          "onUpdate:modelValue": n.onTypeInput
-        }, {
-          label: p((r) => [
-            U(e.$slots, "type", $(z(r)), void 0, !0)
-          ]),
-          _: 3
-        }, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
-      ]),
-      _: 3
-    }, 8, ["active", "text"])) : P("", !0),
-    y(w, R(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: p((r) => [
-        U(e.$slots, "option", $(z(r)), void 0, !0)
-      ]),
-      _: 3
-    }, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
-  ], 2);
-}
-const xe = /* @__PURE__ */ L(ge, [["render", Se], ["__scopeId", "data-v-a4487686"]]), Te = { class: "data-type-text" }, Ie = /* @__PURE__ */ X({
-  __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 i = le(a.control.data, l);
-      a.changeValue(i), t == null || t(i.manualFilter);
-    }, v = (l) => {
-      o({ selected: l });
-    }, n = (l) => {
-      if (l !== null)
-        if ("includedValues" in l) {
-          const { includedValues: i, excludedValues: u, includeUnknownValues: s } = l;
-          if (!i || !u)
-            return;
-          o({
-            manualFilter: {
-              manuallySelected: i,
-              manuallyDeselected: u,
-              includeUnknownColumns: s
-            }
-          });
-        } else
-          o({ manualFilter: { manuallySelected: l } });
-    }, b = (l) => {
-      o({ patternFilter: { pattern: l } });
-    }, d = (l) => {
-      o({ mode: l.toUpperCase() });
-    }, f = (l, i) => {
-      o({ typeFilter: { selectedTypes: l, typeDisplays: i } });
-    }, T = (l) => {
-      o({ patternFilter: { isInverted: l } });
-    }, I = (l) => {
-      o({ patternFilter: { isCaseSensitive: l } });
-    }, { possibleValues: w } = se(
-      k(a, "control")
-    ), r = G([]), { selectedAndDeselected: M, setCurrentManualFilter: q } = ue({
-      data: m(() => a.control.data),
-      possibleValueIds: m(
-        () => {
-          var l;
-          return ((l = w.value) == null ? void 0 : l.map(({ id: i }) => i)) ?? null;
-        }
-      )
-    });
-    t = q;
-    const D = m(() => {
-      const { selected: l, deselected: i } = M.value;
-      return a.showUnknownValues ? {
-        includedValues: l,
-        excludedValues: i,
-        includeUnknownValues: a.control.data.manualFilter.includeUnknownColumns
-      } : l;
-    }), E = m(
-      () => M.value.selected === null ? Q(ne) : null
-    ), j = (l) => typeof l > "u" ? {} : l.reduce(
-      (i, { id: u, text: s }) => ({ ...i, [u]: s }),
-      {}
-    ), N = () => {
-      const l = a.control.data.typeFilter;
-      if (!l)
-        return [];
-      const i = l.selectedTypes, u = j(
-        l.typeDisplays
-      );
-      return i.map((s) => ({
-        id: s,
-        text: u[s] || s
-      }));
-    };
-    r.value = N();
-    const H = m(
-      () => {
-        var l, i;
-        return !!((i = (l = w.value) == null ? void 0 : l[0]) != null && i.hasOwnProperty("type"));
-      }
-    ), { excludedLabel: J, includedLabel: W } = ie(
-      k(a, "control")
-    ), Y = m(() => J ?? a.twinlistLeftLabel), K = m(() => W ?? a.twinlistRightLabel);
-    return (l, i) => {
-      var u;
-      return c(), V(g(xe), R(l.$attrs, {
-        id: e.labelForId,
-        disabled: e.disabled,
-        "with-types": e.showTypeFilter,
-        "selected-types": (u = e.control.data.typeFilter) == null ? void 0 : u.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": E.value,
-        "inverse-pattern": e.control.data.patternFilter.isInverted,
-        "manual-selection": D.value,
-        "include-unknown-values": e.control.data.manualFilter.includeUnknownColumns,
-        "mode-label": "Selection mode",
-        "possible-values": g(w) ?? [],
-        size: e.twinlistSize,
-        "left-label": Y.value,
-        "right-label": K.value,
-        "is-valid": e.isValid,
-        compact: "",
-        "show-resize-handle": "",
-        "onUpdate:selected": v,
-        "onUpdate:manualSelection": n,
-        "onUpdate:pattern": b,
-        "onUpdate:mode": d,
-        "onUpdate:selectedTypes": f,
-        "onUpdate:inversePattern": T,
-        "onUpdate:caseSensitivePattern": I
-      }), Z({ _: 2 }, [
-        H.value ? {
-          name: "option",
-          fn: p(({ slotItem: s }) => {
-            var B, _;
-            return [
-              S("div", {
-                class: F(["data-type-entry", { invalid: s.invalid }])
-              }, [
-                y(g(A), {
-                  "icon-name": (B = s == null ? void 0 : s.type) == null ? void 0 : B.id,
-                  "icon-title": (_ = s == null ? void 0 : s.type) == null ? void 0 : _.text,
-                  size: "small"
-                }, null, 8, ["icon-name", "icon-title"]),
-                S("span", null, C(s.text), 1)
-              ], 2)
-            ];
-          }),
-          key: "0"
-        } : void 0,
-        e.showTypeFilter ? {
-          name: "type",
-          fn: p(({ slotItem: s }) => [
-            y(g(A), {
-              "icon-name": s.id,
-              "icon-title": s.text,
-              size: "small"
-            }, null, 8, ["icon-name", "icon-title"]),
-            S("span", Te, C(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"]);
-    };
-  }
-}), ze = /* @__PURE__ */ L(Ie, [["__scopeId", "data-v-0aa76d2b"]]);
-export {
-  ze as default
-};

package/dist/NumberControlBase.vue_vue_type_script_setup_true_lang-j08h2BDc-ihKuOSeJ.js

@@ -1,51 +0,0 @@
-import { defineComponent as m, computed as t, createBlock as d, openBlock as c, unref as p } from "vue";
-import { i as v, Q as x } from "./TextControl-D38OA8zM-BYAu2w0I.js";
-const b = 1, f = 0.1, h = /* @__PURE__ */ m({
-  __name: "NumberControlBase",
-  props: {
-    control: {},
-    handleChange: { type: Function },
-    changeValue: { type: Function },
-    disabled: { type: Boolean },
-    isValid: { type: Boolean },
-    onRegisterValidation: { type: Function },
-    labelForId: {},
-    type: {}
-  },
-  setup(o) {
-    const a = o, n = t(
-      () => {
-        var e;
-        return ((e = a.control.uischema.options) == null ? void 0 : e.stepSize) ?? (a.type === "integer" ? b : f);
-      }
-    ), s = v(
-      {
-        min: ({ min: e, isExclusive: i }) => (l) => isNaN(l) || (i ? l > e : l >= e),
-        max: ({ max: e, isExclusive: i }) => (l) => isNaN(l) || (i ? l < e : l <= e)
-      },
-      a
-    ), u = t(() => {
-      const e = s.value.min;
-      if (!(!e || e.min === null))
-        return e.min + (e.isExclusive ? n.value : 0);
-    }), r = t(() => {
-      const e = s.value.max;
-      if (!(!e || e.max === null))
-        return e.max - (e.isExclusive ? n.value : 0);
-    });
-    return (e, i) => (c(), d(p(x), {
-      id: o.labelForId,
-      class: "number-input",
-      disabled: o.disabled,
-      "model-value": o.control.data,
-      min: u.value,
-      max: r.value,
-      step: n.value,
-      error: !o.isValid,
-      "onUpdate:modelValue": o.changeValue
-    }, null, 8, ["id", "disabled", "model-value", "min", "max", "step", "error", "onUpdate:modelValue"]));
-  }
-});
-export {
-  h
-};

package/dist/OneOfDropdown-DaJGTKfI-vgoMvhnt.js

@@ -1,34 +0,0 @@
-import { defineComponent as s, computed as p, createBlock as c, openBlock as u, unref as d } from "vue";
-import { c as m } from "./index-Blg1O3Fz-CGafpkU1.js";
-import { s as b } from "./Dropdown-BObDeUax-CwUT8zVH.js";
-const y = /* @__PURE__ */ s({
-  __name: "OneOfDropdown",
-  props: {
-    control: {},
-    handleChange: { type: Function },
-    changeValue: { type: Function },
-    disabled: { type: Boolean },
-    isValid: { type: Boolean },
-    onRegisterValidation: { type: Function },
-    labelForId: {}
-  },
-  setup(e) {
-    var l, t;
-    const o = e, i = ((t = (l = o.control.schema) == null ? void 0 : l.oneOf) == null ? void 0 : t.map(m)) ?? [], a = p({
-      get: () => o.control.data ?? "",
-      set: o.changeValue
-    });
-    return (f, n) => (u(), c(d(b), {
-      id: e.labelForId,
-      modelValue: a.value,
-      "onUpdate:modelValue": n[0] || (n[0] = (r) => a.value = r),
-      "possible-values": d(i),
-      ariaLabel: e.control.label,
-      disabled: e.disabled,
-      compact: ""
-    }, null, 8, ["id", "modelValue", "possible-values", "ariaLabel", "disabled"]));
-  }
-});
-export {
-  y as default
-};