rsuite 5.46.1 → 5.48.0

package/esm/DateInput/useDateInputState.d.ts

@@ -0,0 +1,165 @@
+import type { Locale } from 'date-fns';
+interface DateInputState {
+    formatStr: string;
+    localize: Locale['localize'];
+    date?: Date | null;
+    isControlledDate?: boolean;
+}
+declare function useDateInputState({ formatStr, localize, date, isControlledDate }: DateInputState): {
+    dateField: {
+        year: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        month: number | null;
+        day: number | null;
+        hour: number | null;
+        minute: number | null;
+        second: number | null;
+        meridian: "AM" | "PM" | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    } | {
+        month: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        year: number | null;
+        day: number | null;
+        hour: number | null;
+        minute: number | null;
+        second: number | null;
+        meridian: "AM" | "PM" | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    } | {
+        day: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        year: number | null;
+        month: number | null;
+        hour: number | null;
+        minute: number | null;
+        second: number | null;
+        meridian: "AM" | "PM" | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    } | {
+        hour: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        year: number | null;
+        month: number | null;
+        day: number | null;
+        minute: number | null;
+        second: number | null;
+        meridian: "AM" | "PM" | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    } | {
+        minute: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        year: number | null;
+        month: number | null;
+        day: number | null;
+        hour: number | null;
+        second: number | null;
+        meridian: "AM" | "PM" | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    } | {
+        second: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        year: number | null;
+        month: number | null;
+        day: number | null;
+        hour: number | null;
+        minute: number | null;
+        meridian: "AM" | "PM" | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    } | {
+        meridian: any;
+        format: string;
+        patternArray: {
+            pattern: string;
+            key: string;
+        }[];
+        year: number | null;
+        month: number | null;
+        day: number | null;
+        hour: number | null;
+        minute: number | null;
+        second: number | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    };
+    setDateOffset: (pattern: string, offset: number, callback?: ((newDate: Date) => void) | undefined) => void;
+    setDateField: (pattern: string, value: number | null, callback?: ((newDate: Date) => void) | undefined) => void;
+    getDateField: (pattern: string) => {
+        name: any;
+        value: any;
+    };
+    toDateString: () => string;
+};
+export default useDateInputState;

package/esm/DateInput/useDateInputState.js

@@ -0,0 +1,99 @@
+'use client';
+import { useCallback } from 'react';
+import startCase from 'lodash/startCase';
+import { addDays, addMonths, addYears, addHours, addMinutes, addSeconds, format, isLastDayOfMonth, lastDayOfMonth } from '../utils/dateUtils';
+import { useDateField, patternMap } from './DateField';
+function useDateInputState(_ref) {
+  var formatStr = _ref.formatStr,
+    localize = _ref.localize,
+    date = _ref.date,
+    isControlledDate = _ref.isControlledDate;
+  var _useDateField = useDateField(formatStr, localize, date),
+    dateField = _useDateField.dateField,
+    dispatch = _useDateField.dispatch,
+    toDateString = _useDateField.toDateString,
+    toDate = _useDateField.toDate;
+  var setDateOffset = useCallback(function (pattern, offset, callback) {
+    var currentDate = new Date();
+    var year = dateField.year || currentDate.getFullYear();
+    var month = dateField.month ? dateField.month - 1 : currentDate.getMonth();
+    var day = dateField.day || 0;
+    var hour = dateField.hour || 0;
+    var minute = dateField.minute || 0;
+    var second = dateField.second || 0;
+    var actionName;
+    var value;
+    switch (pattern) {
+      case 'y':
+        actionName = 'setYear';
+        value = addYears(new Date(year, 0), offset).getFullYear();
+        break;
+      case 'M':
+        actionName = 'setMonth';
+        value = addMonths(new Date(year, month), offset).getMonth() + 1;
+        break;
+      case 'd':
+        actionName = 'setDay';
+        var prevDate = new Date(year, month, day);
+        value = addDays(prevDate, offset).getDate();
+        if (offset > 0) {
+          value = isLastDayOfMonth(prevDate) ? 1 : value;
+        } else {
+          value = prevDate.getDate() === 1 ? lastDayOfMonth(prevDate).getDate() : value;
+        }
+        break;
+      case 'H':
+      case 'h':
+        actionName = 'setHour';
+        value = addHours(new Date(year, month, day, hour), offset).getHours();
+        break;
+      case 'm':
+        actionName = 'setMinute';
+        value = addMinutes(new Date(year, month, day, hour, minute), offset).getMinutes();
+        break;
+      case 's':
+        actionName = 'setSecond';
+        value = addSeconds(new Date(year, month, day, hour, minute, second), offset).getSeconds();
+        break;
+      case 'a':
+        actionName = 'setMeridian';
+        value = dateField.meridian === 'AM' ? 'PM' : 'AM';
+        break;
+    }
+    if (actionName && value) {
+      dispatch({
+        type: actionName,
+        value: value
+      });
+      var field = patternMap[pattern];
+      callback === null || callback === void 0 ? void 0 : callback(toDate(field, value));
+    }
+  }, [dateField, toDate, dispatch]);
+  var setDateField = useCallback(function (pattern, value, callback) {
+    var field = patternMap[pattern];
+    var actionName = "set" + startCase(field);
+    dispatch({
+      type: actionName,
+      value: value
+    });
+    callback === null || callback === void 0 ? void 0 : callback(toDate(field, value));
+  }, [toDate, dispatch]);
+  var getDateField = useCallback(function (pattern) {
+    var fieldName = patternMap[pattern];
+    return {
+      name: fieldName,
+      value: dateField[fieldName]
+    };
+  }, [dateField]);
+  var toControlledDateString = useCallback(function () {
+    return format(date || new Date(), formatStr);
+  }, [date, formatStr]);
+  return {
+    dateField: dateField,
+    setDateOffset: setDateOffset,
+    setDateField: setDateField,
+    getDateField: getDateField,
+    toDateString: isControlledDate ? toControlledDateString : toDateString
+  };
+}
+export default useDateInputState;

