@cgi-learning-hub/ui 1.4.0-dev.1742208889 → 1.4.0-dev.1742217009

package/dist/CustomTreeItem-PTf-e74x.js

@@ -0,0 +1,1003 @@
+import { jsx as x, jsxs as W } from "react/jsx-runtime";
+import { c as X } from "./createSvgIcon-B62eln-G.js";
+import { B as Pe } from "./Box-GMNejc_m.js";
+import { _ as u } from "./ButtonBase-CU1npQuI.js";
+import * as E from "react";
+import { w as Re } from "./warning-C8W811fV.js";
+import { u as le } from "./useForkRef-C_4o__cU.js";
+import { e as S, r as de } from "./resolveComponentProps-CIdMNno4.js";
+import { treeContentStyle as Ee, arrowContainerStyle as Oe, expandedGroupStyle as Se } from "./components/TreeView/style.es.js";
+import { getIconComponent as De } from "./components/TreeView/utils.es.js";
+import { n as B, P as y, G as ke, H as Me, I as Le } from "./generateUtilityClasses-EXBFO7eY.js";
+import { a as ue } from "./TransitionGroupContext-DbLioz_6.js";
+import { u as Ne } from "./useThemeProps-v-SfXuGn.js";
+import { s as k, f as Y, c as Ve } from "./DefaultPropsProvider-CQixa6JQ.js";
+import { C as Ae } from "./Collapse-CcMCOZ3q.js";
+import { C as Be } from "./Checkbox-CtRSDqOe.js";
+import { u as Ke } from "./unsupportedProp-BuVD30Gh.js";
+import { u as D } from "./useSlotProps-U2Iu6E0j.js";
+const $e = X(/* @__PURE__ */ x("path", {
+  d: "M7.41 8.59 12 13.17l4.59-4.58L18 10l-6 6-6-6z"
+}), "KeyboardArrowDown"), Fe = X(/* @__PURE__ */ x("path", {
+  d: "M8.59 16.59 13.17 12 8.59 7.41 10 6l6 6-6 6z"
+}), "KeyboardArrowRight");
+function je(e) {
+  return Ne;
+}
+let ce = 0;
+const kt = () => (ce += 1, `mui-tree-view-${ce}`), qe = ({
+  id: e,
+  treeId: o = "",
+  itemId: t
+}) => e ?? `${o}-${t}`, be = /* @__PURE__ */ E.createContext(null);
+process.env.NODE_ENV !== "production" && (be.displayName = "TreeViewContext");
+const K = () => {
+  const e = E.useContext(be);
+  if (e == null)
+    throw new Error(["MUI X: Could not find the Tree View context.", "It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.", "This can also happen if you are bundling multiple versions of the Tree View."].join(`
+`));
+  return e;
+}, ge = /* @__PURE__ */ E.createContext(() => -1);
+process.env.NODE_ENV !== "production" && (ge.displayName = "TreeViewItemDepthContext");
+const me = (e, o) => {
+  let t = o.length - 1;
+  for (; t >= 0 && !e.isItemNavigable(o[t]); )
+    t -= 1;
+  if (t !== -1)
+    return o[t];
+}, ze = (e, o) => {
+  const t = e.getItemMeta(o), i = e.getItemOrderedChildrenIds(t.parentId), p = e.getItemIndex(o);
+  if (p === 0)
+    return t.parentId;
+  let l = p - 1;
+  for (; !e.isItemNavigable(i[l]) && l >= 0; )
+    l -= 1;
+  if (l === -1)
+    return t.parentId == null ? null : ze(e, t.parentId);
+  let b = i[l], s = me(e, e.getItemOrderedChildrenIds(b));
+  for (; e.isItemExpanded(b) && s != null; )
+    b = s, s = e.getItemOrderedChildrenIds(b).find(e.isItemNavigable);
+  return b;
+}, _e = (e, o) => {
+  if (e.isItemExpanded(o)) {
+    const i = e.getItemOrderedChildrenIds(o).find(e.isItemNavigable);
+    if (i != null)
+      return i;
+  }
+  let t = e.getItemMeta(o);
+  for (; t != null; ) {
+    const i = e.getItemOrderedChildrenIds(t.parentId), p = e.getItemIndex(t.id);
+    if (p < i.length - 1) {
+      let l = p + 1;
+      for (; !e.isItemNavigable(i[l]) && l < i.length - 1; )
+        l += 1;
+      if (e.isItemNavigable(i[l]))
+        return i[l];
+    }
+    t = e.getItemMeta(t.parentId);
+  }
+  return null;
+}, Mt = (e) => {
+  let o = null;
+  for (; o == null || e.isItemExpanded(o); ) {
+    const t = e.getItemOrderedChildrenIds(o), i = me(e, t);
+    if (i == null)
+      return o;
+    o = i;
+  }
+  return o;
+}, Ue = (e) => e.getItemOrderedChildrenIds(null).find(e.isItemNavigable), Ge = (e, o, t) => {
+  if (o === t)
+    return [o, t];
+  const i = e.getItemMeta(o), p = e.getItemMeta(t);
+  if (i.parentId === p.id || p.parentId === i.id)
+    return p.parentId === i.id ? [i.id, p.id] : [p.id, i.id];
+  const l = [i.id], b = [p.id];
+  let s = i.parentId, g = p.parentId, c = b.indexOf(s) !== -1, I = l.indexOf(g) !== -1, m = !0, h = !0;
+  for (; !I && !c; )
+    m && (l.push(s), c = b.indexOf(s) !== -1, m = s !== null, !c && m && (s = e.getItemMeta(s).parentId)), h && !c && (b.push(g), I = l.indexOf(g) !== -1, h = g !== null, !I && h && (g = e.getItemMeta(g).parentId));
+  const r = c ? s : g, f = e.getItemOrderedChildrenIds(r), R = l[l.indexOf(r) - 1], V = b[b.indexOf(r) - 1];
+  return f.indexOf(R) < f.indexOf(V) ? [o, t] : [t, o];
+}, Lt = (e, o, t) => {
+  const i = (g) => {
+    if (e.isItemExpandable(g) && e.isItemExpanded(g))
+      return e.getItemOrderedChildrenIds(g)[0];
+    let c = e.getItemMeta(g);
+    for (; c != null; ) {
+      const I = e.getItemOrderedChildrenIds(c.parentId), m = e.getItemIndex(c.id);
+      if (m < I.length - 1)
+        return I[m + 1];
+      c = e.getItemMeta(c.parentId);
+    }
+    throw new Error("Invalid range");
+  }, [p, l] = Ge(e, o, t), b = [p];
+  let s = p;
+  for (; s !== l; )
+    s = i(s), e.isItemDisabled(s) || b.push(s);
+  return b;
+}, Nt = (e) => {
+  let o = Ue(e);
+  const t = [];
+  for (; o != null; )
+    t.push(o), o = _e(e, o);
+  return t;
+}, pe = (e, o) => o !== e.closest('*[role="treeitem"]'), ne = (e, o) => e.getAvailablePlugins().has(o), We = ({
+  props: e
+}) => {
+  const {
+    instance: o
+  } = K(), {
+    label: t,
+    itemId: i
+  } = e, [p, l] = E.useState(t), b = o.isItemBeingEdited(i);
+  return E.useEffect(() => {
+    b || l(t);
+  }, [b, t]), {
+    propsEnhancers: {
+      labelInput: ({
+        externalEventHandlers: s,
+        interactions: g
+      }) => o.isItemEditable(i) ? {
+        value: p ?? "",
+        "data-element": "labelInput",
+        onChange: (r) => {
+          var f;
+          (f = s.onChange) == null || f.call(s, r), l(r.target.value);
+        },
+        onKeyDown: (r) => {
+          var R;
+          if ((R = s.onKeyDown) == null || R.call(s, r), r.defaultMuiPrevented)
+            return;
+          const f = r.target;
+          r.key === "Enter" && f.value ? g.handleSaveItemLabel(r, f.value) : r.key === "Escape" && g.handleCancelItemLabelEditing(r);
+        },
+        onBlur: (r) => {
+          var f;
+          (f = s.onBlur) == null || f.call(s, r), !r.defaultMuiPrevented && r.target.value && g.handleSaveItemLabel(r, r.target.value);
+        },
+        autoFocus: !0,
+        type: "text"
+      } : {}
+    }
+  };
+}, M = ({
+  instance: e,
+  state: o,
+  setState: t,
+  params: i
+}) => {
+  const p = E.useRef(o.editedItemId), l = (m) => p.current === m, b = (m) => {
+    t((h) => u({}, h, {
+      editedItemId: m
+    })), p.current = m;
+  }, s = (m) => m === o.editedItemId, g = !!i.isItemEditable, c = (m) => {
+    if (m == null || !g)
+      return !1;
+    const h = e.getItem(m);
+    return h ? typeof i.isItemEditable == "function" ? i.isItemEditable(h) : !!i.isItemEditable : !1;
+  }, I = (m, h) => {
+    if (!h)
+      throw new Error(["MUI X: The Tree View component requires all items to have a `label` property.", "The label of an item cannot be empty.", m].join(`
+`));
+    t((r) => {
+      const f = r.items.itemMetaMap[m];
+      return f.label !== h ? u({}, r, {
+        items: u({}, r.items, {
+          itemMetaMap: u({}, r.items.itemMetaMap, {
+            [m]: u({}, f, {
+              label: h
+            })
+          })
+        })
+      }) : r;
+    }), i.onItemLabelChange && i.onItemLabelChange(m, h);
+  };
+  return {
+    instance: {
+      setEditedItemId: b,
+      isItemBeingEdited: s,
+      updateItemLabel: I,
+      isItemEditable: c,
+      isTreeViewEditable: g,
+      isItemBeingEditedRef: l
+    },
+    publicAPI: {
+      updateItemLabel: I
+    }
+  };
+};
+M.itemPlugin = We;
+M.getDefaultizedParams = ({
+  params: e,
+  experimentalFeatures: o
+}) => {
+  const t = o == null ? void 0 : o.labelEditing;
+  return process.env.NODE_ENV !== "production" && e.isItemEditable && !t && Re(["MUI X: The label editing feature requires the `labelEditing` experimental feature to be enabled.", "You can do it by passing `experimentalFeatures={{ labelEditing: true}}` to the Rich Tree View Pro component.", "Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/editing/"]), u({}, e, {
+    isItemEditable: t ? e.isItemEditable ?? !1 : !1
+  });
+};
+M.getInitialState = () => ({
+  editedItemId: null
+});
+M.params = {
+  onItemLabelChange: !0,
+  isItemEditable: !0
+};
+const Xe = k("div", {
+  name: "MuiTreeItem2DragAndDropOverlay",
+  slot: "Root",
+  overridesResolver: (e, o) => o.root,
+  shouldForwardProp: (e) => Y(e) && e !== "action"
+})(({
+  theme: e
+}) => ({
+  position: "absolute",
+  left: 0,
+  display: "flex",
+  top: 0,
+  bottom: 0,
+  right: 0,
+  pointerEvents: "none",
+  variants: [{
+    props: {
+      action: "make-child"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderRadius: e.shape.borderRadius,
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.darkChannel} / ${e.vars.palette.action.focusOpacity})` : B(e.palette.primary.dark, e.palette.action.focusOpacity)
+    }
+  }, {
+    props: {
+      action: "reorder-above"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderTop: `1px solid ${(e.vars || e).palette.action.active}`
+    }
+  }, {
+    props: {
+      action: "reorder-below"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderBottom: `1px solid ${(e.vars || e).palette.action.active}`
+    }
+  }, {
+    props: {
+      action: "move-to-parent"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * calc(var(--TreeView-itemDepth) - 1))",
+      borderBottom: `1px solid ${(e.vars || e).palette.action.active}`
+    }
+  }]
+}));
+function Ie(e) {
+  return e.action == null ? null : /* @__PURE__ */ x(Xe, u({}, e));
+}
+process.env.NODE_ENV !== "production" && (Ie.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  action: y.oneOf(["make-child", "move-to-parent", "reorder-above", "reorder-below"]),
+  style: y.object
+});
+const Ye = k("input", {
+  name: "MuiTreeItem2",
+  slot: "LabelInput",
+  overridesResolver: (e, o) => o.labelInput
+})(({
+  theme: e
+}) => u({}, e.typography.body1, {
+  width: "100%",
+  backgroundColor: e.palette.background.paper,
+  borderRadius: e.shape.borderRadius,
+  border: "none",
+  padding: "0 2px",
+  boxSizing: "border-box",
+  "&:focus": {
+    outline: `1px solid ${e.palette.primary.main}`
+  }
+}));
+function Je(e) {
+  return Me("MuiTreeItem", e);
+}
+const Vt = ke("MuiTreeItem", ["root", "groupTransition", "content", "expanded", "selected", "focused", "disabled", "iconContainer", "label", "checkbox", "labelInput", "editable", "editing", "dragAndDropOverlay"]), Qe = X(/* @__PURE__ */ x("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), "TreeViewExpandIcon"), Ze = X(/* @__PURE__ */ x("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "TreeViewCollapseIcon");
+function re(e) {
+  const {
+    children: o,
+    itemId: t
+  } = e, {
+    wrapItem: i,
+    instance: p
+  } = K();
+  return i({
+    children: o,
+    itemId: t,
+    instance: p
+  });
+}
+re.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  children: y.node,
+  itemId: y.string.isRequired
+};
+const fe = (e) => Array.isArray(e) ? e.length > 0 && e.some(fe) : !!e, He = ({
+  itemId: e,
+  children: o
+}) => {
+  const {
+    instance: t,
+    selection: {
+      multiSelect: i
+    },
+    publicAPI: p
+  } = K(), l = {
+    expandable: fe(o),
+    expanded: t.isItemExpanded(e),
+    focused: t.isItemFocused(e),
+    selected: t.isItemSelected(e),
+    disabled: t.isItemDisabled(e),
+    editing: t != null && t.isItemBeingEdited ? t == null ? void 0 : t.isItemBeingEdited(e) : !1,
+    editable: t.isItemEditable ? t.isItemEditable(e) : !1
+  }, b = (r) => {
+    if (l.disabled)
+      return;
+    l.focused || t.focusItem(r, e);
+    const f = i && (r.shiftKey || r.ctrlKey || r.metaKey);
+    l.expandable && !(f && t.isItemExpanded(e)) && t.toggleItemExpansion(r, e);
+  }, s = (r) => {
+    if (l.disabled)
+      return;
+    l.focused || t.focusItem(r, e), i && (r.shiftKey || r.ctrlKey || r.metaKey) ? r.shiftKey ? t.expandSelectionRange(r, e) : t.selectItem({
+      event: r,
+      itemId: e,
+      keepExistingSelection: !0
+    }) : t.selectItem({
+      event: r,
+      itemId: e,
+      shouldBeSelected: !0
+    });
+  }, g = (r) => {
+    const f = r.nativeEvent.shiftKey;
+    i && f ? t.expandSelectionRange(r, e) : t.selectItem({
+      event: r,
+      itemId: e,
+      keepExistingSelection: i,
+      shouldBeSelected: r.target.checked
+    });
+  }, c = () => {
+    ne(t, M) && t.isItemEditable(e) && (t.isItemBeingEdited(e) ? t.setEditedItemId(null) : t.setEditedItemId(e));
+  };
+  return {
+    interactions: {
+      handleExpansion: b,
+      handleSelection: s,
+      handleCheckboxSelection: g,
+      toggleItemEditing: c,
+      handleSaveItemLabel: (r, f) => {
+        ne(t, M) && t.isItemBeingEditedRef(e) && (t.updateItemLabel(e, f), c(), t.focusItem(r, e));
+      },
+      handleCancelItemLabelEditing: (r) => {
+        ne(t, M) && t.isItemBeingEditedRef(e) && (c(), t.focusItem(r, e));
+      }
+    },
+    status: l,
+    publicAPI: p
+  };
+}, et = (e) => {
+  const {
+    runItemPlugins: o,
+    items: {
+      onItemClick: t,
+      disabledItemsFocusable: i,
+      indentationAtItemLevel: p
+    },
+    selection: {
+      disableSelection: l,
+      checkboxSelection: b
+    },
+    expansion: {
+      expansionTrigger: s
+    },
+    treeId: g,
+    instance: c,
+    publicAPI: I
+  } = K(), m = E.useContext(ge), {
+    id: h,
+    itemId: r,
+    label: f,
+    children: R,
+    rootRef: V
+  } = e, {
+    rootRef: J,
+    contentRef: Q,
+    propsEnhancers: P
+  } = o(e), {
+    interactions: w,
+    status: T
+  } = He({
+    itemId: r,
+    children: R
+  }), v = E.useRef(null), L = E.useRef(null), $ = le(V, J, v), F = le(Q, L), j = E.useRef(null), q = qe({
+    itemId: r,
+    treeId: g,
+    id: h
+  }), Z = c.canItemBeTabbed(r) ? 0 : -1, N = {
+    rootRefObject: v,
+    contentRefObject: L,
+    interactions: w
+  }, H = (a) => (n) => {
+    var C;
+    if ((C = a.onFocus) == null || C.call(a, n), n.defaultMuiPrevented)
+      return;
+    const d = !T.disabled || i;
+    !T.focused && d && n.currentTarget === n.target && c.focusItem(n, r);
+  }, z = (a) => (n) => {
+    var C, O, A, ae, se;
+    if ((C = a.onBlur) == null || C.call(a, n), n.defaultMuiPrevented)
+      return;
+    const d = c.getItemDOMElement(r);
+    T.editing || // we can exit the editing state by clicking outside the input (within the Tree Item) or by pressing Enter or Escape -> we don't want to remove the focused item from the state in these cases
+    // we can also exit the editing state by clicking on the root itself -> want to remove the focused item from the state in this case
+    n.relatedTarget && pe(n.relatedTarget, d) && (n.target && ((A = (O = n.target) == null ? void 0 : O.dataset) == null ? void 0 : A.element) === "labelInput" && pe(n.target, d) || ((se = (ae = n.relatedTarget) == null ? void 0 : ae.dataset) == null ? void 0 : se.element) === "labelInput") || c.removeFocusedItem();
+  }, ee = (a) => (n) => {
+    var d, C, O;
+    (d = a.onKeyDown) == null || d.call(a, n), !(n.defaultMuiPrevented || ((O = (C = n.target) == null ? void 0 : C.dataset) == null ? void 0 : O.element) === "labelInput") && c.handleItemKeyDown(n, r);
+  }, _ = (a) => (n) => {
+    var d;
+    (d = a.onDoubleClick) == null || d.call(a, n), !n.defaultMuiPrevented && w.toggleItemEditing();
+  }, te = (a) => (n) => {
+    var d, C;
+    (d = a.onClick) == null || d.call(a, n), t == null || t(n, r), !(n.defaultMuiPrevented || (C = j.current) != null && C.contains(n.target)) && (s === "content" && w.handleExpansion(n), b || w.handleSelection(n));
+  }, U = (a) => (n) => {
+    var d;
+    (d = a.onMouseDown) == null || d.call(a, n), !n.defaultMuiPrevented && (n.shiftKey || n.ctrlKey || n.metaKey || T.disabled) && n.preventDefault();
+  }, oe = (a) => (n) => {
+    var d;
+    (d = a.onChange) == null || d.call(a, n), !n.defaultMuiPrevented && (l || T.disabled || w.handleCheckboxSelection(n));
+  }, G = (a) => (n) => {
+    var d;
+    (d = a.onClick) == null || d.call(a, n), !n.defaultMuiPrevented && s === "iconContainer" && w.handleExpansion(n);
+  };
+  return {
+    getRootProps: (a = {}) => {
+      var A;
+      const n = u({}, S(e), S(a));
+      let d;
+      T.selected ? d = !0 : l || T.disabled ? d = void 0 : d = !1;
+      const C = u({}, n, {
+        ref: $,
+        role: "treeitem",
+        tabIndex: Z,
+        id: q,
+        "aria-expanded": T.expandable ? T.expanded : void 0,
+        "aria-selected": d,
+        "aria-disabled": T.disabled || void 0
+      }, a, {
+        onFocus: H(n),
+        onBlur: z(n),
+        onKeyDown: ee(n)
+      });
+      p && (C.style = {
+        "--TreeView-itemDepth": typeof m == "function" ? m(r) : m
+      });
+      const O = ((A = P.root) == null ? void 0 : A.call(P, u({}, N, {
+        externalEventHandlers: n
+      }))) ?? {};
+      return u({}, C, O);
+    },
+    getContentProps: (a = {}) => {
+      var O;
+      const n = S(a), d = u({}, n, a, {
+        ref: F,
+        onClick: te(n),
+        onMouseDown: U(n),
+        status: T
+      });
+      p && (d.indentationAtItemLevel = !0);
+      const C = ((O = P.content) == null ? void 0 : O.call(P, u({}, N, {
+        externalEventHandlers: n
+      }))) ?? {};
+      return u({}, d, C);
+    },
+    getGroupTransitionProps: (a = {}) => {
+      const n = S(a), d = u({}, n, {
+        unmountOnExit: !0,
+        component: "ul",
+        role: "group",
+        in: T.expanded,
+        children: R
+      }, a);
+      return p && (d.indentationAtItemLevel = !0), d;
+    },
+    getIconContainerProps: (a = {}) => {
+      const n = S(a);
+      return u({}, n, a, {
+        onClick: G(n)
+      });
+    },
+    getCheckboxProps: (a = {}) => {
+      const n = S(a);
+      return u({}, n, {
+        visible: b,
+        ref: j,
+        checked: T.selected,
+        disabled: l || T.disabled,
+        tabIndex: -1
+      }, a, {
+        onChange: oe(n)
+      });
+    },
+    getLabelProps: (a = {}) => {
+      const n = u({}, S(a)), d = u({}, n, {
+        children: f
+      }, a, {
+        onDoubleClick: _(n)
+      });
+      return c.isTreeViewEditable && (d.editable = T.editable), d;
+    },
+    getLabelInputProps: (a = {}) => {
+      var C;
+      const n = S(a), d = ((C = P.labelInput) == null ? void 0 : C.call(P, {
+        rootRefObject: v,
+        contentRefObject: L,
+        externalEventHandlers: n,
+        interactions: w
+      })) ?? {};
+      return u({}, a, d);
+    },
+    getDragAndDropOverlayProps: (a = {}) => {
+      var C;
+      const n = S(a), d = ((C = P.dragAndDropOverlay) == null ? void 0 : C.call(P, u({}, N, {
+        externalEventHandlers: n
+      }))) ?? {};
+      return u({}, a, d);
+    },
+    rootRef: $,
+    status: T,
+    publicAPI: I
+  };
+}, ye = et;
+function xe(e) {
+  const {
+    slots: o,
+    slotProps: t,
+    status: i
+  } = e, p = K(), l = u({}, p.icons.slots, {
+    expandIcon: p.icons.slots.expandIcon ?? Qe,
+    collapseIcon: p.icons.slots.collapseIcon ?? Ze
+  }), b = p.icons.slotProps;
+  let s;
+  o != null && o.icon ? s = "icon" : i.expandable ? i.expanded ? s = "collapseIcon" : s = "expandIcon" : s = "endIcon";
+  const g = (o == null ? void 0 : o[s]) ?? l[s], c = D({
+    elementType: g,
+    externalSlotProps: (I) => u({}, de(b[s], I), de(t == null ? void 0 : t[s], I)),
+    // TODO: Add proper ownerState
+    ownerState: {}
+  });
+  return g ? /* @__PURE__ */ x(g, u({}, c)) : null;
+}
+process.env.NODE_ENV !== "production" && (xe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: y.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: y.object,
+  status: y.shape({
+    disabled: y.bool.isRequired,
+    editable: y.bool.isRequired,
+    editing: y.bool.isRequired,
+    expandable: y.bool.isRequired,
+    expanded: y.bool.isRequired,
+    focused: y.bool.isRequired,
+    selected: y.bool.isRequired
+  }).isRequired
+});
+const tt = ["visible"], ot = ["id", "itemId", "label", "disabled", "children", "slots", "slotProps"], nt = je(), Ce = k("li", {
+  name: "MuiTreeItem2",
+  slot: "Root",
+  overridesResolver: (e, o) => o.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), he = k("div", {
+  name: "MuiTreeItem2",
+  slot: "Content",
+  overridesResolver: (e, o) => o.content,
+  shouldForwardProp: (e) => Y(e) && e !== "status" && e !== "indentationAtItemLevel"
+})(({
+  theme: e
+}) => ({
+  padding: e.spacing(0.5, 1),
+  borderRadius: e.shape.borderRadius,
+  width: "100%",
+  boxSizing: "border-box",
+  // prevent width + padding to overflow
+  position: "relative",
+  display: "flex",
+  alignItems: "center",
+  gap: e.spacing(1),
+  cursor: "pointer",
+  WebkitTapHighlightColor: "transparent",
+  "&:hover": {
+    backgroundColor: (e.vars || e).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: `calc(${e.spacing(1)} + var(--TreeView-itemChildrenIndentation) * var(--TreeView-itemDepth))`
+    }
+  }, {
+    props: ({
+      status: o
+    }) => o.disabled,
+    style: {
+      opacity: (e.vars || e).palette.action.disabledOpacity,
+      backgroundColor: "transparent"
+    }
+  }, {
+    props: ({
+      status: o
+    }) => o.focused,
+    style: {
+      backgroundColor: (e.vars || e).palette.action.focus
+    }
+  }, {
+    props: ({
+      status: o
+    }) => o.selected,
+    style: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : B(e.palette.primary.main, e.palette.action.selectedOpacity),
+      "&:hover": {
+        backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.hoverOpacity}))` : B(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.hoverOpacity),
+        // Reset on touch devices, it doesn't add specificity
+        "@media (hover: none)": {
+          backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : B(e.palette.primary.main, e.palette.action.selectedOpacity)
+        }
+      }
+    }
+  }, {
+    props: ({
+      status: o
+    }) => o.selected && o.focused,
+    style: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.focusOpacity}))` : B(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.focusOpacity)
+    }
+  }]
+})), Te = k("div", {
+  name: "MuiTreeItem2",
+  slot: "Label",
+  overridesResolver: (e, o) => o.label,
+  shouldForwardProp: (e) => Y(e) && e !== "editable"
+})(({
+  theme: e
+}) => u({
+  width: "100%",
+  boxSizing: "border-box",
+  // prevent width + padding to overflow
+  // fixes overflow - see https://github.com/mui/material-ui/issues/27372
+  minWidth: 0,
+  position: "relative",
+  overflow: "hidden"
+}, e.typography.body1, {
+  variants: [{
+    props: ({
+      editable: o
+    }) => o,
+    style: {
+      paddingLeft: "2px"
+    }
+  }]
+})), ve = k("div", {
+  name: "MuiTreeItem2",
+  slot: "IconContainer",
+  overridesResolver: (e, o) => o.iconContainer
+})({
+  width: 16,
+  display: "flex",
+  flexShrink: 0,
+  justifyContent: "center",
+  "& svg": {
+    fontSize: 18
+  }
+}), we = k(Ae, {
+  name: "MuiTreeItem2",
+  slot: "GroupTransition",
+  overridesResolver: (e, o) => o.groupTransition,
+  shouldForwardProp: (e) => Y(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), rt = k(/* @__PURE__ */ E.forwardRef((e, o) => {
+  const {
+    visible: t
+  } = e, i = ue(e, tt);
+  return t ? /* @__PURE__ */ x(Be, u({}, i, {
+    ref: o
+  })) : null;
+}), {
+  name: "MuiTreeItem2",
+  slot: "Checkbox",
+  overridesResolver: (e, o) => o.checkbox
+})({
+  padding: 0
+}), it = (e) => {
+  const {
+    classes: o
+  } = e;
+  return Ve({
+    root: ["root"],
+    content: ["content"],
+    expanded: ["expanded"],
+    editing: ["editing"],
+    editable: ["editable"],
+    selected: ["selected"],
+    focused: ["focused"],
+    disabled: ["disabled"],
+    iconContainer: ["iconContainer"],
+    checkbox: ["checkbox"],
+    label: ["label"],
+    groupTransition: ["groupTransition"],
+    labelInput: ["labelInput"],
+    dragAndDropOverlay: ["dragAndDropOverlay"]
+  }, Je, o);
+}, at = /* @__PURE__ */ E.forwardRef(function(o, t) {
+  const i = nt({
+    props: o,
+    name: "MuiTreeItem2"
+  }), {
+    id: p,
+    itemId: l,
+    label: b,
+    disabled: s,
+    children: g,
+    slots: c = {},
+    slotProps: I = {}
+  } = i, m = ue(i, ot), {
+    getRootProps: h,
+    getContentProps: r,
+    getIconContainerProps: f,
+    getCheckboxProps: R,
+    getLabelProps: V,
+    getGroupTransitionProps: J,
+    getLabelInputProps: Q,
+    getDragAndDropOverlayProps: P,
+    status: w
+  } = ye({
+    id: p,
+    itemId: l,
+    children: g,
+    label: b,
+    disabled: s
+  }), T = u({}, i, w), v = it(T), L = c.root ?? Ce, $ = D({
+    elementType: L,
+    getSlotProps: h,
+    externalForwardedProps: m,
+    externalSlotProps: I.root,
+    additionalProps: {
+      ref: t
+    },
+    ownerState: {},
+    className: v.root
+  }), F = c.content ?? he, j = D({
+    elementType: F,
+    getSlotProps: r,
+    externalSlotProps: I.content,
+    ownerState: {},
+    className: Le(v.content, w.expanded && v.expanded, w.selected && v.selected, w.focused && v.focused, w.disabled && v.disabled, w.editing && v.editing, w.editable && v.editable)
+  }), q = c.iconContainer ?? ve, Z = D({
+    elementType: q,
+    getSlotProps: f,
+    externalSlotProps: I.iconContainer,
+    ownerState: {},
+    className: v.iconContainer
+  }), N = c.label ?? Te, H = D({
+    elementType: N,
+    getSlotProps: V,
+    externalSlotProps: I.label,
+    ownerState: {},
+    className: v.label
+  }), z = c.checkbox ?? rt, ee = D({
+    elementType: z,
+    getSlotProps: R,
+    externalSlotProps: I.checkbox,
+    ownerState: {},
+    className: v.checkbox
+  }), _ = c.groupTransition ?? void 0, te = D({
+    elementType: _,
+    getSlotProps: J,
+    externalSlotProps: I.groupTransition,
+    ownerState: {},
+    className: v.groupTransition
+  }), U = c.labelInput ?? Ye, oe = D({
+    elementType: U,
+    getSlotProps: Q,
+    externalSlotProps: I.labelInput,
+    ownerState: {},
+    className: v.labelInput
+  }), G = c.dragAndDropOverlay ?? Ie, ie = D({
+    elementType: G,
+    getSlotProps: P,
+    externalSlotProps: I.dragAndDropOverlay,
+    ownerState: {},
+    className: v.dragAndDropOverlay
+  });
+  return /* @__PURE__ */ x(re, {
+    itemId: l,
+    children: /* @__PURE__ */ W(L, u({}, $, {
+      children: [/* @__PURE__ */ W(F, u({}, j, {
+        children: [/* @__PURE__ */ x(q, u({}, Z, {
+          children: /* @__PURE__ */ x(xe, {
+            status: w,
+            slots: c,
+            slotProps: I
+          })
+        })), /* @__PURE__ */ x(z, u({}, ee)), w.editing ? /* @__PURE__ */ x(U, u({}, oe)) : /* @__PURE__ */ x(N, u({}, H)), /* @__PURE__ */ x(G, u({}, ie))]
+      })), g && /* @__PURE__ */ x(we, u({
+        as: _
+      }, te))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (at.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: y.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: y.object,
+  className: y.string,
+  /**
+   * If `true`, the item is disabled.
+   * @default false
+   */
+  disabled: y.bool,
+  /**
+   * The id attribute of the item. If not provided, it will be generated.
+   */
+  id: y.string,
+  /**
+   * The id of the item.
+   * Must be unique.
+   */
+  itemId: y.string.isRequired,
+  /**
+   * The label of the item.
+   */
+  label: y.node,
+  /**
+   * Callback fired when the item root is blurred.
+   */
+  onBlur: y.func,
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor an item's focus.
+   */
+  onFocus: Ke,
+  /**
+   * Callback fired when a key is pressed on the keyboard and the tree is in focus.
+   */
+  onKeyDown: y.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: y.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: y.object
+});
+function At(e) {
+  const {
+    id: o,
+    itemId: t,
+    label: i,
+    disabled: p,
+    children: l,
+    itemData: b,
+    iconColor: s = "primary",
+    ref: g
+  } = e, c = De(
+    b == null ? void 0 : b.iconType,
+    b == null ? void 0 : b.customIcon
+  ), {
+    getRootProps: I,
+    getContentProps: m,
+    getLabelProps: h,
+    getGroupTransitionProps: r,
+    getIconContainerProps: f,
+    status: R
+  } = ye({ id: o, itemId: t, label: i, disabled: p, children: l, rootRef: g });
+  return /* @__PURE__ */ x(re, { itemId: t, children: /* @__PURE__ */ W(
+    Ce,
+    {
+      ...I(),
+      "data-treeview-item": t || "",
+      "data-treeview-item-label": i || "",
+      children: [
+        /* @__PURE__ */ W(he, { ...m(), style: Ee, children: [
+          /* @__PURE__ */ x(ve, { ...f(), children: /* @__PURE__ */ x(c, { fontSize: "small", color: s }) }),
+          /* @__PURE__ */ x(Te, { ...h() }),
+          /* @__PURE__ */ x(Pe, { sx: Oe, children: R.expandable && (R.expanded ? /* @__PURE__ */ x($e, { fontSize: "small" }) : /* @__PURE__ */ x(Fe, { fontSize: "small" })) })
+        ] }),
+        l && /* @__PURE__ */ x(
+          we,
+          {
+            ...r(),
+            style: R.expanded ? Se : void 0
+          }
+        )
+      ]
+    }
+  ) });
+}
+export {
+  At as C,
+  be as T,
+  ge as a,
+  Mt as b,
+  kt as c,
+  Ue as d,
+  Nt as e,
+  Ge as f,
+  qe as g,
+  Lt as h,
+  pe as i,
+  _e as j,
+  ze as k,
+  ne as l,
+  K as m,
+  Ye as n,
+  Ie as o,
+  je as p,
+  Ze as q,
+  Qe as r,
+  re as s,
+  Je as t,
+  M as u,
+  Vt as v
+};