bt-core-app 2.2.3 → 2.2.5

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

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

@@ -0,0 +1,102 @@
+import { toRaw as o } from "vue";
+import { wrapInArray as u } from "../../util/helpers.mjs";
+const l = (s) => {
+  const a = {
+    activate: (i) => {
+      let {
+        id: r,
+        value: e,
+        activated: t
+      } = i;
+      return r = o(r), s && !e && t.size === 1 && t.has(r) || (e ? t.add(r) : t.delete(r)), t;
+    },
+    in: (i, r, e) => {
+      let t = /* @__PURE__ */ new Set();
+      if (i != null)
+        for (const n of u(i))
+          t = a.activate({
+            id: n,
+            value: !0,
+            activated: new Set(t),
+            children: r,
+            parents: e
+          });
+      return t;
+    },
+    out: (i) => Array.from(i)
+  };
+  return a;
+}, d = (s) => {
+  const a = l(s);
+  return {
+    activate: (r) => {
+      let {
+        activated: e,
+        id: t,
+        ...n
+      } = r;
+      t = o(t);
+      const c = e.has(t) ? /* @__PURE__ */ new Set([t]) : /* @__PURE__ */ new Set();
+      return a.activate({
+        ...n,
+        id: t,
+        activated: c
+      });
+    },
+    in: (r, e, t) => {
+      let n = /* @__PURE__ */ new Set();
+      if (r != null) {
+        const c = u(r);
+        c.length && (n = a.in(c.slice(0, 1), e, t));
+      }
+      return n;
+    },
+    out: (r, e, t) => a.out(r, e, t)
+  };
+}, y = (s) => {
+  const a = l(s);
+  return {
+    activate: (r) => {
+      let {
+        id: e,
+        activated: t,
+        children: n,
+        ...c
+      } = r;
+      return e = o(e), n.has(e) ? t : a.activate({
+        id: e,
+        activated: t,
+        children: n,
+        ...c
+      });
+    },
+    in: a.in,
+    out: a.out
+  };
+}, S = (s) => {
+  const a = d(s);
+  return {
+    activate: (r) => {
+      let {
+        id: e,
+        activated: t,
+        children: n,
+        ...c
+      } = r;
+      return e = o(e), n.has(e) ? t : a.activate({
+        id: e,
+        activated: t,
+        children: n,
+        ...c
+      });
+    },
+    in: a.in,
+    out: a.out
+  };
+};
+export {
+  l as independentActiveStrategy,
+  d as independentSingleActiveStrategy,
+  y as leafActiveStrategy,
+  S as leafSingleActiveStrategy
+};

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

