bt-core-app 2.2.10 → 2.2.11

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

@@ -0,0 +1,24 @@
+import { useId as p, computed as a, toRef as e, toValue as c } from "vue";
+import { propsFactory as s } from "../util/propsFactory.mjs";
+const f = s({
+  closeText: {
+    type: String,
+    default: "$vuetify.close"
+  },
+  openText: {
+    type: String,
+    default: "$vuetify.open"
+  }
+}, "autocomplete");
+function l(i, o) {
+  const n = p(), t = a(() => `menu-${n}`), r = e(() => c(o)), u = e(() => t.value);
+  return {
+    menuId: t,
+    ariaExpanded: r,
+    ariaControls: u
+  };
+}
+export {
+  f as makeMenuActivatorProps,
+  l as useMenuActivator
+};

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, inject as I, onBeforeMount as H, nextTick as F } 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
+};

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

@@ -0,0 +1,206 @@
+import { toRaw as u } from "vue";
+const S = (a) => {
+  const s = {
+    select: (c) => {
+      let {
+        id: t,
+        value: n,
+        selected: e
+      } = c;
+      if (t = u(t), a && !n) {
+        const r = Array.from(e.entries()).reduce((o, l) => {
+          let [d, y] = l;
+          return y === "on" && o.push(d), o;
+        }, []);
+        if (r.length === 1 && r[0] === t)
+          return e;
+      }
+      return e.set(t, n ? "on" : "off"), e;
+    },
+    in: (c, t, n, e) => {
+      const r = /* @__PURE__ */ new Map();
+      for (const o of c || [])
+        s.select({
+          id: o,
+          value: !0,
+          selected: r,
+          children: t,
+          parents: n,
+          disabled: e
+        });
+      return r;
+    },
+    out: (c) => {
+      const t = [];
+      for (const [n, e] of c.entries())
+        e === "on" && t.push(n);
+      return t;
+    }
+  };
+  return s;
+}, k = (a) => {
+  const s = S(a);
+  return {
+    select: (t) => {
+      let {
+        selected: n,
+        id: e,
+        ...r
+      } = t;
+      e = u(e);
+      const o = n.has(e) ? /* @__PURE__ */ new Map([[e, n.get(e)]]) : /* @__PURE__ */ new Map();
+      return s.select({
+        ...r,
+        id: e,
+        selected: o
+      });
+    },
+    in: (t, n, e, r) => t != null && t.length ? s.in(t.slice(0, 1), n, e, r) : /* @__PURE__ */ new Map(),
+    out: (t, n, e) => s.out(t, n, e)
+  };
+}, v = (a) => {
+  const s = S(a);
+  return {
+    select: (t) => {
+      let {
+        id: n,
+        selected: e,
+        children: r,
+        ...o
+      } = t;
+      return n = u(n), r.has(n) ? e : s.select({
+        id: n,
+        selected: e,
+        children: r,
+        ...o
+      });
+    },
+    in: s.in,
+    out: s.out
+  };
+}, b = (a) => {
+  const s = k(a);
+  return {
+    select: (t) => {
+      let {
+        id: n,
+        selected: e,
+        children: r,
+        ...o
+      } = t;
+      return n = u(n), r.has(n) ? e : s.select({
+        id: n,
+        selected: e,
+        children: r,
+        ...o
+      });
+    },
+    in: s.in,
+    out: s.out
+  };
+}, m = (a) => {
+  const s = {
+    select: (c) => {
+      let {
+        id: t,
+        value: n,
+        selected: e,
+        children: r,
+        parents: o,
+        disabled: l
+      } = c;
+      t = u(t);
+      const d = new Map(e), y = [t];
+      for (; y.length; ) {
+        const i = y.shift();
+        l.has(i) || e.set(u(i), n ? "on" : "off"), r.has(i) && y.push(...r.get(i));
+      }
+      let h = u(o.get(t));
+      for (; h; ) {
+        let i = !0, f = !0;
+        for (const p of r.get(h)) {
+          const g = u(p);
+          if (!l.has(g) && (e.get(g) !== "on" && (i = !1), e.has(g) && e.get(g) !== "off" && (f = !1), !i && !f))
+            break;
+        }
+        e.set(h, i ? "on" : f ? "off" : "indeterminate"), h = u(o.get(h));
+      }
+      return a && !n && Array.from(e.entries()).reduce((f, p) => {
+        let [g, w] = p;
+        return w === "on" && f.push(g), f;
+      }, []).length === 0 ? d : e;
+    },
+    in: (c, t, n) => {
+      let e = /* @__PURE__ */ new Map();
+      for (const r of c || [])
+        e = s.select({
+          id: r,
+          value: !0,
+          selected: e,
+          children: t,
+          parents: n,
+          disabled: /* @__PURE__ */ new Set()
+        });
+      return e;
+    },
+    out: (c, t) => {
+      const n = [];
+      for (const [e, r] of c.entries())
+        r === "on" && !t.has(e) && n.push(e);
+      return n;
+    }
+  };
+  return s;
+}, A = (a) => {
+  const s = m(a);
+  return {
+    select: s.select,
+    in: s.in,
+    out: (t, n, e) => {
+      const r = [];
+      for (const [o, l] of t.entries())
+        if (l === "on") {
+          if (e.has(o)) {
+            const d = e.get(o);
+            if (t.get(d) === "on")
+              continue;
+          }
+          r.push(o);
+        }
+      return r;
+    }
+  };
+}, x = (a) => {
+  const c = {
+    select: m(a).select,
+    in: (t, n, e, r) => {
+      let o = /* @__PURE__ */ new Map();
+      for (const l of t || [])
+        n.has(l) || (o = c.select({
+          id: l,
+          value: !0,
+          selected: o,
+          children: n,
+          parents: e,
+          disabled: r
+        }));
+      return o;
+    },
+    out: (t) => {
+      const n = [];
+      for (const [e, r] of t.entries())
+        (r === "on" || r === "indeterminate") && n.push(e);
+      return n;
+    }
+  };
+  return c;
+};
+export {
+  x as branchSelectStrategy,
+  m as classicSelectStrategy,
+  S as independentSelectStrategy,
+  k as independentSingleSelectStrategy,
+  v as leafSelectStrategy,
+  b as leafSingleSelectStrategy,
+  A as trunkSelectStrategy
+};