bt-core-app 2.2.4 → 2.2.6

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
+};

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

@@ -0,0 +1,104 @@
+import "../../../../../../../_virtual/VGrid.sass.mjs";
+import { makeComponentProps as v } from "../../composables/component.mjs";
+import { breakpoints as S } from "../../composables/display.mjs";
+import { makeTagProps as k } from "../../composables/tag.mjs";
+import { computed as w, h as V, capitalize as b } from "vue";
+import { propsFactory as L } from "../../util/propsFactory.mjs";
+import { genericComponent as N } from "../../util/defineComponent.mjs";
+const i = ["start", "end", "center"], f = ["space-between", "space-around", "space-evenly"];
+function s(t, o) {
+  return S.reduce((e, a) => {
+    const n = t + b(a);
+    return e[n] = o(), e;
+  }, {});
+}
+const P = [...i, "baseline", "stretch"], g = (t) => P.includes(t), d = s("align", () => ({
+  type: String,
+  default: null,
+  validator: g
+})), A = [...i, ...f], y = (t) => A.includes(t), m = s("justify", () => ({
+  type: String,
+  default: null,
+  validator: y
+})), E = [...i, ...f, "stretch"], p = (t) => E.includes(t), C = s("alignContent", () => ({
+  type: String,
+  default: null,
+  validator: p
+})), u = {
+  align: Object.keys(d),
+  justify: Object.keys(m),
+  alignContent: Object.keys(C)
+}, h = {
+  align: "align",
+  justify: "justify",
+  alignContent: "align-content"
+};
+function G(t, o, e) {
+  let a = h[t];
+  if (e != null) {
+    if (o) {
+      const n = o.replace(t, "");
+      a += `-${n}`;
+    }
+    return a += `-${e}`, a.toLowerCase();
+  }
+}
+const R = L({
+  dense: Boolean,
+  noGutters: Boolean,
+  align: {
+    type: String,
+    default: null,
+    validator: g
+  },
+  ...d,
+  justify: {
+    type: String,
+    default: null,
+    validator: y
+  },
+  ...m,
+  alignContent: {
+    type: String,
+    default: null,
+    validator: p
+  },
+  ...C,
+  ...v(),
+  ...k()
+}, "VRow"), x = N()({
+  name: "VRow",
+  props: R(),
+  setup(t, o) {
+    let {
+      slots: e
+    } = o;
+    const a = w(() => {
+      const n = [];
+      let l;
+      for (l in u)
+        u[l].forEach((r) => {
+          const j = t[r], c = G(l, r, j);
+          c && n.push(c);
+        });
+      return n.push({
+        "v-row--no-gutters": t.noGutters,
+        "v-row--dense": t.dense,
+        [`align-${t.align}`]: t.align,
+        [`justify-${t.justify}`]: t.justify,
+        [`align-content-${t.alignContent}`]: t.alignContent
+      }), n;
+    });
+    return () => {
+      var n;
+      return V(t.tag, {
+        class: ["v-row", a.value, t.class],
+        style: t.style
+      }, (n = e.default) == null ? void 0 : n.call(e));
+    };
+  }
+});
+export {
+  x as VRow,
+  R as makeVRowProps
+};

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

@@ -0,0 +1,6 @@
+import "../../../../../../../_virtual/VSpacer.sass.mjs";
+import { createSimpleFunctional as r } from "../../util/createSimpleFunctional.mjs";
+const c = r("v-spacer", "div", "VSpacer");
+export {
+  c as VSpacer
+};

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

@@ -0,0 +1,41 @@
+import { makeDelayProps as u, useDelay as m } from "../../composables/delay.mjs";
+import { useProxiedModel as s } from "../../composables/proxiedModel.mjs";
+import { propsFactory as p } from "../../util/propsFactory.mjs";
+import { genericComponent as i } from "../../util/defineComponent.mjs";
+const d = p({
+  disabled: Boolean,
+  modelValue: {
+    type: Boolean,
+    default: null
+  },
+  ...u()
+}, "VHover"), y = i()({
+  name: "VHover",
+  props: d(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: r
+    } = a;
+    const l = s(e, "modelValue"), {
+      runOpenDelay: n,
+      runCloseDelay: t
+    } = m(e, (o) => !e.disabled && (l.value = o));
+    return () => {
+      var o;
+      return (o = r.default) == null ? void 0 : o.call(r, {
+        isHovering: l.value,
+        props: {
+          onMouseenter: n,
+          onMouseleave: t
+        }
+      });
+    };
+  }
+});
+export {
+  y as VHover,
+  d as makeVHoverProps
+};

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

