@knime/scripting-editor 0.0.122 → 0.0.124

package/dist/{TimeControl-D_qFhFcO-D6gApdlj.js → TimeControl-DWzlpLX--DVTcWUBt.js}

@@ -1,5 +1,5 @@
 import { defineComponent as p, computed as l, createBlock as m, openBlock as h, unref as t } from "vue";
-import { G as d, z as v } from "./localTimeUtils-Dhde1usg-D7fiiRTs.js";
+import { G as d, z as v } from "./localTimeUtils-Bl9xa5Jk-CrPaYHbw.js";
 const b = /* @__PURE__ */ p({
   __name: "TimeControl",
   props: {

package/dist/TimePartInput-CRP2YYM0-CbQSqTuJ.js

@@ -0,0 +1,253 @@
+import { i as c } from "./arrow-dropdown-DMFBPPcK-uCJYJfqE.js";
+import { resolveComponent as v, createElementBlock as m, openBlock as p, normalizeClass as n, createElementVNode as u, createCommentVNode as f, withModifiers as r, createVNode as h } from "vue";
+import { Y as V } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+const g = (t) => Math.max(Math.floor(Math.log10(Math.abs(t))), 0) + 1, b = 200, I = 50, y = 1, N = {
+  name: "TimePartInput",
+  components: {
+    ArrowIcon: c
+  },
+  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 y;
+    },
+    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, i = parseInt(e, 10);
+      if (e === "")
+        this.localValue = "";
+      else {
+        const o = i.toString(10).length;
+        if (e === "")
+          return;
+        if (isNaN(i) || o > g(this.max)) {
+          this.$refs.input.value = this.padValue(this.localValue);
+          return;
+        }
+      }
+      const l = this.limitBounds(i);
+      l.type ? this.$emit("bounds", l) : this.$emit("update:modelValue", l.value);
+    },
+    validate(t) {
+      let e = !0, i;
+      return t = typeof t > "u" ? this.getValue() : t, typeof t != "number" || isNaN(t) ? (e = !1, i = "Current value is not a number.") : (this.min > t || this.max < t) && (e = !1, i = "Current value is outside allowed range."), { isValid: e, errorMessage: i };
+    },
+    /**
+     * 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 i = e + t;
+      if (i = Math.round(i * 10) / 10, this.validate(i).isValid)
+        this.$refs.input.value = this.padValue(i), this.onInput({ target: this.$refs.input });
+      else {
+        const l = this.limitBounds(i);
+        l.type && this.$emit("bounds", l);
+      }
+    },
+    /**
+     * 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 i = this.stepSize;
+      if (e === "decrease" && (i *= -1), t.type === "mousedown") {
+        this.clicked = !0, this.spinnerArrowTimeout = setTimeout(() => {
+          this.spinnerArrowInterval = setInterval(() => {
+            this.changeValue(i);
+          }, I);
+        }, b);
+        return;
+      }
+      this.clicked && (this.clicked = !1, this.changeValue(i));
+    },
+    toggleHover() {
+      this.hovered = !this.hovered;
+    }
+  }
+}, M = ["id", "value", "min", "max", "step", "disabled"], E = {
+  key: 0,
+  class: "invalid-marker"
+};
+function w(t, e, i, l, o, a) {
+  const d = v("ArrowIcon");
+  return p(), m("div", {
+    class: n(["wrapper", { disabled: i.disabled, compact: i.compact }])
+  }, [
+    u("input", {
+      id: i.id,
+      ref: "input",
+      type: "number",
+      role: "spinButton",
+      value: o.localValue,
+      min: i.min,
+      max: i.max,
+      step: a.stepSize,
+      class: n(a.inputClassList),
+      disabled: i.disabled,
+      onInput: e[0] || (e[0] = (...s) => a.onInput && a.onInput(...s)),
+      onBlur: e[1] || (e[1] = (...s) => a.onBlur && a.onBlur(...s)),
+      onMouseenter: e[2] || (e[2] = (...s) => a.toggleHover && a.toggleHover(...s)),
+      onMouseleave: e[3] || (e[3] = (...s) => a.toggleHover && a.toggleHover(...s))
+    }, null, 42, M),
+    i.isValid ? f("", !0) : (p(), m("span", E)),
+    u("span", {
+      class: n(["increase", { disabled: i.disabled }]),
+      onMousedown: e[4] || (e[4] = r((s) => a.mouseEvent(s, "increase"), ["prevent"])),
+      onMouseup: e[5] || (e[5] = r((s) => a.mouseEvent(s, "increase"), ["prevent"])),
+      onMouseleave: e[6] || (e[6] = (s) => a.mouseEvent(s, "increase"))
+    }, [
+      h(d)
+    ], 34),
+    u("span", {
+      class: n(["decrease", { disabled: i.disabled }]),
+      onMousedown: e[7] || (e[7] = r((s) => a.mouseEvent(s, "decrease"), ["prevent"])),
+      onMouseup: e[8] || (e[8] = r((s) => a.mouseEvent(s, "decrease"), ["prevent"])),
+      onMouseleave: e[9] || (e[9] = (s) => a.mouseEvent(s, "decrease"))
+    }, [
+      h(d)
+    ], 34)
+  ], 2);
+}
+const S = /* @__PURE__ */ V(N, [["render", w], ["__scopeId", "data-v-bf742de5"]]);
+export {
+  S as B
+};

package/dist/TimeframesControl-O_hzJcX5-DXtgwxa_.js

@@ -0,0 +1,94 @@
+import { defineComponent as V, createElementBlock as I, openBlock as x, createVNode as t, unref as d, withCtx as B, createElementVNode as p } from "vue";
+import { B as u } from "./TimePartInput-CRP2YYM0-CbQSqTuJ.js";
+import { Y as b, n as g } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+const F = { class: "timeframe" }, N = { class: "input-wrapper" }, _ = { class: "input-wrapper" }, y = /* @__PURE__ */ V({
+  __name: "TimeframesControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(s) {
+    const f = ["hh", "mm", "ss"].length, c = s, n = (i, e, r) => {
+      var v;
+      const l = (i == null ? void 0 : i.value) ?? i, o = Number(l), a = Number.isNaN(o) ? 0 : o, m = (((v = c.control.data) == null ? void 0 : v[e]) ?? "00:00:00").split(":");
+      for (; m.length < f; )
+        m.push("00");
+      m[r] = String(a).padStart(2, "0"), e === "end" && (m[2] = "59");
+      const h = {
+        ...c.control.data,
+        [e]: m.slice(0, f).join(":")
+      };
+      c.changeValue(h);
+    };
+    return (i, e) => (x(), I("div", F, [
+      t(d(g), { text: "Between" }, {
+        default: B(({ labelForId: r }) => {
+          var l, o;
+          return [
+            p("div", N, [
+              t(d(u), {
+                id: r,
+                min: 0,
+                max: 23,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((l = s.control.data) == null ? void 0 : l.start) ?? "00:00:00").split(":")[0], 10),
+                "onUpdate:modelValue": e[0] || (e[0] = (a) => n(a, "start", 0)),
+                onBounds: e[1] || (e[1] = (a) => n(a, "start", 0))
+              }, null, 8, ["id", "model-value"]),
+              e[8] || (e[8] = p("span", null, ":", -1)),
+              t(d(u), {
+                min: 0,
+                max: 59,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((o = s.control.data) == null ? void 0 : o.start) ?? "00:00:00").split(":")[1], 10),
+                "onUpdate:modelValue": e[2] || (e[2] = (a) => n(a, "start", 1)),
+                onBounds: e[3] || (e[3] = (a) => n(a, "start", 1))
+              }, null, 8, ["model-value"])
+            ])
+          ];
+        }),
+        _: 1
+      }),
+      t(d(g), { text: "and" }, {
+        default: B(({ labelForId: r }) => {
+          var l, o;
+          return [
+            p("div", _, [
+              t(d(u), {
+                id: r,
+                min: 0,
+                max: 23,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((l = s.control.data) == null ? void 0 : l.end) ?? "00:00:00").split(":")[0], 10),
+                "onUpdate:modelValue": e[4] || (e[4] = (a) => n(a, "end", 0)),
+                onBounds: e[5] || (e[5] = (a) => n(a, "end", 0))
+              }, null, 8, ["id", "model-value"]),
+              e[9] || (e[9] = p("span", null, ":", -1)),
+              t(d(u), {
+                min: 0,
+                max: 59,
+                "min-digits": 2,
+                compact: "",
+                "model-value": parseInt((((o = s.control.data) == null ? void 0 : o.end) ?? "00:00:00").split(":")[1], 10),
+                "onUpdate:modelValue": e[6] || (e[6] = (a) => n(a, "end", 1)),
+                onBounds: e[7] || (e[7] = (a) => n(a, "end", 1))
+              }, null, 8, ["model-value"])
+            ])
+          ];
+        }),
+        _: 1
+      })
+    ]));
+  }
+}), k = /* @__PURE__ */ b(y, [["__scopeId", "data-v-fef66a7b"]]);
+export {
+  k as default
+};

