bt-core-app 2.2.3 → 2.2.5

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

@@ -0,0 +1,129 @@
+import { ref as I, toRef as r, computed as M, watchEffect as O, createVNode as A, normalizeClass as C, normalizeStyle as h, createElementVNode as n } from "vue";
+import "../../../../../../../_virtual/VProgressCircular.sass.mjs";
+import { useTextColor as y } from "../../composables/color.mjs";
+import { makeComponentProps as D } from "../../composables/component.mjs";
+import { useIntersectionObserver as F } from "../../composables/intersectionObserver.mjs";
+import { useResizeObserver as U } from "../../composables/resizeObserver.mjs";
+import { makeRevealProps as $, useReveal as B } from "../../composables/reveal.mjs";
+import { makeSizeProps as G, useSize as L } from "../../composables/size.mjs";
+import { makeTagProps as W } from "../../composables/tag.mjs";
+import { makeThemeProps as j, provideTheme as q } from "../../composables/theme.mjs";
+import { propsFactory as H } from "../../util/propsFactory.mjs";
+import { genericComponent as J } from "../../util/defineComponent.mjs";
+import { clamp as K, convertToUnit as k } from "../../util/helpers.mjs";
+import { useRender as Q } from "../../util/useRender.mjs";
+import { PREFERS_REDUCED_MOTION as X } from "../../util/globals.mjs";
+const Y = H({
+  bgColor: String,
+  color: String,
+  indeterminate: [Boolean, String],
+  rounded: Boolean,
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  rotate: {
+    type: [Number, String],
+    default: 0
+  },
+  width: {
+    type: [Number, String],
+    default: 4
+  },
+  ...D(),
+  ...$(),
+  ...G(),
+  ...W({
+    tag: "div"
+  }),
+  ...j()
+}, "VProgressCircular"), fe = J()({
+  name: "VProgressCircular",
+  props: Y(),
+  setup(e, S) {
+    let {
+      slots: m
+    } = S;
+    const o = 20, t = 2 * Math.PI * o, i = I(), {
+      themeClasses: b
+    } = q(e), {
+      sizeClasses: p,
+      sizeStyles: v
+    } = L(e), {
+      textColorClasses: R,
+      textColorStyles: w
+    } = y(() => e.color), {
+      textColorClasses: x,
+      textColorStyles: N
+    } = y(() => e.bgColor), {
+      intersectionRef: P,
+      isIntersecting: z
+    } = F(), {
+      resizeRef: _,
+      contentRect: d
+    } = U(), {
+      state: f,
+      duration: E
+    } = B(e), a = r(() => f.value === "initial" ? 0 : K(parseFloat(e.modelValue), 0, 100)), u = r(() => Number(e.width)), g = r(() => v.value ? Number(e.size) : d.value ? d.value.width : Math.max(u.value, 32)), c = r(() => o / (1 - u.value / g.value) * 2), s = r(() => u.value / g.value * c.value), V = r(() => {
+      const l = (100 - a.value) / 100 * t;
+      return e.rounded && a.value > 0 && a.value < 100 ? k(Math.min(t - 0.01, l + s.value)) : k(l);
+    }), T = M(() => {
+      const l = Number(e.rotate);
+      return e.rounded ? l + s.value / 2 / t * 360 : l;
+    });
+    return O(() => {
+      P.value = i.value, _.value = i.value;
+    }), Q(() => A(e.tag, {
+      ref: i,
+      class: C(["v-progress-circular", {
+        "v-progress-circular--indeterminate": !!e.indeterminate,
+        "v-progress-circular--visible": z.value,
+        "v-progress-circular--disable-shrink": e.indeterminate && (e.indeterminate === "disable-shrink" || X()),
+        "v-progress-circular--revealing": ["initial", "pending"].includes(f.value)
+      }, b.value, p.value, R.value, e.class]),
+      style: h([v.value, w.value, {
+        "--progress-reveal-duration": `${E.value}ms`
+      }, e.style]),
+      role: "progressbar",
+      "aria-valuemin": "0",
+      "aria-valuemax": "100",
+      "aria-valuenow": e.indeterminate ? void 0 : a.value
+    }, {
+      default: () => [n("svg", {
+        style: {
+          transform: `rotate(calc(-90deg + ${T.value}deg))`
+        },
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: `0 0 ${c.value} ${c.value}`
+      }, [n("circle", {
+        class: C(["v-progress-circular__underlay", x.value]),
+        style: h(N.value),
+        fill: "transparent",
+        cx: "50%",
+        cy: "50%",
+        r: o,
+        "stroke-width": s.value,
+        "stroke-dasharray": t,
+        "stroke-dashoffset": 0
+      }, null), n("circle", {
+        class: "v-progress-circular__overlay",
+        fill: "transparent",
+        cx: "50%",
+        cy: "50%",
+        r: o,
+        "stroke-width": s.value,
+        "stroke-dasharray": t,
+        "stroke-dashoffset": V.value,
+        "stroke-linecap": e.rounded ? "round" : void 0
+      }, null)]), m.default && n("div", {
+        class: "v-progress-circular__content"
+      }, [m.default({
+        value: a.value
+      })])]
+    })), {};
+  }
+});
+export {
+  fe as VProgressCircular,
+  Y as makeVProgressCircularProps
+};

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

