rsuite 6.1.2 → 6.1.3

package/esm/internals/Picker/PickerPopup.js

@@ -24,18 +24,17 @@ const PickerPopup = forwardRef((props, ref) => {
   } = props;
   const overlayRef = useRef(null);
   const handleResize = useEventCallback(() => {
-    const instance = target === null || target === void 0 ? void 0 : target.current;
+    const instance = target?.current;
     if (instance && placement && resizePlacement.includes(placement)) {
-      var _instance$updatePosit;
-      (_instance$updatePosit = instance.updatePosition) === null || _instance$updatePosit === void 0 || _instance$updatePosit.call(instance);
+      instance.updatePosition?.();
     }
   });
 
   // Use useElementResize hook to listen for element size changes
   useElementResize(useCallback(() => overlayRef.current, []), handleResize);
   useEffect(() => {
-    const toggle = target === null || target === void 0 ? void 0 : target.current;
-    if (autoWidth && toggle !== null && toggle !== void 0 && toggle.root) {
+    const toggle = target?.current;
+    if (autoWidth && toggle?.root) {
       // Get the width of the button and set it to the menu to make them consistent
       const width = getWidth(getDOMNode(toggle.root));
       if (overlayRef.current) {

package/esm/internals/Picker/PickerToggle.js

@@ -59,13 +59,12 @@ const PickerToggle = forwardRef((props, ref) => {
   }, [inputValueProp]);
   const classes = merge(className, withPrefix());
   const handleClean = useEventCallback(event => {
-    var _combobox$current;
     event.stopPropagation();
-    onClean === null || onClean === void 0 || onClean(event);
-    (_combobox$current = combobox.current) === null || _combobox$current === void 0 || _combobox$current.focus();
+    onClean?.(event);
+    combobox.current?.focus();
   });
   const ToggleCaret = useToggleCaret(placement);
-  const Caret = caretAs !== null && caretAs !== void 0 ? caretAs : ToggleCaret;
+  const Caret = caretAs ?? ToggleCaret;
   if (plaintext) {
     return /*#__PURE__*/React.createElement(Plaintext, {
       ref: ref,

package/esm/internals/Picker/SelectedElement.js

@@ -36,7 +36,7 @@ const SelectedElement = props => {
       key: item[valueKey]
     }, /*#__PURE__*/React.createElement("span", {
       className: prefix('value-item')
-    }, item[labelKey], checkAll && locale !== null && locale !== void 0 && locale.checkAll ? ` (${locale.checkAll})` : ''), index === count - 1 ? null : /*#__PURE__*/React.createElement("span", {
+    }, item[labelKey], checkAll && locale?.checkAll ? ` (${locale.checkAll})` : ''), index === count - 1 ? null : /*#__PURE__*/React.createElement("span", {
       className: prefix('value-separator')
     }, ","));
   })), countable ? /*#__PURE__*/React.createElement(Badge, {

package/esm/internals/Picker/hooks/useFocusItemValue.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface FocusItemValueProps<T = unknown> {
     target: HTMLElement | null | (() => HTMLElement | null);
     data?: T[];

package/esm/internals/Picker/hooks/useFocusItemValue.js

@@ -25,7 +25,7 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
     callback,
     // TODO-Doma This legacy behavior of using `.parent` property should be deprecated
     //           Always explicitly pass `getParent` when there's need to traverse upwards
-    getParent = item => item === null || item === void 0 ? void 0 : item.parent
+    getParent = item => item?.parent
   } = props;
   const [focusItemValue, setFocusItemValue] = useState(defaultFocusItemValue);
   const [layer, setLayer] = useState(defaultLayer);
@@ -33,22 +33,22 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
   const focusCallback = useEventCallback((value, event) => {
     if (focusToOption) {
       const menu = isFunction(target) ? target() : target;
-      const focusElement = menu === null || menu === void 0 ? void 0 : menu.querySelector(`[data-key="${value}"]`);
-      focusElement === null || focusElement === void 0 || focusElement.focus();
+      const focusElement = menu?.querySelector(`[data-key="${value}"]`);
+      focusElement?.focus();
     }
-    callback === null || callback === void 0 || callback(value, event);
+    callback?.(value, event);
   });
   const getScrollContainer = useEventCallback(() => {
     const menu = isFunction(target) ? target() : target;
 
     // For Cascader and MutiCascader
-    const subMenu = menu === null || menu === void 0 ? void 0 : menu.querySelector(`[data-layer="${layer}"]`);
+    const subMenu = menu?.querySelector(`[data-layer="${layer}"]`);
     if (subMenu) {
       return subMenu;
     }
 
     // For SelectPicker、CheckPicker、Autocomplete、InputPicker、TagPicker
-    return menu === null || menu === void 0 ? void 0 : menu.querySelector('[role="listbox"]');
+    return menu?.querySelector('[role="listbox"]');
   });
 
   /**
@@ -61,19 +61,11 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
     let currentKeys = keys;
     if (layer < 1) {
       const popup = isFunction(target) ? target() : target;
-      const rootMenu = popup === null || popup === void 0 ? void 0 : popup.querySelector('[data-layer="0"]');
+      const rootMenu = popup?.querySelector('[data-layer="0"]');
       if (rootMenu) {
-        var _rootMenu$querySelect;
-        currentKeys = Array.from((_rootMenu$querySelect = rootMenu.querySelectorAll(focusableQueryKey)) !== null && _rootMenu$querySelect !== void 0 ? _rootMenu$querySelect : []).map(item => {
-          var _item$dataset;
-          return (_item$dataset = item.dataset) === null || _item$dataset === void 0 ? void 0 : _item$dataset.key;
-        });
+        currentKeys = Array.from(rootMenu.querySelectorAll(focusableQueryKey) ?? []).map(item => item.dataset?.key);
       } else {
-        var _popup$querySelectorA;
-        currentKeys = Array.from((_popup$querySelectorA = popup === null || popup === void 0 ? void 0 : popup.querySelectorAll(focusableQueryKey)) !== null && _popup$querySelectorA !== void 0 ? _popup$querySelectorA : []).map(item => {
-          var _item$dataset2;
-          return (_item$dataset2 = item.dataset) === null || _item$dataset2 === void 0 ? void 0 : _item$dataset2.key;
-        });
+        currentKeys = Array.from(popup?.querySelectorAll(focusableQueryKey) ?? []).map(item => item.dataset?.key);
       }
     }
 
@@ -88,8 +80,7 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
   const findFocusItemIndex = useEventCallback(callback => {
     const items = getFocusableMenuItems();
     for (let i = 0; i < items.length; i += 1) {
-      var _items$i;
-      if (shallowEqual(focusItemValue, (_items$i = items[i]) === null || _items$i === void 0 ? void 0 : _items$i[valueKey])) {
+      if (shallowEqual(focusItemValue, items[i]?.[valueKey])) {
         callback(items, i);
         return;
       }
@@ -98,7 +89,7 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
   });
   const scrollListItem = useEventCallback((direction, itemValue, willOverflow) => {
     const container = getScrollContainer();
-    const item = container === null || container === void 0 ? void 0 : container.querySelector(`[data-key="${itemValue}"]`);
+    const item = container?.querySelector(`[data-key="${itemValue}"]`);
     if (willOverflow && container) {
       const {
         scrollHeight,
@@ -140,13 +131,9 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
   });
   const getSubMenuKeys = nextLayer => {
     const menu = isFunction(target) ? target() : target;
-    const subMenu = menu === null || menu === void 0 ? void 0 : menu.querySelector(`[data-layer="${nextLayer}"]`);
+    const subMenu = menu?.querySelector(`[data-layer="${nextLayer}"]`);
     if (subMenu) {
-      var _Array$from;
-      return (_Array$from = Array.from(subMenu.querySelectorAll(focusableQueryKey))) === null || _Array$from === void 0 ? void 0 : _Array$from.map(item => {
-        var _item$dataset3;
-        return (_item$dataset3 = item.dataset) === null || _item$dataset3 === void 0 ? void 0 : _item$dataset3.key;
-      });
+      return Array.from(subMenu.querySelectorAll(focusableQueryKey))?.map(item => item.dataset?.key);
     }
     return null;
   };
@@ -164,11 +151,10 @@ const useFocusItemValue = (defaultFocusItemValue, props) => {
     const nextLayer = layer - 1;
     const nextKeys = getSubMenuKeys(nextLayer);
     if (nextKeys) {
-      var _getParent;
       setKeys(nextKeys);
       setLayer(nextLayer);
       const focusItem = findNodeOfTree(data, item => item[valueKey] === focusItemValue);
-      const parentItemValue = (_getParent = getParent(focusItem)) === null || _getParent === void 0 ? void 0 : _getParent[valueKey];
+      const parentItemValue = getParent(focusItem)?.[valueKey];
       if (parentItemValue) {
         setFocusItemValue(parentItemValue);
         focusCallback(parentItemValue, event);

package/esm/internals/Picker/hooks/usePickerRef.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { OverlayTriggerHandle } from '../../Overlay';
 import type { ListHandle } from '../../Windowing';
 /**

package/esm/internals/Picker/hooks/usePickerRef.js

@@ -14,43 +14,37 @@ function usePickerRef(ref) {
   const searchInput = useRef(null);
   const treeView = useRef(null);
   const handleOpen = useEventCallback(() => {
-    var _trigger$current;
-    trigger === null || trigger === void 0 || (_trigger$current = trigger.current) === null || _trigger$current === void 0 || _trigger$current.open();
+    trigger?.current?.open();
   });
   const handleClose = useEventCallback(() => {
-    var _trigger$current2;
-    trigger === null || trigger === void 0 || (_trigger$current2 = trigger.current) === null || _trigger$current2 === void 0 || _trigger$current2.close();
+    trigger?.current?.close();
   });
   const handleUpdatePosition = useEventCallback(() => {
-    var _trigger$current3;
-    trigger === null || trigger === void 0 || (_trigger$current3 = trigger.current) === null || _trigger$current3 === void 0 || _trigger$current3.updatePosition();
+    trigger?.current?.updatePosition();
   });
   useImperativeHandle(ref, () => {
     return {
       get root() {
-        var _ref, _trigger$current4;
-        return (_ref = (root === null || root === void 0 ? void 0 : root.current) || (trigger === null || trigger === void 0 || (_trigger$current4 = trigger.current) === null || _trigger$current4 === void 0 ? void 0 : _trigger$current4.root)) !== null && _ref !== void 0 ? _ref : null;
+        return (root?.current || trigger?.current?.root) ?? null;
       },
       get overlay() {
-        var _overlay$current;
-        if (!(overlay !== null && overlay !== void 0 && overlay.current)) {
+        if (!overlay?.current) {
           throw new Error('The overlay is not found. Please confirm whether the picker is open.');
         }
-        return (_overlay$current = overlay === null || overlay === void 0 ? void 0 : overlay.current) !== null && _overlay$current !== void 0 ? _overlay$current : null;
+        return overlay?.current ?? null;
       },
       get target() {
-        var _target$current;
-        return (_target$current = target === null || target === void 0 ? void 0 : target.current) !== null && _target$current !== void 0 ? _target$current : null;
+        return target?.current ?? null;
       },
       get list() {
-        if (!(list !== null && list !== void 0 && list.current)) {
+        if (!list?.current) {
           throw new Error(`
             The list is not found.
             1.Please set virtualized for the component.
             2.Please confirm whether the picker is open.
           `);
         }
-        return list === null || list === void 0 ? void 0 : list.current;
+        return list?.current;
       },
       type: RSUITE_PICKER_TYPE,
       updatePosition: handleUpdatePosition,

package/esm/internals/Picker/hooks/useSearch.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface SearchOptions<T> {
     labelKey: string;
     searchBy?: (keyword: string, label: any, item: T) => boolean;

package/esm/internals/Picker/hooks/useSearch.js

@@ -23,7 +23,7 @@ function useSearch(data, props) {
    * @param {node} label
    */
   const checkShouldDisplay = useCallback((item, keyword) => {
-    const checkValue = typeof item === 'object' ? item === null || item === void 0 ? void 0 : item[labelKey] : String(item);
+    const checkValue = typeof item === 'object' ? item?.[labelKey] : String(item);
     const _keyword = isUndefined(keyword) ? searchKeyword : keyword;
     if (typeof searchBy === 'function') {
       return searchBy(_keyword, checkValue, item);
@@ -36,7 +36,7 @@ function useSearch(data, props) {
   const handleSearch = (searchKeyword, event) => {
     const filteredData = data.filter(item => checkShouldDisplay(item, searchKeyword));
     setSearchKeyword(searchKeyword);
-    callback === null || callback === void 0 || callback(searchKeyword, filteredData, event);
+    callback?.(searchKeyword, filteredData, event);
   };
   return {
     searchKeyword,

package/esm/internals/Picker/hooks/useToggleKeyDownEvent.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface ToggleKeyDownEventProps {
     toggle?: boolean;
     trigger: React.RefObject<any>;

package/esm/internals/Picker/hooks/useToggleKeyDownEvent.js

@@ -23,15 +23,13 @@ const useToggleKeyDownEvent = props => {
     onMenuPressBackspace
   } = props;
   const handleClose = useEventCallback(() => {
-    var _trigger$current, _trigger$current$clos, _trigger$current2, _trigger$current2$foc;
-    (_trigger$current = trigger.current) === null || _trigger$current === void 0 || (_trigger$current$clos = _trigger$current.close) === null || _trigger$current$clos === void 0 || _trigger$current$clos.call(_trigger$current);
+    trigger.current?.close?.();
 
     // The focus is on the trigger button after closing
-    (_trigger$current2 = trigger.current) === null || _trigger$current2 === void 0 || (_trigger$current2$foc = _trigger$current2.focus) === null || _trigger$current2$foc === void 0 || _trigger$current2$foc.call(_trigger$current2);
+    trigger.current?.focus?.();
   });
   const handleOpen = useEventCallback(() => {
-    var _trigger$current3, _trigger$current3$ope;
-    (_trigger$current3 = trigger.current) === null || _trigger$current3 === void 0 || (_trigger$current3$ope = _trigger$current3.open) === null || _trigger$current3$ope === void 0 || _trigger$current3$ope.call(_trigger$current3);
+    trigger.current?.open?.();
   });
   const handleToggleDropdown = useEventCallback(() => {
     if (active) {
@@ -45,7 +43,7 @@ const useToggleKeyDownEvent = props => {
     if (readOnly || disabled || loading) {
       return;
     }
-    if (event.target === (target === null || target === void 0 ? void 0 : target.current)) {
+    if (event.target === target?.current) {
       // enter
       if (toggle && event.key === KEY_VALUES.ENTER) {
         handleToggleDropdown();
@@ -53,32 +51,30 @@ const useToggleKeyDownEvent = props => {
 
       // delete
       if (event.key === KEY_VALUES.BACKSPACE) {
-        onExit === null || onExit === void 0 || onExit(event);
+        onExit?.(event);
       }
     }
-    if (overlay !== null && overlay !== void 0 && overlay.current) {
+    if (overlay?.current) {
       // The keyboard operation callback on the menu.
-      onMenuKeyDown === null || onMenuKeyDown === void 0 || onMenuKeyDown(event);
+      onMenuKeyDown?.(event);
       if (event.key === KEY_VALUES.ENTER) {
-        onMenuPressEnter === null || onMenuPressEnter === void 0 || onMenuPressEnter(event);
+        onMenuPressEnter?.(event);
       }
 
       /**
        * There is no callback when typing the Backspace key in the search box.
        * The default is to remove search keywords
        */
-      if (event.key === KEY_VALUES.BACKSPACE && event.target !== (searchInput === null || searchInput === void 0 ? void 0 : searchInput.current)) {
-        onMenuPressBackspace === null || onMenuPressBackspace === void 0 || onMenuPressBackspace(event);
+      if (event.key === KEY_VALUES.BACKSPACE && event.target !== searchInput?.current) {
+        onMenuPressBackspace?.(event);
       }
 
       // The search box gets focus when typing characters and numbers.
       if (event.key.length === 1 && /\w/.test(event.key)) {
-        var _event$target;
         // Exclude Input
         // eg: <SelectPicker renderExtraFooter={() => <Input />} />
-        if (((_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.tagName) !== 'INPUT') {
-          var _searchInput$current;
-          searchInput === null || searchInput === void 0 || (_searchInput$current = searchInput.current) === null || _searchInput$current === void 0 || _searchInput$current.focus();
+        if (event.target?.tagName !== 'INPUT') {
+          searchInput?.current?.focus();
         }
       }
     }
@@ -87,7 +83,7 @@ const useToggleKeyDownEvent = props => {
     }
 
     // Native event callback
-    onKeyDown === null || onKeyDown === void 0 || onKeyDown(event);
+    onKeyDown?.(event);
   });
   return onToggle;
 };

package/esm/internals/Picker/utils.js

@@ -54,44 +54,44 @@ export function onMenuKeyDown(event, events) {
   switch (event.key) {
     // down
     case KEY_VALUES.DOWN:
-      down === null || down === void 0 || down(event);
+      down?.(event);
       event.preventDefault();
       break;
     // up
     case KEY_VALUES.UP:
-      up === null || up === void 0 || up(event);
+      up?.(event);
       event.preventDefault();
       break;
     // enter
     case KEY_VALUES.ENTER:
-      enter === null || enter === void 0 || enter(event);
+      enter?.(event);
       event.preventDefault();
       break;
     // delete
     case KEY_VALUES.BACKSPACE:
-      del === null || del === void 0 || del(event);
+      del?.(event);
       break;
     // esc | tab
     case KEY_VALUES.ESC:
     case KEY_VALUES.TAB:
-      esc === null || esc === void 0 || esc(event);
+      esc?.(event);
       break;
     // left arrow
     case KEY_VALUES.LEFT:
-      left === null || left === void 0 || left(event);
+      left?.(event);
       break;
     // right arrow
     case KEY_VALUES.RIGHT:
-      right === null || right === void 0 || right(event);
+      right?.(event);
       break;
     // home
     case KEY_VALUES.HOME:
-      home === null || home === void 0 || home(event);
+      home?.(event);
       event.preventDefault();
       break;
     // end
     case KEY_VALUES.END:
-      end === null || end === void 0 || end(event);
+      end?.(event);
       event.preventDefault();
       break;
     default:

package/esm/internals/Ripple/Ripple.js

@@ -53,16 +53,15 @@ const Ripple = forwardRef((props, ref) => {
       const position = getPosition(triggerRef.current, event);
       setRippling(true);
       setPosition(position);
-      onMouseDown === null || onMouseDown === void 0 || onMouseDown(position, event);
+      onMouseDown?.(position, event);
     }
   }, [onMouseDown]);
   useEffect(() => {
-    var _triggerRef$current;
-    const parentNode = (_triggerRef$current = triggerRef.current) === null || _triggerRef$current === void 0 ? void 0 : _triggerRef$current.parentNode;
+    const parentNode = triggerRef.current?.parentNode;
     if (parentNode) {
       const mousedownListener = on(parentNode, 'mousedown', handleMouseDown);
       return () => {
-        mousedownListener === null || mousedownListener === void 0 || mousedownListener.off();
+        mousedownListener?.off();
       };
     }
   }, [handleMouseDown]);

package/esm/internals/SafeAnchor/SafeAnchor.js

@@ -31,7 +31,7 @@ const SafeAnchor = forwardRef((props, ref) => {
       event.stopPropagation();
       return;
     }
-    onClick === null || onClick === void 0 || onClick(event);
+    onClick?.(event);
   }, [disabled, href, onClick]);
 
   // There are default role and href attributes on the node to ensure Focus management and keyboard interactions.

package/esm/internals/ScrollView/hooks/useScrollState.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export declare function useScrollState(scrollShadow?: boolean): {
     scrollState: "top" | "bottom" | "middle" | null;
     handleScroll: ((...args: any[]) => any) | undefined;

package/esm/internals/ScrollView/hooks/useScrollState.js

@@ -27,7 +27,7 @@ export function useScrollState(scrollShadow) {
 
       // Listen for changes in scrollHeight
       observer = new MutationObserver(() => {
-        const newScrollHeight = target === null || target === void 0 ? void 0 : target.scrollHeight;
+        const newScrollHeight = target?.scrollHeight;
         if (newScrollHeight && newScrollHeight !== lastScrollHeight) {
           setScrollState(getScrollState(target));
           lastScrollHeight = newScrollHeight;
@@ -40,8 +40,7 @@ export function useScrollState(scrollShadow) {
       });
     }
     return () => {
-      var _observer;
-      (_observer = observer) === null || _observer === void 0 || _observer.disconnect();
+      observer?.disconnect();
     };
   });
   const handleScroll = useEventCallback(event => {

package/esm/internals/Tree/TreeProvider.d.ts

@@ -38,10 +38,10 @@ export declare const useTreeContextProps: () => {
     labelKey: string;
     valueKey: string;
     childrenKey: string;
-    virtualized?: boolean | undefined;
-    scrollShadow?: boolean | undefined;
-    renderTreeNode?: ((nodeData: TreeNode) => React.ReactNode) | undefined;
-    renderTreeIcon?: ((nodeData: TreeNode, expanded?: boolean) => React.ReactNode) | undefined;
+    virtualized?: boolean;
+    scrollShadow?: boolean;
+    renderTreeNode?: (nodeData: TreeNode) => React.ReactNode;
+    renderTreeIcon?: (nodeData: TreeNode, expanded?: boolean) => React.ReactNode;
 };
 /**
  * Custom hook that provides imperative handle for the Tree component.

package/esm/internals/Tree/TreeProvider.js

@@ -68,13 +68,7 @@ export const useTreeImperativeHandle = () => {
   }, []);
   return {
     register,
-    focusFirstNode: () => {
-      var _focusFirstNodeRef$cu;
-      return (_focusFirstNodeRef$cu = focusFirstNodeRef.current) === null || _focusFirstNodeRef$cu === void 0 ? void 0 : _focusFirstNodeRef$cu.call(focusFirstNodeRef);
-    },
-    focusActiveNode: () => {
-      var _focusActiveNodeRef$c;
-      return (_focusActiveNodeRef$c = focusActiveNodeRef.current) === null || _focusActiveNodeRef$c === void 0 ? void 0 : _focusActiveNodeRef$c.call(focusActiveNodeRef);
-    }
+    focusFirstNode: () => focusFirstNodeRef.current?.(),
+    focusActiveNode: () => focusActiveNodeRef.current?.()
   };
 };

package/esm/internals/Tree/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { CheckStateType } from '../constants';
 /**
  * Represents a single node in a tree.

package/esm/internals/Tree/utils/getParentMap.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 /**
  * Returns a WeakMap that maps each item in `items` to its parent
  * indicated by `getChildren` function

package/esm/internals/Windowing/AutoSizer.js

@@ -26,8 +26,7 @@ const AutoSizer = /*#__PURE__*/React.forwardRef((props, ref) => {
   const [width, setWidth] = useState(defaultWidth || 0);
   const rootRef = useRef(null);
   const getParentNode = useCallback(() => {
-    var _rootRef$current;
-    if ((_rootRef$current = rootRef.current) !== null && _rootRef$current !== void 0 && _rootRef$current.parentNode && rootRef.current.parentNode.ownerDocument && rootRef.current.parentNode.ownerDocument.defaultView && rootRef.current.parentNode instanceof rootRef.current.parentNode.ownerDocument.defaultView.HTMLElement) {
+    if (rootRef.current?.parentNode && rootRef.current.parentNode.ownerDocument && rootRef.current.parentNode.ownerDocument.defaultView && rootRef.current.parentNode instanceof rootRef.current.parentNode.ownerDocument.defaultView.HTMLElement) {
       return rootRef.current.parentNode;
     }
     return null;
@@ -47,7 +46,7 @@ const AutoSizer = /*#__PURE__*/React.forwardRef((props, ref) => {
       if (!disableHeight && height !== newHeight || !disableWidth && width !== newWidth) {
         setHeight(offsetHeight - paddingTop - paddingBottom);
         setWidth(offsetWidth - paddingLeft - paddingRight);
-        onResize === null || onResize === void 0 || onResize({
+        onResize?.({
           height: offsetHeight,
           width: offsetWidth
         });

package/esm/internals/Windowing/List.js

@@ -32,20 +32,16 @@ const List = forwardRef((props, ref) => {
   } = useCustom();
   useImperativeHandle(ref, () => ({
     resetAfterIndex: (index, shouldForceUpdate) => {
-      var _listRef$current, _listRef$current$rese;
-      (_listRef$current = listRef.current) === null || _listRef$current === void 0 || (_listRef$current$rese = _listRef$current.resetAfterIndex) === null || _listRef$current$rese === void 0 || _listRef$current$rese.call(_listRef$current, index, shouldForceUpdate);
+      listRef.current?.resetAfterIndex?.(index, shouldForceUpdate);
     },
     scrollTo: scrollOffset => {
-      var _listRef$current2, _listRef$current2$scr;
-      (_listRef$current2 = listRef.current) === null || _listRef$current2 === void 0 || (_listRef$current2$scr = _listRef$current2.scrollTo) === null || _listRef$current2$scr === void 0 || _listRef$current2$scr.call(_listRef$current2, scrollOffset);
+      listRef.current?.scrollTo?.(scrollOffset);
     },
     scrollToItem: (index, align) => {
-      var _listRef$current3, _listRef$current3$scr;
-      (_listRef$current3 = listRef.current) === null || _listRef$current3 === void 0 || (_listRef$current3$scr = _listRef$current3.scrollToItem) === null || _listRef$current3$scr === void 0 || _listRef$current3$scr.call(_listRef$current3, index, align);
+      listRef.current?.scrollToItem?.(index, align);
     },
     scrollToRow: index => {
-      var _listRef$current4, _listRef$current4$scr;
-      (_listRef$current4 = listRef.current) === null || _listRef$current4 === void 0 || (_listRef$current4$scr = _listRef$current4.scrollToItem) === null || _listRef$current4$scr === void 0 || _listRef$current4$scr.call(_listRef$current4, index);
+      listRef.current?.scrollToItem?.(index);
     }
   }));
   const setRowHeight = useCallback(index => {

package/esm/internals/constants/index.d.ts

@@ -19,8 +19,8 @@ export type CheckStateType = CHECK_STATE.UNCHECK | CHECK_STATE.CHECK | CHECK_STA
  * Tree Node Drag Type
  */
 export declare enum TREE_NODE_DROP_POSITION {
-    DRAG_OVER = 0,
-    DRAG_OVER_TOP = 1,
+    DRAG_OVER = 0,// drag node in tree node
+    DRAG_OVER_TOP = 1,// drag node on tree node
     DRAG_OVER_BOTTOM = 2
 }
 /**

package/esm/internals/hooks/useClickOutside.js

@@ -14,10 +14,8 @@ export function useClickOutside({
   useEffect(() => {
     if (enabled) {
       const eventHandler = event => {
-        var _isOutsideRef$current;
-        if ((_isOutsideRef$current = isOutsideRef.current) !== null && _isOutsideRef$current !== void 0 && _isOutsideRef$current.call(isOutsideRef, event)) {
-          var _handleRef$current;
-          (_handleRef$current = handleRef.current) === null || _handleRef$current === void 0 || _handleRef$current.call(handleRef, event);
+        if (isOutsideRef.current?.(event)) {
+          handleRef.current?.(event);
         }
       };
       window.addEventListener('mousedown', eventHandler);

package/esm/internals/hooks/useCustom.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import enGB from '../../locales/en_GB';
 import type { FormatDateOptions } from '../utils/date/types';
 import type { ReactSuiteComponents } from '../Provider/types';

package/esm/internals/hooks/useCustom.js

@@ -38,7 +38,6 @@ function getComponentLocaleKey(componentName) {
  * @param componentProps - The props of the component
  */
 export function useCustom(componentName, componentProps) {
-  var _globalLocale$DateTim;
   const {
     components = {},
     locale: globalLocale = enGB,
@@ -53,26 +52,25 @@ export function useCustom(componentName, componentProps) {
     locale: componentLocale,
     ...restProps
   } = componentProps || {};
-  const dateLocale = globalLocale === null || globalLocale === void 0 || (_globalLocale$DateTim = globalLocale.DateTimeFormats) === null || _globalLocale$DateTim === void 0 ? void 0 : _globalLocale$DateTim.dateLocale;
-  const code = globalLocale === null || globalLocale === void 0 ? void 0 : globalLocale.code;
+  const dateLocale = globalLocale?.DateTimeFormats?.dateLocale;
+  const code = globalLocale?.code;
   const getLocale = useCallback((key, overrideLocale) => {
     // Initialize with common locale
-    const publicLocale = (globalLocale === null || globalLocale === void 0 ? void 0 : globalLocale.common) || {};
+    const publicLocale = globalLocale?.common || {};
 
     // Merge component-specific locale(s) based on key type
-    const specificLocale = typeof key === 'string' ? globalLocale === null || globalLocale === void 0 ? void 0 : globalLocale[key] : Array.isArray(key) ? assign({}, ...key.map(k => globalLocale === null || globalLocale === void 0 ? void 0 : globalLocale[k])) : {};
+    const specificLocale = typeof key === 'string' ? globalLocale?.[key] : Array.isArray(key) ? assign({}, ...key.map(k => globalLocale?.[k])) : {};
 
     // Merge all parts: public locale, specific locale, custom component locale
     return assign({}, publicLocale, specificLocale, componentLocale, overrideLocale);
   }, [globalLocale, componentLocale]);
   const propsWithDefaults = useMemo(() => {
-    var _components$component;
     if (!componentName) {
       return;
     }
 
     //Memoize the global default props based on component name
-    const globalDefaultProps = ((_components$component = components[componentName]) === null || _components$component === void 0 ? void 0 : _components$component.defaultProps) || {};
+    const globalDefaultProps = components[componentName]?.defaultProps || {};
     const mergedProps = assign({}, globalDefaultProps, restProps);
     const localeKey = getComponentLocaleKey(componentName);
 

package/esm/internals/hooks/useElementResize.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 /**
  * Attach the event handler directly to the specified DOM element,
  * and it will be triggered when the size of the DOM element is changed.

package/esm/internals/hooks/useEventCallback.js

@@ -17,8 +17,7 @@ export function useEventCallback(fn) {
     ref.current = fn;
   });
   return useCallback((...args) => {
-    var _ref$current;
-    return (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.call(ref, ...args);
+    return ref.current?.(...args);
   }, []);
 }
 export default useEventCallback;

package/esm/internals/hooks/useEventListener.js

@@ -15,7 +15,7 @@ export function useEventListener(eventTarget, event, listener, capture = false)
     const target = typeof eventTarget === 'function' ? eventTarget() : eventTarget;
     const controller = target ? on(target, event, listener, capture) : null;
     return () => {
-      controller === null || controller === void 0 || controller.off();
+      controller?.off();
     };
   }, [eventTarget, event, listener, capture]);
 }