@knime/scripting-editor 0.0.126 → 0.0.128

package/dist/TimeControl-Dvt5U7xN-CTkb_kae.js

@@ -0,0 +1,71 @@
+import { defineComponent as h, computed as u, ref as x, createBlock as D, openBlock as F, unref as I } from "vue";
+import { w as S } from "./TextControl-8jfyOJKb-BkT4AwNP.js";
+import { u as m } from "./plainDateTimeUtils-CR0UhpkD-DU-LM4_V.js";
+import { D as d } from "./classApi-CHpAZrj3-BptMrhKH.js";
+const V = /* @__PURE__ */ h({
+  __name: "TimeControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    error: { type: Boolean },
+    subText: {},
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(a) {
+    const r = a, p = u(() => r.control.uischema.options), f = u(
+      () => m.getMaxGranularity(p.value)
+    ), y = (e) => {
+      if (!e)
+        return null;
+      if (/(Z|[+-]\d{2}:?\d{2})$/.test(e))
+        try {
+          return d.Instant.from(e).toZonedDateTimeISO("UTC").toPlainTime();
+        } catch {
+          return null;
+        }
+      try {
+        return d.PlainTime.from(e);
+      } catch {
+        try {
+          return d.PlainDateTime.from(e).toPlainTime();
+        } catch {
+          return null;
+        }
+      }
+    }, g = (e, t) => e === null ? "" : t === "minute" ? e.toString({ smallestUnit: "minute" }) : t === "second" ? e.toString({ smallestUnit: "second" }) : e.toString({ fractionalSecondDigits: 3 }), s = u(
+      () => y(r.control.data)
+    ), l = x(
+      m.detectGranularity(r.control.data)
+    );
+    let o, n, i = !1;
+    const b = () => {
+      i = !1;
+      const e = o === void 0 ? s.value : o, t = n ?? l.value;
+      o = void 0, n = void 0, l.value = t, r.changeValue(g(e, t));
+    }, c = () => {
+      i || (i = !0, queueMicrotask(b));
+    }, v = (e) => {
+      o = e, c();
+    }, T = (e) => {
+      n = e, c();
+    };
+    return (e, t) => (F(), D(I(S), {
+      id: a.labelForId,
+      "model-value": s.value,
+      granularity: l.value,
+      ariaLabel: r.control.label,
+      "max-granularity": f.value,
+      disabled: a.disabled,
+      error: a.error,
+      "sub-text": a.subText,
+      "onUpdate:modelValue": v,
+      "onUpdate:granularity": T
+    }, null, 8, ["id", "model-value", "granularity", "ariaLabel", "max-granularity", "disabled", "error", "sub-text"]));
+  }
+});
+export {
+  V as default
+};

package/dist/TimeframesControl-DcUxC3kX-1e3a-BRE.js