@@ -0,0 +1,315 @@
+import { useProxiedModel as G } from "../proxiedModel.mjs";
+import { shallowRef as b, ref as s, computed as v, onBeforeUnmount as E, watch as x, toValue as m, toRaw as j, toRef as R, provide as U, nextTick as F, inject as I, onBeforeMount as H } from "vue";
+import { independentSingleActiveStrategy as J, independentActiveStrategy as K, leafSingleActiveStrategy as Q, leafActiveStrategy as W } from "./activeStrategies.mjs";
+import { multipleOpenStrategy as X, singleOpenStrategy as Y, listOpenStrategy as Z } from "./openStrategies.mjs";
+import { classicSelectStrategy as ee, branchSelectStrategy as te, trunkSelectStrategy as ae, independentSingleSelectStrategy as ne, independentSelectStrategy as le, leafSelectStrategy as re, leafSingleSelectStrategy as oe } from "./selectStrategies.mjs";
+import { throttle as ce } from "../../util/throttle.mjs";
+import { propsFactory as ie } from "../../util/propsFactory.mjs";
+import { getCurrentInstance as ue } from "../../util/getCurrentInstance.mjs";
+import { consoleError as se } from "../../util/console.mjs";
+const A = Symbol.for("vuetify:nested"), L = {
+  id: b(),
+  root: {
+    itemsRegistration: s("render"),
+    register: () => null,
+    unregister: () => null,
+    updateDisabled: () => null,
+    children: s(/* @__PURE__ */ new Map()),
+    parents: s(/* @__PURE__ */ new Map()),
+    disabled: s(/* @__PURE__ */ new Set()),
+    open: () => null,
+    openOnSelect: () => null,
+    activate: () => null,
+    select: () => null,
+    activatable: s(!1),
+    scrollToActive: s(!1),
+    selectable: s(!1),
+    opened: s(/* @__PURE__ */ new Set()),
+    activated: s(/* @__PURE__ */ new Set()),
+    selected: s(/* @__PURE__ */ new Map()),
+    selectedValues: s([]),
+    getPath: () => []
+  }
+}, we = ie({
+  activatable: Boolean,
+  selectable: Boolean,
+  activeStrategy: [String, Function, Object],
+  selectStrategy: [String, Function, Object],
+  openStrategy: [String, Object],
+  opened: null,
+  activated: null,
+  selected: null,
+  mandatory: Boolean,
+  itemsRegistration: {
+    type: String,
+    default: "render"
+  }
+}, "nested"), be = (t, h) => {
+  let {
+    items: S,
+    returnObject: l,
+    scrollToActive: k
+  } = h, i = !1;
+  const c = b(/* @__PURE__ */ new Map()), n = b(/* @__PURE__ */ new Map()), u = b(/* @__PURE__ */ new Set()), p = G(t, "opened", t.opened, (e) => new Set(Array.isArray(e) ? e.map((a) => j(a)) : e), (e) => [...e.values()]), V = v(() => {
+    if (typeof t.activeStrategy == "object")
+      return t.activeStrategy;
+    if (typeof t.activeStrategy == "function")
+      return t.activeStrategy(t.mandatory);
+    switch (t.activeStrategy) {
+      case "leaf":
+        return W(t.mandatory);
+      case "single-leaf":
+        return Q(t.mandatory);
+      case "independent":
+        return K(t.mandatory);
+      case "single-independent":
+      default:
+        return J(t.mandatory);
+    }
+  }), N = v(() => {
+    if (typeof t.selectStrategy == "object")
+      return t.selectStrategy;
+    if (typeof t.selectStrategy == "function")
+      return t.selectStrategy(t.mandatory);
+    switch (t.selectStrategy) {
+      case "single-leaf":
+        return oe(t.mandatory);
+      case "leaf":
+        return re(t.mandatory);
+      case "independent":
+        return le(t.mandatory);
+      case "single-independent":
+        return ne(t.mandatory);
+      case "trunk":
+        return ae(t.mandatory);
+      case "branch":
+        return te(t.mandatory);
+      case "classic":
+      default:
+        return ee(t.mandatory);
+    }
+  }), _ = v(() => {
+    if (typeof t.openStrategy == "object")
+      return t.openStrategy;
+    switch (t.openStrategy) {
+      case "list":
+        return Z;
+      case "single":
+        return Y;
+      case "multiple":
+      default:
+        return X;
+    }
+  }), g = G(t, "activated", t.activated, (e) => V.value.in(e, c.value, n.value), (e) => V.value.out(e, c.value, n.value)), w = G(t, "selected", t.selected, (e) => N.value.in(e, c.value, n.value, u.value), (e) => N.value.out(e, c.value, n.value));
+  E(() => {
+    i = !0;
+  });
+  function y(e) {
+    const a = [];
+    let r = j(e);
+    for (; r !== void 0; )
+      a.unshift(r), r = n.value.get(r);
+    return a;
+  }
+  const P = ue("nested"), T = /* @__PURE__ */ new Set(), z = ce(() => {
+    F(() => {
+      c.value = new Map(c.value), n.value = new Map(n.value);
+    });
+  }, 100);
+  x(() => [S.value, m(l)], () => {
+    t.itemsRegistration === "props" && q();
+  }, {
+    immediate: !0
+  });
+  function q() {
+    const e = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), o = m(l) ? (f) => j(f.raw) : (f) => f.value, d = [...S.value];
+    let O = 0;
+    for (; O < d.length; ) {
+      const f = d[O++], B = o(f);
+      if (f.children) {
+        const D = [];
+        for (const $ of f.children) {
+          const C = o($);
+          e.set(C, B), D.push(C), d.push($);
+        }
+        a.set(B, D);
+      }
+      f.props.disabled && r.add(B);
+    }
+    c.value = a, n.value = e, u.value = r;
+  }
+  const M = {
+    id: b(),
+    root: {
+      opened: p,
+      activatable: R(() => t.activatable),
+      scrollToActive: R(() => m(k)),
+      selectable: R(() => t.selectable),
+      activated: g,
+      selected: w,
+      selectedValues: v(() => {
+        const e = [];
+        for (const [a, r] of w.value.entries())
+          r === "on" && e.push(a);
+        return e;
+      }),
+      itemsRegistration: R(() => t.itemsRegistration),
+      register: (e, a, r, o) => {
+        if (T.has(e)) {
+          const d = y(e).map(String).join(" -> "), O = y(a).concat(e).map(String).join(" -> ");
+          se(`Multiple nodes with the same ID
+	${d}
+	${O}`);
+          return;
+        } else
+          T.add(e);
+        a && e !== a && n.value.set(e, a), r && u.value.add(e), o && c.value.set(e, []), a != null && c.value.set(a, [...c.value.get(a) || [], e]), z();
+      },
+      unregister: (e) => {
+        if (i)
+          return;
+        T.delete(e), c.value.delete(e), u.value.delete(e);
+        const a = n.value.get(e);
+        if (a) {
+          const r = c.value.get(a) ?? [];
+          c.value.set(a, r.filter((o) => o !== e));
+        }
+        n.value.delete(e), z();
+      },
+      updateDisabled: (e, a) => {
+        a ? u.value.add(e) : u.value.delete(e);
+      },
+      open: (e, a, r) => {
+        P.emit("click:open", {
+          id: e,
+          value: a,
+          path: y(e),
+          event: r
+        });
+        const o = _.value.open({
+          id: e,
+          value: a,
+          opened: new Set(p.value),
+          children: c.value,
+          parents: n.value,
+          event: r
+        });
+        o && (p.value = o);
+      },
+      openOnSelect: (e, a, r) => {
+        const o = _.value.select({
+          id: e,
+          value: a,
+          selected: new Map(w.value),
+          opened: new Set(p.value),
+          children: c.value,
+          parents: n.value,
+          event: r
+        });
+        o && (p.value = o);
+      },
+      select: (e, a, r) => {
+        P.emit("click:select", {
+          id: e,
+          value: a,
+          path: y(e),
+          event: r
+        });
+        const o = N.value.select({
+          id: e,
+          value: a,
+          selected: new Map(w.value),
+          children: c.value,
+          parents: n.value,
+          disabled: u.value,
+          event: r
+        });
+        o && (w.value = o), M.root.openOnSelect(e, a, r);
+      },
+      activate: (e, a, r) => {
+        if (!t.activatable)
+          return M.root.select(e, !0, r);
+        P.emit("click:activate", {
+          id: e,
+          value: a,
+          path: y(e),
+          event: r
+        });
+        const o = V.value.activate({
+          id: e,
+          value: a,
+          activated: new Set(g.value),
+          children: c.value,
+          parents: n.value,
+          event: r
+        });
+        if (o.size !== g.value.size)
+          g.value = o;
+        else {
+          for (const d of o)
+            if (!g.value.has(d)) {
+              g.value = o;
+              return;
+            }
+          for (const d of g.value)
+            if (!o.has(d)) {
+              g.value = o;
+              return;
+            }
+        }
+      },
+      children: c,
+      parents: n,
+      disabled: u,
+      getPath: y
+    }
+  };
+  return U(A, M), M.root;
+}, Ae = (t, h, S) => {
+  const l = I(A, L), k = Symbol("nested item"), i = v(() => {
+    const n = j(m(t));
+    return n !== void 0 ? n : k;
+  }), c = {
+    ...l,
+    id: i,
+    open: (n, u) => l.root.open(i.value, n, u),
+    openOnSelect: (n, u) => l.root.openOnSelect(i.value, n, u),
+    isOpen: v(() => l.root.opened.value.has(i.value)),
+    parent: v(() => l.root.parents.value.get(i.value)),
+    activate: (n, u) => l.root.activate(i.value, n, u),
+    isActivated: v(() => l.root.activated.value.has(i.value)),
+    scrollToActive: l.root.scrollToActive,
+    select: (n, u) => l.root.select(i.value, n, u),
+    isSelected: v(() => l.root.selected.value.get(i.value) === "on"),
+    isIndeterminate: v(() => l.root.selected.value.get(i.value) === "indeterminate"),
+    isLeaf: v(() => !l.root.children.value.get(i.value)),
+    isGroupActivator: l.isGroupActivator
+  };
+  return H(() => {
+    l.isGroupActivator || l.root.itemsRegistration.value === "props" || F(() => {
+      l.root.register(i.value, l.id.value, m(h), S);
+    });
+  }), E(() => {
+    l.isGroupActivator || l.root.itemsRegistration.value === "props" || l.root.unregister(i.value);
+  }), x(i, (n, u) => {
+    l.isGroupActivator || l.root.itemsRegistration.value === "props" || (l.root.unregister(u), F(() => {
+      l.root.register(n, l.id.value, m(h), S);
+    }));
+  }), x(() => m(h), (n) => {
+    l.root.updateDisabled(i.value, n);
+  }), S && U(A, c), c;
+}, Me = () => {
+  const t = I(A, L);
+  U(A, {
+    ...t,
+    isGroupActivator: !0
+  });
+};
+export {
+  A as VNestedSymbol,
+  L as emptyNested,
+  we as makeNestedProps,
+  be as useNested,
+  Me as useNestedGroupActivator,
+  Ae as useNestedItem
+};

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