@@ -0,0 +1,195 @@
+import { ref as G, computed as t, shallowRef as H, watchEffect as V, createVNode as P, normalizeClass as n, normalizeStyle as s, createElementVNode as l, Transition as J } from "vue";
+import "../../../../../../../_virtual/VProgressLinear.sass.mjs";
+import { useTextColor as K, useBackgroundColor as h } from "../../composables/color.mjs";
+import { makeComponentProps as Q } from "../../composables/component.mjs";
+import { useIntersectionObserver as Y } from "../../composables/intersectionObserver.mjs";
+import { useRtl as Z } from "../../composables/locale.mjs";
+import { makeLocationProps as ee, useLocation as ae } from "../../composables/location.mjs";
+import { useProxiedModel as te } from "../../composables/proxiedModel.mjs";
+import { useResizeObserver as re } from "../../composables/resizeObserver.mjs";
+import { makeRoundedProps as le, useRounded as oe } from "../../composables/rounded.mjs";
+import { makeTagProps as ne } from "../../composables/tag.mjs";
+import { makeThemeProps as se, provideTheme as ie } from "../../composables/theme.mjs";
+import { useToggleScope as ue } from "../../composables/toggleScope.mjs";
+import { makeChunksProps as ce, useChunks as ve } from "./chunks.mjs";
+import { propsFactory as de } from "../../util/propsFactory.mjs";
+import { genericComponent as me } from "../../util/defineComponent.mjs";
+import { clamp as R, convertToUnit as a } from "../../util/helpers.mjs";
+import { useRender as fe } from "../../util/useRender.mjs";
+const ge = de({
+  absolute: Boolean,
+  active: {
+    type: Boolean,
+    default: !0
+  },
+  bgColor: String,
+  bgOpacity: [Number, String],
+  bufferValue: {
+    type: [Number, String],
+    default: 0
+  },
+  bufferColor: String,
+  bufferOpacity: [Number, String],
+  clickable: Boolean,
+  color: String,
+  height: {
+    type: [Number, String],
+    default: 4
+  },
+  indeterminate: Boolean,
+  max: {
+    type: [Number, String],
+    default: 100
+  },
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  opacity: [Number, String],
+  reverse: Boolean,
+  stream: Boolean,
+  striped: Boolean,
+  roundedBar: Boolean,
+  ...ce(),
+  ...Q(),
+  ...ee({
+    location: "top"
+  }),
+  ...le(),
+  ...ne(),
+  ...se()
+}, "VProgressLinear"), ze = me()({
+  name: "VProgressLinear",
+  props: ge(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, p) {
+    let {
+      slots: y
+    } = p;
+    const v = G(), d = te(e, "modelValue"), {
+      isRtl: x,
+      rtlClasses: w
+    } = Z(), {
+      themeClasses: F
+    } = ie(e), {
+      locationStyles: N
+    } = ae(e), {
+      textColorClasses: T,
+      textColorStyles: O
+    } = K(() => e.color), {
+      backgroundColorClasses: z,
+      backgroundColorStyles: L
+    } = h(() => e.bgColor || e.color), {
+      backgroundColorClasses: M,
+      backgroundColorStyles: W
+    } = h(() => e.bufferColor || e.bgColor || e.color), {
+      backgroundColorClasses: k,
+      backgroundColorStyles: S
+    } = h(() => e.color), {
+      roundedClasses: E
+    } = oe(e), {
+      intersectionRef: m,
+      isIntersecting: I
+    } = Y(), i = t(() => parseFloat(e.max)), o = t(() => parseFloat(e.height)), u = t(() => R(parseFloat(e.bufferValue) / i.value * 100, 0, 100)), f = t(() => R(parseFloat(d.value) / i.value * 100, 0, 100)), c = t(() => x.value !== e.reverse), X = t(() => e.indeterminate ? "fade-transition" : "slide-x-transition"), _ = H(0), {
+      hasChunks: g,
+      chunksMaskStyles: $,
+      snapValueToChunk: B
+    } = ve(e, _);
+    ue(g, () => {
+      const {
+        resizeRef: r
+      } = re((b) => _.value = b[0].contentRect.width);
+      V(() => r.value = v.value);
+    });
+    const U = t(() => g.value ? B(u.value) : u.value), j = t(() => g.value ? B(f.value) : f.value);
+    function q(r) {
+      if (!m.value)
+        return;
+      const {
+        left: b,
+        right: A,
+        width: C
+      } = m.value.getBoundingClientRect(), D = c.value ? C - r.clientX + (A - C) : r.clientX - b;
+      d.value = Math.round(D / C * i.value);
+    }
+    return V(() => {
+      m.value = v.value;
+    }), fe(() => P(e.tag, {
+      ref: v,
+      class: n(["v-progress-linear", {
+        "v-progress-linear--absolute": e.absolute,
+        "v-progress-linear--active": e.active && I.value,
+        "v-progress-linear--reverse": c.value,
+        "v-progress-linear--rounded": e.rounded,
+        "v-progress-linear--rounded-bar": e.roundedBar,
+        "v-progress-linear--striped": e.striped,
+        "v-progress-linear--clickable": e.clickable
+      }, E.value, F.value, w.value, e.class]),
+      style: s([{
+        bottom: e.location === "bottom" ? 0 : void 0,
+        top: e.location === "top" ? 0 : void 0,
+        height: e.active ? a(o.value) : 0,
+        "--v-progress-linear-height": a(o.value),
+        ...e.absolute ? N.value : {}
+      }, $.value, e.style]),
+      role: "progressbar",
+      "aria-hidden": e.active ? "false" : "true",
+      "aria-valuemin": "0",
+      "aria-valuemax": e.max,
+      "aria-valuenow": e.indeterminate ? void 0 : Math.min(parseFloat(d.value), i.value),
+      onClick: e.clickable && q
+    }, {
+      default: () => [e.stream && l("div", {
+        key: "stream",
+        class: n(["v-progress-linear__stream", T.value]),
+        style: {
+          ...O.value,
+          [c.value ? "left" : "right"]: a(-o.value),
+          borderTop: `${a(o.value / 2)} dotted`,
+          opacity: parseFloat(e.bufferOpacity),
+          top: `calc(50% - ${a(o.value / 4)})`,
+          width: a(100 - u.value, "%"),
+          "--v-progress-linear-stream-to": a(o.value * (c.value ? 1 : -1))
+        }
+      }, null), l("div", {
+        class: n(["v-progress-linear__background", z.value]),
+        style: s([L.value, {
+          opacity: parseFloat(e.bgOpacity),
+          width: e.stream ? 0 : void 0
+        }])
+      }, null), l("div", {
+        class: n(["v-progress-linear__buffer", M.value]),
+        style: s([W.value, {
+          opacity: parseFloat(e.bufferOpacity),
+          width: a(U.value, "%")
+        }])
+      }, null), P(J, {
+        name: X.value
+      }, {
+        default: () => [e.indeterminate ? l("div", {
+          class: "v-progress-linear__indeterminate"
+        }, [["long", "short"].map((r) => l("div", {
+          key: r,
+          class: n(["v-progress-linear__indeterminate", r, k.value]),
+          style: s(S.value)
+        }, null))]) : l("div", {
+          class: n(["v-progress-linear__determinate", k.value]),
+          style: s([S.value, {
+            width: a(j.value, "%")
+          }])
+        }, null)]
+      }), y.default && l("div", {
+        class: "v-progress-linear__content"
+      }, [y.default({
+        value: f.value,
+        buffer: u.value
+      })])]
+    })), {};
+  }
+});
+export {
+  ze as VProgressLinear,
+  ge as makeVProgressLinearProps
+};

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