package/dist/Tooltip-C9vAa0Wb-DNgF-D1Q.js

@@ -0,0 +1,24 @@
+import { createElementBlock as e, openBlock as o, renderSlot as n, createCommentVNode as p, toDisplayString as s } from "vue";
+import { Y as i } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+const l = {
+  name: "Tooltip",
+  props: {
+    text: {
+      type: String,
+      required: !0
+    }
+  }
+}, a = { class: "tooltip" }, c = {
+  key: 0,
+  class: "text"
+};
+function d(r, m, t, u, f, x) {
+  return o(), e("div", a, [
+    n(r.$slots, "default", {}, void 0, !0),
+    t.text ? (o(), e("span", c, s(t.text), 1)) : p("", !0)
+  ]);
+}
+const y = /* @__PURE__ */ i(l, [["render", d], ["__scopeId", "data-v-64e1cb84"]]);
+export {
+  y as k
+};

package/dist/TwinlistControlBase.vue_vue_type_script_setup_true_lang-DtphbKhB-BhwFw0-m.js

@@ -0,0 +1,42 @@
+import { defineComponent as s, toRef as r, computed as i, createBlock as p, openBlock as b, unref as o } from "vue";
+import { e as m } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+import { c as y } from "./usePossibleValues-B8es3DCW-CX4w2_Zt.js";
+import { p as f } from "./toKdsPossibleValues-BklBg3gG-Dr1D12GJ.js";
+const v = /* @__PURE__ */ s({
+  __name: "TwinlistControlBase",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    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 d = new Set(a.control.data ?? []);
+      return n.value.filter((e) => !d.has(e.id)).map((e) => e.id);
+    });
+    return (d, e) => (b(), p(o(m), {
+      id: l.labelForId,
+      ariaLabel: l.control.label,
+      disabled: l.disabled,
+      "manually-included": l.control.data ?? [],
+      "manually-excluded": c.value,
+      "possible-values": n.value,
+      loading: l.possibleValues === null,
+      "exclude-label": o(t),
+      "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"]));
+  }
+});
+export {
+  v as L
+};

