@midas-ds/components 12.0.0 → 12.1.0

package/ListBoxSection-BCPv9H50.js

@@ -0,0 +1,1085 @@
+import { jsx as k, jsxs as ne } from "react/jsx-runtime";
+import { a as se, b as re, c as ae } from "./ListBox-LncMQt6I.js";
+import { g as he, m as de } from "./Collection-B0_WAieZ.js";
+import w, { useState as $, useRef as C, useMemo as L, useCallback as z, useEffect as ce, createContext as F, useContext as j } from "react";
+import { $ as V, d as ue } from "./mergeProps-BSsN7Bgk.js";
+import { $ as U } from "./context-CGNJ3grH.js";
+import { flushSync as B } from "react-dom";
+import { g as fe } from "./OverlayArrow-CvNuu3e3.js";
+import { $ as W } from "./useEvent-DpBHTuHJ.js";
+import { c as K } from "./clsx-OuTLNxxd.js";
+import { f as D } from "./SelectionManager-Bq-Gw1UT.js";
+import { a as ge } from "./Dialog-B8swxl24.js";
+import { e as ye } from "./Separator-CM0KPvsX.js";
+import './assets/ListBoxSection.css';class ve {
+  /**
+  * Returns whether the layout should invalidate in response to
+  * visible rectangle changes. By default, it only invalidates
+  * when the virtualizer's size changes. Return true always
+  * to make the layout invalidate while scrolling (e.g. sticky headers).
+  */
+  shouldInvalidate(e, t) {
+    return e.width !== t.width || e.height !== t.height;
+  }
+  /**
+  * Returns whether the layout should invalidate when the layout options change.
+  * By default it invalidates when the object identity changes. Override this
+  * method to optimize layout updates based on specific option changes.
+  */
+  shouldInvalidateLayoutOptions(e, t) {
+    return e !== t;
+  }
+  /**
+  * This method allows the layout to perform any pre-computation
+  * it needs to in order to prepare LayoutInfos for retrieval.
+  * Called by the virtualizer before `getVisibleLayoutInfos`
+  * or `getLayoutInfo` are called.
+  */
+  update(e) {
+  }
+  /** @private */
+  getItemRect(e) {
+    var t, i;
+    return (i = (t = this.getLayoutInfo(e)) === null || t === void 0 ? void 0 : t.rect) !== null && i !== void 0 ? i : null;
+  }
+  /** @private */
+  getVisibleRect() {
+    return this.virtualizer.visibleRect;
+  }
+  constructor() {
+    this.virtualizer = null;
+  }
+}
+class b {
+  /**
+  * Returns a copy of the LayoutInfo.
+  */
+  copy() {
+    let e = new b(this.type, this.key, this.rect.copy());
+    return e.estimatedSize = this.estimatedSize, e.opacity = this.opacity, e.transform = this.transform, e.parentKey = this.parentKey, e.content = this.content, e.isSticky = this.isSticky, e.zIndex = this.zIndex, e.allowOverflow = this.allowOverflow, e;
+  }
+  /**
+  * @param type The type of element represented by this LayoutInfo. Should match the `type` of the corresponding collection node.
+  * @param key A unique key for this LayoutInfo. Should match the `key` of the corresponding collection node.
+  * @param rect The rectangle describing the size and position of this element.
+  */
+  constructor(e, t, i) {
+    this.type = e, this.key = t, this.parentKey = null, this.content = null, this.rect = i, this.estimatedSize = !1, this.isSticky = !1, this.opacity = 1, this.transform = null, this.zIndex = 0, this.allowOverflow = !1;
+  }
+}
+class x {
+  /**
+  * Returns a copy of this point.
+  */
+  copy() {
+    return new x(this.x, this.y);
+  }
+  /**
+  * Checks if two points are equal.
+  */
+  equals(e) {
+    return this.x === e.x && this.y === e.y;
+  }
+  /**
+  * Returns true if this point is the origin.
+  */
+  isOrigin() {
+    return this.x === 0 && this.y === 0;
+  }
+  constructor(e = 0, t = 0) {
+    this.x = e, this.y = t;
+  }
+}
+class f {
+  /**
+  * The maximum x-coordinate in the rectangle.
+  */
+  get maxX() {
+    return this.x + this.width;
+  }
+  /**
+  * The maximum y-coordinate in the rectangle.
+  */
+  get maxY() {
+    return this.y + this.height;
+  }
+  /**
+  * The area of the rectangle.
+  */
+  get area() {
+    return this.width * this.height;
+  }
+  /**
+  * The top left corner of the rectangle.
+  */
+  get topLeft() {
+    return new x(this.x, this.y);
+  }
+  /**
+  * The top right corner of the rectangle.
+  */
+  get topRight() {
+    return new x(this.maxX, this.y);
+  }
+  /**
+  * The bottom left corner of the rectangle.
+  */
+  get bottomLeft() {
+    return new x(this.x, this.maxY);
+  }
+  /**
+  * The bottom right corner of the rectangle.
+  */
+  get bottomRight() {
+    return new x(this.maxX, this.maxY);
+  }
+  /**
+  * Returns whether this rectangle intersects another rectangle.
+  * @param rect - The rectangle to check.
+  */
+  intersects(e) {
+    return (process.env.NODE_ENV === "test" && !process.env.VIRT_ON || this.area > 0 && e.area > 0) && this.x <= e.x + e.width && e.x <= this.x + this.width && this.y <= e.y + e.height && e.y <= this.y + this.height;
+  }
+  /**
+  * Returns whether this rectangle fully contains another rectangle.
+  * @param rect - The rectangle to check.
+  */
+  containsRect(e) {
+    return this.x <= e.x && this.y <= e.y && this.maxX >= e.maxX && this.maxY >= e.maxY;
+  }
+  /**
+  * Returns whether the rectangle contains the given point.
+  * @param point - The point to check.
+  */
+  containsPoint(e) {
+    return this.x <= e.x && this.y <= e.y && this.maxX >= e.x && this.maxY >= e.y;
+  }
+  /**
+  * Returns the first corner of this rectangle (from top to bottom, left to right)
+  * that is contained in the given rectangle, or null of the rectangles do not intersect.
+  * @param rect - The rectangle to check.
+  */
+  getCornerInRect(e) {
+    for (let t of [
+      "topLeft",
+      "topRight",
+      "bottomLeft",
+      "bottomRight"
+    ])
+      if (e.containsPoint(this[t])) return t;
+    return null;
+  }
+  equals(e) {
+    return e.x === this.x && e.y === this.y && e.width === this.width && e.height === this.height;
+  }
+  pointEquals(e) {
+    return this.x === e.x && this.y === e.y;
+  }
+  sizeEquals(e) {
+    return this.width === e.width && this.height === e.height;
+  }
+  /**
+  * Returns the union of this Rect and another.
+  */
+  union(e) {
+    let t = Math.min(this.x, e.x), i = Math.min(this.y, e.y), l = Math.max(this.maxX, e.maxX) - t, o = Math.max(this.maxY, e.maxY) - i;
+    return new f(t, i, l, o);
+  }
+  /**
+  * Returns the intersection of this Rect with another.
+  * If the rectangles do not intersect, an all zero Rect is returned.
+  */
+  intersection(e) {
+    if (!this.intersects(e)) return new f(0, 0, 0, 0);
+    let t = Math.max(this.x, e.x), i = Math.max(this.y, e.y);
+    return new f(t, i, Math.min(this.maxX, e.maxX) - t, Math.min(this.maxY, e.maxY) - i);
+  }
+  /**
+  * Returns a copy of this rectangle.
+  */
+  copy() {
+    return new f(this.x, this.y, this.width, this.height);
+  }
+  constructor(e = 0, t = 0, i = 0, l = 0) {
+    this.x = e, this.y = t, this.width = i, this.height = l;
+  }
+}
+class H {
+  /**
+  * Returns a copy of this size.
+  */
+  copy() {
+    return new H(this.width, this.height);
+  }
+  /**
+  * Returns whether this size is equal to another one.
+  */
+  equals(e) {
+    return this.width === e.width && this.height === e.height;
+  }
+  /**
+  * The total area of the Size.
+  */
+  get area() {
+    return this.width * this.height;
+  }
+  constructor(e = 0, t = 0) {
+    this.width = Math.max(e, 0), this.height = Math.max(t, 0);
+  }
+}
+let pe = 0;
+class G {
+  /**
+  * Prepares the view for reuse. Called just before the view is removed from the DOM.
+  */
+  prepareForReuse() {
+    this.content = null, this.rendered = null, this.layoutInfo = null;
+  }
+  getReusableView(e) {
+    let t = this.reusableViews.get(e);
+    return t && t.length > 0 ? t.shift() : new we(this.virtualizer, this, e);
+  }
+  reuseChild(e) {
+    e.prepareForReuse();
+    let t = this.reusableViews.get(e.viewType);
+    t || (t = [], this.reusableViews.set(e.viewType, t)), t.push(e);
+  }
+  constructor(e, t) {
+    this.virtualizer = e, this.key = ++pe, this.viewType = t, this.children = /* @__PURE__ */ new Set(), this.reusableViews = /* @__PURE__ */ new Map(), this.layoutInfo = null, this.content = null, this.rendered = null;
+  }
+}
+class me extends G {
+  constructor(e) {
+    super(e, "root");
+  }
+}
+class we extends G {
+  constructor(e, t, i) {
+    super(e, i), this.parent = t;
+  }
+}
+function be(n, e) {
+  if (n === e) return !0;
+  if (n.size !== e.size) return !1;
+  for (let t of n)
+    if (!e.has(t)) return !1;
+  return !0;
+}
+class xe {
+  setVisibleRect(e) {
+    let t = performance.now() - this.startTime;
+    t < 500 && (e.x !== this.visibleRect.x && t > 0 && (this.velocity.x = (e.x - this.visibleRect.x) / t), e.y !== this.visibleRect.y && t > 0 && (this.velocity.y = (e.y - this.visibleRect.y) / t)), this.startTime = performance.now(), this.visibleRect = e;
+  }
+  getOverscannedRect() {
+    let e = this.visibleRect.copy(), t = this.visibleRect.height / 3;
+    if (e.height += t, this.velocity.y < 0 && (e.y -= t), this.velocity.x !== 0) {
+      let i = this.visibleRect.width / 3;
+      e.width += i, this.velocity.x < 0 && (e.x -= i);
+    }
+    return e;
+  }
+  constructor() {
+    this.startTime = 0, this.velocity = new x(0, 0), this.visibleRect = new f();
+  }
+}
+class Ie {
+  /** Returns whether the given key, or an ancestor, is persisted. */
+  isPersistedKey(e) {
+    if (this.persistedKeys.has(e)) return !0;
+    for (let t of this.persistedKeys) for (; t != null; ) {
+      let i = this.layout.getLayoutInfo(t);
+      if (!i || i.parentKey == null) break;
+      if (t = i.parentKey, t === e) return !0;
+    }
+    return !1;
+  }
+  getParentView(e) {
+    return e.parentKey != null ? this._visibleViews.get(e.parentKey) : this._rootView;
+  }
+  getReusableView(e) {
+    let i = this.getParentView(e).getReusableView(e.type);
+    return i.layoutInfo = e, this._renderView(i), i;
+  }
+  _renderView(e) {
+    if (e.layoutInfo) {
+      let { type: t, key: i, content: l } = e.layoutInfo;
+      e.content = l || this.collection.getItem(i), e.rendered = this._renderContent(t, e.content);
+    }
+  }
+  _renderContent(e, t) {
+    let i = t != null ? this._renderedContent.get(t) : null;
+    if (i != null) return i;
+    let l = this.delegate.renderView(e, t);
+    return t && this._renderedContent.set(t, l), l;
+  }
+  /**
+  * Returns the key for the item view currently at the given point.
+  */
+  keyAtPoint(e) {
+    let t = new f(e.x, e.y, 1, 1), i = t.area === 0 ? [] : this.layout.getVisibleLayoutInfos(t);
+    for (let l of i)
+      if (l.rect.intersects(t)) return l.key;
+    return null;
+  }
+  relayout(e = {}) {
+    this.layout.update(e), this.contentSize = this.layout.getContentSize();
+    let t = this.visibleRect, i = e.contentChanged ? 0 : t.x, l = e.contentChanged ? 0 : t.y;
+    if (i = Math.max(0, Math.min(this.contentSize.width - t.width, i)), l = Math.max(0, Math.min(this.contentSize.height - t.height, l)), i !== t.x || l !== t.y) {
+      let o = new f(i, l, t.width, t.height);
+      this.delegate.setVisibleRect(o);
+    } else this.updateSubviews();
+  }
+  getVisibleLayoutInfos() {
+    let e = process.env.NODE_ENV === "test" && !process.env.VIRT_ON, t = e && typeof HTMLElement < "u" && Object.getOwnPropertyNames(HTMLElement.prototype).includes("clientWidth"), i = e && typeof HTMLElement < "u" && Object.getOwnPropertyNames(HTMLElement.prototype).includes("clientHeight"), l;
+    e && !(t && i) ? l = new f(0, 0, this.contentSize.width, this.contentSize.height) : l = this._overscanManager.getOverscannedRect();
+    let o = this.layout.getVisibleLayoutInfos(l), s = /* @__PURE__ */ new Map();
+    for (let a of o) s.set(a.key, a);
+    return s;
+  }
+  updateSubviews() {
+    let e = this.getVisibleLayoutInfos(), t = /* @__PURE__ */ new Set();
+    for (let [i, l] of this._visibleViews) {
+      let o = e.get(i);
+      (!o || l.parent !== this.getParentView(o)) && (this._visibleViews.delete(i), l.parent.reuseChild(l), t.add(l));
+    }
+    for (let [i, l] of e) {
+      let o = this._visibleViews.get(i);
+      if (!o)
+        o = this.getReusableView(l), o.parent.children.add(o), this._visibleViews.set(i, o), t.delete(o);
+      else {
+        o.layoutInfo = l;
+        let s = this.collection.getItem(l.key);
+        o.content !== s && (o.content != null && this._renderedContent.delete(o.content), this._renderView(o));
+      }
+    }
+    for (let i of t)
+      i.parent.children.delete(i), i.parent.reusableViews.clear();
+    if (!this._isScrolling)
+      for (let i of e.keys()) {
+        let l = this._visibleViews.get(i);
+        l.parent.children.delete(l), l.parent.children.add(l);
+      }
+  }
+  /** Performs layout and updates visible views as needed. */
+  render(e) {
+    let t = this, i = !1, l = !1, o = !1, s = !1, a = !1, h = !1;
+    return e.collection !== this.collection && (t.collection = e.collection, i = !0), (e.layout !== this.layout || this.layout.virtualizer !== this) && (this.layout && (this.layout.virtualizer = null), e.layout.virtualizer = this, t.layout = e.layout, i = !0), e.persistedKeys && !be(e.persistedKeys, this.persistedKeys) && (t.persistedKeys = e.persistedKeys, h = !0), this.visibleRect.equals(e.visibleRect) || (this._overscanManager.setVisibleRect(e.visibleRect), this.layout.shouldInvalidate(e.visibleRect, this.visibleRect) ? (l = !e.visibleRect.pointEquals(this.visibleRect), o = !e.visibleRect.sizeEquals(this.visibleRect), i = !0) : h = !0, t.visibleRect = e.visibleRect), e.invalidationContext !== this._invalidationContext && (e.invalidationContext && (o || (o = e.invalidationContext.sizeChanged || !1), l || (l = e.invalidationContext.offsetChanged || !1), s || (s = e.invalidationContext.itemSizeChanged || !1), a || (a = e.invalidationContext.layoutOptions != null && this._invalidationContext.layoutOptions != null && e.invalidationContext.layoutOptions !== this._invalidationContext.layoutOptions && this.layout.shouldInvalidateLayoutOptions(e.invalidationContext.layoutOptions, this._invalidationContext.layoutOptions)), i || (i = s || o || l || a)), this._invalidationContext = e.invalidationContext), e.isScrolling !== this._isScrolling && (this._isScrolling = e.isScrolling, e.isScrolling || (h = !0)), i ? this.relayout({
+      offsetChanged: l,
+      sizeChanged: o,
+      itemSizeChanged: s,
+      layoutOptionsChanged: a,
+      layoutOptions: this._invalidationContext.layoutOptions
+    }) : h && this.updateSubviews(), Array.from(this._rootView.children);
+  }
+  getVisibleView(e) {
+    return this._visibleViews.get(e);
+  }
+  invalidate(e) {
+    this.delegate.invalidate(e);
+  }
+  updateItemSize(e, t) {
+    if (!this.layout.updateItemSize) return;
+    this.layout.updateItemSize(e, t) && this.invalidate({
+      itemSizeChanged: !0
+    });
+  }
+  constructor(e) {
+    this.delegate = e.delegate, this.collection = e.collection, this.layout = e.layout, this.contentSize = new H(), this.visibleRect = new f(), this.persistedKeys = /* @__PURE__ */ new Set(), this._visibleViews = /* @__PURE__ */ new Map(), this._renderedContent = /* @__PURE__ */ new WeakMap(), this._rootView = new me(this), this._isScrolling = !1, this._invalidationContext = {}, this._overscanManager = new xe();
+  }
+}
+function Re(n) {
+  let [e, t] = $(new f(0, 0, 0, 0)), [i, l] = $(!1), [o, s] = $({}), a = C(!1), [h] = $(() => new Ie({
+    collection: n.collection,
+    layout: n.layout,
+    delegate: {
+      setVisibleRect(v) {
+        t(v), a.current = !0;
+      },
+      // TODO: should changing these invalidate the entire cache?
+      renderView: n.renderView,
+      invalidate: s
+    }
+  }));
+  V(() => {
+    a.current && (a.current = !1, n.onVisibleRectChange(e));
+  });
+  let r = L(() => n.layoutOptions != null ? {
+    ...o,
+    layoutOptions: n.layoutOptions
+  } : o, [
+    o,
+    n.layoutOptions
+  ]), d = h.render({
+    layout: n.layout,
+    collection: n.collection,
+    persistedKeys: n.persistedKeys,
+    layoutOptions: n.layoutOptions,
+    visibleRect: e,
+    invalidationContext: r,
+    isScrolling: i
+  }), c = h.contentSize, u = z(() => {
+    l(!0);
+  }, []), g = z(() => {
+    l(!1);
+  }, []);
+  return L(() => ({
+    virtualizer: h,
+    visibleViews: d,
+    setVisibleRect: t,
+    contentSize: c,
+    isScrolling: i,
+    startScrolling: u,
+    endScrolling: g
+  }), [
+    h,
+    d,
+    t,
+    c,
+    i,
+    u,
+    g
+  ]);
+}
+const R = 48;
+class Se extends ve {
+  // Backward compatibility for subclassing.
+  get collection() {
+    return this.virtualizer.collection;
+  }
+  getLayoutInfo(e) {
+    var t;
+    return this.ensureLayoutInfo(e), ((t = this.layoutNodes.get(e)) === null || t === void 0 ? void 0 : t.layoutInfo) || null;
+  }
+  getVisibleLayoutInfos(e) {
+    if (e.height > 1) {
+      var t, i;
+      let s = ((i = (t = this.rowHeight) !== null && t !== void 0 ? t : this.estimatedRowHeight) !== null && i !== void 0 ? i : R) + this.gap;
+      e.y = Math.floor(e.y / s) * s, e.height = Math.ceil(e.height / s) * s;
+    }
+    this.layoutIfNeeded(e);
+    let l = [], o = (s) => {
+      for (let a of s) this.isVisible(a, e) && (l.push(a.layoutInfo), a.children && o(a.children));
+    };
+    return o(this.rootNodes), l;
+  }
+  layoutIfNeeded(e) {
+    if (this.lastCollection) {
+      this.requestedRect.containsRect(e) || (this.requestedRect = this.requestedRect.union(e), this.rootNodes = this.buildCollection());
+      for (let t of this.virtualizer.persistedKeys)
+        if (this.ensureLayoutInfo(t)) return;
+    }
+  }
+  ensureLayoutInfo(e) {
+    return !this.layoutNodes.has(e) && this.requestedRect.area < this.contentSize.area && this.lastCollection ? (this.requestedRect = new f(0, 0, 1 / 0, 1 / 0), this.rootNodes = this.buildCollection(), this.requestedRect = new f(0, 0, this.contentSize.width, this.contentSize.height), !0) : !1;
+  }
+  isVisible(e, t) {
+    return e.layoutInfo.rect.intersects(t) || e.layoutInfo.isSticky || e.layoutInfo.type === "header" || e.layoutInfo.type === "loader" || this.virtualizer.isPersistedKey(e.layoutInfo.key);
+  }
+  shouldInvalidateEverything(e) {
+    let t = e.layoutOptions;
+    var i, l, o, s, a;
+    return e.sizeChanged || this.rowHeight !== ((i = t == null ? void 0 : t.rowHeight) !== null && i !== void 0 ? i : this.rowHeight) || this.headingHeight !== ((l = t == null ? void 0 : t.headingHeight) !== null && l !== void 0 ? l : this.headingHeight) || this.loaderHeight !== ((o = t == null ? void 0 : t.loaderHeight) !== null && o !== void 0 ? o : this.loaderHeight) || this.gap !== ((s = t == null ? void 0 : t.gap) !== null && s !== void 0 ? s : this.gap) || this.padding !== ((a = t == null ? void 0 : t.padding) !== null && a !== void 0 ? a : this.padding);
+  }
+  shouldInvalidateLayoutOptions(e, t) {
+    return e.rowHeight !== t.rowHeight || e.estimatedRowHeight !== t.estimatedRowHeight || e.headingHeight !== t.headingHeight || e.estimatedHeadingHeight !== t.estimatedHeadingHeight || e.loaderHeight !== t.loaderHeight || e.dropIndicatorThickness !== t.dropIndicatorThickness || e.gap !== t.gap || e.padding !== t.padding;
+  }
+  update(e) {
+    let t = this.virtualizer.collection;
+    this.invalidateEverything = this.shouldInvalidateEverything(e), this.invalidateEverything && (this.requestedRect = this.virtualizer.visibleRect.copy(), this.layoutNodes.clear());
+    let i = e.layoutOptions;
+    var l;
+    this.rowHeight = (l = i == null ? void 0 : i.rowHeight) !== null && l !== void 0 ? l : this.rowHeight;
+    var o;
+    this.estimatedRowHeight = (o = i == null ? void 0 : i.estimatedRowHeight) !== null && o !== void 0 ? o : this.estimatedRowHeight;
+    var s;
+    this.headingHeight = (s = i == null ? void 0 : i.headingHeight) !== null && s !== void 0 ? s : this.headingHeight;
+    var a;
+    this.estimatedHeadingHeight = (a = i == null ? void 0 : i.estimatedHeadingHeight) !== null && a !== void 0 ? a : this.estimatedHeadingHeight;
+    var h;
+    this.loaderHeight = (h = i == null ? void 0 : i.loaderHeight) !== null && h !== void 0 ? h : this.loaderHeight;
+    var r;
+    this.dropIndicatorThickness = (r = i == null ? void 0 : i.dropIndicatorThickness) !== null && r !== void 0 ? r : this.dropIndicatorThickness;
+    var d;
+    this.gap = (d = i == null ? void 0 : i.gap) !== null && d !== void 0 ? d : this.gap;
+    var c;
+    if (this.padding = (c = i == null ? void 0 : i.padding) !== null && c !== void 0 ? c : this.padding, this.rootNodes = this.buildCollection(), this.lastCollection && t !== this.lastCollection)
+      for (let u of this.lastCollection.getKeys()) t.getItem(u) || this.layoutNodes.get(u) && this.layoutNodes.delete(u);
+    this.lastCollection = t, this.invalidateEverything = !1, this.validRect = this.requestedRect.copy();
+  }
+  buildCollection(e = this.padding) {
+    let t = this.virtualizer.collection, i = [
+      ...t
+    ], l = i.filter((r) => r.type === "loader"), o = [], s = (t == null ? void 0 : t.size) === 0;
+    s && (e = 0);
+    for (let r of i) {
+      var a, h;
+      let d = ((h = (a = this.rowHeight) !== null && a !== void 0 ? a : this.estimatedRowHeight) !== null && h !== void 0 ? h : R) + this.gap;
+      if (r.type === "item" && e + d < this.requestedRect.y && !this.isValid(r, e)) {
+        e += d;
+        continue;
+      }
+      let c = this.buildChild(r, this.padding, e, null);
+      if (e = c.layoutInfo.rect.maxY + this.gap, o.push(c), r.type === "loader") {
+        let u = l.indexOf(r);
+        l.splice(u, 1);
+      }
+      if ((r.type === "item" || r.type === "loader") && e > this.requestedRect.maxY) {
+        let u = i.indexOf(r);
+        for (let g of l) {
+          let y = i.indexOf(g);
+          e += (y - u - 1) * d;
+          let v = this.buildChild(g, this.padding, e, null);
+          o.push(v), e = v.layoutInfo.rect.maxY, u = y;
+        }
+        e += (i.length - u - 1) * d;
+        break;
+      }
+    }
+    return e -= this.gap, e += s ? 0 : this.padding, this.contentSize = new H(this.virtualizer.visibleRect.width, e), o;
+  }
+  isValid(e, t) {
+    let i = this.layoutNodes.get(e.key);
+    return !this.invalidateEverything && !!i && i.node === e && t === i.layoutInfo.rect.y && i.layoutInfo.rect.intersects(this.validRect) && i.validRect.containsRect(i.layoutInfo.rect.intersection(this.requestedRect));
+  }
+  buildChild(e, t, i, l) {
+    if (this.isValid(e, i)) return this.layoutNodes.get(e.key);
+    let o = this.buildNode(e, t, i);
+    return o.layoutInfo.parentKey = l ?? null, o.layoutInfo.allowOverflow = !0, this.layoutNodes.set(e.key, o), o;
+  }
+  buildNode(e, t, i) {
+    switch (e.type) {
+      case "section":
+        return this.buildSection(e, t, i);
+      case "item":
+        return this.buildItem(e, t, i);
+      case "header":
+        return this.buildSectionHeader(e, t, i);
+      case "loader":
+        return this.buildLoader(e, t, i);
+      case "separator":
+        return this.buildItem(e, t, i);
+      default:
+        throw new Error("Unsupported node type: " + e.type);
+    }
+  }
+  buildLoader(e, t, i) {
+    let l = new f(t, i, this.padding, 0), o = new b("loader", e.key, l);
+    l.width = this.virtualizer.contentSize.width - this.padding - t;
+    var s, a, h;
+    return l.height = e.props.isLoading ? (h = (a = (s = this.loaderHeight) !== null && s !== void 0 ? s : this.rowHeight) !== null && a !== void 0 ? a : this.estimatedRowHeight) !== null && h !== void 0 ? h : R : 0, {
+      layoutInfo: o,
+      validRect: l.intersection(this.requestedRect)
+    };
+  }
+  buildSection(e, t, i) {
+    let l = this.virtualizer.collection, o = this.virtualizer.visibleRect.width - this.padding, s = new f(t, i, o - t, 0), a = new b(e.type, e.key, s), h = i, r = 0, d = [];
+    for (let g of D(e, l)) {
+      var c, u;
+      let y = ((u = (c = this.rowHeight) !== null && c !== void 0 ? c : this.estimatedRowHeight) !== null && u !== void 0 ? u : R) + this.gap;
+      if (i + y < this.requestedRect.y && !this.isValid(e, i)) {
+        i += y, r++;
+        continue;
+      }
+      let v = this.buildChild(g, t, i, a.key);
+      if (i = v.layoutInfo.rect.maxY + this.gap, d.push(v), i > this.requestedRect.maxY) {
+        i += ([
+          ...D(e, l)
+        ].length - (d.length + r)) * y;
+        break;
+      }
+    }
+    return i -= this.gap, s.height = i - h, {
+      layoutInfo: a,
+      children: d,
+      validRect: a.rect.intersection(this.requestedRect),
+      node: e
+    };
+  }
+  buildSectionHeader(e, t, i) {
+    let l = this.virtualizer.visibleRect.width - this.padding, o = this.headingHeight, s = !1;
+    if (o == null) {
+      let r = this.layoutNodes.get(e.key), d = r == null ? void 0 : r.layoutInfo;
+      if (d) {
+        let c = this.virtualizer.collection.getItem(e.key), u = this.lastCollection ? this.lastCollection.getItem(e.key) : null;
+        o = d.rect.height, s = l !== d.rect.width || c !== u || d.estimatedSize;
+      } else
+        o = e.rendered ? this.estimatedHeadingHeight : 0, s = !0;
+    }
+    o == null && (o = R);
+    let a = new f(t, i, l - t, o), h = new b("header", e.key, a);
+    return h.estimatedSize = s, {
+      layoutInfo: h,
+      children: [],
+      validRect: h.rect.intersection(this.requestedRect),
+      node: e
+    };
+  }
+  buildItem(e, t, i) {
+    let l = this.virtualizer.visibleRect.width - this.padding - t, o = this.rowHeight, s = !1;
+    if (o == null) {
+      let r = this.layoutNodes.get(e.key);
+      r ? (o = r.layoutInfo.rect.height, s = l !== r.layoutInfo.rect.width || e !== r.node || r.layoutInfo.estimatedSize) : (o = this.estimatedRowHeight, s = !0);
+    }
+    o == null && (o = R);
+    let a = new f(t, i, l, o), h = new b(e.type, e.key, a);
+    return h.estimatedSize = s, {
+      layoutInfo: h,
+      children: [],
+      validRect: h.rect,
+      node: e
+    };
+  }
+  updateItemSize(e, t) {
+    let i = this.layoutNodes.get(e);
+    if (!i) return !1;
+    let l = this.virtualizer.collection, o = i.layoutInfo;
+    if (o.estimatedSize = !1, o.rect.height !== t.height) {
+      let s = o.copy();
+      s.rect.height = t.height, i.layoutInfo = s, this.validRect.height = Math.min(this.validRect.height, o.rect.y - this.validRect.y), this.requestedRect.height += s.rect.height - o.rect.height, this.updateLayoutNode(e, o, s);
+      let a = o.parentKey != null ? l.getItem(o.parentKey) : null;
+      for (; a; )
+        this.updateLayoutNode(a.key, o, s), a = a.parentKey != null ? l.getItem(a.parentKey) : null;
+      return !0;
+    }
+    return !1;
+  }
+  updateLayoutNode(e, t, i) {
+    let l = this.layoutNodes.get(e);
+    l && (l.validRect = l.validRect.intersection(this.validRect), l.layoutInfo === t && (l.layoutInfo = i));
+  }
+  getContentSize() {
+    return this.contentSize;
+  }
+  getDropTargetFromPoint(e, t, i) {
+    e += this.virtualizer.visibleRect.x, t += this.virtualizer.visibleRect.y;
+    let l = new f(e, Math.max(0, t - this.gap), 1, Math.max(1, this.gap * 2)), o = this.getVisibleLayoutInfos(l), s = null, a = 1 / 0;
+    for (let c of o) {
+      if (!c.rect.intersects(l)) continue;
+      let u = Math.abs(c.rect.y - t), g = Math.abs(c.rect.maxY - t), y = Math.min(u, g);
+      y < a && (a = y, s = c.key);
+    }
+    if (s == null || this.virtualizer.collection.size === 0) return {
+      type: "root"
+    };
+    let h = this.getLayoutInfo(s);
+    if (!h) return null;
+    let r = h.rect, d = {
+      type: "item",
+      key: h.key,
+      dropPosition: "on"
+    };
+    return i(d) ? t <= r.y + 10 && i({
+      ...d,
+      dropPosition: "before"
+    }) ? d.dropPosition = "before" : t >= r.maxY - 10 && i({
+      ...d,
+      dropPosition: "after"
+    }) && (d.dropPosition = "after") : t <= r.y + r.height / 2 && i({
+      ...d,
+      dropPosition: "before"
+    }) ? d.dropPosition = "before" : i({
+      ...d,
+      dropPosition: "after"
+    }) && (d.dropPosition = "after"), d;
+  }
+  getDropTargetLayoutInfo(e) {
+    let t = this.getLayoutInfo(e.key), i;
+    if (e.dropPosition === "before") i = new f(t.rect.x, Math.max(0, t.rect.y - this.dropIndicatorThickness / 2), t.rect.width, this.dropIndicatorThickness);
+    else if (e.dropPosition === "after") {
+      let o = this.collection.getItem(e.key);
+      if (o) {
+        var l;
+        let s = (l = o.level) !== null && l !== void 0 ? l : 0, a = this.collection.getKeyAfter(e.key);
+        for (; a != null; ) {
+          let h = this.collection.getItem(a);
+          if (!h || h.level <= s) break;
+          t = this.getLayoutInfo(a) || t, a = this.collection.getKeyAfter(a);
+        }
+      }
+      i = new f(t.rect.x, t.rect.maxY - this.dropIndicatorThickness / 2, t.rect.width, this.dropIndicatorThickness);
+    } else i = t.rect;
+    return new b("dropIndicator", e.key + ":" + e.dropPosition, i);
+  }
+  /**
+  * Creates a new ListLayout with options. See the list of properties below for a description
+  * of the options that can be provided.
+  */
+  constructor(e = {}) {
+    super();
+    var t;
+    this.rowHeight = (t = e.rowHeight) !== null && t !== void 0 ? t : null;
+    var i;
+    this.estimatedRowHeight = (i = e.estimatedRowHeight) !== null && i !== void 0 ? i : null;
+    var l;
+    this.headingHeight = (l = e.headingHeight) !== null && l !== void 0 ? l : null;
+    var o;
+    this.estimatedHeadingHeight = (o = e.estimatedHeadingHeight) !== null && o !== void 0 ? o : null;
+    var s;
+    this.loaderHeight = (s = e.loaderHeight) !== null && s !== void 0 ? s : null, this.dropIndicatorThickness = e.dropIndicatorThickness || 2, this.gap = e.gap || 0, this.padding = e.padding || 0, this.layoutNodes = /* @__PURE__ */ new Map(), this.rootNodes = [], this.lastCollection = null, this.invalidateEverything = !1, this.validRect = new f(), this.requestedRect = new f(), this.contentSize = new H();
+  }
+}
+let S = null;
+function $e(n = !1) {
+  if (S === null || n) {
+    const e = document.createElement("div"), t = e.style;
+    t.width = "50px", t.height = "50px", t.overflow = "scroll", t.direction = "rtl";
+    const i = document.createElement("div"), l = i.style;
+    return l.width = "100px", l.height = "100px", e.appendChild(i), document.body.appendChild(e), e.scrollLeft > 0 ? S = "positive-descending" : (e.scrollLeft = 1, e.scrollLeft === 0 ? S = "negative" : S = "positive-ascending"), document.body.removeChild(e), S;
+  }
+  return S;
+}
+function ze(n, e) {
+  let { scrollLeft: t } = n;
+  if (e === "rtl") {
+    let { scrollWidth: i, clientWidth: l } = n;
+    switch ($e()) {
+      case "negative":
+        t = -t;
+        break;
+      case "positive-descending":
+        t = i - l - t;
+        break;
+    }
+  }
+  return t;
+}
+function He(n, e) {
+  let { contentSize: t, onVisibleRectChange: i, innerStyle: l, onScrollStart: o, onScrollEnd: s, scrollDirection: a = "both", ...h } = n, r = C({
+    scrollTop: 0,
+    scrollLeft: 0,
+    scrollEndTime: 0,
+    scrollTimeout: null,
+    width: 0,
+    height: 0,
+    isScrolling: !1
+  }).current, { direction: d } = U(), [c, u] = $(!1), g = z(() => {
+    r.isScrolling = !1, u(!1), r.scrollTimeout = null, window.dispatchEvent(new Event("tk.connect-observer")), s == null || s();
+  }, [
+    r,
+    s
+  ]), y = z((p) => {
+    p.target === p.currentTarget && (n.onScroll && n.onScroll(p), B(() => {
+      let m = p.currentTarget.scrollTop, _ = ze(p.currentTarget, d);
+      r.scrollTop = Math.max(0, Math.min(m, t.height - r.height)), r.scrollLeft = Math.max(0, Math.min(_, t.width - r.width)), i(new f(r.scrollLeft, r.scrollTop, r.width, r.height)), r.isScrolling || (r.isScrolling = !0, u(!0), window.dispatchEvent(new Event("tk.disconnect-observer")), o && o());
+      let E = Date.now();
+      !("onscrollend" in window) && r.scrollEndTime <= E + 50 && (r.scrollEndTime = E + 300, r.scrollTimeout != null && clearTimeout(r.scrollTimeout), r.scrollTimeout = setTimeout(g, 300));
+    }));
+  }, [
+    n,
+    d,
+    r,
+    t,
+    i,
+    o,
+    g
+  ]);
+  W(e, "scroll", y), W(e, "scrollend", g), ce(() => () => {
+    r.scrollTimeout != null && clearTimeout(r.scrollTimeout), r.isScrolling && window.dispatchEvent(new Event("tk.connect-observer"));
+  }, []);
+  let v = C(!1), N = ue((p) => {
+    let m = e.current;
+    if (!m || v.current) return;
+    v.current = !0;
+    let _ = process.env.NODE_ENV === "test" && !process.env.VIRT_ON, E = Object.getOwnPropertyNames(window.HTMLElement.prototype).includes("clientWidth"), oe = Object.getOwnPropertyNames(window.HTMLElement.prototype).includes("clientHeight"), q = m.clientWidth, Y = m.clientHeight, O = _ && !E ? 1 / 0 : q, P = _ && !oe ? 1 / 0 : Y;
+    (r.width !== O || r.height !== P) && (r.width = O, r.height = P, p(() => {
+      i(new f(r.scrollLeft, r.scrollTop, O, P));
+    }), (!_ && q !== m.clientWidth || Y !== m.clientHeight) && (r.width = m.clientWidth, r.height = m.clientHeight, p(() => {
+      i(new f(r.scrollLeft, r.scrollTop, r.width, r.height));
+    }))), v.current = !1;
+  }), T = C(null), [te, ie] = $({});
+  V(() => {
+    if (!v.current && (T.current == null || !t.equals(T.current)))
+      if (typeof IS_REACT_ACT_ENVIRONMENT == "boolean" ? IS_REACT_ACT_ENVIRONMENT : typeof jest < "u") {
+        ie({}), T.current = t;
+        return;
+      } else queueMicrotask(() => N(B));
+    T.current = t;
+  }), V(() => {
+    N((p) => p());
+  }, [
+    te
+  ]);
+  let le = z(() => {
+    N(B);
+  }, [
+    N
+  ]);
+  fe({
+    ref: e,
+    box: "border-box",
+    onResize: le
+  });
+  let I = {
+    // Reset padding so that relative positioning works correctly. Padding will be done in JS layout.
+    padding: 0,
+    ...h.style
+  };
+  return a === "horizontal" ? (I.overflowX = "auto", I.overflowY = "hidden") : a === "vertical" || t.width === r.width ? (I.overflowY = "auto", I.overflowX = "hidden") : I.overflow = "auto", l = {
+    width: Number.isFinite(t.width) ? t.width : void 0,
+    height: Number.isFinite(t.height) ? t.height : void 0,
+    pointerEvents: c ? "none" : "auto",
+    position: "relative",
+    ...l
+  }, {
+    isScrolling: c,
+    scrollViewProps: {
+      ...h,
+      style: I
+    },
+    contentProps: {
+      role: "presentation",
+      style: l
+    }
+  };
+}
+function _e(n) {
+  let { layoutInfo: e, virtualizer: t, ref: i } = n, l = e == null ? void 0 : e.key, o = z(() => {
+    if (l != null && i.current) {
+      let s = Ce(i.current);
+      t.updateItemSize(l, s);
+    }
+  }, [
+    t,
+    l,
+    i
+  ]);
+  return V(() => {
+    e != null && e.estimatedSize && o();
+  }), {
+    updateSize: o
+  };
+}
+function Ce(n) {
+  let e = n.style.height;
+  n.style.height = "";
+  let t = new H(n.scrollWidth, n.scrollHeight);
+  return n.style.height = e, t;
+}
+function J(n) {
+  let { style: e, className: t, layoutInfo: i, virtualizer: l, parent: o, children: s } = n, { direction: a } = U(), h = C(null);
+  return _e({
+    layoutInfo: i,
+    virtualizer: l,
+    ref: h
+  }), /* @__PURE__ */ w.createElement("div", {
+    role: "presentation",
+    ref: h,
+    className: t,
+    style: {
+      ...ke(i, a, o),
+      ...e
+    }
+  }, s);
+}
+let X = /* @__PURE__ */ new WeakMap();
+function ke(n, e, t) {
+  let i = e === "rtl" ? "right" : "left", l = X.get(n);
+  if (l && l[i] != null) {
+    if (!t) return l;
+    let h = n.rect.y - t.rect.y, r = n.rect.x - t.rect.x;
+    if (l.top === h && l[i] === r) return l;
+  }
+  let o = {
+    // TODO: For layoutInfos that are sticky that have parents with overflow visible, their "top" will be relative to the to the nearest scrolling container
+    // which WON'T be the parent since the parent has overflow visible. This means we shouldn't offset the height by the parent's position
+    // Not 100% about this change here since it is quite ambigious what the scrolling container maybe and how its top is positioned with respect to the
+    // calculated layoutInfo.y here
+    top: n.rect.y - (t && !(t.allowOverflow && n.isSticky) ? t.rect.y : 0),
+    [i]: n.rect.x - (t && !(t.allowOverflow && n.isSticky) ? t.rect.x : 0),
+    width: n.rect.width,
+    height: n.rect.height
+  };
+  Object.entries(o).forEach(([h, r]) => {
+    Number.isFinite(r) || (o[h] = void 0);
+  });
+  var s;
+  let a = {
+    position: n.isSticky ? "sticky" : "absolute",
+    // Sticky elements are positioned in normal document flow. Display inline-block so that they don't push other sticky columns onto the following rows.
+    display: n.isSticky ? "inline-block" : void 0,
+    overflow: n.allowOverflow ? "visible" : "hidden",
+    opacity: n.opacity,
+    zIndex: n.zIndex,
+    transform: (s = n.transform) !== null && s !== void 0 ? s : void 0,
+    contain: "size layout style",
+    ...o
+  };
+  return X.set(n, a), a;
+}
+const Q = /* @__PURE__ */ F(null), Z = /* @__PURE__ */ F(null);
+function Le(n) {
+  let { children: e, layout: t, layoutOptions: i } = n, l = L(() => typeof t == "function" ? new t() : t, [
+    t
+  ]), o = L(() => ({
+    isVirtualized: !0,
+    layoutDelegate: l,
+    dropTargetDelegate: l.getDropTargetFromPoint ? l : void 0,
+    CollectionRoot: Ne,
+    CollectionBranch: Te
+  }), [
+    l
+  ]);
+  return /* @__PURE__ */ w.createElement(he.Provider, {
+    value: o
+  }, /* @__PURE__ */ w.createElement(Z.Provider, {
+    value: {
+      layout: l,
+      layoutOptions: i
+    }
+  }, e));
+}
+function Ne({ collection: n, persistedKeys: e, scrollRef: t, renderDropIndicator: i }) {
+  var l;
+  let { layout: o, layoutOptions: s } = j(Z), a = (l = o.useLayoutOptions) === null || l === void 0 ? void 0 : l.call(o), h = Re({
+    layout: o,
+    collection: n,
+    renderView: (d, c) => {
+      var u;
+      return c == null || (u = c.render) === null || u === void 0 ? void 0 : u.call(c, c);
+    },
+    onVisibleRectChange(d) {
+      let c = t == null ? void 0 : t.current;
+      c && (c.scrollLeft = d.x, c.scrollTop = d.y);
+    },
+    persistedKeys: e,
+    layoutOptions: L(() => s && a ? {
+      ...s,
+      ...a
+    } : s || a, [
+      s,
+      a
+    ])
+  }), { contentProps: r } = He({
+    onVisibleRectChange: h.setVisibleRect,
+    contentSize: h.contentSize,
+    onScrollStart: h.startScrolling,
+    onScrollEnd: h.endScrolling
+  }, t);
+  return /* @__PURE__ */ w.createElement("div", r, /* @__PURE__ */ w.createElement(Q.Provider, {
+    value: h
+  }, ee(null, h.visibleViews, i)));
+}
+function Te({ parent: n, renderDropIndicator: e }) {
+  let i = j(Q).virtualizer.getVisibleView(n.key);
+  return ee(i, Array.from(i.children), e);
+}
+function ee(n, e, t) {
+  return e.map((i) => Ee(n, i, t));
+}
+function Ee(n, e, t) {
+  let i = /* @__PURE__ */ w.createElement(J, {
+    key: e.key,
+    layoutInfo: e.layoutInfo,
+    virtualizer: e.virtualizer,
+    parent: n == null ? void 0 : n.layoutInfo
+  }, e.rendered), { collection: l, layout: o } = e.virtualizer, s = e.content;
+  return (s == null ? void 0 : s.type) === "item" && t && o.getDropTargetLayoutInfo && (i = /* @__PURE__ */ w.createElement(w.Fragment, {
+    key: e.key
+  }, A(n, e, {
+    type: "item",
+    key: e.content.key,
+    dropPosition: "before"
+  }, t), i, de(l, s, (a) => A(n, e, a, t)))), i;
+}
+function A(n, e, t, i) {
+  let l = i(t);
+  if (l) {
+    let o = e.virtualizer.layout.getDropTargetLayoutInfo(t);
+    l = /* @__PURE__ */ w.createElement(J, {
+      layoutInfo: o,
+      virtualizer: e.virtualizer,
+      parent: n == null ? void 0 : n.layoutInfo
+    }, l);
+  }
+  return l;
+}
+class Ve extends Se {
+  /**
+   * When using the ListLayout our scroll container height is not calculated properly when the content is partially sectioned.
+   * ```ts
+   * const partiallySectionedContent = [
+   *  {
+   *    name: 'fruit section',
+   *    children: [{ id: 'kiwi', name: 'Kiwi' }]
+   *  },
+   *  // berries have no section, because it's optional
+   *  { id: 'lingonberries', name: 'Lingonberries' }
+   * ];
+   * ```
+   * If we load the layout info for each key in the collection the calculation is correct.
+   *
+   * This might not be optional for performance, FYI
+   */
+  getContentSize() {
+    var t;
+    const e = (t = this == null ? void 0 : this.virtualizer) == null ? void 0 : t.collection.getKeys();
+    return Array.from(e || []).forEach((i) => {
+      this.getLayoutInfo(i);
+    }), this.contentSize;
+  }
+}
+const Me = "_listBox_1ns4v_7", Oe = "_listBoxPopover_1ns4v_19", Pe = "_listBoxSectionHeading_1ns4v_34", Be = "_listBoxButton_1ns4v_44", Ke = "_listBoxItem_1ns4v_56", qe = "_listBoxLoadMoreItem_1ns4v_101", M = {
+  listBox: Me,
+  listBoxPopover: Oe,
+  listBoxSectionHeading: Pe,
+  listBoxButton: Be,
+  listBoxItem: Ke,
+  listBoxLoadMoreItem: qe
+}, tt = ({
+  className: n,
+  children: e,
+  ...t
+}) => /* @__PURE__ */ k(
+  Le,
+  {
+    layout: Ve,
+    layoutOptions: {
+      headingHeight: 44
+    },
+    children: /* @__PURE__ */ k(
+      se,
+      {
+        className: K(M.listBox, n),
+        ...t,
+        children: e
+      }
+    )
+  }
+), it = ({
+  children: n,
+  className: e,
+  ...t
+}) => /* @__PURE__ */ k(
+  re,
+  {
+    className: K(M.listBoxItem, e),
+    ...t,
+    children: n
+  }
+), lt = ({
+  className: n,
+  children: e,
+  ...t
+}) => /* @__PURE__ */ k(
+  ge,
+  {
+    className: K(n, M.listBoxPopover),
+    offset: 0,
+    ...t,
+    children: e
+  }
+), ot = ({
+  children: n,
+  name: e,
+  ...t
+}) => /* @__PURE__ */ ne(ae, { ...t, children: [
+  /* @__PURE__ */ k(ye, { className: M.listBoxSectionHeading, children: e }),
+  n
+] });
+export {
+  tt as L,
+  it as a,
+  lt as b,
+  ot as c,
+  M as s
+};