package/esm/DateInput/utils.d.ts

@@ -0,0 +1,41 @@
+import { type Locale } from 'date-fns';
+interface SelectedStateOptions {
+    /**
+     * The input element
+     */
+    input: HTMLInputElement;
+    /**
+     * The direction of the arrow key, left or right
+     */
+    direction?: 'left' | 'right';
+    /**
+     * Format of the string is based on Unicode Technical Standard: https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+     */
+    formatStr: string;
+    /**
+     * The locale object, date-fns locale object
+     */
+    localize: Locale['localize'];
+    /**
+     * The selected month, used to calculate the offset of the character selection range
+     */
+    selectedMonth: number | null;
+    /**
+     * The offset of the value, which is used to calculate the month.
+     * This value will be changed when pressing the up and down arrow keys.
+     */
+    valueOffset?: number;
+    /**
+     * The date is rendered in string format according to format
+     */
+    dateString: string;
+}
+export declare function getPatternGroups(format: string, pattern: string): string;
+export declare function getInputSelectedState(options: SelectedStateOptions): {
+    selectionStart: number;
+    selectionEnd: number;
+    selectedPattern: string;
+};
+export declare function validateDateTime(type: string, value: number): boolean;
+export declare function modifyDate(date: Date, type: string, value: number): Date;
+export {};

package/esm/DateInput/utils.js

