@devtron-labs/devtron-fe-common-lib 1.4.3 → 1.4.5

package/dist/{@common-rjsf-C-eNkDr9.js → @common-rjsf-DfTsF2Ah.js}

@@ -1,8 +1,8 @@
-import { j as n, J as A } from "./@vendor-QI4m26H1.js";
+import { j as n, J as A } from "./@vendor-CwAQS8iU.js";
 import E, { forwardRef as $ } from "react";
 import L, { getDefaultRegistry as k } from "@rjsf/core";
 import D from "@rjsf/validator-ajv8";
-import { T as y, c as H, a as U, i as J, d as w } from "./@code-editor-CJzLZbk_.js";
+import { T as y, c as H, a as U, i as J, d as w } from "./@code-editor-DOrCsZCp.js";
 import M, { components as O } from "react-select";
 import { getUiOptions as B, getTemplate as I, getSubmitButtonOptions as W, ADDITIONAL_PROPERTY_FLAG as P, errorId as V, englishStringTranslator as q, TranslatableString as K, titleId as Y, canExpand as z, deepEquals as G } from "@rjsf/utils";
 import { ReactComponent as Q } from "./assets/ic-chevron-down.fc70d7a7.svg";

package/dist/{@framer-motion-BxQTtYmm.js → @framer-motion-CdgdF0KV.js}