@@ -0,0 +1,352 @@
+import { defineComponent as B, createElementBlock as g, openBlock as V, createVNode as d, unref as p, withCtx as I, createElementVNode as m, resolveComponent as N, normalizeClass as h, createCommentVNode as E, withModifiers as v } from "vue";
+import { E as w, t as x } from "./TextControl-8jfyOJKb-BkT4AwNP.js";
+const M = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function C(t, e) {
+  return V(), g("svg", M, [...e[0] || (e[0] = [
+    m("path", { d: "M28.7 9.7 16 22.3 3.3 9.7" }, null, -1)
+  ])]);
+}
+const S = { render: C }, A = (t) => Math.max(Math.floor(Math.log10(Math.abs(t))), 0) + 1, _ = 200, k = 50, T = 1, F = {
+  name: "TimePartInput",
+  components: {
+    ArrowIcon: S
+  },
+  props: {
+    modelValue: {
+      default: 0,
+      type: [Number, String]
+    },
+    id: {
+      type: String,
+      default: null
+    },
+    min: {
+      default: Number.MIN_SAFE_INTEGER,
+      type: Number
+    },
+    max: {
+      default: Number.MAX_SAFE_INTEGER,
+      type: Number
+    },
+    /**
+     * Minimum number of digits shown, non existent digits will be filled with zeros (0)
+     * e.g 3 -> 001, no leading zeros with the default 0
+     */
+    minDigits: {
+      default: 0,
+      type: Number
+    },
+    /**
+     * Validity controlled by the parent component to be flexible.
+     */
+    isValid: {
+      default: !0,
+      type: Boolean
+    },
+    inputClasses: {
+      default: "",
+      type: String
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    compact: {
+      default: !1,
+      type: Boolean
+    }
+  },
+  emits: ["update:modelValue", "bounds"],
+  data() {
+    return {
+      clicked: !1,
+      // false to prevent unintended 'mouseup' or 'mouseleave' events.
+      hovered: !1,
+      // if the input field is currently hovered or not
+      /* @type {String|Number} */
+      localValue: this.modelValue
+      // value with leading zeros
+    };
+  },
+  computed: {
+    stepSize() {
+      return T;
+    },
+    inputClassList() {
+      let t = this.inputClasses;
+      return this.hovered && (t += " hover"), t;
+    }
+  },
+  watch: {
+    modelValue: {
+      handler(t) {
+        this.localValue = this.padValue(t);
+      },
+      immediate: !0
+    }
+  },
+  /**
+   * The reference to the timeout which is set when
+   * a user clicks one of the numeric spinner wheels. This
+   * Timeout will trigger the spinnerArrowInterval.
+   */
+  spinnerArrowTimeout: null,
+  /**
+   * This interval rapid calls the change value method until the
+   * user releases the mouse.
+   */
+  spinnerArrowInterval: null,
+  mounted() {
+    this.initialValue = this.modelValue;
+  },
+  methods: {
+    /**
+     * Check min/max limits and return details about it
+     * @param {Number} value - value to check for min/max bounds
+     * @returns {Object} - bounds info object also used for @bounds event
+     */
+    limitBounds(t) {
+      return t < this.min ? {
+        type: "min",
+        limit: this.min,
+        input: t,
+        value: this.min
+      } : t > this.max ? {
+        type: "max",
+        limit: this.max,
+        input: t,
+        value: this.max
+      } : {
+        value: t
+      };
+    },
+    /**
+     * Pad with zeros based on minDigits prop
+     *
+     * @param {Number} value
+     * @returns {String|Number}
+     */
+    padValue(t) {
+      if (isNaN(t) || !t && t !== 0 || t < 0)
+        return t;
+      const e = t.toString(10);
+      return this.minDigits < 1 ? e : e.padStart(this.minDigits, "0");
+    },
+    getValue() {
+      return parseInt(this.$refs.input.value, 10);
+    },
+    onBlur() {
+      this.localValue = this.padValue(this.modelValue);
+    },
+    onInput(t) {
+      const e = t.target.value, n = parseInt(e, 10);
+      if (e === "")
+        this.localValue = "";
+      else {
+        const o = n.toString(10).length;
+        if (e === "")
+          return;
+        if (isNaN(n) || o > A(this.max)) {
+          this.$refs.input.value = this.padValue(this.localValue);
+          return;
+        }
+      }
+      const s = this.limitBounds(n);
+      s.type ? this.$emit("bounds", s) : this.$emit("update:modelValue", s.value);
+    },
+    validate(t) {
+      let e = !0, n;
+      return t = typeof t > "u" ? this.getValue() : t, typeof t != "number" || isNaN(t) ? (e = !1, n = "Current value is not a number.") : (this.min > t || this.max < t) && (e = !1, n = "Current value is outside allowed range."), { isValid: e, errorMessage: n };
+    },
+    /**
+     * 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).
+     *
+     * @param  {Number} increment - the amount by which to change the current value.
+     * @returns {undefined}
+     */
+    changeValue(t) {
+      let e = this.getValue();
+      this.validate(e).isValid || (e < this.min ? e = this.min : e > this.max ? e = this.max : e = this.initialValue);
+      let n = e + t;
+      if (n = Math.round(n * 10) / 10, this.validate(n).isValid)
+        this.$refs.input.value = this.padValue(n), this.onInput({ target: this.$refs.input });
+      else {
+        const s = this.limitBounds(n);
+        s.type && this.$emit("bounds", s);
+      }
+    },
+    /**
+     * 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(t, e) {
+      if (this.disabled)
+        return;
+      clearTimeout(this.spinnerArrowInterval), clearInterval(this.spinnerArrowTimeout);
+      let n = this.stepSize;
+      if (e === "decrease" && (n *= -1), t.type === "mousedown") {
+        this.clicked = !0, this.spinnerArrowTimeout = setTimeout(() => {
+          this.spinnerArrowInterval = setInterval(() => {
+            this.changeValue(n);
+          }, k);
+        }, _);
+        return;
+      }
+      this.clicked && (this.clicked = !1, this.changeValue(n));
+    },
+    toggleHover() {
+      this.hovered = !this.hovered;
+    }
+  }
+}, $ = ["id", "value", "min", "max", "step", "disabled"], H = {
+  key: 0,
+  class: "invalid-marker"
+};
+function z(t, e, n, s, o, a) {
+  const r = N("ArrowIcon");
+  return V(), g("div", {
+    class: h(["wrapper", { disabled: n.disabled, compact: n.compact }])
+  }, [
+    m("input", {
+      id: n.id,
+      ref: "input",
+      type: "number",
+      role: "spinButton",
+      value: o.localValue,
+      min: n.min,
+      max: n.max,
+      step: a.stepSize,
+      class: h(a.inputClassList),
+      disabled: n.disabled,
+      onInput: e[0] || (e[0] = (...i) => a.onInput && a.onInput(...i)),
+      onBlur: e[1] || (e[1] = (...i) => a.onBlur && a.onBlur(...i)),
+      onMouseenter: e[2] || (e[2] = (...i) => a.toggleHover && a.toggleHover(...i)),
+      onMouseleave: e[3] || (e[3] = (...i) => a.toggleHover && a.toggleHover(...i))
+    }, null, 42, $),
+    n.isValid ? E("", !0) : (V(), g("span", H)),
+    m("span", {
+      class: h(["increase", { disabled: n.disabled }]),
+      onMousedown: e[4] || (e[4] = v((i) => a.mouseEvent(i, "increase"), ["prevent"])),
+      onMouseup: e[5] || (e[5] = v((i) => a.mouseEvent(i, "increase"), ["prevent"])),
+      onMouseleave: e[6] || (e[6] = (i) => a.mouseEvent(i, "increase"))
+    }, [
+      d(r)
+    ], 34),
+    m("span", {
+      class: h(["decrease", { disabled: n.disabled }]),
+      onMousedown: e[7] || (e[7] = v((i) => a.mouseEvent(i, "decrease"), ["prevent"])),
+      onMouseup: e[8] || (e[8] = v((i) => a.mouseEvent(i, "decrease"), ["prevent"])),
+      onMouseleave: e[9] || (e[9] = (i) => a.mouseEvent(i, "decrease"))
+    }, [
+      d(r)
+    ], 34)
+  ], 2);
+}
+const f = /* @__PURE__ */ w(F, [["render", z], ["__scopeId", "data-v-bf742de5"]]), U = { class: "timeframe" }, D = { class: "input-wrapper" }, R = { class: "input-wrapper" }, G = /* @__PURE__ */ B({
+  __name: "TimeframesControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    error: { type: Boolean },
+    subText: {},
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(t) {
+    const e = ["hh", "mm", "ss"].length, n = t, s = (o, a, r) => {
+      var b;
+      const i = (o == null ? void 0 : o.value) ?? o, u = Number(i), l = Number.isNaN(u) ? 0 : u, c = (((b = n.control.data) == null ? void 0 : b[a]) ?? "00:00:00").split(":");
+      for (; c.length < e; )
+        c.push("00");
+      c[r] = String(l).padStart(2, "0"), a === "end" && (c[2] = "59");
+      const y = {
+        ...n.control.data,
+        [a]: c.slice(0, e).join(":")
+      };
+      n.changeValue(y);
+    };
+    return (o, a) => (V(), g("div", U, [
+      d(p(x), { text: "Between" }, {
+        default: I(({ labelForId: r }) => {
+          var i, u;
+          return [
+            m("div", D, [
+              d(p(f), {
+                id: r,
+                min: 0,
+                max: 23,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((i = t.control.data) == null ? void 0 : i.start) ?? "00:00:00").split(":")[0], 10),
+                "onUpdate:modelValue": a[0] || (a[0] = (l) => s(l, "start", 0)),
+                onBounds: a[1] || (a[1] = (l) => s(l, "start", 0))
+              }, null, 8, ["id", "model-value"]),
+              a[8] || (a[8] = m("span", null, ":", -1)),
+              d(p(f), {
+                min: 0,
+                max: 59,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((u = t.control.data) == null ? void 0 : u.start) ?? "00:00:00").split(":")[1], 10),
+                "onUpdate:modelValue": a[2] || (a[2] = (l) => s(l, "start", 1)),
+                onBounds: a[3] || (a[3] = (l) => s(l, "start", 1))
+              }, null, 8, ["model-value"])
+            ])
+          ];
+        }),
+        _: 1
+      }),
+      d(p(x), { text: "and" }, {
+        default: I(({ labelForId: r }) => {
+          var i, u;
+          return [
+            m("div", R, [
+              d(p(f), {
+                id: r,
+                min: 0,
+                max: 23,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((i = t.control.data) == null ? void 0 : i.end) ?? "00:00:00").split(":")[0], 10),
+                "onUpdate:modelValue": a[4] || (a[4] = (l) => s(l, "end", 0)),
+                onBounds: a[5] || (a[5] = (l) => s(l, "end", 0))
+              }, null, 8, ["id", "model-value"]),
+              a[9] || (a[9] = m("span", null, ":", -1)),
+              d(p(f), {
+                min: 0,
+                max: 59,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((u = t.control.data) == null ? void 0 : u.end) ?? "00:00:00").split(":")[1], 10),
+                "onUpdate:modelValue": a[6] || (a[6] = (l) => s(l, "end", 1)),
+                onBounds: a[7] || (a[7] = (l) => s(l, "end", 1))
+              }, null, 8, ["model-value"])
+            ])
+          ];
+        }),
+        _: 1
+      })
+    ]));
+  }
+}), P = /* @__PURE__ */ w(G, [["__scopeId", "data-v-fef66a7b"]]);
+export {
+  P as default
+};

