bt-core-app 2.2.10 → 2.2.12

package/dist/bt-core/core/node_modules/vuetify/lib/components/VSlider/VSlider.mjs

@@ -0,0 +1,159 @@
+import { ref as k, computed as B, createVNode as m, mergeProps as y, createElementVNode as p, Fragment as U } from "vue";
+import "../../../../../../../_virtual/VSlider.sass.mjs";
+import { VSliderThumb as j } from "./VSliderThumb.mjs";
+import { VSliderTrack as q } from "./VSliderTrack.mjs";
+import { makeVInputProps as z, VInput as P } from "../VInput/VInput.mjs";
+import { makeSliderProps as D, useSteps as G, useSlider as H } from "./slider.mjs";
+import { makeFocusProps as J, useFocus as O } from "../../composables/focus.mjs";
+import { forwardRefs as Q } from "../../composables/forwardRefs.mjs";
+import { useRtl as W } from "../../composables/locale.mjs";
+import { useProxiedModel as X } from "../../composables/proxiedModel.mjs";
+import { VLabel as Y } from "../VLabel/VLabel.mjs";
+import { propsFactory as Z } from "../../util/propsFactory.mjs";
+import { genericComponent as ee } from "../../util/defineComponent.mjs";
+import { useRender as le } from "../../util/useRender.mjs";
+import { filterInputAttrs as ae } from "../../util/helpers.mjs";
+const te = Z({
+  ...J(),
+  ...D(),
+  ...z(),
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  }
+}, "VSlider"), he = ee()({
+  name: "VSlider",
+  inheritAttrs: !1,
+  props: te(),
+  emits: {
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0,
+    start: (e) => !0,
+    end: (e) => !0
+  },
+  setup(e, g) {
+    let {
+      slots: a,
+      emit: b,
+      attrs: x
+    } = g;
+    const v = k(), V = k(), {
+      rtlClasses: F
+    } = W(), c = G(e), t = X(e, "modelValue", void 0, (l) => c.roundValue(l ?? c.min.value)), {
+      min: R,
+      max: A,
+      mousePressed: T,
+      roundValue: S,
+      onSliderMousedown: C,
+      onSliderTouchstart: I,
+      trackContainerRef: M,
+      position: _,
+      hasLabels: w,
+      disabled: u,
+      readonly: r,
+      noKeyboard: N
+    } = H({
+      props: e,
+      steps: c,
+      onSliderStart: () => {
+        !u.value && !r.value && b("start", t.value);
+      },
+      onSliderEnd: (l) => {
+        let {
+          value: o
+        } = l;
+        const i = S(o);
+        !u.value && !r.value && (t.value = i), b("end", i);
+      },
+      onSliderMove: (l) => {
+        let {
+          value: o
+        } = l;
+        !u.value && !r.value && (t.value = S(o));
+      },
+      getActiveThumb: () => {
+        var l;
+        return (l = v.value) == null ? void 0 : l.$el;
+      }
+    }), {
+      isFocused: f,
+      focus: E,
+      blur: K
+    } = O(e), h = B(() => _(t.value));
+    return le(() => {
+      const l = P.filterProps(e), [o, i] = ae(x), L = !!(e.label || a.label || a.prepend);
+      return m(P, y({
+        ref: V,
+        class: ["v-slider", {
+          "v-slider--has-labels": !!a["tick-label"] || w.value,
+          "v-slider--focused": f.value,
+          "v-slider--pressed": T.value,
+          "v-slider--disabled": u.value
+        }, F.value, e.class],
+        style: e.style
+      }, l, o, {
+        focused: f.value
+      }), {
+        ...a,
+        prepend: L ? (n) => {
+          var d, s;
+          return p(U, null, [((d = a.label) == null ? void 0 : d.call(a, n)) ?? (e.label ? m(Y, {
+            id: n.id.value,
+            class: "v-slider__label",
+            text: e.label
+          }, null) : void 0), (s = a.prepend) == null ? void 0 : s.call(a, n)]);
+        } : void 0,
+        default: (n) => {
+          let {
+            id: d,
+            messagesId: s
+          } = n;
+          return p("div", {
+            class: "v-slider__container",
+            onMousedown: r.value ? void 0 : C,
+            onTouchstartPassive: r.value ? void 0 : I
+          }, [p("input", {
+            id: d.value,
+            name: e.name || d.value,
+            disabled: u.value,
+            readonly: r.value,
+            tabindex: "-1",
+            value: t.value
+          }, null), m(q, {
+            ref: M,
+            start: 0,
+            stop: h.value
+          }, {
+            "tick-label": a["tick-label"]
+          }), m(j, y({
+            ref: v,
+            "aria-describedby": s.value,
+            focused: f.value,
+            noKeyboard: N.value,
+            min: R.value,
+            max: A.value,
+            modelValue: t.value,
+            "onUpdate:modelValue": ($) => t.value = $,
+            position: h.value,
+            elevation: e.elevation,
+            onFocus: E,
+            onBlur: K,
+            ripple: e.ripple,
+            name: e.name
+          }, i), {
+            "thumb-label": a["thumb-label"]
+          })]);
+        }
+      });
+    }), Q({
+      focus: () => {
+        var l;
+        return (l = v.value) == null ? void 0 : l.$el.focus();
+      }
+    }, V);
+  }
+});
+export {
+  he as VSlider,
+  te as makeVSliderProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VSlider/VSliderThumb.mjs

@@ -0,0 +1,176 @@
+import { inject as re, shallowRef as q, computed as z, watch as ae, createElementVNode as r, normalizeClass as m, normalizeStyle as v, withDirectives as B, createVNode as ie, vShow as ue } from "vue";
+import "../../../../../../../_virtual/VSliderThumb.sass.mjs";
+import { VSliderSymbol as se } from "./slider.mjs";
+import { VScaleTransition as ne } from "../transitions/index.mjs";
+import { useTextColor as de, useBackgroundColor as me } from "../../composables/color.mjs";
+import { makeComponentProps as ve } from "../../composables/component.mjs";
+import { useElevation as ce } from "../../composables/elevation.mjs";
+import { useRtl as fe } from "../../composables/locale.mjs";
+import E from "../../directives/ripple/index.mjs";
+import { convertToUnit as M, keyValues as be } from "../../util/helpers.mjs";
+import { propsFactory as ye } from "../../util/propsFactory.mjs";
+import { genericComponent as he } from "../../util/defineComponent.mjs";
+import { useRender as pe } from "../../util/useRender.mjs";
+const Ve = ye({
+  focused: Boolean,
+  max: {
+    type: Number,
+    required: !0
+  },
+  min: {
+    type: Number,
+    required: !0
+  },
+  modelValue: {
+    type: Number,
+    required: !0
+  },
+  position: {
+    type: Number,
+    required: !0
+  },
+  ripple: {
+    type: [Boolean, Object],
+    default: !0
+  },
+  name: String,
+  noKeyboard: Boolean,
+  ...ve()
+}, "VSliderThumb"), ze = he()({
+  name: "VSliderThumb",
+  directives: {
+    vRipple: E
+  },
+  props: Ve(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, F) {
+    let {
+      slots: c,
+      emit: L
+    } = F;
+    const w = re(se), {
+      isRtl: C,
+      rtlClasses: j
+    } = fe();
+    if (!w)
+      throw new Error("[Vuetify] v-slider-thumb must be used inside v-slider or v-range-slider");
+    const {
+      min: f,
+      max: i,
+      thumbColor: D,
+      thumbLabelColor: H,
+      step: b,
+      disabled: y,
+      thumbSize: I,
+      thumbLabel: h,
+      direction: O,
+      isReversed: U,
+      vertical: A,
+      readonly: g,
+      elevation: G,
+      mousePressed: J,
+      decimals: Q,
+      indexFromEnd: S
+    } = w, p = q(!1), u = q(!1), W = z(() => y.value ? void 0 : G.value), {
+      elevationClasses: X
+    } = ce(W), {
+      textColorClasses: k,
+      textColorStyles: x
+    } = de(D), {
+      backgroundColorClasses: Y,
+      backgroundColorStyles: Z
+    } = me(H), {
+      pageup: $,
+      pagedown: _,
+      end: K,
+      home: N,
+      left: s,
+      right: n,
+      down: V,
+      up: a
+    } = be, ee = [$, _, K, N, s, n, V, a], le = z(() => b.value ? [1, 2, 3] : [1, 5, 10]);
+    function te(l, t) {
+      if (e.noKeyboard || y.value || !ee.includes(l.key))
+        return;
+      l.preventDefault();
+      const o = b.value || 0.1, d = (i.value - f.value) / o;
+      if ([s, n, V, a].includes(l.key)) {
+        const R = (A.value ? [C.value ? s : n, U.value ? V : a] : S.value !== C.value ? [s, a] : [n, a]).includes(l.key) ? 1 : -1, P = l.shiftKey ? 2 : l.ctrlKey ? 1 : 0;
+        R === -1 && t === i.value && !P && !Number.isInteger(d) ? t = t - d % 1 * o : t = t + R * o * le.value[P];
+      } else if (l.key === N)
+        t = f.value;
+      else if (l.key === K)
+        t = i.value;
+      else {
+        const T = l.key === _ ? 1 : -1;
+        t = t - T * o * (d > 100 ? d / 10 : 10);
+      }
+      return Math.max(e.min, Math.min(e.max, t));
+    }
+    function oe(l) {
+      const t = te(l, e.modelValue);
+      t != null && (u.value = !1, L("update:modelValue", t));
+    }
+    return ae(() => e.focused, (l) => {
+      l && (u.value = !1);
+    }), pe(() => {
+      const l = M(S.value ? 100 - e.position : e.position, "%"), t = h.value === "always" || h.value === !0 && e.focused || h.value === "hover" && (p.value || e.focused && !u.value);
+      return r("div", {
+        class: m(["v-slider-thumb", {
+          "v-slider-thumb--focused": e.focused,
+          "v-slider-thumb--pressed": e.focused && J.value
+        }, e.class, j.value]),
+        style: v([{
+          "--v-slider-thumb-position": l,
+          "--v-slider-thumb-size": M(I.value)
+        }, e.style]),
+        role: "slider",
+        tabindex: y.value ? -1 : 0,
+        "aria-label": e.name,
+        "aria-valuemin": f.value,
+        "aria-valuemax": i.value,
+        "aria-valuenow": e.modelValue,
+        "aria-readonly": !!g.value,
+        "aria-orientation": O.value,
+        onKeydown: g.value ? void 0 : oe,
+        onMouseenter: () => {
+          p.value = !0;
+        },
+        onMouseleave: () => {
+          p.value = !1, u.value = !0;
+        }
+      }, [r("div", {
+        class: m(["v-slider-thumb__surface", k.value, X.value]),
+        style: v(x.value)
+      }, null), B(r("div", {
+        class: m(["v-slider-thumb__ripple", k.value]),
+        style: v(x.value)
+      }, null), [[E, e.ripple, null, {
+        circle: !0,
+        center: !0
+      }]]), ie(ne, {
+        origin: "bottom center"
+      }, {
+        default: () => {
+          var o;
+          return [B(r("div", {
+            class: "v-slider-thumb__label-container"
+          }, [r("div", {
+            class: m(["v-slider-thumb__label", Y.value]),
+            style: v(Z.value)
+          }, [r("div", null, [((o = c["thumb-label"]) == null ? void 0 : o.call(c, {
+            modelValue: e.modelValue
+          })) ?? e.modelValue.toFixed(b.value ? Q.value : 1)]), r("div", {
+            class: "v-slider-thumb__label-wedge"
+          }, null)])]), [[ue, t]])];
+        }
+      })]);
+    }), {};
+  }
+});
+export {
+  ze as VSliderThumb,
+  Ve as makeVSliderThumbProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VSlider/VSliderTrack.mjs

@@ -0,0 +1,109 @@
+import { inject as $, computed as l, createElementVNode as t, normalizeClass as a, normalizeStyle as j } from "vue";
+import "../../../../../../../_virtual/VSliderTrack.sass.mjs";
+import { VSliderSymbol as B } from "./slider.mjs";
+import { useBackgroundColor as _ } from "../../composables/color.mjs";
+import { makeComponentProps as U } from "../../composables/component.mjs";
+import { useRounded as W } from "../../composables/rounded.mjs";
+import { propsFactory as A } from "../../util/propsFactory.mjs";
+import { genericComponent as G } from "../../util/defineComponent.mjs";
+import { convertToUnit as s } from "../../util/helpers.mjs";
+import { useRender as H } from "../../util/useRender.mjs";
+const I = A({
+  start: {
+    type: Number,
+    required: !0
+  },
+  stop: {
+    type: Number,
+    required: !0
+  },
+  ...U()
+}, "VSliderTrack"), le = G()({
+  name: "VSliderTrack",
+  props: I(),
+  emits: {},
+  setup(r, C) {
+    let {
+      slots: o
+    } = C;
+    const n = $(B);
+    if (!n)
+      throw new Error("[Vuetify] v-slider-track must be inside v-slider or v-range-slider");
+    const {
+      color: b,
+      parsedTicks: v,
+      rounded: f,
+      showTicks: i,
+      tickSize: S,
+      trackColor: g,
+      trackFillColor: d,
+      trackSize: T,
+      vertical: c,
+      min: k,
+      max: m,
+      indexFromEnd: V
+    } = n, {
+      roundedClasses: h
+    } = W(f), {
+      backgroundColorClasses: w,
+      backgroundColorStyles: F
+    } = _(d), {
+      backgroundColorClasses: z,
+      backgroundColorStyles: x
+    } = _(g), u = l(() => `inset-${c.value ? "block" : "inline"}-${V.value ? "end" : "start"}`), p = l(() => c.value ? "height" : "width"), E = l(() => ({
+      [u.value]: "0%",
+      [p.value]: "100%"
+    })), N = l(() => r.stop - r.start), q = l(() => ({
+      [u.value]: s(r.start, "%"),
+      [p.value]: s(N.value, "%")
+    })), D = l(() => i.value ? (c.value ? v.value.slice().reverse() : v.value).map((e, P) => {
+      var y;
+      const R = e.value !== k.value && e.value !== m.value ? s(e.position, "%") : void 0;
+      return t("div", {
+        key: e.value,
+        class: a(["v-slider-track__tick", {
+          "v-slider-track__tick--filled": e.position >= r.start && e.position <= r.stop,
+          "v-slider-track__tick--first": e.value === k.value,
+          "v-slider-track__tick--last": e.value === m.value
+        }]),
+        style: {
+          [u.value]: R
+        }
+      }, [(e.label || o["tick-label"]) && t("div", {
+        class: "v-slider-track__tick-label"
+      }, [((y = o["tick-label"]) == null ? void 0 : y.call(o, {
+        tick: e,
+        index: P
+      })) ?? e.label])]);
+    }) : []);
+    return H(() => t("div", {
+      class: a(["v-slider-track", h.value, r.class]),
+      style: j([{
+        "--v-slider-track-size": s(T.value),
+        "--v-slider-tick-size": s(S.value)
+      }, r.style])
+    }, [t("div", {
+      class: a(["v-slider-track__background", z.value, {
+        "v-slider-track__background--opacity": !!b.value || !d.value
+      }]),
+      style: {
+        ...E.value,
+        ...x.value
+      }
+    }, null), t("div", {
+      class: a(["v-slider-track__fill", w.value]),
+      style: {
+        ...q.value,
+        ...F.value
+      }
+    }, null), i.value && t("div", {
+      class: a(["v-slider-track__ticks", {
+        "v-slider-track__ticks--always-show": i.value === "always"
+      }])
+    }, [D.value])])), {};
+  }
+});
+export {
+  le as VSliderTrack,
+  I as makeVSliderTrackProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VSlider/slider.mjs

@@ -0,0 +1,242 @@
+import { makeElevationProps as le } from "../../composables/elevation.mjs";
+import { useForm as ie } from "../../composables/form.mjs";
+import { useRtl as se } from "../../composables/locale.mjs";
+import { makeRoundedProps as ue } from "../../composables/rounded.mjs";
+import { computed as r, toRef as u, shallowRef as K, ref as j, onScopeDispose as ce, provide as de, nextTick as ve } from "vue";
+import { getDecimals as X, createRange as me, clamp as z } from "../../util/helpers.mjs";
+import { propsFactory as fe } from "../../util/propsFactory.mjs";
+const pe = Symbol.for("vuetify:v-slider");
+function he(o, e, i) {
+  const a = i === "vertical", l = e.getBoundingClientRect(), m = "touches" in o ? o.touches[0] : o;
+  return a ? m.clientY - (l.top + l.height / 2) : m.clientX - (l.left + l.width / 2);
+}
+function be(o, e) {
+  return "touches" in o && o.touches.length ? o.touches[0][e] : "changedTouches" in o && o.changedTouches.length ? o.changedTouches[0][e] : o[e];
+}
+const Ee = fe({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  max: {
+    type: [Number, String],
+    default: 100
+  },
+  min: {
+    type: [Number, String],
+    default: 0
+  },
+  step: {
+    type: [Number, String],
+    default: 0
+  },
+  thumbColor: String,
+  thumbLabel: {
+    type: [Boolean, String],
+    default: void 0,
+    validator: (o) => typeof o == "boolean" || o === "always" || o === "hover"
+  },
+  thumbSize: {
+    type: [Number, String],
+    default: 20
+  },
+  showTicks: {
+    type: [Boolean, String],
+    default: !1,
+    validator: (o) => typeof o == "boolean" || o === "always"
+  },
+  ticks: {
+    type: [Array, Object]
+  },
+  tickSize: {
+    type: [Number, String],
+    default: 2
+  },
+  color: String,
+  trackColor: String,
+  trackFillColor: String,
+  trackSize: {
+    type: [Number, String],
+    default: 4
+  },
+  direction: {
+    type: String,
+    default: "horizontal",
+    validator: (o) => ["vertical", "horizontal"].includes(o)
+  },
+  reverse: Boolean,
+  noKeyboard: Boolean,
+  ...ue(),
+  ...le({
+    elevation: 2
+  }),
+  ripple: {
+    type: Boolean,
+    default: !0
+  }
+}, "Slider"), Fe = (o) => {
+  const e = r(() => parseFloat(o.min)), i = r(() => parseFloat(o.max)), a = r(() => Number(o.step) > 0 ? parseFloat(o.step) : 0), l = r(() => Math.max(X(a.value), X(e.value)));
+  function m(f) {
+    if (f = parseFloat(f), a.value <= 0)
+      return f;
+    const s = z(f, e.value, i.value), S = e.value % a.value;
+    let c = Math.round((s - S) / a.value) * a.value + S;
+    return s > c && c + a.value > i.value && (c = i.value), parseFloat(Math.min(c, i.value).toFixed(l.value));
+  }
+  return {
+    min: e,
+    max: i,
+    step: a,
+    decimals: l,
+    roundValue: m
+  };
+}, Te = (o) => {
+  let {
+    props: e,
+    steps: i,
+    onSliderStart: a,
+    onSliderMove: l,
+    onSliderEnd: m,
+    getActiveThumb: f
+  } = o;
+  const s = ie(e), {
+    isRtl: S
+  } = se(), c = u(() => e.reverse), B = r(() => e.direction === "vertical"), L = r(() => B.value !== c.value), {
+    min: d,
+    max: g,
+    step: C,
+    decimals: Y,
+    roundValue: M
+  } = i, U = r(() => parseInt(e.thumbSize, 10)), $ = r(() => parseInt(e.tickSize, 10)), q = r(() => parseInt(e.trackSize, 10)), E = r(() => (g.value - d.value) / C.value), G = r(() => e.error || s.isDisabled.value ? void 0 : e.thumbColor ?? e.color), H = r(() => e.error || s.isDisabled.value ? void 0 : e.thumbColor), J = r(() => e.error || s.isDisabled.value ? void 0 : e.trackColor ?? e.color), Q = r(() => e.error || s.isDisabled.value ? void 0 : e.trackFillColor ?? e.color), F = K(!1), b = K(0), x = j(), p = j();
+  function k(t) {
+    var V;
+    const n = (V = x.value) == null ? void 0 : V.$el;
+    if (!n)
+      return;
+    const v = e.direction === "vertical", ee = v ? "top" : "left", te = v ? "height" : "width", oe = v ? "clientY" : "clientX", {
+      [ee]: ne,
+      [te]: re
+    } = n.getBoundingClientRect(), ae = be(t, oe);
+    let R = z((ae - ne - b.value) / re) || 0;
+    return (v ? L.value : L.value !== S.value) && (R = 1 - R), M(d.value + R * (g.value - d.value));
+  }
+  const D = (t) => {
+    const n = k(t);
+    n != null && m({
+      value: n
+    }), F.value = !1, b.value = 0;
+  }, N = (t) => {
+    const n = k(t);
+    p.value = f(t), p.value && (F.value = !0, p.value.contains(t.target) ? b.value = he(t, p.value, e.direction) : (b.value = 0, n != null && l({
+      value: n
+    })), n != null && a({
+      value: n
+    }), ve(() => {
+      var v;
+      return (v = p.value) == null ? void 0 : v.focus();
+    }));
+  }, y = {
+    passive: !0,
+    capture: !0
+  };
+  function h(t) {
+    const n = k(t);
+    n != null && l({
+      value: n
+    });
+  }
+  function T(t) {
+    t.stopPropagation(), t.preventDefault(), D(t), window.removeEventListener("mousemove", h, y), window.removeEventListener("mouseup", T);
+  }
+  function P(t) {
+    var n;
+    D(t), window.removeEventListener("touchmove", h, y), (n = t.target) == null || n.removeEventListener("touchend", P);
+  }
+  function W(t) {
+    var n;
+    N(t), window.addEventListener("touchmove", h, y), (n = t.target) == null || n.addEventListener("touchend", P, {
+      passive: !1
+    });
+  }
+  function Z(t) {
+    t.button === 0 && (t.preventDefault(), N(t), window.addEventListener("mousemove", h, y), window.addEventListener("mouseup", T, {
+      passive: !1
+    }));
+  }
+  ce(() => {
+    window.removeEventListener("touchmove", h), window.removeEventListener("mousemove", h), window.removeEventListener("mouseup", T);
+  });
+  const w = (t) => {
+    const n = (t - d.value) / (g.value - d.value) * 100;
+    return z(isNaN(n) ? 0 : n, 0, 100);
+  }, O = u(() => e.showTicks), A = r(() => O.value ? e.ticks ? Array.isArray(e.ticks) ? e.ticks.map((t) => ({
+    value: t,
+    position: w(t),
+    label: t.toString()
+  })) : Object.keys(e.ticks).map((t) => ({
+    value: parseFloat(t),
+    position: w(parseFloat(t)),
+    label: e.ticks[t]
+  })) : E.value !== 1 / 0 ? me(E.value + 1).map((t) => {
+    const n = d.value + t * C.value;
+    return {
+      value: n,
+      position: w(n)
+    };
+  }) : [] : []), _ = r(() => A.value.some((t) => {
+    let {
+      label: n
+    } = t;
+    return !!n;
+  })), I = {
+    activeThumbRef: p,
+    color: u(() => e.color),
+    decimals: Y,
+    disabled: s.isDisabled,
+    direction: u(() => e.direction),
+    elevation: u(() => e.elevation),
+    hasLabels: _,
+    isReversed: c,
+    indexFromEnd: L,
+    min: d,
+    max: g,
+    mousePressed: F,
+    noKeyboard: u(() => e.noKeyboard),
+    numTicks: E,
+    onSliderMousedown: Z,
+    onSliderTouchstart: W,
+    parsedTicks: A,
+    parseMouseMove: k,
+    position: w,
+    readonly: s.isReadonly,
+    rounded: u(() => e.rounded),
+    roundValue: M,
+    showTicks: O,
+    startOffset: b,
+    step: C,
+    thumbSize: U,
+    thumbColor: G,
+    thumbLabelColor: H,
+    thumbLabel: u(() => e.thumbLabel),
+    ticks: u(() => e.ticks),
+    tickSize: $,
+    trackColor: J,
+    trackContainerRef: x,
+    trackFillColor: Q,
+    trackSize: q,
+    vertical: B
+  };
+  return de(pe, I), I;
+};
+export {
+  pe as VSliderSymbol,
+  he as getOffset,
+  Ee as makeSliderProps,
+  Te as useSlider,
+  Fe as useSteps
+};