@atlaskit/renderer 137.1.7 → 137.1.9

package/dist/es2019/ui/utils/expand-body.js

@@ -0,0 +1,198 @@
+import React, { createContext, isValidElement, useContext } from 'react';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
+import { BLOCK_SEPARATOR, getBlockSearchText, getTableStandInParts, holdsRevealableContent, isExpandNode } from './expand-search-text';
+const ExpandBodyContext = /*#__PURE__*/createContext(null);
+export const ExpandBodyProvider = ExpandBodyContext.Provider;
+export const useExpandBody = () => useContext(ExpandBodyContext);
+/**
+ * One or more neighbouring blocks of an expand's body. Shows their text until the expand is
+ * opened, then renders them. Falls back to rendering if there is no text, or if there is no
+ * expand above it.
+ *
+ * The text is rendered as-is, with no element around it. Nothing reads it but browser find,
+ * which only needs the characters to be in the DOM.
+ */
+export const ExpandBodyBlock = ({
+  children,
+  searchText
+}) => {
+  const body = useExpandBody();
+  if (searchText === undefined || body === null || body.revealed) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  }
+  return searchText;
+};
+
+/**
+ * Called for every node the serializer renders. If the node is a block of an expand's body,
+ * wraps it so it can show its text instead of rendering while that expand is collapsed.
+ * Everything else is returned untouched.
+ *
+ * A block holding an expand of its own is returned untouched, because standing in for the whole
+ * block would take that expand with it, and the expand needs an element of its own: the element
+ * browser find reveals is the only way we learn the match was inside it rather than higher up. A
+ * table is handed to `ExpandBodyTable`, which stands in for its own rows and keeps only the rows
+ * that hold an expand. Everything else — a panel, a list, an extension with stashed ADF — renders
+ * in full, so the reader searches once instead of once per level.
+ *
+ * `ancestors` is the node's ancestor chain, nearest last.
+ */
+export const withExpandBodyBlock = (node, ancestors, index, serialized) => {
+  const parent = ancestors[ancestors.length - 1];
+  if (!parent || !isExpandNode(parent)) {
+    return serialized;
+  }
+  if (!isExperimentEnabled('platform_editor_defer_collapsed_expand_body')) {
+    return serialized;
+  }
+
+  // `serialized` is only null for a node the renderer has no component for, which a table is not.
+  // Such a table falls through to the paths below, which do not reach into it.
+  if (node.type.name === 'table' && serialized !== null) {
+    const parts = getTableStandInParts(node);
+
+    // With no row to keep, one string can stand in for the whole table — the table then renders
+    // nothing at all, and its text joins with the blocks either side of it.
+    return parts.every(part => typeof part === 'string') ? /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+      key: `expand-body-block-${index}`,
+      searchText: parts.join('')
+    }, serialized) : /*#__PURE__*/React.createElement(ExpandBodyTable, {
+      key: `expand-body-table-${index}`,
+      node: node
+    }, serialized);
+  }
+  if (holdsRevealableContent(node)) {
+    return serialized;
+  }
+  const searchText = getBlockSearchText(node);
+  if (searchText === undefined) {
+    return serialized;
+  }
+  return /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+    key: `expand-body-block-${index}`,
+    searchText: searchText
+  }, serialized);
+};
+const isRow = child => /*#__PURE__*/isValidElement(child) && child.props.nodeType === 'tableRow';
+
+/**
+ * The rows inside the serialized table, wherever they sit.
+ *
+ * What the serializer hands over is not reliably the element whose children are the rows. Marks are
+ * folded around the node afterwards, and a product's own serializer may wrap the rows themselves —
+ * Confluence's progressive renderer wraps every row but the first. Assuming either a depth or a set
+ * of direct children means any wrapper added later silently costs the saving, so the rows are found
+ * instead by the `nodeType` the serializer puts on every node.
+ *
+ * Descent stops at each row: a nested table's rows sit inside a row of this one, and would
+ * otherwise be counted among them.
+ *
+ * The count is only a consistency check. `getTableStandInParts` indexes the rows by position, so a
+ * partial match cannot be lined up and the table has to render instead.
+ */
+const rowsOf = (serialized, rowCount) => {
+  const rows = [];
+  const collect = node => {
+    React.Children.toArray(node).forEach(child => {
+      if (! /*#__PURE__*/isValidElement(child)) {
+        return;
+      }
+      if (isRow(child)) {
+        rows.push(child);
+        return;
+      }
+      collect(child.props.children);
+    });
+  };
+  collect(serialized);
+  return rows.length === rowCount ? rows : undefined;
+};
+
+/**
+ * A table in the body of a collapsed expand. Shows the text of its rows until the expand is opened,
+ * keeping the rows that hold an expand of their own — those need an element for find to reveal.
+ *
+ * Standing in for the whole table, the way an ordinary block does, would take that expand with it.
+ */
+export const ExpandBodyTable = ({
+  children,
+  node
+}) => {
+  const body = useExpandBody();
+  if (body === null || body.revealed) {
+    return children;
+  }
+  const rows = rowsOf(children, node.childCount);
+  if (!rows) {
+    // Nothing is wrong: the table renders as it always did, only without the saving. Still worth
+    // saying, because a silent fallback looks exactly like the feature being switched off.
+    // Every environment but production says it: a wrapper added by a product is only ever seen
+    // once that product has deployed, which a `NODE_ENV` check never reaches.
+    if (process.env.CLOUD_ENV !== 'production') {
+      // eslint-disable-next-line no-console
+      console.info('@atlaskit/renderer: the rows of a table in a collapsed expand were not found, so the table renders in full rather than showing their text');
+    }
+    return children;
+  }
+  return getTableStandInParts(node).map(part => typeof part === 'string' ? part :
+  /*#__PURE__*/
+  // A row cannot stand in the page on its own — `<tr>` is only valid inside a table — so it
+  // keeps the least table around it that makes the markup valid. None of this is laid out: the
+  // body is hidden until the reader or find opens the expand, and opening it renders the real
+  // table in place of all this.
+  React.createElement("table", {
+    key: `expand-body-row-${part}`
+  }, /*#__PURE__*/React.createElement("tbody", null, rows[part])));
+};
+
+/** Whatever the serializer produced for one child: an element, a string, an array of either. */
+
+const searchTextOf = child => /*#__PURE__*/isValidElement(child) && child.type === ExpandBodyBlock ? child.props.searchText : undefined;
+
+/**
+ * Joins neighbouring blocks that are showing text into one, so a run of them is a single string in
+ * the DOM rather than one per block. A body of twenty paragraphs becomes one text node instead of
+ * twenty.
+ *
+ * A block that is being rendered — a nested expand, say — ends the run, because the text either
+ * side of it has to stay either side of it.
+ */
+export const mergeExpandBodyText = children => {
+  // Called for every fragment in the document, and only an expand's body has anything to merge, so
+  // leave the array alone unless two neighbours are actually showing text.
+  const hasRun = children.some((child, index) => index > 0 && searchTextOf(child) !== undefined && searchTextOf(children[index - 1]) !== undefined);
+  if (!hasRun) {
+    return children;
+  }
+  const merged = [];
+  let run = [];
+  const endRun = () => {
+    if (run.length === 0) {
+      return;
+    }
+    if (run.length === 1) {
+      merged.push(run[0]);
+    } else {
+      var _key;
+      const text = run.map(searchTextOf).filter(Boolean).join(BLOCK_SEPARATOR);
+      // The blocks themselves, not the wrappers around them: nesting the wrappers would show
+      // each block's text again inside the joined run.
+      const blocks = run.map(child => child.props.children);
+      merged.push( /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+        key: (_key = run[0].key) !== null && _key !== void 0 ? _key : undefined,
+        searchText: text
+      }, blocks));
+    }
+    run = [];
+  };
+  children.forEach(child => {
+    if (searchTextOf(child) === undefined) {
+      endRun();
+      merged.push(child);
+      return;
+    }
+    run.push(child);
+  });
+  endRun();
+  return merged;
+};

