@jetbrains/ring-ui-built 7.0.114 → 8.0.0-beta.2

package/components/table/table-component.js

@@ -0,0 +1,316 @@
+import { c } from 'react-compiler-runtime';
+import { useRef } from 'react';
+import classNames from 'classnames';
+import { IntersectionObserverContext } from '../global/intersection-observer-context.js';
+import { useTableVirtualize, SpacerRow } from './table-virtualize.js';
+import { DefaultItemRenderer } from './default-item-renderer.js';
+import { defaultMinScrollAndResizeDeltaPx, defaultRetentionMarginPx, defaultLookaheadPx, TablePropsContext, CollapseItemIntoSpacerContext, defaultRowHeight, ColumnIndexContext } from './table-const.js';
+import { s as styles } from '../_helpers/table.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import '../global/use-event-callback.js';
+import './table-base.js';
+import '@jetbrains/icons/unsorted-12px';
+import '@jetbrains/icons/arrow-12px-down';
+import '@jetbrains/icons/arrow-12px-up';
+import '@jetbrains/icons/trash-12px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon.constants.js';
+import '../_helpers/icon-svg.js';
+import '../global/memoize.js';
+
+function Table(props) {
+  var _userRef;
+  const $ = c(66);
+  if ($[0] !== "c5cbf342ef76906cf21ee6f16da41c5d4e7db7a707456ae37dfa4f28ed5d910a") {
+    for (let $i = 0; $i < 66; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "c5cbf342ef76906cf21ee6f16da41c5d4e7db7a707456ae37dfa4f28ed5d910a";
+  }
+  let className;
+  let columns;
+  let data;
+  let renderItem;
+  let restProps;
+  let scrollerRef;
+  let t0;
+  let t1;
+  let t2;
+  let t3;
+  let t4;
+  let tbodyClassName;
+  let theadClassName;
+  let theadTrClassName;
+  let userRef;
+  if ($[1] !== props) {
+    const {
+      data: t5,
+      columns: t6,
+      getKey,
+      selection,
+      isItemKeyboardFocusable,
+      onItemFocus,
+      onItemMove,
+      onSort,
+      onColumnDelete,
+      onColumnMove,
+      renderItem: t7,
+      virtualizeRows: t8,
+      scrollerRef: t9,
+      estimateHeight: t10,
+      lookaheadPx: t11,
+      retentionMarginPx: t12,
+      minScrollAndResizeDeltaPx: t13,
+      columnEditButton,
+      ref: t14,
+      className: t15,
+      theadClassName: t16,
+      theadTrClassName: t17,
+      tbodyClassName: t18,
+      ...t19
+    } = props;
+    data = t5;
+    columns = t6;
+    renderItem = t7;
+    t0 = t8;
+    scrollerRef = t9;
+    t1 = t10;
+    t2 = t11;
+    t3 = t12;
+    t4 = t13;
+    userRef = t14;
+    className = t15;
+    theadClassName = t16;
+    theadTrClassName = t17;
+    tbodyClassName = t18;
+    restProps = t19;
+    $[1] = props;
+    $[2] = className;
+    $[3] = columns;
+    $[4] = data;
+    $[5] = renderItem;
+    $[6] = restProps;
+    $[7] = scrollerRef;
+    $[8] = t0;
+    $[9] = t1;
+    $[10] = t2;
+    $[11] = t3;
+    $[12] = t4;
+    $[13] = tbodyClassName;
+    $[14] = theadClassName;
+    $[15] = theadTrClassName;
+    $[16] = userRef;
+  } else {
+    className = $[2];
+    columns = $[3];
+    data = $[4];
+    renderItem = $[5];
+    restProps = $[6];
+    scrollerRef = $[7];
+    t0 = $[8];
+    t1 = $[9];
+    t2 = $[10];
+    t3 = $[11];
+    t4 = $[12];
+    tbodyClassName = $[13];
+    theadClassName = $[14];
+    theadTrClassName = $[15];
+    userRef = $[16];
+  }
+  const virtualizeRows = t0 === undefined ? false : t0;
+  const estimateHeight = t1 === undefined ? _temp : t1;
+  const lookaheadPx = t2 === undefined ? defaultLookaheadPx : t2;
+  const retentionMarginPx = t3 === undefined ? defaultRetentionMarginPx : t3;
+  const minScrollAndResizeDeltaPx = t4 === undefined ? defaultMinScrollAndResizeDeltaPx : t4;
+  const selfRef = useRef(null);
+  const tableRef = (_userRef = userRef) !== null && _userRef !== void 0 ? _userRef : selfRef;
+  let t5;
+  if ($[17] !== data.length || $[18] !== estimateHeight || $[19] !== lookaheadPx || $[20] !== minScrollAndResizeDeltaPx || $[21] !== retentionMarginPx || $[22] !== scrollerRef || $[23] !== tableRef || $[24] !== virtualizeRows) {
+    t5 = {
+      enabled: virtualizeRows,
+      length: data.length,
+      scrollerRef,
+      tableRef,
+      estimateHeight,
+      lookaheadPx,
+      retentionMarginPx,
+      minScrollAndResizeDeltaPx
+    };
+    $[17] = data.length;
+    $[18] = estimateHeight;
+    $[19] = lookaheadPx;
+    $[20] = minScrollAndResizeDeltaPx;
+    $[21] = retentionMarginPx;
+    $[22] = scrollerRef;
+    $[23] = tableRef;
+    $[24] = virtualizeRows;
+    $[25] = t5;
+  } else {
+    t5 = $[25];
+  }
+  const {
+    virtualItems,
+    intersectionObserverHandle,
+    collapseItemIntoSpacer
+  } = useTableVirtualize(t5);
+  let t6;
+  if ($[26] !== className) {
+    t6 = classNames(styles.table, className);
+    $[26] = className;
+    $[27] = t6;
+  } else {
+    t6 = $[27];
+  }
+  let t7;
+  if ($[28] !== theadTrClassName) {
+    t7 = classNames(styles.headerRow, theadTrClassName);
+    $[28] = theadTrClassName;
+    $[29] = t7;
+  } else {
+    t7 = $[29];
+  }
+  let t8;
+  if ($[30] !== columns) {
+    t8 = columns.map(_temp2);
+    $[30] = columns;
+    $[31] = t8;
+  } else {
+    t8 = $[31];
+  }
+  let t9;
+  if ($[32] !== t7 || $[33] !== t8) {
+    t9 = /*#__PURE__*/jsx("tr", {
+      className: t7,
+      children: t8
+    });
+    $[32] = t7;
+    $[33] = t8;
+    $[34] = t9;
+  } else {
+    t9 = $[34];
+  }
+  let t10;
+  if ($[35] !== t9 || $[36] !== theadClassName) {
+    t10 = /*#__PURE__*/jsx("thead", {
+      className: theadClassName,
+      children: t9
+    });
+    $[35] = t9;
+    $[36] = theadClassName;
+    $[37] = t10;
+  } else {
+    t10 = $[37];
+  }
+  let t11;
+  if ($[38] !== collapseItemIntoSpacer || $[39] !== columns.length || $[40] !== data || $[41] !== props || $[42] !== renderItem || $[43] !== virtualItems) {
+    let t12;
+    if ($[45] !== collapseItemIntoSpacer || $[46] !== columns.length || $[47] !== data || $[48] !== props || $[49] !== renderItem) {
+      t12 = virtualItem => {
+        if (virtualItem.type === "spacer") {
+          return /*#__PURE__*/jsx(SpacerRow, {
+            spacer: virtualItem,
+            colSpan: columns.length
+          }, virtualItem.key);
+        }
+        const index = virtualItem.index;
+        const item = data[index];
+        const key = props.getKey(item, index);
+        return /*#__PURE__*/jsx(CollapseItemIntoSpacerContext.Provider, {
+          value: height => collapseItemIntoSpacer(index, height),
+          children: renderItem ? renderItem(item, index, data) : /*#__PURE__*/jsx(DefaultItemRenderer, {
+            index: index
+          })
+        }, key);
+      };
+      $[45] = collapseItemIntoSpacer;
+      $[46] = columns.length;
+      $[47] = data;
+      $[48] = props;
+      $[49] = renderItem;
+      $[50] = t12;
+    } else {
+      t12 = $[50];
+    }
+    t11 = virtualItems.map(t12);
+    $[38] = collapseItemIntoSpacer;
+    $[39] = columns.length;
+    $[40] = data;
+    $[41] = props;
+    $[42] = renderItem;
+    $[43] = virtualItems;
+    $[44] = t11;
+  } else {
+    t11 = $[44];
+  }
+  let t12;
+  if ($[51] !== t11 || $[52] !== tbodyClassName) {
+    t12 = /*#__PURE__*/jsx("tbody", {
+      className: tbodyClassName,
+      children: t11
+    });
+    $[51] = t11;
+    $[52] = tbodyClassName;
+    $[53] = t12;
+  } else {
+    t12 = $[53];
+  }
+  let t13;
+  if ($[54] !== restProps || $[55] !== t10 || $[56] !== t12 || $[57] !== t6 || $[58] !== tableRef) {
+    t13 = /*#__PURE__*/jsxs("table", {
+      className: t6,
+      ref: tableRef,
+      ...restProps,
+      children: [t10, t12]
+    });
+    $[54] = restProps;
+    $[55] = t10;
+    $[56] = t12;
+    $[57] = t6;
+    $[58] = tableRef;
+    $[59] = t13;
+  } else {
+    t13 = $[59];
+  }
+  let t14;
+  if ($[60] !== intersectionObserverHandle || $[61] !== t13) {
+    t14 = /*#__PURE__*/jsx(IntersectionObserverContext.Provider, {
+      value: intersectionObserverHandle,
+      children: t13
+    });
+    $[60] = intersectionObserverHandle;
+    $[61] = t13;
+    $[62] = t14;
+  } else {
+    t14 = $[62];
+  }
+  let t15;
+  if ($[63] !== props || $[64] !== t14) {
+    t15 = /*#__PURE__*/jsx(TablePropsContext.Provider, {
+      value: props,
+      children: t14
+    });
+    $[63] = props;
+    $[64] = t14;
+    $[65] = t15;
+  } else {
+    t15 = $[65];
+  }
+  return t15;
+}
+function _temp2(column, columnIndex) {
+  var _ref, _column$renderHeader;
+  return /*#__PURE__*/jsx("th", {
+    className: classNames(styles.headerCell, column.thClassName),
+    "aria-sort": column.sortOrder,
+    children: /*#__PURE__*/jsx(ColumnIndexContext.Provider, {
+      value: columnIndex,
+      children: (_ref = (_column$renderHeader = column.renderHeader?.()) !== null && _column$renderHeader !== void 0 ? _column$renderHeader : column.name) !== null && _ref !== void 0 ? _ref : String(column.key)
+    })
+  }, column.key);
+}
+function _temp() {
+  return defaultRowHeight;
+}
+
+export { Table as default };

package/components/table/table-const.d.ts

@@ -0,0 +1,8 @@
+import type { TableProps } from './table';
+export declare const TablePropsContext: import("react").Context<TableProps<unknown> | null>;
+export declare const ColumnIndexContext: import("react").Context<number>;
+export declare const CollapseItemIntoSpacerContext: import("react").Context<(height: number) => void>;
+export declare const defaultRowHeight = 37;
+export declare const defaultLookaheadPx = 400;
+export declare const defaultRetentionMarginPx = 450;
+export declare const defaultMinScrollAndResizeDeltaPx = 50;

package/components/table/table-const.js

@@ -0,0 +1,11 @@
+import { createContext } from 'react';
+
+const TablePropsContext = /*#__PURE__*/createContext(null);
+const ColumnIndexContext = /*#__PURE__*/createContext(-1);
+const CollapseItemIntoSpacerContext = /*#__PURE__*/createContext(() => {});
+const defaultRowHeight = 37;
+const defaultLookaheadPx = 400;
+const defaultRetentionMarginPx = 450;
+const defaultMinScrollAndResizeDeltaPx = 50;
+
+export { CollapseItemIntoSpacerContext, ColumnIndexContext, TablePropsContext, defaultLookaheadPx, defaultMinScrollAndResizeDeltaPx, defaultRetentionMarginPx, defaultRowHeight };

package/components/table/table-virtualize.d.ts

@@ -0,0 +1,32 @@
+import { type RefObject } from 'react';
+export type VirtualItem = RenderedItem | Spacer;
+interface RenderedItem {
+    type: 'rendered';
+    index: number;
+}
+interface Spacer {
+    type: 'spacer';
+    from: number;
+    to: number;
+    height: number;
+    key: string;
+}
+export declare function useTableVirtualize({ enabled, length, scrollerRef, tableRef, estimateHeight, lookaheadPx, retentionMarginPx, minScrollAndResizeDeltaPx, }: {
+    enabled: boolean;
+    length: number;
+    scrollerRef: RefObject<HTMLElement | null> | undefined;
+    tableRef: RefObject<HTMLTableElement | null>;
+    estimateHeight: (index: number) => number;
+    lookaheadPx: number;
+    retentionMarginPx: number;
+    minScrollAndResizeDeltaPx: number;
+}): {
+    virtualItems: VirtualItem[];
+    intersectionObserverHandle: import("../global/intersection-observer-context").IntersectionObserverHandle | null;
+    collapseItemIntoSpacer: (index: number, height: number) => void;
+};
+export declare function SpacerRow({ spacer: { from, to, height }, colSpan }: {
+    spacer: Spacer;
+    colSpan: number;
+}): import("react").JSX.Element;
+export {};

package/components/table/table-virtualize.js

@@ -0,0 +1,330 @@
+import { c } from 'react-compiler-runtime';
+import { useRef, useState, useEffect } from 'react';
+import useEventCallback from '../global/use-event-callback.js';
+import { useIntersectionObserverHandle } from '../global/intersection-observer-context.js';
+import { s as styles } from '../_helpers/table.js';
+import { jsx } from 'react/jsx-runtime';
+
+const virtualizationThrottleDelay = 50;
+function useTableVirtualize(t0) {
+  const $ = c(33);
+  if ($[0] !== "43a8daad27f2d756ec5346c25f1057b419a001b3d7cb998cd41acf333e829c58") {
+    for (let $i = 0; $i < 33; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "43a8daad27f2d756ec5346c25f1057b419a001b3d7cb998cd41acf333e829c58";
+  }
+  const {
+    enabled,
+    length,
+    scrollerRef,
+    tableRef,
+    estimateHeight,
+    lookaheadPx,
+    retentionMarginPx,
+    minScrollAndResizeDeltaPx
+  } = t0;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [];
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const itemsMaterialization = useRef(t1);
+  let t2;
+  if ($[2] !== estimateHeight || $[3] !== length) {
+    t2 = () => [{
+      type: "spacer",
+      from: 0,
+      to: length,
+      height: Array.from({
+        length
+      }, (_, i) => estimateHeight(i)).reduce(_temp, 0),
+      key: `${styles.spacerRow}-0`
+    }];
+    $[2] = estimateHeight;
+    $[3] = length;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const [virtualItems, setVirtualItems] = useState(t2);
+  let t3;
+  if ($[5] !== estimateHeight || $[6] !== lookaheadPx || $[7] !== scrollerRef || $[8] !== tableRef) {
+    t3 = () => {
+      var _scrollerRef$current$;
+      if (!tableRef.current) {
+        return;
+      }
+      const containerHeight = (_scrollerRef$current$ = scrollerRef?.current?.clientHeight) !== null && _scrollerRef$current$ !== void 0 ? _scrollerRef$current$ : window.innerHeight;
+      for (const spacerRow of tableRef.current.querySelectorAll(`.${styles.spacerRow}`)) {
+        const rect = spacerRow.getBoundingClientRect();
+        const spacerIntersectsLookaheadArea = rect.top < containerHeight + lookaheadPx && rect.bottom > -lookaheadPx;
+        if (!spacerIntersectsLookaheadArea) {
+          continue;
+        }
+        const visibleOffsetStart = Math.max(0, -rect.top);
+        const visibleOffsetEnd = Math.min(rect.height, containerHeight - rect.top);
+        const materializeOffsetStart = visibleOffsetStart - lookaheadPx;
+        const materializeOffsetEnd = visibleOffsetEnd + lookaheadPx;
+        let offsetInSpacer = 0;
+        const from = Number(spacerRow.dataset.from);
+        const to = Number(spacerRow.dataset.to);
+        for (let i_0 = from; i_0 < to; i_0++) {
+          const itemMaterialization = itemsMaterialization.current[i_0];
+          const itemHeight = typeof itemMaterialization === "number" ? itemMaterialization : estimateHeight(i_0);
+          const itemOffsetStart = offsetInSpacer;
+          const itemOffsetEnd = offsetInSpacer + itemHeight;
+          if (itemOffsetStart < materializeOffsetEnd && itemOffsetEnd > materializeOffsetStart) {
+            itemsMaterialization.current[i_0] = true;
+          } else {
+            if (itemOffsetStart > materializeOffsetEnd) {
+              break;
+            }
+          }
+          offsetInSpacer = offsetInSpacer + itemHeight;
+        }
+      }
+    };
+    $[5] = estimateHeight;
+    $[6] = lookaheadPx;
+    $[7] = scrollerRef;
+    $[8] = tableRef;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  const materializeVisibleSpacerItems = useEventCallback(t3);
+  let t4;
+  if ($[10] !== estimateHeight || $[11] !== length) {
+    t4 = () => {
+      const newVirtualItems = [];
+      let spacerCounter = 0;
+      for (let i_1 = 0; i_1 < length; i_1++) {
+        const itemMaterialization_0 = itemsMaterialization.current[i_1];
+        if (itemMaterialization_0 === true) {
+          newVirtualItems.push({
+            type: "rendered",
+            index: i_1
+          });
+        } else {
+          const lastItemOrSpacer = newVirtualItems[newVirtualItems.length - 1];
+          const lastSpacer = lastItemOrSpacer?.type === "spacer" ? lastItemOrSpacer : undefined;
+          const height = typeof itemMaterialization_0 === "number" ? itemMaterialization_0 : estimateHeight(i_1);
+          if (lastSpacer) {
+            lastSpacer.to = i_1 + 1;
+            lastSpacer.height = lastSpacer.height + height;
+          } else {
+            newVirtualItems.push({
+              type: "spacer",
+              from: i_1,
+              to: i_1 + 1,
+              height,
+              key: `${styles.spacerRow}-${spacerCounter++}`
+            });
+          }
+        }
+      }
+      setVirtualItems(newVirtualItems);
+    };
+    $[10] = estimateHeight;
+    $[11] = length;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  const recomputeVirtualItems = useEventCallback(t4);
+  const timerIdRef = useRef(null);
+  const callbacksRef = useRef(null);
+  let t5;
+  if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = (...t6) => {
+      const callbacks = t6;
+      if (timerIdRef.current != null) {
+        callbacks.forEach(cb => {
+          callbacksRef.current.delete(cb);
+          callbacksRef.current.add(cb);
+        });
+        return;
+      }
+      callbacksRef.current = new Set(callbacks);
+      timerIdRef.current = window.setTimeout(() => {
+        callbacksRef.current.forEach(_temp2);
+        timerIdRef.current = null;
+        callbacksRef.current = null;
+      }, virtualizationThrottleDelay);
+    };
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const throttle = useEventCallback(t5);
+  let t6;
+  let t7;
+  if ($[14] !== enabled || $[15] !== materializeVisibleSpacerItems || $[16] !== minScrollAndResizeDeltaPx || $[17] !== recomputeVirtualItems || $[18] !== scrollerRef || $[19] !== throttle) {
+    t6 = () => {
+      if (!enabled) {
+        return;
+      }
+      const scroller = scrollerRef?.current;
+      let lastHandledScrollTop = -Infinity;
+      let lastHandledHeight = -Infinity;
+      let lastHandledWidth = -Infinity;
+      const handleViewportChange = function handleViewportChange() {
+        const scrollTop = scroller ? scroller.scrollTop : window.scrollY;
+        const height_0 = scroller ? scroller.clientHeight : window.innerHeight;
+        const width = scroller ? scroller.clientWidth : window.innerWidth;
+        if (Math.abs(scrollTop - lastHandledScrollTop) >= minScrollAndResizeDeltaPx || Math.abs(height_0 - lastHandledHeight) >= minScrollAndResizeDeltaPx || Math.abs(width - lastHandledWidth) >= minScrollAndResizeDeltaPx) {
+          lastHandledScrollTop = scrollTop;
+          lastHandledHeight = height_0;
+          lastHandledWidth = width;
+          throttle(materializeVisibleSpacerItems, recomputeVirtualItems);
+        }
+      };
+      const scrollTarget = scroller !== null && scroller !== void 0 ? scroller : window;
+      scrollTarget.addEventListener("scroll", handleViewportChange, {
+        passive: true
+      });
+      const resizeObserver = new ResizeObserver(handleViewportChange);
+      const resizeTarget = scroller !== null && scroller !== void 0 ? scroller : document.documentElement;
+      resizeObserver.observe(resizeTarget);
+      handleViewportChange();
+      return () => {
+        scrollTarget.removeEventListener("scroll", handleViewportChange);
+        resizeObserver.unobserve(resizeTarget);
+        resizeObserver.disconnect();
+      };
+    };
+    t7 = [enabled, materializeVisibleSpacerItems, minScrollAndResizeDeltaPx, recomputeVirtualItems, scrollerRef, throttle];
+    $[14] = enabled;
+    $[15] = materializeVisibleSpacerItems;
+    $[16] = minScrollAndResizeDeltaPx;
+    $[17] = recomputeVirtualItems;
+    $[18] = scrollerRef;
+    $[19] = throttle;
+    $[20] = t6;
+    $[21] = t7;
+  } else {
+    t6 = $[20];
+    t7 = $[21];
+  }
+  useEffect(t6, t7);
+  const intersectionObserverHandle = useIntersectionObserverHandle(scrollerRef, scrollerRef ? retentionMarginPx : undefined, !scrollerRef ? retentionMarginPx : undefined);
+  let t8;
+  if ($[22] !== enabled || $[23] !== recomputeVirtualItems || $[24] !== throttle) {
+    t8 = (index, height_1) => {
+      if (!enabled) {
+        return;
+      }
+      itemsMaterialization.current[index] = height_1;
+      throttle(recomputeVirtualItems);
+    };
+    $[22] = enabled;
+    $[23] = recomputeVirtualItems;
+    $[24] = throttle;
+    $[25] = t8;
+  } else {
+    t8 = $[25];
+  }
+  const collapseItemIntoSpacer = useEventCallback(t8);
+  let t9;
+  if ($[26] !== enabled || $[27] !== length) {
+    t9 = Array.from({
+      length: enabled ? 0 : length
+    }, _temp3);
+    $[26] = enabled;
+    $[27] = length;
+    $[28] = t9;
+  } else {
+    t9 = $[28];
+  }
+  const allVisibleVirtualItems = t9;
+  const t10 = enabled ? virtualItems : allVisibleVirtualItems;
+  let t11;
+  if ($[29] !== collapseItemIntoSpacer || $[30] !== intersectionObserverHandle || $[31] !== t10) {
+    t11 = {
+      virtualItems: t10,
+      intersectionObserverHandle,
+      collapseItemIntoSpacer
+    };
+    $[29] = collapseItemIntoSpacer;
+    $[30] = intersectionObserverHandle;
+    $[31] = t10;
+    $[32] = t11;
+  } else {
+    t11 = $[32];
+  }
+  return t11;
+}
+function _temp3(__0, index_0) {
+  return {
+    type: "rendered",
+    index: index_0
+  };
+}
+function _temp2(cb_0) {
+  return cb_0();
+}
+function _temp(a, b) {
+  return a + b;
+}
+function SpacerRow(t0) {
+  const $ = c(10);
+  if ($[0] !== "43a8daad27f2d756ec5346c25f1057b419a001b3d7cb998cd41acf333e829c58") {
+    for (let $i = 0; $i < 10; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "43a8daad27f2d756ec5346c25f1057b419a001b3d7cb998cd41acf333e829c58";
+  }
+  const {
+    spacer: t1,
+    colSpan
+  } = t0;
+  const {
+    from,
+    to,
+    height
+  } = t1;
+  let t2;
+  if ($[1] !== height) {
+    t2 = {
+      height
+    };
+    $[1] = height;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== colSpan || $[4] !== t2) {
+    t3 = /*#__PURE__*/jsx("td", {
+      className: styles.spacerCell,
+      colSpan: colSpan,
+      style: t2
+    });
+    $[3] = colSpan;
+    $[4] = t2;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== from || $[7] !== t3 || $[8] !== to) {
+    t4 = /*#__PURE__*/jsx("tr", {
+      className: styles.spacerRow,
+      "data-from": from,
+      "data-to": to,
+      children: t3
+    });
+    $[6] = from;
+    $[7] = t3;
+    $[8] = to;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
+}
+
+export { SpacerRow, useTableVirtualize };