bt-core-app 2.2.3 → 2.2.5

package/dist/bt-core/core/node_modules/vuetify/lib/composables/elevation.mjs

@@ -0,0 +1,25 @@
+import { toRef as o, isRef as a } from "vue";
+import { propsFactory as r } from "../util/propsFactory.mjs";
+const s = r({
+  elevation: {
+    type: [Number, String],
+    validator(e) {
+      const t = parseInt(e);
+      return !isNaN(t) && t >= 0 && // Material Design has a maximum elevation of 24
+      // https://material.io/design/environment/elevation.html#default-elevations
+      t <= 24;
+    }
+  }
+}, "elevation");
+function v(e) {
+  return {
+    elevationClasses: o(() => {
+      const n = a(e) ? e.value : e.elevation;
+      return n == null ? [] : [`elevation-${n}`];
+    })
+  };
+}
+export {
+  s as makeElevationProps,
+  v as useElevation
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/focusTrap.mjs

@@ -0,0 +1,97 @@
+import { toRef as h, watch as L, onScopeDispose as k, nextTick as g, toValue as F } from "vue";
+import { propsFactory as K } from "../util/propsFactory.mjs";
+import { IN_BROWSER as D } from "../util/globals.mjs";
+import { focusableChildren as E } from "../util/helpers.mjs";
+const O = K({
+  retainFocus: Boolean,
+  captureFocus: Boolean,
+  /** @deprecated */
+  disableInitialFocus: Boolean
+}, "focusTrap"), y = /* @__PURE__ */ new Map();
+let b = 0;
+function T(n) {
+  const f = document.activeElement;
+  if (n.key !== "Tab" || !f)
+    return;
+  const c = Array.from(y.values()).filter((o) => {
+    var v;
+    let {
+      isActive: d,
+      contentEl: i
+    } = o;
+    return d.value && ((v = i.value) == null ? void 0 : v.contains(f));
+  }).map((o) => o.contentEl.value);
+  let m, u = f.parentElement;
+  for (; u; ) {
+    if (c.includes(u)) {
+      m = u;
+      break;
+    }
+    u = u.parentElement;
+  }
+  if (!m)
+    return;
+  const e = E(m).filter((o) => o.tabIndex >= 0);
+  if (!e.length)
+    return;
+  const s = document.activeElement;
+  if (e.length === 1 && e[0].classList.contains("v-list") && e[0].contains(s)) {
+    n.preventDefault();
+    return;
+  }
+  const a = e[0], r = e[e.length - 1];
+  n.shiftKey && (s === a || a.classList.contains("v-list") && a.contains(s)) && (n.preventDefault(), r.focus()), !n.shiftKey && (s === r || r.classList.contains("v-list") && r.contains(s)) && (n.preventDefault(), a.focus());
+}
+function P(n, f) {
+  let {
+    isActive: c,
+    localTop: m,
+    activatorEl: u,
+    contentEl: e
+  } = f;
+  const s = Symbol("trap");
+  let a = !1, r = -1;
+  async function o() {
+    a = !0, r = window.setTimeout(() => {
+      a = !1;
+    }, 100);
+  }
+  async function d(t) {
+    var w;
+    const p = t.relatedTarget, l = t.target;
+    document.removeEventListener("pointerdown", o), document.removeEventListener("keydown", i), await g(), c.value && !a && p !== l && e.value && // We're the menu without open submenus or overlays
+    F(m) && // It isn't the document or the container body
+    ![document, e.value].includes(l) && // It isn't inside the container body
+    !e.value.contains(l) && ((w = E(e.value)[0]) == null || w.focus());
+  }
+  function i(t) {
+    if (t.key === "Tab" && (document.removeEventListener("keydown", i), c.value && e.value && t.target && !e.value.contains(t.target))) {
+      const p = E(document.documentElement);
+      if (t.shiftKey && t.target === p.at(0) || !t.shiftKey && t.target === p.at(-1)) {
+        const l = E(e.value);
+        l.length > 0 && (t.preventDefault(), l[0].focus());
+      }
+    }
+  }
+  const v = h(() => c.value && n.captureFocus && !n.disableInitialFocus);
+  D && (L(() => n.retainFocus, (t) => {
+    t ? y.set(s, {
+      isActive: c,
+      contentEl: e
+    }) : y.delete(s);
+  }, {
+    immediate: !0
+  }), L(v, (t) => {
+    t ? (document.addEventListener("pointerdown", o), document.addEventListener("focusin", d, {
+      once: !0
+    }), document.addEventListener("keydown", i)) : (document.removeEventListener("pointerdown", o), document.removeEventListener("focusin", d), document.removeEventListener("keydown", i));
+  }, {
+    immediate: !0
+  }), b++ < 1 && document.addEventListener("keydown", T)), k(() => {
+    y.delete(s), clearTimeout(r), document.removeEventListener("pointerdown", o), document.removeEventListener("focusin", d), document.removeEventListener("keydown", i), --b < 1 && document.removeEventListener("keydown", T);
+  });
+}
+export {
+  O as makeFocusTrapProps,
+  P as useFocusTrap
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/forwardRefs.mjs

@@ -0,0 +1,78 @@
+const h = Symbol("Forwarded refs");
+function p(c, u) {
+  let r = c;
+  for (; r; ) {
+    const n = Reflect.getOwnPropertyDescriptor(r, u);
+    if (n)
+      return n;
+    r = Object.getPrototypeOf(r);
+  }
+}
+function R(c) {
+  for (var u = arguments.length, r = new Array(u > 1 ? u - 1 : 0), n = 1; n < u; n++)
+    r[n - 1] = arguments[n];
+  return c[h] = r, new Proxy(c, {
+    get(s, t) {
+      if (Reflect.has(s, t))
+        return Reflect.get(s, t);
+      if (!(typeof t == "symbol" || t.startsWith("$") || t.startsWith("__"))) {
+        for (const e of r)
+          if (e.value && Reflect.has(e.value, t)) {
+            const f = Reflect.get(e.value, t);
+            return typeof f == "function" ? f.bind(e.value) : f;
+          }
+      }
+    },
+    has(s, t) {
+      if (Reflect.has(s, t))
+        return !0;
+      if (typeof t == "symbol" || t.startsWith("$") || t.startsWith("__"))
+        return !1;
+      for (const e of r)
+        if (e.value && Reflect.has(e.value, t))
+          return !0;
+      return !1;
+    },
+    set(s, t, e) {
+      if (Reflect.has(s, t))
+        return Reflect.set(s, t, e);
+      if (typeof t == "symbol" || t.startsWith("$") || t.startsWith("__"))
+        return !1;
+      for (const f of r)
+        if (f.value && Reflect.has(f.value, t))
+          return Reflect.set(f.value, t, e);
+      return !1;
+    },
+    getOwnPropertyDescriptor(s, t) {
+      var f;
+      const e = Reflect.getOwnPropertyDescriptor(s, t);
+      if (e)
+        return e;
+      if (!(typeof t == "symbol" || t.startsWith("$") || t.startsWith("__"))) {
+        for (const o of r) {
+          if (!o.value)
+            continue;
+          const i = p(o.value, t) ?? ("_" in o.value ? p((f = o.value._) == null ? void 0 : f.setupState, t) : void 0);
+          if (i)
+            return i;
+        }
+        for (const o of r) {
+          const i = o.value && o.value[h];
+          if (!i)
+            continue;
+          const l = i.slice();
+          for (; l.length; ) {
+            const a = l.shift(), v = p(a.value, t);
+            if (v)
+              return v;
+            const d = a.value && a.value[h];
+            d && l.push(...d);
+          }
+        }
+      }
+    }
+  });
+}
+export {
+  R as forwardRefs
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/group.mjs

@@ -0,0 +1,169 @@
+import { useProxiedModel as G } from "./proxiedModel.mjs";
+import { useId as E, provide as b, inject as A, toRef as x, computed as g, onBeforeUnmount as w, watch as B, reactive as P, onMounted as k, onUpdated as M, unref as U } from "vue";
+import { deepEqual as $ } from "../util/deepEqual.mjs";
+import { wrapInArray as q, findChildrenWithProvide as F } from "../util/helpers.mjs";
+import { propsFactory as y } from "../util/propsFactory.mjs";
+import { getCurrentInstance as C } from "../util/getCurrentInstance.mjs";
+import { consoleWarn as W } from "../util/console.mjs";
+const Q = y({
+  modelValue: {
+    type: null,
+    default: void 0
+  },
+  multiple: Boolean,
+  mandatory: [Boolean, String],
+  max: Number,
+  selectedClass: String,
+  disabled: Boolean
+}, "group"), X = y({
+  value: null,
+  disabled: Boolean,
+  selectedClass: String
+}, "group-item");
+function Y(s, o) {
+  let d = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !0;
+  const n = C("useGroupItem");
+  if (!n)
+    throw new Error("[Vuetify] useGroupItem composable must be used inside a component setup function");
+  const t = E();
+  b(Symbol.for(`${o.description}:id`), t);
+  const i = A(o, null);
+  if (!i) {
+    if (!d)
+      return i;
+    throw new Error(`[Vuetify] Could not find useGroup injection with symbol ${o.description}`);
+  }
+  const m = x(() => s.value), p = g(() => !!(i.disabled.value || s.disabled));
+  function h() {
+    i == null || i.register({
+      id: t,
+      value: m,
+      disabled: p
+    }, n);
+  }
+  function v() {
+    i == null || i.unregister(t);
+  }
+  h(), w(() => v());
+  const f = g(() => i.isSelected(t)), I = g(() => i.items.value[0].id === t), e = g(() => i.items.value[i.items.value.length - 1].id === t), l = g(() => f.value && [i.selectedClass.value, s.selectedClass]);
+  return B(f, (r) => {
+    n.emit("group:selected", {
+      value: r
+    });
+  }, {
+    flush: "sync"
+  }), {
+    id: t,
+    isSelected: f,
+    isFirst: I,
+    isLast: e,
+    toggle: () => i.select(t, !f.value),
+    select: (r) => i.select(t, r),
+    selectedClass: l,
+    value: m,
+    disabled: p,
+    group: i,
+    register: h,
+    unregister: v
+  };
+}
+function Z(s, o) {
+  let d = !1;
+  const n = P([]), t = G(s, "modelValue", [], (e) => e === void 0 ? [] : S(n, e === null ? [null] : q(e)), (e) => {
+    const l = N(n, e);
+    return s.multiple ? l : l[0];
+  }), i = C("useGroup");
+  function m(e, l) {
+    const r = e, u = Symbol.for(`${o.description}:id`), a = F(u, i == null ? void 0 : i.vnode).indexOf(l);
+    U(r.value) === void 0 && (r.value = a, r.useIndexAsValue = !0), a > -1 ? n.splice(a, 0, r) : n.push(r);
+  }
+  function p(e) {
+    if (d)
+      return;
+    h();
+    const l = n.findIndex((r) => r.id === e);
+    n.splice(l, 1);
+  }
+  function h() {
+    const e = n.find((l) => !l.disabled);
+    e && s.mandatory === "force" && !t.value.length && (t.value = [e.id]);
+  }
+  k(() => {
+    h();
+  }), w(() => {
+    d = !0;
+  }), M(() => {
+    for (let e = 0; e < n.length; e++)
+      n[e].useIndexAsValue && (n[e].value = e);
+  });
+  function v(e, l) {
+    const r = n.find((u) => u.id === e);
+    if (!(l && (r != null && r.disabled)))
+      if (s.multiple) {
+        const u = t.value.slice(), c = u.findIndex((V) => V === e), a = ~c;
+        if (l = l ?? !a, a && s.mandatory && u.length <= 1 || !a && s.max != null && u.length + 1 > s.max)
+          return;
+        c < 0 && l ? u.push(e) : c >= 0 && !l && u.splice(c, 1), t.value = u;
+      } else {
+        const u = t.value.includes(e);
+        if (s.mandatory && u || !u && !l)
+          return;
+        t.value = l ?? !u ? [e] : [];
+      }
+  }
+  function f(e) {
+    if (s.multiple && W('This method is not supported when using "multiple" prop'), t.value.length) {
+      const l = t.value[0], r = n.findIndex((a) => a.id === l);
+      let u = (r + e) % n.length, c = n[u];
+      for (; c.disabled && u !== r; )
+        u = (u + e) % n.length, c = n[u];
+      if (c.disabled)
+        return;
+      t.value = [n[u].id];
+    } else {
+      const l = n.find((r) => !r.disabled);
+      l && (t.value = [l.id]);
+    }
+  }
+  const I = {
+    register: m,
+    unregister: p,
+    selected: t,
+    select: v,
+    disabled: x(() => s.disabled),
+    prev: () => f(n.length - 1),
+    next: () => f(1),
+    isSelected: (e) => t.value.includes(e),
+    selectedClass: x(() => s.selectedClass),
+    items: x(() => n),
+    getItemIndex: (e) => L(n, e)
+  };
+  return b(o, I), I;
+}
+function L(s, o) {
+  const d = S(s, [o]);
+  return d.length ? s.findIndex((n) => n.id === d[0]) : -1;
+}
+function S(s, o) {
+  const d = [];
+  return o.forEach((n) => {
+    const t = s.find((m) => $(n, m.value)), i = s[n];
+    (t == null ? void 0 : t.value) !== void 0 ? d.push(t.id) : i != null && i.useIndexAsValue && d.push(i.id);
+  }), d;
+}
+function N(s, o) {
+  const d = [];
+  return o.forEach((n) => {
+    const t = s.findIndex((i) => i.id === n);
+    if (~t) {
+      const i = s[t];
+      d.push(i.value !== void 0 ? i.value : t);
+    }
+  }), d;
+}
+export {
+  X as makeGroupItemProps,
+  Q as makeGroupProps,
+  Z as useGroup,
+  Y as useGroupItem
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/hydration.mjs

@@ -0,0 +1,20 @@
+import { useDisplay as t } from "./display.mjs";
+import { shallowRef as r, onMounted as s } from "vue";
+import { IN_BROWSER as n } from "../util/globals.mjs";
+function l() {
+  if (!n)
+    return r(!1);
+  const {
+    ssr: o
+  } = t();
+  if (o) {
+    const e = r(!1);
+    return s(() => {
+      e.value = !0;
+    }), e;
+  } else
+    return r(!0);
+}
+export {
+  l as useHydration
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/iconSizes.mjs

@@ -0,0 +1,21 @@
+import { computed as c } from "vue";
+import { propsFactory as t } from "../util/propsFactory.mjs";
+const S = t({
+  iconSize: [Number, String],
+  iconSizes: {
+    type: Array,
+    default: () => [["x-small", 10], ["small", 16], ["default", 24], ["large", 28], ["x-large", 32]]
+  }
+}, "iconSize");
+function z(i, n) {
+  return {
+    iconSize: c(() => {
+      const o = new Map(i.iconSizes), e = i.iconSize ?? n() ?? "default";
+      return o.has(e) ? o.get(e) : e;
+    })
+  };
+}
+export {
+  S as makeIconSizeProps,
+  z as useIconSizes
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/icons.mjs

@@ -1,82 +1,115 @@
-import { createVNode as r, mergeProps as u, createElementVNode as o, normalizeClass as s } from "vue";
-import { genericComponent as m, defineComponent as c } from "../util/defineComponent.mjs";
-import { propsFactory as g } from "../util/propsFactory.mjs";
-const p = [String, Function, Object, Array], l = g({
+import { createVNode as i, mergeProps as g, createElementVNode as c, normalizeClass as d, inject as y, computed as I, toValue as V } from "vue";
+import { genericComponent as S, defineComponent as l } from "../util/defineComponent.mjs";
+import { propsFactory as v } from "../util/propsFactory.mjs";
+import { consoleWarn as A } from "../util/console.mjs";
+const h = [String, Function, Object, Array], w = Symbol.for("vuetify:icons"), s = v({
   icon: {
-    type: p
+    type: h
   },
   // Could not remove this and use makeTagProps, types complained because it is not required
   tag: {
     type: [String, Object, Function],
     required: !0
   }
-}, "icon");
-m()({
+}, "icon"), m = S()({
   name: "VComponentIcon",
-  props: l(),
-  setup(n, a) {
+  props: s(),
+  setup(t, o) {
     let {
-      slots: t
-    } = a;
+      slots: r
+    } = o;
     return () => {
-      const e = n.icon;
-      return r(n.tag, null, {
+      const e = t.icon;
+      return i(t.tag, null, {
         default: () => {
-          var i;
-          return [n.icon ? r(e, null, null) : (i = t.default) == null ? void 0 : i.call(t)];
+          var n;
+          return [t.icon ? i(e, null, null) : (n = r.default) == null ? void 0 : n.call(r)];
         }
       });
     };
   }
-});
-const I = c({
+}), C = l({
   name: "VSvgIcon",
   inheritAttrs: !1,
-  props: l(),
-  setup(n, a) {
+  props: s(),
+  setup(t, o) {
     let {
-      attrs: t
-    } = a;
-    return () => r(n.tag, u(t, {
+      attrs: r
+    } = o;
+    return () => i(t.tag, g(r, {
       style: null
     }), {
-      default: () => [o("svg", {
+      default: () => [c("svg", {
         class: "v-icon__svg",
         xmlns: "http://www.w3.org/2000/svg",
         viewBox: "0 0 24 24",
         role: "img",
         "aria-hidden": "true"
-      }, [Array.isArray(n.icon) ? n.icon.map((e) => Array.isArray(e) ? o("path", {
+      }, [Array.isArray(t.icon) ? t.icon.map((e) => Array.isArray(e) ? c("path", {
         d: e[0],
         "fill-opacity": e[1]
-      }, null) : o("path", {
+      }, null) : c("path", {
         d: e
-      }, null)) : o("path", {
-        d: n.icon
+      }, null)) : c("path", {
+        d: t.icon
       }, null)])]
     });
   }
 });
-c({
+l({
   name: "VLigatureIcon",
-  props: l(),
-  setup(n) {
-    return () => r(n.tag, null, {
-      default: () => [n.icon]
+  props: s(),
+  setup(t) {
+    return () => i(t.tag, null, {
+      default: () => [t.icon]
     });
   }
 });
-c({
+l({
   name: "VClassIcon",
-  props: l(),
-  setup(n) {
-    return () => r(n.tag, {
-      class: s(n.icon)
+  props: s(),
+  setup(t) {
+    return () => i(t.tag, {
+      class: d(t.icon)
     }, null);
   }
 });
+const O = (t) => {
+  const o = y(w);
+  if (!o)
+    throw new Error("Missing Vuetify Icons provide!");
+  return {
+    iconData: I(() => {
+      var u;
+      const e = V(t);
+      if (!e)
+        return {
+          component: m
+        };
+      let n = e;
+      if (typeof n == "string" && (n = n.trim(), n.startsWith("$") && (n = (u = o.aliases) == null ? void 0 : u[n.slice(1)])), n || A(`Could not find aliased icon "${e}"`), Array.isArray(n))
+        return {
+          component: C,
+          icon: n
+        };
+      if (typeof n != "string")
+        return {
+          component: m,
+          icon: n
+        };
+      const a = Object.keys(o.sets).find((p) => typeof n == "string" && n.startsWith(`${p}:`)), f = a ? n.slice(a.length + 1) : n;
+      return {
+        component: o.sets[a ?? o.defaultSet].component,
+        icon: f
+      };
+    })
+  };
+};
 export {
-  p as IconValue,
-  I as VSvgIcon,
-  l as makeIconProps
+  w as IconSymbol,
+  h as IconValue,
+  m as VComponentIcon,
+  C as VSvgIcon,
+  s as makeIconProps,
+  O as useIcon
 };

package/dist/bt-core/core/node_modules/vuetify/lib/composables/intersectionObserver.mjs

@@ -0,0 +1,24 @@
+import { ref as f, shallowRef as v, onScopeDispose as p, watch as I } from "vue";
+import { SUPPORTS_INTERSECTION as c } from "../util/globals.mjs";
+function O(o, i) {
+  const t = f(), r = v(!1);
+  if (c) {
+    const s = new IntersectionObserver((e) => {
+      o == null || o(e, s), r.value = !!e.find((n) => n.isIntersecting);
+    }, i);
+    p(() => {
+      s.disconnect();
+    }), I(t, (e, n) => {
+      n && (s.unobserve(n), r.value = !1), e && s.observe(e);
+    }, {
+      flush: "post"
+    });
+  }
+  return {
+    intersectionRef: t,
+    isIntersecting: r
+  };
+}
+export {
+  O as useIntersectionObserver
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/lazy.mjs

@@ -0,0 +1,21 @@
+import { shallowRef as n, toRef as f, watch as l } from "vue";
+import { propsFactory as s } from "../util/propsFactory.mjs";
+const i = s({
+  eager: Boolean
+}, "lazy");
+function m(o, a) {
+  const e = n(!1), t = f(() => e.value || o.eager || a.value);
+  l(a, () => e.value = !0);
+  function r() {
+    o.eager || (e.value = !1);
+  }
+  return {
+    isBooted: e,
+    hasContent: t,
+    onAfterLeave: r
+  };
+}
+export {
+  i as makeLazyProps,
+  m as useLazy
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/list-items.mjs

@@ -0,0 +1,33 @@
+import "vue";
+import { propsFactory as t } from "../util/propsFactory.mjs";
+const o = t({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  itemTitle: {
+    type: [String, Array, Function],
+    default: "title"
+  },
+  itemValue: {
+    type: [String, Array, Function],
+    default: "value"
+  },
+  itemChildren: {
+    type: [Boolean, String, Array, Function],
+    default: "children"
+  },
+  itemProps: {
+    type: [Boolean, String, Array, Function],
+    default: "props"
+  },
+  itemType: {
+    type: [Boolean, String, Array, Function],
+    default: "type"
+  },
+  returnObject: Boolean,
+  valueComparator: Function
+}, "list-items");
+export {
+  o as makeItemsProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/loader.mjs

@@ -0,0 +1,38 @@
+import { toRef as a, createElementVNode as n, normalizeClass as l, createVNode as i } from "vue";
+import { VProgressLinear as m } from "../components/VProgressLinear/VProgressLinear.mjs";
+import { propsFactory as c } from "../util/propsFactory.mjs";
+import { getCurrentInstanceName as d } from "../util/getCurrentInstance.mjs";
+const v = c({
+  loading: [Boolean, String]
+}, "loader");
+function C(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : d();
+  return {
+    loaderClasses: a(() => ({
+      [`${t}--loading`]: e.loading
+    }))
+  };
+}
+function L(e, t) {
+  var r;
+  let {
+    slots: o
+  } = t;
+  return n("div", {
+    class: l(`${e.name}__loader`)
+  }, [((r = o.default) == null ? void 0 : r.call(o, {
+    color: e.color,
+    isActive: e.active
+  })) || i(m, {
+    absolute: e.absolute,
+    active: e.active,
+    color: e.color,
+    height: "2",
+    indeterminate: !0
+  }, null)]);
+}
+export {
+  L as LoaderSlot,
+  v as makeLoaderProps,
+  C as useLoader
+};