@@ -0,0 +1,53 @@
+import { toRef as h, computed as k, toValue as l } from "vue";
+import { propsFactory as p } from "../../util/propsFactory.mjs";
+import { convertToUnit as s, clamp as v } from "../../util/helpers.mjs";
+const g = p({
+  chunkCount: {
+    type: [Number, String],
+    default: null
+  },
+  chunkWidth: {
+    type: [Number, String],
+    default: null
+  },
+  chunkGap: {
+    type: [Number, String],
+    default: 4
+  }
+}, "chunks");
+function N(t, c) {
+  const r = h(() => !!t.chunkCount || !!t.chunkWidth), o = k(() => {
+    const e = l(c);
+    if (!e)
+      return 0;
+    if (!t.chunkCount)
+      return Number(t.chunkWidth);
+    const n = Number(t.chunkCount);
+    return (e - Number(t.chunkGap) * (n - 1)) / n;
+  }), u = h(() => Number(t.chunkGap)), m = k(() => {
+    if (!r.value)
+      return {};
+    const e = s(u.value), n = s(o.value);
+    return {
+      maskRepeat: "repeat-x",
+      maskImage: `linear-gradient(90deg, #000, #000 ${n}, transparent ${n}, transparent)`,
+      maskSize: `calc(${n} + ${e}) 100%`
+    };
+  });
+  function f(e) {
+    const n = l(c);
+    if (!n)
+      return e;
+    const a = 100 * u.value / n, i = 100 * (o.value + u.value) / n, d = Math.floor((e + a) / i);
+    return v(0, d * i - a / 2, 100);
+  }
+  return {
+    hasChunks: r,
+    chunksMaskStyles: m,
+    snapValueToChunk: f
+  };
+}
+export {
+  g as makeChunksProps,
+  N as useChunks
+};

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

