rsuite 5.61.0 → 5.62.0

package/esm/{utils → internals/hooks}/useRootClose.js

@@ -3,7 +3,8 @@ import { useEffect, useCallback } from 'react';
 import contains from 'dom-lib/contains';
 import ownerDocument from 'dom-lib/ownerDocument';
 import on from 'dom-lib/on';
-import { getDOMNode, KEY_VALUES } from './';
+import getDOMNode from "../utils/getDOMNode";
+import { KEY_VALUES } from "../constants";
 function isLeftClickEvent(event) {
   return (event === null || event === void 0 ? void 0 : event.button) === 0;
 }
@@ -16,7 +17,7 @@ function isModifiedEvent(event) {
  * @param param1
  * @todo Allow different behaviors based on whether clicked element is focusable
  */
-function useRootClose(onRootClose, _ref) {
+export function useRootClose(onRootClose, _ref) {
   var disabled = _ref.disabled,
     triggerTarget = _ref.triggerTarget,
     overlayTarget = _ref.overlayTarget,

package/esm/{utils → internals/hooks}/useTimeout.d.ts

@@ -8,5 +8,5 @@ export interface UseTimeoutFnReturn {
  * @param ms Milliseconds of the timer
  * @param enabled Whether to open the timer
  */
-declare function useTimeout(fn: (() => void) | undefined, ms?: number, enabled?: boolean): UseTimeoutFnReturn;
+export declare function useTimeout(fn: (() => void) | undefined, ms?: number, enabled?: boolean): UseTimeoutFnReturn;
 export default useTimeout;

package/esm/{utils → internals/hooks}/useTimeout.js

@@ -6,7 +6,7 @@ import { useEffect, useRef, useCallback } from 'react';
  * @param ms Milliseconds of the timer
  * @param enabled Whether to open the timer
  */
-function useTimeout(fn, ms, enabled) {
+export function useTimeout(fn, ms, enabled) {
   if (ms === void 0) {
     ms = 0;
   }

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

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TypeAttributes } from '@/internals/types';
+export declare function useToggleCaret(placement: TypeAttributes.Placement8 | TypeAttributes.Placement): import("react").FC<import("@rsuite/icons/lib/Icon").IconProps>;
+export default useToggleCaret;

package/esm/{utils → internals/hooks}/useToggleCaret.js

@@ -4,8 +4,8 @@ import AngleDownIcon from '@rsuite/icons/legacy/AngleDown';
 import AngleUpIcon from '@rsuite/icons/legacy/AngleUp';
 import AngleLeftIcon from '@rsuite/icons/legacy/AngleLeft';
 import AngleRightIcon from '@rsuite/icons/legacy/AngleRight';
-import useCustom from './useCustom';
-function useToggleCaret(placement) {
+import useCustom from "./useCustom";
+export function useToggleCaret(placement) {
   var _useCustom = useCustom('Dropdown'),
     rtl = _useCustom.rtl;
   return useMemo(function () {

package/{cjs/utils → esm/internals/hooks}/useUniqueId.d.ts

@@ -3,4 +3,5 @@
  *
  * @param idProp If id is provided, it will be used instead of generating a new one
  */
-export default function useUniqueId(prefix: string, idProp?: string): string;
+export declare function useUniqueId(prefix: string, idProp?: string): string;
+export default useUniqueId;

package/esm/{utils → internals/hooks}/useUniqueId.js

@@ -8,7 +8,7 @@ var reactUseId = React['useId'.toString()];
  *
  * @param idProp If id is provided, it will be used instead of generating a new one
  */
-export default function useUniqueId(prefix, idProp) {
+export function useUniqueId(prefix, idProp) {
   var idRef = React.useRef();
   if (reactUseId !== undefined) {
     return idProp !== null && idProp !== void 0 ? idProp : "" + prefix + reactUseId();
@@ -17,4 +17,5 @@ export default function useUniqueId(prefix, idProp) {
     idRef.current = uniqueId(prefix);
   }
   return idProp !== null && idProp !== void 0 ? idProp : idRef.current;
-}
+}
+export default useUniqueId;

package/esm/{utils → internals/hooks}/useUpdateEffect.d.ts

@@ -1,3 +1,3 @@
 import { useEffect } from 'react';
-declare const useUpdateEffect: typeof useEffect;
+export declare const useUpdateEffect: typeof useEffect;
 export default useUpdateEffect;

package/esm/{utils → internals/hooks}/useUpdateEffect.js

@@ -1,6 +1,6 @@
 'use client';
 import { useEffect, useRef } from 'react';
-var useUpdateEffect = function useUpdateEffect(effect, deps) {
+export var useUpdateEffect = function useUpdateEffect(effect, deps) {
   var isMounting = useRef(true);
   useEffect(function () {
     if (isMounting.current) {

package/{cjs/utils → esm/internals/hooks}/useUpdatedRef.d.ts

@@ -5,4 +5,5 @@
  * @param value The Ref value
  * @category refs
  */
-export default function useUpdatedRef<T>(value: T): import("react").MutableRefObject<T>;
+export declare function useUpdatedRef<T>(value: T): import("react").MutableRefObject<T>;
+export default useUpdatedRef;

package/esm/{utils → internals/hooks}/useUpdatedRef.js

@@ -7,8 +7,9 @@ import { useRef } from 'react';
  * @param value The Ref value
  * @category refs
  */
-export default function useUpdatedRef(value) {
+export function useUpdatedRef(value) {
   var valueRef = useRef(value);
   valueRef.current = value;
   return valueRef;
-}
+}
+export default useUpdatedRef;

package/{cjs/utils → esm/internals/hooks}/useWillUnmount.d.ts

@@ -4,4 +4,5 @@
  * @param fn Handler to run when the component unmounts
  * @category effects
  */
-export default function useWillUnmount(fn: () => void): void;
+export declare function useWillUnmount(fn: () => void): void;
+export default useWillUnmount;

package/esm/{utils → internals/hooks}/useWillUnmount.js

@@ -1,5 +1,5 @@
 'use client';
-import useUpdatedRef from './useUpdatedRef';
+import useUpdatedRef from "./useUpdatedRef";
 import { useEffect } from 'react';
 
 /**
@@ -8,7 +8,7 @@ import { useEffect } from 'react';
  * @param fn Handler to run when the component unmounts
  * @category effects
  */
-export default function useWillUnmount(fn) {
+export function useWillUnmount(fn) {
   var onUnmount = useUpdatedRef(fn);
 
   // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -17,4 +17,5 @@ export default function useWillUnmount(fn) {
       return onUnmount.current();
     };
   }, []);
-}
+}
+export default useWillUnmount;

package/esm/internals/propTypes/deprecatePropType.js

@@ -1,7 +1,7 @@
 'use client';
 // Ref: https://github.com/thefrontside/deprecated-prop-type/blob/master/deprecated.js
 
-import warnOnce from '../../utils/warnOnce';
+import { warnOnce } from "../utils";
 
 /**
  * Prints deprecation message when user uses a deprecated prop

package/esm/internals/propTypes/index.js

@@ -1,7 +1,7 @@
 'use client';
 import PropTypes from 'prop-types';
-export { default as oneOf } from './oneOf';
-export { default as deprecatePropType, deprecatePropTypeNew } from './deprecatePropType';
+export { default as oneOf } from "./oneOf";
+export { default as deprecatePropType, deprecatePropTypeNew } from "./deprecatePropType";
 export function tupleType() {
   for (var _len = arguments.length, typeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {
     typeCheckers[_key] = arguments[_key];

package/esm/internals/types/index.js

@@ -0,0 +1 @@
+'use client';

package/{cjs/@types → esm/internals/types}/utils.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="react" />
-export declare const tuple: <T extends string[]>(...args: T) => T;
 export declare type Partial<T> = {
     [P in keyof T]?: T[P];
 };

package/esm/internals/types/utils.js

@@ -0,0 +1 @@
+'use client';

package/esm/internals/utils/ReactChildren.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+/**
+ * Finds the first child that satisfies the given condition.
+ * @param children - The children to search.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns The first child that satisfies the condition, or undefined if no child is found.
+ */
+export declare function find(children: React.ReactNode, func: any, context?: any): React.ReactNode;
+/**
+ * Maps over the children and applies the given function to each child.
+ * @param children - The children to map over.
+ * @param func - The function to apply to each child.
+ * @param context - The context to use for the function.
+ * @returns An array of the results of applying the function to each child.
+ */
+export declare function map(children: React.ReactNode, func: any, context?: any): any[];
+/**
+ * Maps over the children and clones each child element with the provided props.
+ * @param children - The children to clone and map over.
+ * @param func - The function to apply to each child element.
+ * @param context - The context to use for the function.
+ * @returns An array of the cloned and modified child elements.
+ */
+export declare function mapCloneElement(children: React.ReactNode, func: any, context?: any): any[];
+/**
+ * Returns the number of children.
+ * @param children - The children to count.
+ * @returns The number of children.
+ */
+export declare function count(children: React.ReactNode): number;
+/**
+ * Checks if any child satisfies the given condition.
+ * @param children - The children to check.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns True if any child satisfies the condition, false otherwise.
+ */
+declare function some(children: React.ReactNode, func: any, context?: any): boolean;
+/**
+ * Utility functions for working with React children.
+ */
+export declare const ReactChildren: {
+    /**
+     * Maps over the children and clones each child element with the provided props.
+     */
+    mapCloneElement: typeof mapCloneElement;
+    /**
+     * Returns the number of children.
+     */
+    count: typeof count;
+    /**
+     * Checks if any child satisfies the given condition.
+     */
+    some: typeof some;
+    /**
+     * Maps over the children and applies the given function to each child.
+     */
+    map: typeof map;
+    /**
+     * Finds the first child that satisfies the given condition.
+     */
+    find: typeof find;
+};
+export default ReactChildren;

package/esm/internals/utils/ReactChildren.js

@@ -0,0 +1,156 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React from 'react';
+
+/**
+ * Returns the type of the given object.
+ * @param object - The object to check.
+ * @returns The type of the object.
+ */
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    return object.type || object.$$typeof;
+  }
+}
+
+/**
+ * Checks if the given children is a React fragment.
+ * @param children - The children to check.
+ * @returns True if the children is a React fragment, false otherwise.
+ */
+function isFragment(children) {
+  return React.Children.count(children) === 1 && typeOf(children) === Symbol.for('react.fragment');
+}
+
+/**
+ * Flattens the given children into an array.
+ * @param children - The children to flatten.
+ * @returns The flattened array of children.
+ */
+function flatChildren(children) {
+  return React.Children.toArray(React.Children.map(children, function (child) {
+    if (isFragment(child)) {
+      var _child$props;
+      return React.Children.toArray(((_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.children) || []);
+    }
+    return child;
+  }));
+}
+
+/**
+ * Finds the first child that satisfies the given condition.
+ * @param children - The children to search.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns The first child that satisfies the condition, or undefined if no child is found.
+ */
+export function find(children, func, context) {
+  var index = 0;
+  var result;
+  React.Children.forEach(flatChildren(children), function (child) {
+    if (result) {
+      return;
+    }
+    index += 1;
+    if (func.call(context, child, index)) {
+      result = child;
+    }
+  });
+  return result;
+}
+
+/**
+ * Maps over the children and applies the given function to each child.
+ * @param children - The children to map over.
+ * @param func - The function to apply to each child.
+ * @param context - The context to use for the function.
+ * @returns An array of the results of applying the function to each child.
+ */
+export function map(children, func, context) {
+  var index = 0;
+  return React.Children.map(flatChildren(children), function (child) {
+    if (! /*#__PURE__*/React.isValidElement(child)) {
+      return child;
+    }
+    var handle = func.call(context, child, index);
+    index += 1;
+    return handle;
+  });
+}
+
+/**
+ * Maps over the children and clones each child element with the provided props.
+ * @param children - The children to clone and map over.
+ * @param func - The function to apply to each child element.
+ * @param context - The context to use for the function.
+ * @returns An array of the cloned and modified child elements.
+ */
+export function mapCloneElement(children, func, context) {
+  return map(children, function (child, index) {
+    return /*#__PURE__*/React.cloneElement(child, _extends({
+      key: index
+    }, func(child, index)));
+  }, context);
+}
+
+/**
+ * Returns the number of children.
+ * @param children - The children to count.
+ * @returns The number of children.
+ */
+export function count(children) {
+  return React.Children.count(flatChildren(children));
+}
+
+/**
+ * Checks if any child satisfies the given condition.
+ * @param children - The children to check.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns True if any child satisfies the condition, false otherwise.
+ */
+function some(children, func, context) {
+  var index = 0;
+  var result = false;
+  React.Children.forEach(flatChildren(children), function (child) {
+    if (result) {
+      return;
+    }
+    if (! /*#__PURE__*/React.isValidElement(child)) {
+      return;
+    }
+
+    /* eslint-disable */
+    if (func.call(context, child, index += 1)) {
+      result = true;
+    }
+  });
+  return result;
+}
+
+/**
+ * Utility functions for working with React children.
+ */
+export var ReactChildren = {
+  /**
+   * Maps over the children and clones each child element with the provided props.
+   */
+  mapCloneElement: mapCloneElement,
+  /**
+   * Returns the number of children.
+   */
+  count: count,
+  /**
+   * Checks if any child satisfies the given condition.
+   */
+  some: some,
+  /**
+   * Maps over the children and applies the given function to each child.
+   */
+  map: map,
+  /**
+   * Finds the first child that satisfies the given condition.
+   */
+  find: find
+};
+export default ReactChildren;

package/esm/internals/utils/attachParent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Attaches a parent object to the given data object.
+ */
+export declare function attachParent<T>(data: T, parent: T): T;
+export default attachParent;

package/esm/{utils → internals/utils}/attachParent.js

@@ -1,4 +1,7 @@
 'use client';
+/**
+ * Attaches a parent object to the given data object.
+ */
 export function attachParent(data, parent) {
   // mark "parent" unenumable
   Object.defineProperty(data, 'parent', {
@@ -8,4 +11,5 @@ export function attachParent(data, parent) {
     configurable: true
   });
   return data;
-}
+}
+export default attachParent;

package/esm/internals/utils/composeFunctions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composes multiple functions into a single function.
+ *
+ * @example
+ * ```
+ * const a = () => console.log('a');
+ * const b = () => console.log('b');
+ * const c = () => console.log('c');
+ *
+ * const d = composeFunctions(a, b, c);
+ *
+ * d(); // a b c
+ * ```
+ */
+export declare function composeFunctions(...fns: any[]): (first: any) => any;
+export default composeFunctions;

package/esm/internals/utils/composeFunctions.js

@@ -0,0 +1,26 @@
+'use client';
+/**
+ * Composes multiple functions into a single function.
+ *
+ * @example
+ * ```
+ * const a = () => console.log('a');
+ * const b = () => console.log('b');
+ * const c = () => console.log('c');
+ *
+ * const d = composeFunctions(a, b, c);
+ *
+ * d(); // a b c
+ * ```
+ */
+export function composeFunctions() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function (first) {
+    return fns.reduce(function (previousValue, fn) {
+      return fn(previousValue);
+    }, first);
+  };
+}
+export default composeFunctions;

package/{cjs → esm/internals}/utils/createChainedFunction.d.ts

@@ -11,5 +11,5 @@
  * @param {function} functions to chain
  * @returns {function|undefined}
  */
-declare function createChainedFunction<T = any>(...funcs: (T | null)[]): T;
+export declare function createChainedFunction<T = any>(...funcs: (T | null)[]): T;
 export default createChainedFunction;

package/esm/{utils → internals/utils}/createChainedFunction.js

@@ -13,7 +13,7 @@
  * @returns {function|undefined}
  */
 
-function createChainedFunction() {
+export function createChainedFunction() {
   for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
     funcs[_key] = arguments[_key];
   }

package/{cjs → esm/internals}/utils/createComponent.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WithAsProps, RsRefForwardingComponent } from '../@types/common';
+import { WithAsProps, RsRefForwardingComponent } from '@/internals/types';
 export declare type ComponentProps = WithAsProps & React.HTMLAttributes<HTMLDivElement>;
 interface Props<TElement extends React.ElementType> extends React.HTMLAttributes<HTMLDivElement> {
     name: string;
@@ -9,5 +9,5 @@ interface Props<TElement extends React.ElementType> extends React.HTMLAttributes
 /**
  * Create a component with `classPrefix` and `as` attributes.
  */
-declare function createComponent<TElement extends React.ElementType = 'div'>({ name, componentAs, componentClassPrefix, ...defaultProps }: Props<TElement>): RsRefForwardingComponent<TElement, ComponentProps>;
+export declare function createComponent<TElement extends React.ElementType = 'div'>({ name, componentAs, componentClassPrefix, ...defaultProps }: Props<TElement>): RsRefForwardingComponent<TElement, ComponentProps>;
 export default createComponent;

package/esm/{utils → internals/utils}/createComponent.js

@@ -4,11 +4,11 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import React from 'react';
 import kebabCase from 'lodash/kebabCase';
 import PropTypes from 'prop-types';
-import { useClassNames } from '../utils';
+import { useClassNames } from "../hooks";
 /**
  * Create a component with `classPrefix` and `as` attributes.
  */
-function createComponent(_ref) {
+export function createComponent(_ref) {
   var name = _ref.name,
     componentAs = _ref.componentAs,
     componentClassPrefix = _ref.componentClassPrefix,

package/esm/internals/utils/date/copyTime.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copy the time from one date to another.
+ *
+ * @param from - The source date.
+ * @param to - The target date.
+ * @returns The target date with the time copied from the source date.
+ */
+export declare function copyTime({ from, to }: {
+    from: Date;
+    to: Date;
+}): Date;
+export default copyTime;

package/esm/internals/utils/date/copyTime.js

@@ -0,0 +1,27 @@
+'use client';
+import getHours from 'date-fns/getHours';
+import getMinutes from 'date-fns/getMinutes';
+import getSeconds from 'date-fns/getSeconds';
+import set from 'date-fns/set';
+import isValid from 'date-fns/isValid';
+
+/**
+ * Copy the time from one date to another.
+ *
+ * @param from - The source date.
+ * @param to - The target date.
+ * @returns The target date with the time copied from the source date.
+ */
+export function copyTime(_ref) {
+  var from = _ref.from,
+    to = _ref.to;
+  if (!isValid(from) || !isValid(to)) {
+    return to;
+  }
+  return set(to, {
+    hours: getHours(from),
+    minutes: getMinutes(from),
+    seconds: getSeconds(from)
+  });
+}
+export default copyTime;

package/esm/internals/utils/date/disableTime.d.ts

@@ -0,0 +1,18 @@
+import { TimeProp } from './types';
+interface CalendarProps {
+    [TimeProp.DisabledHours]?: (hours: number, date: Date) => boolean;
+    [TimeProp.DisabledMinutes]?: (minutes: number, date: Date) => boolean;
+    [TimeProp.DisabledSeconds]?: (seconds: number, date: Date) => boolean;
+    [TimeProp.HideHours]?: (hours: number, date: Date) => boolean;
+    [TimeProp.HideMinutes]?: (minutes: number, date: Date) => boolean;
+    [TimeProp.HideSeconds]?: (seconds: number, date: Date) => boolean;
+}
+/**
+ * Verify that the time is valid.
+ *
+ * @param props - The calendar props.
+ * @param date - The date to check.
+ * @returns Whether the time is disabled.
+ */
+export declare function disableTime(props: CalendarProps, date: Date): boolean;
+export default disableTime;

package/esm/internals/utils/date/disableTime.js

@@ -0,0 +1,41 @@
+'use client';
+import pick from 'lodash/pick';
+import getHours from 'date-fns/getHours';
+import getMinutes from 'date-fns/getMinutes';
+import getSeconds from 'date-fns/getSeconds';
+import { TimeProp } from "./types";
+var HOURS_PATTERN = /(Hours?)/;
+var MINUTES_PATTERN = /(Minutes?)/;
+var SECONDS_PATTERN = /(Seconds?)/;
+
+/**
+ * Verify that the time is valid.
+ *
+ * @param props - The calendar props.
+ * @param date - The date to check.
+ * @returns Whether the time is disabled.
+ */
+export function disableTime(props, date) {
+  if (!date) {
+    return false;
+  }
+  var disabledTimeProps = [TimeProp.DisabledHours, TimeProp.DisabledMinutes, TimeProp.DisabledSeconds, TimeProp.ShouldDisableHour, TimeProp.ShouldDisableMinute, TimeProp.ShouldDisableSecond];
+  var calendarProps = pick(props, disabledTimeProps);
+  var mapProps = new Map(Object.entries(calendarProps));
+  return Array.from(mapProps.keys()).some(function (key) {
+    if (HOURS_PATTERN.test(key)) {
+      var _mapProps$get;
+      return (_mapProps$get = mapProps.get(key)) === null || _mapProps$get === void 0 ? void 0 : _mapProps$get(getHours(date), date);
+    }
+    if (MINUTES_PATTERN.test(key)) {
+      var _mapProps$get2;
+      return (_mapProps$get2 = mapProps.get(key)) === null || _mapProps$get2 === void 0 ? void 0 : _mapProps$get2(getMinutes(date), date);
+    }
+    if (SECONDS_PATTERN.test(key)) {
+      var _mapProps$get3;
+      return (_mapProps$get3 = mapProps.get(key)) === null || _mapProps$get3 === void 0 ? void 0 : _mapProps$get3(getSeconds(date), date);
+    }
+    return false;
+  });
+}
+export default disableTime;

package/esm/internals/utils/date/formatCheck.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Check if the time should be rendered based on the format.
+ *
+ * @param format - The format string.
+ * @returns Whether the time should be rendered.
+ */
+export declare const shouldRenderTime: (format: string) => boolean;
+/**
+ * Check if the month should be rendered based on the format.
+ *
+ * @param format - The format string.
+ * @returns Whether the month should be rendered.
+ */
+export declare const shouldRenderMonth: (format: string) => boolean;
+/**
+ * Check if the date should be rendered based on the format.
+ *
+ * @param format - The format string.
+ * @returns Whether the date should be rendered.
+ */
+export declare const shouldRenderDate: (format: string) => boolean;
+/**
+ * Check if only the time should be rendered based on the format.
+ *
+ * @param format - The format string.
+ * @returns Whether only the time should be rendered.
+ */
+export declare const shouldOnlyRenderTime: (format: string) => boolean;