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

package/components/internal/virtual-items.js

@@ -0,0 +1,353 @@
+import { c } from 'react/compiler-runtime';
+import { createContext, useRef, useState, useEffect } from 'react';
+import { useIntersectionObserverHandle } from '../global/intersection-observer-context.js';
+import { setTimeoutWithCleanup } from '../global/schedule-with-cleanup.js';
+import { s as styles } from '../_helpers/table.js';
+import { jsx } from 'react/jsx-runtime';
+
+const CollapseItemIntoSpacerContext = /*#__PURE__*/createContext(() => {});
+/**
+ * RAF is somewhat too frequent. Most updates happen on virtualization boundaries
+ * within the invisible overscroll area, so they don't require such a high update rate.
+ * Therefore, we throttle with a custom delay.
+ */
+const virtualizationThrottleDelay = 50;
+function useVirtualItems(t0) {
+  const $ = c(41);
+  if ($[0] !== "80b5c65d0516051224f2341cd07e0f80847b5a4f7e3a2576798e9173d2ec550d") {
+    for (let $i = 0; $i < 41; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "80b5c65d0516051224f2341cd07e0f80847b5a4f7e3a2576798e9173d2ec550d";
+  }
+  const {
+    enabled,
+    data,
+    data: t1,
+    scrollerRef,
+    tableRef,
+    estimateHeight,
+    lookaheadPx,
+    retentionMarginPx,
+    minScrollAndResizeDeltaPx
+  } = t0;
+  const {
+    length
+  } = t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = [];
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const itemsMaterialization = useRef(t2);
+  let t3;
+  if ($[2] !== data || $[3] !== enabled || $[4] !== estimateHeight) {
+    t3 = () => enabled ? getAllVirtualizedItems(data, estimateHeight) : [];
+    $[2] = data;
+    $[3] = enabled;
+    $[4] = estimateHeight;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const [virtualItems, setVirtualItems] = useState(t3);
+  let t4;
+  if ($[6] !== data || $[7] !== estimateHeight || $[8] !== lookaheadPx || $[9] !== scrollerRef || $[10] !== tableRef) {
+    t4 = () => {
+      var _scrollerRect$top;
+      if (!tableRef.current) {
+        return;
+      }
+      const scrollerRect = scrollerRef?.current?.getBoundingClientRect();
+      const visibleStart = (_scrollerRect$top = scrollerRect?.top) !== null && _scrollerRect$top !== void 0 ? _scrollerRect$top : 0;
+      const visibleEnd = scrollerRect ? Math.min(scrollerRect.bottom, window.innerHeight) : window.innerHeight;
+      const materializeStart = visibleStart - lookaheadPx;
+      const materializeEnd = visibleEnd + lookaheadPx;
+      for (const spacerRow of tableRef.current.querySelectorAll(`.${styles.spacerRow}`)) {
+        const spacerRect = spacerRow.getBoundingClientRect();
+        if (spacerRect.bottom < materializeStart || spacerRect.top > materializeEnd) {
+          continue;
+        }
+        const from = Number(spacerRow.dataset.from);
+        const to = Number(spacerRow.dataset.to);
+        let currentTop = spacerRect.top;
+        for (let i = from; i < to; i++) {
+          const itemMaterialization = itemsMaterialization.current[i];
+          const itemHeight = typeof itemMaterialization === "number" ? itemMaterialization : estimateHeight(data[i], i, data);
+          const itemTop = currentTop;
+          const itemBottom = currentTop + itemHeight;
+          if (itemBottom >= materializeStart && itemTop <= materializeEnd) {
+            itemsMaterialization.current[i] = true;
+          } else {
+            if (itemTop > materializeEnd) {
+              break;
+            }
+          }
+          currentTop = currentTop + itemHeight;
+        }
+      }
+    };
+    $[6] = data;
+    $[7] = estimateHeight;
+    $[8] = lookaheadPx;
+    $[9] = scrollerRef;
+    $[10] = tableRef;
+    $[11] = t4;
+  } else {
+    t4 = $[11];
+  }
+  const materializeVisibleSpacerItems = t4;
+  let t5;
+  if ($[12] !== data || $[13] !== estimateHeight || $[14] !== length) {
+    t5 = () => {
+      const newVirtualItems = [];
+      let spacerCounter = 0;
+      for (let i_0 = 0; i_0 < length; i_0++) {
+        const itemMaterialization_0 = itemsMaterialization.current[i_0];
+        if (itemMaterialization_0 === true) {
+          newVirtualItems.push({
+            type: "materialized",
+            index: i_0
+          });
+        } else {
+          const lastItemOrSpacer = newVirtualItems[newVirtualItems.length - 1];
+          const lastSpacer = lastItemOrSpacer?.type === "spacer" ? lastItemOrSpacer : undefined;
+          const height = typeof itemMaterialization_0 === "number" ? itemMaterialization_0 : estimateHeight(data[i_0], i_0, data);
+          if (lastSpacer) {
+            lastSpacer.to = i_0 + 1;
+            lastSpacer.height = lastSpacer.height + height;
+          } else {
+            newVirtualItems.push({
+              type: "spacer",
+              from: i_0,
+              to: i_0 + 1,
+              height,
+              key: spacerKey(spacerCounter++)
+            });
+          }
+        }
+      }
+      setVirtualItems(newVirtualItems);
+    };
+    $[12] = data;
+    $[13] = estimateHeight;
+    $[14] = length;
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  const recomputeVirtualItems = t5;
+  const timerIdRef = useRef(null);
+  const callbacksRef = useRef(null);
+  let t6;
+  if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = (...t7) => {
+      const callbacks = t7;
+      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(_temp);
+        timerIdRef.current = null;
+        callbacksRef.current = null;
+      }, virtualizationThrottleDelay);
+    };
+    $[16] = t6;
+  } else {
+    t6 = $[16];
+  }
+  const throttle = t6;
+  const prevEnabledRef = useRef(enabled);
+  let t7;
+  if ($[17] !== data || $[18] !== enabled || $[19] !== estimateHeight || $[20] !== materializeVisibleSpacerItems || $[21] !== minScrollAndResizeDeltaPx || $[22] !== recomputeVirtualItems || $[23] !== scrollerRef) {
+    t7 = () => {
+      const prevEnabled = prevEnabledRef.current;
+      prevEnabledRef.current = enabled;
+      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);
+      let timeoutCleanup;
+      if (!prevEnabled) {
+        timeoutCleanup = setTimeoutWithCleanup(() => {
+          itemsMaterialization.current = [];
+          setVirtualItems(getAllVirtualizedItems(data, estimateHeight));
+          handleViewportChange();
+        });
+      } else {
+        handleViewportChange();
+      }
+      return () => {
+        timeoutCleanup?.();
+        scrollTarget.removeEventListener("scroll", handleViewportChange);
+        resizeObserver.unobserve(resizeTarget);
+        resizeObserver.disconnect();
+        if (timerIdRef.current != null) {
+          window.clearTimeout(timerIdRef.current);
+          timerIdRef.current = null;
+          callbacksRef.current = null;
+        }
+      };
+    };
+    $[17] = data;
+    $[18] = enabled;
+    $[19] = estimateHeight;
+    $[20] = materializeVisibleSpacerItems;
+    $[21] = minScrollAndResizeDeltaPx;
+    $[22] = recomputeVirtualItems;
+    $[23] = scrollerRef;
+    $[24] = t7;
+  } else {
+    t7 = $[24];
+  }
+  let t8;
+  if ($[25] !== data || $[26] !== enabled || $[27] !== estimateHeight || $[28] !== length || $[29] !== materializeVisibleSpacerItems || $[30] !== minScrollAndResizeDeltaPx || $[31] !== recomputeVirtualItems || $[32] !== scrollerRef) {
+    t8 = [data, enabled, estimateHeight, length, materializeVisibleSpacerItems, minScrollAndResizeDeltaPx, recomputeVirtualItems, scrollerRef, throttle];
+    $[25] = data;
+    $[26] = enabled;
+    $[27] = estimateHeight;
+    $[28] = length;
+    $[29] = materializeVisibleSpacerItems;
+    $[30] = minScrollAndResizeDeltaPx;
+    $[31] = recomputeVirtualItems;
+    $[32] = scrollerRef;
+    $[33] = t8;
+  } else {
+    t8 = $[33];
+  }
+  useEffect(t7, t8);
+  const intersectionObserverHandle = useIntersectionObserverHandle(scrollerRef, scrollerRef ? retentionMarginPx : undefined, !scrollerRef ? retentionMarginPx : undefined);
+  let t9;
+  if ($[34] !== enabled || $[35] !== recomputeVirtualItems) {
+    t9 = (index, height_1) => {
+      if (!enabled) {
+        return;
+      }
+      itemsMaterialization.current[index] = height_1;
+      throttle(recomputeVirtualItems);
+    };
+    $[34] = enabled;
+    $[35] = recomputeVirtualItems;
+    $[36] = t9;
+  } else {
+    t9 = $[36];
+  }
+  const collapseItemIntoSpacer = t9;
+  let t10;
+  if ($[37] !== collapseItemIntoSpacer || $[38] !== intersectionObserverHandle || $[39] !== virtualItems) {
+    t10 = {
+      virtualItems,
+      intersectionObserverHandle,
+      collapseItemIntoSpacer
+    };
+    $[37] = collapseItemIntoSpacer;
+    $[38] = intersectionObserverHandle;
+    $[39] = virtualItems;
+    $[40] = t10;
+  } else {
+    t10 = $[40];
+  }
+  return t10;
+}
+function _temp(cb_0) {
+  return cb_0();
+}
+function getAllVirtualizedItems(data, estimateHeight) {
+  return [{
+    type: 'spacer',
+    from: 0,
+    to: data.length,
+    height: data.reduce((acc, item, index, items) => acc + estimateHeight(item, index, items), 0),
+    key: spacerKey(0)
+  }];
+}
+function spacerKey(index) {
+  return `__${styles.spacerRow}-${index}`;
+}
+function SpacerRow(t0) {
+  const $ = c(10);
+  if ($[0] !== "80b5c65d0516051224f2341cd07e0f80847b5a4f7e3a2576798e9173d2ec550d") {
+    for (let $i = 0; $i < 10; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "80b5c65d0516051224f2341cd07e0f80847b5a4f7e3a2576798e9173d2ec550d";
+  }
+  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 { CollapseItemIntoSpacerContext, SpacerRow, useVirtualItems };

package/components/island/adaptive-island-hoc.js

@@ -1,4 +1,4 @@
-import { createContext, Component } from 'react';
+import { Component, createContext } from 'react';
 import { interpolateLinear } from '../global/linear-function.js';
 import { jsx } from 'react/jsx-runtime';
 
@@ -25,9 +25,9 @@ function adaptiveIslandHOC(ComposedComponent) {
       }
     };
     render() {
-      return /*#__PURE__*/jsx(PhaseContext.Provider, {
+      return /*#__PURE__*/jsx(PhaseContext, {
         value: this.state.phase,
-        children: /*#__PURE__*/jsx(ScrollHandlerContext.Provider, {
+        children: /*#__PURE__*/jsx(ScrollHandlerContext, {
           value: this.onContentScroll,
           children: /*#__PURE__*/jsx(ComposedComponent, {
             ...this.props

package/components/island/content.d.ts

@@ -1,11 +1,13 @@
-import { Component, type HTMLAttributes } from 'react';
+import { Component, type Ref, type HTMLAttributes } from 'react';
 import createResizeDetector from 'element-resize-detector';
 export interface IslandContentProps extends Omit<HTMLAttributes<HTMLElement>, 'onScroll'> {
+    ref?: Ref<Content>;
     fade?: boolean | null | undefined;
     onScrollToBottom?: (() => void) | null | undefined;
     scrollableWrapperClassName?: string | null | undefined;
 }
 export interface IslandContentInnerProps extends IslandContentProps {
+    ref?: Ref<Content>;
     onScroll: (node: HTMLElement) => void;
     bottomBorder: boolean;
 }
@@ -29,5 +31,8 @@ declare class Content extends Component<IslandContentInnerProps> {
     setScrollableNodeAndCalculatePosition: (node: HTMLElement | null) => void;
     render(): import("react").JSX.Element;
 }
-declare const ContentWrapper: import("react").ForwardRefExoticComponent<IslandContentProps & import("react").RefAttributes<Content>>;
+declare const ContentWrapper: {
+    ({ ...props }: IslandContentProps): import("react").JSX.Element;
+    displayName: string;
+};
 export default ContentWrapper;

package/components/island/content.js

@@ -1,5 +1,5 @@
-import { c } from 'react-compiler-runtime';
-import { forwardRef, Component } from 'react';
+import { c } from 'react/compiler-runtime';
+import { Component } from 'react';
 import classNames from 'classnames';
 import createResizeDetector from 'element-resize-detector';
 import scheduleRAF from '../global/schedule-raf.js';
@@ -73,6 +73,7 @@ class Content extends Component {
   };
   render() {
     const {
+      ref,
       children,
       className,
       bottomBorder,
@@ -111,17 +112,27 @@ class Content extends Component {
     });
   }
 }
-const ContentWrapper = /*#__PURE__*/forwardRef((props, ref) => {
-  const $ = c(4);
-  if ($[0] !== "c32a71969444a48a67d8737ca30be3eaf2fe1249949706470667058a052ec377") {
-    for (let $i = 0; $i < 4; $i += 1) {
+const ContentWrapper = t0 => {
+  const $ = c(5);
+  if ($[0] !== "e4db06b946c16f75a9eac1dc4434adb1fda7cf8013533176d779915994c312c4") {
+    for (let $i = 0; $i < 5; $i += 1) {
       $[$i] = Symbol.for("react.memo_cache_sentinel");
     }
-    $[0] = "c32a71969444a48a67d8737ca30be3eaf2fe1249949706470667058a052ec377";
+    $[0] = "e4db06b946c16f75a9eac1dc4434adb1fda7cf8013533176d779915994c312c4";
   }
-  let t0;
-  if ($[1] !== props || $[2] !== ref) {
-    t0 = /*#__PURE__*/jsx(ScrollHandlerContext.Consumer, {
+  let props;
+  if ($[1] !== t0) {
+    ({
+      ...props
+    } = t0);
+    $[1] = t0;
+    $[2] = props;
+  } else {
+    props = $[2];
+  }
+  let t1;
+  if ($[3] !== props) {
+    t1 = /*#__PURE__*/jsx(ScrollHandlerContext.Consumer, {
       children: onScroll => {
         const addProps = onScroll ? {
           onScroll,
@@ -129,19 +140,17 @@ const ContentWrapper = /*#__PURE__*/forwardRef((props, ref) => {
         } : {};
         return /*#__PURE__*/jsx(Content, {
           ...props,
-          ...addProps,
-          ref: ref
+          ...addProps
         });
       }
     });
-    $[1] = props;
-    $[2] = ref;
-    $[3] = t0;
+    $[3] = props;
+    $[4] = t1;
   } else {
-    t0 = $[3];
+    t1 = $[4];
   }
-  return t0;
-});
+  return t1;
+};
 ContentWrapper.displayName = 'ContentWrapper';
 
 export { ContentWrapper as default };

package/components/island/header.js

@@ -1,4 +1,4 @@
-import { c } from 'react-compiler-runtime';
+import { c } from 'react/compiler-runtime';
 import { Component } from 'react';
 import classNames from 'classnames';
 import { interpolateLinear } from '../global/linear-function.js';

package/components/island/island.js

@@ -7,7 +7,7 @@ import { jsx } from 'react/jsx-runtime';
 export { default as Header } from './header.js';
 export { default as Content } from './content.js';
 import '../global/linear-function.js';
-import 'react-compiler-runtime';
+import 'react/compiler-runtime';
 import 'element-resize-detector';
 import '../global/schedule-raf.js';
 

package/components/legacy-table/cell.js

@@ -1,7 +1,7 @@
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import joinDataTestAttributes from '../global/data-tests.js';
-import { s as style } from '../_helpers/table2.js';
+import { s as style } from '../_helpers/legacy-table.js';
 import { jsx } from 'react/jsx-runtime';
 
 class Cell extends PureComponent {

package/components/legacy-table/header-cell.js

@@ -1,15 +1,15 @@
 import { PureComponent } from 'react';
 import classNames from 'classnames';
-import unsortedIcon from '@jetbrains/icons/unsorted-12px';
+import sortableIcon from '@jetbrains/icons/unsorted-12px';
 import chevron12pxDown from '@jetbrains/icons/chevron-12px-down';
 import Icon from '../icon/icon.js';
 import joinDataTestAttributes from '../global/data-tests.js';
-import { s as style } from '../_helpers/table2.js';
+import { s as style } from '../_helpers/legacy-table.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import 'util-deprecate';
 import '../icon/icon.constants.js';
 import '../_helpers/icon-svg.js';
-import 'react-compiler-runtime';
+import 'react/compiler-runtime';
 import '../global/memoize.js';
 
 class HeaderCell extends PureComponent {
@@ -46,7 +46,7 @@ class HeaderCell extends PureComponent {
     } = this.props;
     this.sortable = column.sortable === true;
     this.sorted = sortKey === column.id;
-    const glyph = this.sorted ? chevron12pxDown : unsortedIcon;
+    const glyph = this.sorted ? chevron12pxDown : sortableIcon;
     const classes = classNames(className, column.headerClassName, {
       [style.headerCell]: true,
       [style.headerCellSortable]: this.sortable,

package/components/legacy-table/header.js

@@ -3,7 +3,7 @@ import classNames from 'classnames';
 import Checkbox from '../checkbox/checkbox.js';
 import getUID from '../global/get-uid.js';
 import HeaderCell from './header-cell.js';
-import { s as style } from '../_helpers/table2.js';
+import { s as style } from '../_helpers/legacy-table.js';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import '@jetbrains/icons/checkmark-12px';
 import '@jetbrains/icons/remove-12px';
@@ -11,7 +11,7 @@ import '../icon/icon.js';
 import 'util-deprecate';
 import '../icon/icon.constants.js';
 import '../_helpers/icon-svg.js';
-import 'react-compiler-runtime';
+import 'react/compiler-runtime';
 import '../global/memoize.js';
 import '../global/compose-refs.js';
 import 'memoize-one';

package/components/legacy-table/multitable.d.ts

@@ -1,6 +1,6 @@
 import { PureComponent, type ReactElement } from 'react';
 import { type TableAttrs } from './table';
-import { type SelectionItem } from './selection';
+import { type SelectionItem } from '../global/table-selection';
 type TableComponent = ReactElement<TableAttrs<SelectionItem>>;
 export interface MultiTableProps {
     children: TableComponent[];

package/components/legacy-table/row-with-focus-sensor.js

@@ -3,8 +3,8 @@ import focusSensorHOC from '../global/focus-sensor-hoc.js';
 import Row from './row.js';
 import { jsx } from 'react/jsx-runtime';
 import '../global/compose-refs.js';
+import 'react/compiler-runtime';
 import 'memoize-one';
-import 'react-compiler-runtime';
 import 'classnames';
 import '@jetbrains/icons/chevron-right';
 import '@jetbrains/icons/chevron-down';
@@ -44,7 +44,7 @@ import '../popup/popup.target.js';
 import '../popup/position-css.js';
 import '../_helpers/theme.js';
 import './cell.js';
-import '../_helpers/table2.js';
+import '../_helpers/legacy-table.js';
 
 const getContainer = () => focusSensorHOC(Row);
 class RowWithFocusSensorCallbacks extends PureComponent {

package/components/legacy-table/row.d.ts

@@ -55,7 +55,7 @@ export default class Row<T extends object> extends PureComponent<RowProps<T>> {
     onDoubleClick: () => void;
     row?: HTMLElement | null;
     rowRef: (el: HTMLElement | null) => void;
-    composedRowRef: import("memoize-one").MemoizedFn<(...refs: (React.Ref<HTMLElement> | undefined)[]) => (value: T_1 | null) => void>;
+    composedRowRef: import("memoize-one").MemoizedFn<(...refs: (React.Ref<HTMLElement> | undefined)[]) => (value: T_1 | null) => () => void>;
     render(): React.JSX.Element;
 }
 export type RowAttrs<T extends object> = React.JSX.LibraryManagedAttributes<typeof Row, RowProps<T>>;

package/components/legacy-table/row.js

@@ -1,4 +1,4 @@
-import { c } from 'react-compiler-runtime';
+import { c } from 'react/compiler-runtime';
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import chevronRightIcon from '@jetbrains/icons/chevron-right';
@@ -11,7 +11,7 @@ import joinDataTestAttributes from '../global/data-tests.js';
 import getUID from '../global/get-uid.js';
 import { createComposedRef } from '../global/compose-refs.js';
 import Cell from './cell.js';
-import { s as style } from '../_helpers/table2.js';
+import { s as style } from '../_helpers/legacy-table.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import '@jetbrains/icons/checkmark-12px';
 import '@jetbrains/icons/remove-12px';
@@ -46,11 +46,11 @@ import 'memoize-one';
 
 const DragHandle = t0 => {
   const $ = c(6);
-  if ($[0] !== "55dd4b764fc7ce682e91a4f9ed76700dd0c03ecdbbc71fc25d11ed30dc931312") {
+  if ($[0] !== "6d181a7b79d6c43c9efeb4fa43b5ac2047952f3bf582e26f319cda89e9e36280") {
     for (let $i = 0; $i < 6; $i += 1) {
       $[$i] = Symbol.for("react.memo_cache_sentinel");
     }
-    $[0] = "55dd4b764fc7ce682e91a4f9ed76700dd0c03ecdbbc71fc25d11ed30dc931312";
+    $[0] = "6d181a7b79d6c43c9efeb4fa43b5ac2047952f3bf582e26f319cda89e9e36280";
   }
   const {
     alwaysShowDragHandle,

package/components/legacy-table/selection-adapter.d.ts

@@ -1,6 +1,6 @@
-import type Selection from './selection';
-import type { SelectionItem } from './selection';
-export default function selectionAdapter(getSelection: () => Selection<SelectionItem>): {
+import type TableSelection from '../global/table-selection';
+import type { SelectionItem } from '../global/table-selection';
+export default function selectionAdapter(getSelection: () => TableSelection<SelectionItem>): {
     readonly size: number;
     readonly items: SelectionItem[];
 };

package/components/legacy-table/selection-shortcuts-hoc.d.ts

@@ -1,16 +1,16 @@
 import { type ComponentClass } from 'react';
 import { type ShortcutsMap } from '../shortcuts/core';
-import type Selection from './selection';
+import type TableSelection from '../global/table-selection';
 export interface SelectionShortcutsOuterProps<T extends object> {
-    selection: Selection<T>;
+    selection: TableSelection<T>;
     selectable?: boolean | undefined;
-    onSelect?: ((selection: Selection<T>) => void) | undefined;
+    onSelect?: ((selection: TableSelection<T>) => void) | undefined;
     shortcuts?: ShortcutsMap | undefined;
 }
 export interface SelectionShortcutsAddProps<T extends object> {
-    selection: Selection<T>;
+    selection: TableSelection<T>;
     selectable: boolean;
-    onSelect: (selection: Selection<T>) => void;
+    onSelect: (selection: TableSelection<T>) => void;
     shortcutsMap: ShortcutsMap;
 }
 export type SelectionShortcutsProps<T extends object, P> = Omit<P, keyof SelectionShortcutsAddProps<T>> & SelectionShortcutsOuterProps<T>;

package/components/legacy-table/simple-table.d.ts

@@ -1,6 +1,6 @@
 import { PureComponent } from 'react';
 import { type TableAttrs } from './table';
-import Selection, { type SelectionItem } from './selection';
+import TableSelection, { type SelectionItem } from '../global/table-selection';
 export interface SimpleTableProps<T extends SelectionItem> extends Omit<TableAttrs<T>, 'selection' | 'onSelect' | 'selectable'> {
 }
 declare class SimpleTable<T extends SelectionItem> extends PureComponent<SimpleTableProps<T>> {
@@ -9,7 +9,7 @@ declare class SimpleTable<T extends SelectionItem> extends PureComponent<SimpleT
         wideFirstColumn: boolean;
     };
     state: {
-        selection: Selection<T>;
+        selection: TableSelection<T>;
     };
     classes: string;
     render(): import("react").JSX.Element;