antd-mobile 5.37.1 → 5.38.1

package/2x/es/components/calendar-picker-view/calendar-picker-view.js

@@ -1,8 +1,8 @@
 import classNames from 'classnames';
 import dayjs from 'dayjs';
-import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
 import isoWeek from 'dayjs/plugin/isoWeek';
-import React, { forwardRef, useContext, useImperativeHandle, useMemo, useRef, useState } from 'react';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import React, { forwardRef, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
 import { withNativeProps } from '../../utils/native-props';
 import { usePropsValue } from '../../utils/use-props-value';
 import { mergeProps } from '../../utils/with-default-props';
@@ -49,12 +49,33 @@ export const CalendarPickerView = forwardRef((p, ref) => {
   });
   const [intermediate, setIntermediate] = useState(false);
   const [current, setCurrent] = useState(() => dayjs(dateRange ? dateRange[0] : today).date(1));
+  const onDateChange = v => {
+    if (v) {
+      setCurrent(dayjs(v[0]).date(1));
+    }
+    setDateRange(v);
+  };
+  const showHeader = props.title !== false;
   // =============================== Scroll ===============================
   const context = useContext(Context);
   const scrollTo = useSyncScroll(current, context.visible, bodyRef);
   // ============================== Boundary ==============================
-  const maxDay = useMemo(() => props.max ? dayjs(props.max) : current.add(6, 'month'), [props.max, current]);
-  const minDay = useMemo(() => props.min ? dayjs(props.min) : current, [props.min, current]);
+  // 记录默认的 min 和 max，并在外部的值超出边界时自动扩充
+  const [defaultMin, setDefaultMin] = useState(current);
+  const [defaultMax, setDefaultMax] = useState(() => current.add(6, 'month'));
+  useEffect(() => {
+    if (dateRange) {
+      const [startDate, endDate] = dateRange;
+      if (!props.min && startDate && dayjs(startDate).isBefore(defaultMin)) {
+        setDefaultMin(dayjs(startDate).date(1));
+      }
+      if (!props.max && endDate && dayjs(endDate).isAfter(defaultMax)) {
+        setDefaultMax(dayjs(endDate).endOf('month'));
+      }
+    }
+  }, [dateRange]);
+  const maxDay = useMemo(() => props.max ? dayjs(props.max) : defaultMax, [props.max, defaultMax]);
+  const minDay = useMemo(() => props.min ? dayjs(props.min) : defaultMin, [props.min, defaultMin]);
   // ================================ Refs ================================
   useImperativeHandle(ref, () => ({
     jumpTo: pageOrPageGenerator => {
@@ -173,27 +194,27 @@ export const CalendarPickerView = forwardRef((p, ref) => {
             }
             if (props.selectionMode === 'single') {
               if (props.allowClear && shouldClear()) {
-                setDateRange(null);
+                onDateChange(null);
                 return;
               }
-              setDateRange([date, date]);
+              onDateChange([date, date]);
             } else if (props.selectionMode === 'range') {
               if (!dateRange) {
-                setDateRange([date, date]);
+                onDateChange([date, date]);
                 setIntermediate(true);
                 return;
               }
               if (shouldClear()) {
-                setDateRange(null);
+                onDateChange(null);
                 setIntermediate(false);
                 return;
               }
               if (intermediate) {
                 const another = dateRange[0];
-                setDateRange(another > date ? [date, another] : [another, date]);
+                onDateChange(another > date ? [date, another] : [another, date]);
                 setIntermediate(false);
               } else {
-                setDateRange([date, date]);
+                onDateChange([date, date]);
                 setIntermediate(true);
               }
             }
@@ -222,5 +243,5 @@ export const CalendarPickerView = forwardRef((p, ref) => {
   }, item)));
   return withNativeProps(props, React.createElement("div", {
     className: classPrefix
-  }, header, mark, body));
+  }, showHeader && header, mark, body));
 });

package/2x/es/components/card/card.css

@@ -9,6 +9,7 @@
   display: flex;
   justify-content: space-between;
   align-items: center;
+  gap: var(--adm-card-header-gap, 16px);
   box-sizing: border-box;
   padding: var(--adm-card-header-padding-block, 24px) 0;
 }

package/2x/es/components/card/card.d.ts

@@ -1,8 +1,9 @@
+import type { CSSProperties, FC, ReactNode } from 'react';
 import React from 'react';
