rsuite 5.76.2 → 6.0.0-canary-20250103

package/esm/List/helper/AutoScroller.js

@@ -1,11 +1,11 @@
 'use client';
-var ACCELERATION = 5; // for auto scroll
+const ACCELERATION = 5; // for auto scroll
 
 /***
  * Auto scroll when approaching the edge
  * */
-var AutoScroller = /*#__PURE__*/function () {
-  function AutoScroller(container, onScrollCallback) {
+class AutoScroller {
+  constructor(container, onScrollCallback) {
     this.container = void 0;
     this.onScrollCallback = void 0;
     this.interval = null;
@@ -13,39 +13,40 @@ var AutoScroller = /*#__PURE__*/function () {
     this.container = container;
     this.onScrollCallback = onScrollCallback;
   }
-  var _proto = AutoScroller.prototype;
-  _proto.clear = function clear() {
+  clear() {
     if (this.interval !== null) {
       clearInterval(this.interval);
       this.interval = null;
     }
-  };
-  _proto.update = function update(_ref) {
-    var _this = this;
-    var translate = _ref.translate,
-      minTranslate = _ref.minTranslate,
-      maxTranslate = _ref.maxTranslate,
-      width = _ref.width,
-      height = _ref.height;
-    var direction = {
+  }
+  update(_ref) {
+    let {
+      translate,
+      minTranslate,
+      maxTranslate,
+      width,
+      height
+    } = _ref;
+    const direction = {
       x: 0,
       y: 0
     };
-    var speed = {
+    const speed = {
       x: 0,
       y: 0
     };
-    var _this$container = this.container,
-      scrollTop = _this$container.scrollTop,
-      scrollLeft = _this$container.scrollLeft,
-      scrollHeight = _this$container.scrollHeight,
-      scrollWidth = _this$container.scrollWidth,
-      clientHeight = _this$container.clientHeight,
-      clientWidth = _this$container.clientWidth;
-    var isTop = scrollTop === 0;
-    var isBottom = scrollTop === scrollHeight - clientHeight;
-    var isLeft = scrollLeft === 0;
-    var isRight = scrollLeft === scrollWidth - clientWidth;
+    const {
+      scrollTop,
+      scrollLeft,
+      scrollHeight,
+      scrollWidth,
+      clientHeight,
+      clientWidth
+    } = this.container;
+    const isTop = scrollTop === 0;
+    const isBottom = scrollTop === scrollHeight - clientHeight;
+    const isLeft = scrollLeft === 0;
+    const isRight = scrollLeft === scrollWidth - clientWidth;
     if (translate.y >= maxTranslate.y - height / 2 && !isBottom) {
       // Scroll Down
       direction.y = 1;
@@ -69,18 +70,17 @@ var AutoScroller = /*#__PURE__*/function () {
     }
     if (direction.x !== 0 || direction.y !== 0) {
       // duration of auto scroll
-      this.interval = setInterval(function () {
-        _this.isAutoScrolling = true;
-        var offset = {
+      this.interval = setInterval(() => {
+        this.isAutoScrolling = true;
+        const offset = {
           left: speed.x * direction.x,
           top: speed.y * direction.y
         };
-        _this.container.scrollTop += offset.top;
-        _this.container.scrollLeft += offset.left;
-        _this.onScrollCallback(offset);
+        this.container.scrollTop += offset.top;
+        this.container.scrollLeft += offset.left;
+        this.onScrollCallback(offset);
       }, 20);
     }
-  };
-  return AutoScroller;
-}();
+  }
+}
 export default AutoScroller;

package/esm/List/helper/useManager.js

@@ -1,39 +1,35 @@
 'use client';
 import _flatten from "lodash/flatten";
 import { useCallback, useRef } from 'react';
-var useManager = function useManager() {
-  var collectionMapRef = useRef({});
-  var listItemRegister = useCallback(function (item) {
-    var collection = item.info.collection;
+const useManager = () => {
+  const collectionMapRef = useRef({});
+  const listItemRegister = useCallback(item => {
+    const collection = item.info.collection;
     if (!Array.isArray(collectionMapRef.current[collection])) {
       // reset collection
       collectionMapRef.current[collection] = [];
     }
     collectionMapRef.current[collection].push(item);
     return {
-      unregister: function unregister() {
-        var index = collectionMapRef.current[collection].indexOf(item);
+      unregister: () => {
+        const index = collectionMapRef.current[collection].indexOf(item);
         if (index !== -1) {
           collectionMapRef.current[collection].splice(index, 1);
         }
       }
     };
   }, []);
-  var getManagedItem = useCallback(function (node) {
-    var allItems = _flatten(Object.values(collectionMapRef.current));
-    return allItems.find(function (managerRef) {
-      return managerRef.node === node;
-    });
+  const getManagedItem = useCallback(node => {
+    const allItems = _flatten(Object.values(collectionMapRef.current));
+    return allItems.find(managerRef => managerRef.node === node);
   }, []);
-  var getOrderedItems = useCallback(function (collection) {
-    return collection != null ? [].concat(collectionMapRef.current[collection]).sort(function (nodeInfo1, nodeInfo2) {
-      return Number(nodeInfo1.info.index) - Number(nodeInfo2.info.index);
-    }) : [];
+  const getOrderedItems = useCallback(collection => {
+    return collection != null ? [...collectionMapRef.current[collection]].sort((nodeInfo1, nodeInfo2) => Number(nodeInfo1.info.index) - Number(nodeInfo2.info.index)) : [];
   }, []);
   return {
-    listItemRegister: listItemRegister,
-    getManagedItem: getManagedItem,
-    getOrderedItems: getOrderedItems
+    listItemRegister,
+    getManagedItem,
+    getOrderedItems
   };
 };
 export default useManager;

package/esm/List/helper/useSortHelper.js

@@ -1,100 +1,92 @@
 'use client';
-function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 import on from 'dom-lib/on';
 import { useCallback, useRef, useState } from 'react';
 import AutoScroller from "./AutoScroller.js";
 import { closestNode, getEdgeOffset, getScrollingParent, isContainInteractiveElement, setInlineStyles, setTransitionDuration, setTranslate3d } from "./utils.js";
 import { useIsMounted } from "../../internals/hooks/index.js";
 import useManager from "./useManager.js";
-var helperElementClass = 'rs-list-item-helper';
-var holderElementClass = 'rs-list-item-holder';
-var useSortHelper = function useSortHelper(config) {
-  var autoScroll = config.autoScroll,
-    pressDelay = config.pressDelay,
-    transitionDuration = config.transitionDuration,
-    onSort = config.onSort,
-    onSortEnd = config.onSortEnd,
-    onSortMove = config.onSortMove,
-    onSortStart = config.onSortStart;
-  var _useState = useState(false),
-    sorting = _useState[0],
-    setSorting = _useState[1];
-  var containerRef = useRef(null);
-  var pressTimer = useRef();
-  var _useManager = useManager(),
-    listItemRegister = _useManager.listItemRegister,
-    getManagedItem = _useManager.getManagedItem,
-    getOrderedItems = _useManager.getOrderedItems;
-  var isMounted = useIsMounted();
+const helperElementClass = 'rs-list-item-helper';
+const holderElementClass = 'rs-list-item-holder';
+const useSortHelper = config => {
+  const {
+    autoScroll,
+    pressDelay,
+    transitionDuration,
+    onSort,
+    onSortEnd,
+    onSortMove,
+    onSortStart
+  } = config;
+  const [sorting, setSorting] = useState(false);
+  const containerRef = useRef(null);
+  const pressTimer = useRef();
+  const {
+    listItemRegister,
+    getManagedItem,
+    getOrderedItems
+  } = useManager();
+  const isMounted = useIsMounted();
 
   /**
    * start dragging
    * */
-  var handlePress = useCallback(function (mouseDownEvent, _targetNode, curManagedItem) {
+  const handlePress = useCallback((mouseDownEvent, _targetNode, curManagedItem) => {
     var _curManagedItem$info$, _curManagedItem$info$2, _activeNodeHelper;
     if (!isMounted()) return;
     // data
-    var containerElement = containerRef.current;
-    var activeNode = curManagedItem.node;
-    var activeNodeOldIndex = (_curManagedItem$info$ = curManagedItem.info.index) !== null && _curManagedItem$info$ !== void 0 ? _curManagedItem$info$ : 0;
-    var activeNodeNextIndex = (_curManagedItem$info$2 = curManagedItem.info.index) !== null && _curManagedItem$info$2 !== void 0 ? _curManagedItem$info$2 : 0;
-    var activeNodeHolderTranslate = {
+    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;
+    let activeNodeHolderTranslate = {
       x: 0,
       y: 0
     };
-    var animatedNodesOffset = []; // all list item offset
+    let animatedNodesOffset = []; // all list item offset
 
     // init scroller
-    var scrollContainer = getScrollingParent(containerElement) || containerElement;
-    var initScroll = {
+    const scrollContainer = getScrollingParent(containerElement) || containerElement;
+    const initScroll = {
       x: scrollContainer.scrollLeft,
       y: scrollContainer.scrollTop
     };
-    var autoScroller = new AutoScroller(scrollContainer, function (offset) {
+    const autoScroller = new AutoScroller(scrollContainer, offset => {
       activeNodeHolderTranslate.x += offset.left;
       activeNodeHolderTranslate.y += offset.top;
     });
-    var activeNodeBoundingClientRect = activeNode.getBoundingClientRect();
-    var activeNodeOffsetEdge = getEdgeOffset(activeNode, containerElement);
-    var activeNodeStyle = getComputedStyle(activeNode);
-    var activeNodeHelper = activeNode.cloneNode(true);
+    const activeNodeBoundingClientRect = activeNode.getBoundingClientRect();
+    const activeNodeOffsetEdge = getEdgeOffset(activeNode, containerElement);
+    const activeNodeStyle = getComputedStyle(activeNode);
+    let activeNodeHelper = activeNode.cloneNode(true);
     (_activeNodeHelper = activeNodeHelper) === null || _activeNodeHelper === void 0 || _activeNodeHelper.classList.add(helperElementClass);
     setInlineStyles(activeNodeHelper, {
       position: 'fixed',
-      width: activeNodeBoundingClientRect.width + "px",
-      height: activeNodeBoundingClientRect.height + "px",
-      left: activeNodeBoundingClientRect.left - parseFloat(activeNodeStyle.marginLeft) + "px",
-      top: activeNodeBoundingClientRect.top - parseFloat(activeNodeStyle.marginTop) + "px"
+      width: `${activeNodeBoundingClientRect.width}px`,
+      height: `${activeNodeBoundingClientRect.height}px`,
+      left: `${activeNodeBoundingClientRect.left - parseFloat(activeNodeStyle.marginLeft)}px`,
+      top: `${activeNodeBoundingClientRect.top - parseFloat(activeNodeStyle.marginTop)}px`
     });
     activeNode.classList.add(holderElementClass);
     document.body.appendChild(activeNodeHelper);
-    var getContainerScrollDelta = function getContainerScrollDelta() {
-      return {
-        left: scrollContainer.scrollLeft - initScroll.x,
-        top: scrollContainer.scrollTop - initScroll.y
-      };
-    };
-    var getHolderTranslate = function getHolderTranslate() {
-      return animatedNodesOffset.reduce(function (acc, item) {
-        return {
-          x: acc.x + item.x,
-          y: acc.y + item.y
-        };
-      }, {
-        x: 0,
-        y: 0
-      });
-    };
-    var sortMouseMoveListener = on(window, 'mousemove', function (mouseOverEvent) {
+    const getContainerScrollDelta = () => ({
+      left: scrollContainer.scrollLeft - initScroll.x,
+      top: scrollContainer.scrollTop - initScroll.y
+    });
+    const getHolderTranslate = () => animatedNodesOffset.reduce((acc, item) => ({
+      x: acc.x + item.x,
+      y: acc.y + item.y
+    }), {
+      x: 0,
+      y: 0
+    });
+    const sortMouseMoveListener = on(window, 'mousemove', mouseOverEvent => {
       // Update helper position
-      var offset = {
+      const offset = {
         x: (mouseOverEvent === null || mouseOverEvent === void 0 ? void 0 : mouseOverEvent.pageX) || 0,
         y: (mouseOverEvent === null || mouseOverEvent === void 0 ? void 0 : mouseOverEvent.pageY) || 0
       };
-      var containerScrollDelta = getContainerScrollDelta();
-      var containerBoundingRect = scrollContainer.getBoundingClientRect();
+      const containerScrollDelta = getContainerScrollDelta();
+      const containerBoundingRect = scrollContainer.getBoundingClientRect();
       activeNodeHolderTranslate = {
         x: offset.x - mouseDownEvent.pageX,
         y: offset.y - mouseDownEvent.pageY
@@ -105,27 +97,27 @@ var useSortHelper = function useSortHelper(config) {
 
       // animate
       activeNodeNextIndex = -1;
-      var listItemManagerRefs = getOrderedItems(curManagedItem.info.collection);
-      var aTop = activeNodeOffsetEdge.top || 0;
-      var cTop = containerScrollDelta.top || 0;
-      var sortingOffsetY = aTop + activeNodeHolderTranslate.y + cTop;
-      for (var i = 0, len = listItemManagerRefs.length; i < len; i++) {
+      const listItemManagerRefs = getOrderedItems(curManagedItem.info.collection);
+      const aTop = activeNodeOffsetEdge.top || 0;
+      const cTop = containerScrollDelta.top || 0;
+      const sortingOffsetY = aTop + activeNodeHolderTranslate.y + cTop;
+      for (let i = 0, len = listItemManagerRefs.length; i < len; i++) {
         var _listItemManagerRefs$;
-        var currentNode = listItemManagerRefs[i].node;
-        var currentNodeIndex = (_listItemManagerRefs$ = listItemManagerRefs[i].info.index) !== null && _listItemManagerRefs$ !== void 0 ? _listItemManagerRefs$ : 0;
-        var offsetY = activeNodeBoundingClientRect.height > currentNode.offsetHeight ? currentNode.offsetHeight / 2 : activeNodeBoundingClientRect.height / 2;
-        var translate = {
+        const currentNode = listItemManagerRefs[i].node;
+        const currentNodeIndex = (_listItemManagerRefs$ = listItemManagerRefs[i].info.index) !== null && _listItemManagerRefs$ !== void 0 ? _listItemManagerRefs$ : 0;
+        const offsetY = activeNodeBoundingClientRect.height > currentNode.offsetHeight ? currentNode.offsetHeight / 2 : activeNodeBoundingClientRect.height / 2;
+        const translate = {
           x: 0,
           y: 0
         };
 
         // If we haven't cached the node's offsetTop / offsetLeft value
-        var curEdgeOffset = listItemManagerRefs[i].edgeOffset || getEdgeOffset(currentNode, containerElement);
+        const curEdgeOffset = listItemManagerRefs[i].edgeOffset || getEdgeOffset(currentNode, containerElement);
         listItemManagerRefs[i].edgeOffset = curEdgeOffset;
 
         // Get a reference to the next node
-        var prvNode = i > 0 && listItemManagerRefs[i - 1];
-        var nextNode = i < len - 1 && listItemManagerRefs[i + 1];
+        const prvNode = i > 0 && listItemManagerRefs[i - 1];
+        const nextNode = i < len - 1 && listItemManagerRefs[i + 1];
 
         // Also cache the node's edge offset if needed.
         if (prvNode && !prvNode.edgeOffset) {
@@ -139,10 +131,10 @@ var useSortHelper = function useSortHelper(config) {
         if (currentNodeIndex === activeNodeOldIndex) {
           continue;
         }
-        var curEdgeOffsetTop = curEdgeOffset.top || 0;
+        const curEdgeOffsetTop = curEdgeOffset.top || 0;
         if (prvNode && currentNodeIndex > activeNodeOldIndex && sortingOffsetY + offsetY >= curEdgeOffsetTop) {
           var _prvNode$edgeOffset;
-          var yOffset = (((_prvNode$edgeOffset = prvNode.edgeOffset) === null || _prvNode$edgeOffset === void 0 ? void 0 : _prvNode$edgeOffset.top) || 0) - curEdgeOffsetTop;
+          const yOffset = (((_prvNode$edgeOffset = prvNode.edgeOffset) === null || _prvNode$edgeOffset === void 0 ? void 0 : _prvNode$edgeOffset.top) || 0) - curEdgeOffsetTop;
           translate.y = yOffset;
           animatedNodesOffset[currentNodeIndex] = {
             x: 0,
@@ -151,11 +143,11 @@ var useSortHelper = function useSortHelper(config) {
           activeNodeNextIndex = currentNodeIndex;
         } else if (nextNode && currentNodeIndex < activeNodeOldIndex && sortingOffsetY <= curEdgeOffsetTop + offsetY) {
           var _nextNode$edgeOffset;
-          var _yOffset = (((_nextNode$edgeOffset = nextNode.edgeOffset) === null || _nextNode$edgeOffset === void 0 ? void 0 : _nextNode$edgeOffset.top) || 0) - curEdgeOffsetTop;
-          translate.y = _yOffset;
+          const yOffset = (((_nextNode$edgeOffset = nextNode.edgeOffset) === null || _nextNode$edgeOffset === void 0 ? void 0 : _nextNode$edgeOffset.top) || 0) - curEdgeOffsetTop;
+          translate.y = yOffset;
           animatedNodesOffset[currentNodeIndex] = {
             x: 0,
-            y: -_yOffset
+            y: -yOffset
           };
           if (activeNodeNextIndex === -1) {
             activeNodeNextIndex = currentNodeIndex;
@@ -201,12 +193,12 @@ var useSortHelper = function useSortHelper(config) {
     }, {
       passive: false
     });
-    var sortMouseEndListener = on(window, 'mouseup', function (event) {
+    const sortMouseEndListener = on(window, 'mouseup', event => {
       // Remove the event listeners
       sortMouseMoveListener.off();
       sortMouseEndListener.off();
-      var holderTranslate = getHolderTranslate();
-      var containerScrollDelta = getContainerScrollDelta();
+      const holderTranslate = getHolderTranslate();
+      const containerScrollDelta = getContainerScrollDelta();
       if (activeNodeHelper) {
         setTranslate3d(activeNodeHelper, {
           x: holderTranslate.x - (containerScrollDelta.left || 0),
@@ -216,7 +208,7 @@ var useSortHelper = function useSortHelper(config) {
       }
 
       // wait for animation
-      setTimeout(function () {
+      setTimeout(() => {
         var _activeNodeHelper2;
         if (!isMounted()) return;
         // Remove the helper from the DOM
@@ -227,13 +219,12 @@ var useSortHelper = function useSortHelper(config) {
         activeNode.classList.remove(holderElementClass);
         setTranslate3d(activeNode, null);
         animatedNodesOffset = [];
-        for (var _iterator = _createForOfIteratorHelperLoose(getOrderedItems(curManagedItem.info.collection)), _step; !(_step = _iterator()).done;) {
-          var item = _step.value;
+        for (const item of getOrderedItems(curManagedItem.info.collection)) {
           // Clear the cached offsetTop / offsetLeft value
           item.edgeOffset = null;
 
           // Remove the transforms / transitions
-          var el = item.node;
+          const el = item.node;
           setTranslate3d(el, null);
           setTransitionDuration(el, null);
         }
@@ -245,7 +236,7 @@ var useSortHelper = function useSortHelper(config) {
         setSorting(false);
 
         // callbacks
-        var callbackPayload = {
+        const callbackPayload = {
           collection: curManagedItem.info.collection,
           node: curManagedItem.node,
           newIndex: activeNodeNextIndex,
@@ -270,12 +261,10 @@ var useSortHelper = function useSortHelper(config) {
   /**
    * Determine whether to start dragging
    * */
-  var handleStart = useCallback(function (mouseDownEvent) {
-    var triggeredNode = mouseDownEvent.target;
-    var targetNode = closestNode(triggeredNode, function (el) {
-      return Boolean(getManagedItem(el));
-    });
-    var curManagedItem = getManagedItem(targetNode);
+  const handleStart = useCallback(mouseDownEvent => {
+    const triggeredNode = mouseDownEvent.target;
+    const targetNode = closestNode(triggeredNode, el => Boolean(getManagedItem(el)));
+    const curManagedItem = getManagedItem(targetNode);
     if (
     // is not secondary button pressed
     mouseDownEvent.button !== 2 &&
@@ -295,14 +284,12 @@ var useSortHelper = function useSortHelper(config) {
   /**
    * Clear timer after drag
    * */
-  var handleEnd = useCallback(function () {
-    return clearTimeout(pressTimer.current);
-  }, []);
+  const handleEnd = useCallback(() => clearTimeout(pressTimer.current), []);
   return {
-    handleStart: handleStart,
-    handleEnd: handleEnd,
-    containerRef: containerRef,
-    sorting: sorting,
+    handleStart,
+    handleEnd,
+    containerRef,
+    sorting,
     register: listItemRegister
   };
 };

package/esm/List/helper/utils.js

@@ -2,28 +2,25 @@
 /**
  * interactive elements should be skiped
  * */
-var INTERACTIVE_ELEMENTS = ['A', 'BUTTON', 'INPUT', 'OPTION', 'TEXTAREA', 'SELECT'];
+const INTERACTIVE_ELEMENTS = ['A', 'BUTTON', 'INPUT', 'OPTION', 'TEXTAREA', 'SELECT'];
 export function isContainInteractiveElement(targetNode) {
   return INTERACTIVE_ELEMENTS.includes(targetNode.tagName) || targetNode.contentEditable === 'true';
 }
 export function setInlineStyles(node, styles) {
   if (node !== null && styles !== null) {
-    for (var _i = 0, _Object$entries = Object.entries(styles); _i < _Object$entries.length; _i++) {
-      var _Object$entries$_i = _Object$entries[_i],
-        key = _Object$entries$_i[0],
-        value = _Object$entries$_i[1];
+    for (const [key, value] of Object.entries(styles)) {
       node.style[key] = value;
     }
   }
 }
 export function setTranslate3d(node, translate) {
   setInlineStyles(node, {
-    transform: translate ? "translate3d(" + translate.x + "px," + translate.y + "px,0)" : ''
+    transform: translate ? `translate3d(${translate.x}px,${translate.y}px,0)` : ''
   });
 }
 export function setTransitionDuration(node, duration) {
   setInlineStyles(node, {
-    transitionDuration: duration ? duration + "ms" : ''
+    transitionDuration: duration ? `${duration}ms` : ''
   });
 }
 
@@ -31,7 +28,7 @@ export function setTransitionDuration(node, duration) {
  * find closest target node from source node
  * */
 export function closestNode(sourceNode, judge) {
-  var currentNode = sourceNode;
+  let currentNode = sourceNode;
   while (currentNode) {
     if (judge(currentNode)) {
       return currentNode;
@@ -52,7 +49,7 @@ export function getEdgeOffset(node, parent, offset) {
   }
 
   // Get the actual offsetTop / offsetLeft value, no matter how deep the node is nested
-  var nodeOffset = {
+  const nodeOffset = {
     left: (offset.left || 0) + node.offsetLeft,
     top: (offset.top || 0) + node.offsetTop
   };
@@ -62,12 +59,10 @@ export function getEdgeOffset(node, parent, offset) {
   return getEdgeOffset(node.parentNode, parent, nodeOffset);
 }
 export function getScrollingParent(el) {
-  return closestNode(el, function (el) {
-    var computedStyle = window.getComputedStyle(el);
-    var overflowRegex = /(auto|scroll)/;
-    var properties = ['overflow', 'overflowX', 'overflowY'];
-    return properties.some(function (property) {
-      return overflowRegex.test(computedStyle[property]);
-    });
+  return closestNode(el, el => {
+    const computedStyle = window.getComputedStyle(el);
+    const overflowRegex = /(auto|scroll)/;
+    const properties = ['overflow', 'overflowX', 'overflowY'];
+    return properties.some(property => overflowRegex.test(computedStyle[property]));
   });
 }

package/esm/Loader/Loader.js

@@ -1,43 +1,40 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["as", "classPrefix", "className", "inverse", "backdrop", "speed", "center", "vertical", "content", "size"];
 import React from 'react';
-import PropTypes from 'prop-types';
 import { useClassNames, useUniqueId } from "../internals/hooks/index.js";
-import { oneOf } from "../internals/propTypes/index.js";
 import { useCustom } from "../CustomProvider/index.js";
 /**
  * The `Loader` component is used to indicate the loading state of a page or a section.
  * @see https://rsuitejs.com/components/loader
  */
-var Loader = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _useCustom = useCustom('Loader', props),
-    propsWithDefaults = _useCustom.propsWithDefaults;
-  var _propsWithDefaults$as = propsWithDefaults.as,
-    Component = _propsWithDefaults$as === void 0 ? 'div' : _propsWithDefaults$as,
-    _propsWithDefaults$cl = propsWithDefaults.classPrefix,
-    classPrefix = _propsWithDefaults$cl === void 0 ? 'loader' : _propsWithDefaults$cl,
-    className = propsWithDefaults.className,
-    inverse = propsWithDefaults.inverse,
-    backdrop = propsWithDefaults.backdrop,
-    _propsWithDefaults$sp = propsWithDefaults.speed,
-    speed = _propsWithDefaults$sp === void 0 ? 'normal' : _propsWithDefaults$sp,
-    center = propsWithDefaults.center,
-    vertical = propsWithDefaults.vertical,
-    content = propsWithDefaults.content,
-    size = propsWithDefaults.size,
-    rest = _objectWithoutPropertiesLoose(propsWithDefaults, _excluded);
-  var _useClassNames = useClassNames(classPrefix),
-    merge = _useClassNames.merge,
-    withClassPrefix = _useClassNames.withClassPrefix,
-    prefix = _useClassNames.prefix;
-  var labelId = useUniqueId('loader-label-');
-  var classes = merge(className, prefix('wrapper', "speed-" + speed, size, {
+const Loader = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    propsWithDefaults
+  } = useCustom('Loader', props);
+  const {
+    as: Component = 'div',
+    classPrefix = 'loader',
+    className,
+    inverse,
+    backdrop,
+    speed = 'normal',
+    center,
+    vertical,
+    content,
+    size,
+    ...rest
+  } = propsWithDefaults;
+  const {
+    merge,
+    withClassPrefix,
+    prefix
+  } = useClassNames(classPrefix);
+  const labelId = useUniqueId('loader-label-');
+  const classes = merge(className, prefix('wrapper', `speed-${speed}`, size, {
     'backdrop-wrapper': backdrop,
-    vertical: vertical,
-    inverse: inverse,
-    center: center
+    vertical,
+    inverse,
+    center
   }));
   return /*#__PURE__*/React.createElement(Component, _extends({
     role: "status",
@@ -57,16 +54,4 @@ var Loader = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }, content)));
 });
 Loader.displayName = 'Loader';
-Loader.propTypes = {
-  as: PropTypes.elementType,
-  className: PropTypes.string,
-  classPrefix: PropTypes.string,
-  center: PropTypes.bool,
-  backdrop: PropTypes.bool,
-  inverse: PropTypes.bool,
-  vertical: PropTypes.bool,
-  content: PropTypes.node,
-  size: oneOf(['lg', 'md', 'sm', 'xs']),
-  speed: oneOf(['normal', 'fast', 'slow', 'paused'])
-};
 export default Loader;

package/esm/MaskedInput/MaskedInput.js

@@ -4,14 +4,17 @@ import React from 'react';
 import TextMask from "./TextMask.js";
 import Input from "../Input/index.js";
 import { useCustom } from "../CustomProvider/index.js";
-var MaskedInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _useCustom = useCustom('MaskedInput', props),
-    propsWithDefaults = _useCustom.propsWithDefaults;
-  var _propsWithDefaults$as = propsWithDefaults.as,
-    inputAs = _propsWithDefaults$as === void 0 ? TextMask : _propsWithDefaults$as;
+const MaskedInput = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    propsWithDefaults
+  } = useCustom('MaskedInput', props);
+  const {
+    as: inputAs = TextMask
+  } = propsWithDefaults;
   return /*#__PURE__*/React.createElement(Input, _extends({}, propsWithDefaults, {
     as: inputAs,
     ref: ref
   }));
 });
+MaskedInput.displayName = 'MaskedInput';
 export default MaskedInput;