@@ -1,4 +1,4 @@
-import { g as ct, l as m, o as I, p as Yr, q as we, r as T, t as at, v as zt, w as ae, x as Xe, y as J, z as kr, B as Qn, C as Xr, D as ti, E as ei, F as ri, G as ni, H as ii, I as Wr, K as ai, L as oi, M as si, N as ui, O as li, P as fi, S as ci, T as yt, U as k, V as pe, W as Zr, X as vi, Y as di, Z as W, $, a0 as pi, a1 as he, a2 as Dt, a3 as hi, a4 as mi, a5 as $r, a6 as Mt, a7 as O, a8 as me, a9 as gi, aa as oe, ab as yi } from "./@vendor-QI4m26H1.js";
+import { g as ct, l as m, o as I, p as Yr, q as we, r as T, t as at, v as zt, w as ae, x as Xe, y as J, z as kr, B as Qn, C as Xr, D as ti, E as ei, F as ri, G as ni, H as ii, I as Wr, K as ai, L as oi, M as si, N as ui, O as li, P as fi, S as ci, T as yt, U as k, V as pe, W as Zr, X as vi, Y as di, Z as W, $, a0 as pi, a1 as he, a2 as Dt, a3 as hi, a4 as mi, a5 as $r, a6 as Mt, a7 as O, a8 as me, a9 as gi, aa as oe, ab as yi } from "./@vendor-CwAQS8iU.js";
 import * as K from "react";
 import Ee, { createContext as bt, useContext as F, useLayoutEffect as Pi, useEffect as G, useState as qr, useRef as q, useCallback as ge, useMemo as It, forwardRef as bi, createElement as Vi, cloneElement as Ti, Children as Si, isValidElement as xi } from "react";
 var We = "production", Le = typeof process > "u" || process.env === void 0 ? We : process.env.NODE_ENV || We, Q = function(t) {

package/dist/{@react-dates-M_eJUVeH.js → @react-dates-CtQV2TLr.js}

@@ -1,5 +1,5 @@
 import Te from "react";
-import { ac as xe, ad as we, ae as ve, af as lr, ag as Le, ah as Je, ai as tt, aj as at, ak as et, al as lt, am as rt, an as Xn, ao as sr, ap as Jn, aq as bt, ar as Go, as as dr, at as eo, au as to, av as ao, aw as $o, ax as Yo, ay as ur, az as Fe, aA as Rt, aB as Uo, aC as cr, aD as Qo, aE as Cr, aF as Zo, aG as Xo, aH as Jo } from "./@vendor-QI4m26H1.js";
+import { ac as xe, ad as we, ae as ve, af as lr, ag as Le, ah as Je, ai as tt, aj as at, ak as et, al as lt, am as rt, an as Xn, ao as sr, ap as Jn, aq as bt, ar as Go, as as dr, at as eo, au as to, av as ao, aw as $o, ax as Yo, ay as ur, az as Fe, aA as Rt, aB as Uo, aC as cr, aD as Qo, aE as Cr, aF as Zo, aG as Xo, aH as Jo } from "./@vendor-CwAQS8iU.js";
 import { r as Ne, g as ei, h as ti } from "./@moment-C_WeV3Af.js";
 import './assets/@react-dates.css';var ro = {}, Wt = {}, jt = {}, Mr;
 function Ve() {

package/dist/{@react-select-CywptBlV.js → @react-select-Cn3OpC9h.js}

@@ -1,4 +1,4 @@
-import { aI as xt, aJ as Bt, aK as Ft, aL as v, aM as U, aN as xe, ay as re, aO as h, aG as f, aP as Y, aQ as Vt, aR as Ue, aS as Et, aT as yt, aU as Wt, aV as Xt, aW as Zt, aX as ne } from "./@vendor-QI4m26H1.js";
+import { aI as xt, aJ as Bt, aK as Ft, aL as v, aM as U, aN as xe, ay as re, aO as h, aG as f, aP as Y, aQ as Vt, aR as Ue, aS as Et, aT as yt, aU as Wt, aV as Xt, aW as Zt, aX as ne } from "./@vendor-CwAQS8iU.js";
 import * as y from "react";
 import { useContext as Nt, useRef as j, useState as ee, createContext as St, useMemo as q, useCallback as D, Component as Rt, Fragment as Be, useEffect as Qe, forwardRef as Ht } from "react";
 import { createPortal as Tt } from "react-dom";

package/dist/@react-virtualized-sticky-tree-CVJYfMx0.js

@@ -0,0 +1,452 @@
+var v = Object.defineProperty;
+var E = (a, h, e) => h in a ? v(a, h, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[h] = e;
+var f = (a, h, e) => E(a, typeof h != "symbol" ? h + "" : h, e);
+import u, { createRef as k } from "react";
+import { aY as x } from "./@vendor-CwAQS8iU.js";
+const b = () => typeof navigator < "u" && /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor) ? "-webkit-sticky" : "sticky";
+var g;
+(function(a) {
+  a.OBSERVED = "observed", a.REQUESTED = "requested";
+})(g || (g = {}));
+class N extends u.PureComponent {
+  constructor(e) {
+    super(e);
+    f(this, "nodes");
+    f(this, "getChildrenCache");
+    f(this, "rowRenderCache");
+    f(this, "rowRenderRange");
+    f(this, "structureChanged");
+    f(this, "elemRef", k());
+    f(this, "pendingScrollTop");
+    f(this, "treeToRender");
+    this.props.apiRef && this.props.apiRef(this), this.state = {
+      scrollTop: 0,
+      currNodePos: 0,
+      scrollTick: !1
+    }, this.nodes = [], this.structureChanged = !1, this.onScroll = this.onScroll.bind(this), this.getChildrenCache = {}, this.rowRenderCache = {}, this.rowRenderRange = void 0;
+  }
+  /**
+   *  Converts the consumer's tree structure into a flat array with root at index: 0,
+   *  including information about the top and height of each node.
+   *
+   *  i.e:
+   *  [
+   *    { id: 'root', top: 0, index: 0, height: 100. isSticky: true , zIndex: 0, stickyTop: 10 },
+   *    { id: 'child1', top: 10, index: 1, parentIndex: 0 height: 10, isSticky: false },
+   *    ...
+   *  ]
+   */
+  flattenTree(e, t = this.props, i = [], s = !1, r = !1, o = void 0, d = { totalHeight: 0 }) {
+    const n = i.length, S = e.height !== void 0 ? e.height : t.rowHeight, R = o !== void 0 ? i[o] : void 0, { isSticky: T = !1, stickyTop: w = 0, zIndex: I = 0, node: m } = e, p = {
+      id: m.id,
+      isSticky: T,
+      stickyTop: w,
+      zIndex: I,
+      node: m,
+      top: d.totalHeight,
+      isLeafNode: !1,
+      meta: e.meta,
+      parentIndex: o,
+      parentInfo: R,
+      depth: R !== void 0 ? R.depth + 1 : 0,
+      height: S,
+      index: n,
+      isFirstChild: s,
+      isLastChild: r,
+      totalHeight: 0
+    };
+    i.push(p), R !== void 0 && R.children.push(n), d.totalHeight += S;
+    const l = t.getChildren(e.node, p);
+    if (t.isModelImmutable) {
+      let c = this.getChildrenCache[p.id];
+      (l === void 0 || c !== l) && (delete this.rowRenderCache[p.id], this.getChildrenCache[p.id] = l, c && l && (l.length !== c.length || !l.every((C, y) => C.node.id === c[y].node.id)) && (this.structureChanged = !0, this.getBranchChildrenIds(l).forEach((C) => delete this.rowRenderCache[C])));
+    } else
+      this.structureChanged = !0;
+    if (Array.isArray(l)) {
+      p.children = [];
+      for (let c = 0; c < l.length; c++) {
+        const C = l[c];
+        this.flattenTree(C, t, i, c === 0, c === l.length - 1, n, d);
+      }
+    } else
+      p.isLeafNode = !0;
+    return p.totalHeight = d.totalHeight - p.top, i;
+  }
+  getBranchChildrenIds(e, t = []) {
+    return e && e.forEach((i) => {
+      t.push(i.node.id), this.getBranchChildrenIds(this.getChildrenCache[i.node.id], t);
+    }), t;
+  }
+  UNSAFE_componentWillMount() {
+    this.refreshCachedMetadata(this.props), this.storeRenderTree(this.props, this.state);
+  }
+  treeDataUpdated(e) {
+    return e.root !== this.props.root || e.getChildren !== this.props.getChildren || e.rowHeight !== this.props.rowHeight;
+  }
+  UNSAFE_componentWillReceiveProps(e) {
+    this.treeDataUpdated(e) && this.refreshCachedMetadata(e), e.scrollIndex !== void 0 && e.scrollIndex >= 0 && this.scrollIndexIntoView(e.scrollIndex);
+  }
+  UNSAFE_componentWillUpdate(e, t) {
+    (t.scrollTick === this.state.scrollTick || t.currNodePos !== this.state.currNodePos) && this.storeRenderTree(e, t);
+  }
+  getNode(e) {
+    return this.nodes[this.getNodeIndex(e)]?.node;
+  }
+  /**
+   * Returns the index of the node in a flat list tree (post-order traversal).
+   *
+   * @param nodeId The node index to get the index for.
+   * @returns {number}
+   */
+  getNodeIndex(e) {
+    return this.nodes.findIndex((t) => t.id === e);
+  }
+  /**
+   * Returns the node that appears higher than this node (either a parent, sibling or child of the sibling above).
+   * @param nodeId The node to get the previous node of.
+   * @returns {*}
+   */
+  getPreviousNodeId(e) {
+    const t = this.getNodeIndex(e);
+    if (t !== -1) {
+      const i = this.nodes[t - 1];
+      if (i)
+        return i.id;
+    }
+  }
+  /**
+   * Returns the node that appears lower than this node (sibling or sibling of the node's parent).
+   * @param nodeId The node to get the next node of.
+   * @returns {*}
+   */
+  getNextNodeId(e) {
+    const t = this.getNodeIndex(e);
+    if (t !== -1) {
+      const i = this.nodes[t + 1];
+      if (i)
+        return i.id;
+    }
+  }
+  /**
+   * Returns true if the node is completely visible and is not obscured.
+   * This will return false when the node is partially obscured.
+   *
+   * @param nodeId The id of the node to check
+   * @param includeObscured if true, this method will return true for partially visible nodes.
+   * @returns {boolean}
+   */
+  isNodeVisible(e, t = !1) {
+    return this.isIndexVisible(this.getNodeIndex(e), t);
+  }
+  /**
+   * Returns true if the node is completely visible and is not obscured, unless includeObscured is specified.
+   * This will return false when the node is partially obscured, unless includeObscured is set to true.
+   *
+   * @param index The index of the node to check, generally retrieved via getNodeIndex()
+   * @param includeObscured if true, this method will return true for partially visible nodes.
+   * @returns {boolean}
+   */
+  isIndexVisible(e, t = !1) {
+    let i;
+    const s = this.nodes[e];
+    if (!s)
+      return !1;
+    if (s.isSticky && e === this.state.currNodePos || this.getParentPath(this.state.currNodePos).includes(this.nodes[e]))
+      return !0;
+    const r = this.getScrollTop();
+    if (t ? this.elemRef.current && (i = r <= s.top + s.height - s.stickyTop && r + this.props.height >= s.top) : i = this.isIndexInViewport(e), i) {
+      const o = this.getParentPath(e, !1);
+      for (let d = 0; d < o.length; d++) {
+        const n = o[d];
+        if (n.isSticky && (!t && n.stickyTop + n.height > s.top - r || t && n.stickyTop + n.height > s.top + s.height - r))
+          return !1;
+      }
+      return !0;
+    }
+    return !1;
+  }
+  /**
+   * Returns true if the node is within the view port window. Note this this will return FALSE for visible sticky nodes that are
+   * partially out of view disregarding sticky, which is useful when the node will become unstuck. This may occur when the node is
+   * collapsed in a tree. In this case, you want to scroll this node back into view so that the collapsed node stays in the same position.
+   *
+   * @param nodeId The id of the node to check
+   * @returns {boolean}
+   */
+  isNodeInViewport(e) {
+    return this.isIndexInViewport(this.getNodeIndex(e));
+  }
+  /**
+   * Returns true if the node is within the view port window. Note this this will return FALSE for visible sticky nodes that are
+   * partially out of view disregarding sticky, which is useful when the node will become unstuck. This may occur when the node is
+   * collapsed in a tree. In this case, you want to scroll this node back into view so that the collapsed node stays in the same position.
+   *
+   * This also returns false if the node is partially out of view.
+   *
+   * @param index The node index, generally retrieved via getNodeIndex()
+   * @returns {boolean}
+   */
+  isIndexInViewport(e) {
+    let t = this.nodes[e];
+    if (!t || !this.elemRef)
+      return !1;
+    const i = this.getScrollTop();
+    return i <= t.top - t.stickyTop && i + this.props.height >= t.top + t.height;
+  }
+  /**
+   * Returns the top of the node with the specified id.
+   * @param nodeId
+   */
+  getNodeTop(e) {
+    return this.getIndexTop(this.getNodeIndex(e));
+  }
+  /**
+   * Returns the top of the node with the specified index.
+   * @param index
+   */
+  getIndexTop(e) {
+    const t = this.nodes[e];
+    return t ? t.top : -1;
+  }
+  /**
+   * Returns the scrollTop of the scrollable element
+   *
+   * @return returns -1 if the elem does not exist.
+   */
+  getScrollTop() {
+    return this.elemRef.current ? this.elemRef.current.scrollTop : -1;
+  }
+  /**
+   * Returns the scrollLeft of the scrollable element
+   *
+   * @return returns -1 if the elem does not exist.
+   */
+  getScrollLeft() {
+    return this.elemRef.current ? this.elemRef.current.scrollLeft : -1;
+  }
+  /**
+   * Sets the scrollTop position of the scrollable element.
+   * @param scrollTop
+   */
+  setScrollTop(e) {
+    isNaN(e) || this.setScrollTopAndClosestNode(e, this.state.currNodePos, g.REQUESTED);
+  }
+  /**
+   * Sets the scrollLeft position of the scrollable element.
+   * @param scrollLeft
+   */
+  setScrollLeft(e) {
+    !isNaN(e) && this.elemRef.current && (this.elemRef.current.scrollLeft = e);
+  }
+  /**
+   * Scrolls the node into view so that it is visible.
+   *
+   * @param nodeId The node id of the node to scroll into view.
+   * @param alignToTop if true, the node will aligned to the top of viewport, or sticky parent. If false, the bottom of the node will
+   * be aligned with the bottom of the viewport.
+   */
+  scrollNodeIntoView(e, t = !0) {
+    this.scrollIndexIntoView(this.getNodeIndex(e), t);
+  }
+  /**
+   * Scrolls the node into view so that it is visible.
+   *
+   * @param index The index of the node.
+   * @param alignToTop if true, the node will aligned to the top of viewport, or sticky parent. If false, the bottom of the node will
+   * be aligned with the bottom of the viewport.
+   */
+  scrollIndexIntoView(e, t = !0) {
+    let i = this.nodes[e];
+    if (i !== void 0) {
+      let s;
+      if (t)
+        if (i.isSticky)
+          s = i.top - i.stickyTop;
+        else {
+          const r = this.getParentPath(e, !1);
+          for (let o = 0; o < r.length; o++) {
+            const d = r[o];
+            if (d.isSticky) {
+              s = i.top - d.stickyTop - d.height;
+              break;
+            }
+          }
+          s === void 0 && (s = i.top);
+        }
+      else
+        s = i.top - this.props.height + i.height;
+      this.setScrollTop(s);
+    }
+  }
+  componentDidUpdate(e, t) {
+    if (this.state.scrollReason === g.REQUESTED && this.elemRef.current && this.state.scrollTop >= 0 && this.state.scrollTop !== this.elemRef.current.scrollTop && (this.elemRef.current.scrollTop = this.state.scrollTop), this.props.onRowsRendered !== void 0 && (t.currNodePos !== this.state.currNodePos || this.treeDataUpdated(e))) {
+      const i = this.rowRenderRange, s = this.nodes[i.visibleStart], r = this.nodes[i.visibleEnd];
+      this.props.onRowsRendered({
+        overscanStartIndex: i.start,
+        overscanStopIndex: i.end,
+        startIndex: i.visibleStart,
+        stopIndex: i.visibleEnd,
+        startNode: s && s,
+        endNode: r && r,
+        nodes: this.nodes
+      });
+    }
+  }
+  refreshCachedMetadata(e) {
+    this.structureChanged = !1, this.nodes = this.flattenTree(e.root, e), this.structureChanged && this.elemRef && this.setScrollTopAndClosestNode(this.pendingScrollTop || this.getScrollTop(), 0, g.REQUESTED);
+  }
+  recomputeTree() {
+    this.props.root !== void 0 && this.props.getChildren !== void 0 && (this.refreshCachedMetadata(this.props), this.forceUpdate());
+  }
+  storeRenderTree(e, t) {
+    this.treeToRender = this.renderParentTree(e, t);
+  }
+  forceUpdate() {
+    this.getChildrenCache = {}, this.rowRenderCache = {}, this.storeRenderTree(this.props, this.state), super.forceUpdate();
+  }
+  renderParentTree(e, t) {
+    this.rowRenderRange = this.getRenderRowRange(e, t);
+    const i = this.getParentPath(this.rowRenderRange.start), s = /* @__PURE__ */ new Set();
+    for (let r = 0; r < i.length; r++)
+      s.add(i[r].index);
+    for (let r = this.rowRenderRange.start; r <= this.rowRenderRange.end; r++)
+      s.add(this.nodes[r].index);
+    return this.props.renderRoot ? u.createElement("div", { className: "rv-sticky-node-list", style: { width: "100%", position: "absolute", top: 0 } }, this.renderChildWithChildren(e, t, this.nodes[0], 0, s)) : this.renderParentContainer(e, t, this.nodes[0], s);
+  }
+  renderParentContainer(e, t, i, s) {
+    return u.createElement("div", { className: "rv-sticky-node-list", style: { position: "absolute", width: "100%", height: i.totalHeight - i.height } }, this.renderChildren(e, t, i, s));
+  }
+  getChildContainerStyle(e, t) {
+    return { position: "absolute", top: t, height: e.totalHeight, width: "100%" };
+  }
+  renderChildWithChildren(e, t, i, s, r) {
+    return u.createElement(
+      "div",
+      { key: `rv-node-${i.id}`, className: "rv-sticky-parent-node", style: this.getChildContainerStyle(i, s) },
+      this.renderNode(e, t, i, this.getClientNodeStyle(i)),
+      this.renderParentContainer(e, t, i, r)
+    );
+  }
+  getClientNodeStyle(e) {
+    const t = { height: e.height };
+    return e.isSticky && (t.position = b(), t.top = e.stickyTop, t.zIndex = e.zIndex), t;
+  }
+  getClientLeafNodeStyle(e, t) {
+    return {
+      position: "absolute",
+      top: t,
+      height: e.height,
+      width: "100%"
+    };
+  }
+  renderChildren(e, t, i, s) {
+    const r = [];
+    let o = 0;
+    return i.children.forEach((d) => {
+      const n = this.nodes[d];
+      s.has(d) && ("children" in n && n.children.length > 0 ? r.push(this.renderChildWithChildren(e, t, n, o, s)) : n.isSticky || e.wrapAllLeafNodes ? r.push(u.createElement("div", { className: "rv-sticky-leaf-node", key: `rv-node-${n.id}`, style: this.getChildContainerStyle(n, o) }, this.renderNode(e, t, n, this.getClientNodeStyle(n)))) : r.push(this.renderNode(e, t, n, this.getClientLeafNodeStyle(n, o)))), o += n.totalHeight;
+    }), r;
+  }
+  renderNode(e, t, i, s) {
+    if (e.isModelImmutable && this.rowRenderCache[i.id])
+      return this.rowRenderCache[i.id];
+    const r = e.rowRenderer({ node: i.node, nodeInfo: i, style: s, meta: e.meta });
+    return e.isModelImmutable && (this.rowRenderCache[i.id] = r), r;
+  }
+  /**
+   * Determines the start and end number of the range to be rendered.
+   * @returns {{start: number, end: number}} Indexes within nodes
+   */
+  getRenderRowRange(e, t) {
+    let i = e.overscanRowCount > 0 ? e.overscanRowCount : 1, s = t.currNodePos - i;
+    s < 0 && (s = 0);
+    let r = t.currNodePos + 1;
+    for (; this.nodes[r] && this.nodes[r].top < t.scrollTop + e.height; )
+      r++;
+    let o = r + i;
+    return o > this.nodes.length - 1 && (o = this.nodes.length - 1), { start: s, end: o, visibleStart: t.currNodePos, visibleEnd: r };
+  }
+  /**
+   * Returns the parent path from nodes for the specified index within nodes.
+   * @param nodeIndex
+   * @param topDownOrder if true, the array with index 0 will be the root node, otherwise 0 will be the immediate parent.
+   * @returns {Array<TreeNode>}
+   */
+  getParentPath(e, t = !0) {
+    let i = this.nodes[e];
+    const s = [];
+    for (; i; )
+      i = this.nodes[i.parentIndex], i && s.push(i);
+    return t ? s.reverse() : s;
+  }
+  /**
+   * Searches from the current node position downwards to see if the top of nodes above are greater
+   * than or equal to the current scrollTop
+   * @param scrollTop
+   * @param searchPos
+   * @returns {number}
+   */
+  forwardSearch(e, t) {
+    const i = this.nodes;
+    for (let s = t; s < i.length; s++)
+      if (i[s].top >= e)
+        return s;
+    return i.length - 1;
+  }
+  /**
+   * Searches from the current node position upwards to see if the top of nodes above are less than
+   * or equal the current scrollTop.
+   * @param scrollTop
+   * @param searchPos
+   * @returns {number}
+   */
+  backwardSearch(e, t) {
+    const i = this.nodes;
+    for (let s = Math.min(t, Math.max(i.length - 1, 0)); s >= 0; s--)
+      if (i[s].top <= e)
+        return s;
+    return 0;
+  }
+  /**
+   * Sets the scroll top in state and finds and sets the closest node to that scroll top.
+   */
+  setScrollTopAndClosestNode(e, t, i) {
+    if (e === this.state.scrollTop || (this.elemRef.current && e >= this.elemRef.current.scrollHeight - this.elemRef.current.offsetHeight && (e = this.elemRef.current.scrollHeight - this.elemRef.current.offsetHeight), e === this.state.scrollTop))
+      return;
+    let s;
+    (e > this.state.scrollTop || t === 0) && (s = this.forwardSearch(e, t)), e < this.state.scrollTop && s === void 0 && (s = this.backwardSearch(e, t)), this.pendingScrollTop = e, this.setState({ currNodePos: s || 0, scrollTop: e, scrollReason: i }, () => {
+      this.pendingScrollTop = void 0;
+    });
+  }
+  onScroll(e) {
+    const { scrollTop: t, scrollLeft: i } = e.target, s = this.state.scrollReason || g.OBSERVED;
+    this.setScrollTopAndClosestNode(t, this.state.currNodePos, s), this.props.onScroll !== void 0 && this.props.onScroll({ scrollTop: t, scrollLeft: i, scrollReason: s }), this.setState({ scrollTick: !this.state.scrollTick, scrollReason: void 0 });
+  }
+  render() {
+    let e = { overflow: "auto", position: "relative" };
+    return this.props.inlineWidthHeight !== !1 && (this.props.width && (e.width = this.props.width), this.props.height && (e.height = this.props.height)), u.createElement("div", { ref: this.elemRef, className: "rv-sticky-tree", style: e, onScroll: this.onScroll }, this.treeToRender);
+  }
+}
+f(N, "defaultProps", {
+  overscanRowCount: 10,
+  renderRoot: !0,
+  wrapAllLeafNodes: !1,
+  isModelImmutable: !1
+});
+class U extends u.PureComponent {
+  constructor(h) {
+    super(h), this.state = {};
+  }
+  render() {
+    return u.createElement(x, { bounds: !0, onResize: (h) => {
+      this.setState({ width: h.bounds.width, height: h.bounds.height }), this.props.onResize !== void 0 && this.props.onResize(h);
+    } }, ({ measureRef: h }) => u.createElement(
+      "div",
+      { ref: h, className: this.props.className },
+      u.createElement(N, { ref: this.props.treeRef, width: this.state.width, height: this.state.height, ...this.props })
+    ));
+  }
+}
+export {
+  U as A
+};