bt-core-app 2.2.5 → 2.2.6

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

@@ -0,0 +1,51 @@
+import { toRef as r, createVNode as n, withDirectives as i, createElementVNode as m, normalizeClass as l, normalizeStyle as u, vShow as s } from "vue";
+import "../../../../../../../_virtual/VCounter.sass.mjs";
+import { VSlideYTransition as c } from "../transitions/index.mjs";
+import { makeComponentProps as v } from "../../composables/component.mjs";
+import { makeTransitionProps as d, MaybeTransition as f } from "../../composables/transition.mjs";
+import { propsFactory as x } from "../../util/propsFactory.mjs";
+import { genericComponent as C } from "../../util/defineComponent.mjs";
+import { useRender as V } from "../../util/useRender.mjs";
+const y = x({
+  active: Boolean,
+  disabled: Boolean,
+  max: [Number, String],
+  value: {
+    type: [Number, String],
+    default: 0
+  },
+  ...v(),
+  ...d({
+    transition: {
+      component: c
+    }
+  })
+}, "VCounter"), h = C()({
+  name: "VCounter",
+  functional: !0,
+  props: y(),
+  setup(e, o) {
+    let {
+      slots: t
+    } = o;
+    const a = r(() => e.max ? `${e.value} / ${e.max}` : String(e.value));
+    return V(() => n(f, {
+      transition: e.transition
+    }, {
+      default: () => [i(m("div", {
+        class: l(["v-counter", {
+          "text-error": e.max && !e.disabled && parseFloat(e.value) > parseFloat(e.max)
+        }, e.class]),
+        style: u(e.style)
+      }, [t.default ? t.default({
+        counter: a.value,
+        max: e.max,
+        value: e.value
+      }) : a.value]), [[s, e.active]])]
+    })), {};
+  }
+});
+export {
+  h as VCounter,
+  y as makeVCounterProps
+};

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

@@ -0,0 +1,103 @@
+import { ref as x, watch as E, nextTick as p, mergeProps as c, createVNode as s } from "vue";
+import "../../../../../../../_virtual/VDialog.sass.mjs";
+import { makeVOverlayProps as y, VOverlay as d } from "../VOverlay/VOverlay.mjs";
+import { forwardRefs as D } from "../../composables/forwardRefs.mjs";
+import { useProxiedModel as b } from "../../composables/proxiedModel.mjs";
+import { useScopeId as w } from "../../composables/scopeId.mjs";
+import { VDialogTransition as A } from "../transitions/dialog-transition.mjs";
+import { VDefaultsProvider as F } from "../VDefaultsProvider/VDefaultsProvider.mjs";
+import { propsFactory as I } from "../../util/propsFactory.mjs";
+import { omit as L } from "../../util/helpers.mjs";
+import { genericComponent as S } from "../../util/defineComponent.mjs";
+import { useRender as B } from "../../util/useRender.mjs";
+const H = I({
+  fullscreen: Boolean,
+  scrollable: Boolean,
+  ...L(y({
+    captureFocus: !0,
+    origin: "center center",
+    scrollStrategy: "block",
+    transition: {
+      component: A
+    },
+    zIndex: 2400,
+    retainFocus: !0
+  }), ["disableInitialFocus"])
+}, "VDialog"), G = S()({
+  name: "VDialog",
+  props: H(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    afterEnter: () => !0,
+    afterLeave: () => !0
+  },
+  setup(e, v) {
+    let {
+      emit: u,
+      slots: r
+    } = v;
+    const i = b(e, "modelValue"), {
+      scopeId: g
+    } = w(), t = x();
+    function V() {
+      var o;
+      u("afterEnter"), (e.scrim || e.retainFocus) && ((o = t.value) != null && o.contentEl) && !t.value.contentEl.contains(document.activeElement) && t.value.contentEl.focus({
+        preventScroll: !0
+      });
+    }
+    function h() {
+      u("afterLeave");
+    }
+    return E(i, async (o) => {
+      var a;
+      o || (await p(), (a = t.value.activatorEl) == null || a.focus({
+        preventScroll: !0
+      }));
+    }), B(() => {
+      const o = d.filterProps(e), a = c({
+        "aria-haspopup": "dialog"
+      }, e.activatorProps), P = c({
+        tabindex: -1
+      }, e.contentProps);
+      return s(d, c({
+        ref: t,
+        class: ["v-dialog", {
+          "v-dialog--fullscreen": e.fullscreen,
+          "v-dialog--scrollable": e.scrollable
+        }, e.class],
+        style: e.style
+      }, o, {
+        modelValue: i.value,
+        "onUpdate:modelValue": (n) => i.value = n,
+        "aria-modal": "true",
+        activatorProps: a,
+        contentProps: P,
+        height: e.fullscreen ? void 0 : e.height,
+        width: e.fullscreen ? void 0 : e.width,
+        maxHeight: e.fullscreen ? void 0 : e.maxHeight,
+        maxWidth: e.fullscreen ? void 0 : e.maxWidth,
+        role: "dialog",
+        onAfterEnter: V,
+        onAfterLeave: h
+      }, g), {
+        activator: r.activator,
+        default: function() {
+          for (var n = arguments.length, f = new Array(n), l = 0; l < n; l++)
+            f[l] = arguments[l];
+          return s(F, {
+            root: "VDialog"
+          }, {
+            default: () => {
+              var m;
+              return [(m = r.default) == null ? void 0 : m.call(r, ...f)];
+            }
+          });
+        }
+      });
+    }), D({}, t);
+  }
+});
+export {
+  G as VDialog,
+  H as makeVDialogProps
+};

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

