rsuite 6.1.2 → 6.1.3

package/esm/InlineEdit/useEditState.js

@@ -23,40 +23,37 @@ const useEditState = props => {
     if (disabled) {
       return;
     }
-    onClick === null || onClick === void 0 || onClick(event);
-    onEdit === null || onEdit === void 0 || onEdit(event);
+    onClick?.(event);
+    onEdit?.(event);
     setIsEditing(true);
     setResetValue(value);
   });
   const handleFocus = useEventCallback(event => {
     if (disabled || isEditing) return;
-    onFocus === null || onFocus === void 0 || onFocus(event);
+    onFocus?.(event);
     setIsEditing(true);
     setResetValue(value);
   });
   const handleChange = useEventCallback((value, event) => {
     setValue(value);
-    onChange === null || onChange === void 0 || onChange(value, event);
+    onChange?.(value, event);
   });
   const handleCancel = useEventCallback(event => {
-    var _event$stopPropagatio;
     setIsEditing(false);
     setValue(resetValue);
-    onCancel === null || onCancel === void 0 || onCancel(event);
-    event === null || event === void 0 || (_event$stopPropagatio = event.stopPropagation) === null || _event$stopPropagatio === void 0 || _event$stopPropagatio.call(event);
+    onCancel?.(event);
+    event?.stopPropagation?.();
   });
   const handleSave = useEventCallback(event => {
-    var _event$stopPropagatio2;
     setIsEditing(false);
-    onSave === null || onSave === void 0 || onSave(event);
-    event === null || event === void 0 || (_event$stopPropagatio2 = event.stopPropagation) === null || _event$stopPropagatio2 === void 0 || _event$stopPropagatio2.call(event);
+    onSave?.(event);
+    event?.stopPropagation?.();
   });
   const handleKeyDown = useEventCallback(event => {
-    var _event$target;
     if (isEditing) {
       switch (event.key) {
         case 'Enter':
-          if (((_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.tagName) === 'INPUT') {
+          if (event.target?.tagName === 'INPUT') {
             handleSave(event);
           }
           break;

package/esm/InlineEdit/useFocusEvent.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { PickerHandle } from '../internals/Picker/types';
 interface FocusEventProps {
     isEditing: boolean;

package/esm/InlineEdit/useFocusEvent.js

@@ -9,38 +9,34 @@ const useFocusEvent = ({
   onSave,
   onCancel
 }) => {
-  var _ref$current;
   const ref = useRef(null);
   const rootRef = useRef(null);
-  const isPicker = ((_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.type) === RSUITE_PICKER_TYPE;
+  const isPicker = ref.current?.type === RSUITE_PICKER_TYPE;
   const focus = () => {
     if (isPicker) {
       setTimeout(() => {
-        var _picker$target, _picker$target$focus, _picker$open;
         const picker = ref.current;
         // Auto focus the search input
-        picker === null || picker === void 0 || (_picker$target = picker.target) === null || _picker$target === void 0 || (_picker$target$focus = _picker$target.focus) === null || _picker$target$focus === void 0 || _picker$target$focus.call(_picker$target);
+        picker?.target?.focus?.();
 
         // Open the picker
-        picker === null || picker === void 0 || (_picker$open = picker.open) === null || _picker$open === void 0 || _picker$open.call(picker);
+        picker?.open?.();
       }, 100);
     } else {
-      var _ref$current2, _ref$current2$focus;
-      (_ref$current2 = ref.current) === null || _ref$current2 === void 0 || (_ref$current2$focus = _ref$current2.focus) === null || _ref$current2$focus === void 0 || _ref$current2$focus.call(_ref$current2);
+      ref.current?.focus?.();
     }
   };
   const handleBlur = useEventCallback(event => {
     if (event) {
-      var _event$relatedTarget;
-      const relatedTarget = (_event$relatedTarget = event.relatedTarget) !== null && _event$relatedTarget !== void 0 ? _event$relatedTarget : ownerDocument(event.currentTarget).activeElement;
+      const relatedTarget = event.relatedTarget ?? ownerDocument(event.currentTarget).activeElement;
       if (rootRef.current && contains(rootRef.current, relatedTarget)) {
         return;
       }
     }
     if (stateOnBlur === 'save') {
-      onSave === null || onSave === void 0 || onSave(event);
+      onSave?.(event);
     } else if (stateOnBlur === 'cancel') {
-      onCancel === null || onCancel === void 0 || onCancel(event);
+      onCancel?.(event);
     }
   });
   useIsomorphicLayoutEffect(() => {

package/esm/Input/Input.js

@@ -18,7 +18,7 @@ const Input = forwardRef((props, ref) => {
   const {
     type = 'text',
     htmlSize,
-    size = (inputGroup === null || inputGroup === void 0 ? void 0 : inputGroup.size) || 'md',
+    size = inputGroup?.size || 'md',
     classPrefix = 'input',
     ...rest
   } = propsWithDefaults;

package/esm/InputGroup/InputGroupContext.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
+import type { Size } from '../internals/types';
 export declare const InputGroupContext: React.Context<{
     onFocus: () => void;
     onBlur: () => void;
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | undefined;
+    size?: Size;
 } | null>;

package/esm/InputNumber/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { NumberInputProps as InputNumberProps } from '../NumberInput';
 /**
  * The `InputNumber` component is used to enter a numerical value.

package/esm/InputPicker/InputAutosize.js

@@ -50,7 +50,7 @@ const useInputWidth = (props, sizerRef, placeholderRef) => {
     }
     if (width !== inputWidth) {
       setInputWidth(width);
-      onAutosize === null || onAutosize === void 0 || onAutosize(width);
+      onAutosize?.(width);
     }
   }, [minWidth, placeholder, inputWidth, value, placeholderRef, sizerRef, onAutosize]);
   return inputWidth;

package/esm/InputPicker/InputPicker.js

@@ -123,8 +123,7 @@ const InputPicker = forwardRef((props, ref) => {
     triggerRef
   });
   const handleDataChange = data => {
-    var _data$;
-    setFocusItemValue(data === null || data === void 0 || (_data$ = data[0]) === null || _data$ === void 0 ? void 0 : _data$[valueKey]);
+    setFocusItemValue(data?.[0]?.[valueKey]);
   };
   const {
     data,
@@ -139,11 +138,10 @@ const InputPicker = forwardRef((props, ref) => {
   const [value, setValue, isControlled] = useControlled(valueProp, multi ? defaultValue || [] : defaultValue);
   const cloneValue = () => multi ? clone(value) || [] : value;
   const handleClose = useEventCallback(() => {
-    var _triggerRef$current, _target$current, _target$current$focus;
-    triggerRef === null || triggerRef === void 0 || (_triggerRef$current = triggerRef.current) === null || _triggerRef$current === void 0 || _triggerRef$current.close();
+    triggerRef?.current?.close();
 
     // The focus is on the trigger button after closing
-    (_target$current = target.current) === null || _target$current === void 0 || (_target$current$focus = _target$current.focus) === null || _target$current$focus === void 0 || _target$current$focus.call(_target$current);
+    target.current?.focus?.();
   });
   const focusItemValueOptions = {
     data: dataWithCache,
@@ -156,12 +154,11 @@ const InputPicker = forwardRef((props, ref) => {
     focusItemValue,
     setFocusItemValue,
     onKeyDown
-  } = useFocusItemValue(multi ? value === null || value === void 0 ? void 0 : value[0] : value, focusItemValueOptions);
+  } = useFocusItemValue(multi ? value?.[0] : value, focusItemValueOptions);
   const onSearchCallback = useEventCallback((searchKeyword, filteredData, event) => {
     if (!disabledOptions) {
-      var _filteredData$;
       // The first option after filtering is the focus.
-      let firstItemValue = filteredData === null || filteredData === void 0 || (_filteredData$ = filteredData[0]) === null || _filteredData$ === void 0 ? void 0 : _filteredData$[valueKey];
+      let firstItemValue = filteredData?.[0]?.[valueKey];
 
       // If there is no value in the option and new options are supported, the search keyword is the first option
       if (!firstItemValue && creatable) {
@@ -169,7 +166,7 @@ const InputPicker = forwardRef((props, ref) => {
       }
       setFocusItemValue(firstItemValue);
     }
-    onSearch === null || onSearch === void 0 || onSearch(searchKeyword, event);
+    onSearch?.(searchKeyword, event);
   });
   const searchOptions = {
     labelKey,
@@ -187,15 +184,14 @@ const InputPicker = forwardRef((props, ref) => {
 
   // Update the position of the menu when the search keyword and value change
   useEffect(() => {
-    var _triggerRef$current2, _triggerRef$current2$;
-    (_triggerRef$current2 = triggerRef.current) === null || _triggerRef$current2 === void 0 || (_triggerRef$current2$ = _triggerRef$current2.updatePosition) === null || _triggerRef$current2$ === void 0 || _triggerRef$current2$.call(_triggerRef$current2);
+    triggerRef.current?.updatePosition?.();
   }, [searchKeyword, value]);
   const getDataItem = value => {
     // Find active `MenuItem` by `value`
     const activeItem = dataWithCache.find(item => shallowEqual(item[valueKey], value));
     let itemNode = placeholder;
-    if (activeItem !== null && activeItem !== void 0 && activeItem[labelKey]) {
-      itemNode = activeItem === null || activeItem === void 0 ? void 0 : activeItem[labelKey];
+    if (activeItem?.[labelKey]) {
+      itemNode = activeItem?.[labelKey];
     }
     return {
       isValid: !!activeItem,
@@ -215,14 +211,14 @@ const InputPicker = forwardRef((props, ref) => {
     };
     if (groupBy) {
       return {
-        [groupBy]: locale === null || locale === void 0 ? void 0 : locale.newItem,
+        [groupBy]: locale?.newItem,
         ...option
       };
     }
     return option;
   };
   const handleChange = useEventCallback((value, event) => {
-    onChange === null || onChange === void 0 || onChange(value, event);
+    onChange?.(value, event);
   });
   const handleRemoveItemByTag = useEventCallback((tag, event) => {
     event.stopPropagation();
@@ -230,13 +226,13 @@ const InputPicker = forwardRef((props, ref) => {
     remove(val, itemVal => shallowEqual(itemVal, tag));
     setValue(val);
     handleChange(val, event);
-    onTagRemove === null || onTagRemove === void 0 || onTagRemove(tag, event);
+    onTagRemove?.(tag, event);
   });
   const handleSelect = useEventCallback((value, item, event) => {
-    onSelect === null || onSelect === void 0 || onSelect(value, item, event);
+    onSelect?.(value, item, event);
     if (creatable && item.create) {
       delete item.create;
-      onCreate === null || onCreate === void 0 || onCreate(value, item, event);
+      onCreate?.(value, item, event);
       setNewData(newData.concat(item));
     }
   });
@@ -294,7 +290,7 @@ const InputPicker = forwardRef((props, ref) => {
     }
 
     // If the value is disabled in this option, it is returned.
-    if (disabledItemValues !== null && disabledItemValues !== void 0 && disabledItemValues.some(item => item === newItemValue)) {
+    if (disabledItemValues?.some(item => item === newItemValue)) {
       return;
     }
     if (!val.some(v => shallowEqual(v, newItemValue))) {
@@ -302,7 +298,7 @@ const InputPicker = forwardRef((props, ref) => {
     } else if (!disabledOptions) {
       remove(val, itemVal => shallowEqual(itemVal, newItemValue));
     }
-    let focusItem = data.find(item => shallowEqual(item === null || item === void 0 ? void 0 : item[valueKey], newItemValue));
+    let focusItem = data.find(item => shallowEqual(item?.[valueKey], newItemValue));
     if (!focusItem) {
       focusItem = createOption(newItemValue);
     }
@@ -317,7 +313,7 @@ const InputPicker = forwardRef((props, ref) => {
     }
 
     // If the value is disabled in this option, it is returned.
-    if (disabledItemValues !== null && disabledItemValues !== void 0 && disabledItemValues.some(item => item === focusItemValue)) {
+    if (disabledItemValues?.some(item => item === focusItemValue)) {
       return;
     }
 
@@ -342,12 +338,12 @@ const InputPicker = forwardRef((props, ref) => {
    * @param event
    */
   const removeLastItem = useEventCallback(event => {
-    const target = event === null || event === void 0 ? void 0 : event.target;
-    if ((target === null || target === void 0 ? void 0 : target.tagName) !== 'INPUT') {
+    const target = event?.target;
+    if (target?.tagName !== 'INPUT') {
       focus();
       return;
     }
-    if ((target === null || target === void 0 ? void 0 : target.tagName) === 'INPUT' && target !== null && target !== void 0 && target.value) {
+    if (target?.tagName === 'INPUT' && target?.value) {
       return;
     }
     const val = cloneValue();
@@ -373,7 +369,7 @@ const InputPicker = forwardRef((props, ref) => {
     } else {
       handleChange(null, event);
     }
-    onClean === null || onClean === void 0 || onClean(event);
+    onClean?.(event);
   });
   const events = {
     onMenuPressBackspace: multi ? removeLastItem : handleClean,
@@ -413,16 +409,15 @@ const InputPicker = forwardRef((props, ref) => {
     ...rest
   });
   const handleExited = useEventCallback(() => {
-    setFocusItemValue(multi ? value === null || value === void 0 ? void 0 : value[0] : value);
+    setFocusItemValue(multi ? value?.[0] : value);
     resetSearch();
   });
   const handleFocus = useEventCallback(event => {
     if (!readOnly) {
-      var _triggerRef$current3;
       setOpen(true);
-      (_triggerRef$current3 = triggerRef.current) === null || _triggerRef$current3 === void 0 || _triggerRef$current3.open();
+      triggerRef.current?.open();
     }
-    onFocus === null || onFocus === void 0 || onFocus(event);
+    onFocus?.(event);
   });
   const handleEnter = useEventCallback(() => {
     focus();
@@ -434,7 +429,7 @@ const InputPicker = forwardRef((props, ref) => {
   });
   const renderListItem = (label, item) => {
     // 'Create option "{0}"' =>  Create option "xxxxx"
-    const newLabel = item.create ? /*#__PURE__*/React.createElement("span", null, tplTransform((locale === null || locale === void 0 ? void 0 : locale.createOption) || '', label)) : label;
+    const newLabel = item.create ? /*#__PURE__*/React.createElement("span", null, tplTransform(locale?.createOption || '', label)) : label;
     return renderOption ? renderOption(newLabel, item) : newLabel;
   };
   const checkValue = () => {
@@ -539,7 +534,7 @@ const InputPicker = forwardRef((props, ref) => {
       virtualized: virtualized
     }) : /*#__PURE__*/React.createElement("div", {
       className: prefix`none`
-    }, locale === null || locale === void 0 ? void 0 : locale.noResultsText);
+    }, locale?.noResultsText);
     return /*#__PURE__*/React.createElement(PickerPopup, {
       ref: mergeRefs(overlay, speakerRef),
       autoWidth: popupAutoWidth,
@@ -547,7 +542,7 @@ const InputPicker = forwardRef((props, ref) => {
       style: mergedPopupStyle,
       target: triggerRef,
       onKeyDown: onPickerKeyDown
-    }, renderListbox ? renderListbox(listbox) : listbox, renderExtraFooter === null || renderExtraFooter === void 0 ? void 0 : renderExtraFooter());
+    }, renderListbox ? renderListbox(listbox) : listbox, renderExtraFooter?.());
   };
   const {
     isValid,
@@ -562,7 +557,7 @@ const InputPicker = forwardRef((props, ref) => {
    */
   const hasSingleValue = !isNil(value) && isFunction(renderValue) && !isNil(itemNode);
   const hasMultiValue = isArray(value) && value.length > 0 && isFunction(renderValue) && !isNil(tagElements);
-  const hasValue = multi ? !!(tagElements !== null && tagElements !== void 0 && tagElements.length) || hasMultiValue : isValid || hasSingleValue;
+  const hasValue = multi ? !!tagElements?.length || hasMultiValue : isValid || hasSingleValue;
   const searching = !!searchKeyword && open;
   const editable = searchable && !disabled && !loading;
   if (plaintext) {
@@ -577,9 +572,9 @@ const InputPicker = forwardRef((props, ref) => {
     return /*#__PURE__*/React.createElement(Plaintext, _extends({
       localeKey: "notSelected",
       ref: target
-    }, plaintextProps), itemNode || (tagElements !== null && tagElements !== void 0 && tagElements.length ? tagElements : null) || placeholder);
+    }, plaintextProps), itemNode || (tagElements?.length ? tagElements : null) || placeholder);
   }
-  const placeholderNode = placeholder || (disabledOptions ? null : locale === null || locale === void 0 ? void 0 : locale.placeholder);
+  const placeholderNode = placeholder || (disabledOptions ? null : locale?.placeholder);
   const triggerProps = {
     ...pick(props, triggerPropKeys),
     onEnter: createChainedFunction(handleEnter, onEnter),

package/esm/InputPicker/InputSearch.js

@@ -17,8 +17,7 @@ const InputSearch = forwardRef((props, ref) => {
     ...rest
   } = props;
   const handleChange = useEventCallback(event => {
-    var _event$target;
-    onChange === null || onChange === void 0 || onChange(event === null || event === void 0 || (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.value, event);
+    onChange?.(event?.target?.value, event);
   });
   const {
     withPrefix,

package/esm/InputPicker/hooks/useData.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { Option } from '../../internals/types';
 export interface InputOption<T = number | string> extends Option<T> {
     create?: boolean;

package/esm/InputPicker/hooks/useData.js

@@ -21,7 +21,7 @@ function useData(props) {
     if (controlledData && !shallowEqual(controlledData, uncontrolledData)) {
       setData(controlledData);
       setNewData([]);
-      onChange === null || onChange === void 0 || onChange(controlledData);
+      onChange?.(controlledData);
     }
   }, [controlledData, uncontrolledData, onChange]);
   return {

package/esm/InputPicker/hooks/useInput.js

@@ -11,16 +11,13 @@ function useInput(props) {
   const inputRef = useRef(null);
   const maxWidth = useMaxWidth(triggerRef);
   const getInput = useCallback(() => {
-    var _inputRef$current;
-    return multi ? (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.input : inputRef.current;
+    return multi ? inputRef.current?.input : inputRef.current;
   }, [multi]);
   const focus = useCallback(() => {
-    var _getInput;
-    (_getInput = getInput()) === null || _getInput === void 0 || _getInput.focus();
+    getInput()?.focus();
   }, [getInput]);
   const blur = useCallback(() => {
-    var _getInput2;
-    (_getInput2 = getInput()) === null || _getInput2 === void 0 || _getInput2.blur();
+    getInput()?.blur();
   }, [getInput]);
   const inputProps = useMemo(() => {
     return multi ? {

package/esm/InputPicker/hooks/useMaxWidth.js

@@ -4,11 +4,9 @@ import getWidth from 'dom-lib/getWidth';
 function useMaxWidth(triggerRef) {
   const [maxWidth, setMaxWidth] = useState(100);
   useEffect(() => {
-    var _triggerRef$current;
     // In multiple selection, you need to set a maximum width for the input.
-    if ((_triggerRef$current = triggerRef.current) !== null && _triggerRef$current !== void 0 && _triggerRef$current.root) {
-      var _triggerRef$current2;
-      setMaxWidth(getWidth((_triggerRef$current2 = triggerRef.current) === null || _triggerRef$current2 === void 0 ? void 0 : _triggerRef$current2.root));
+    if (triggerRef.current?.root) {
+      setMaxWidth(getWidth(triggerRef.current?.root));
     }
   }, []);
   return maxWidth;

package/esm/List/helper/AutoScroller.js

@@ -5,11 +5,9 @@ const ACCELERATION = 5; // for auto scroll
  * Auto scroll when approaching the edge
  * */
 class AutoScroller {
+  interval = null;
+  isAutoScrolling = true;
   constructor(container, onScrollCallback) {
-    this.container = void 0;
-    this.onScrollCallback = void 0;
-    this.interval = null;
-    this.isAutoScrolling = true;
     this.container = container;
     this.onScrollCallback = onScrollCallback;
   }

package/esm/List/helper/useSortHelper.d.ts

@@ -16,10 +16,10 @@ export type SortConfig = {
     onSort?(payload?: MovedItemInfo, event?: MouseEvent | TouchEvent): void;
 };
 declare const useSortHelper: (config: SortConfig) => {
-    handleStart: MouseEventHandler<Element>;
-    handleEnd: MouseEventHandler<Element>;
-    handleTouchStart: TouchEventHandler<Element>;
-    handleTouchEnd: TouchEventHandler<Element>;
+    handleStart: MouseEventHandler;
+    handleEnd: MouseEventHandler;
+    handleTouchStart: TouchEventHandler;
+    handleTouchEnd: TouchEventHandler;
     containerRef: import("react").RefObject<HTMLDivElement | null>;
     sorting: boolean;
     register: (item: ManagedItem) => {

package/esm/List/helper/useSortHelper.js

@@ -31,13 +31,12 @@ const useSortHelper = config => {
    * start dragging
    * */
   const handlePress = useCallback((event, _targetNode, curManagedItem) => {
-    var _curManagedItem$info$, _curManagedItem$info$2, _activeNodeHelper;
     if (!isMounted()) return;
     // data
     const containerElement = containerRef.current;
     const activeNode = curManagedItem.node;
-    const activeNodeOldIndex = (_curManagedItem$info$ = curManagedItem.info.index) !== null && _curManagedItem$info$ !== void 0 ? _curManagedItem$info$ : 0;
-    let activeNodeNextIndex = (_curManagedItem$info$2 = curManagedItem.info.index) !== null && _curManagedItem$info$2 !== void 0 ? _curManagedItem$info$2 : 0;
+    const activeNodeOldIndex = curManagedItem.info.index ?? 0;
+    let activeNodeNextIndex = curManagedItem.info.index ?? 0;
     let activeNodeHolderTranslate = {
       x: 0,
       y: 0
@@ -65,7 +64,7 @@ const useSortHelper = config => {
     const activeNodeOffsetEdge = getEdgeOffset(activeNode, containerElement);
     const activeNodeStyle = getComputedStyle(activeNode);
     let activeNodeHelper = activeNode.cloneNode(true);
-    (_activeNodeHelper = activeNodeHelper) === null || _activeNodeHelper === void 0 || _activeNodeHelper.classList.add(helperElementClass);
+    activeNodeHelper?.classList.add(helperElementClass);
     setInlineStyles(activeNodeHelper, {
       position: 'fixed',
       width: `${activeNodeBoundingClientRect.width}px`,
@@ -123,9 +122,8 @@ const useSortHelper = config => {
       const cTop = containerScrollDelta.top || 0;
       const sortingOffsetY = aTop + activeNodeHolderTranslate.y + cTop;
       for (let i = 0, len = listItemManagerRefs.length; i < len; i++) {
-        var _listItemManagerRefs$;
         const currentNode = listItemManagerRefs[i].node;
-        const currentNodeIndex = (_listItemManagerRefs$ = listItemManagerRefs[i].info.index) !== null && _listItemManagerRefs$ !== void 0 ? _listItemManagerRefs$ : 0;
+        const currentNodeIndex = listItemManagerRefs[i].info.index ?? 0;
         const offsetY = activeNodeBoundingClientRect.height > currentNode.offsetHeight ? currentNode.offsetHeight / 2 : activeNodeBoundingClientRect.height / 2;
         const translate = {
           x: 0,
@@ -154,8 +152,7 @@ const useSortHelper = config => {
         }
         const curEdgeOffsetTop = curEdgeOffset.top || 0;
         if (prvNode && currentNodeIndex > activeNodeOldIndex && sortingOffsetY + offsetY >= curEdgeOffsetTop) {
-          var _prvNode$edgeOffset;
-          const yOffset = (((_prvNode$edgeOffset = prvNode.edgeOffset) === null || _prvNode$edgeOffset === void 0 ? void 0 : _prvNode$edgeOffset.top) || 0) - curEdgeOffsetTop;
+          const yOffset = (prvNode.edgeOffset?.top || 0) - curEdgeOffsetTop;
           translate.y = yOffset;
           animatedNodesOffset[currentNodeIndex] = {
             x: 0,
@@ -163,8 +160,7 @@ const useSortHelper = config => {
           };
           activeNodeNextIndex = currentNodeIndex;
         } else if (nextNode && currentNodeIndex < activeNodeOldIndex && sortingOffsetY <= curEdgeOffsetTop + offsetY) {
-          var _nextNode$edgeOffset;
-          const yOffset = (((_nextNode$edgeOffset = nextNode.edgeOffset) === null || _nextNode$edgeOffset === void 0 ? void 0 : _nextNode$edgeOffset.top) || 0) - curEdgeOffsetTop;
+          const yOffset = (nextNode.edgeOffset?.top || 0) - curEdgeOffsetTop;
           translate.y = yOffset;
           animatedNodesOffset[currentNodeIndex] = {
             x: 0,
@@ -205,7 +201,7 @@ const useSortHelper = config => {
           }
         });
       }
-      onSortMove === null || onSortMove === void 0 || onSortMove({
+      onSortMove?.({
         collection: curManagedItem.info.collection,
         node: activeNode,
         oldIndex: activeNodeOldIndex,
@@ -215,12 +211,11 @@ const useSortHelper = config => {
 
     // Common handler for both mouse and touch end events
     const handleSortEnd = endEvent => {
-      var _sortTouchMoveListene, _sortTouchEndListener;
       // Remove the event listeners
       sortMouseMoveListener.off();
       sortMouseEndListener.off();
-      (_sortTouchMoveListene = sortTouchMoveListener) === null || _sortTouchMoveListene === void 0 || _sortTouchMoveListene.off();
-      (_sortTouchEndListener = sortTouchEndListener) === null || _sortTouchEndListener === void 0 || _sortTouchEndListener.off();
+      sortTouchMoveListener?.off();
+      sortTouchEndListener?.off();
 
       // Enable page scrolling again
       if (document.body.style.overflow === 'hidden') {
@@ -238,10 +233,9 @@ const useSortHelper = config => {
 
       // wait for animation
       setTimeout(() => {
-        var _activeNodeHelper2;
         if (!isMounted()) return;
         // Remove the helper from the DOM
-        (_activeNodeHelper2 = activeNodeHelper) === null || _activeNodeHelper2 === void 0 || (_activeNodeHelper2 = _activeNodeHelper2.parentNode) === null || _activeNodeHelper2 === void 0 || _activeNodeHelper2.removeChild(activeNodeHelper);
+        activeNodeHelper?.parentNode?.removeChild(activeNodeHelper);
         activeNodeHelper = null;
 
         // Remove redundant styles
@@ -271,8 +265,8 @@ const useSortHelper = config => {
           newIndex: activeNodeNextIndex,
           oldIndex: activeNodeOldIndex
         };
-        onSortEnd === null || onSortEnd === void 0 || onSortEnd(callbackPayload, endEvent);
-        onSort === null || onSort === void 0 || onSort(callbackPayload, endEvent);
+        onSortEnd?.(callbackPayload, endEvent);
+        onSort?.(callbackPayload, endEvent);
       }, transitionDuration);
     };
 
@@ -300,7 +294,7 @@ const useSortHelper = config => {
     }
     setSorting(true);
     // start callback
-    onSortStart === null || onSortStart === void 0 || onSortStart({
+    onSortStart?.({
       collection: curManagedItem.info.collection,
       node: activeNode,
       oldIndex: activeNodeOldIndex,

package/esm/MaskedInput/TextMask.d.ts

@@ -38,10 +38,10 @@ export type TextMaskProps = TextMaskBaseProps & React.HTMLAttributes<HTMLInputEl
  */
 declare const TextMask: React.ForwardRefExoticComponent<TextMaskBaseProps & React.HTMLAttributes<HTMLInputElement> & {
     /** Custom rendering DOM */
-    render?: ((ref: React.Ref<HTMLInputElement>, props: React.HTMLAttributes<HTMLInputElement>) => any) | undefined;
-    onChange?: ((event: React.ChangeEvent<HTMLInputElement>) => void) | undefined;
-    value?: string | number | undefined;
-    readOnly?: boolean | undefined;
-    disabled?: boolean | undefined;
+    render?: (ref: React.Ref<HTMLInputElement>, props: React.HTMLAttributes<HTMLInputElement>) => any;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    value?: string | number;
+    readOnly?: boolean;
+    disabled?: boolean;
 } & React.RefAttributes<HTMLInputElement>>;
 export default TextMask;

package/esm/MaskedInput/TextMask.js

@@ -32,17 +32,15 @@ const TextMask = /*#__PURE__*/React.forwardRef((props, ref) => {
   const inputRef = useRef(null);
   const textMaskInputElement = useRef(null);
   const initTextMask = useCallback(() => {
-    var _textMaskInputElement;
     textMaskInputElement.current = createTextMaskInputElement({
       inputElement: inputRef.current,
       ...props
     });
-    (_textMaskInputElement = textMaskInputElement.current) === null || _textMaskInputElement === void 0 || _textMaskInputElement.update(value);
+    textMaskInputElement.current?.update(value);
   }, [props, value]);
   const handleChange = useCallback(event => {
-    var _textMaskInputElement2;
-    (_textMaskInputElement2 = textMaskInputElement.current) === null || _textMaskInputElement2 === void 0 || _textMaskInputElement2.update();
-    onChange === null || onChange === void 0 || onChange(event);
+    textMaskInputElement.current?.update();
+    onChange?.(event);
   }, [onChange]);
   useEffect(() => {
     initTextMask();

package/esm/MaskedInput/conformToMask.d.ts

@@ -1,5 +1,5 @@
 import { MaskType, ConfigType, MaskFunctionType } from './types';
-export declare function isArray(value: any): boolean;
+export declare function isArray(value: any): value is any[];
 export default function conformToMask(rawValue?: string, mask?: MaskType | MaskFunctionType | any, config?: ConfigType): {
     conformedValue: string;
     meta: {

package/esm/MaskedInput/createTextMaskInputElement.js

@@ -27,7 +27,6 @@ export default function createTextMaskInputElement(config) {
       keepCharPositions = false,
       showMask = false
     } = config) {
-      var _pipeResults, _pipeResults2;
       // if `rawValue` is `undefined`, read from the `inputElement`
       if (typeof rawValue === 'undefined') {
         rawValue = inputElement.value;
@@ -161,7 +160,7 @@ export default function createTextMaskInputElement(config) {
 
       // Before we proceed, we need to know which conformed value to use, the one returned by the pipe or the one
       // returned by `conformToMask`.
-      const finalConformedValue = piped ? (_pipeResults = pipeResults) === null || _pipeResults === void 0 ? void 0 : _pipeResults.value : conformedValue;
+      const finalConformedValue = piped ? pipeResults?.value : conformedValue;
 
       // After determining the conformed value, we will need to know where to set
       // the caret position. `adjustCaretPosition` will tell us.
@@ -173,7 +172,7 @@ export default function createTextMaskInputElement(config) {
         rawValue: safeRawValue,
         currentCaretPosition,
         placeholderChar,
-        indexesOfPipedChars: (_pipeResults2 = pipeResults) === null || _pipeResults2 === void 0 ? void 0 : _pipeResults2.indexesOfPipedChars,
+        indexesOfPipedChars: pipeResults?.indexesOfPipedChars,
         caretTrapIndexes
       });
 

package/esm/Menu/MenuItem.js

@@ -30,11 +30,10 @@ const MenuItem = forwardRef((props, ref) => {
     prefix
   } = useStyles(classPrefix);
   const handleSelectItem = useCallback(event => {
-    var _menu$onSelect;
-    onSelect === null || onSelect === void 0 || onSelect(eventKey, event);
-    menu === null || menu === void 0 || (_menu$onSelect = menu.onSelect) === null || _menu$onSelect === void 0 || _menu$onSelect.call(menu, eventKey, event);
+    onSelect?.(eventKey, event);
+    menu?.onSelect?.(eventKey, event);
   }, [onSelect, eventKey, menu]);
-  const selected = activeProp || !isNil(eventKey) && shallowEqual(menu === null || menu === void 0 ? void 0 : menu.activeKey, eventKey);
+  const selected = activeProp || !isNil(eventKey) && shallowEqual(menu?.activeKey, eventKey);
   const renderMenuItem = useRenderMenuItem(as);
   return /*#__PURE__*/React.createElement(MenuItemBase, {
     selected: selected,