@knime/scripting-editor 0.0.118 → 0.0.120

package/dist/NumberInput-CHeMUEcJ-CBjiZXnc.js

@@ -0,0 +1,230 @@
+import { i as m } from "./arrow-dropdown-BHK4j8GT-uCJYJfqE.js";
+import { resolveComponent as c, createElementBlock as d, openBlock as p, normalizeClass as r, createElementVNode as u, createCommentVNode as V, withModifiers as n, createVNode as h } from "vue";
+import { X as v } from "./parameters-TDvh_VJm.js";
+const f = 200, g = 50, b = 0.1, I = 1, w = {
+  name: "NumberInput",
+  components: {
+    ArrowIcon: m
+  },
+  props: {
+    modelValue: {
+      default: 0,
+      type: [Number, String],
+      validator(e) {
+        return typeof e == "string" ? e.toLowerCase().includes("e") : typeof e == "number";
+      }
+    },
+    id: {
+      type: String,
+      default: null
+    },
+    name: {
+      type: String,
+      default: null
+    },
+    min: {
+      default: Number.MIN_SAFE_INTEGER,
+      type: Number
+    },
+    max: {
+      default: Number.MAX_SAFE_INTEGER,
+      type: Number
+    },
+    step: {
+      default: null,
+      type: Number
+    },
+    /**
+     * Validity controlled by the parent component to be flexible.
+     */
+    isValid: {
+      default: !0,
+      type: Boolean
+    },
+    /**
+     * Sets the significant digit of the spinner input.
+     *
+     * Possible values: 'double' | 'integer'
+     */
+    type: {
+      default: "double",
+      type: String
+    },
+    inputClasses: {
+      default: "",
+      type: String
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    compact: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  data() {
+    return {
+      clicked: !1,
+      // false to prevent unintended 'mouseup' or 'mouseleave' events.
+      hovered: !1,
+      initialValue: 0,
+      localValue: "",
+      spinnerArrowTimeout: null,
+      spinnerArrowInterval: null
+    };
+  },
+  computed: {
+    isInteger() {
+      return this.type === "integer";
+    },
+    stepSize() {
+      return this.step !== null ? this.step : this.isInteger ? I : b;
+    },
+    inputClassList() {
+      let e = this.inputClasses;
+      return this.hovered && (e += " hover"), e;
+    },
+    inputValue() {
+      return typeof this.localValue == "number" && isNaN(this.localValue) ? "" : this.isInteger ? this.localValue : this.localValue.toString();
+    }
+  },
+  watch: {
+    modelValue: {
+      handler() {
+        this.parseValue(this.localValue) !== this.parseValue(this.modelValue) && (this.localValue = this.parseValue(this.modelValue));
+      },
+      immediate: !0
+    }
+  },
+  mounted() {
+    this.localValue = this.parseValue(this.modelValue), this.initialValue = this.localValue;
+  },
+  methods: {
+    getInputRef() {
+      return this.$refs.input;
+    },
+    parseValue(e) {
+      return this.isInteger ? parseInt(e.toString(), 10) : parseFloat(e.toString());
+    },
+    getParsedValue() {
+      return this.parseValue(this.localValue);
+    },
+    onInput(e) {
+      const t = e.target.value;
+      e && !t && (e.data === "." || e.data === "-") || (t || (this.getInputRef().value = ""), this.updateAndEmit({ newValue: t }));
+    },
+    updateAndEmit({ newValue: e }) {
+      this.localValue = e, this.$emit("update:modelValue", this.getParsedValue());
+    },
+    onBlur() {
+      this.localValue = this.getParsedValue(), this.getInputRef().valueAsNumber = this.localValue;
+    },
+    validate(e) {
+      let t = !0, a;
+      return e = typeof e > "u" ? this.getParsedValue() : this.parseValue(e), typeof e != "number" || isNaN(e) ? (t = !1, a = "Current value is not a number.") : (this.min > e || this.max < e) && (t = !1, a = "Current value is outside allowed range."), { isValid: t, errorMessage: a };
+    },
+    /**
+     * Change value updates the actual value of the input field if a valid new value
+     * can be found. It prevents users from further invalidating the value in the input
+     * by moving in the wrong direction (lower than min/higher than max).
+     *
+     * It will snap to the nearest multiple of the given increment, i.e. initial
+     * value 13 incremented by 10 will yield 20.
+     *
+     * @param  {Number} increment - the amount by which to change the current
+     * value. If value is 0, no update is performed.
+     * @returns {undefined}
+     */
+    changeValue(e) {
+      if (e === 0)
+        return;
+      let t = this.getParsedValue();
+      this.validate(t).isValid || (t = this.findNearestValidValue(t));
+      let a = t + e, l = 1 / Math.abs(e);
+      Math.abs(e) < 1 && (l = Math.round(l)), a = Math.round(a * l) / l, this.validate(a).isValid && this.updateAndEmit({ newValue: a });
+    },
+    findNearestValidValue(e) {
+      return e < this.min ? this.min : e > this.max ? this.max : this.initialValue;
+    },
+    /**
+     * This method is the callback handler for mouse events on the input field controls.
+     * It is fired when either the up-arrow or down-arrow is pressed by the user. It manages
+     * both mousedown and mouseup events. It clears any existing timeouts or intervals which
+     * may have been set previously. It also recognizes when the mouse leaves the button
+     * (which could cause a mouseup event to be missed) and therefore uses the this.clicked
+     * data property to ensure it doesn't get stuck in an interval.
+     *
+     * @param {Event} e - the DOM event object which triggered the handler.
+     * @param {String} type - the type of button pressed (either 'increased' or 'decreased').
+     * @returns {undefined}
+     */
+    mouseEvent(e, t) {
+      if (this.disabled)
+        return;
+      this.spinnerArrowInterval !== null && clearTimeout(this.spinnerArrowInterval), this.spinnerArrowTimeout !== null && clearInterval(this.spinnerArrowTimeout);
+      let a = this.stepSize;
+      if (t === "decrease" && (a *= -1), e.type === "mousedown") {
+        this.clicked = !0, this.spinnerArrowTimeout = setTimeout(() => {
+          this.spinnerArrowInterval = setInterval(() => {
+            this.changeValue(a);
+          }, g);
+        }, f);
+        return;
+      }
+      this.clicked && (this.clicked = !1, this.changeValue(a));
+    },
+    toggleHover() {
+      this.hovered = !this.hovered;
+    }
+  }
+}, y = ["id", "name", "value", "min", "max", "step", "disabled"], N = {
+  key: 0,
+  class: "invalid-marker"
+};
+function E(e, t, a, l, A, i) {
+  const o = c("ArrowIcon");
+  return p(), d("div", {
+    class: r(["wrapper", { disabled: a.disabled, compact: a.compact }])
+  }, [
+    u("input", {
+      id: a.id,
+      ref: "input",
+      name: a.name,
+      type: "number",
+      role: "spinButton",
+      value: i.inputValue,
+      min: a.min,
+      max: a.max,
+      step: i.stepSize,
+      class: r(i.inputClassList),
+      disabled: a.disabled,
+      onInput: t[0] || (t[0] = (s) => i.onInput(s)),
+      onBlur: t[1] || (t[1] = (...s) => i.onBlur && i.onBlur(...s)),
+      onMouseenter: t[2] || (t[2] = (...s) => i.toggleHover && i.toggleHover(...s)),
+      onMouseleave: t[3] || (t[3] = (...s) => i.toggleHover && i.toggleHover(...s))
+    }, null, 42, y),
+    a.isValid ? V("", !0) : (p(), d("span", N)),
+    u("span", {
+      class: r(["increase", { disabled: a.disabled }]),
+      onMousedown: t[4] || (t[4] = n((s) => i.mouseEvent(s, "increase"), ["prevent"])),
+      onMouseup: t[5] || (t[5] = n((s) => i.mouseEvent(s, "increase"), ["prevent"])),
+      onMouseleave: t[6] || (t[6] = (s) => i.mouseEvent(s, "increase"))
+    }, [
+      h(o)
+    ], 34),
+    u("span", {
+      class: r(["decrease", { disabled: a.disabled }]),
+      onMousedown: t[7] || (t[7] = n((s) => i.mouseEvent(s, "decrease"), ["prevent"])),
+      onMouseup: t[8] || (t[8] = n((s) => i.mouseEvent(s, "decrease"), ["prevent"])),
+      onMouseleave: t[9] || (t[9] = (s) => i.mouseEvent(s, "decrease"))
+    }, [
+      h(o)
+    ], 34)
+  ], 2);
+}
+const C = /* @__PURE__ */ v(w, [["render", E], ["__scopeId", "data-v-0ce77f1e"]]);
+export {
+  C as B
+};

package/dist/OneOfDropdown-DZgSOLLJ-wCE5bOVZ.js

@@ -0,0 +1,34 @@
+import { defineComponent as p, computed as s, createBlock as c, openBlock as u, unref as d } from "vue";
+import { c as m } from "./index-Blg1O3Fz-CGafpkU1.js";
+import { i as b } from "./Dropdown-6eVZoGpG-PuXROd15.js";
+const y = /* @__PURE__ */ p({
+  __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 = s({
+      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
+};

package/dist/RadioControl-xm6uqnsz-Bpu9pAXm.js

@@ -0,0 +1,24 @@
+import { defineComponent as e, createBlock as t, openBlock as n, mergeProps as a } from "vue";
+import { I as r } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-cwi1lPmz-D1KwRFTF.js";
+import { X as p } from "./parameters-TDvh_VJm.js";
+const l = /* @__PURE__ */ e({
+  __name: "RadioControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(i) {
+    return (o, s) => (n(), t(r, a(o.$props, {
+      type: "radio",
+      class: "radio"
+    }), null, 16));
+  }
+}), u = /* @__PURE__ */ p(l, [["__scopeId", "data-v-6720fee0"]]);
+export {
+  u as default
+};

package/dist/RadioControlBase.vue_vue_type_script_setup_true_lang-cwi1lPmz-D1KwRFTF.js

@@ -0,0 +1,60 @@
+import { defineComponent as c, computed as u, ref as b, toRef as v, createElementBlock as f, createCommentVNode as y, onMounted as V, openBlock as n, Fragment as h, createBlock as i, unref as r } from "vue";
+import { l as g } from "./parameters-TDvh_VJm.js";
+import { c as k } from "./index-Blg1O3Fz-CGafpkU1.js";
+import { t as F } from "./usePossibleValues-CJPCrHNK-DHhG_gUy.js";
+import { O as B } from "./ValueSwitch-BmW_v2r_-DCcRA3Nu.js";
+const R = /* @__PURE__ */ c({
+  __name: "RadioControlBase",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {},
+    type: {}
+  },
+  setup(l) {
+    const o = l, s = u(() => {
+      var e;
+      return (e = o.control.uischema.options) == null ? void 0 : e.radioLayout;
+    }), m = (e) => ({
+      id: e.id,
+      text: e.text,
+      ...e.disabled ? { disabled: !0 } : {}
+    }), d = b(null), { possibleValues: p } = F(v(o, "control"), {
+      defaultOnNonProvided: null
+    }), a = u(
+      () => {
+        var e;
+        return (e = p.value ?? d.value) == null ? void 0 : e.map(m);
+      }
+    );
+    return V(() => {
+      var e, t;
+      d.value = (t = (e = o.control) == null ? void 0 : e.schema) != null && t.oneOf ? o.control.schema.oneOf.map(k) : null;
+    }), (e, t) => a.value ? (n(), f(h, { key: 0 }, [
+      o.type === "valueSwitch" ? (n(), i(r(B), {
+        key: 0,
+        id: l.labelForId,
+        "possible-values": a.value,
+        disabled: l.disabled,
+        "model-value": l.control.data,
+        compact: "",
+        "onUpdate:modelValue": l.changeValue
+      }, null, 8, ["id", "possible-values", "disabled", "model-value", "onUpdate:modelValue"])) : (n(), i(r(g), {
+        key: 1,
+        id: l.labelForId,
+        "possible-values": a.value,
+        alignment: s.value,
+        disabled: l.disabled,
+        "model-value": l.control.data,
+        "onUpdate:modelValue": l.changeValue
+      }, null, 8, ["id", "possible-values", "alignment", "disabled", "model-value", "onUpdate:modelValue"]))
+    ], 64)) : y("", !0);
+  }
+});
+export {
+  R as I
+};