@@ -0,0 +1,56 @@
+import { createElementVNode as t, normalizeClass as i, normalizeStyle as r, computed as m } from "vue";
+import "../../../../../../../_virtual/VResponsive.sass.mjs";
+import { makeComponentProps as p } from "../../composables/component.mjs";
+import { makeDimensionProps as c, useDimension as u } from "../../composables/dimensions.mjs";
+import { propsFactory as v } from "../../util/propsFactory.mjs";
+import { genericComponent as d } from "../../util/defineComponent.mjs";
+import { useRender as f } from "../../util/useRender.mjs";
+function y(e) {
+  return {
+    aspectStyles: m(() => {
+      const s = Number(e.aspectRatio);
+      return s ? {
+        paddingBottom: String(1 / s * 100) + "%"
+      } : void 0;
+    })
+  };
+}
+const R = v({
+  aspectRatio: [String, Number],
+  contentClass: null,
+  inline: Boolean,
+  ...p(),
+  ...c()
+}, "VResponsive"), N = d()({
+  name: "VResponsive",
+  props: R(),
+  setup(e, s) {
+    let {
+      slots: n
+    } = s;
+    const {
+      aspectStyles: l
+    } = y(e), {
+      dimensionStyles: a
+    } = u(e);
+    return f(() => {
+      var o;
+      return t("div", {
+        class: i(["v-responsive", {
+          "v-responsive--inline": e.inline
+        }, e.class]),
+        style: r([a.value, e.style])
+      }, [t("div", {
+        class: "v-responsive__sizer",
+        style: r(l.value)
+      }, null), (o = n.additional) == null ? void 0 : o.call(n), n.default && t("div", {
+        class: i(["v-responsive__content", e.contentClass])
+      }, [n.default()])]);
+    }), {};
+  }
+});
+export {
+  N as VResponsive,
+  R as makeVResponsiveProps,
+  y as useAspectStyles
+};

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

