linear-react-components-ui 1.1.25-rc.2 → 1.1.26-beta-1

package/lib/treeview/index.js

@@ -1,320 +1,185 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "TreeNode", {
-  enumerable: true,
-  get: function () {
-    return _Node.default;
-  }
-});
-Object.defineProperty(exports, "TreeViewHeader", {
-  enumerable: true,
-  get: function () {
-    return _Header.default;
-  }
-});
-exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _lodash = _interopRequireDefault(require("lodash"));
-var _Node = _interopRequireDefault(require("./Node"));
-var _Header = _interopRequireDefault(require("./Header"));
-require("../assets/styles/treeview.scss");
-var _constants = require("./constants");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-const TreeView = props => {
+import { j as g } from "../chunks/jsx-runtime.CYK1ROHF.js";
+import { useState as u, useEffect as q } from "react";
+import w from "lodash";
+import pe from "./Node.js";
+import { default as Oe } from "./Header.js";
+import { TreeviewContext as Se } from "./constants.js";
+import '../assets/index18.css';const qe = (h) => {
   const {
-    selectedIds = [],
-    enableDynamicData,
-    allowCheckAllAncestry,
-    onNodeOpen,
-    allowCheckAllChildren,
-    onSelectedIdsChange,
-    idsInLoading,
-    startNodesOpened = false,
-    alwaysShowArrow,
-    nodeElementsValidations,
-    nodeRightElements,
-    nodeMenuButtonSize = 'small',
-    nodeToolbarElements,
-    onNodeClick,
-    selectedNodeId,
-    customClass = '',
-    children,
-    styleForContainer,
-    bordered,
-    requiredIds: propsRequiredIds = [],
-    customClassForNodes = '',
-    customStyleForNodes
-  } = props;
-  const [data, setData] = (0, _react.useState)(props.data);
-  const [currentSelectedIds, setCurrentSelectedIds] = (0, _react.useState)(selectedIds);
-  const [propSelectedIds, setPropSelectedIds] = (0, _react.useState)(selectedIds);
-  const [isHandlingSelectedIds, setIsHandlingSelectedIds] = (0, _react.useState)(false);
-  const [selectedIdsUpdatedOnMount, setSelectedIdsUpdatedOnMount] = (0, _react.useState)(false);
-  const [requiredParentsIds, setRequiredParentsIds] = (0, _react.useState)([]);
-  const [alreadyOpenedIds, setAlreadyOpenedIds] = (0, _react.useState)([]);
-  const [idsWithChildren] = (0, _react.useState)({});
-  const returnChildrenIds = function (nodeId) {
-    let returnRequiredIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    let nodeChildrenIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    let requiredIds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-    if (idsWithChildren[nodeId] !== undefined) {
-      nodeChildrenIds.push(nodeId);
-      if (returnRequiredIds) requiredIds.push(nodeId);
-      idsWithChildren[nodeId].forEach(childId => returnChildrenIds(childId, returnRequiredIds, nodeChildrenIds, requiredIds));
-    } else nodeChildrenIds.push(nodeId);
-    return returnRequiredIds ? {
-      nodeChildrenIds,
-      requiredIds
-    } : {
-      nodeChildrenIds
-    };
-  };
-  const returnParentId = nodeId => {
-    const parentId = Object.keys(idsWithChildren).find(id => idsWithChildren[id].find(childId => childId === nodeId));
-    return Number(parentId);
-  };
-  const returnAllAncestryIds = function (nodeId) {
-    let ancestryIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    const parentId = returnParentId(nodeId);
-    if (parentId) {
-      const currentAncestryIds = [...ancestryIds, Number(parentId)];
-      return returnAllAncestryIds(Number(parentId), currentAncestryIds);
-    }
-    return ancestryIds;
-  };
-  const returnRequiredAncestryIds = function (nodeId) {
-    let requiredAncestryIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    let previousParentId = arguments.length > 2 ? arguments[2] : undefined;
-    let selectedSiblingsIds = [];
-    const parentId = returnParentId(nodeId);
-    if (parentId) {
-      const nodeSiblingsIds = idsWithChildren && idsWithChildren[parentId].filter(childId => childId !== nodeId);
-      const isPreviousParentSelected = previousParentId && currentSelectedIds.includes(previousParentId);
-      if (nodeSiblingsIds && nodeSiblingsIds.length > 0) {
-        selectedSiblingsIds = currentSelectedIds.filter(id => nodeSiblingsIds.includes(id));
-      }
-      const requiredIds = isPreviousParentSelected || selectedSiblingsIds.length > 0 ? [...requiredAncestryIds] : [...requiredAncestryIds, parentId];
-      if (selectedSiblingsIds.length === 0 && !isPreviousParentSelected) {
-        return returnRequiredAncestryIds(parentId, requiredIds, parentId);
-      }
-    }
-    return requiredAncestryIds;
-  };
-  const updateAncestryAndSelectedIds = (nodeId, codigos, requiredParents) => {
-    const ancestryIds = returnRequiredAncestryIds(nodeId);
-    const remainRequiredParentsIds = requiredParents.filter(id => !ancestryIds.includes(id));
-    const newSelectedIds = currentSelectedIds.filter(selectedId => !codigos.includes(selectedId));
-    setRequiredParentsIds(remainRequiredParentsIds);
-    return newSelectedIds;
-  };
-  const checkAllAncestry = function (nodeId, codigos) {
-    let returnRequiredParentsIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    let updateState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
-    const nodeAncestryIds = returnAllAncestryIds(nodeId);
-    const notRequiredAncestryIds = nodeAncestryIds.filter(id => !requiredParentsIds.includes(id));
-    const notSelectedAncestryIds = nodeAncestryIds.filter(id => !currentSelectedIds.includes(id));
-    const newSelectedIds = [...currentSelectedIds, ...codigos, ...notSelectedAncestryIds];
-    const newRequiredParentsIds = [...requiredParentsIds, ...notRequiredAncestryIds];
-    if (updateState) {
-      setRequiredParentsIds(newRequiredParentsIds);
+    selectedIds: f = [],
+    enableDynamicData: $,
+    allowCheckAllAncestry: I,
+    onNodeOpen: v,
+    allowCheckAllChildren: E,
+    onSelectedIdsChange: p,
+    idsInLoading: z,
+    startNodesOpened: B = !1,
+    alwaysShowArrow: L,
+    nodeElementsValidations: _,
+    nodeRightElements: G,
+    nodeMenuButtonSize: J = "small",
+    nodeToolbarElements: K,
+    onNodeClick: Q,
+    selectedNodeId: X,
+    customClass: Y = "",
+    children: Z,
+    styleForContainer: ee,
+    bordered: te,
+    requiredIds: se = [],
+    customClassForNodes: ne = "",
+    customStyleForNodes: re
+  } = h, [N, le] = u(h.data), [c, P] = u(f), [W, de] = u(f), [C, O] = u(!1), [R, ce] = u(!1), [m, S] = u([]), [b, ie] = u([]), [o] = u({}), y = (e, n = !1, t = [], r = []) => (o[e] !== void 0 ? (t.push(e), n && r.push(e), o[e].forEach((s) => y(s, n, t, r))) : t.push(e), n ? { nodeChildrenIds: t, requiredIds: r } : { nodeChildrenIds: t }), T = (e) => {
+    const n = Object.keys(o).find((t) => o[t].find((r) => r === e));
+    return Number(n);
+  }, U = (e, n = []) => {
+    const t = T(e);
+    if (t) {
+      const r = [...n, Number(t)];
+      return U(Number(t), r);
     }
-    return !returnRequiredParentsIds ? {
-      updatedIdsWithAncestryIds: newSelectedIds
-    } : {
-      updatedIdsWithAncestryIds: newSelectedIds,
-      requiredParentsIds: newRequiredParentsIds
-    };
-  };
-  const checkAllChildren = function (nodeId) {
-    let returnRequiredIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    let currentRequiredIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    let childrenIds;
-    let newRequiredParentsIds = currentRequiredIds;
-    if (returnRequiredIds) {
-      const {
-        nodeChildrenIds,
-        requiredIds
-      } = returnChildrenIds(nodeId, returnRequiredIds);
-      const newRequiredIds = requiredIds ? requiredIds.filter(id => !currentRequiredIds.includes(id)) : [];
-      newRequiredParentsIds = [...currentRequiredIds, ...newRequiredIds];
-      childrenIds = nodeChildrenIds;
-    } else childrenIds = returnChildrenIds(nodeId).nodeChildrenIds;
-    const notSelectedChildrenIds = childrenIds.filter(id => !currentSelectedIds.includes(id));
-    const newSelectedIds = [...currentSelectedIds, ...notSelectedChildrenIds];
-    setRequiredParentsIds(newRequiredParentsIds);
-    setIsHandlingSelectedIds(false);
-    return newSelectedIds;
-  };
-  const uncheckAllChildren = function (nodeId) {
-    let remainSelectedIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    let newSelectedIds = remainSelectedIds.length > 0 ? remainSelectedIds : currentSelectedIds;
-    const childrenIds = returnChildrenIds(nodeId).nodeChildrenIds;
-    newSelectedIds = newSelectedIds.filter(selectedId => !childrenIds.includes(selectedId));
-    setIsHandlingSelectedIds(false);
-    return newSelectedIds;
-  };
-  const uncheckRequiredChildren = (nodeId, codigos, requiredParents) => {
-    const childrenIds = returnChildrenIds(nodeId).nodeChildrenIds;
-    const remainRequiredIds = requiredParents.filter(id => !childrenIds.includes(id));
-    setRequiredParentsIds([...remainRequiredIds]);
-    updateAncestryAndSelectedIds(nodeId, codigos, remainRequiredIds);
-  };
-  const handleOnNodeOpen = node => {
-    const {
-      id
-    } = node;
-    let newAlreadyOpenedIds = alreadyOpenedIds;
-    if (!alreadyOpenedIds.includes(id) && onNodeOpen) {
-      newAlreadyOpenedIds = [...newAlreadyOpenedIds, id];
-      onNodeOpen(node);
+    return n;
+  }, V = (e, n = [], t) => {
+    let r = [];
+    const s = T(e);
+    if (s) {
+      const l = o && o[s].filter((a) => a !== e), d = t && c.includes(t);
+      l && l.length > 0 && (r = c.filter((a) => l.includes(a)));
+      const i = d || r.length > 0 ? [...n] : [...n, s];
+      if (r.length === 0 && !d)
+        return V(s, i, s);
     }
-    setAlreadyOpenedIds(newAlreadyOpenedIds);
-  };
-  const handleCheck = (nodeId, handlingSelectedIds, isParent) => {
-    const codigos = _lodash.default.isArray(nodeId) ? nodeId : [nodeId];
-    let newSelectedIds = [...currentSelectedIds, ...codigos];
-    if (isParent && (handlingSelectedIds || isHandlingSelectedIds) && allowCheckAllChildren) {
-      if (allowCheckAllAncestry) {
+    return n;
+  }, k = (e, n, t) => {
+    const r = V(e), s = t.filter((d) => !r.includes(d)), l = c.filter((d) => !n.includes(d));
+    return S(s), l;
+  }, x = (e, n, t = !1, r = !0) => {
+    const s = U(e), l = s.filter((A) => !m.includes(A)), d = s.filter((A) => !c.includes(A)), i = [...c, ...n, ...d], a = [...m, ...l];
+    return r && S(a), t ? { updatedIdsWithAncestryIds: i, requiredParentsIds: a } : { updatedIdsWithAncestryIds: i };
+  }, D = (e, n = !1, t = []) => {
+    let r, s = t;
+    if (n) {
+      const { nodeChildrenIds: i, requiredIds: a } = y(e, n), A = a ? a.filter((me) => !t.includes(me)) : [];
+      s = [...t, ...A], r = i;
+    } else r = y(e).nodeChildrenIds;
+    const l = r.filter((i) => !c.includes(i)), d = [...c, ...l];
+    return S(s), O(!1), d;
+  }, F = (e, n = []) => {
+    let t = n.length > 0 ? n : c;
+    const r = y(e).nodeChildrenIds;
+    return t = t.filter((s) => !r.includes(s)), O(!1), t;
+  }, ae = (e, n, t) => {
+    const r = y(e).nodeChildrenIds, s = t.filter((l) => !r.includes(l));
+    S([...s]), k(e, n, s);
+  }, oe = (e) => {
+    const { id: n } = e;
+    let t = b;
+    !b.includes(n) && v && (t = [...t, n], v(e)), ie(t);
+  }, ue = (e, n, t) => {
+    const r = w.isArray(e) ? e : [e];
+    let s = [...c, ...r];
+    if (t && (n || C) && E)
+      if (I) {
         const {
-          updatedIdsWithAncestryIds,
-          requiredParentsIds: requiredParents
-        } = checkAllAncestry(nodeId, codigos, true);
-        const updatedIdsWithChildrenIds = checkAllChildren(nodeId, true, requiredParents);
-        newSelectedIds = [...updatedIdsWithAncestryIds, ...updatedIdsWithChildrenIds];
-      } else newSelectedIds = checkAllChildren(nodeId);
-    } else if (allowCheckAllAncestry) {
-      newSelectedIds = checkAllAncestry(nodeId, codigos).updatedIdsWithAncestryIds;
+          updatedIdsWithAncestryIds: l,
+          requiredParentsIds: d
+        } = x(e, r, !0), i = D(e, !0, d);
+        s = [...l, ...i];
+      } else s = D(e);
+    else I && (s = x(e, r).updatedIdsWithAncestryIds);
+    return s;
+  }, fe = (e, n, t, r) => {
+    const s = w.isArray(e) ? e : [e];
+    let l = c.filter((d) => !s.includes(d));
+    if (t && (n || C) && E)
+      if (I) {
+        const d = k(
+          e,
+          s,
+          m
+        );
+        l = F(e, d), r && ae(e, s, m);
+      } else l = F(e);
+    else I && (l = k(e, s, m));
+    return l;
+  }, H = (e, n, t, r = !1, s = C) => {
+    let l = [...c];
+    n ? l = ue(e, s, t) : l = fe(e, s, t, r), P(l), p && p(l);
+  }, he = (e, n, t = !1) => {
+    O(!0), H(e, n, !0, t, !0);
+  }, j = (e, n, t) => {
+    let r = [];
+    if (e.itens && e.itens.length > 0 && (r = e.itens.map((s) => s.id), t)) {
+      const s = {};
+      s[e.id] = r, Object.assign(t, s);
     }
-    return newSelectedIds;
-  };
-  const handleUncheck = (nodeId, handlingSelectedIds, isParent, required) => {
-    const codigos = _lodash.default.isArray(nodeId) ? nodeId : [nodeId];
-    let newSelectedIds = currentSelectedIds.filter(id => !codigos.includes(id));
-    if (isParent && (handlingSelectedIds || isHandlingSelectedIds) && allowCheckAllChildren) {
-      if (allowCheckAllAncestry) {
-        const updatedSelectedIds = updateAncestryAndSelectedIds(nodeId, codigos, requiredParentsIds);
-        newSelectedIds = uncheckAllChildren(nodeId, updatedSelectedIds);
-        if (required) uncheckRequiredChildren(nodeId, codigos, requiredParentsIds);
-      } else newSelectedIds = uncheckAllChildren(nodeId);
-    } else if (allowCheckAllAncestry) {
-      newSelectedIds = updateAncestryAndSelectedIds(nodeId, codigos, requiredParentsIds);
-    }
-    return newSelectedIds;
-  };
-  const updateSelectedIds = function (nodeId, checked, isParent) {
-    let required = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    let handlingSelectedIds = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : isHandlingSelectedIds;
-    let newSelectedIds = [...currentSelectedIds];
-    if (checked) {
-      newSelectedIds = handleCheck(nodeId, handlingSelectedIds, isParent);
-    } else {
-      newSelectedIds = handleUncheck(nodeId, handlingSelectedIds, isParent, required);
-    }
-    setCurrentSelectedIds(newSelectedIds);
-    if (onSelectedIdsChange) onSelectedIdsChange(newSelectedIds);
-  };
-  const toggleCheckChildren = function (nodeId, check) {
-    let required = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    setIsHandlingSelectedIds(true);
-    updateSelectedIds(nodeId, check, true, required, true);
-  };
-  const buildTree = (node, parentId, ids) => {
-    let childrenIds = [];
-    if (node.itens && node.itens.length > 0) {
-      childrenIds = node.itens.map(i => i.id);
-      if (ids) {
-        const idWithChildren = {};
-        idWithChildren[node.id] = childrenIds;
-        Object.assign(ids, idWithChildren);
-      }
-    }
-    return /*#__PURE__*/_react.default.createElement(_Node.default, {
-      key: `node-${node.id}`,
-      node: node,
-      idsInLoading: idsInLoading,
-      startNodesOpened: startNodesOpened,
-      alwaysShowArrow: alwaysShowArrow,
-      childrenIds: childrenIds,
-      isParent: node.itens && node.itens.length > 0,
-      parentId: parentId,
-      nodeRightElements: nodeRightElements,
-      nodeToolbarElements: nodeToolbarElements,
-      nodeElementsValidations: nodeElementsValidations,
-      nodeMenuButtonSize: nodeMenuButtonSize,
-      onNodeClick: onNodeClick,
-      selectedNodeId: selectedNodeId,
-      handlerOnNodeOpen: handleOnNodeOpen,
-      customClass: customClassForNodes,
-      customStyle: customStyleForNodes
-    }, childrenIds.length > 0 && node.itens && node.itens.map(nodeitem => buildTree(nodeitem, node.id, idsWithChildren)));
-  };
-  const handleNewSelectedIds = selectedNodeIds => {
-    let requiredIds = [];
-    let newSelectedIds = [];
-    selectedNodeIds.forEach(id => {
+    return /* @__PURE__ */ g.jsx(
+      pe,
+      {
+        node: e,
+        idsInLoading: z,
+        startNodesOpened: B,
+        alwaysShowArrow: L,
+        childrenIds: r,
+        isParent: e.itens && e.itens.length > 0,
+        parentId: n,
+        nodeRightElements: G,
+        nodeToolbarElements: K,
+        nodeElementsValidations: _,
+        nodeMenuButtonSize: J,
+        onNodeClick: Q,
+        selectedNodeId: X,
+        handlerOnNodeOpen: oe,
+        customClass: ne,
+        customStyle: re,
+        children: r.length > 0 && e.itens && e.itens.map((s) => j(s, e.id, o))
+      },
+      `node-${e.id}`
+    );
+  }, M = (e) => {
+    let n = [], t = [];
+    e.forEach((r) => {
       const {
-        requiredParentsIds: requiredParents,
-        updatedIdsWithAncestryIds
-      } = checkAllAncestry(id, [], true, false);
-      newSelectedIds = [...newSelectedIds, ...updatedIdsWithAncestryIds];
-      if (requiredParents) {
-        requiredIds = [...requiredIds, ...requiredParents];
-      }
-    });
-    setRequiredParentsIds(_lodash.default.uniq(requiredIds));
-    setCurrentSelectedIds(_lodash.default.uniq(newSelectedIds));
-    setSelectedIdsUpdatedOnMount(prevState => prevState || true);
-  };
-  (0, _react.useEffect)(() => {
-    const isSameSelectedIds = _lodash.default.isEqual(propSelectedIds.sort(), selectedIds.sort());
-    if (enableDynamicData && props.data !== data) {
-      setData(props.data);
-    } else if (!isSameSelectedIds) {
-      setCurrentSelectedIds(selectedIds);
-      onSelectedIdsChange?.(selectedIds);
-      setPropSelectedIds(selectedIds);
-    }
-  }, [selectedIds.length, props.data]);
-  (0, _react.useEffect)(() => {
-    if (allowCheckAllAncestry && !selectedIdsUpdatedOnMount) {
-      handleNewSelectedIds(currentSelectedIds);
-    }
-  }, [currentSelectedIds]);
-  (0, _react.useEffect)(() => {
-    if (allowCheckAllAncestry) {
-      handleNewSelectedIds(currentSelectedIds);
-    }
-  }, [propSelectedIds]);
-  (0, _react.useEffect)(() => {
-    buildTree(data, undefined, idsWithChildren);
+        requiredParentsIds: s,
+        updatedIdsWithAncestryIds: l
+      } = x(r, [], !0, !1);
+      t = [...t, ...l], s && (n = [...n, ...s]);
+    }), S(w.uniq(n)), P(w.uniq(t)), ce((r) => r || !0);
+  };
+  q(() => {
+    const e = w.isEqual(W.sort(), f.sort());
+    $ && h.data !== N ? le(h.data) : e || (P(f), p == null || p(f), de(f));
+  }, [f.length, h.data]), q(() => {
+    I && !R && M(c);
+  }, [c]), q(() => {
+    I && M(c);
+  }, [W]), q(() => {
+    j(N, void 0, o);
   }, []);
-  const contextValues = _objectSpread(_objectSpread({}, props), {}, {
-    requiredIds: propsRequiredIds,
-    selectedIds: currentSelectedIds,
-    isHandlingSelectedIds,
-    selectedIdsUpdatedOnMount,
-    requiredParentsIds,
-    alreadyOpenedIds,
-    handlerUpdateSelectedIds: updateSelectedIds,
-    handlerToggleCheckChildren: toggleCheckChildren
-  });
-  return /*#__PURE__*/_react.default.createElement(_constants.TreeviewContext.Provider, {
-    value: contextValues
-  }, /*#__PURE__*/_react.default.createElement("div", {
-    className: `treeview-component ${customClass}`
-  }, children, /*#__PURE__*/_react.default.createElement("ul", {
-    style: styleForContainer,
-    className: `treeviewcontainer ${bordered && '-bordered'}`
-  }, buildTree(data))));
+  const Ie = {
+    ...h,
+    requiredIds: se,
+    selectedIds: c,
+    isHandlingSelectedIds: C,
+    selectedIdsUpdatedOnMount: R,
+    requiredParentsIds: m,
+    alreadyOpenedIds: b,
+    handlerUpdateSelectedIds: H,
+    handlerToggleCheckChildren: he
+  };
+  return /* @__PURE__ */ g.jsx(Se.Provider, { value: Ie, children: /* @__PURE__ */ g.jsxs("div", { className: `treeview-component ${Y}`, children: [
+    Z,
+    /* @__PURE__ */ g.jsx(
+      "ul",
+      {
+        style: ee,
+        className: `treeviewcontainer ${te && "-bordered"}`,
+        children: j(N)
+      }
+    )
+  ] }) });
+};
+export {
+  pe as TreeNode,
+  Oe as TreeViewHeader,
+  qe as default
 };
-var _default = exports.default = TreeView;

package/lib/treeview/types.d.ts

@@ -1,26 +1,25 @@
-import { ReactNode, CSSProperties, ReactElement } from 'react';
-import { Size } from '../@types/Size.js';
-
-type NodeItem<T = void> = T & {
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { Size } from '../@types/Size';
+export type NodeItem<T = void> = T & {
     id: number;
     itens?: NodeItem<T>[];
     statusEnum?: {
         id: number | string;
     };
 };
-interface IValidator<T = void> {
+export interface IValidator<T = void> {
     validator: (node: NodeItem<T>) => boolean;
     applyBehavior?: 'unvisible' | 'disabled';
 }
-interface INodeElementsValidations<T = void> {
+export interface INodeElementsValidations<T = void> {
     [key: string]: IValidator<T>[];
 }
-interface INodeValidationProps {
+export interface INodeValidationProps {
     validationKey: string | null;
     onNodeElementClick: (node: any) => void;
     visible: boolean;
 }
-interface ITreeviewProps {
+export interface ITreeviewProps {
     data: object;
     valuePropName: string;
     labelPropName: string;
@@ -50,7 +49,7 @@ interface ITreeviewProps {
     customClassForNodes?: string;
     customStyleForNodes?: CSSProperties;
 }
-interface ITreeNodeProps {
+export interface ITreeNodeProps {
     node: any;
     children: ReactNode;
     startNodesOpened: boolean;
@@ -70,12 +69,12 @@ interface ITreeNodeProps {
     customClass?: string;
     customStyle?: CSSProperties;
 }
-interface ITreeHeaderProps {
+export interface ITreeHeaderProps {
     title?: string;
     customClass?: string;
     children?: ReactNode;
 }
-interface ITreeViewContext extends ITreeviewProps {
+export interface ITreeViewContext extends ITreeviewProps {
     requiredIds: number[] | string[];
     selectedIds?: number[];
     isHandlingSelectedIds: boolean;
@@ -95,7 +94,7 @@ type ItensMock = {
     }[];
     itens: ItensMock[];
 };
-interface IDataMock {
+export interface IDataMock {
     id: number;
     titulo: string;
     codigo: string;
@@ -104,5 +103,4 @@ interface IDataMock {
     }[];
     itens: ItensMock[];
 }
-
-export { IDataMock, INodeElementsValidations, INodeValidationProps, ITreeHeaderProps, ITreeNodeProps, ITreeViewContext, ITreeviewProps, IValidator, NodeItem };
+export {};

package/lib/uitour/helpers.d.ts

@@ -4,5 +4,4 @@ declare const STEP_POSITIONS: {
     right: string;
     left: string;
 };
-
-export { ARROW_HEIGHT, ARROW_WIDTH, STEP_POSITIONS };
+export { ARROW_WIDTH, ARROW_HEIGHT, STEP_POSITIONS, };

package/lib/uitour/helpers.js

@@ -1,12 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.STEP_POSITIONS = exports.ARROW_WIDTH = exports.ARROW_HEIGHT = void 0;
-const ARROW_WIDTH = exports.ARROW_WIDTH = 26;
-const ARROW_HEIGHT = exports.ARROW_HEIGHT = 20;
-const STEP_POSITIONS = exports.STEP_POSITIONS = {
-  right: 'right',
-  left: 'left'
-};
+const t = 26, o = 20, I = {
+  right: "right",
+  left: "left"
+};
+export {
+  o as ARROW_HEIGHT,
+  t as ARROW_WIDTH,
+  I as STEP_POSITIONS
+};

package/lib/uitour/index.d.ts

@@ -1,7 +1,4 @@
-import React__default from 'react';
-import { IUITourProps } from './types.js';
-import './helpers.js';
-
-declare const UiTour: (props: IUITourProps) => React__default.ReactPortal | null;
-
-export { UiTour as default };
+import { default as React } from 'react';
+import { IUITourProps } from './types';
+declare const UiTour: (props: IUITourProps) => React.ReactPortal | null;
+export default UiTour;