@@ -0,0 +1,77 @@
+import { shallowRef as C, Text as g, createVNode as y, normalizeClass as k, normalizeStyle as z } from "vue";
+import "../../../../../../../_virtual/VIcon.sass.mjs";
+import { useTextColor as b } from "../../composables/color.mjs";
+import { makeComponentProps as I } from "../../composables/component.mjs";
+import { IconValue as S, useIcon as V } from "../../composables/icons.mjs";
+import { makeSizeProps as x, useSize as T } from "../../composables/size.mjs";
+import { makeTagProps as p } from "../../composables/tag.mjs";
+import { makeThemeProps as P, useTheme as B } from "../../composables/theme.mjs";
+import { flattenFragments as w, convertToUnit as a } from "../../util/helpers.mjs";
+import { propsFactory as F } from "../../util/propsFactory.mjs";
+import { genericComponent as N } from "../../util/defineComponent.mjs";
+import { useRender as R } from "../../util/useRender.mjs";
+const D = F({
+  color: String,
+  disabled: Boolean,
+  start: Boolean,
+  end: Boolean,
+  icon: S,
+  opacity: [String, Number],
+  ...I(),
+  ...x(),
+  ...p({
+    tag: "i"
+  }),
+  ...P()
+}, "VIcon"), Q = N()({
+  name: "VIcon",
+  props: D(),
+  setup(e, u) {
+    let {
+      attrs: l,
+      slots: t
+    } = u;
+    const r = C(), {
+      themeClasses: f
+    } = B(), {
+      iconData: c
+    } = V(() => r.value || e.icon), {
+      sizeClasses: s
+    } = T(e), {
+      textColorClasses: v,
+      textColorStyles: h
+    } = b(() => e.color);
+    return R(() => {
+      var m, d;
+      const n = (m = t.default) == null ? void 0 : m.call(t);
+      n && (r.value = (d = w(n).filter((i) => i.type === g && i.children && typeof i.children == "string")[0]) == null ? void 0 : d.children);
+      const o = !!(l.onClick || l.onClickOnce);
+      return y(c.value.component, {
+        tag: e.tag,
+        icon: c.value.icon,
+        class: k(["v-icon", "notranslate", f.value, s.value, v.value, {
+          "v-icon--clickable": o,
+          "v-icon--disabled": e.disabled,
+          "v-icon--start": e.start,
+          "v-icon--end": e.end
+        }, e.class]),
+        style: z([{
+          "--v-icon-opacity": e.opacity
+        }, s.value ? void 0 : {
+          fontSize: a(e.size),
+          height: a(e.size),
+          width: a(e.size)
+        }, h.value, e.style]),
+        role: o ? "button" : void 0,
+        "aria-hidden": !o,
+        tabindex: o ? e.disabled ? -1 : 0 : void 0
+      }, {
+        default: () => [n]
+      });
+    }), {};
+  }
+});
+export {
+  Q as VIcon,
+  D as makeVIconProps
+};

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

