@jetbrains/ring-ui-built 7.0.72 → 7.0.73

package/components/tab-trap/tab-trap.js

@@ -1,138 +1,283 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { forwardRef, useRef, useImperativeHandle, useCallback, useEffect } from 'react';
+import { c } from 'react-compiler-runtime';
+import { forwardRef, useRef, useImperativeHandle, useEffect } from 'react';
 import { isNodeInVisiblePartOfPage } from '../global/dom.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
 
 var styles = {"trapButton":"ring-tab-trap-trapButton"};
 
 const FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])';
-// eslint-disable-next-line @typescript-eslint/no-shadow
-const TabTrap = /*#__PURE__*/forwardRef(function TabTrap({
-  children,
-  trapDisabled = false,
-  autoFocusFirst = true,
-  focusBackOnClose = true,
-  focusBackOnExit = false,
-  ...restProps
-}, ref) {
+// eslint-disable-next-line no-shadow
+const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
+  const $ = c(36);
+  if ($[0] !== "0332e0ee653a0153e98c2004e643614e720cfc900b162b7629295f63077cddf5") {
+    for (let $i = 0; $i < 36; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "0332e0ee653a0153e98c2004e643614e720cfc900b162b7629295f63077cddf5";
+  }
+  let children;
+  let restProps;
+  let t1;
+  let t2;
+  let t3;
+  let t4;
+  if ($[1] !== t0) {
+    ({
+      children,
+      trapDisabled: t1,
+      autoFocusFirst: t2,
+      focusBackOnClose: t3,
+      focusBackOnExit: t4,
+      ...restProps
+    } = t0);
+    $[1] = t0;
+    $[2] = children;
+    $[3] = restProps;
+    $[4] = t1;
+    $[5] = t2;
+    $[6] = t3;
+    $[7] = t4;
+  } else {
+    children = $[2];
+    restProps = $[3];
+    t1 = $[4];
+    t2 = $[5];
+    t3 = $[6];
+    t4 = $[7];
+  }
+  const trapDisabled = t1 === undefined ? false : t1;
+  const autoFocusFirst = t2 === undefined ? true : t2;
+  const focusBackOnClose = t3 === undefined ? true : t3;
+  const focusBackOnExit = t4 === undefined ? false : t4;
   const nodeRef = useRef(null);
   const trapButtonNodeRef = useRef(null);
   const previousFocusedNodeRef = useRef(null);
   const trapWithoutFocusRef = useRef(false);
   const mountedRef = useRef(false);
-  // It's the same approach as in focus-trap-react:
-  // https://github.com/focus-trap/focus-trap-react/commit/3b22fca9eebeb883edc89548850fe5a5b9d6d50e
-  // We can't do it in useEffect because it's too late, some children might have already
-  // focused itself.
   if (previousFocusedNodeRef.current === null) {
     previousFocusedNodeRef.current = document.activeElement;
   }
-  useImperativeHandle(ref, () => ({
-    node: nodeRef.current
-  }), []);
-  const focusFirst = useCallback(() => focusElement(true), []);
-  const focusLast = () => focusElement(false);
-  useEffect(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
+  let t5;
+  let t6;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = () => ({
+      node: nodeRef.current
+    });
+    t6 = [];
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t5 = $[8];
+    t6 = $[9];
+  }
+  useImperativeHandle(ref, t5, t6);
+  let t7;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = function restoreFocus() {
+      const previousFocusedNode = previousFocusedNodeRef.current;
+      if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
+        if (!mountedRef.current) {
+          previousFocusedNode.focus({
+            preventScroll: true
+          });
+        }
+      }
     };
-  }, []);
-  useEffect(() => {
-    if (autoFocusFirst) {
-      focusFirst();
-    } else if (!trapDisabled) {
-      const previousFocusedElementIsInContainer = previousFocusedNodeRef.current && nodeRef.current?.contains(previousFocusedNodeRef.current);
-      // The component wrapped in TabTrap can already have a focused element (e.g. Date Picker),
-      // so we need to check if it does. If so, we don't need to focus anything.
-      const currentlyFocusedElementIsInContainer = nodeRef.current?.contains(document.activeElement);
-      if (!nodeRef.current || !previousFocusedElementIsInContainer && !currentlyFocusedElementIsInContainer) {
-        trapWithoutFocusRef.current = true;
-        trapButtonNodeRef.current?.focus();
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  const restoreFocus = t7;
+  let t8;
+  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = function focusElement(t9) {
+      const first = t9 === undefined ? true : t9;
+      const node = nodeRef.current;
+      if (!node) {
+        return;
       }
-    }
-    return () => {
-      if (focusBackOnClose) {
-        restoreFocus();
+      const tabables = [...node.querySelectorAll(FOCUSABLE_ELEMENTS)].filter(_temp);
+      const toBeFocused = first ? tabables[0] : tabables[tabables.length - 1];
+      if (toBeFocused) {
+        toBeFocused.focus();
       }
     };
-  }, [autoFocusFirst, trapDisabled, focusBackOnClose, focusFirst]);
-  function restoreFocus() {
-    const previousFocusedNode = previousFocusedNodeRef.current;
-    if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
-      // This is to prevent the focus from being restored the first time
-      // componentWillUnmount is called in StrictMode.
-      if (!mountedRef.current) {
-        previousFocusedNode.focus({
-          preventScroll: true
-        });
+    $[11] = t8;
+  } else {
+    t8 = $[11];
+  }
+  const focusElement = t8;
+  let t9;
+  if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = () => focusElement(true);
+    $[12] = t9;
+  } else {
+    t9 = $[12];
+  }
+  const focusFirst = t9;
+  let t10;
+  if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+    t10 = () => focusElement(false);
+    $[13] = t10;
+  } else {
+    t10 = $[13];
+  }
+  const focusLast = t10;
+  let t11;
+  let t12;
+  if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+    t11 = () => {
+      mountedRef.current = true;
+      return () => {
+        mountedRef.current = false;
+      };
+    };
+    t12 = [];
+    $[14] = t11;
+    $[15] = t12;
+  } else {
+    t11 = $[14];
+    t12 = $[15];
+  }
+  useEffect(t11, t12);
+  let t13;
+  let t14;
+  if ($[16] !== autoFocusFirst || $[17] !== focusBackOnClose || $[18] !== trapDisabled) {
+    t13 = () => {
+      if (autoFocusFirst) {
+        focusFirst();
+      } else {
+        if (!trapDisabled) {
+          const previousFocusedElementIsInContainer = previousFocusedNodeRef.current && nodeRef.current?.contains(previousFocusedNodeRef.current);
+          const currentlyFocusedElementIsInContainer = nodeRef.current?.contains(document.activeElement);
+          if (!nodeRef.current || !previousFocusedElementIsInContainer && !currentlyFocusedElementIsInContainer) {
+            trapWithoutFocusRef.current = true;
+            trapButtonNodeRef.current?.focus();
+          }
+        }
       }
-    }
+      return () => {
+        if (focusBackOnClose) {
+          restoreFocus();
+        }
+      };
+    };
+    t14 = [autoFocusFirst, trapDisabled, focusBackOnClose, focusFirst];
+    $[16] = autoFocusFirst;
+    $[17] = focusBackOnClose;
+    $[18] = trapDisabled;
+    $[19] = t13;
+    $[20] = t14;
+  } else {
+    t13 = $[19];
+    t14 = $[20];
   }