package/dist/es2019/ui/utils/expand-search-text.js

@@ -117,4 +117,42 @@ export const getBlockSearchText = node => {
     searchTextCache.set(node, cached);
   }
   return (_cached = cached) !== null && _cached !== void 0 ? _cached : undefined;
+};
+
+/**
+ * One piece of what a collapsed table shows: either the text of the rows being stood in for, or the
+ * index of a row that has to keep rendering.
+ */
+
+const tableStandInCache = new WeakMap();
+
+/**
+ * What a table inside a collapsed expand shows in place of rendering, in table order so that find
+ * walks it the way the reader reads it.
+ *
+ * A row keeps rendering when it holds an expand of its own, which needs a real element for browser
+ * find to reveal, or when its text carries an inline comment. Its text is left out of the runs
+ * either side of it, since the row itself puts that text in the DOM.
+ */
+export const getTableStandInParts = table => {
+  const cached = tableStandInCache.get(table);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const parts = [];
+  table.forEach((row, _offset, index) => {
+    const text = holdsRevealableContent(row) ? undefined : getBlockSearchText(row);
+    if (text === undefined) {
+      parts.push(index);
+      return;
+    }
+    const last = parts[parts.length - 1];
+    if (typeof last === 'string') {
+      parts[parts.length - 1] = `${last}${BLOCK_SEPARATOR}${text}`;
+      return;
+    }
+    parts.push(text);
+  });
+  tableStandInCache.set(table, parts);
+  return parts;
 };