@@ -0,0 +1,248 @@
+import { shallowRef as g, ref as L, computed as V, watch as b, onBeforeMount as D, nextTick as $, onBeforeUnmount as G, toRef as J, withDirectives as B, createVNode as i, mergeProps as K, createElementVNode as c, Fragment as Q, normalizeClass as U, vShow as X } from "vue";
+import "../../../../../../../_virtual/VImg.sass.mjs";
+import { makeVResponsiveProps as Y, VResponsive as N } from "../VResponsive/VResponsive.mjs";
+import { useBackgroundColor as Z } from "../../composables/color.mjs";
+import { makeComponentProps as p } from "../../composables/component.mjs";
+import { makeRoundedProps as ee, useRounded as re } from "../../composables/rounded.mjs";
+import { makeTransitionProps as te, MaybeTransition as S } from "../../composables/transition.mjs";
+import W from "../../directives/intersect/index.mjs";
+import { propsFactory as ae } from "../../util/propsFactory.mjs";
+import { genericComponent as ne } from "../../util/defineComponent.mjs";
+import { getCurrentInstance as le } from "../../util/getCurrentInstance.mjs";
+import { SUPPORTS_INTERSECTION as ie } from "../../util/globals.mjs";
+import { useRender as oe } from "../../util/useRender.mjs";
+import { convertToUnit as ue } from "../../util/helpers.mjs";
+const ce = ae({
+  absolute: Boolean,
+  alt: String,
+  cover: Boolean,
+  color: String,
+  draggable: {
+    type: [Boolean, String],
+    default: void 0
+  },
+  eager: Boolean,
+  gradient: String,
+  imageClass: null,
+  lazySrc: String,
+  options: {
+    type: Object,
+    // For more information on types, navigate to:
+    // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+    default: () => ({
+      root: void 0,
+      rootMargin: void 0,
+      threshold: void 0
+    })
+  },
+  sizes: String,
+  src: {
+    type: [String, Object],
+    default: ""
+  },
+  crossorigin: String,
+  referrerpolicy: String,
+  srcset: String,
+  position: String,
+  ...Y(),
+  ...p(),
+  ...ee(),
+  ...te()
+}, "VImg"), Ie = ne()({
+  name: "VImg",
+  directives: {
+    vIntersect: W
+  },
+  props: ce(),
+  emits: {
+    loadstart: (e) => !0,
+    load: (e) => !0,
+    error: (e) => !0
+  },
+  setup(e, j) {
+    let {
+      emit: _,
+      slots: o
+    } = j;
+    const {
+      backgroundColorClasses: E,
+      backgroundColorStyles: F
+    } = Z(() => e.color), {
+      roundedClasses: O
+    } = re(e), v = le("VImg"), z = g(""), n = L(), a = g(e.eager ? "loading" : "idle"), s = g(), f = g(), l = V(() => e.src && typeof e.src == "object" ? {
+      src: e.src.src,
+      srcset: e.srcset || e.src.srcset,
+      lazySrc: e.lazySrc || e.src.lazySrc,
+      aspect: Number(e.aspectRatio || e.src.aspect || 0)
+    } : {
+      src: e.src,
+      srcset: e.srcset,
+      lazySrc: e.lazySrc,
+      aspect: Number(e.aspectRatio || 0)
+    }), m = V(() => l.value.aspect || s.value / f.value || 0);
+    b(() => e.src, () => {
+      y(a.value !== "idle");
+    }), b(m, (r, t) => {
+      !r && t && n.value && d(n.value);
+    }), D(() => y());
+    function y(r) {
+      if (!(e.eager && r) && !(ie && !r && !e.eager)) {
+        if (a.value = "loading", l.value.lazySrc) {
+          const t = new Image();
+          t.src = l.value.lazySrc, d(t, null);
+        }
+        l.value.src && $(() => {
+          var t;
+          _("loadstart", ((t = n.value) == null ? void 0 : t.currentSrc) || l.value.src), setTimeout(() => {
+            var u;
+            if (!v.isUnmounted)
+              if ((u = n.value) != null && u.complete) {
+                if (n.value.naturalWidth || R(), a.value === "error")
+                  return;
+                m.value || d(n.value, null), a.value === "loading" && C();
+              } else
+                m.value || d(n.value), I();
+          });
+        });
+      }
+    }
+    function C() {
+      var r;
+      v.isUnmounted || (I(), d(n.value), a.value = "loaded", _("load", ((r = n.value) == null ? void 0 : r.currentSrc) || l.value.src));
+    }
+    function R() {
+      var r;
+      v.isUnmounted || (a.value = "error", _("error", ((r = n.value) == null ? void 0 : r.currentSrc) || l.value.src));
+    }
+    function I() {
+      const r = n.value;
+      r && (z.value = r.currentSrc || r.src);
+    }
+    let h = -1;
+    G(() => {
+      clearTimeout(h);
+    });
+    function d(r) {
+      let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100;
+      const u = () => {
+        if (clearTimeout(h), v.isUnmounted)
+          return;
+        const {
+          naturalHeight: T,
+          naturalWidth: k
+        } = r;
+        T || k ? (s.value = k, f.value = T) : !r.complete && a.value === "loading" && t != null ? h = window.setTimeout(u, t) : (r.currentSrc.endsWith(".svg") || r.currentSrc.startsWith("data:image/svg+xml")) && (s.value = 1, f.value = 1);
+      };
+      u();
+    }
+    const P = J(() => ({
+      "v-img__img--cover": e.cover,
+      "v-img__img--contain": !e.cover
+    })), x = () => {
+      var u;
+      if (!l.value.src || a.value === "idle")
+        return null;
+      const r = c("img", {
+        class: U(["v-img__img", P.value, e.imageClass]),
+        style: {
+          objectPosition: e.position
+        },
+        crossorigin: e.crossorigin,
+        src: l.value.src,
+        srcset: l.value.srcset,
+        alt: e.alt,
+        referrerpolicy: e.referrerpolicy,
+        draggable: e.draggable,
+        sizes: e.sizes,
+        ref: n,
+        onLoad: C,
+        onError: R
+      }, null), t = (u = o.sources) == null ? void 0 : u.call(o);
+      return i(S, {
+        transition: e.transition,
+        appear: !0
+      }, {
+        default: () => [B(t ? c("picture", {
+          class: "v-img__picture"
+        }, [t, r]) : r, [[X, a.value === "loaded"]])]
+      });
+    }, H = () => i(S, {
+      transition: e.transition
+    }, {
+      default: () => [l.value.lazySrc && a.value !== "loaded" && c("img", {
+        class: U(["v-img__img", "v-img__img--preload", P.value]),
+        style: {
+          objectPosition: e.position
+        },
+        crossorigin: e.crossorigin,
+        src: l.value.lazySrc,
+        alt: e.alt,
+        referrerpolicy: e.referrerpolicy,
+        draggable: e.draggable
+      }, null)]
+    }), M = () => o.placeholder ? i(S, {
+      transition: e.transition,
+      appear: !0
+    }, {
+      default: () => [(a.value === "loading" || a.value === "error" && !o.error) && c("div", {
+        class: "v-img__placeholder"
+      }, [o.placeholder()])]
+    }) : null, q = () => o.error ? i(S, {
+      transition: e.transition,
+      appear: !0
+    }, {
+      default: () => [a.value === "error" && c("div", {
+        class: "v-img__error"
+      }, [o.error()])]
+    }) : null, A = () => e.gradient ? c("div", {
+      class: "v-img__gradient",
+      style: {
+        backgroundImage: `linear-gradient(${e.gradient})`
+      }
+    }, null) : null, w = g(!1);
+    {
+      const r = b(m, (t) => {
+        t && (requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            w.value = !0;
+          });
+        }), r());
+      });
+    }
+    return oe(() => {
+      const r = N.filterProps(e);
+      return B(i(N, K({
+        class: ["v-img", {
+          "v-img--absolute": e.absolute,
+          "v-img--booting": !w.value,
+          "v-img--fit-content": e.width === "fit-content"
+        }, E.value, O.value, e.class],
+        style: [{
+          width: ue(e.width === "auto" ? s.value : e.width)
+        }, F.value, e.style]
+      }, r, {
+        aspectRatio: m.value,
+        "aria-label": e.alt,
+        role: e.alt ? "img" : void 0
+      }), {
+        additional: () => c(Q, null, [i(x, null, null), i(H, null, null), i(A, null, null), i(M, null, null), i(q, null, null)]),
+        default: o.default
+      }), [[W, {
+        handler: y,
+        options: e.options
+      }, null, {
+        once: !0
+      }]]);
+    }), {
+      currentSrc: z,
+      image: n,
+      state: a,
+      naturalWidth: s,
+      naturalHeight: f
+    };
+  }
+});
+export {
+  Ie as VImg,
+  ce as makeVImgProps
+};

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

@@ -0,0 +1,40 @@
+import { createVNode as f, mergeProps as m } from "vue";
+import { useLocale as s } from "../../composables/locale.mjs";
+import { VIcon as I } from "../VIcon/VIcon.mjs";
+import { callEvent as y } from "../../util/helpers.mjs";
+function b(e) {
+  const {
+    t: c
+  } = s();
+  function p(i) {
+    let {
+      name: o,
+      color: l,
+      ...a
+    } = i;
+    const r = {
+      prepend: "prependAction",
+      prependInner: "prependAction",
+      append: "appendAction",
+      appendInner: "appendAction",
+      clear: "clear"
+    }[o], t = e[`onClick:${o}`];
+    function u(n) {
+      n.key !== "Enter" && n.key !== " " || (n.preventDefault(), n.stopPropagation(), y(t, new PointerEvent("click", n)));
+    }
+    const d = t && r ? c(`$vuetify.input.${r}`, e.label ?? "") : void 0;
+    return f(I, m({
+      icon: e[`${o}Icon`],
+      "aria-label": d,
+      onClick: t,
+      onKeydown: u,
+      color: l
+    }, a), null);
+  }
+  return {
+    InputIcon: p
+  };
+}
+export {
+  b as useInputIcon
+};