@@ -0,0 +1,151 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { setYear, setMonth, setDate, setHours, setMinutes, setSeconds } from '../utils/dateUtils';
+export function getPatternGroups(format, pattern) {
+  var _format$match;
+  return ((_format$match = format.match(new RegExp("(" + pattern + ")+"))) === null || _format$match === void 0 ? void 0 : _format$match[0]) || '';
+}
+export function getInputSelectedState(options) {
+  var input = options.input,
+    direction = options.direction,
+    formatStr = options.formatStr,
+    localize = options.localize,
+    selectedMonth = options.selectedMonth,
+    dateString = options.dateString,
+    _options$valueOffset = options.valueOffset,
+    valueOffset = _options$valueOffset === void 0 ? 0 : _options$valueOffset;
+  var getSelectIndexGap = function getSelectIndexGap(pattern) {
+    var gap = 0;
+    var monthIsAbbreviated = formatStr.includes('MMM');
+    var monthIsFull = formatStr.includes('MMMM');
+
+    // If the month is abbreviated or full, the gap needs to be adjusted.
+    if (monthIsAbbreviated || monthIsFull) {
+      var isSelected = pattern === 'M';
+      if (selectedMonth === null && valueOffset === 0) {
+        return gap;
+      }
+      var month = selectedMonth ? selectedMonth + (isSelected ? valueOffset : 0) : 1;
+      if (month > 12) {
+        month = 1;
+      } else if (month === 0) {
+        month = 12;
+      }
+      var monthStr = localize === null || localize === void 0 ? void 0 : localize.month(month - 1, {
+        width: monthIsFull ? 'wide' : 'abbreviated'
+      });
+      gap = monthStr.length - (monthIsFull ? 4 : 3);
+    }
+    return gap;
+  };
+  var getDatePattern = function getDatePattern(selectionIndex, positionOffset) {
+    if (positionOffset === void 0) {
+      positionOffset = -1;
+    }
+    var pattern = formatStr.charAt((input === null || input === void 0 ? void 0 : input.selectionStart) || 0);
+    if (selectionIndex < 0 || selectionIndex > dateString.length - 1) {
+      pattern = formatStr.trim().charAt(0);
+      return pattern;
+    }
+    var gap = getSelectIndexGap(pattern);
+    pattern = formatStr.charAt(selectionIndex - gap);
+
+    // If the pattern is not a letter, then get the pattern from the previous or next letter.
+    if (!pattern.match(/[y|d|M|H|h|m|s|a]/)) {
+      var nextIndex = selectionIndex + positionOffset;
+      pattern = getDatePattern(nextIndex, positionOffset);
+    }
+    return pattern;
+  };
+  var getPatternSelectedIndexes = function getPatternSelectedIndexes(pattern) {
+    var selectionStart = formatStr.indexOf(pattern);
+    var selectionEnd = formatStr.lastIndexOf(pattern) + 1;
+    var gap = getSelectIndexGap(pattern);
+    if (pattern === 'M') {
+      return {
+        selectionStart: selectionStart,
+        selectionEnd: selectionEnd + gap
+      };
+    }
+    return {
+      selectionStart: selectionStart + gap,
+      selectionEnd: selectionEnd + gap
+    };
+  };
+  if (typeof input.selectionEnd === 'number' && typeof input.selectionStart === 'number') {
+    var index = input.selectionStart;
+    var positionOffset = -1;
+    if (direction === 'left') {
+      index = input.selectionStart - 1;
+    } else if (direction === 'right') {
+      index = input.selectionEnd + 1;
+      positionOffset = 1;
+    }
+    var datePattern = getDatePattern(index, positionOffset);
+    var indexes = getPatternSelectedIndexes(datePattern);
+    return _extends({
+      selectedPattern: datePattern
+    }, indexes);
+  }
+  return {
+    selectedPattern: 'y',
+    selectionStart: 0,
+    selectionEnd: 0
+  };
+}
+export function validateDateTime(type, value) {
+  switch (type) {
+    case 'year':
+      if (value < 1 || value > 9999) {
+        return false;
+      }
+      break;
+    case 'month':
+      if (value < 1 || value > 12) {
+        return false;
+      }
+      break;
+    case 'day':
+      if (value < 1 || value > 31) {
+        return false;
+      }
+      break;
+    case 'hour':
+      if (value < 0 || value > 23) {
+        return false;
+      }
+      break;
+    case 'minute':
+      if (value < 0 || value > 59) {
+        return false;
+      }
+      break;
+    case 'second':
+      if (value < 0 || value > 59) {
+        return false;
+      }
+      break;
+    default:
+      return false;
+    // Invalid type
+  }
+
+  return true;
+}
+export function modifyDate(date, type, value) {
+  switch (type) {
+    case 'year':
+      return setYear(date, value);
+    case 'month':
+      return setMonth(date, value - 1);
+    case 'day':
+      return setDate(date, value);
+    case 'hour':
+      return setHours(date, value);
+    case 'minute':
+      return setMinutes(date, value);
+    case 'second':
+      return setSeconds(date, value);
+  }
+  return date;
+}

package/esm/DatePicker/DatePicker.d.ts

@@ -101,5 +101,10 @@ export interface DatePickerProps extends PickerBaseProps<DatePickerLocale>, Form
     /** Custom render value */
     renderValue?: (value: Date, format: string) => string;
 }
+/**
+ * A date picker allows users to select a date from a calendar.
+ *
+ * @see https://rsuitejs.com/components/date-picker
+ */
 declare const DatePicker: RsRefForwardingComponent<'div', DatePickerProps>;
 export default DatePicker;

package/esm/DatePicker/DatePicker.js