package/dist/esm/react/index.js

@@ -11,7 +11,7 @@ import React from 'react';
 import { MarkType } from '@atlaskit/editor-prosemirror/model';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
-import { mergeExpandBodyText, withExpandBodyBlock } from '../ui/expand-body';
+import { mergeExpandBodyText, withExpandBodyBlock } from '../ui/utils/expand-body';
 import { Doc, DocWithSelectAllTrap, isTextNode, isTextWrapper, mergeTextNodes, toReact } from './nodes';
 import TextWrapperComponent from './nodes/text-wrapper';
 import { isNestedHeaderLinksEnabled } from './utils/links';

package/dist/esm/react/nodes/tableNew.js

@@ -891,36 +891,6 @@ var addTableCellEdgePropsThroughWrappers = function addTableCellEdgePropsThrough
     return rows;
   }
 };
-var addTableCellEdgeProps = function addTableCellEdgeProps(rows, tableNode, isNumberColumnEnabled) {
-  try {
-    if (!tableNode) {
-      return rows;
-    }
-    var cellEdgePropsByCellOffset = getCellEdgePropsByCellOffset(tableNode, isNumberColumnEnabled);
-    var cellOffset = 0;
-    return React.Children.map(rows, function (row, rowIndex) {
-      var rowNode = tableNode.child(rowIndex);
-      cellOffset += 1;
-      var cellIndex = 0;
-      var rowChildren = React.Children.map(row.props.children, function (child) {
-        if (! /*#__PURE__*/React.isValidElement(child)) {
-          return child;
-        }
-        var cellNode = rowNode.child(cellIndex);
-        var edgeProps = cellEdgePropsByCellOffset.get(cellOffset);
-        cellIndex += 1;
-        cellOffset += cellNode.nodeSize;
-        return edgeProps ? /*#__PURE__*/React.cloneElement(child, edgeProps) : child;
-      });
-      cellOffset += 1;
-      return /*#__PURE__*/React.cloneElement(row, undefined, rowChildren);
-    });
-  } catch (_unused2) {
-    // Renderer can receive malformed historical ADF. If the table shape cannot
-    // be described safely, keep rendering without rounded edge metadata.
-    return rows;
-  }
-};
 
 /**
  * Processes table children before passing them to the styled table container.
@@ -1012,7 +982,7 @@ export var TableProcessorWithContainerStyles = /*#__PURE__*/function (_React$Com
         return null;
       }
       var childrenArray = React.Children.toArray(children);