@@ -0,0 +1,295 @@
+import { toRef as c, useId as ne, computed as m, ref as F, watch as ae, createElementVNode as a, mergeProps as g, createVNode as o, withDirectives as te, vShow as oe, normalizeClass as ie, normalizeStyle as re, Fragment as de } from "vue";
+import "../../../../../../../_virtual/VField.sass.mjs";
+import { VFieldLabel as p } from "./VFieldLabel.mjs";
+import { VExpandXTransition as se } from "../transitions/index.mjs";
+import { useInputIcon as ue } from "../VInput/InputIcon.mjs";
+import { useBackgroundColor as ce, useTextColor as ve } from "../../composables/color.mjs";
+import { makeComponentProps as fe } from "../../composables/component.mjs";
+import { makeFocusProps as me, useFocus as ge } from "../../composables/focus.mjs";
+import { IconValue as S } from "../../composables/icons.mjs";
+import { makeLoaderProps as be, useLoader as ye, LoaderSlot as Ce } from "../../composables/loader.mjs";
+import { useRtl as he } from "../../composables/locale.mjs";
+import { makeRoundedProps as Ie, useRounded as _e } from "../../composables/rounded.mjs";
+import { makeThemeProps as pe, provideTheme as ke } from "../../composables/theme.mjs";
+import { VDefaultsProvider as Pe } from "../VDefaultsProvider/VDefaultsProvider.mjs";
+import { propsFactory as Be } from "../../util/propsFactory.mjs";
+import { EventProp as x, convertToUnit as Fe } from "../../util/helpers.mjs";
+import { genericComponent as Se } from "../../util/defineComponent.mjs";
+import { PREFERS_REDUCED_MOTION as xe } from "../../util/globals.mjs";
+import { nullifyTransforms as Ve, animate as Re } from "../../util/animation.mjs";
+import { standardEasing as we } from "../../util/easing.mjs";
+import { useRender as Le } from "../../util/useRender.mjs";
+const Ee = ["underlined", "outlined", "filled", "solo", "solo-inverted", "solo-filled", "plain"], $e = Be({
+  appendInnerIcon: S,
+  bgColor: String,
+  clearable: Boolean,
+  clearIcon: {
+    type: S,
+    default: "$clear"
+  },
+  active: Boolean,
+  centerAffix: {
+    type: Boolean,
+    default: void 0
+  },
+  color: String,
+  baseColor: String,
+  dirty: Boolean,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  glow: Boolean,
+  error: Boolean,
+  flat: Boolean,
+  iconColor: [Boolean, String],
+  label: String,
+  persistentClear: Boolean,
+  prependInnerIcon: S,
+  reverse: Boolean,
+  singleLine: Boolean,
+  variant: {
+    type: String,
+    default: "filled",
+    validator: (e) => Ee.includes(e)
+  },
+  "onClick:clear": x(),
+  "onClick:appendInner": x(),
+  "onClick:prependInner": x(),
+  ...fe(),
+  ...be(),
+  ...Ie(),
+  ...pe()
+}, "VField"), al = Se()({
+  name: "VField",
+  inheritAttrs: !1,
+  props: {
+    id: String,
+    details: Boolean,
+    labelId: String,
+    ...me(),
+    ...$e()
+  },
+  emits: {
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, M) {
+    let {
+      attrs: N,
+      emit: De,
+      slots: l
+    } = M;
+    const {
+      themeClasses: U
+    } = ke(e), {
+      loaderClasses: z
+    } = ye(e), {
+      focusClasses: H,
+      isFocused: k,
+      focus: b,
+      blur: y
+    } = ge(e), {
+      InputIcon: P
+    } = ue(e), {
+      roundedClasses: W
+    } = _e(e), {
+      rtlClasses: q
+    } = he(), s = c(() => e.dirty || e.active), V = c(() => !!(e.label || l.label)), v = c(() => !e.singleLine && V.value), X = ne(), u = m(() => e.id || `input-${X}`), R = c(() => e.details ? `${u.value}-messages` : void 0), w = F(), C = F(), L = F(), E = m(() => ["plain", "underlined"].includes(e.variant)), $ = m(() => e.error || e.disabled ? void 0 : s.value && k.value ? e.color : e.baseColor), h = m(() => {
+      if (!(!e.iconColor || e.glow && !k.value))
+        return e.iconColor === !0 ? $.value : e.iconColor;
+    }), {
+      backgroundColorClasses: j,
+      backgroundColorStyles: G
+    } = ce(() => e.bgColor), {
+      textColorClasses: D,
+      textColorStyles: T
+    } = ve($);
+    ae(s, (n) => {
+      if (v.value && !xe()) {
+        const i = w.value.$el, r = C.value.$el;
+        requestAnimationFrame(() => {
+          const d = Ve(i), t = r.getBoundingClientRect(), I = t.x - d.x, _ = t.y - d.y - (d.height / 2 - t.height / 2), A = t.width / 0.75, Q = Math.abs(A - d.width) > 1 ? {
+            maxWidth: Fe(A)
+          } : void 0, Y = getComputedStyle(i), O = getComputedStyle(r), Z = parseFloat(Y.transitionDuration) * 1e3 || 150, ee = parseFloat(O.getPropertyValue("--v-field-label-scale")), le = O.getPropertyValue("color");
+          i.style.visibility = "visible", r.style.visibility = "hidden", Re(i, {
+            transform: `translate(${I}px, ${_}px) scale(${ee})`,
+            color: le,
+            ...Q
+          }, {
+            duration: Z,
+            easing: we,
+            direction: n ? "normal" : "reverse"
+          }).finished.then(() => {
+            i.style.removeProperty("visibility"), r.style.removeProperty("visibility");
+          });
+        });
+      }
+    }, {
+      flush: "post"
+    });
+    const f = m(() => ({
+      isActive: s,
+      isFocused: k,
+      controlRef: L,
+      iconColor: h,
+      blur: y,
+      focus: b
+    })), B = c(() => {
+      const n = !s.value;
+      return {
+        "aria-hidden": n,
+        for: n ? void 0 : u.value
+      };
+    }), J = c(() => {
+      const n = v.value && s.value;
+      return {
+        "aria-hidden": n,
+        for: n ? void 0 : u.value
+      };
+    });
+    function K(n) {
+      n.target !== document.activeElement && n.preventDefault();
+    }
+    return Le(() => {
+      var I;
+      const n = e.variant === "outlined", i = !!(l["prepend-inner"] || e.prependInnerIcon), r = !!(e.clearable || l.clear) && !e.disabled, d = !!(l["append-inner"] || e.appendInnerIcon || r), t = () => l.label ? l.label({
+        ...f.value,
+        label: e.label,
+        props: {
+          for: u.value
+        }
+      }) : e.label;
+      return a("div", g({
+        class: ["v-field", {
+          "v-field--active": s.value,
+          "v-field--appended": d,
+          "v-field--center-affix": e.centerAffix ?? !E.value,
+          "v-field--disabled": e.disabled,
+          "v-field--dirty": e.dirty,
+          "v-field--error": e.error,
+          "v-field--glow": e.glow,
+          "v-field--flat": e.flat,
+          "v-field--has-background": !!e.bgColor,
+          "v-field--persistent-clear": e.persistentClear,
+          "v-field--prepended": i,
+          "v-field--reverse": e.reverse,
+          "v-field--single-line": e.singleLine,
+          "v-field--no-label": !t(),
+          [`v-field--variant-${e.variant}`]: !0
+        }, U.value, j.value, H.value, z.value, W.value, q.value, e.class],
+        style: [G.value, e.style],
+        onClick: K
+      }, N), [a("div", {
+        class: "v-field__overlay"
+      }, null), o(Ce, {
+        name: "v-field",
+        active: !!e.loading,
+        color: e.error ? "error" : typeof e.loading == "string" ? e.loading : e.color
+      }, {
+        default: l.loader
+      }), i && a("div", {
+        key: "prepend",
+        class: "v-field__prepend-inner"
+      }, [l["prepend-inner"] ? l["prepend-inner"](f.value) : e.prependInnerIcon && o(P, {
+        key: "prepend-icon",
+        name: "prependInner",
+        color: h.value
+      }, null)]), a("div", {
+        class: "v-field__field",
+        "data-no-activator": ""
+      }, [["filled", "solo", "solo-inverted", "solo-filled"].includes(e.variant) && v.value && o(p, g({
+        key: "floating-label",
+        ref: C,
+        class: [D.value],
+        floating: !0
+      }, B.value, {
+        style: T.value
+      }), {
+        default: () => [t()]
+      }), V.value && o(p, g({
+        key: "label",
+        ref: w,
+        id: e.labelId
+      }, J.value), {
+        default: () => [t()]
+      }), ((I = l.default) == null ? void 0 : I.call(l, {
+        ...f.value,
+        props: {
+          id: u.value,
+          class: "v-field__input",
+          "aria-describedby": R.value
+        },
+        focus: b,
+        blur: y
+      })) ?? a("div", {
+        id: u.value,
+        class: "v-field__input",
+        "aria-describedby": R.value
+      }, null)]), r && o(se, {
+        key: "clear"
+      }, {
+        default: () => [te(a("div", {
+          class: "v-field__clearable",
+          onMousedown: (_) => {
+            _.preventDefault(), _.stopPropagation();
+          }
+        }, [o(Pe, {
+          defaults: {
+            VIcon: {
+              icon: e.clearIcon
+            }
+          }
+        }, {
+          default: () => [l.clear ? l.clear({
+            ...f.value,
+            props: {
+              onFocus: b,
+              onBlur: y,
+              onClick: e["onClick:clear"],
+              tabindex: -1
+            }
+          }) : o(P, {
+            name: "clear",
+            onFocus: b,
+            onBlur: y,
+            tabindex: -1
+          }, null)]
+        })]), [[oe, e.dirty]])]
+      }), d && a("div", {
+        key: "append",
+        class: "v-field__append-inner"
+      }, [l["append-inner"] ? l["append-inner"](f.value) : e.appendInnerIcon && o(P, {
+        key: "append-icon",
+        name: "appendInner",
+        color: h.value
+      }, null)]), a("div", {
+        class: ie(["v-field__outline", D.value]),
+        style: re(T.value)
+      }, [n && a(de, null, [a("div", {
+        class: "v-field__outline__start"
+      }, null), v.value && a("div", {
+        class: "v-field__outline__notch"
+      }, [o(p, g({
+        ref: C,
+        floating: !0
+      }, B.value), {
+        default: () => [t()]
+      })]), a("div", {
+        class: "v-field__outline__end"
+      }, null)]), E.value && v.value && o(p, g({
+        ref: C,
+        floating: !0
+      }, B.value), {
+        default: () => [t()]
+      })])]);
+    }), {
+      controlRef: L,
+      fieldIconColor: h
+    };
+  }
+});
+export {
+  al as VField,
+  $e as makeVFieldProps
+};

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