@@ -0,0 +1,167 @@
+import { shallowRef as B, computed as v, createVNode as o, normalizeClass as N, normalizeStyle as E, createElementVNode as a } from "vue";
+import "../../../../../../../_virtual/VToolbar.sass.mjs";
+import { VToolbarTitle as H } from "./VToolbarTitle.mjs";
+import { VExpandTransition as I } from "../transitions/index.mjs";
+import { makeBorderProps as R, useBorder as p } from "../../composables/border.mjs";
+import { useBackgroundColor as D } from "../../composables/color.mjs";
+import { makeComponentProps as w } from "../../composables/component.mjs";
+import { provideDefaults as z } from "../../composables/defaults.mjs";
+import { makeElevationProps as L, useElevation as $ } from "../../composables/elevation.mjs";
+import { useRtl as F } from "../../composables/locale.mjs";
+import { makeLocationProps as U, useLocation as j } from "../../composables/location.mjs";
+import { makeRoundedProps as q, useRounded as A } from "../../composables/rounded.mjs";
+import { makeTagProps as G } from "../../composables/tag.mjs";
+import { makeThemeProps as J, provideTheme as K } from "../../composables/theme.mjs";
+import { VImg as M } from "../VImg/VImg.mjs";
+import { VDefaultsProvider as m } from "../VDefaultsProvider/VDefaultsProvider.mjs";
+import { propsFactory as O } from "../../util/propsFactory.mjs";
+import { genericComponent as Q } from "../../util/defineComponent.mjs";
+import { useRender as W } from "../../util/useRender.mjs";
+import { convertToUnit as l } from "../../util/helpers.mjs";
+const X = [null, "prominent", "default", "comfortable", "compact"], Y = O({
+  absolute: Boolean,
+  collapse: Boolean,
+  collapsePosition: {
+    type: String,
+    default: "start"
+  },
+  color: String,
+  density: {
+    type: String,
+    default: "default",
+    validator: (e) => X.includes(e)
+  },
+  extended: {
+    type: Boolean,
+    default: null
+  },
+  extensionHeight: {
+    type: [Number, String],
+    default: 48
+  },
+  flat: Boolean,
+  floating: Boolean,
+  height: {
+    type: [Number, String],
+    default: 64
+  },
+  image: String,
+  title: String,
+  ...R(),
+  ...w(),
+  ...L(),
+  ...U(),
+  ...q(),
+  ...G({
+    tag: "header"
+  }),
+  ...J()
+}, "VToolbar"), xe = Q()({
+  name: "VToolbar",
+  props: Y(),
+  setup(e, b) {
+    var d;
+    let {
+      slots: t
+    } = b;
+    const {
+      backgroundColorClasses: h,
+      backgroundColorStyles: y
+    } = D(() => e.color), {
+      borderClasses: x
+    } = p(e), {
+      elevationClasses: k
+    } = $(e), {
+      locationStyles: T
+    } = j(e), {
+      roundedClasses: V
+    } = A(e), {
+      themeClasses: C
+    } = K(e), {
+      rtlClasses: P
+    } = F(), n = B(e.extended === null ? !!((d = t.extension) != null && d.call(t)) : e.extended), i = v(() => parseInt(Number(e.height) + (e.density === "prominent" ? Number(e.height) : 0) - (e.density === "comfortable" ? 8 : 0) - (e.density === "compact" ? 16 : 0), 10)), r = v(() => n.value ? parseInt(Number(e.extensionHeight) + (e.density === "prominent" ? Number(e.extensionHeight) : 0) - (e.density === "comfortable" ? 4 : 0) - (e.density === "compact" ? 8 : 0), 10) : 0);
+    return z({
+      VBtn: {
+        variant: "text"
+      }
+    }), W(() => {
+      var u;
+      const S = !!(e.title || t.title), _ = !!(t.image || e.image), s = (u = t.extension) == null ? void 0 : u.call(t);
+      return n.value = e.extended === null ? !!s : e.extended, o(e.tag, {
+        class: N(["v-toolbar", `v-toolbar--collapse-${e.collapsePosition}`, {
+          "v-toolbar--absolute": e.absolute,
+          "v-toolbar--collapse": e.collapse,
+          "v-toolbar--flat": e.flat,
+          "v-toolbar--floating": e.floating,
+          [`v-toolbar--density-${e.density}`]: !0
+        }, h.value, x.value, k.value, V.value, C.value, P.value, e.class]),
+        style: E([y.value, T.value, e.style])
+      }, {
+        default: () => [_ && a("div", {
+          key: "image",
+          class: "v-toolbar__image"
+        }, [t.image ? o(m, {
+          key: "image-defaults",
+          disabled: !e.image,
+          defaults: {
+            VImg: {
+              cover: !0,
+              src: e.image
+            }
+          }
+        }, t.image) : o(M, {
+          key: "image-img",
+          cover: !0,
+          src: e.image
+        }, null)]), o(m, {
+          defaults: {
+            VTabs: {
+              height: l(i.value)
+            }
+          }
+        }, {
+          default: () => {
+            var c, f, g;
+            return [a("div", {
+              class: "v-toolbar__content",
+              style: {
+                height: l(i.value)
+              }
+            }, [t.prepend && a("div", {
+              class: "v-toolbar__prepend"
+            }, [(c = t.prepend) == null ? void 0 : c.call(t)]), S && o(H, {
+              key: "title",
+              text: e.title
+            }, {
+              text: t.title
+            }), (f = t.default) == null ? void 0 : f.call(t), t.append && a("div", {
+              class: "v-toolbar__append"
+            }, [(g = t.append) == null ? void 0 : g.call(t)])])];
+          }
+        }), o(m, {
+          defaults: {
+            VTabs: {
+              height: l(r.value)
+            }
+          }
+        }, {
+          default: () => [o(I, null, {
+            default: () => [n.value && a("div", {
+              class: "v-toolbar__extension",
+              style: {
+                height: l(r.value)
+              }
+            }, [s])]
+          })]
+        })]
+      });
+    }), {
+      contentHeight: i,
+      extensionHeight: r
+    };
+  }
+});
+export {
+  xe as VToolbar,
+  Y as makeVToolbarProps
+};

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