-import type { FC, ReactNode, CSSProperties } from 'react';
 import { NativeProps } from '../../utils/native-props';
 export declare type CardProps = {
     title?: ReactNode;
+    icon?: ReactNode;
     extra?: ReactNode;
     headerStyle?: CSSProperties;
     headerClassName?: string;

package/2x/es/components/card/card.js

@@ -1,5 +1,5 @@
-import React from 'react';
 import classNames from 'classnames';
+import React from 'react';
 import { withNativeProps } from '../../utils/native-props';
 const classPrefix = `adm-card`;
 export const Card = props => {
@@ -11,9 +11,13 @@ export const Card = props => {
       className: classNames(`${classPrefix}-header`, props.headerClassName),
       style: props.headerStyle,
       onClick: props.onHeaderClick
-    }, React.createElement("div", {
+    }, props.icon && React.createElement("div", {
+      className: `${classPrefix}-header-icon`
+    }, props.icon), React.createElement("div", {
       className: `${classPrefix}-header-title`
-    }, props.title), props.extra);
+    }, props.title), props.extra && React.createElement("div", {
+      className: `${classPrefix}-header-extra`
+    }, props.extra));
   };
   const renderBody = () => {
     if (!props.children) {

package/2x/es/components/card/card.patch.css

@@ -16,6 +16,14 @@
   font-size: 30px;
 }
 
+.adm-card-header-icon {
+  margin-right: 16px;
+}
+
+.adm-card-header-extra {
+  margin-left: 16px;
+}
+
 .adm-card-body {
   padding: 24px 0;
 }

package/2x/es/components/date-picker/date-picker-quarter-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import { PickerColumn } from '../picker';
+import type { DatePickerFilter } from './date-picker-utils';
+export declare type QuarterPrecision = 'year' | 'quarter';
+export declare function generateDatePickerColumns(selected: string[], min: Date, max: Date, precision: QuarterPrecision, renderLabel: (type: QuarterPrecision, data: number) => ReactNode, filter: DatePickerFilter | undefined): PickerColumn[];
+export declare function convertDateToStringArray(date: Date | undefined | null): string[];
+export declare function convertStringArrayToDate<T extends string | number | null | undefined>(value: T[]): Date;

package/2x/es/components/date-picker/date-picker-quarter-utils.js

@@ -0,0 +1,68 @@
+import dayjs from 'dayjs';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+dayjs.extend(quarterOfYear);
+const precisionRankRecord = {
+  year: 0,
+  quarter: 1
+};
+export function generateDatePickerColumns(selected, min, max, precision, renderLabel, filter) {
+  const ret = [];
+  const minYear = min.getFullYear();
+  const maxYear = max.getFullYear();
+  const rank = precisionRankRecord[precision];
+  const selectedYear = parseInt(selected[0]);
+  const isInMinYear = selectedYear === minYear;
+  const isInMaxYear = selectedYear === maxYear;
+  const minDay = dayjs(min);
+  const maxDay = dayjs(max);
+  const minQuarter = minDay.quarter();
+  const maxQuarter = maxDay.quarter();
+  const generateColumn = (from, to, precision) => {
+    let column = [];
+    for (let i = from; i <= to; i++) {
+      column.push(i);
+    }
+    const prefix = selected.slice(0, precisionRankRecord[precision]);
+    const currentFilter = filter === null || filter === void 0 ? void 0 : filter[precision];
+    if (currentFilter && typeof currentFilter === 'function') {
+      column = column.filter(i => currentFilter(i, {
+        get date() {
+          const stringArray = [...prefix, i.toString()];
+          return convertStringArrayToDate(stringArray);
+        }
+      }));
+    }
+    return column;
+  };
+  if (rank >= precisionRankRecord.year) {
+    const lower = minYear;
+    const upper = maxYear;
+    const years = generateColumn(lower, upper, 'year');
+    ret.push(years.map(v => ({
+      label: renderLabel('year', v),
+      value: v.toString()
+    })));
+  }
+  if (rank >= precisionRankRecord.quarter) {
+    const lower = isInMinYear ? minQuarter : 1;
+    const upper = isInMaxYear ? maxQuarter : 4;
+    const quarters = generateColumn(lower, upper, 'quarter');
+    ret.push(quarters.map(v => ({
+      label: renderLabel('quarter', v),
+      value: v.toString()
+    })));
+  }
+  return ret;
+}
+export function convertDateToStringArray(date) {
+  if (!date) return [];
+  const day = dayjs(date);
+  return [day.year().toString(), day.quarter().toString()];
+}
+export function convertStringArrayToDate(value) {
+  var _a, _b;
+  const yearString = (_a = value[0]) !== null && _a !== void 0 ? _a : '1900';
+  const quarterString = (_b = value[1]) !== null && _b !== void 0 ? _b : '1';
+  const day = dayjs().year(parseInt(yearString)).quarter(parseInt(quarterString)).hour(0).minute(0).second(0);
+  return day.toDate();
+}

package/2x/es/components/date-picker/date-picker-utils.d.ts

@@ -1,7 +1,8 @@
+import { RenderLabel } from '../date-picker-view/date-picker-view';
 import type { DatePrecision } from './date-picker-date-utils';
+import type { QuarterPrecision } from './date-picker-quarter-utils';
 import type { WeekPrecision } from './date-picker-week-utils';
-import { RenderLabel } from '../date-picker-view/date-picker-view';
-export declare type Precision = DatePrecision | WeekPrecision;
+export declare type Precision = DatePrecision | WeekPrecision | QuarterPrecision;
 export declare type DatePickerFilter = Partial<Record<Precision, (val: number, extend: {
     date: Date;
 }) => boolean>>;

package/2x/es/components/date-picker/date-picker-utils.js

@@ -1,4 +1,5 @@
 import * as dateUtils from './date-picker-date-utils';
+import * as quarterUtils from './date-picker-quarter-utils';
 import * as weekUtils from './date-picker-week-utils';
 import { TILL_NOW } from './util';
 const precisionLengthRecord = {
@@ -12,6 +13,8 @@ const precisionLengthRecord = {
 export const convertDateToStringArray = (date, precision) => {
   if (precision.includes('week')) {
     return weekUtils.convertDateToStringArray(date);
+  } else if (precision.includes('quarter')) {
+    return quarterUtils.convertDateToStringArray(date);
   } else {
     const datePrecision = precision;
     const stringArray = dateUtils.convertDateToStringArray(date);
@@ -27,6 +30,8 @@ export const convertStringArrayToDate = (value, precision) => {
   }
   if (precision.includes('week')) {
     return weekUtils.convertStringArrayToDate(value);
+  } else if (precision.includes('quarter')) {
+    return quarterUtils.convertStringArrayToDate(value);
   } else {
     return dateUtils.convertStringArrayToDate(value);
   }
@@ -34,6 +39,8 @@ export const convertStringArrayToDate = (value, precision) => {
 export const generateDatePickerColumns = (selected, min, max, precision, renderLabel, filter, tillNow) => {
   if (precision.startsWith('week')) {
     return weekUtils.generateDatePickerColumns(selected, min, max, precision, renderLabel, filter);
+  } else if (precision.startsWith('quarter')) {
+    return quarterUtils.generateDatePickerColumns(selected, min, max, precision, renderLabel, filter);
   } else {
     return dateUtils.generateDatePickerColumns(selected, min, max, precision, renderLabel, filter, tillNow);
   }

package/2x/es/components/ellipsis/ellipsis.css

@@ -1,4 +1,5 @@
 .adm-ellipsis {
   overflow: hidden;
   line-height: 1.5;
+  word-break: break-word;
 }

package/2x/es/components/ellipsis/ellipsis.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
 import type { FC, ReactNode } from 'react';
+import React from 'react';
 import { NativeProps } from '../../utils/native-props';
 import { PropagationEvent } from '../../utils/with-stop-propagation';
 export declare type EllipsisProps = {

package/2x/es/components/ellipsis/ellipsis.js

@@ -1,10 +1,9 @@
-import React, { useMemo, useRef, useState } from 'react';
-import runes from 'runes2';
-import { mergeProps } from '../../utils/with-default-props';
+import React from 'react';
 import { withNativeProps } from '../../utils/native-props';
 import { useResizeEffect } from '../../utils/use-resize-effect';
-import { useIsomorphicLayoutEffect } from 'ahooks';
+import { mergeProps } from '../../utils/with-default-props';
 import { withStopPropagation } from '../../utils/with-stop-propagation';
+import useMeasure from './useMeasure';
 const classPrefix = `adm-ellipsis`;
 const defaultProps = {
   direction: 'end',
@@ -18,134 +17,41 @@ const defaultProps = {
 };
 export const Ellipsis = p => {
   const props = mergeProps(defaultProps, p);
-  const rootRef = useRef(null);
-  const expandElRef = useRef(null);
-  const collapseElRef = useRef(null);
-  const [ellipsised, setEllipsised] = useState({});
-  const [expanded, setExpanded] = useState(props.defaultExpanded);
-  const [exceeded, setExceeded] = useState(false);
-  const chars = useMemo(() => runes(props.content), [props.content]);
-  function getSubString(start, end) {
-    return chars.slice(start, end).join('');
-  }
-  function calcEllipsised() {
-    var _a, _b;
-    const root = rootRef.current;
-    if (!root) return;
-    const originDisplay = root.style.display;
-    root.style.display = 'block';
-    const originStyle = window.getComputedStyle(root);
-    const container = document.createElement('div');
-    const styleNames = Array.prototype.slice.apply(originStyle);
-    styleNames.forEach(name => {
-      container.style.setProperty(name, originStyle.getPropertyValue(name));
-    });
-    root.style.display = originDisplay;
-    container.style.height = 'auto';
-    container.style.minHeight = 'auto';
-    container.style.maxHeight = 'auto';
-    container.style.textOverflow = 'clip';
-    container.style.webkitLineClamp = 'unset';
-    container.style.display = 'block';
-    const lineHeight = pxToNumber(originStyle.lineHeight);
-    const maxHeight = Math.floor(lineHeight * (props.rows + 0.5) + pxToNumber(originStyle.paddingTop) + pxToNumber(originStyle.paddingBottom));
-    container.innerText = props.content;
-    document.body.appendChild(container);
-    if (container.offsetHeight <= maxHeight) {
-      setExceeded(false);
-    } else {
-      setExceeded(true);
-      const end = props.content.length;
-      const collapseEl = typeof props.collapseText === 'string' ? props.collapseText : (_a = collapseElRef.current) === null || _a === void 0 ? void 0 : _a.innerHTML;
-      const expandEl = typeof props.expandText === 'string' ? props.expandText : (_b = expandElRef.current) === null || _b === void 0 ? void 0 : _b.innerHTML;
-      const actionText = expanded ? collapseEl : expandEl;
-      function check(left, right) {
-        if (right - left <= 1) {
-          if (props.direction === 'end') {
-            return {
-              leading: getSubString(0, left) + '...'
-            };
-          } else {
-            return {
-              tailing: '...' + getSubString(right, end)
-            };
-          }
-        }
-        const middle = Math.round((left + right) / 2);
-        if (props.direction === 'end') {
-          container.innerHTML = getSubString(0, middle) + '...' + actionText;
-        } else {
-          container.innerHTML = actionText + '...' + getSubString(middle, end);
-        }
-        if (container.offsetHeight <= maxHeight) {
-          if (props.direction === 'end') {
-            return check(middle, right);
-          } else {
-            return check(left, middle);
-          }
-        } else {
-          if (props.direction === 'end') {
-            return check(left, middle);
-          } else {
-            return check(middle, right);
-          }
-        }
-      }
-      function checkMiddle(leftPart, rightPart) {
-        if (leftPart[1] - leftPart[0] <= 1 && rightPart[1] - rightPart[0] <= 1) {
-          return {
-            leading: getSubString(0, leftPart[0]) + '...',
-            tailing: '...' + getSubString(rightPart[1], end)
-          };
-        }
-        const leftPartMiddle = Math.floor((leftPart[0] + leftPart[1]) / 2);
-        const rightPartMiddle = Math.ceil((rightPart[0] + rightPart[1]) / 2);
-        container.innerHTML = getSubString(0, leftPartMiddle) + '...' + actionText + '...' + getSubString(rightPartMiddle, end);
-        if (container.offsetHeight <= maxHeight) {
-          return checkMiddle([leftPartMiddle, leftPart[1]], [rightPart[0], rightPartMiddle]);
-        } else {
-          return checkMiddle([leftPart[0], leftPartMiddle], [rightPartMiddle, rightPart[1]]);
-        }
-      }
-      const middle = Math.floor((0 + end) / 2);
-      const ellipsised = props.direction === 'middle' ? checkMiddle([0, middle], [middle, end]) : check(0, end);
-      setEllipsised(ellipsised);
-    }
-    document.body.removeChild(container);
-  }
-  useResizeEffect(calcEllipsised, rootRef);
-  useIsomorphicLayoutEffect(() => {
-    calcEllipsised();
-  }, [props.content, props.direction, props.rows, props.expandText, props.collapseText]);
-  const expandActionElement = !!props.expandText && withStopPropagation(props.stopPropagationForActionButtons, React.createElement("a", {
-    ref: expandElRef,
+  const {
+    content,
+    direction,
+    rows,
+    expandText,
+    collapseText,
+    stopPropagationForActionButtons,
+    onContentClick,
+    defaultExpanded
+  } = props;
+  // ============================ Refs ============================
+  const rootRef = React.useRef(null);
+  // ========================== Expanded ==========================
+  const [expanded, setExpanded] = React.useState(defaultExpanded);
+  const expandNode = expandText ? withStopPropagation(stopPropagationForActionButtons, React.createElement("a", {
     onClick: () => {
       setExpanded(true);
     }
-  }, props.expandText));
-  const collapseActionElement = !!props.collapseText && withStopPropagation(props.stopPropagationForActionButtons, React.createElement("a", {
-    ref: collapseElRef,
+  }, expandText)) : null;
+  const collapseNode = collapseText ? withStopPropagation(stopPropagationForActionButtons, React.createElement("a", {
     onClick: () => {
       setExpanded(false);
     }
-  }, props.collapseText));
-  const renderContent = () => {
-    if (!exceeded) return props.content;
-    if (expanded) return React.createElement(React.Fragment, null, props.content, collapseActionElement);
-    return React.createElement(React.Fragment, null, ellipsised.leading, expandActionElement, ellipsised.tailing);
-  };
+  }, collapseText)) : null;
+  // ========================== Ellipsis ==========================
+  const [measureNodes, forceResize] = useMeasure(rootRef, content, rows, direction, expanded, expandNode, collapseNode);
+  useResizeEffect(forceResize, rootRef);
+  // =========================== Render ===========================
   return withNativeProps(props, React.createElement("div", {
     ref: rootRef,
     className: classPrefix,
     onClick: e => {
       if (e.target === e.currentTarget) {
-        props.onContentClick(e);
+        onContentClick(e);
       }
     }
-  }, renderContent()));
-};
-function pxToNumber(value) {
-  if (!value) return 0;
-  const match = value.match(/^\d*(\.\d*)?/);
-  return match ? Number(match[0]) : 0;
-}
+  }, measureNodes));
+};

package/2x/es/components/ellipsis/useMeasure.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function useMeasure(containerRef: React.RefObject<HTMLDivElement>, content: string, rows: number, direction: 'start' | 'end' | 'middle', expanded: boolean, expandNode: React.ReactElement | null, collapseNode: React.ReactElement | null): readonly [React.JSX.Element, () => void];

package/2x/es/components/ellipsis/useMeasure.js

@@ -0,0 +1,101 @@
+import { useEvent } from 'rc-util';
+import React from 'react';
+import runes from 'runes2';
+const ELLIPSIS_TEXT = '...';
+const measureStyle = {
+  visibility: 'hidden',
+  whiteSpace: 'inherit',
+  lineHeight: 'inherit',
+  fontSize: 'inherit'
+};
+export default function useMeasure(containerRef, content, rows, direction, expanded, expandNode, collapseNode) {
+  const contentChars = React.useMemo(() => runes(content), [content]);
+  const [maxHeight, setMaxHeight] = React.useState(0);
+  const [walkingIndexes, setWalkingIndexes] = React.useState([0, 0]);
+  const midIndex = Math.ceil((walkingIndexes[0] + walkingIndexes[1]) / 2);
+  const [status, setStatus] = React.useState(100 /* STABLE_NO_ELLIPSIS */);
+  // ============================ Refs ============================
+  const singleRowMeasureRef = React.useRef(null);
+  const fullMeasureRef = React.useRef(null);
+  const midMeasureRef = React.useRef(null);
+  const startMeasure = useEvent(() => {
+    setStatus(1 /* PREPARE */);
+    setWalkingIndexes([0, direction === 'middle' ? Math.ceil(contentChars.length / 2) : contentChars.length]);
+  });
+  // Initialize
+  React.useLayoutEffect(() => {
+    startMeasure();
+  }, [contentChars, rows]);
+  // Measure element height
+  React.useLayoutEffect(() => {
+    var _a, _b;
+    if (status === 1 /* PREPARE */) {
+      const fullMeasureHeight = ((_a = fullMeasureRef.current) === null || _a === void 0 ? void 0 : _a.offsetHeight) || 0;
+      const singleRowMeasureHeight = ((_b = singleRowMeasureRef.current) === null || _b === void 0 ? void 0 : _b.offsetHeight) || 0;
+      const rowMeasureHeight = singleRowMeasureHeight * rows;
+      if (fullMeasureHeight <= rowMeasureHeight) {
+        setStatus(100 /* STABLE_NO_ELLIPSIS */);
+      } else {
+        setMaxHeight(rowMeasureHeight);
+        setStatus(2 /* MEASURE_WALKING */);
+      }
+    }
+  }, [status]);
+  // Walking measure
+  React.useLayoutEffect(() => {
+    var _a;
+    if (status === 2 /* MEASURE_WALKING */) {
+      const diff = walkingIndexes[1] - walkingIndexes[0];
+      const midHeight = ((_a = midMeasureRef.current) === null || _a === void 0 ? void 0 : _a.offsetHeight) || 0;
+      if (diff > 1) {
+        if (midHeight > maxHeight) {
+          setWalkingIndexes([walkingIndexes[0], midIndex]);
+        } else {
+          setWalkingIndexes([midIndex, walkingIndexes[1]]);
+        }
+      } else {
+        if (midHeight > maxHeight) {
+          setWalkingIndexes([walkingIndexes[0], walkingIndexes[0]]);
+        } else {
+          setWalkingIndexes([walkingIndexes[1], walkingIndexes[1]]);
+        }
+        setStatus(99 /* STABLE_ELLIPSIS */);
+      }
+    }
+  }, [status, walkingIndexes]);
+  // =========================== Render ===========================
+  /** Render by cut index */
+  const renderContent = index => {
+    const prefixContent = contentChars.slice(0, index);
+    const suffixContent = contentChars.slice(contentChars.length - index);
+    return React.createElement(React.Fragment, null, direction === 'start' && React.createElement(React.Fragment, null, expandNode, ELLIPSIS_TEXT), direction !== 'start' && prefixContent.join(''), direction === 'middle' && React.createElement(React.Fragment, null, ELLIPSIS_TEXT, expandNode, ELLIPSIS_TEXT), direction !== 'end' && suffixContent.join(''), direction === 'end' && React.createElement(React.Fragment, null, ELLIPSIS_TEXT, expandNode));
+  };
+  const finalContent = React.useMemo(() => {
+    if (expanded || status === 100 /* STABLE_NO_ELLIPSIS */) {
+      return React.createElement(React.Fragment, {
+        key: 'display'
+      }, content, status === 99 /* STABLE_ELLIPSIS */ && collapseNode);
+    }
+    if (status === 99 /* STABLE_ELLIPSIS */) {
+      return renderContent(midIndex);
+    }
+    return null;
+  }, [expanded, status, content, collapseNode, midIndex]);
+  const allNodes = React.createElement(React.Fragment, null, status === 1 /* PREPARE */ && React.createElement("div", {
+    key: 'full',
+    "aria-hidden": true,
+    ref: fullMeasureRef,
+    style: measureStyle
+  }, content, expandNode), status === 1 /* PREPARE */ && React.createElement("div", {
+    key: 'stable',
+    "aria-hidden": true,
+    ref: singleRowMeasureRef,
+    style: measureStyle
+  }, '\u00A0'), status === 2 /* MEASURE_WALKING */ && React.createElement("div", {
+    key: 'walking-mid',
+    "aria-hidden": true,
+    ref: midMeasureRef,
+    style: measureStyle
+  }, renderContent(midIndex)), finalContent);
+  return [allNodes, startMeasure];
+}

package/2x/es/components/ellipsis/~ellipsis.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { FC, ReactNode } from 'react';
+import { NativeProps } from '../../utils/native-props';
+import { PropagationEvent } from '../../utils/with-stop-propagation';
+export declare type EllipsisProps = {
+    content: string;
+    direction?: 'start' | 'end' | 'middle';
+    rows?: number;
+    expandText?: ReactNode;
+    collapseText?: ReactNode;
+    stopPropagationForActionButtons?: PropagationEvent[];
+    onContentClick?: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    defaultExpanded?: boolean;
+} & NativeProps;
+export declare const Ellipsis: FC<EllipsisProps>;