@knime/jsonforms 0.1.4

package/dist/NumberInput-BdL-jZ-i.js

@@ -0,0 +1,219 @@
+import { X as h, _ as p } from "./index-ZDm2GXeD.js";
+import { resolveComponent as f, openBlock as o, createElementBlock as d, normalizeClass as l, createElementVNode as n, createCommentVNode as V, withModifiers as r, createVNode as m } from "vue";
+const c = 200, g = 50, v = 0.1, E = 1, I = {
+  name: "NumberInput",
+  components: {
+    ArrowIcon: h
+  },
+  props: {
+    modelValue: {
+      default: 0,
+      type: [Number, String],
+      validator(t) {
+        return typeof t == "string" ? t.toLowerCase().includes("e") : typeof t == "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
+    },
+    /**
+     * 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.isInteger ? E : v;
+    },
+    inputClassList() {
+      let t = this.inputClasses;
+      return this.hovered && (t += " hover"), t;
+    },
+    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(t) {
+      return this.isInteger ? parseInt(t.toString(), 10) : parseFloat(t.toString());
+    },
+    getParsedValue() {
+      return this.parseValue(this.localValue);
+    },
+    onInput(t) {
+      const e = t.target.value;
+      t && !e && (t.data === "." || t.data === "-") || (e || (this.getInputRef().value = ""), this.updateAndEmit({ newValue: e }));
+    },
+    updateAndEmit({ newValue: t }) {
+      this.localValue = t, this.$emit("update:modelValue", this.getParsedValue());
+    },
+    onBlur() {
+      this.localValue = this.getParsedValue(), this.getInputRef().valueAsNumber = this.localValue;
+    },
+    validate(t) {
+      let e = !0, a;
+      return t = typeof t > "u" ? this.getParsedValue() : this.parseValue(t), typeof t != "number" || isNaN(t) ? (e = !1, a = "Current value is not a number.") : (this.min > t || this.max < t) && (e = !1, a = "Current value is outside allowed range."), { isValid: e, 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).
+     *
+     * @param  {Number} increment - the amount by which to change the current value.
+     * @returns {undefined}
+     */
+    changeValue(t) {
+      let e = this.getParsedValue();
+      this.validate(e).isValid || (e = this.findNearestValidValue(e));
+      let a = e + t;
+      a = Math.round(a * 10) / 10, this.validate(a).isValid && this.updateAndEmit({ newValue: a });
+    },
+    findNearestValidValue(t) {
+      return t < this.min ? this.min : t > 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(t, e) {
+      if (this.disabled)
+        return;
+      this.spinnerArrowInterval !== null && clearTimeout(this.spinnerArrowInterval), this.spinnerArrowTimeout !== null && clearInterval(this.spinnerArrowTimeout);
+      let a = this.stepSize;
+      if (e === "decrease" && (a *= -1), t.type === "mousedown") {
+        this.clicked = !0, this.spinnerArrowTimeout = setTimeout(() => {
+          this.spinnerArrowInterval = setInterval(() => {
+            this.changeValue(a);
+          }, g);
+        }, c);
+        return;
+      }
+      this.clicked && (this.clicked = !1, this.changeValue(a));
+    },
+    toggleHover() {
+      this.hovered = !this.hovered;
+    }
+  }
+}, b = ["id", "name", "value", "min", "max", "step", "disabled"], N = {
+  key: 0,
+  class: "invalid-marker"
+};
+function A(t, e, a, w, y, s) {
+  const u = f("ArrowIcon");
+  return o(), d("div", {
+    class: l(["wrapper", { disabled: a.disabled, compact: a.compact }])
+  }, [
+    n("input", {
+      id: a.id,
+      ref: "input",
+      name: a.name,
+      type: "number",
+      role: "spinButton",
+      value: s.inputValue,
+      min: a.min,
+      max: a.max,
+      step: s.stepSize,
+      class: l(s.inputClassList),
+      disabled: a.disabled,
+      onInput: e[0] || (e[0] = (i) => s.onInput(i)),
+      onBlur: e[1] || (e[1] = (...i) => s.onBlur && s.onBlur(...i)),
+      onMouseenter: e[2] || (e[2] = (...i) => s.toggleHover && s.toggleHover(...i)),
+      onMouseleave: e[3] || (e[3] = (...i) => s.toggleHover && s.toggleHover(...i))
+    }, null, 42, b),
+    a.isValid ? V("", !0) : (o(), d("span", N)),
+    n("span", {
+      class: l(["increase", { disabled: a.disabled }]),
+      onMousedown: e[4] || (e[4] = r((i) => s.mouseEvent(i, "increase"), ["prevent"])),
+      onMouseup: e[5] || (e[5] = r((i) => s.mouseEvent(i, "increase"), ["prevent"])),
+      onMouseleave: e[6] || (e[6] = (i) => s.mouseEvent(i, "increase"))
+    }, [
+      m(u)
+    ], 34),
+    n("span", {
+      class: l(["decrease", { disabled: a.disabled }]),
+      onMousedown: e[7] || (e[7] = r((i) => s.mouseEvent(i, "decrease"), ["prevent"])),
+      onMouseup: e[8] || (e[8] = r((i) => s.mouseEvent(i, "decrease"), ["prevent"])),
+      onMouseleave: e[9] || (e[9] = (i) => s.mouseEvent(i, "decrease"))
+    }, [
+      m(u)
+    ], 34)
+  ], 2);
+}
+const M = /* @__PURE__ */ p(I, [["render", A], ["__scopeId", "data-v-6b79dc2b"]]);
+export {
+  M as N
+};

package/dist/OneOfDropdown-BmbbuaZk.js

@@ -0,0 +1,15 @@
+import { defineComponent as i, openBlock as c, createBlock as m, mergeProps as l, unref as f } from "vue";
+import { r as u, j as _, o as d } from "./index-ZDm2GXeD.js";
+import { _ as O } from "./DropdownControl.vue_vue_type_script_setup_true_lang-B5dPfH3x.js";
+const k = /* @__PURE__ */ i({
+  __name: "OneOfDropdown",
+  props: u(),
+  setup(r) {
+    var o, n;
+    const e = r, { control: t } = _(e), p = ((n = (o = t.value.schema) == null ? void 0 : o.oneOf) == null ? void 0 : n.map(d)) ?? [], a = Promise.resolve(p);
+    return (s, h) => (c(), m(O, l({ ...s.$attrs, ...s.$props }, { "async-initial-options": f(a) }), null, 16, ["async-initial-options"]));
+  }
+});
+export {
+  k as default
+};

package/dist/RadioControl-GbwpOdAy.js

@@ -0,0 +1,13 @@
+import { defineComponent as o, openBlock as e, createBlock as p, mergeProps as n } from "vue";
+import { r as t } from "./index-ZDm2GXeD.js";
+import { _ as s } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-BlImm9is.js";
+const f = /* @__PURE__ */ o({
+  __name: "RadioControl",
+  props: t(),
+  setup(a) {
+    return (r, m) => (e(), p(s, n(r.$props, { type: "radio" }), null, 16));
+  }
+});
+export {
+  f as default
+};

package/dist/RadioControlBase.vue_vue_type_script_setup_true_lang-BlImm9is.js

@@ -0,0 +1,128 @@
+import { resolveComponent as h, openBlock as c, createBlock as p, normalizeClass as V, defineComponent as y, computed as d, ref as C, onMounted as S, unref as u, withCtx as w, resolveDynamicComponent as R, createCommentVNode as k } from "vue";
+import { _ as x, r as O, a as z, o as L, L as U } from "./index-ZDm2GXeD.js";
+import { B as D, V as F } from "./ValueSwitch-B9oWSkM_.js";
+const M = {
+  name: "RadioButtons",
+  components: {
+    BaseRadioButtons: D
+  },
+  props: {
+    // these props are passed to BaseRadioButtons
+    id: {
+      type: String,
+      default: null
+    },
+    modelValue: {
+      type: String,
+      default: ""
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    /**
+     * 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: () => []
+    },
+    // additional props
+    alignment: {
+      type: String,
+      default: "horizontal",
+      validator(o) {
+        return ["horizontal", "vertical"].includes(o);
+      }
+    }
+  },
+  emits: ["update:modelValue"],
+  methods: {
+    hasSelection() {
+      return this.$refs.radioButton.$refs.input.some((o) => o.checked);
+    }
+  }
+};
+function $(o, a, t, l, b, f) {
+  const r = h("BaseRadioButtons");
+  return c(), p(r, {
+    id: t.id,
+    ref: "radioButton",
+    "possible-values": t.possibleValues,
+    "model-value": t.modelValue,
+    disabled: t.disabled,
+    class: V(["radio-buttons", t.alignment, { disabled: t.disabled }]),
+    "onUpdate:modelValue": a[0] || (a[0] = (m) => o.$emit("update:modelValue", m))
+  }, null, 8, ["id", "possible-values", "model-value", "disabled", "class"]);
+}
+const v = /* @__PURE__ */ x(M, [["render", $], ["__scopeId", "data-v-e428929b"]]), q = 0, A = -10, j = /* @__PURE__ */ y({
+  __name: "RadioControlBase",
+  props: {
+    ...O(),
+    type: {
+      type: String,
+      required: !0,
+      default: "radio"
+    }
+  },
+  setup(o) {
+    const a = o, { onChange: t, control: l, disabled: b } = z({ props: a }), f = d(() => {
+      var e;
+      return (e = l.value.uischema.options) == null ? void 0 : e.radioLayout;
+    }), r = d(
+      () => {
+        var e;
+        return ((e = l.value.uischema.options) == null ? void 0 : e.disabledOptions) ?? [];
+      }
+    ), m = (e) => r.value.includes(e.id) ? { ...e, disabled: !0 } : e, g = d(() => {
+      switch (a.type) {
+        case "valueSwitch":
+          return F;
+        case "radio":
+          return v;
+        default:
+          return v;
+      }
+    }), i = C(null);
+    S(() => {
+      var e, n, s;
+      i.value = (s = (n = (e = l.value) == null ? void 0 : e.schema) == null ? void 0 : n.oneOf) == null ? void 0 : s.map(L).map(m);
+    });
+    const B = (e) => {
+      var n;
+      (n = i.value) != null && n.filter(({ id: s }) => e === s).length && t(e);
+    }, _ = d(
+      () => a.type === "valueSwitch" ? q : A
+    );
+    return (e, n) => (c(), p(U, {
+      control: u(l),
+      "margin-bottom": _.value,
+      onControllingFlowVariableSet: B
+    }, {
+      default: w(({ labelForId: s }) => [
+        i.value ? (c(), p(R(g.value), {
+          key: 0,
+          id: s,
+          "possible-values": i.value,
+          alignment: f.value,
+          disabled: u(b),
+          "model-value": u(l).data,
+          compact: "",
+          "onUpdate:modelValue": u(t)
+        }, null, 8, ["id", "possible-values", "alignment", "disabled", "model-value", "onUpdate:modelValue"])) : k("", !0)
+      ]),
+      _: 1
+    }, 8, ["control", "margin-bottom"]));
+  }
+});
+export {
+  j as _
+};