@knime/jsonforms 1.18.9 → 1.18.11

package/dist/IntervalControl-DQCAGoNo.js

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