@@ -0,0 +1,60 @@
+const s = {
+  open: (p) => {
+    let {
+      id: t,
+      value: a,
+      opened: n,
+      parents: r
+    } = p;
+    if (a) {
+      const e = /* @__PURE__ */ new Set();
+      e.add(t);
+      let l = r.get(t);
+      for (; l != null; )
+        e.add(l), l = r.get(l);
+      return e;
+    } else
+      return n.delete(t), n;
+  },
+  select: () => null
+}, d = {
+  open: (p) => {
+    let {
+      id: t,
+      value: a,
+      opened: n,
+      parents: r
+    } = p;
+    if (a) {
+      let e = r.get(t);
+      for (n.add(t); e != null && e !== t; )
+        n.add(e), e = r.get(e);
+      return n;
+    } else
+      n.delete(t);
+    return n;
+  },
+  select: () => null
+}, u = {
+  open: d.open,
+  select: (p) => {
+    let {
+      id: t,
+      value: a,
+      opened: n,
+      parents: r
+    } = p;
+    if (!a)
+      return n;
+    const e = [];
+    let l = r.get(t);
+    for (; l != null; )
+      e.push(l), l = r.get(l);
+    return new Set(e);
+  }
+};
+export {
+  u as listOpenStrategy,
+  d as multipleOpenStrategy,
+  s as singleOpenStrategy
+};