bt-core-app 2.2.4 → 2.2.6

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 { consoleWarn as v } from "../util/console.mjs";
+import { propsFactory as A } from "../util/propsFactory.mjs";
+const h = [String, Function, Object, Array], w = Symbol.for("vuetify:icons"), s = A({
   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 || v(`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/layout.mjs

@@ -0,0 +1,43 @@
+import { inject as i, useId as l, provide as n, shallowRef as m, onDeactivated as s, onActivated as c, computed as f, onBeforeUnmount as v } from "vue";
+import { getCurrentInstance as d } from "../util/getCurrentInstance.mjs";
+import { propsFactory as p } from "../util/propsFactory.mjs";
+const I = Symbol.for("vuetify:layout"), S = Symbol.for("vuetify:layout-item"), w = p({
+  name: {
+    type: String
+  },
+  order: {
+    type: [Number, String],
+    default: 0
+  },
+  absolute: Boolean
+}, "layout-item");
+function K(e) {
+  const t = i(I);
+  if (!t)
+    throw new Error("[Vuetify] Could not find injected layout");
+  const o = e.id ?? `layout-item-${l()}`, a = d("useLayoutItem");
+  n(S, {
+    id: o
+  });
+  const u = m(!1);
+  s(() => u.value = !0), c(() => u.value = !1);
+  const {
+    layoutItemStyles: r,
+    layoutItemScrimStyles: y
+  } = t.register(a, {
+    ...e,
+    active: f(() => u.value ? !1 : e.active.value),
+    id: o
+  });
+  return v(() => t.unregister(o)), {
+    layoutItemStyles: r,
+    layoutRect: t.layoutRect,
+    layoutItemScrimStyles: y
+  };
+}
+export {
+  S as VuetifyLayoutItemKey,
+  I as VuetifyLayoutKey,
+  w as makeLayoutItemProps,
+  K as useLayoutItem
+};

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,120 @@
+import { computed as A, shallowRef as _, watchEffect as S } from "vue";
+import { isPrimitive as T, getPropertyFromItem as d, omit as b, pick as C } from "../util/helpers.mjs";
+import { propsFactory as j } from "../util/propsFactory.mjs";
+import { deepEqual as k } from "../util/deepEqual.mjs";
+const N = j({
+  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"), O = /* @__PURE__ */ new Set(["item", "divider", "subheader"]);
+function f(t, e) {
+  const u = d(e, t.itemTitle, e), i = d(e, t.itemValue, u), s = d(e, t.itemChildren), v = t.itemProps === !0 ? typeof e == "object" && e != null && !Array.isArray(e) ? "children" in e ? b(e, ["children"]) : e : void 0 : d(e, t.itemProps);
+  let l = d(e, t.itemType, "item");
+  O.has(l) || (l = "item");
+  const n = {
+    title: u,
+    value: i,
+    ...v
+  };
+  return {
+    type: l,
+    title: String(n.title ?? ""),
+    value: n.value,
+    props: n,
+    children: l === "item" && Array.isArray(s) ? F(t, s) : void 0,
+    raw: e
+  };
+}
+f.neededProps = ["itemTitle", "itemValue", "itemChildren", "itemProps", "itemType"];
+function F(t, e) {
+  const u = C(t, f.neededProps), i = [];
+  for (const s of e)
+    i.push(f(u, s));
+  return i;
+}
+function q(t) {
+  const e = A(() => F(t, t.items)), u = A(() => e.value.some((n) => n.value === null)), i = _(/* @__PURE__ */ new Map()), s = _([]);
+  S(() => {
+    const n = e.value, r = /* @__PURE__ */ new Map(), o = [];
+    for (let p = 0; p < n.length; p++) {
+      const a = n[p];
+      if (T(a.value) || a.value === null) {
+        let c = r.get(a.value);
+        c || (c = [], r.set(a.value, c)), c.push(a);
+      } else
+        o.push(a);
+    }
+    i.value = r, s.value = o;
+  });
+  function v(n) {
+    const r = i.value, o = e.value, p = s.value, a = u.value, c = t.returnObject, h = !!t.valueComparator, w = t.valueComparator || k, I = C(t, f.neededProps), y = [];
+    e:
+      for (const m of n) {
+        if (!a && m === null)
+          continue;
+        if (c && typeof m == "string") {
+          y.push(f(I, m));
+          continue;
+        }
+        const g = r.get(m);
+        if (h || !g) {
+          for (const P of h ? o : p)
+            if (w(m, P.value)) {
+              y.push(P);
+              continue e;
+            }
+          y.push(f(I, m));
+          continue;
+        }
+        y.push(...g);
+      }
+    return y;
+  }
+  function l(n) {
+    return t.returnObject ? n.map((r) => {
+      let {
+        raw: o
+      } = r;
+      return o;
+    }) : n.map((r) => {
+      let {
+        value: o
+      } = r;
+      return o;
+    });
+  }
+  return {
+    items: e,
+    transformIn: v,
+    transformOut: l
+  };
+}
+export {
+  N as makeItemsProps,
+  f as transformItem,
+  F as transformItems,
+  q as useItems
+};

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

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

@@ -0,0 +1,22 @@
+import { inject as e } from "vue";
+const o = Symbol.for("vuetify:locale");
+function n() {
+  const t = e(o);
+  if (!t)
+    throw new Error("[Vuetify] Could not find injected locale instance");
+  return t;
+}
+function r() {
+  const t = e(o);
+  if (!t)
+    throw new Error("[Vuetify] Could not find injected rtl instance");
+  return {
+    isRtl: t.isRtl,
+    rtlClasses: t.rtlClasses
+  };
+}
+export {
+  o as LocaleSymbol,
+  n as useLocale,
+  r as useRtl
+};

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

@@ -0,0 +1,49 @@
+import { useRtl as f } from "./locale.mjs";
+import { computed as m } from "vue";
+import { parseAnchor as p } from "../util/anchor.mjs";
+import { propsFactory as u } from "../util/propsFactory.mjs";
+const i = {
+  center: "center",
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+}, x = u({
+  location: String
+}, "location");
+function S(o) {
+  let r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1, l = arguments.length > 2 ? arguments[2] : void 0;
+  const {
+    isRtl: s
+  } = f();
+  return {
+    locationStyles: m(() => {
+      if (!o.location)
+        return {};
+      const {
+        side: e,
+        align: n
+      } = p(o.location.split(" ").length > 1 ? o.location : `${o.location} center`, s.value);
+      function a(c) {
+        return l ? l(c) : 0;
+      }
+      const t = {};
+      return e !== "center" && (r ? t[i[e]] = `calc(100% - ${a(e)}px)` : t[e] = 0), n !== "center" ? r ? t[i[n]] = `calc(100% - ${a(n)}px)` : t[n] = 0 : (e === "center" ? t.top = t.left = "50%" : t[{
+        top: "left",
+        bottom: "left",
+        left: "top",
+        right: "top"
+      }[e]] = "50%", t.transform = {
+        top: "translateX(-50%)",
+        bottom: "translateX(-50%)",
+        left: "translateY(-50%)",
+        right: "translateY(-50%)",
+        center: "translate(-50%, -50%)"
+      }[e]), t;
+    })
+  };
+}
+export {
+  x as makeLocationProps,
+  S as useLocation
+};