@@ -22,6 +22,11 @@ import { PickerOverlay, pickerPropTypes, PickerToggle, PickerToggleTrigger, pick
 import { OverlayCloseCause } from '../Overlay/OverlayTrigger';
 import { deprecatePropTypeNew } from '../utils/deprecatePropType';
 import { getAriaLabel } from '../Calendar/utils';
+/**
+ * A date picker allows users to select a date from a calendar.
+ *
+ * @see https://rsuitejs.com/components/date-picker
+ */
 var DatePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$as = props.as,
     Component = _props$as === void 0 ? 'div' : _props$as,

package/esm/DateRangePicker/DateRangePicker.d.ts

@@ -70,5 +70,10 @@ export interface DateRangePicker extends PickerComponent<DateRangePickerProps> {
     /** Used to combine multiple conditions */
     combine?: (...args: any) => DisabledDateFunction;
 }
+/**
+ * A date range picker allows you to select a date range from a calendar.
+ *
+ * @see https://rsuitejs.com/components/date-range-picker
+ */
 declare const DateRangePicker: DateRangePicker;
 export default DateRangePicker;

package/esm/DateRangePicker/DateRangePicker.js

@@ -21,6 +21,11 @@ import * as disabledDateUtils from './disabledDateUtils';
 import { getSafeCalendarDate, getMonthHoverRange, getWeekHoverRange, isSameRange } from './utils';
 import { deprecatePropTypeNew } from '../utils/deprecatePropType';
 import DateRangePickerContext from './DateRangePickerContext';
+/**
+ * A date range picker allows you to select a date range from a calendar.
+ *
+ * @see https://rsuitejs.com/components/date-range-picker
+ */
 var DateRangePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _ref, _ref2, _merge;
   var _props$as = props.as,

package/esm/Divider/Divider.d.ts

@@ -5,5 +5,9 @@ export interface DividerProps extends WithAsProps {
      */
     vertical?: boolean;
 }
+/**
+ * The Divider component is used to separate content.
+ * @see https://rsuitejs.com/components/divider
+ */
 declare const Divider: RsRefForwardingComponent<'div', DividerProps>;
 export default Divider;

package/esm/Divider/Divider.js

@@ -4,6 +4,10 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import React from 'react';
 import PropTypes from 'prop-types';
 import { useClassNames } from '../utils';
+/**
+ * The Divider component is used to separate content.
+ * @see https://rsuitejs.com/components/divider
+ */
 var Divider = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$as = props.as,
     Component = _props$as === void 0 ? 'div' : _props$as,

package/esm/Drawer/Drawer.d.ts

@@ -22,5 +22,9 @@ interface DrawerComponent extends React.FC<DrawerProps> {
      */
     Footer: typeof DrawerFooter;
 }
+/**
+ * The Drawer component is used to display extra content from a main content.
+ * @see https://rsuitejs.com/components/drawer
+ */
 declare const Drawer: DrawerComponent;
 export default Drawer;

package/esm/Drawer/Drawer.js

@@ -43,6 +43,10 @@ var DrawerTitle = /*#__PURE__*/React.forwardRef(function (props, ref) {
     ref: ref
   }));
 });
+/**
+ * The Drawer component is used to display extra content from a main content.
+ * @see https://rsuitejs.com/components/drawer
+ */
 var Drawer = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var className = props.className,
     _props$placement = props.placement,

package/esm/Dropdown/Dropdown.d.ts

@@ -62,9 +62,12 @@ export interface DropdownComponent extends RsRefForwardingComponent<'div', Dropd
     Separator: typeof DropdownSeparator;
 }
 /**
- * The <Dropdown> API
- * When used inside <Sidenav>, renders a <TreeviewRootItem>;
- * Otherwise renders a <MenuRoot>
+ * The `Dropdown` component is used to select an option from a set of options.
+ * @see https://rsuitejs.com/components/dropdown
+ *
+ * The `<Dropdown>` API
+ * - When used inside `<Sidenav>`, renders a `<TreeviewRootItem>`;
+ * - Otherwise renders a `<MenuRoot>`
  */
 declare const Dropdown: DropdownComponent;
 export default Dropdown;

package/esm/Dropdown/Dropdown.js

@@ -19,9 +19,12 @@ import warnOnce from '../utils/warnOnce';
 import Nav from '../Nav';
 import DropdownSeparator from './DropdownSeparator';
 /**
- * The <Dropdown> API
- * When used inside <Sidenav>, renders a <TreeviewRootItem>;
- * Otherwise renders a <MenuRoot>
+ * The `Dropdown` component is used to select an option from a set of options.
+ * @see https://rsuitejs.com/components/dropdown
+ *
+ * The `<Dropdown>` API
+ * - When used inside `<Sidenav>`, renders a `<TreeviewRootItem>`;
+ * - Otherwise renders a `<MenuRoot>`
  */
 var Dropdown = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var activeKey = props.activeKey,

