@knime/scripting-editor 0.0.118 → 0.0.120

package/dist/Button-BfZfHt8q-BirQNc2F.js

@@ -0,0 +1,82 @@
+import { defineComponent as a, resolveComponent as o, createBlock as s, openBlock as n, normalizeClass as l, withCtx as r, renderSlot as i } from "vue";
+import { X as d, k as p } from "./parameters-TDvh_VJm.js";
+const c = a({
+  name: "Button",
+  components: {
+    BaseButton: p
+  },
+  props: {
+    /**
+     * @see {@link BaseButton.vue}
+     */
+    /**
+     * show button with border
+     */
+    withBorder: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * switches colors to use button on a dark background
+     */
+    onDark: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * switches colors
+     */
+    primary: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * smaller font size and padding
+     */
+    compact: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * show button in an error state
+     * - requires withBorder
+     * - doesnt work onDark
+     */
+    withWarning: {
+      type: Boolean,
+      default: !1
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  computed: {
+    classes() {
+      return [
+        "button",
+        { primary: this.primary },
+        { "with-border": this.withBorder },
+        { "with-warning": this.withWarning },
+        { "on-dark": this.onDark },
+        { compact: this.compact }
+      ];
+    }
+  }
+});
+function f(t, m, u, B, h, y) {
+  const e = o("BaseButton");
+  return n(), s(e, {
+    class: l(t.classes),
+    disabled: t.disabled
+  }, {
+    default: r(() => [
+      i(t.$slots, "default")
+    ]),
+    _: 3
+  }, 8, ["class", "disabled"]);
+}
+const k = /* @__PURE__ */ d(c, [["render", f], ["__scopeId", "data-v-497027a0"]]);
+export {
+  k as b
+};

package/dist/ButtonControl-HiHtzOYh.js

@@ -0,0 +1,132 @@
+import { defineComponent as H, ref as l, computed as _, onMounted as q, createElementBlock as S, openBlock as m, createVNode as z, createBlock as L, createCommentVNode as C, unref as B, withCtx as U, createElementVNode as W, toDisplayString as b } from "vue";
+import { FunctionButton as j, LoadingIcon as P } from "@knime/components";
+import { v as f, a1 as T, a2 as G } from "./parameters-TDvh_VJm.js";
+import { _ as J } from "./_plugin-vue_export-helper-CHgC5LLL.js";
+const k = ({ view: u, model: i }) => ({
+  ...u,
+  ...i
+}), K = { class: "button-wrapper" }, Q = { class: "button-input-text" }, X = {
+  key: 1,
+  class: "error-message"
+}, Y = /* @__PURE__ */ H({
+  __name: "ButtonControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    labelForId: {},
+    isValid: { type: Boolean },
+    messages: {},
+    onRegisterValidation: { type: Function }
+  },
+  setup(u) {
+    const i = f("registerWatcher"), V = f("getData"), g = f("applyData"), n = u, c = l(null), x = () => {
+      c.value = null;
+    }, h = l({}), v = (t) => {
+      h.value = k(t);
+    }, s = l({}), E = _(
+      () => {
+        var t;
+        return ((t = n.control.uischema.options) == null ? void 0 : t.states) ?? [];
+      }
+    ), y = (t) => {
+      x(), s.value = E.value.find(({ id: e }) => e === t);
+    }, F = (t) => {
+      setTimeout(() => n.changeValue(t));
+    }, w = (t) => {
+      if (t === null)
+        return;
+      const { settingValue: e, setSettingValue: o, buttonState: a } = t;
+      o && F(e), y(a);
+    }, D = (t, e = () => {
+    }) => {
+      var a;
+      const { state: o } = t;
+      if (o === "SUCCESS") {
+        w(t.result);
+        return;
+      }
+      o === "FAIL" && (c.value = (a = t.message) == null ? void 0 : a[0]), e();
+    }, p = l(0), I = T(), d = async ({
+      method: t,
+      options: e,
+      handler: o
+    }, a = () => {
+    }) => {
+      p.value += 1;
+      const r = await V({
+        method: t,
+        options: [I, o, ...e]
+      });
+      p.value -= 1, D(r, a);
+    }, A = async (t) => {
+      v(t), await d({
+        method: "settings.initializeButton",
+        options: [n.control.data],
+        handler: n.control.uischema.options.actionHandler
+      });
+    }, M = (t) => {
+      d({
+        method: "settings.update",
+        options: [k(t)],
+        handler: n.control.uischema.options.updateOptions.updateHandler
+      });
+    }, N = async () => {
+      var r;
+      if (g && ((r = n.control.uischema.options) != null && r.incrementAndApplyOnClick)) {
+        g((R) => G(R, n.control.path, n.control.data + 1));
+        return;
+      }
+      const { id: t, nextState: e } = s.value, o = s.value, a = () => {
+        e === s.value.id && (s.value = o);
+      };
+      typeof e < "u" && y(e), await d(
+        {
+          method: "settings.invokeButtonAction",
+          options: [t, h.value],
+          handler: n.control.uischema.options.actionHandler
+        },
+        a
+      );
+    };
+    q(() => {
+      var e, o, a;
+      i({
+        init: A,
+        transformSettings: v,
+        dependencies: ((e = n.control.uischema.options) == null ? void 0 : e.dependencies) || []
+      });
+      const t = (a = (o = n.control.uischema) == null ? void 0 : o.options) == null ? void 0 : a.updateOptions;
+      typeof t < "u" && i({
+        transformSettings: M,
+        dependencies: t.dependencies
+      });
+    });
+    const O = _(
+      () => {
+        var t;
+        return ((t = n.control.uischema.options) == null ? void 0 : t.displayErrorMessage) ?? !0;
+      }
+    );
+    return (t, e) => (m(), S("div", K, [
+      z(B(j), {
+        disabled: s.value.disabled,
+        class: "button-input",
+        primary: s.value.primary,
+        compact: "",
+        onClick: N
+      }, {
+        default: U(() => [
+          W("div", Q, b(s.value.text), 1)
+        ]),
+        _: 1
+      }, 8, ["disabled", "primary"]),
+      p.value > 0 ? (m(), L(B(P), { key: 0 })) : C("", !0),
+      c.value && O.value ? (m(), S("span", X, " Error: " + b(c.value), 1)) : C("", !0)
+    ]));
+  }
+}), nt = /* @__PURE__ */ J(Y, [["__scopeId", "data-v-c6a54afa"]]);
+export {
+  nt as default
+};

package/dist/Checkbox-M2rFIZY0-r6RqY214.js

@@ -0,0 +1,75 @@
+import { createElementBlock as o, openBlock as i, normalizeClass as s, createElementVNode as d, renderSlot as r } from "vue";
+import { X as u } from "./parameters-TDvh_VJm.js";
+const c = {
+  name: "Checkbox",
+  props: {
+    id: {
+      type: String,
+      default: null
+    },
+    name: {
+      type: String,
+      default: null
+    },
+    modelValue: {
+      type: Boolean,
+      default: !1
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    invalid: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Controls the size of the label
+     * supported values:
+     * - regular
+     * - large
+     */
+    labelSize: {
+      type: String,
+      default: "regular",
+      validator: (e) => ["regular", "large"].includes(e)
+    }
+  },
+  emits: ["update:modelValue"],
+  computed: {
+    classes() {
+      return ["checkbox", this.labelSize, { disabled: this.disabled }];
+    }
+  },
+  methods: {
+    onInput(e) {
+      const { checked: l } = e.target;
+      consola.trace("Checkbox value changed to", l), this.$emit("update:modelValue", l);
+    },
+    isChecked() {
+      return this.$refs.input.checked;
+    }
+  }
+}, p = ["id", "name", "checked", "disabled"];
+function m(e, l, t, h, f, a) {
+  return i(), o("label", {
+    class: s([a.classes, { invalid: t.invalid }])
+  }, [
+    d("input", {
+      id: t.id,
+      ref: "input",
+      name: t.name,
+      checked: t.modelValue,
+      disabled: t.disabled,
+      type: "checkbox",
+      onChange: l[0] || (l[0] = (...n) => a.onInput && a.onInput(...n))
+    }, null, 40, p),
+    d("span", null, [
+      r(e.$slots, "default", {}, void 0, !0)
+    ])
+  ], 2);
+}
+const g = /* @__PURE__ */ u(c, [["render", m], ["__scopeId", "data-v-54817902"]]);
+export {
+  g as _
+};

package/dist/CheckboxControl-Dz65huic-ByuEiGEp.js

@@ -0,0 +1,38 @@
+import { defineComponent as s, ref as c, createElementBlock as d, openBlock as r, createElementVNode as u, renderSlot as n, createVNode as i, unref as p } from "vue";
+import { X as b, R as v } from "./parameters-TDvh_VJm.js";
+const m = { class: "checkbox-container" }, f = /* @__PURE__ */ s({
+  __name: "CheckboxControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    labelForId: {},
+    isValid: { type: Boolean },
+    messages: {},
+    onRegisterValidation: { type: Function }
+  },
+  setup(o) {
+    const l = c(!1);
+    return (t, e) => (r(), d("div", {
+      class: "checkbox-input",
+      onMouseover: e[1] || (e[1] = (a) => l.value = !0),
+      onMouseleave: e[2] || (e[2] = (a) => l.value = !1)
+    }, [
+      u("div", m, [
+        i(p(v), {
+          class: "checkbox",
+          disabled: o.disabled,
+          "model-value": o.control.data,
+          label: o.control.label,
+          "onUpdate:modelValue": e[0] || (e[0] = (a) => o.changeValue(a))
+        }, null, 8, ["disabled", "model-value", "label"]),
+        n(t.$slots, "icon", {}, void 0, !0)
+      ]),
+      n(t.$slots, "buttons", { hover: l.value }, void 0, !0)
+    ], 32));
+  }
+}), k = /* @__PURE__ */ b(f, [["__scopeId", "data-v-dc3caa04"]]);
+export {
+  k as default
+};

package/dist/Checkboxes-Qc7Wn4p8-B8qRgy0F.js

@@ -0,0 +1,106 @@
+import { _ as u } from "./Checkbox-M2rFIZY0-r6RqY214.js";
+import { resolveComponent as c, createElementBlock as s, openBlock as l, normalizeClass as m, Fragment as p, renderList as f, createBlock as h, withCtx as b, renderSlot as v, createTextVNode as x, toDisplayString as y } from "vue";
+import { X as V } from "./parameters-TDvh_VJm.js";
+const k = {
+  name: "Checkboxes",
+  components: {
+    Checkbox: u
+  },
+  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((r) => r !== 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 C(e, a, t, r, g, i) {
+  const d = c("Checkbox");
+  return l(), s("div", {
+    class: m(["checkboxes", t.alignment])
+  }, [
+    (l(!0), s(p, null, f(t.possibleValues, (o) => (l(), h(d, {
+      ref_for: !0,
+      ref: "boxes",
+      key: `checkboxes-${o.id}`,
+      "model-value": t.modelValue.indexOf(o.id) > -1,
+      title: o.text,
+      invalid: o.invalid,
+      disabled: t.disabled,
+      class: "box",
+      "onUpdate:modelValue": (n) => i.onUpdateModelValue(o.id, n)
+    }, {
+      default: b(() => [
+        v(e.$slots, "label", { slotItem: o }, () => [
+          x(y(o.text), 1)
+        ], !0)
+      ]),
+      _: 2
+    }, 1032, ["model-value", "title", "invalid", "disabled", "onUpdate:modelValue"]))), 128))
+  ], 2);
+}
+const B = /* @__PURE__ */ V(k, [["render", C], ["__scopeId", "data-v-c83ea4f7"]]);
+export {
+  B as O
+};

package/dist/CheckboxesControl-52GcYYsS-Cpk0ZUTo.js

@@ -0,0 +1,41 @@
+import { defineComponent as d, computed as t, ref as c, toRef as u, createBlock as r, createCommentVNode as m, onMounted as p, openBlock as f, unref as v } from "vue";
+import { c as b } from "./index-Blg1O3Fz-CGafpkU1.js";
+import { t as h } from "./usePossibleValues-CJPCrHNK-DHhG_gUy.js";
+import { O as y } from "./Checkboxes-Qc7Wn4p8-B8qRgy0F.js";
+import { X as V } from "./parameters-TDvh_VJm.js";
+const k = /* @__PURE__ */ d({
+  __name: "CheckboxesControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(e) {
+    const o = e, s = t(
+      () => {
+        var l;
+        return (l = o.control.uischema.options) == null ? void 0 : l.checkboxLayout;
+      }
+    ), a = c(null), { possibleValues: i } = h(u(o, "control")), n = t(() => a.value ?? i.value);
+    return p(() => {
+      a.value = o.control.schema.anyOf ? o.control.schema.anyOf.map(b) : null;
+    }), (l, g) => n.value ? (f(), r(v(y), {
+      key: 0,
+      id: e.labelForId,
+      class: "checkboxes",
+      "possible-values": n.value,
+      alignment: s.value,
+      disabled: e.disabled,
+      "model-value": e.control.data,
+      "is-valid": e.isValid,
+      "onUpdate:modelValue": e.changeValue
+    }, null, 8, ["id", "possible-values", "alignment", "disabled", "model-value", "is-valid", "onUpdate:modelValue"])) : m("", !0);
+  }
+}), _ = /* @__PURE__ */ V(k, [["__scopeId", "data-v-2891ceef"]]);
+export {
+  _ as default
+};