@knime/scripting-editor 0.0.121 → 0.0.122

package/dist/IntervalControl-DQCAGoNo-Cr8-ACcA.js

@@ -0,0 +1,767 @@
+import { defineComponent as X, computed as D, createBlock as ee, openBlock as p, unref as v, mergeModels as O, useModel as U, ref as I, watch as q, createElementBlock as h, createElementVNode as m, withDirectives as N, normalizeClass as x, createCommentVNode as k, withKeys as Ve, vModelText as we, createVNode as y, normalizeStyle as Ae, vShow as R, Fragment as C, renderList as L, toDisplayString as H, withCtx as Y, createTextVNode as Te, resolveComponent as _e, withModifiers as $, renderSlot as be } from "vue";
+import { B as xe, Y as P, q as Ne, x as De, n as Me } from "./TextControl-D38OA8zM-BYAu2w0I.js";
+import { z as $e, _ as Se, H as Re, I as ke, $ as Pe } from "./floating-ui.vue-Fx4CxKut-DAsMxBCU.js";
+import { i as Ce } from "./arrow-dropdown-DMFBPPcK-uCJYJfqE.js";
+import { O as W } from "./ValueSwitch-BKwWC7oO-Dwv2nQCW.js";
+const Fe = {
+  name: "Tooltip",
+  props: {
+    text: {
+      type: String,
+      required: !0
+    }
+  }
+}, Be = { class: "tooltip" }, Ge = {
+  key: 0,
+  class: "text"
+};
+function Oe(e, t, a, l, u, s) {
+  return p(), h("div", Be, [
+    be(e.$slots, "default", {}, void 0, !0),
+    a.text ? (p(), h("span", Ge, H(a.text), 1)) : k("", !0)
+  ]);
+}
+const Ue = /* @__PURE__ */ P(Fe, [["render", Oe], ["__scopeId", "data-v-64e1cb84"]]), te = (e, t) => ({
+  negative: e,
+  years: parseInt(t[1] ?? "0", 10),
+  months: parseInt(t[2] ?? "0", 10),
+  weeks: parseInt(t[3] ?? "0", 10),
+  days: parseInt(t[4] ?? "0", 10)
+}), ae = (e, t) => {
+  var l;
+  const a = parseInt(((l = t[4]) == null ? void 0 : l.padEnd(3, "0")) ?? "0", 10);
+  return {
+    negative: e,
+    hours: parseInt(t[1] ?? "0", 10),
+    minutes: parseInt(t[2] ?? "0", 10),
+    seconds: parseInt(t[3] ?? "0", 10),
+    milliseconds: a
+  };
+}, j = (e) => e.type === "DATE" ? e.interval.years === 0 && e.interval.months === 0 && e.interval.weeks === 0 && e.interval.days === 0 : e.interval.hours === 0 && e.interval.minutes === 0 && e.interval.seconds === 0 && e.interval.milliseconds === 0, F = (e) => {
+  let t = "P";
+  return e.type === "DATE" ? t += `${e.interval.years}Y${e.interval.months}M${e.interval.weeks}W${e.interval.days}D` : t += `T${e.interval.hours}H${e.interval.minutes}M${e.interval.seconds}.${e.interval.milliseconds.toString().padStart(3, "0")}S`, e.interval.negative && (t = `-${t}`), t;
+}, b = (e) => {
+  const t = (l, u) => l === 0 ? "" : l === 1 ? `${l} ${u} ` : `${l} ${u}s `;
+  let a = "";
+  if (e.type === "DATE") {
+    if (j(e))
+      return "0 days";
+    a += t(e.interval.years, "year"), a += t(e.interval.months, "month"), a += t(e.interval.weeks, "week"), a += t(e.interval.days, "day");
+  } else {
+    if (j(e))
+      return "0 seconds";
+    a += t(e.interval.hours, "hour"), a += t(e.interval.minutes, "minute");
+    const l = e.interval.milliseconds === 0;
+    (e.interval.seconds !== 0 || !l) && (l ? a += t(e.interval.seconds, "second") : a += `${e.interval.seconds}.${e.interval.milliseconds.toString().padStart(3, "0")} seconds `);
+  }
+  return e.interval.negative && (a = `-(${a.trim()})`), a.trim();
+}, le = "(\\d+)\\s*y(?:ears?)?", se = "(\\d+)\\s*m(?:o(?:nths?)?)?", re = "(\\d+)\\s*w(?:eeks?)?", ne = "(\\d+)\\s*d(?:ays?)?", ie = "(\\d+)\\s*h(?:ours?)?", oe = "(\\d+)\\s*m(?:in(?:s|utes?)?)?", ue = "(\\d+)(?:[,.](\\d{1,3}))?\\s*s(?:ec(?:s|onds?)?)?", de = new RegExp(
+  `^(?:${le})?\\s*(?:${se})?\\s*(?:${re})?\\s*(?:${ne})?\\s*$`,
+  "i"
+), me = new RegExp(
+  `^(?:${ie})?\\s*(?:${oe})?\\s*(?:${ue})?$`,
+  "i"
+), He = new RegExp(
+  `^\\s*-\\s*\\(\\s*${de.source.replace(/[$^]/g, "")}\\s*\\)\\s*$`,
+  "i"
+), Xe = new RegExp(
+  `^\\s*-\\s*(?:\\s*${le}|${se}|${re}|${ne})\\s*$`,
+  "i"
+), ze = new RegExp(
+  `^\\s*-\\s*\\(\\s*${me.source.replace(/[$^]/g, "")}\\s*\\)\\s*$`,
+  "i"
+), qe = new RegExp(
+  `^\\s*-\\s*(?:\\s*${ie}|${oe}|${ue})\\s*$`,
+  "i"
+), pe = (e) => {
+  if (e = e == null ? void 0 : e.trim(), !e)
+    throw new Error("Empty interval string");
+  const t = de.exec(e), a = He.exec(e) ?? Xe.exec(e), l = me.exec(e), u = ze.exec(e) ?? qe.exec(e), s = t ?? a, d = l ?? u, n = (a ?? u) !== null;
+  if (d && s)
+    throw new Error("Ambiguous time format");
+  if (s)
+    return {
+      type: "DATE",
+      interval: te(n, s)
+    };
+  if (d)
+    return {
+      type: "TIME",
+      interval: ae(n, d)
+    };
+  throw new Error(`Invalid human readable time: ${e}`);
+}, ce = (e, t) => {
+  try {
+    const a = pe(e), l = a.type, u = a.interval.negative;
+    if (l === t || t === "DATE_OR_TIME")
+      return {
+        valid: !0,
+        type: l,
+        negative: u
+      };
+  } catch {
+    return { valid: !1 };
+  }
+}, w = (e) => {
+  if (e = e == null ? void 0 : e.trim(), ["", "P", "PT", "-", "-P", "-PT"].includes(e))
+    throw new Error("Empty ISO duration");
+  const t = /^-?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?$/, a = /^-?PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)(?:[,.](\d{1,3}))?S)?$/, l = t.exec(e), u = a.exec(e);
+  if (l)
+    return {
+      type: "DATE",
+      interval: te(
+        e.startsWith("-"),
+        l
+      )
+    };
+  if (u)
+    return {
+      type: "TIME",
+      interval: ae(
+        e.startsWith("-"),
+        u
+      )
+    };
+  throw new Error(`Invalid ISO duration: ${e}`);
+}, ve = (e, t) => {
+  try {
+    const a = w(e), l = a.type, u = a.interval.negative;
+    if (l === t || t === "DATE_OR_TIME")
+      return {
+        valid: !0,
+        type: l,
+        negative: u
+      };
+  } catch {
+    return { valid: !1 };
+  }
+}, Le = (e) => {
+  const t = ve(e, "DATE_OR_TIME"), a = ce(
+    e,
+    "DATE_OR_TIME"
+  );
+  if (t.valid)
+    return w(e);
+  if (a.valid)
+    return pe(e);
+  throw new Error(`Invalid interval string: ${e}`);
+}, B = (e, t) => {
+  const a = ve(e, t), l = ce(e, t);
+  return a.valid ? a : l.valid ? l : { valid: !1 };
+}, Ye = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function We(e, t) {
+  return p(), h("svg", Ye, [...t[0] || (t[0] = [
+    m("path", { d: "m19.7 17-4.6-2.6V8.7m6.3 15.6h8.7m-3.2-3.2 3.2 3.2-3.2 3.2m-18-5.4c-2.2-1.8-3.6-4.6-3.6-7.7 0-5.5 4.4-9.9 9.9-9.9S25 8.9 25 14.4s-4.4 9.9-9.9 9.9H1.9" }, null, -1)
+  ])]);
+}
+const je = { render: We }, Ke = 200, Je = 50, Qe = 0.1, Ze = 1, et = {
+  name: "NumberInput",
+  components: {
+    ArrowIcon: Ce
+  },
+  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 ? Ze : Qe;
+    },
+    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);
+          }, Je);
+        }, Ke);
+        return;
+      }
+      this.clicked && (this.clicked = !1, this.changeValue(a));
+    },
+    toggleHover() {
+      this.hovered = !this.hovered;
+    }
+  }
+}, tt = ["id", "name", "value", "min", "max", "step", "disabled"], at = {
+  key: 0,
+  class: "invalid-marker"
+};
+function lt(e, t, a, l, u, s) {
+  const d = _e("ArrowIcon");
+  return p(), h("div", {
+    class: x(["wrapper", { disabled: a.disabled, compact: a.compact }])
+  }, [
+    m("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: x(s.inputClassList),
+      disabled: a.disabled,
+      onInput: t[0] || (t[0] = (n) => s.onInput(n)),
+      onBlur: t[1] || (t[1] = (...n) => s.onBlur && s.onBlur(...n)),
+      onMouseenter: t[2] || (t[2] = (...n) => s.toggleHover && s.toggleHover(...n)),
+      onMouseleave: t[3] || (t[3] = (...n) => s.toggleHover && s.toggleHover(...n))
+    }, null, 42, tt),
+    a.isValid ? k("", !0) : (p(), h("span", at)),
+    m("span", {
+      class: x(["increase", { disabled: a.disabled }]),
+      onMousedown: t[4] || (t[4] = $((n) => s.mouseEvent(n, "increase"), ["prevent"])),
+      onMouseup: t[5] || (t[5] = $((n) => s.mouseEvent(n, "increase"), ["prevent"])),
+      onMouseleave: t[6] || (t[6] = (n) => s.mouseEvent(n, "increase"))
+    }, [
+      y(d)
+    ], 34),
+    m("span", {
+      class: x(["decrease", { disabled: a.disabled }]),
+      onMousedown: t[7] || (t[7] = $((n) => s.mouseEvent(n, "decrease"), ["prevent"])),
+      onMouseup: t[8] || (t[8] = $((n) => s.mouseEvent(n, "decrease"), ["prevent"])),
+      onMouseleave: t[9] || (t[9] = (n) => s.mouseEvent(n, "decrease"))
+    }, [
+      y(d)
+    ], 34)
+  ], 2);
+}
+const K = /* @__PURE__ */ P(et, [["render", lt], ["__scopeId", "data-v-0ce77f1e"]]), J = [
+  "years",
+  "months",
+  "weeks",
+  "days"
+], Q = [
+  "hours",
+  "minutes",
+  "seconds",
+  "milliseconds"
+], V = {
+  years: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  months: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  weeks: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  days: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  hours: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  minutes: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  seconds: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  milliseconds: { min: 0, max: 999 }
+}, Z = (e, t) => t === "DATE" ? {
+  type: "DATE",
+  interval: e.periodPart
+} : {
+  type: "TIME",
+  interval: e.durationPart
+}, S = (e, t) => e.type === "DATE" ? {
+  ...t,
+  periodPart: e.interval
+} : {
+  ...t,
+  durationPart: e.interval
+}, G = (e) => e.charAt(0).toUpperCase() + e.slice(1).toLowerCase(), st = { class: "header" }, rt = { class: "ascending-descending-switch-container" }, nt = { class: "input-grid" }, it = { class: "input-label" }, ot = { class: "input-label" }, ut = { class: "accept-controls" }, dt = /* @__PURE__ */ X({
+  __name: "IntervalInputPopoverContent",
+  props: /* @__PURE__ */ O({
+    format: {},
+    allowDescending: { type: Boolean }
+  }, {
+    usedFormat: {
+      required: !0
+    },
+    usedFormatModifiers: {},
+    modelValue: {
+      required: !0
+    },
+    modelModifiers: {}
+  }),
+  emits: /* @__PURE__ */ O(["commit"], ["update:usedFormat", "update:modelValue"]),
+  setup(e, { emit: t }) {
+    const a = t, l = e, u = U(e, "usedFormat"), s = U(e, "modelValue"), d = D(() => {
+      const f = u.value === "DATE" ? J : Q, c = u.value === "DATE" ? f.map(
+        (i) => s.value.periodPart[i]
+      ) : f.map(
+        (i) => s.value.durationPart[i]
+      );
+      for (let i = 0; i < c.length; i++) {
+        const g = f[i], T = c[i];
+        if (isNaN(T) || T < V[g].min || T > V[g].max)
+          return {
+            valid: !1,
+            reason: `${G(g)} out of bounds.`
+          };
+      }
+      return { valid: !0 };
+    }), n = D({
+      get() {
+        return l.allowDescending ? u.value === "DATE" ? s.value.periodPart.negative ? "DESCENDING" : "ASCENDING" : s.value.durationPart.negative ? "DESCENDING" : "ASCENDING" : "ASCENDING";
+      },
+      set(f) {
+        s.value.periodPart.negative = f === "DESCENDING", s.value.durationPart.negative = f === "DESCENDING";
+      }
+    }), A = () => {
+      a(
+        "commit",
+        u.value,
+        s.value,
+        n.value
+      );
+    };
+    return (f, c) => (p(), h(C, null, [
+      m("span", st, [
+        c[2] || (c[2] = m("span", { class: "input-title" }, "Interval", -1)),
+        l.format === "DATE_OR_TIME" ? (p(), ee(W, {
+          key: 0,
+          modelValue: u.value,
+          "onUpdate:modelValue": c[0] || (c[0] = (i) => u.value = i),
+          "possible-values": [
+            { id: "DATE", text: "Date" },
+            { id: "TIME", text: "Time" }
+          ],
+          compact: ""
+        }, null, 8, ["modelValue"])) : k("", !0)
+      ]),
+      N(m("div", rt, [
+        y(W, {
+          modelValue: n.value,
+          "onUpdate:modelValue": c[1] || (c[1] = (i) => n.value = i),
+          compact: "",
+          "possible-values": [
+            { id: "ASCENDING", text: "Forward" },
+            { id: "DESCENDING", text: "Backward" }
+          ]
+        }, null, 8, ["modelValue"])
+      ], 512), [
+        [R, e.allowDescending]
+      ]),
+      m("div", nt, [
+        (p(!0), h(C, null, L(v(J), (i) => N((p(), h("span", {
+          key: i,
+          class: "labeled-date-time-input"
+        }, [
+          m("span", it, H(v(G)(i)), 1),
+          y(K, {
+            modelValue: s.value.periodPart[i],
+            "onUpdate:modelValue": (g) => s.value.periodPart[i] = g,
+            min: v(V)[i].min,
+            max: v(V)[i].max,
+            compact: "",
+            type: "integer"
+          }, null, 8, ["modelValue", "onUpdate:modelValue", "min", "max"])
+        ], 512)), [
+          [R, u.value === "DATE"]
+        ])), 128)),
+        (p(!0), h(C, null, L(v(Q), (i) => N((p(), h("span", {
+          key: i,
+          class: "labeled-date-time-input"
+        }, [
+          m("span", ot, H(v(G)(i)), 1),
+          y(K, {
+            "model-value": s.value.durationPart[i],
+            min: v(V)[i].min,
+            max: v(V)[i].max,
+            compact: "",
+            type: "integer",
+            "onUpdate:modelValue": (g) => {
+              s.value.durationPart[i] = g;
+            }
+          }, null, 8, ["model-value", "min", "max", "onUpdate:modelValue"])
+        ], 512)), [
+          [R, u.value === "TIME"]
+        ])), 128))
+      ]),
+      m("div", ut, [
+        y(Ue, {
+          text: d.value.valid ? "" : d.value.reason
+        }, {
+          default: Y(() => [
+            y(Me, {
+              primary: "",
+              disabled: !d.value.valid,
+              onClick: A
+            }, {
+              default: Y(() => [...c[3] || (c[3] = [
+                Te(" Set ", -1)
+              ])]),
+              _: 1
+            }, 8, ["disabled"])
+          ]),
+          _: 1
+        }, 8, ["text"])
+      ])
+    ], 64));
+  }
+}), mt = /* @__PURE__ */ P(dt, [["__scopeId", "data-v-a372cf12"]]), pt = { class: "input-fields" }, ct = ["disabled", "placeholder"], vt = {
+  key: 0,
+  class: "invalid-marker"
+}, ht = ["disabled"], ft = {}, Et = /* @__PURE__ */ X({
+  ...ft,
+  __name: "IntervalInput",
+  props: /* @__PURE__ */ O({
+    format: { default: "DATE_OR_TIME" },
+    allowDescending: { type: Boolean, default: !0 },
+    disabled: { type: Boolean, default: !1 },
+    compact: { type: Boolean, default: !1 }
+  }, {
+    modelValue: {
+      required: !0
+    },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(e) {
+    const t = e, a = U(e, "modelValue"), l = I(
+      (() => {
+        if (t.format === "DATE_OR_TIME") {
+          const o = B(
+            a.value,
+            "DATE_OR_TIME"
+          );
+          return o.valid ? o.type : "DATE";
+        } else
+          return t.format;
+      })()
+    ), u = D(() => l.value === "DATE" ? "ISO-8601, whole words (1 year), single letters (1y)" : "ISO-8601, whole words (1 hour), single letters (1h)"), s = I(
+      (() => {
+        const o = w(
+          a.value
+        );
+        return S(o, {
+          periodPart: {
+            negative: !1,
+            years: 0,
+            months: 0,
+            weeks: 0,
+            days: 1
+          },
+          durationPart: {
+            negative: !1,
+            hours: 0,
+            minutes: 0,
+            seconds: 1,
+            milliseconds: 0
+          }
+        });
+      })()
+    ), d = I(
+      b(
+        w(a.value)
+      )
+    ), n = D(() => {
+      const o = B(
+        d.value,
+        "DATE_OR_TIME"
+      );
+      return o.valid && (t.allowDescending || !o.negative) && (o.type === l.value || t.format === "DATE_OR_TIME");
+    }), A = I(null), f = I(null), c = I(null), i = (o, r) => {
+      const E = Z(
+        o,
+        r
+      );
+      d.value = b(E), a.value = F(E), l.value = r, s.value = o;
+    }, g = () => {
+      s.value = S(
+        w(a.value),
+        s.value
+      );
+    }, T = (o) => {
+      const r = B(
+        o,
+        "DATE_OR_TIME"
+      );
+      if (!r.valid || !t.allowDescending && r.negative || r.type !== l.value && t.format !== "DATE_OR_TIME")
+        return;
+      const E = Le(
+        o
+      );
+      s.value = S(
+        E,
+        s.value
+      ), a.value = F(E), l.value = r.type, d.value = b(E);
+    }, he = (o) => {
+      const r = w(o);
+      d.value = b(r), s.value = S(
+        r,
+        s.value
+      ), a.value = o;
+    }, fe = (o) => {
+      const r = Z(
+        s.value,
+        o
+      );
+      d.value = b(r), a.value = F(r), l.value = o;
+    }, Ee = (o) => {
+      o !== "DATE_OR_TIME" && fe(o);
+    }, _ = I(!1);
+    q(() => t.format, Ee), q(a, he);
+    const z = (o) => {
+      T(o);
+    }, M = (o, r) => {
+      o && r ? i(
+        r.popoverValues,
+        r.usedFormat
+      ) : g(), _.value = !1;
+    };
+    Ne(A, () => M(!1), {
+      ignore: [f]
+    }), De("Escape", () => M(!1));
+    const { floatingStyles: ge, update: ye } = $e(f, A, {
+      middleware: [
+        Re(),
+        // move left/right to keep it on screen
+        ke({
+          // flip it vertically to keep it on screen
+          mainAxis: !0,
+          crossAxis: !1
+        }),
+        Pe({
+          // move it a bit away from the button vertically
+          mainAxis: 2,
+          // vertical
+          crossAxis: 0
+          // horizontal
+        })
+      ],
+      placement: "top-end",
+      whileElementsMounted: Se
+    });
+    return (o, r) => (p(), h("div", null, [
+      m("div", {
+        class: x(["wrapper", { disabled: e.disabled, compact: e.compact }])
+      }, [
+        m("span", pt, [
+          N(m("input", {
+            ref_key: "inputTextFieldRef",
+            ref: c,
+            "onUpdate:modelValue": r[0] || (r[0] = (E) => d.value = E),
+            type: "text",
+            disabled: e.disabled,
+            placeholder: u.value,
+            spellcheck: "false",
+            onFocus: r[1] || (r[1] = (E) => _.value = !1),
+            onFocusout: r[2] || (r[2] = () => z(d.value)),
+            onKeypress: r[3] || (r[3] = Ve(() => z(d.value), ["enter"]))
+          }, null, 40, ct), [
+            [we, d.value]
+          ]),
+          n.value ? k("", !0) : (p(), h("span", vt)),
+          m("button", {
+            ref_key: "togglePopoverButtonRef",
+            ref: f,
+            class: "trigger-popover-button",
+            disabled: e.disabled,
+            onClick: r[4] || (r[4] = () => {
+              _.value ? M(!1) : (_.value = !0, v(ye)());
+            })
+          }, [
+            y(v(je))
+          ], 8, ht)
+        ])
+      ], 2),
+      N(m("div", {
+        ref_key: "durationInputPopoverRef",
+        ref: A,
+        class: "control-popup",
+        style: Ae(v(ge))
+      }, [
+        y(mt, {
+          "model-value": s.value,
+          "used-format": l.value,
+          format: t.format,
+          "allow-descending": t.allowDescending,
+          onCommit: r[5] || (r[5] = (E, Ie, yt) => M(!0, {
+            usedFormat: E,
+            popoverValues: Ie
+          }))
+        }, null, 8, ["model-value", "used-format", "format", "allow-descending"])
+      ], 4), [
+        [R, _.value]
+      ])
+    ]));
+  }
+}), gt = /* @__PURE__ */ P(Et, [["__scopeId", "data-v-f37d874a"]]), _t = /* @__PURE__ */ X({
+  __name: "IntervalControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(e) {
+    const t = e, a = D(
+      () => t.control.uischema
+    ), l = xe(
+      a,
+      "intervalType",
+      "DATE_OR_TIME"
+    );
+    return (u, s) => (p(), ee(v(gt), {
+      id: e.labelForId,
+      compact: "",
+      disabled: e.disabled,
+      "model-value": e.control.data,
+      format: v(l),
+      "onUpdate:modelValue": e.changeValue
+    }, null, 8, ["id", "disabled", "model-value", "format", "onUpdate:modelValue"]));
+  }
+});
+export {
+  _t as default
+};