@@ -0,0 +1,28 @@
+import { createVNode as r, normalizeClass as t, normalizeStyle as a } from "vue";
+import { makeComponentProps as m } from "../../composables/component.mjs";
+import { VLabel as i } from "../VLabel/VLabel.mjs";
+import { propsFactory as n } from "../../util/propsFactory.mjs";
+import { genericComponent as s } from "../../util/defineComponent.mjs";
+import { useRender as p } from "../../util/useRender.mjs";
+const f = n({
+  floating: Boolean,
+  ...m()
+}, "VFieldLabel"), g = s()({
+  name: "VFieldLabel",
+  props: f(),
+  setup(e, o) {
+    let {
+      slots: l
+    } = o;
+    return p(() => r(i, {
+      class: t(["v-field-label", {
+        "v-field-label--floating": e.floating
+      }, e.class]),
+      style: a(e.style)
+    }, l)), {};
+  }
+});
+export {
+  g as VFieldLabel,
+  f as makeVFieldLabelProps
+};

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

@@ -0,0 +1,53 @@
+import { ref as d, createElementVNode as v, normalizeClass as b, normalizeStyle as y } from "vue";
+import { makeComponentProps as F } from "../../composables/component.mjs";
+import { makeFormProps as V, createForm as h } from "../../composables/form.mjs";
+import { forwardRefs as R } from "../../composables/forwardRefs.mjs";
+import { propsFactory as P } from "../../util/propsFactory.mjs";
+import { genericComponent as k } from "../../util/defineComponent.mjs";
+import { useRender as C } from "../../util/useRender.mjs";
+const S = P({
+  ...F(),
+  ...V()
+}, "VForm"), j = k()({
+  name: "VForm",
+  props: S(),
+  emits: {
+    "update:modelValue": (r) => !0,
+    submit: (r) => !0
+  },
+  setup(r, f) {
+    let {
+      slots: n,
+      emit: l
+    } = f;
+    const m = h(r), a = d();
+    function s(t) {
+      t.preventDefault(), m.reset();
+    }
+    function u(t) {
+      const o = t, e = m.validate();
+      o.then = e.then.bind(e), o.catch = e.catch.bind(e), o.finally = e.finally.bind(e), l("submit", o), o.defaultPrevented || e.then((c) => {
+        var i;
+        let {
+          valid: p
+        } = c;
+        p && ((i = a.value) == null || i.submit());
+      }), o.preventDefault();
+    }
+    return C(() => {
+      var t;
+      return v("form", {
+        ref: a,
+        class: b(["v-form", r.class]),
+        style: y(r.style),
+        novalidate: !0,
+        onReset: s,
+        onSubmit: u
+      }, [(t = n.default) == null ? void 0 : t.call(n, m)]);
+    }), R(m, a);
+  }
+});
+export {
+  j as VForm,
+  S as makeVFormProps
+};

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

