react-window 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/react-window.js

@@ -1,7 +1,7 @@
-import { jsx as j } from "react/jsx-runtime";
-import { useLayoutEffect as J, useEffect as W, useMemo as H, useState as L, useCallback as P, memo as V, useImperativeHandle as F, createElement as N, useRef as Y } from "react";
-const q = typeof window < "u" ? J : W;
-function B(t) {
+import { jsx as R } from "react/jsx-runtime";
+import { useLayoutEffect as Y, useEffect as U, useMemo as H, useState as L, useRef as W, useCallback as G, memo as q, useImperativeHandle as A, createElement as _ } from "react";
+const V = typeof window < "u" ? Y : U;
+function F(t) {
   if (t !== void 0)
     switch (typeof t) {
       case "number":
@@ -15,39 +15,39 @@ function B(t) {
 }
 function K({
   box: t,
-  defaultHeight: r,
-  defaultWidth: l,
-  disabled: s,
+  defaultHeight: s,
+  defaultWidth: n,
+  disabled: r,
   element: e,
   mode: f,
-  style: n
+  style: i
 }) {
   const { styleHeight: c, styleWidth: o } = H(
     () => ({
-      styleHeight: B(n?.height),
-      styleWidth: B(n?.width)
+      styleHeight: F(i?.height),
+      styleWidth: F(i?.width)
     }),
-    [n?.height, n?.width]
-  ), [u, w] = L({
-    height: r,
-    width: l
-  }), I = s || f === "only-height" && c !== void 0 || f === "only-width" && o !== void 0 || c !== void 0 && o !== void 0;
-  return q(() => {
-    if (e === null || I)
+    [i?.height, i?.width]
+  ), [u, m] = L({
+    height: s,
+    width: n
+  }), z = r || f === "only-height" && c !== void 0 || f === "only-width" && o !== void 0 || c !== void 0 && o !== void 0;
+  return V(() => {
+    if (e === null || z)
       return;
-    const O = new ResizeObserver((S) => {
-      for (const m of S) {
-        const { contentRect: d, target: b } = m;
-        e === b && w((a) => a.height === d.height && a.width === d.width ? a : {
-          height: d.height,
-          width: d.width
+    const O = new ResizeObserver((x) => {
+      for (const v of x) {
+        const { contentRect: w, target: I } = v;
+        e === I && m((h) => h.height === w.height && h.width === w.width ? h : {
+          height: w.height,
+          width: w.width
         });
       }
     });
     return O.observe(e, { box: t }), () => {
       O?.unobserve(e);
     };
-  }, [t, I, e, c, o]), H(
+  }, [t, z, e, c, o]), H(
     () => ({
       height: c ?? u.height,
       width: o ?? u.width
@@ -55,39 +55,47 @@ function K({
     [u, c, o]
   );
 }
-function $(t, r = "Assertion error") {
+function Q(t) {
+  const s = W(() => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  return V(() => {
+    s.current = t;
+  }, [t]), G((n) => s.current?.(n), [s]);
+}
+function $(t, s = "Assertion error") {
   if (!t)
-    throw console.error(r), Error(r);
+    throw console.error(s), Error(s);
 }
-function Q({
+function X({
   cachedBounds: t,
-  itemCount: r,
-  itemSize: l
+  itemCount: s,
+  itemSize: n
 }) {
-  if (typeof l == "number")
-    return r * l;
+  if (typeof n == "number")
+    return s * n;
   if (t.size > 0) {
-    const s = t.get(t.size - 1);
-    $(s !== void 0, "Unexpected bounds cache miss");
-    const e = (s.scrollOffset + s.size) / t.size;
-    return r * e;
+    const r = t.get(t.size - 1);
+    $(r !== void 0, "Unexpected bounds cache miss");
+    const e = (r.scrollOffset + r.size) / t.size;
+    return s * e;
   } else
     return 0;
 }
-function X({
+function Z({
   align: t,
-  cachedBounds: r,
-  index: l,
-  itemCount: s,
+  cachedBounds: s,
+  index: n,
+  itemCount: r,
   containerScrollOffset: e,
   containerSize: f
 }) {
-  const n = r.get(s - 1).scrollOffset, c = n + n - f, o = Math.max(
+  const i = s.get(r - 1).scrollOffset, c = i + i - f, o = Math.max(
     0,
-    r.get(l + 1).scrollOffset - f
+    s.get(n + 1).scrollOffset - f
   ), u = Math.min(
-    n,
-    r.get(l).scrollOffset
+    i,
+    s.get(n).scrollOffset
   );
   switch (t === "smart" && (e >= o && e <= u ? t = "auto" : t = "center"), t) {
     case "start":
@@ -95,494 +103,509 @@ function X({
     case "end":
       return o;
     case "center": {
-      const w = Math.round(
+      const m = Math.round(
         o + (u - o) / 2
       );
-      return w < Math.ceil(f / 2) ? 0 : w > c ? c : w;
+      return m < Math.ceil(f / 2) ? 0 : m > c ? c : m;
     }
     case "auto":
     default:
       return e >= o && e <= u ? e : e < o ? o : u;
   }
 }
-function Z({
+function tt({
   cachedBounds: t,
-  containerScrollOffset: r,
-  containerSize: l,
-  itemCount: s,
+  containerScrollOffset: s,
+  containerSize: n,
+  itemCount: r,
   overscanCount: e
 }) {
-  const f = s - 1;
-  let n = 0, c = -1, o = 0;
+  const f = r - 1;
+  let i = 0, c = -1, o = 0;
   for (; o < f; ) {
     const u = t.get(o);
-    if (u.scrollOffset + u.size > r)
+    if (u.scrollOffset + u.size > s)
       break;
     o++;
   }
-  for (n = o, n = Math.max(0, n - e); o < f; ) {
+  for (i = o, i = Math.max(0, i - e); o < f; ) {
     const u = t.get(o);
-    if (u.scrollOffset + u.size >= r + l)
+    if (u.scrollOffset + u.size >= s + n)
       break;
     o++;
   }
-  return c = Math.min(f, o), c = Math.min(s - 1, c + e), n < 0 ? [0, -1] : [n, c];
+  return c = Math.min(f, o), c = Math.min(r - 1, c + e), i < 0 ? [0, -1] : [i, c];
 }
-function C({
+function et({
   itemCount: t,
-  itemProps: r,
-  itemSize: l
+  itemProps: s,
+  itemSize: n
 }) {
-  const s = /* @__PURE__ */ new Map();
+  const r = /* @__PURE__ */ new Map();
   return {
     get(e) {
-      for ($(e < t, `Invalid index ${e}`); s.size - 1 < e; ) {
-        const n = s.size, c = typeof l == "number" ? l : l(n, r);
-        if (n === 0)
-          s.set(n, {
+      for ($(e < t, `Invalid index ${e}`); r.size - 1 < e; ) {
+        const i = r.size, c = typeof n == "number" ? n : n(i, s);
+        if (i === 0)
+          r.set(i, {
             size: c,
             scrollOffset: 0
           });
         else {
-          const o = s.get(n - 1);
+          const o = r.get(i - 1);
           $(
             o !== void 0,
             `Unexpected bounds cache miss for index ${e}`
-          ), s.set(n, {
+          ), r.set(i, {
             scrollOffset: o.scrollOffset + o.size,
             size: c
           });
         }
       }
-      const f = s.get(e);
+      const f = r.get(e);
       return $(
         f !== void 0,
         `Unexpected bounds cache miss for index ${e}`
       ), f;
     },
     set(e, f) {
-      s.set(e, f);
+      r.set(e, f);
     },
     get size() {
-      return s.size;
+      return r.size;
     }
   };
 }
-function tt({
+function st({
   itemCount: t,
-  itemProps: r,
-  itemSize: l
+  itemProps: s,
+  itemSize: n
 }) {
   return H(
-    () => C({
+    () => et({
       itemCount: t,
-      itemProps: r,
-      itemSize: l
+      itemProps: s,
+      itemSize: n
     }),
-    [t, r, l]
+    [t, s, n]
   );
 }
-function G({
+function B({
   containerElement: t,
-  containerStyle: r,
-  defaultContainerSize: l = 0,
-  direction: s,
+  containerStyle: s,
+  defaultContainerSize: n = 0,
+  direction: r,
   itemCount: e,
   itemProps: f,
-  itemSize: n,
-  overscanCount: c
+  itemSize: i,
+  onResize: c,
+  overscanCount: o
 }) {
-  const [o, u] = L([0, -1]), [w, I] = [
-    Math.min(e - 1, o[0]),
-    Math.min(e - 1, o[1])
-  ], { height: O = l, width: S = l } = K({
-    defaultHeight: s === "vertical" ? l : void 0,
-    defaultWidth: s === "horizontal" ? l : void 0,
+  const [u, m] = L([0, -1]), [z, O] = [
+    Math.min(e - 1, u[0]),
+    Math.min(e - 1, u[1])
+  ], { height: x = n, width: v = n } = K({
+    defaultHeight: r === "vertical" ? n : void 0,
+    defaultWidth: r === "horizontal" ? n : void 0,
     element: t,
-    mode: s === "vertical" ? "only-height" : "only-width",
-    style: r
-  }), m = s === "vertical" ? O : S, d = tt({
+    mode: r === "vertical" ? "only-height" : "only-width",
+    style: s
+  }), w = W({
+    height: 0,
+    width: 0
+  });
+  Y(() => {
+    if (typeof c == "function") {
+      const l = w.current;
+      (l.height !== x || l.width !== v) && (c({ height: x, width: v }, { ...l }), l.height = x, l.width = v);
+    }
+  }, [x, c, v]);
+  const I = r === "vertical" ? x : v, h = st({
     itemCount: e,
     itemProps: f,
-    itemSize: n
-  }), b = P(
-    (i) => d.get(i),
-    [d]
-  ), a = P(
-    () => Q({
-      cachedBounds: d,
+    itemSize: i
+  }), y = G(
+    (l) => h.get(l),
+    [h]
+  ), P = G(
+    () => X({
+      cachedBounds: h,
       itemCount: e,
-      itemSize: n
+      itemSize: i
     }),
-    [d, e, n]
-  ), M = P(
-    (i) => Z({
-      cachedBounds: d,
-      containerScrollOffset: i,
-      containerSize: m,
+    [h, e, i]
+  ), a = G(
+    (l) => tt({
+      cachedBounds: h,
+      containerScrollOffset: l,
+      containerSize: I,
       itemCount: e,
-      overscanCount: c
+      overscanCount: o
     }),
-    [d, m, e, c]
+    [h, I, e, o]
   );
-  q(() => {
-    const i = (s === "vertical" ? t?.scrollTop : t?.scrollLeft) ?? 0;
-    u(M(i));
-  }, [t, s, M]);
-  const g = P(
+  V(() => {
+    const l = (r === "vertical" ? t?.scrollTop : t?.scrollLeft) ?? 0;
+    m(a(l));
+  }, [t, r, a]);
+  const d = Q(
     ({
-      align: i = "auto",
-      behavior: p = "auto",
-      containerScrollOffset: z,
-      index: x
+      align: l = "auto",
+      behavior: T = "auto",
+      containerScrollOffset: p,
+      index: g
     }) => {
-      const h = X({
-        align: i,
-        cachedBounds: d,
-        containerScrollOffset: z,
-        containerSize: m,
-        index: x,
+      const k = Z({
+        align: l,
+        cachedBounds: h,
+        containerScrollOffset: p,
+        containerSize: I,
+        index: g,
         itemCount: e
       });
-      s === "horizontal" ? t?.scrollTo({
-        left: h,
-        behavior: p || void 0
+      r === "horizontal" ? t?.scrollTo({
+        left: k,
+        behavior: T || void 0
       }) : t?.scrollTo({
-        behavior: p || void 0,
-        top: h
+        behavior: T || void 0,
+        top: k
       });
-    },
-    [d, t, m, s, e]
+    }
   );
   return {
-    getCellBounds: b,
-    getEstimatedHeight: a,
+    getCellBounds: y,
+    getEstimatedHeight: P,
     onScroll: () => {
-      const i = M(
-        (s === "vertical" ? t?.scrollTop : t?.scrollLeft) ?? 0
+      const l = a(
+        (r === "vertical" ? t?.scrollTop : t?.scrollLeft) ?? 0
       );
-      (i[0] !== w || i[1] !== I) && u(i);
+      (l[0] !== z || l[1] !== O) && m(l);
     },
-    scrollToIndex: g,
-    startIndex: w,
-    stopIndex: I
+    scrollToIndex: d,
+    startIndex: z,
+    stopIndex: O
   };
 }
-function A(t) {
+function C(t) {
   return H(() => t, Object.values(t));
 }
-function U(t, r) {
-  if (t === r)
+function N(t, s) {
+  if (t === s)
     return !0;
-  if (!!t != !!r || ($(t !== void 0), $(r !== void 0), Object.keys(t).length !== Object.keys(r).length))
+  if (!!t != !!s || ($(t !== void 0), $(s !== void 0), Object.keys(t).length !== Object.keys(s).length))
     return !1;
-  for (const l in t)
-    if (!Object.is(r[l], t[l]))
+  for (const n in t)
+    if (!Object.is(s[n], t[n]))
       return !1;
   return !0;
 }
-function _(t, r) {
-  const { style: l, ...s } = t, { style: e, ...f } = r;
-  return U(l, e) && U(s, f);
+function D(t, s) {
+  const { style: n, ...r } = t, { style: e, ...f } = s;
+  return N(n, e) && N(r, f);
 }
-const D = () => {
+const J = () => {
 };
-function ot({
+function nt({
   cellComponent: t,
-  cellProps: r,
-  className: l,
-  columnCount: s,
+  cellProps: s,
+  className: n,
+  columnCount: r,
   columnWidth: e,
   defaultHeight: f = 0,
-  defaultWidth: n = 0,
+  defaultWidth: i = 0,
   gridRef: c,
   onCellsRendered: o,
-  onScroll: u = D,
-  overscanCount: w = 3,
-  rowCount: I,
-  rowHeight: O,
-  style: S,
-  ...m
+  onResize: u,
+  onScroll: m = J,
+  overscanCount: z = 3,
+  rowCount: O,
+  rowHeight: x,
+  style: v,
+  ...w
 }) {
-  const d = A(r), b = H(
-    () => V(t, _),
+  const I = C(s), h = H(
+    () => q(t, D),
     [t]
-  ), [a, M] = L(null), g = G({
-    containerElement: a,
-    defaultContainerSize: n,
+  ), [y, P] = L(null), a = B({
+    containerElement: y,
+    defaultContainerSize: i,
     direction: "horizontal",
-    itemCount: s,
-    itemProps: d,
+    itemCount: r,
+    itemProps: I,
     itemSize: e,
-    overscanCount: w
-  }), i = G({
-    containerElement: a,
+    onResize: u,
+    overscanCount: z
+  }), d = B({
+    containerElement: y,
     defaultContainerSize: f,
     direction: "vertical",
-    itemCount: I,
-    itemProps: d,
-    itemSize: O,
-    overscanCount: w
-  }), { startIndex: p, stopIndex: z } = g, { startIndex: x, stopIndex: h } = i;
-  F(
+    itemCount: O,
+    itemProps: I,
+    itemSize: x,
+    onResize: u,
+    overscanCount: z
+  }), { startIndex: l, stopIndex: T } = a, { startIndex: p, stopIndex: g } = d;
+  A(
     c,
     () => ({
       get element() {
-        return a;
+        return y;
       },
       scrollToCell({
-        behavior: v = "auto",
-        columnAlign: y = "auto",
-        columnIndex: T,
-        rowAlign: k = "auto",
-        rowIndex: R
+        behavior: b = "auto",
+        columnAlign: S = "auto",
+        columnIndex: E,
+        rowAlign: M = "auto",
+        rowIndex: j
       }) {
-        i?.scrollToIndex({
-          align: k,
-          behavior: v,
-          containerScrollOffset: a?.scrollTop ?? 0,
-          index: R
-        }), g?.scrollToIndex({
-          align: y,
-          behavior: v,
-          containerScrollOffset: a?.scrollLeft ?? 0,
-          index: T
+        d?.scrollToIndex({
+          align: M,
+          behavior: b,
+          containerScrollOffset: y?.scrollTop ?? 0,
+          index: j
+        }), a?.scrollToIndex({
+          align: S,
+          behavior: b,
+          containerScrollOffset: y?.scrollLeft ?? 0,
+          index: E
         });
       },
       scrollToColumn({
-        align: v = "auto",
-        behavior: y = "auto",
-        index: T
+        align: b = "auto",
+        behavior: S = "auto",
+        index: E
       }) {
-        g?.scrollToIndex({
-          align: v,
-          behavior: y,
-          containerScrollOffset: a?.scrollLeft ?? 0,
-          index: T
+        a?.scrollToIndex({
+          align: b,
+          behavior: S,
+          containerScrollOffset: y?.scrollLeft ?? 0,
+          index: E
         });
       },
       scrollToRow({
-        align: v = "auto",
-        behavior: y = "auto",
-        index: T
+        align: b = "auto",
+        behavior: S = "auto",
+        index: E
       }) {
-        i?.scrollToIndex({
-          align: v,
-          behavior: y,
-          containerScrollOffset: a?.scrollTop ?? 0,
-          index: T
+        d?.scrollToIndex({
+          align: b,
+          behavior: S,
+          containerScrollOffset: y?.scrollTop ?? 0,
+          index: E
         });
       }
     }),
-    [g, a, i]
-  ), W(() => {
-    p >= 0 && z >= 0 && x >= 0 && h >= 0 && o && o({
-      columnStartIndex: p,
-      columnStopIndex: z,
-      rowStartIndex: x,
-      rowStopIndex: h
+    [a, y, d]
+  ), U(() => {
+    l >= 0 && T >= 0 && p >= 0 && g >= 0 && o && o({
+      columnStartIndex: l,
+      columnStopIndex: T,
+      rowStartIndex: p,
+      rowStopIndex: g
     });
   }, [
     o,
+    l,
+    T,
     p,
-    z,
-    x,
-    h
+    g
   ]);
-  const E = H(() => {
-    const v = [];
-    if (g && s > 0 && i && I > 0)
-      for (let y = x; y <= h; y++) {
-        const T = i.getCellBounds(y);
-        for (let k = p; k <= z; k++) {
-          const R = g.getCellBounds(k);
-          v.push(
-            /* @__PURE__ */ N(
-              b,
+  const k = H(() => {
+    const b = [];
+    if (a && r > 0 && d && O > 0)
+      for (let S = p; S <= g; S++) {
+        const E = d.getCellBounds(S);
+        for (let M = l; M <= T; M++) {
+          const j = a.getCellBounds(M);
+          b.push(
+            /* @__PURE__ */ _(
+              h,
               {
-                ...d,
-                columnIndex: k,
-                key: `${y}-${k}`,
-                rowIndex: y,
+                ...I,
+                columnIndex: M,
+                key: `${S}-${M}`,
+                rowIndex: S,
                 style: {
                   position: "absolute",
                   left: 0,
-                  transform: `translate(${R.scrollOffset}px, ${T.scrollOffset}px)`,
-                  height: T.size,
-                  width: R.size
+                  transform: `translate(${j.scrollOffset}px, ${E.scrollOffset}px)`,
+                  height: E.size,
+                  width: j.size
                 }
               }
             )
           );
         }
       }
-    return v;
+    return b;
   }, [
-    b,
-    d,
-    s,
+    h,
+    I,
+    r,
+    l,
+    T,
+    a,
+    O,
     p,
-    z,
     g,
-    I,
-    x,
-    h,
-    i
+    d
   ]);
-  return /* @__PURE__ */ j(
+  return /* @__PURE__ */ R(
     "div",
     {
       role: "grid",
-      ...m,
-      className: l,
-      onScroll: (v) => {
-        g.onScroll(), i.onScroll(), u(v);
+      ...w,
+      className: n,
+      onScroll: (b) => {
+        a.onScroll(), d.onScroll(), m(b);
       },
-      ref: M,
+      ref: P,
       style: {
-        ...S,
+        ...v,
         maxHeight: "100%",
         maxWidth: "100%",
         flexGrow: 1,
         overflow: "auto"
       },
-      children: /* @__PURE__ */ j(
+      children: /* @__PURE__ */ R(
         "div",
         {
-          className: l,
+          className: n,
           style: {
             position: "relative",
-            height: i?.getEstimatedHeight(),
-            width: g?.getEstimatedHeight()
+            height: d?.getEstimatedHeight(),
+            width: a?.getEstimatedHeight()
           },
-          children: E
+          children: k
         }
       )
     }
   );
 }
-const rt = L, lt = Y;
-function nt({
+const lt = L, it = W;
+function ct({
   className: t,
-  defaultHeight: r = 0,
-  listRef: l,
-  onRowsRendered: s,
-  onScroll: e = D,
-  overscanCount: f = 3,
-  rowComponent: n,
-  rowCount: c,
-  rowHeight: o,
-  rowProps: u,
-  style: w,
-  ...I
+  defaultHeight: s = 0,
+  listRef: n,
+  onResize: r,
+  onRowsRendered: e,
+  onScroll: f = J,
+  overscanCount: i = 3,
+  rowComponent: c,
+  rowCount: o,
+  rowHeight: u,
+  rowProps: m,
+  style: z,
+  ...O
 }) {
-  const O = A(u), S = H(
-    () => V(n, _),
-    [n]
-  ), [m, d] = L(null), {
-    getCellBounds: b,
-    getEstimatedHeight: a,
-    onScroll: M,
-    scrollToIndex: g,
-    startIndex: i,
-    stopIndex: p
-  } = G({
-    containerElement: m,
-    defaultContainerSize: r,
+  const x = C(m), v = H(
+    () => q(c, D),
+    [c]
+  ), [w, I] = L(null), {
+    getCellBounds: h,
+    getEstimatedHeight: y,
+    onScroll: P,
+    scrollToIndex: a,
+    startIndex: d,
+    stopIndex: l
+  } = B({
+    containerElement: w,
+    defaultContainerSize: s,
     direction: "vertical",
-    itemCount: c,
-    itemProps: O,
-    itemSize: o,
-    overscanCount: f
+    itemCount: o,
+    itemProps: x,
+    itemSize: u,
+    onResize: r,
+    overscanCount: i
   });
-  F(
-    l,
+  A(
+    n,
     () => ({
       get element() {
-        return m;
+        return w;
       },
       scrollToRow({
-        align: x = "auto",
-        behavior: h = "auto",
-        index: E
+        align: p = "auto",
+        behavior: g = "auto",
+        index: k
       }) {
-        g({
-          align: x,
-          behavior: h,
-          containerScrollOffset: m?.scrollTop ?? 0,
-          index: E
+        a({
+          align: p,
+          behavior: g,
+          containerScrollOffset: w?.scrollTop ?? 0,
+          index: k
         });
       }
     }),
-    [m, g]
-  ), W(() => {
-    i >= 0 && p >= 0 && s && s({
-      startIndex: i,
-      stopIndex: p
+    [w, a]
+  ), U(() => {
+    d >= 0 && l >= 0 && e && e({
+      startIndex: d,
+      stopIndex: l
     });
-  }, [s, i, p]);
-  const z = H(() => {
-    const x = [];
-    if (c > 0)
-      for (let h = i; h <= p; h++) {
-        const E = b(h);
-        x.push(
-          /* @__PURE__ */ N(
-            S,
+  }, [e, d, l]);
+  const T = H(() => {
+    const p = [];
+    if (o > 0)
+      for (let g = d; g <= l; g++) {
+        const k = h(g);
+        p.push(
+          /* @__PURE__ */ _(
+            v,
             {
-              ...O,
-              key: h,
-              index: h,
+              ...x,
+              key: g,
+              index: g,
               style: {
                 position: "absolute",
                 left: 0,
-                transform: `translateY(${E.scrollOffset}px)`,
-                height: E.size,
+                transform: `translateY(${k.scrollOffset}px)`,
+                height: k.size,
                 width: "100%"
               }
             }
           )
         );
       }
-    return x;
-  }, [S, b, c, O, i, p]);
-  return /* @__PURE__ */ j(
+    return p;
+  }, [v, h, o, x, d, l]);
+  return /* @__PURE__ */ R(
     "div",
     {
       role: "list",
-      ...I,
+      ...O,
       className: t,
-      onScroll: (x) => {
-        M(), e(x);
+      onScroll: (p) => {
+        P(), f(p);
       },
-      ref: d,
+      ref: I,
       style: {
-        ...w,
+        ...z,
         maxHeight: "100%",
         flexGrow: 1,
         overflowY: "auto"
       },
-      children: /* @__PURE__ */ j(
+      children: /* @__PURE__ */ R(
         "div",
         {
           className: t,
           style: {
-            height: a(),
+            height: y(),
             position: "relative",
             width: "100%"
           },
-          children: z
+          children: T
         }
       )
     }
   );
 }
-const it = L, ct = Y;
+const ft = L, ut = W;
 export {
-  ot as Grid,
-  nt as List,
-  rt as useGridCallbackRef,
-  lt as useGridRef,
-  it as useListCallbackRef,
-  ct as useListRef
+  nt as Grid,
+  ct as List,
+  lt as useGridCallbackRef,
+  it as useGridRef,
+  ft as useListCallbackRef,
+  ut as useListRef
 };