ezr-antd 1.0.0

package/lib/date-picker/style/token.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareComponentToken = exports.initPickerPanelToken = exports.initPanelComponentToken = void 0;
+var _tinycolor = require("@ctrl/tinycolor");
+var _token = require("../../input/style/token");
+var _roundedArrow = require("../../style/roundedArrow");
+const initPickerPanelToken = token => {
+  const {
+    componentCls,
+    controlHeightLG,
+    paddingXXS,
+    padding
+  } = token;
+  return {
+    pickerCellCls: `${componentCls}-cell`,
+    pickerCellInnerCls: `${componentCls}-cell-inner`,
+    pickerYearMonthCellWidth: token.calc(controlHeightLG).mul(1.5).equal(),
+    pickerQuarterPanelContentHeight: token.calc(controlHeightLG).mul(1.4).equal(),
+    pickerCellPaddingVertical: token.calc(paddingXXS).add(token.calc(paddingXXS).div(2)).equal(),
+    pickerCellBorderGap: 2,
+    // Magic for gap between cells
+    pickerControlIconSize: 7,
+    pickerControlIconMargin: 4,
+    pickerControlIconBorderWidth: 1.5,
+    pickerDatePanelPaddingHorizontal: token.calc(padding).add(token.calc(paddingXXS).div(2)).equal() // 18 in normal
+  };
+};
+exports.initPickerPanelToken = initPickerPanelToken;
+const initPanelComponentToken = token => {
+  const {
+    colorBgContainerDisabled,
+    controlHeight,
+    controlHeightSM,
+    controlHeightLG,
+    paddingXXS,
+    lineWidth
+  } = token;
+  // Item height default use `controlHeight - 2 * paddingXXS`,
+  // but some case `paddingXXS=0`.
+  // Let's fallback it.
+  const dblPaddingXXS = paddingXXS * 2;
+  const dblLineWidth = lineWidth * 2;
+  const multipleItemHeight = Math.min(controlHeight - dblPaddingXXS, controlHeight - dblLineWidth);
+  const multipleItemHeightSM = Math.min(controlHeightSM - dblPaddingXXS, controlHeightSM - dblLineWidth);
+  const multipleItemHeightLG = Math.min(controlHeightLG - dblPaddingXXS, controlHeightLG - dblLineWidth);
+  // FIXED_ITEM_MARGIN is a hardcode calculation since calc not support rounding
+  const INTERNAL_FIXED_ITEM_MARGIN = Math.floor(paddingXXS / 2);
+  const filledToken = {
+    INTERNAL_FIXED_ITEM_MARGIN,
+    cellHoverBg: token.controlItemBgHover,
+    cellActiveWithRangeBg: token.controlItemBgActive,
+    cellHoverWithRangeBg: new _tinycolor.TinyColor(token.colorPrimary).lighten(35).toHexString(),
+    cellRangeBorderColor: new _tinycolor.TinyColor(token.colorPrimary).lighten(20).toHexString(),
+    cellBgDisabled: colorBgContainerDisabled,
+    timeColumnWidth: controlHeightLG * 1.4,
+    timeColumnHeight: 28 * 8,
+    timeCellHeight: 28,
+    cellWidth: controlHeightSM * 1.5,
+    cellHeight: controlHeightSM,
+    textHeight: controlHeightLG,
+    withoutTimeCellHeight: controlHeightLG * 1.65,
+    multipleItemBg: token.colorFillSecondary,
+    multipleItemBorderColor: 'transparent',
+    multipleItemHeight,
+    multipleItemHeightSM,
+    multipleItemHeightLG,
+    multipleSelectorBgDisabled: colorBgContainerDisabled,
+    multipleItemColorDisabled: token.colorTextDisabled,
+    multipleItemBorderColorDisabled: 'transparent'
+  };
+  return filledToken;
+};
+exports.initPanelComponentToken = initPanelComponentToken;
+const prepareComponentToken = token => Object.assign(Object.assign(Object.assign(Object.assign({}, (0, _token.initComponentToken)(token)), initPanelComponentToken(token)), (0, _roundedArrow.getArrowToken)(token)), {
+  presetsWidth: 120,
+  presetsMaxWidth: 200,
+  zIndexPopup: token.zIndexPopupBase + 50
+});
+exports.prepareComponentToken = prepareComponentToken;

package/lib/date-picker/style/variants.d.ts

@@ -0,0 +1,4 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { PickerToken } from './token';
+declare const genVariantsStyle: (token: PickerToken) => CSSObject;
+export default genVariantsStyle;