-  function focusElement(first = true) {
-    const node = nodeRef.current;
-    if (!node) {
-      return;
-    }
-    const tabables = [...node.querySelectorAll(FOCUSABLE_ELEMENTS)].filter(item => item.tabIndex >= 0);
-    const toBeFocused = first ? tabables[0] : tabables[tabables.length - 1];
-    if (toBeFocused) {
-      toBeFocused.focus();
-    }
+  useEffect(t13, t14);
+  let t15;
+  if ($[21] !== focusBackOnExit) {
+    t15 = function focusLastIfEnabled(event) {
+      if (trapWithoutFocusRef.current) {
+        return;
+      }
+      if (focusBackOnExit) {
+        const prevFocused = event.nativeEvent.relatedTarget;
+        if (prevFocused && nodeRef.current && prevFocused instanceof Element && nodeRef.current.contains(prevFocused)) {
+          restoreFocus();
+        }
+      } else {
+        focusLast();
+      }
+    };
+    $[21] = focusBackOnExit;
+    $[22] = t15;
+  } else {
+    t15 = $[22];
   }
-  function focusLastIfEnabled(event) {
-    if (trapWithoutFocusRef.current) {
-      return;
-    }
-    if (focusBackOnExit) {
-      const prevFocused = event.nativeEvent.relatedTarget;
-      if (prevFocused && nodeRef.current && prevFocused instanceof Element && nodeRef.current.contains(prevFocused)) {
-        restoreFocus();
+  const focusLastIfEnabled = t15;
+  let t16;
+  if ($[23] === Symbol.for("react.memo_cache_sentinel")) {
+    t16 = function handleBlurIfWithoutFocus(event_0) {
+      if (!trapWithoutFocusRef.current) {
+        return;
+      }
+      trapWithoutFocusRef.current = false;
+      const newFocused = event_0.nativeEvent.relatedTarget;
+      if (!newFocused) {
+        return;
+      }
+      if (newFocused instanceof Element && nodeRef.current?.contains(newFocused)) {
+        return;
       }
-    } else {
       focusLast();
-    }
-  }
-  function handleBlurIfWithoutFocus(event) {
-    if (!trapWithoutFocusRef.current) {
-      return;
-    }
-    trapWithoutFocusRef.current = false;
-    const newFocused = event.nativeEvent.relatedTarget;
-    if (!newFocused) {
-      return;
-    }
-    if (newFocused instanceof Element && nodeRef.current?.contains(newFocused)) {
-      return;
-    }
-    focusLast();
+    };
+    $[23] = t16;
+  } else {
+    t16 = $[23];
   }
+  const handleBlurIfWithoutFocus = t16;
   if (trapDisabled) {
-    return jsx("div", {
-      ref: nodeRef,
-      ...restProps,
-      children: children
-    });
+    let t17;
+    if ($[24] !== children || $[25] !== restProps) {
+      t17 = /*#__PURE__*/jsx("div", {
+        ref: nodeRef,
+        ...restProps,
+        children: children
+      });
+      $[24] = children;
+      $[25] = restProps;
+      $[26] = t17;
+    } else {
+      t17 = $[26];
+    }
+    return t17;
   }
-  return jsxs("div", {
-    ref: nodeRef,
-    ...restProps,
-    children: [jsx("div", {
-      // It never actually stays focused
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+  let t17;
+  if ($[27] !== focusLastIfEnabled) {
+    t17 = /*#__PURE__*/jsx("div", {
       tabIndex: 0,
       ref: trapButtonNodeRef,
       className: styles.trapButton,
       onFocus: focusLastIfEnabled,
       onBlur: handleBlurIfWithoutFocus,
       "data-trap-button": true
-    }), children, jsx("div", {
-      // It never actually stays focused
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+    });
+    $[27] = focusLastIfEnabled;
+    $[28] = t17;
+  } else {
+    t17 = $[28];
+  }
+  const t18 = focusBackOnExit ? restoreFocus : focusFirst;
+  let t19;
+  if ($[29] !== t18) {
+    t19 = /*#__PURE__*/jsx("div", {
       tabIndex: 0,
-      onFocus: focusBackOnExit ? restoreFocus : focusFirst,
+      onFocus: t18,
       "data-trap-button": true
-    })]
-  });
+    });
+    $[29] = t18;
+    $[30] = t19;
+  } else {
+    t19 = $[30];
+  }
+  let t20;
+  if ($[31] !== children || $[32] !== restProps || $[33] !== t17 || $[34] !== t19) {
+    t20 = /*#__PURE__*/jsxs("div", {
+      ref: nodeRef,
+      ...restProps,
+      children: [t17, children, t19]
+    });
+    $[31] = children;
+    $[32] = restProps;
+    $[33] = t17;
+    $[34] = t19;
+    $[35] = t20;
+  } else {
+    t20 = $[35];
+  }
+  return t20;
 });
+function _temp(item) {
+  return item.tabIndex >= 0;
+}
 
 export { FOCUSABLE_ELEMENTS, TabTrap as default };

package/components/table/cell.d.ts

@@ -3,5 +3,5 @@ export interface CellProps extends TdHTMLAttributes<HTMLTableDataCellElement> {
     'data-test'?: string | null | undefined;
 }
 export default class Cell extends PureComponent<CellProps> {
-    render(): import("react/jsx-runtime").JSX.Element;
+    render(): import("react").JSX.Element;
 }

package/components/table/cell.js

@@ -1,13 +1,13 @@
-import { jsx } from 'react/jsx-runtime';
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import joinDataTestAttributes from '../global/data-tests.js';
 import { s as style } from '../_helpers/table.js';
+import { jsx } from 'react/jsx-runtime';
 
 class Cell extends PureComponent {
   render() {
     const classes = classNames(style.cell, this.props.className);
-    return jsx("td", {
+    return /*#__PURE__*/jsx("td", {
       ...this.props,
       className: classes,
       "data-test": joinDataTestAttributes('ring-table-cell', this.props['data-test']),

package/components/table/disable-hover-hoc.js

@@ -1,5 +1,5 @@
-import { jsx } from 'react/jsx-runtime';
 import { PureComponent } from 'react';
+import { jsx } from 'react/jsx-runtime';
 
 function disableHoverHOC(ComposedComponent) {
   return class DisableHover extends PureComponent {
@@ -23,7 +23,7 @@ function disableHoverHOC(ComposedComponent) {
       }
     };
     onKeyDown = e => {
-      const metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line @typescript-eslint/no-magic-numbers
+      const metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line no-magic-numbers
       if (!this.state.disabledHover && !metaKeys.includes(e.keyCode)) {
         this.setState({
           disabledHover: true
@@ -31,7 +31,7 @@ function disableHoverHOC(ComposedComponent) {
       }
     };
     render() {
-      return jsx(ComposedComponent, {
+      return /*#__PURE__*/jsx(ComposedComponent, {
         ...this.props,
         disabledHover: this.state.disabledHover
       });

package/components/table/header-cell.d.ts

@@ -30,5 +30,5 @@ export default class HeaderCell extends PureComponent<HeaderCellProps> {
     sorted?: boolean;
     onClick: () => void;
     onChildrenClick(e: SyntheticEvent): void;
-    render(): import("react/jsx-runtime").JSX.Element;
+    render(): import("react").JSX.Element;
 }

package/components/table/header-cell.js

@@ -1,4 +1,3 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import sortableIcon from '@jetbrains/icons/unsorted-12px';
@@ -6,9 +5,11 @@ 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/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 '../global/memoize.js';
 
 class HeaderCell extends PureComponent {
@@ -53,18 +54,18 @@ class HeaderCell extends PureComponent {
       [style.sortedUp]: sortOrder && this.sorted,
       [style.cellRight]: column.rightAlign
     });
-    return jsxs("th", {
+    return /*#__PURE__*/jsxs("th", {
       ...restProps,
       className: classes,
       onClick: this.onClick,
       "data-test": joinDataTestAttributes('ring-table-header-cell', dataTest),
-      children: [jsx("span", {
+      children: [/*#__PURE__*/jsx("span", {
         onClick: this.onChildrenClick,
-        role: 'presentation',
+        role: "presentation",
         children: this.props.children
-      }), column.getHeaderValue ? column.getHeaderValue() : column.title, this.sortable && jsx("span", {
+      }), column.getHeaderValue ? column.getHeaderValue() : column.title, this.sortable && /*#__PURE__*/jsx("span", {
         className: style.sorter,
-        children: jsx(Icon, {
+        children: /*#__PURE__*/jsx(Icon, {
           glyph: glyph,
           className: style.icon
         })

package/components/table/header.d.ts

@@ -28,7 +28,7 @@ export default class Header extends PureComponent<HeaderProps> {
     };
     id: string;
     onCheckboxFocus: (event: SyntheticEvent<HTMLElement>) => void;
-    createCells(widths?: never[]): import("react/jsx-runtime").JSX.Element[];
-    render(): import("react/jsx-runtime").JSX.Element;
+    createCells(widths?: never[]): import("react").JSX.Element[];
+    render(): import("react").JSX.Element;
 }
 export type HeaderAttrs = React.JSX.LibraryManagedAttributes<typeof Header, HeaderProps>;

package/components/table/header.js

@@ -1,16 +1,17 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import Checkbox from '../checkbox/checkbox.js';
 import getUID from '../global/get-uid.js';
-import { s as style } from '../_helpers/table.js';
 import HeaderCell from './header-cell.js';
+import { s as style } from '../_helpers/table.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
 import '@jetbrains/icons/checkmark-12px';
 import '@jetbrains/icons/remove-12px';
 import '../icon/icon.js';
 import 'util-deprecate';
 import '../icon/icon.constants.js';
 import '../_helpers/icon-svg.js';
+import 'react-compiler-runtime';
 import '../global/memoize.js';
 import '../global/compose-refs.js';
 import 'memoize-one';
@@ -48,9 +49,9 @@ class Header extends PureComponent {
       sortOrder
     } = this.props;
     const metaColumnClasses = classNames(style.metaColumn, style.headerMetaColumn);
-    const metaColumn = jsx("div", {
+    const metaColumn = /*#__PURE__*/jsx("div", {
       className: metaColumnClasses,
-      children: selectable && jsx(Checkbox, {
+      children: selectable && /*#__PURE__*/jsx(Checkbox, {
         "aria-labelledby": this.id,
         disabled: checkboxDisabled,
         checked: checked,
@@ -69,7 +70,7 @@ class Header extends PureComponent {
         sortOrder,
         style: columnStyle
       };
-      return jsx(HeaderCell, {
+      return /*#__PURE__*/jsx(HeaderCell, {
         "data-test": column.id,
         ...props,
         children: index === 0 && (draggable || selectable) && metaColumn
@@ -83,9 +84,9 @@ class Header extends PureComponent {
       topStickOffset
     } = this.props;
     const regularCells = this.createCells();
-    return jsxs("thead", {
+    return /*#__PURE__*/jsxs("thead", {
       id: this.id,
-      "data-test": 'ring-table-header',
+      "data-test": "ring-table-header",
       style: {
         top: topStickOffset
       },
@@ -93,17 +94,17 @@ class Header extends PureComponent {
         [style.tableHead]: true,
         [style.subHeaderSticky]: sticky
       }),
-      children: [caption && jsx("tr", {
-        "data-test": 'ring-table-header-row',
-        children: jsx("th", {
+      children: [caption && /*#__PURE__*/jsx("tr", {
+        "data-test": "ring-table-header-row",
+        children: /*#__PURE__*/jsx("th", {
           className: classNames(style.headerCell, style.caption),
           colSpan: regularCells.length + 1,
-          "data-test": 'ring-table-header-cell',
+          "data-test": "ring-table-header-cell",
           children: caption
         })
-      }), jsx("tr", {
+      }), /*#__PURE__*/jsx("tr", {
         className: style.subHeader,
-        "data-test": 'ring-table-header-row',
+        "data-test": "ring-table-header-row",
         children: regularCells
       })]
     });

package/components/table/multitable.d.ts

@@ -18,6 +18,6 @@ export default class MultiTable extends PureComponent<MultiTableProps> {
         'command+a': () => boolean;
         'ctrl+a': () => boolean;
     };
-    render(): import("react/jsx-runtime").JSX.Element;
+    render(): import("react").JSX.Element;
 }
 export {};

package/components/table/multitable.js

@@ -1,5 +1,5 @@
-import { jsx } from 'react/jsx-runtime';
 import { PureComponent, Children, cloneElement } from 'react';
+import { jsx } from 'react/jsx-runtime';
 
 class MultiTable extends PureComponent {
   componentDidUpdate(prevProps) {
@@ -95,8 +95,8 @@ class MultiTable extends PureComponent {
     'ctrl+a': this.onCmdAPress
   };
   render() {
-    return jsx("div", {
-      "data-test": 'ring-multitable',
+    return /*#__PURE__*/jsx("div", {
+      "data-test": "ring-multitable",
       children: Children.map(this.props.children, child => {
         const props = {
           shortcuts: this.shortcuts

package/components/table/row-with-focus-sensor.d.ts

@@ -14,5 +14,5 @@ export default class RowWithFocusSensorCallbacks<T extends SelectionItem> extend
     onSelect: (item: T, selected: boolean) => void;
     onCollapse: () => void;
     onExpand: () => void;
-    render(): import("react/jsx-runtime").JSX.Element;
+    render(): import("react").JSX.Element;
 }

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

@@ -1,9 +1,10 @@
-import { jsx } from 'react/jsx-runtime';
 import { PureComponent } from 'react';
 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 'memoize-one';
+import 'react-compiler-runtime';
 import 'classnames';
 import '@jetbrains/icons/chevron-right';
 import '@jetbrains/icons/chevron-down';
@@ -61,7 +62,7 @@ class RowWithFocusSensorCallbacks extends PureComponent {
     this.props.onExpand?.(this.props.item);
   };
   render() {
-    return jsx(this.RowWithFocusSensor, {
+    return /*#__PURE__*/jsx(this.RowWithFocusSensor, {
       ...this.props,
       onFocus: this.onFocus,
       onSelect: this.onSelect,

package/components/table/row.d.ts

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