-      var childrenWithTableEdgeProps = expValEquals('platform_editor_table_q4_loveability', 'isEnabled', true) ? expValEquals('platform_editor_table_q4_patch_5', 'isEnabled', true) ? addTableCellEdgePropsThroughWrappers(childrenArray, tableNode, isNumberColumnEnabled) : addTableCellEdgeProps(childrenArray, tableNode, isNumberColumnEnabled) : childrenArray;
+      var childrenWithTableEdgeProps = expValEquals('platform_editor_table_q4_loveability', 'isEnabled', true) ? addTableCellEdgePropsThroughWrappers(childrenArray, tableNode, isNumberColumnEnabled) : childrenArray;
       var orderedChildren = compose(this.addNumberColumnIndexes, this.addSortableColumn
       // @ts-expect-error TS2345: Argument of type '(ReactChild | ReactFragment | ReactPortal)[]' is not assignable to parameter of type 'ReactElement<any, string | JSXElementConstructor<any>>[]'
       )(childrenWithTableEdgeProps);

package/dist/esm/ui/Expand.js

@@ -14,7 +14,7 @@ import { akEditorLineHeight, akEditorSwoopCubicBezier, akLayoutGutterOffset } fr
 import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
 import Tooltip from '@atlaskit/tooltip/Tooltip';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
-import { ExpandBodyProvider, useExpandBody } from './expand-body';
+import { ExpandBodyProvider, useExpandBody } from './utils/expand-body';
 import _uniqueId from 'lodash/uniqueId';
 import { injectIntl } from 'react-intl';
 import { MODE, PLATFORM } from '../analytics/events';