package/lib/date-picker/style/variants.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _variants = require("../../input/style/variants");
+const genVariantsStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [componentCls]: [Object.assign(Object.assign(Object.assign({}, (0, _variants.genOutlinedStyle)(token)), (0, _variants.genFilledStyle)(token)), (0, _variants.genBorderlessStyle)(token)),
+    // ========================= Multiple =========================
+    {
+      '&-outlined': {
+        [`&${componentCls}-multiple ${componentCls}-selection-item`]: {
+          background: token.multipleItemBg,
+          border: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.multipleItemBorderColor}`
+        }
+      },
+      '&-filled': {
+        [`&${componentCls}-multiple ${componentCls}-selection-item`]: {
+          background: token.colorBgContainer,
+          border: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorSplit}`
+        }
+      },
+      '&-borderless': {
+        [`&${componentCls}-multiple ${componentCls}-selection-item`]: {
+          background: token.multipleItemBg,
+          border: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.multipleItemBorderColor}`
+        }
+      }
+    }]
+  };
+};
+var _default = exports.default = genVariantsStyle;

package/lib/date-picker/util.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import type { PickerMode } from 'rc-picker/lib/interface';
+import type { PickerLocale, PickerProps } from './generatePicker';
+export declare function getPlaceholder(locale: PickerLocale, picker?: PickerMode, customizePlaceholder?: string): string;
+export declare function getRangePlaceholder(locale: PickerLocale, picker?: PickerMode, customizePlaceholder?: [string, string]): [string, string] | undefined;
+export declare function useIcons(props: Pick<PickerProps, 'allowClear' | 'removeIcon'>, prefixCls: string): readonly [false | {
+    clearIcon: React.ReactNode;
+}, string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | ((props: any) => React.ReactNode) | null];

package/lib/date-picker/util.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaceholder = getPlaceholder;
+exports.getRangePlaceholder = getRangePlaceholder;
+exports.useIcons = useIcons;
+var React = _interopRequireWildcard(require("react"));
+var _useIcons = _interopRequireDefault(require("../select/useIcons"));
+function getPlaceholder(locale, picker, customizePlaceholder) {
+  if (customizePlaceholder !== undefined) {
+    return customizePlaceholder;
+  }
+  if (picker === 'year' && locale.lang.yearPlaceholder) {
+    return locale.lang.yearPlaceholder;
+  }
+  if (picker === 'quarter' && locale.lang.quarterPlaceholder) {
+    return locale.lang.quarterPlaceholder;
+  }
+  if (picker === 'month' && locale.lang.monthPlaceholder) {
+    return locale.lang.monthPlaceholder;
+  }
+  if (picker === 'week' && locale.lang.weekPlaceholder) {
+    return locale.lang.weekPlaceholder;
+  }
+  if (picker === 'time' && locale.timePickerLocale.placeholder) {
+    return locale.timePickerLocale.placeholder;
+  }
+  return locale.lang.placeholder;
+}
+function getRangePlaceholder(locale, picker, customizePlaceholder) {
+  if (customizePlaceholder !== undefined) {
+    return customizePlaceholder;
+  }
+  if (picker === 'year' && locale.lang.yearPlaceholder) {
+    return locale.lang.rangeYearPlaceholder;
+  }
+  if (picker === 'quarter' && locale.lang.quarterPlaceholder) {
+    return locale.lang.rangeQuarterPlaceholder;
+  }
+  if (picker === 'month' && locale.lang.monthPlaceholder) {
+    return locale.lang.rangeMonthPlaceholder;
+  }
+  if (picker === 'week' && locale.lang.weekPlaceholder) {
+    return locale.lang.rangeWeekPlaceholder;
+  }
+  if (picker === 'time' && locale.timePickerLocale.placeholder) {
+    return locale.timePickerLocale.rangePlaceholder;
+  }
+  return locale.lang.rangePlaceholder;
+}
+function useIcons(props, prefixCls) {
+  const {
+    allowClear = true
+  } = props;
+  const {
+    clearIcon,
+    removeIcon
+  } = (0, _useIcons.default)(Object.assign(Object.assign({}, props), {
+    prefixCls,
+    componentName: 'DatePicker'
+  }));
+  const mergedAllowClear = React.useMemo(() => {
+    if (allowClear === false) {
+      return false;
+    }
+    const allowClearConfig = allowClear === true ? {} : allowClear;
+    return Object.assign({
+      clearIcon: clearIcon
+    }, allowClearConfig);
+  }, [allowClear, clearIcon]);
+  return [mergedAllowClear, removeIcon];
+}

package/lib/descriptions/Cell.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export interface CellProps {
+    itemPrefixCls: string;
+    span: number;
+    className?: string;
+    component: string;
+    style?: React.CSSProperties;
+    labelStyle?: React.CSSProperties;
+    contentStyle?: React.CSSProperties;
+    bordered?: boolean;
+    label?: React.ReactNode;
+    content?: React.ReactNode;
+    colon?: boolean;
+    type?: 'label' | 'content' | 'item';
+}
+declare const Cell: React.FC<CellProps>;
+export default Cell;

package/lib/descriptions/Cell.js

@@ -0,0 +1,61 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+function notEmpty(val) {
+  return val !== undefined && val !== null;
+}
+const Cell = props => {
+  const {
+    itemPrefixCls,
+    component,
+    span,
+    className,
+    style,
+    labelStyle,
+    contentStyle,
+    bordered,
+    label,
+    content,
+    colon,
+    type
+  } = props;
+  const Component = component;
+  if (bordered) {
+    return /*#__PURE__*/React.createElement(Component, {
+      className: (0, _classnames.default)({
+        [`${itemPrefixCls}-item-label`]: type === 'label',
+        [`${itemPrefixCls}-item-content`]: type === 'content'
+      }, className),
+      style: style,
+      colSpan: span
+    }, notEmpty(label) && /*#__PURE__*/React.createElement("span", {
+      style: labelStyle
+    }, label), notEmpty(content) && /*#__PURE__*/React.createElement("span", {
+      style: contentStyle
+    }, content));
+  }
+  return /*#__PURE__*/React.createElement(Component, {
+    className: (0, _classnames.default)(`${itemPrefixCls}-item`, className),
+    style: style,
+    colSpan: span
+  }, /*#__PURE__*/React.createElement("div", {
+    className: `${itemPrefixCls}-item-container`
+  }, (label || label === 0) && (/*#__PURE__*/React.createElement("span", {
+    className: (0, _classnames.default)(`${itemPrefixCls}-item-label`, {
+      [`${itemPrefixCls}-item-no-colon`]: !colon
+    }),
+    style: labelStyle
+  }, label)), (content || content === 0) && (/*#__PURE__*/React.createElement("span", {
+    className: (0, _classnames.default)(`${itemPrefixCls}-item-content`),
+    style: contentStyle
+  }, content))));
+};
+var _default = exports.default = Cell;

package/lib/descriptions/DescriptionsContext.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export interface DescriptionsContextProps {
+    labelStyle?: React.CSSProperties;
+    contentStyle?: React.CSSProperties;
+}
+declare const DescriptionsContext: React.Context<DescriptionsContextProps>;
+export default DescriptionsContext;

package/lib/descriptions/DescriptionsContext.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+const DescriptionsContext = /*#__PURE__*/_react.default.createContext({});
+var _default = exports.default = DescriptionsContext;

package/lib/descriptions/Item.d.ts

@@ -0,0 +1,13 @@
+import type * as React from 'react';
+export interface DescriptionsItemProps {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    label?: React.ReactNode;
+    labelStyle?: React.CSSProperties;
+    contentStyle?: React.CSSProperties;
+    children: React.ReactNode;
+    span?: number;
+}
+declare const DescriptionsItem: React.FC<DescriptionsItemProps>;
+export default DescriptionsItem;

package/lib/descriptions/Item.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const DescriptionsItem = ({
+  children
+}) => children;
+var _default = exports.default = DescriptionsItem;

package/lib/descriptions/Row.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { InternalDescriptionsItemType } from '.';
+export interface RowProps {
+    prefixCls: string;
+    vertical: boolean;
+    row: InternalDescriptionsItemType[];
+    bordered?: boolean;
+    colon: boolean;
+    index: number;
+    children?: React.ReactNode;
+}
+declare const Row: React.FC<RowProps>;
+export default Row;

package/lib/descriptions/Row.js

@@ -0,0 +1,113 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _Cell = _interopRequireDefault(require("./Cell"));
+var _DescriptionsContext = _interopRequireDefault(require("./DescriptionsContext"));
+function renderCells(items, {
+  colon,
+  prefixCls,
+  bordered
+}, {
+  component,
+  type,
+  showLabel,
+  showContent,
+  labelStyle: rootLabelStyle,
+  contentStyle: rootContentStyle
+}) {
+  return items.map(({
+    label,
+    children,
+    prefixCls: itemPrefixCls = prefixCls,
+    className,
+    style,
+    labelStyle,
+    contentStyle,
+    span = 1,
+    key
+  }, index) => {
+    if (typeof component === 'string') {
+      return /*#__PURE__*/React.createElement(_Cell.default, {
+        key: `${type}-${key || index}`,
+        className: className,
+        style: style,
+        labelStyle: Object.assign(Object.assign({}, rootLabelStyle), labelStyle),
+        contentStyle: Object.assign(Object.assign({}, rootContentStyle), contentStyle),
+        span: span,
+        colon: colon,
+        component: component,
+        itemPrefixCls: itemPrefixCls,
+        bordered: bordered,
+        label: showLabel ? label : null,
+        content: showContent ? children : null,
+        type: type
+      });
+    }
+    return [/*#__PURE__*/React.createElement(_Cell.default, {
+      key: `label-${key || index}`,
+      className: className,
+      style: Object.assign(Object.assign(Object.assign({}, rootLabelStyle), style), labelStyle),
+      span: 1,
+      colon: colon,
+      component: component[0],
+      itemPrefixCls: itemPrefixCls,
+      bordered: bordered,
+      label: label,
+      type: "label"
+    }), /*#__PURE__*/React.createElement(_Cell.default, {
+      key: `content-${key || index}`,
+      className: className,
+      style: Object.assign(Object.assign(Object.assign({}, rootContentStyle), style), contentStyle),
+      span: span * 2 - 1,
+      component: component[1],
+      itemPrefixCls: itemPrefixCls,
+      bordered: bordered,
+      content: children,
+      type: "content"
+    })];
+  });
+}
+const Row = props => {
+  const descContext = React.useContext(_DescriptionsContext.default);
+  const {
+    prefixCls,
+    vertical,
+    row,
+    index,
+    bordered
+  } = props;
+  if (vertical) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("tr", {
+      key: `label-${index}`,
+      className: `${prefixCls}-row`
+    }, renderCells(row, props, Object.assign({
+      component: 'th',
+      type: 'label',
+      showLabel: true
+    }, descContext))), /*#__PURE__*/React.createElement("tr", {
+      key: `content-${index}`,
+      className: `${prefixCls}-row`
+    }, renderCells(row, props, Object.assign({
+      component: 'td',
+      type: 'content',
+      showContent: true
+    }, descContext))));
+  }
+  return /*#__PURE__*/React.createElement("tr", {
+    key: index,
+    className: `${prefixCls}-row`
+  }, renderCells(row, props, Object.assign({
+    component: bordered ? ['th', 'td'] : 'td',
+    type: 'item',
+    showLabel: true,
+    showContent: true
+  }, descContext)));
+};
+var _default = exports.default = Row;

package/lib/descriptions/constant.d.ts

@@ -0,0 +1,3 @@
+import type { Breakpoint } from '../_util/responsiveObserver';
+declare const DEFAULT_COLUMN_MAP: Record<Breakpoint, number>;
+export default DEFAULT_COLUMN_MAP;

package/lib/descriptions/constant.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const DEFAULT_COLUMN_MAP = {
+  xxl: 3,
+  xl: 3,
+  lg: 3,
+  md: 3,
+  sm: 2,
+  xs: 1
+};
+var _default = exports.default = DEFAULT_COLUMN_MAP;

package/lib/descriptions/hooks/useItems.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { DescriptionsItemType, InternalDescriptionsItemType } from '..';
+import type { ScreenMap } from '../../_util/responsiveObserver';
+export default function useItems(screens: ScreenMap, items?: DescriptionsItemType[], children?: React.ReactNode): InternalDescriptionsItemType[];

package/lib/descriptions/hooks/useItems.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useItems;
+var React = _interopRequireWildcard(require("react"));
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+var _responsiveObserver = require("../../_util/responsiveObserver");
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+// Convert children into items
+const transChildren2Items = childNodes => (0, _toArray.default)(childNodes).map(node => Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.props), {
+  key: node.key
+}));
+function useItems(screens, items, children) {
+  const mergedItems = React.useMemo(() =>
+  // Take `items` first or convert `children` into items
+  items || transChildren2Items(children), [items, children]);
+  const responsiveItems = React.useMemo(() => mergedItems.map(_a => {
+    var {
+        span
+      } = _a,
+      restItem = __rest(_a, ["span"]);
+    if (span === 'filled') {
+      return Object.assign(Object.assign({}, restItem), {
+        filled: true
+      });
+    }
+    return Object.assign(Object.assign({}, restItem), {
+      span: typeof span === 'number' ? span : (0, _responsiveObserver.matchScreen)(screens, span)
+    });
+  }), [mergedItems, screens]);
+  return responsiveItems;
+}

package/lib/descriptions/hooks/useRow.d.ts

@@ -0,0 +1,3 @@
+import type { InternalDescriptionsItemType } from '..';
+declare const useRow: (mergedColumn: number, items: InternalDescriptionsItemType[]) => InternalDescriptionsItemType[][];
+export default useRow;

package/lib/descriptions/hooks/useRow.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _warning = require("../../_util/warning");
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+// Calculate the sum of span in a row
+function getCalcRows(rowItems, mergedColumn) {
+  let rows = [];
+  let tmpRow = [];
+  let exceed = false;
+  let count = 0;
+  rowItems.filter(n => n).forEach(rowItem => {
+    const {
+        filled
+      } = rowItem,
+      restItem = __rest(rowItem, ["filled"]);
+    if (filled) {
+      tmpRow.push(restItem);
+      rows.push(tmpRow);
+      // reset
+      tmpRow = [];
+      count = 0;
+      return;
+    }
+    const restSpan = mergedColumn - count;
+    count += rowItem.span || 1;
+    if (count >= mergedColumn) {
+      if (count > mergedColumn) {
+        exceed = true;
+        tmpRow.push(Object.assign(Object.assign({}, restItem), {
+          span: restSpan
+        }));
+      } else {
+        tmpRow.push(restItem);
+      }
+      rows.push(tmpRow);
+      // reset
+      tmpRow = [];
+      count = 0;
+    } else {
+      tmpRow.push(restItem);
+    }
+  });
+  if (tmpRow.length > 0) {
+    rows.push(tmpRow);
+  }
+  rows = rows.map(rows => {
+    const count = rows.reduce((acc, item) => acc + (item.span || 1), 0);
+    if (count < mergedColumn) {
+      // If the span of the last element in the current row is less than the column, then add its span to the remaining columns
+      const last = rows[rows.length - 1];
+      last.span = mergedColumn - count + 1;
+      return rows;
+    }
+    return rows;
+  });
+  return [rows, exceed];
+}
+const useRow = (mergedColumn, items) => {
+  const [rows, exceed] = (0, _react.useMemo)(() => getCalcRows(items, mergedColumn), [items, mergedColumn]);
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = (0, _warning.devUseWarning)('Descriptions');
+    process.env.NODE_ENV !== "production" ? warning(!exceed, 'usage', 'Sum of column `span` in a line not match `column` of Descriptions.') : void 0;
+  }
+  return rows;
+};
+var _default = exports.default = useRow;

package/lib/descriptions/index.d.ts

@@ -0,0 +1,42 @@
+import * as React from 'react';
+import type { Breakpoint } from '../_util/responsiveObserver';
+import DescriptionsContext from './DescriptionsContext';
+import type { DescriptionsItemProps } from './Item';
+import DescriptionsItem from './Item';
+interface CompoundedComponent {
+    Item: typeof DescriptionsItem;
+}
+export interface InternalDescriptionsItemType extends DescriptionsItemProps {
+    key?: React.Key;
+    filled?: boolean;
+}
+export interface DescriptionsItemType extends Omit<InternalDescriptionsItemType, 'span' | 'filled'> {
+    span?: number | 'filled' | {
+        [key in Breakpoint]?: number;
+    };
+}
+export interface DescriptionsProps {
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    style?: React.CSSProperties;
+    bordered?: boolean;
+    size?: 'middle' | 'small' | 'default';
+    /**
+     * @deprecated use `items` instead
+     */
+    children?: React.ReactNode;
+    title?: React.ReactNode;
+    extra?: React.ReactNode;
+    column?: number | Partial<Record<Breakpoint, number>>;
+    layout?: 'horizontal' | 'vertical';
+    colon?: boolean;
+    labelStyle?: React.CSSProperties;
+    contentStyle?: React.CSSProperties;
+    items?: DescriptionsItemType[];
+    id?: string;
+}
+declare const Descriptions: React.FC<DescriptionsProps> & CompoundedComponent;
+export type { DescriptionsContextProps } from './DescriptionsContext';
+export { DescriptionsContext };
+export default Descriptions;