@@ -0,0 +1,37 @@
+import { createVNode as a, normalizeClass as m, normalizeStyle as i, createElementVNode as n } from "vue";
+import { makeComponentProps as s } from "../../composables/component.mjs";
+import { makeTagProps as c } from "../../composables/tag.mjs";
+import { propsFactory as p } from "../../util/propsFactory.mjs";
+import { genericComponent as T } from "../../util/defineComponent.mjs";
+import { useRender as f } from "../../util/useRender.mjs";
+const d = p({
+  text: String,
+  ...s(),
+  ...c()
+}, "VToolbarTitle"), k = T()({
+  name: "VToolbarTitle",
+  props: d(),
+  setup(e, r) {
+    let {
+      slots: t
+    } = r;
+    return f(() => {
+      const l = !!(t.default || t.text || e.text);
+      return a(e.tag, {
+        class: m(["v-toolbar-title", e.class]),
+        style: i(e.style)
+      }, {
+        default: () => {
+          var o;
+          return [l && n("div", {
+            class: "v-toolbar-title__placeholder"
+          }, [t.text ? t.text() : e.text, (o = t.default) == null ? void 0 : o.call(t)])];
+        }
+      });
+    }), {};
+  }
+});
+export {
+  k as VToolbarTitle,
+  d as makeVToolbarTitleProps
+};