@@ -209,6 +209,7 @@ function fireExpandToggleAnalytics(nodeType, expanded, fireAnalyticsEvent) {
   });
 }
 function Expand(_ref) {
+  var _ancestorBody$reveale;
   var title = _ref.title,
     children = _ref.children,
     nodeType = _ref.nodeType,
@@ -219,7 +220,25 @@ function Expand(_ref) {
     rendererContentMode = _ref.rendererContentMode,
     node = _ref.node;
   var ancestorBody = useExpandBody();
-  var _useState = useState(false),
+
+  // Shared with every expand in the chain: the element that stood in for this expand and caught the
+  // find sits under an expand further out, and by the time this one mounts that element is gone.
+  //
+  // Built on first render rather than passed to `useRef`, which would evaluate and discard a new set
+  // on every render for the life of the expand.
+  var ownRevealedByFind = useRef(null);
+  if (!ownRevealedByFind.current) {
+    ownRevealedByFind.current = new WeakSet();
+  }
+  var revealedByFind = (_ancestorBody$reveale = ancestorBody === null || ancestorBody === void 0 ? void 0 : ancestorBody.revealedByFind) !== null && _ancestorBody$reveale !== void 0 ? _ancestorBody$reveale : ownRevealedByFind.current;
+  /**
+   * Browser find matched inside this expand while the expand above it was still collapsed, so it
+   * opens as soon as it mounts — otherwise the reader would watch the outer expand open onto a
+   * closed one, with the match nowhere to be seen. Empty on the server and on the first client
+   * render, so hydration cannot disagree; only a find on the client ever puts anything in it.
+   */
+  var revealedByFindOnMount = node !== undefined && revealedByFind.has(node);
+  var _useState = useState(revealedByFindOnMount),
     _useState2 = _slicedToArray(_useState, 2),
     expanded = _useState2[0],
     setExpanded = _useState2[1];
@@ -232,9 +251,9 @@ function Expand(_ref) {
    * Throwing it away would re-run every macro and Forge fetch inside it on the next open, which is
    * slower and visibly reloads content the reader has already seen. We only wanted to save work on
    * the first page load, and by now that has happened. Starts false on both the server and the
-   * client, so hydration cannot disagree.
+   * first client render, so hydration cannot disagree.
    */
-  var _useState5 = useState(false),
+  var _useState5 = useState(revealedByFindOnMount),
     _useState6 = _slicedToArray(_useState5, 2),
     hasBeenExpanded = _useState6[0],
     setHasBeenExpanded = _useState6[1];
@@ -260,9 +279,15 @@ function Expand(_ref) {
   // inside other expands, those have to open too or the reader still cannot see it. Each expand
   // asks the one above it, so a single match opens the whole chain and nothing else.
   var openWithAncestors = useCallback(function () {
+    // Remembered before anything opens: a block above this expand may have been standing in for
+    // itself, and rendering it rebuilds this expand. Without this it would come back closed over
+    // the match the reader was just taken to.
+    if (node) {
+      revealedByFind.add(node);
+    }
     openBody();
     ancestorBody === null || ancestorBody === void 0 || ancestorBody.openWithAncestors();
-  }, [ancestorBody, openBody]);
+  }, [ancestorBody, node, openBody, revealedByFind]);
 
   // Feature-detect hidden="until-found" support via the beforematch event. Chrome 102+,
   // Firefox 139+ and Safari 26.2+ all have it; in a browser without it, hidden="until-found" is
@@ -344,9 +369,10 @@ function Expand(_ref) {
   var expandBody = useMemo(function () {
     return {
       revealed: revealed,
-      openWithAncestors: openWithAncestors
+      openWithAncestors: openWithAncestors,
+      revealedByFind: revealedByFind
     };
-  }, [revealed, openWithAncestors]);
+  }, [revealed, openWithAncestors, revealedByFind]);
   return jsx(Container, {
     "data-testid": "expand-container-".concat(nodeType, "-").concat(id),
     "data-node-type": nodeType,

package/dist/esm/ui/Renderer/index.js

@@ -65,7 +65,7 @@ export var DEGRADED_SEVERITY_THRESHOLD = 3000;
 var TABLE_INFO_TIMEOUT = 10000;
 var RENDER_EVENT_SAMPLE_RATE = 0.1;
 var packageName = "@atlaskit/renderer";
-var packageVersion = "137.1.6";
+var packageVersion = "137.1.8";
 var setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

package/dist/esm/ui/utils/expand-body.js

@@ -0,0 +1,210 @@
+import React, { createContext, isValidElement, useContext } from 'react';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
+import { BLOCK_SEPARATOR, getBlockSearchText, getTableStandInParts, holdsRevealableContent, isExpandNode } from './expand-search-text';
+var ExpandBodyContext = /*#__PURE__*/createContext(null);
+export var ExpandBodyProvider = ExpandBodyContext.Provider;
+export var useExpandBody = function useExpandBody() {
+  return useContext(ExpandBodyContext);
+};
+/**
+ * One or more neighbouring blocks of an expand's body. Shows their text until the expand is
+ * opened, then renders them. Falls back to rendering if there is no text, or if there is no
+ * expand above it.
+ *
+ * The text is rendered as-is, with no element around it. Nothing reads it but browser find,
+ * which only needs the characters to be in the DOM.
+ */
+export var ExpandBodyBlock = function ExpandBodyBlock(_ref) {
+  var children = _ref.children,
+    searchText = _ref.searchText;
+  var body = useExpandBody();
+  if (searchText === undefined || body === null || body.revealed) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  }
+  return searchText;
+};
+
+/**
+ * Called for every node the serializer renders. If the node is a block of an expand's body,
+ * wraps it so it can show its text instead of rendering while that expand is collapsed.
+ * Everything else is returned untouched.
+ *
+ * A block holding an expand of its own is returned untouched, because standing in for the whole
+ * block would take that expand with it, and the expand needs an element of its own: the element
+ * browser find reveals is the only way we learn the match was inside it rather than higher up. A
+ * table is handed to `ExpandBodyTable`, which stands in for its own rows and keeps only the rows
+ * that hold an expand. Everything else — a panel, a list, an extension with stashed ADF — renders
+ * in full, so the reader searches once instead of once per level.
+ *
+ * `ancestors` is the node's ancestor chain, nearest last.
+ */
+export var withExpandBodyBlock = function withExpandBodyBlock(node, ancestors, index, serialized) {
+  var parent = ancestors[ancestors.length - 1];
+  if (!parent || !isExpandNode(parent)) {
+    return serialized;
+  }
+  if (!isExperimentEnabled('platform_editor_defer_collapsed_expand_body')) {
+    return serialized;
+  }
+
+  // `serialized` is only null for a node the renderer has no component for, which a table is not.
+  // Such a table falls through to the paths below, which do not reach into it.
+  if (node.type.name === 'table' && serialized !== null) {
+    var parts = getTableStandInParts(node);
+
+    // With no row to keep, one string can stand in for the whole table — the table then renders
+    // nothing at all, and its text joins with the blocks either side of it.
+    return parts.every(function (part) {
+      return typeof part === 'string';
+    }) ? /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+      key: "expand-body-block-".concat(index),
+      searchText: parts.join('')
+    }, serialized) : /*#__PURE__*/React.createElement(ExpandBodyTable, {
+      key: "expand-body-table-".concat(index),
+      node: node
+    }, serialized);
+  }
+  if (holdsRevealableContent(node)) {
+    return serialized;
+  }
+  var searchText = getBlockSearchText(node);
+  if (searchText === undefined) {
+    return serialized;
+  }
+  return /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+    key: "expand-body-block-".concat(index),
+    searchText: searchText
+  }, serialized);
+};
+var isRow = function isRow(child) {
+  return /*#__PURE__*/isValidElement(child) && child.props.nodeType === 'tableRow';
+};
+
+/**
+ * The rows inside the serialized table, wherever they sit.
+ *
+ * What the serializer hands over is not reliably the element whose children are the rows. Marks are
+ * folded around the node afterwards, and a product's own serializer may wrap the rows themselves —
+ * Confluence's progressive renderer wraps every row but the first. Assuming either a depth or a set
+ * of direct children means any wrapper added later silently costs the saving, so the rows are found
+ * instead by the `nodeType` the serializer puts on every node.
+ *
+ * Descent stops at each row: a nested table's rows sit inside a row of this one, and would
+ * otherwise be counted among them.
+ *
+ * The count is only a consistency check. `getTableStandInParts` indexes the rows by position, so a
+ * partial match cannot be lined up and the table has to render instead.
+ */
+var rowsOf = function rowsOf(serialized, rowCount) {
+  var rows = [];
+  var _collect = function collect(node) {
+    React.Children.toArray(node).forEach(function (child) {
+      if (! /*#__PURE__*/isValidElement(child)) {
+        return;
+      }
+      if (isRow(child)) {
+        rows.push(child);
+        return;
+      }
+      _collect(child.props.children);
+    });
+  };
+  _collect(serialized);
+  return rows.length === rowCount ? rows : undefined;
+};
+
+/**
+ * A table in the body of a collapsed expand. Shows the text of its rows until the expand is opened,
+ * keeping the rows that hold an expand of their own — those need an element for find to reveal.
+ *
+ * Standing in for the whole table, the way an ordinary block does, would take that expand with it.
+ */
+export var ExpandBodyTable = function ExpandBodyTable(_ref2) {
+  var children = _ref2.children,
+    node = _ref2.node;
+  var body = useExpandBody();
+  if (body === null || body.revealed) {
+    return children;
+  }
+  var rows = rowsOf(children, node.childCount);
+  if (!rows) {
+    // Nothing is wrong: the table renders as it always did, only without the saving. Still worth
+    // saying, because a silent fallback looks exactly like the feature being switched off.
+    // Every environment but production says it: a wrapper added by a product is only ever seen
+    // once that product has deployed, which a `NODE_ENV` check never reaches.
+    if (process.env.CLOUD_ENV !== 'production') {
+      // eslint-disable-next-line no-console
+      console.info('@atlaskit/renderer: the rows of a table in a collapsed expand were not found, so the table renders in full rather than showing their text');
+    }
+    return children;
+  }
+  return getTableStandInParts(node).map(function (part) {
+    return typeof part === 'string' ? part :
+    /*#__PURE__*/
+    // A row cannot stand in the page on its own — `<tr>` is only valid inside a table — so it
+    // keeps the least table around it that makes the markup valid. None of this is laid out: the
+    // body is hidden until the reader or find opens the expand, and opening it renders the real
+    // table in place of all this.
+    React.createElement("table", {
+      key: "expand-body-row-".concat(part)
+    }, /*#__PURE__*/React.createElement("tbody", null, rows[part]));
+  });
+};
+
+/** Whatever the serializer produced for one child: an element, a string, an array of either. */
+
+var searchTextOf = function searchTextOf(child) {
+  return /*#__PURE__*/isValidElement(child) && child.type === ExpandBodyBlock ? child.props.searchText : undefined;
+};
+
+/**
+ * Joins neighbouring blocks that are showing text into one, so a run of them is a single string in
+ * the DOM rather than one per block. A body of twenty paragraphs becomes one text node instead of
+ * twenty.
+ *
+ * A block that is being rendered — a nested expand, say — ends the run, because the text either
+ * side of it has to stay either side of it.
+ */
+export var mergeExpandBodyText = function mergeExpandBodyText(children) {
+  // Called for every fragment in the document, and only an expand's body has anything to merge, so
+  // leave the array alone unless two neighbours are actually showing text.
+  var hasRun = children.some(function (child, index) {
+    return index > 0 && searchTextOf(child) !== undefined && searchTextOf(children[index - 1]) !== undefined;
+  });
+  if (!hasRun) {
+    return children;
+  }
+  var merged = [];
+  var run = [];
+  var endRun = function endRun() {
+    if (run.length === 0) {
+      return;
+    }
+    if (run.length === 1) {
+      merged.push(run[0]);
+    } else {
+      var _key;
+      var text = run.map(searchTextOf).filter(Boolean).join(BLOCK_SEPARATOR);
+      // The blocks themselves, not the wrappers around them: nesting the wrappers would show
+      // each block's text again inside the joined run.
+      var blocks = run.map(function (child) {
+        return child.props.children;
+      });
+      merged.push( /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+        key: (_key = run[0].key) !== null && _key !== void 0 ? _key : undefined,
+        searchText: text
+      }, blocks));
+    }
+    run = [];
+  };
+  children.forEach(function (child) {
+    if (searchTextOf(child) === undefined) {
+      endRun();
+      merged.push(child);
+      return;
+    }
+    run.push(child);
+  });
+  endRun();
+  return merged;
+};