package/dist/TypedStringFilter-ByeMPxR6-CCQ4uw8i.js

@@ -0,0 +1,29 @@
+import { defineComponent as a, computed as p, createBlock as r, openBlock as s, mergeProps as u } from "vue";
+import i from "./MultimodeTwinlistControl-CyZQ54SO-DT50Fro-.js";
+const d = /* @__PURE__ */ a({
+  __name: "TypedStringFilter",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(o) {
+    const l = o, e = p(() => l.control.uischema.options);
+    return (t, c) => {
+      var n;
+      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)
+      }), null, 16, ["unknown-values-text", "empty-state-label", "show-type-filter"]);
+    };
+  }
+});
+export {
+  d as default
+};

package/dist/{ValueSwitch-BKwWC7oO-Dwv2nQCW.js → ValueSwitch-BV9qUd5x-CEiCBY-I.js}

@@ -1,6 +1,6 @@
-import { defineComponent as u, resolveComponent as v, createBlock as V, openBlock as d, normalizeClass as r, withCtx as B, renderSlot as p, normalizeProps as g, guardReactiveProps as h, createElementBlock as o, Fragment as n, renderList as S, createElementVNode as s, createCommentVNode as k, toDisplayString as i } from "vue";
-import { Y as m, s as x } from "./TextControl-D38OA8zM-BYAu2w0I.js";
-const C = u({
+import { defineComponent as u, resolveComponent as v, createBlock as V, openBlock as d, normalizeClass as r, withCtx as B, renderSlot as p, normalizeProps as g, guardReactiveProps as h, createElementBlock as o, Fragment as n, renderList as S, createElementVNode as s, createCommentVNode as C, toDisplayString as i } from "vue";
+import { Y as m, p as k } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+const x = u({
   name: "BaseRadioButtons",
   props: {
     id: {
@@ -14,7 +14,7 @@ const C = u({
     name: {
       type: String,
       default() {
-        return `RadioButtons-${x()}`;
+        return `RadioButtons-${k()}`;
       }
     },
     disabled: {
@@ -65,11 +65,11 @@ function R(e, t, c, b, f, y) {
       a.subtext ? (d(), o(n, { key: 0 }, [
         t[1] || (t[1] = s("br", null, null, -1)),
         s("span", null, i(a.subtext), 1)
-      ], 64)) : k("", !0)
+      ], 64)) : C("", !0)
     ], 2))), 128))
   ], 8, _);
 }