package/dist/{TwinlistControlBase.vue_vue_type_script_setup_true_lang-B5lCsIOD-DoWlznIt.js → TwinlistControlBase.vue_vue_type_script_setup_true_lang-Buo-KA0N-tQDZulBA.js}

@@ -1,7 +1,7 @@
-import { defineComponent as s, toRef as r, computed as i, createBlock as p, openBlock as b, unref as o } from "vue";
-import { b as m } from "./TextControl-B0ag-3Pv-CVDIw3MG.js";
-import { c as y } from "./usePossibleValues-B-W6u-1T-CRO8qQzd.js";
-import { p as f } from "./toKdsPossibleValues-BklBg3gG-Dr1D12GJ.js";
+import { defineComponent as s, toRef as c, computed as t, createBlock as p, openBlock as b, unref as o } from "vue";
+import { T as m } from "./TextControl-8jfyOJKb-BkT4AwNP.js";
+import { c as y } from "./usePossibleValues-CtPV4Cjp-B6UlAJ8A.js";
+import { p as x } from "./toKdsPossibleValues-BklBg3gG-Dr1D12GJ.js";
 const v = /* @__PURE__ */ s({
   __name: "TwinlistControlBase",
   props: {
@@ -9,17 +9,18 @@ const v = /* @__PURE__ */ s({
     handleChange: { type: Function },
     changeValue: { type: Function },
     disabled: { type: Boolean },
-    isValid: { type: Boolean },
+    error: { type: Boolean },
+    subText: {},
     onRegisterValidation: { type: Function },
     labelForId: {},
     possibleValues: {}
   },
   setup(l) {
-    const a = l, { includedLabel: u, excludedLabel: t } = y(
-      r(a, "control")
-    ), n = i(
-      () => f(a.possibleValues ?? [])
-    ), c = i(() => {
+    const a = l, { includedLabel: u, excludedLabel: r } = y(
+      c(a, "control")
+    ), n = t(
+      () => x(a.possibleValues ?? [])
+    ), i = t(() => {
       const d = new Set(a.control.data ?? []);
       return n.value.filter((e) => !d.has(e.id)).map((e) => e.id);
     });
@@ -27,14 +28,16 @@ const v = /* @__PURE__ */ s({
       id: l.labelForId,
       ariaLabel: l.control.label,
       disabled: l.disabled,
+      error: l.error,
+      "sub-text": l.subText,
       "manually-included": l.control.data ?? [],
-      "manually-excluded": c.value,
+      "manually-excluded": i.value,
       "possible-values": n.value,
       loading: l.possibleValues === null,
-      "exclude-label": o(t),
+      "exclude-label": o(r),
       "include-label": o(u),
       "onUpdate:manuallyIncluded": l.changeValue
-    }, null, 8, ["id", "ariaLabel", "disabled", "manually-included", "manually-excluded", "possible-values", "loading", "exclude-label", "include-label", "onUpdate:manuallyIncluded"]));
+    }, null, 8, ["id", "ariaLabel", "disabled", "error", "sub-text", "manually-included", "manually-excluded", "possible-values", "loading", "exclude-label", "include-label", "onUpdate:manuallyIncluded"]));
   }
 });
 export {

package/dist/{TypedStringFilter-ry7fTUTx-BqgMPUbD.js → TypedStringFilter-Cx8OCQcE-Cx82QY6q.js}

@@ -1,5 +1,5 @@
 import { defineComponent as a, computed as p, createBlock as r, openBlock as s, mergeProps as u } from "vue";
-import i from "./MultimodeTwinlistControl-yCdeWH2E-BiXMa7PW.js";
+import i from "./MultimodeTwinlistControl-NMnPBn6a-DQkdp8td.js";
 const d = /* @__PURE__ */ a({
   __name: "TypedStringFilter",
   props: {
@@ -7,19 +7,20 @@ const d = /* @__PURE__ */ a({
     handleChange: { type: Function },
     changeValue: { type: Function },
     disabled: { type: Boolean },
-    isValid: { type: Boolean },
+    error: { type: Boolean },
+    subText: {},
     onRegisterValidation: { type: Function },
     labelForId: {}
   },
-  setup(o) {
-    const l = o, e = p(() => l.control.uischema.options);
+  setup(n) {
+    const l = n, e = p(() => l.control.uischema.options);
     return (t, c) => {
-      var n;
+      var o;
       return s(), r(i, u({ ...t.$props, ...t.$attrs }, {
         "show-unknown-values": "",
         "unknown-values-text": e.value.unknownValuesText,
         "empty-state-label": e.value.emptyStateLabel,
-        "show-type-filter": !((n = e.value) != null && n.hideTypeFilter)
+        "show-type-filter": !((o = e.value) != null && o.hideTypeFilter)
       }), null, 16, ["unknown-values-text", "empty-state-label", "show-type-filter"]);
     };
   }

package/dist/{ValueSwitchControl-aVx7pUi9-BQVaMPgo.js → ValueSwitchControl-1ax1yKbk-Dssrj-K0.js}

@@ -1,20 +1,21 @@
-import { defineComponent as o, createBlock as t, openBlock as n, mergeProps as l } from "vue";
-import { U as a } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-BScekfhl-Cu_jwWBt.js";
-const s = /* @__PURE__ */ o({
+import { defineComponent as o, createBlock as t, openBlock as n, mergeProps as r } from "vue";
+import { T as l } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-jxw_5dVt-B1RfPe72.js";
+const u = /* @__PURE__ */ o({
   __name: "ValueSwitchControl",
   props: {
     control: {},
     handleChange: { type: Function },
     changeValue: { type: Function },
     disabled: { type: Boolean },
-    isValid: { type: Boolean },
+    error: { type: Boolean },
+    subText: {},
     onRegisterValidation: { type: Function },
     labelForId: {}
   },
   setup(p) {
-    return (e, r) => (n(), t(a, l(e.$props, { type: "valueSwitch" }), null, 16));
+    return (e, a) => (n(), t(l, r(e.$props, { type: "valueSwitch" }), null, 16));
   }
 });
 export {
-  s as default
+  u as default
 };