package/dist/esm/ui/utils/expand-search-text.js

@@ -130,4 +130,42 @@ export var getBlockSearchText = function getBlockSearchText(node) {
     searchTextCache.set(node, cached);
   }
   return cached !== null && cached !== void 0 ? cached : undefined;
+};
+
+/**
+ * One piece of what a collapsed table shows: either the text of the rows being stood in for, or the
+ * index of a row that has to keep rendering.
+ */
+
+var tableStandInCache = new WeakMap();
+
+/**
+ * What a table inside a collapsed expand shows in place of rendering, in table order so that find
+ * walks it the way the reader reads it.
+ *
+ * A row keeps rendering when it holds an expand of its own, which needs a real element for browser
+ * find to reveal, or when its text carries an inline comment. Its text is left out of the runs
+ * either side of it, since the row itself puts that text in the DOM.
+ */
+export var getTableStandInParts = function getTableStandInParts(table) {
+  var cached = tableStandInCache.get(table);
+  if (cached !== undefined) {
+    return cached;
+  }
+  var parts = [];
+  table.forEach(function (row, _offset, index) {
+    var text = holdsRevealableContent(row) ? undefined : getBlockSearchText(row);
+    if (text === undefined) {
+      parts.push(index);
+      return;
+    }
+    var last = parts[parts.length - 1];
+    if (typeof last === 'string') {
+      parts[parts.length - 1] = "".concat(last).concat(BLOCK_SEPARATOR).concat(text);
+      return;
+    }
+    parts.push(text);
+  });
+  tableStandInCache.set(table, parts);
+  return parts;
 };