@devtron-labs/devtron-fe-common-lib 1.23.4-beta-2 → 1.23.4-beta-3

package/dist/@react-virtualized-sticky-tree-LXSXNrbc.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 { ct as x } from "./@vendor-CtCMPfdc.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
+};