package/esm/Dropdown/DropdownItem.d.ts

@@ -39,9 +39,9 @@ export interface DropdownMenuItemProps<T = any> extends WithAsProps, Omit<React.
     onSelect?: (eventKey: T, event: React.SyntheticEvent) => void;
 }
 /**
- * The <Dropdown.Item> API
- * When used inside <Sidenav>, renders a <TreeviewItem>
- * Otherwise renders a <MenuItem>
+ * The `<Dropdown.Item>` API
+ * - When used inside `<Sidenav>`, renders a `<TreeviewItem>`
+ * - Otherwise renders a `<MenuItem>`
  */
 declare const DropdownItem: RsRefForwardingComponent<'li', DropdownMenuItemProps>;
 export default DropdownItem;

package/esm/Dropdown/DropdownItem.js

@@ -17,9 +17,9 @@ import warnOnce from '../utils/warnOnce';
 import Nav from '../Nav';
 import DropdownSeparator from './DropdownSeparator';
 /**
- * The <Dropdown.Item> API
- * When used inside <Sidenav>, renders a <TreeviewItem>
- * Otherwise renders a <MenuItem>
+ * The `<Dropdown.Item>` API
+ * - When used inside `<Sidenav>`, renders a `<TreeviewItem>`
+ * - Otherwise renders a `<MenuItem>`
  */
 var DropdownItem = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$classPrefix = props.classPrefix,

package/esm/Dropdown/DropdownMenu.d.ts

@@ -23,11 +23,11 @@ export interface DropdownMenuProps<T = string> extends StandardProps {
     onToggle?: (eventKey: T | undefined, event: React.SyntheticEvent) => void;
 }
 /**
- * The <Dropdown.Menu> API
+ * The `<Dropdown.Menu>` API
  *
  * @description
- * Note the difference between this component and <Menu> component:
- * <Menu> is used for ARIA menu control logic and is used internally only.
+ * Note the difference between this component and `<Menu>` component:
+ * `<Menu>` is used for ARIA menu control logic and is used internally only.
  * This component is only used for supporting submenu syntax and is
  * assigned to Dropdown.Menu
  *

package/esm/Dropdown/DropdownMenu.js

@@ -18,11 +18,11 @@ import Nav from '../Nav';
 import NavContext from '../Nav/NavContext';
 import warnOnce from '../utils/warnOnce';
 /**
- * The <Dropdown.Menu> API
+ * The `<Dropdown.Menu>` API
  *
  * @description
- * Note the difference between this component and <Menu> component:
- * <Menu> is used for ARIA menu control logic and is used internally only.
+ * Note the difference between this component and `<Menu>` component:
+ * `<Menu>` is used for ARIA menu control logic and is used internally only.
  * This component is only used for supporting submenu syntax and is
  * assigned to Dropdown.Menu
  *

package/esm/Dropdown/DropdownSeparator.d.ts

@@ -5,7 +5,7 @@ export interface DropdownSeparatorProps extends WithAsProps, React.HTMLAttribute
     as?: React.ElementType;
 }
 /**
- * The <Dropdown.Separator> API
+ * The `<Dropdown.Separator>` API
  *
  * Renders a non-focusable and non-interactive `separator`
  * Per ARIA APG https://www.w3.org/WAI/ARIA/apg/patterns/menu/

package/esm/Dropdown/DropdownSeparator.js

@@ -5,7 +5,7 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { useClassNames } from '../utils';
 /**
- * The <Dropdown.Separator> API
+ * The `<Dropdown.Separator>` API
  *
  * Renders a non-focusable and non-interactive `separator`
  * Per ARIA APG https://www.w3.org/WAI/ARIA/apg/patterns/menu/

package/esm/FlexboxGrid/FlexboxGrid.d.ts

@@ -9,5 +9,9 @@ export interface FlexboxGridProps extends WithAsProps {
 interface FlexboxGridCompont extends RsRefForwardingComponent<'div', FlexboxGridProps> {
     Item: typeof FlexboxGridItem;
 }
+/**
+ * The FlexboxGrid component is a box that can be used to layout other components.
+ * @see https://rsuitejs.com/components/flexbox-grid
+ */
 declare const FlexboxGrid: FlexboxGridCompont;
 export default FlexboxGrid;