-const $ = /* @__PURE__ */ m(C, [["render", R], ["__scopeId", "data-v-2bbebb4b"]]), A = u({
+const $ = /* @__PURE__ */ m(x, [["render", R], ["__scopeId", "data-v-2bbebb4b"]]), A = u({
   name: "ValueSwitch",
   components: {
     BaseRadioButtons: $

package/dist/{ValueSwitchControl-B0UEbXJS-D6nVCnmN.js → ValueSwitchControl-nW7WtSSM-D2W0Q4QS.js}

@@ -1,5 +1,5 @@
 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-Dgt56ocW-DvweExgs.js";
+import { U as a } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-Cp22r9KZ-BLsCS6ST.js";
 const s = /* @__PURE__ */ o({
   __name: "ValueSwitchControl",
   props: {

package/dist/{VennDiagramLayout-DImj8tUc.js → VennDiagramLayout-CGbt8VwT.js}

@@ -1,5 +1,5 @@
-import { computed as v, ref as $, defineComponent as i, useAttrs as D, createBlock as k, openBlock as u, resolveDynamicComponent as P, mergeProps as m, unref as a, useId as S, createElementBlock as L, createElementVNode as l, createVNode as o, normalizeProps as f, guardReactiveProps as g, withCtx as V } from "vue";
-import { ah as B, a3 as F, a1 as d, v as I, a9 as R } from "./TextControl-D38OA8zM-BYAu2w0I.js";
+import { computed as v, ref as y, defineComponent as i, useAttrs as D, createBlock as k, openBlock as u, resolveDynamicComponent as P, mergeProps as m, unref as a, useId as S, createElementBlock as L, createElementVNode as l, createVNode as o, normalizeProps as f, guardReactiveProps as g, withCtx as V } from "vue";
+import { av as B, aa as F, a7 as d, v as I, af as R } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
 import { _ as C } from "./_plugin-vue_export-helper-CHgC5LLL.js";
 const z = (t) => {
   const { control: e, handleChange: s } = B(t), { disabledByFlowVariables: n } = F({
@@ -14,9 +14,9 @@ const z = (t) => {
   };
 }, E = (t) => {
   const e = () => {
-  }, s = $(!0);
+  }, s = y(!0);
   return {
-    isSelected: $(t),
+    isSelected: y(t),
     onClick: e,
     disabled: s
   };
@@ -87,7 +87,7 @@ const z = (t) => {
     const e = t, [s, n, c] = e.uischema.elements;
     let r, p, _;
     typeof c > "u" ? (r = s, _ = n) : (p = s, r = n, _ = c);
-    const w = S(), b = `${w}-mask-left`, y = `${w}-mask-right`;
+    const w = S(), b = `${w}-mask-left`, $ = `${w}-mask-right`;
     return (Q, h) => (u(), L("svg", M, [
       l("defs", null, [
         l("mask", { id: b }, h[0] || (h[0] = [
@@ -103,7 +103,7 @@ const z = (t) => {
             fill: "black"
           }, null, -1)
         ])),
-        l("mask", { id: y }, h[1] || (h[1] = [
+        l("mask", { id: $ }, h[1] || (h[1] = [
           l("rect", {
             width: "95",
             height: "60",
@@ -123,7 +123,7 @@ const z = (t) => {
         o(A, f(g({ ...e, uischema: a(r) })), null, 16)
       ], 8, Z),
       l("g", {
-        mask: `url(#${y})`
+        mask: `url(#${$})`
       }, [
         o(J, f(g({ ...e, uischema: a(_) })), null, 16)
       ], 8, j),
@@ -148,7 +148,7 @@ const z = (t) => {
       }, 8, ["elements"]),
       o(a(I), {
         elements: [s.uischema.elements[0]],
-        style: { flex: "0" }
+        class: "flex-none"
       }, {
         default: V(() => [
           o(H, f(g(e)), null, 16)
@@ -157,7 +157,7 @@ const z = (t) => {
       }, 8, ["elements"])
     ]));
   }
-}), X = /* @__PURE__ */ C(O, [["__scopeId", "data-v-afd44b0e"]]);
+}), X = /* @__PURE__ */ C(O, [["__scopeId", "data-v-8b7aa709"]]);
 export {
   X as default
 };

package/dist/{VerticalLayout-xxxNQVy2-7Y9vsI3j.js → VerticalLayout-C7_-yu_D-ODUVb0PV.js}

@@ -1,6 +1,6 @@
 import { defineComponent as s, createBlock as t, openBlock as a, withCtx as n, unref as r } from "vue";
-import { v as u, j as m } from "./TextControl-D38OA8zM-BYAu2w0I.js";
-const y = /* @__PURE__ */ s({
+import { v as u, c as m } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+const d = /* @__PURE__ */ s({
   __name: "VerticalLayout",
   props: {
     layout: {}
@@ -25,5 +25,5 @@ const y = /* @__PURE__ */ s({
   }
 });
 export {
-  y as default
+  d as default
 };

package/dist/ZonedDateTimeControl-DlrvZKe4-zaxSf2EX.js

@@ -0,0 +1,72 @@
+import { defineComponent as b, computed as o, createElementBlock as V, openBlock as h, createVNode as m, unref as p } from "vue";
+import { K as w, Z as f, z as g } from "./localTimeUtils-Bl9xa5Jk-CrPaYHbw.js";
+import { Y as y, a as z } from "./TextControl-BlUQLMGo-CSdt3hw2.js";
+const B = ["id"], C = /* @__PURE__ */ b({
+  __name: "ZonedDateTimeControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(l) {
+    const d = l, i = o(() => d.control.uischema.options), a = o({
+      get: () => d.control.data,
+      set: d.changeValue
+    }), t = o({
+      get: () => w(a.value.dateTime),
+      set: (e) => {
+        a.value = {
+          ...a.value,
+          // get wall time of UTC time
+          dateTime: f(e)
+        };
+      }
+    }), u = o({
+      get: () => a.value.timeZone,
+      set: (e) => {
+        a.value = {
+          ...a.value,
+          timeZone: e
+        };
+      }
+    }), v = o(() => {
+      var e;
+      return ((e = i.value) == null ? void 0 : e.possibleValues) ?? [];
+    });
+    return (e, s) => {
+      var r, c;
+      return h(), V("div", {
+        id: l.labelForId,
+        class: "layout-container"
+      }, [
+        m(p(g), {
+          modelValue: t.value,
+          "onUpdate:modelValue": s[0] || (s[0] = (n) => t.value = n),
+          required: !0,
+          "show-timezone": !1,
+          "show-seconds": (r = i.value) == null ? void 0 : r.showSeconds,
+          "show-milliseconds": (c = i.value) == null ? void 0 : c.showMilliseconds,
+          timezone: "UTC",
+          "is-valid": l.isValid,
+          compact: "",
+          disabled: l.disabled
+        }, null, 8, ["modelValue", "show-seconds", "show-milliseconds", "is-valid", "disabled"]),
+        m(p(z), {
+          modelValue: u.value,
+          "onUpdate:modelValue": s[1] || (s[1] = (n) => u.value = n),
+          error: !l.isValid,
+          "possible-values": v.value,
+          disabled: l.disabled,
+          ariaLabel: "Timezone"
+        }, null, 8, ["modelValue", "error", "possible-values", "disabled"])
+      ], 8, B);
+    };
+  }
+}), _ = /* @__PURE__ */ y(C, [["__scopeId", "data-v-bd87c35e"]]);
+export {
+  _ as default
+};