@@ -0,0 +1,98 @@
+import "../../../../../../../_virtual/VGrid.sass.mjs";
+import { makeComponentProps as y } from "../../composables/component.mjs";
+import { breakpoints as a } from "../../composables/display.mjs";
+import { makeTagProps as S } from "../../composables/tag.mjs";
+import { capitalize as u, computed as C, h as k } from "vue";
+import { propsFactory as N } from "../../util/propsFactory.mjs";
+import { genericComponent as h } from "../../util/defineComponent.mjs";
+const i = a.reduce((e, r) => (e[r] = {
+  type: [Boolean, String, Number],
+  default: !1
+}, e), {}), m = a.reduce((e, r) => {
+  const t = "offset" + u(r);
+  return e[t] = {
+    type: [String, Number],
+    default: null
+  }, e;
+}, {}), d = a.reduce((e, r) => {
+  const t = "order" + u(r);
+  return e[t] = {
+    type: [String, Number],
+    default: null
+  }, e;
+}, {}), f = {
+  col: Object.keys(i),
+  offset: Object.keys(m),
+  order: Object.keys(d)
+};
+function L(e, r, t) {
+  let n = e;
+  if (!(t == null || t === !1)) {
+    if (r) {
+      const o = r.replace(e, "");
+      n += `-${o}`;
+    }
+    return e === "col" && (n = "v-" + n), e === "col" && (t === "" || t === !0) || (n += `-${t}`), n.toLowerCase();
+  }
+}
+const P = ["auto", "start", "end", "center", "baseline", "stretch"], $ = N({
+  cols: {
+    type: [Boolean, String, Number],
+    default: !1
+  },
+  ...i,
+  offset: {
+    type: [String, Number],
+    default: null
+  },
+  ...m,
+  order: {
+    type: [String, Number],
+    default: null
+  },
+  ...d,
+  alignSelf: {
+    type: String,
+    default: null,
+    validator: (e) => P.includes(e)
+  },
+  ...y(),
+  ...S()
+}, "VCol"), A = h()({
+  name: "VCol",
+  props: $(),
+  setup(e, r) {
+    let {
+      slots: t
+    } = r;
+    const n = C(() => {
+      const o = [];
+      let s;
+      for (s in f)
+        f[s].forEach((l) => {
+          const g = e[l], c = L(s, l, g);
+          c && o.push(c);
+        });
+      const b = o.some((l) => l.startsWith("v-col-"));
+      return o.push({
+        // Default to .v-col if no other col-{bp}-* classes generated nor `cols` specified.
+        "v-col": !b || !e.cols,
+        [`v-col-${e.cols}`]: e.cols,
+        [`offset-${e.offset}`]: e.offset,
+        [`order-${e.order}`]: e.order,
+        [`align-self-${e.alignSelf}`]: e.alignSelf
+      }), o;
+    });
+    return () => {
+      var o;
+      return k(e.tag, {
+        class: [n.value, e.class],
+        style: e.style
+      }, (o = t.default) == null ? void 0 : o.call(t));
+    };
+  }
+});
+export {
+  A as VCol,
+  $ as makeVColProps
+};

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

@@ -0,0 +1,41 @@
+import { createVNode as m, normalizeClass as s, normalizeStyle as i } from "vue";
+import "../../../../../../../_virtual/VContainer.sass.mjs";
+import { makeComponentProps as a } from "../../composables/component.mjs";
+import { makeDimensionProps as l, useDimension as p } from "../../composables/dimensions.mjs";
+import { useRtl as f } from "../../composables/locale.mjs";
+import { makeTagProps as c } from "../../composables/tag.mjs";
+import { propsFactory as u } from "../../util/propsFactory.mjs";
+import { genericComponent as C } from "../../util/defineComponent.mjs";
+import { useRender as d } from "../../util/useRender.mjs";
+const y = u({
+  fluid: {
+    type: Boolean,
+    default: !1
+  },
+  ...a(),
+  ...l(),
+  ...c()
+}, "VContainer"), x = C()({
+  name: "VContainer",
+  props: y(),
+  setup(o, e) {
+    let {
+      slots: t
+    } = e;
+    const {
+      rtlClasses: r
+    } = f(), {
+      dimensionStyles: n
+    } = p(o);
+    return d(() => m(o.tag, {
+      class: s(["v-container", {
+        "v-container--fluid": o.fluid
+      }, r.value, o.class]),
+      style: i([n.value, o.style])
+    }, t)), {};
+  }
+});
+export {
+  x as VContainer,
+  y as makeVContainerProps
+};