@atlaskit/renderer 137.1.6 → 137.1.7

package/dist/esm/ui/Expand.js

@@ -14,8 +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 { fg } from '@atlaskit/platform-feature-flags/fg';
-import { getExpandSearchText } from './utils/expand-search-text';
+import { ExpandBodyProvider, useExpandBody } from './expand-body';
 import _uniqueId from 'lodash/uniqueId';
 import { injectIntl } from 'react-intl';
 import { MODE, PLATFORM } from '../analytics/events';
@@ -140,12 +139,18 @@ var contentContainerStylesNotExpanded = css({
 // hidden="until-found" attribute on the outer container to hide content.
 // We remove height:0/overflow:hidden/clip from the inner wrapper so the
 // browser can actually search through the content.
+//
+// `user-select: none` must NOT be set here, unlike the variant above. WebKit scrolls to a
+// find-in-page match by selecting it, so unselectable text is matched but never revealed: the
+// reader is told there is a hit, the `hidden` attribute stays put, and the expand never opens.
+// Chrome does not need a selection, so it hid the problem. Nothing is lost by leaving it out —
+// content-visibility:hidden already makes a skipped subtree unselectable. It is only needed in the
+// other variant, where the content is merely clipped and would otherwise be selectable.
 var contentContainerStylesNotExpandedBrowserFind = css({
   // eslint-disable-next-line @atlaskit/ui-styling-standard/no-nested-selectors
   '.expand-content-wrapper, .nestedExpand-content-wrapper': {
     width: '100%',
-    display: 'block',
-    userSelect: 'none'
+    display: 'block'
   }
 });
 var clearNextSiblingMarginTopStyle = css({
@@ -213,6 +218,7 @@ function Expand(_ref) {
     nestedHeaderIds = _ref.nestedHeaderIds,
     rendererContentMode = _ref.rendererContentMode,
     node = _ref.node;
+  var ancestorBody = useExpandBody();
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
     expanded = _useState2[0],
@@ -222,12 +228,11 @@ function Expand(_ref) {
     focused = _useState4[0],
     setFocused = _useState4[1];
   /**
-   * PGXT-9021: latches on the first open so the body stays mounted once rendered, including after
-   * the expand is collapsed again. Remounting it would re-run every macro and Forge data fetch
-   * inside on each reopen, which is both slower and visibly reloads content the reader has already
-   * seen. The saving this gate exists for is at initial load, where the body has never been opened,
-   * so nothing is given up by keeping it after that. Never set on the server, so the server and the
-   * client's first render agree and hydration cannot desync.
+   * PGXT-9021: once opened, the body stays rendered even if the reader closes the expand again.
+   * 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.
    */
   var _useState5 = useState(false),
     _useState6 = _slicedToArray(_useState5, 2),
@@ -251,15 +256,21 @@ function Expand(_ref) {
     setExpanded(true);
     setHasBeenExpanded(true);
   }, []);
+  // The browser found the text inside this expand. Opening this one is not enough: if it sits
+  // 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 () {
+    openBody();
+    ancestorBody === null || ancestorBody === void 0 || ancestorBody.openWithAncestors();
+  }, [ancestorBody, openBody]);
 
-  // Feature-detect hidden="until-found" support via the beforematch event.
-  // Chrome 102+ and Firefox 130+ support it; Safari does not yet.
-  // In unsupported browsers, setting hidden="until-found" is treated as boolean hidden
-  // (display:none), which would break the expand entirely.
-  // Initialised as false and set in useEffect to avoid SSR/client hydration mismatch —
-  // useMemo would return true on the client's first render in supported browsers,
-  // differing from the server snapshot which always produces false.
-  var _useState7 = useState(false),
+  // 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
+  // treated as plain boolean hidden (display:none), which would break the expand entirely.
+  // Starts as `undefined`, meaning "we do not know yet", and is only answered in an effect. We
+  // cannot check during render: the server has no browser to check, so it would say no there and
+  // yes on the client, and hydration would disagree.
+  var _useState7 = useState(undefined),
     _useState8 = _slicedToArray(_useState7, 2),
     supportsHiddenUntilFound = _useState8[0],
     setSupportsHiddenUntilFound = _useState8[1];
@@ -276,9 +287,9 @@ function Expand(_ref) {
   // because visibility:hidden blocks browser find. On expanded, we restore visibility to visible.
   //
   // Only applied when the browser supports hidden="until-found" (detected via onbeforematch).
-  // In unsupported browsers (Safari), we skip this entirely and fall back to the normal
-  // CSS hiding (visibility:hidden + height:0), which doesn't support find-in-page but
-  // still works correctly for expand/collapse.
+  // Without it we skip this entirely and fall back to the normal CSS hiding
+  // (visibility:hidden + height:0), which doesn't support find-in-page but still works
+  // correctly for expand/collapse.
   useEffect(function () {
     var contentContainer = contentContainerRef.current;
     var contentWrapper = contentWrapperRef.current;
@@ -287,6 +298,13 @@ function Expand(_ref) {
     }
     if (supportsHiddenUntilFound && isExperimentEnabled('platform_editor_close_expand_find') && !expanded) {
       contentWrapper.setAttribute('hidden', 'until-found');
+      // Products ship a CSS reset with `[hidden] { display: none }` — Confluence does. That is an
+      // author rule, so it beats the UA stylesheet's
+      // `[hidden="until-found"] { content-visibility: hidden }` and takes the content out of the
+      // page altogether, where find cannot reach it. Setting display next to the attribute keeps
+      // the two together, rather than relying on a class selector elsewhere out-weighing a reset
+      // we do not own.
+      contentWrapper.style.display = 'block';
       // Override the CSS visibility:hidden from contentContainerStyles — hidden="until-found"
       // now handles hiding via content-visibility:hidden, which allows browser find to index
       // the content. We use 'visible' (not '') because '' only clears the inline style but
@@ -295,6 +313,7 @@ function Expand(_ref) {
       contentWrapper.style.visibility = 'visible';
     } else {
       contentWrapper.removeAttribute('hidden');
+      contentWrapper.style.display = '';
       contentContainer === null || contentContainer === void 0 || contentContainer.style.removeProperty('visibility');
       contentWrapper.style.visibility = '';
     }
@@ -306,22 +325,28 @@ function Expand(_ref) {
     var contentWrapper = contentWrapperRef.current;
     var unbindWrapperBeforeMatch = contentWrapper && supportsHiddenUntilFound ? bind(contentWrapper, {
       type: 'beforematch',
-      listener: openBody
+      listener: openWithAncestors
     }) : undefined;
     return function () {
       unbindWrapperBeforeMatch === null || unbindWrapperBeforeMatch === void 0 || unbindWrapperBeforeMatch();
     };
-  }, [expanded, openBody, supportsHiddenUntilFound]);
+  }, [expanded, openWithAncestors, supportsHiddenUntilFound]);
 
-  // Until the expand is first opened, stand in a plain-text mirror of the body so
-  // hidden="until-found" keeps the content findable by browser find without mounting the real
-  // subtree. The beforematch listener above expands before the browser scrolls to its match.
-  // Computed lazily: a nested expand is not mounted until its ancestor opens, so its mirror is
-  // never built on initial load.
-  var searchText = useMemo(function () {
-    return node && fg('hot-121622_lazy_load_expand_content') ? getExpandSearchText(node) : undefined;
-  }, [node]);
-  var expandContent = searchText && !expanded && !hasBeenExpanded ? jsx("span", null, searchText) : children;
+  // While this is false, the blocks of the body show their text instead of rendering. It is true
+  // when:
+  // - the expand is open, or has been opened before, so the reader wants to see the content;
+  // - no node was given, so this expand never opted into lazy loading;
+  // - the experiment is off;
+  // - the browser has no hidden="until-found", so the text would not be findable and standing it in
+  //   would gain nothing. While we still do not know, we assume the browser has it — assuming the
+  //   opposite would render the whole body on the first paint and lose the saving entirely.
+  var revealed = expanded || hasBeenExpanded || !node || supportsHiddenUntilFound === false || !isExperimentEnabled('platform_editor_defer_collapsed_expand_body');
+  var expandBody = useMemo(function () {
+    return {
+      revealed: revealed,
+      openWithAncestors: openWithAncestors
+    };
+  }, [revealed, openWithAncestors]);
   return jsx(Container, {
     "data-testid": "expand-container-".concat(nodeType, "-").concat(id),
     "data-node-type": nodeType,
@@ -386,7 +411,9 @@ function Expand(_ref) {
     ref: contentWrapperRef
   }, jsx(WidthProvider, null, jsx("div", {
     css: clearNextSiblingMarginTopStyle
-  }), expandContent))));
+  }), jsx(ExpandBodyProvider, {
+    value: expandBody
+  }, children)))));
 }
 
 // eslint-disable-next-line @typescript-eslint/ban-types

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.5";
+var packageVersion = "137.1.6";
 var setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

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

@@ -0,0 +1,114 @@
+import React, { createContext, isValidElement, useContext } from 'react';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
+import { BLOCK_SEPARATOR, getBlockSearchText, holdsRevealableContent, isExpandNode } from './utils/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 also returned untouched, so a table with a nested
+ * expand in it, or an extension holding stashed ADF, renders even while collapsed. That
+ * expand needs an element of its own, because the element browser find reveals is the only
+ * way we learn the match was inside it rather than higher up. We give up the saving on those
+ * blocks 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') || 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);
+};
+
+/** 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

@@ -6,22 +6,29 @@ import { findChildrenByMark } from '@atlaskit/editor-prosemirror/utils';
  */
 
 /** Separates text from adjacent blocks so phrases cannot fuse across block boundaries. */
-var BLOCK_SEPARATOR = ' ';
+export var BLOCK_SEPARATOR = ' ';
 var asText = function asText(value) {
   return typeof value === 'string' ? value : '';
 };
+var nestedContentOf = function nestedContentOf(attrs) {
+  var _attrs$parameters;
+  return attrs === null || attrs === void 0 || (_attrs$parameters = attrs.parameters) === null || _attrs$parameters === void 0 ? void 0 : _attrs$parameters.nestedContent;
+};
+export var isExpandNode = function isExpandNode(node) {
+  return node.type.name === 'expand' || node.type.name === 'nestedExpand';
+};
 
 /**
- * Extracts text from raw ADF JSON.
+ * Reads the text out of raw ADF JSON.
  *
- * Needed because some extensions stash a whole ADF subtree in `attrs.parameters.nestedContent`
- * instead of in their node content — Confluence does this when it coerces nesting the schema
- * cannot represent (an expand more than two collapsible layers deep, say). Such a node is a
- * ProseMirror leaf, so the model walk cannot see the subtree even though it renders on the page
- * via a nested renderer. Recurses, because nestedContent routinely holds further nested content.
+ * Some extensions keep a whole ADF subtree in `attrs.parameters.nestedContent` rather than in their
+ * node content. Confluence does this when the authored nesting is deeper than the schema allows —
+ * an expand more than two collapsible layers deep, for example. To ProseMirror the extension is a
+ * leaf, so walking the node tree never sees that subtree, even though a nested renderer puts it on
+ * the page. Recurses, because stashed content often stashes more content of its own.
  */
 var _adfEntityText = function adfEntityText(entity) {
-  var _entity$attrs, _entity$content;
+  var _entity$content;
   if (!entity) {
     return '';
   }
@@ -29,13 +36,13 @@ var _adfEntityText = function adfEntityText(entity) {
   if (entity.type === 'text') {
     parts.push(asText(entity.text));
   }
-  var nestedContent = (_entity$attrs = entity.attrs) === null || _entity$attrs === void 0 || (_entity$attrs = _entity$attrs.parameters) === null || _entity$attrs === void 0 ? void 0 : _entity$attrs.nestedContent;
+  var nestedContent = nestedContentOf(entity.attrs);
   if (nestedContent) {
     // Prefer the real subtree over `attrs.text`, which is only a placeholder label for it.
     parts.push(_adfEntityText(nestedContent));
   } else {
-    var _entity$attrs2;
-    parts.push(asText((_entity$attrs2 = entity.attrs) === null || _entity$attrs2 === void 0 ? void 0 : _entity$attrs2.text));
+    var _entity$attrs;
+    parts.push(asText((_entity$attrs = entity.attrs) === null || _entity$attrs === void 0 ? void 0 : _entity$attrs.text));
   }
   (_entity$content = entity.content) === null || _entity$content === void 0 || _entity$content.forEach(function (child) {
     return parts.push(_adfEntityText(child));
@@ -44,16 +51,48 @@ var _adfEntityText = function adfEntityText(entity) {
 };
 
 /**
- * `textBetween` drops every non-text leaf unless the node spec declares `leafText`, and no ADF
- * node does. Leaves carry their visible text in attrs, so recover it here.
+ * `textBetween` skips every leaf node unless its spec declares `leafText`, and no ADF node
+ * does — so mentions, emoji, dates and statuses would all be lost. They keep their visible
+ * text in attrs, so read it from there.
  */
 var leafText = function leafText(leaf) {
-  var _leaf$attrs, _leaf$attrs2;
-  var nestedContent = (_leaf$attrs = leaf.attrs) === null || _leaf$attrs === void 0 || (_leaf$attrs = _leaf$attrs.parameters) === null || _leaf$attrs === void 0 ? void 0 : _leaf$attrs.nestedContent;
+  var _leaf$attrs;
+  var nestedContent = nestedContentOf(leaf.attrs);
   if (nestedContent) {
     return _adfEntityText(nestedContent);
   }
-  return asText((_leaf$attrs2 = leaf.attrs) === null || _leaf$attrs2 === void 0 ? void 0 : _leaf$attrs2.text);
+  return asText((_leaf$attrs = leaf.attrs) === null || _leaf$attrs === void 0 ? void 0 : _leaf$attrs.text);
+};
+var isRevealable = function isRevealable(node) {
+  return isExpandNode(node) || Boolean(nestedContentOf(node.attrs));
+};
+var revealableCache = new WeakMap();
+
+/**
+ * Whether this block holds something that can be opened on its own: an expand, or an extension
+ * holding stashed ADF that a nested renderer will mount expands from.
+ *
+ * Those need a real element even while the expand around them is collapsed. The element is how we
+ * know find matched inside them rather than higher up: the beforematch event says nothing about
+ * where the match was, so the element the browser chose to reveal is the only clue.
+ */
+export var holdsRevealableContent = function holdsRevealableContent(node) {
+  var cached = revealableCache.get(node);
+  if (cached !== undefined) {
+    return cached;
+  }
+  var found = isRevealable(node);
+  if (!found) {
+    node.descendants(function (descendant) {
+      if (found) {
+        return false;
+      }
+      found = isRevealable(descendant);
+      return !found;
+    });
+  }
+  revealableCache.set(node, found);
+  return found;
 };
 var hasInlineComment = function hasInlineComment(node) {
   return findChildrenByMark(node, node.type.schema.marks.annotation, true).some(function (annotation) {
@@ -63,30 +102,31 @@ var hasInlineComment = function hasInlineComment(node) {
   });
 };
 
-/** `null` is a cached "no mirror for this node", as distinct from `undefined` for a cache miss. */
+/** `null` is a cached "no search text for this node", as distinct from `undefined` for a miss. */
 var searchTextCache = new WeakMap();
 
 /**
- * Plain-text mirror of an expand's body, rendered in its place while collapsed so browser
- * find-in-page can still reach the content.
+ * The text shown in place of one block of a collapsed expand's body, so browser find can still
+ * reach the content without the block being rendered.
  *
- * Cached on the node. ProseMirror nodes are immutable and `render-document` memoises
- * `nodeFromJSON`, so the same node instance is reused across renders — including across the
- * serializer rebuilds that invalidate the module-level `memoizeOne` caches.
+ * Cached on the node. ProseMirror nodes never change, and the serializer reuses the same instances
+ * across renders, so the text only has to be worked out once per block.
  *
- * @returns the mirror text, or `undefined` if this expand must keep its body rendered.
+ * @returns the text, or `undefined` if this block has to be rendered instead.
  */
-export var getExpandSearchText = function getExpandSearchText(node) {
+export var getBlockSearchText = function getBlockSearchText(node) {
   var cached = searchTextCache.get(node);
   if (cached === undefined) {
     cached = hasInlineComment(node) ?
-    // Withhold the mirror, which makes Expand keep rendering `children`. Comment
-    // navigation walks the DOM to find the annotated node and scrolls it into view, so
-    // the annotation has to exist as a real element — a flat text mirror carries no
-    // annotation marks and cannot stand in for it. Without this, stepping through
-    // comments with the arrow keys silently fails to reach any comment inside a
-    // collapsed expand. Costs the lazy-load win for these expands, deliberately.
-    null : node.textBetween(0, node.content.size, BLOCK_SEPARATOR, leafText);
+    // No text, which makes the block render instead. Comment navigation looks through the DOM
+    // for the commented text and scrolls to it, so that text has to be a real element —
+    // plain text carries no comment marks and cannot stand in for it. Without this, the
+    // arrow keys silently skip every comment inside a collapsed expand. We give up the
+    // saving for this block on purpose.
+    null :
+    // A leaf block is not inside its own range, so `textBetween` would return nothing and its
+    // text would be lost — a macro sitting straight in an expand body, for instance.
+    node.isLeaf ? leafText(node) : node.textBetween(0, node.content.size, BLOCK_SEPARATOR, leafText);
     searchTextCache.set(node, cached);
   }
   return cached !== null && cached !== void 0 ? cached : undefined;

package/dist/types/ui/Expand.d.ts

@@ -9,10 +9,11 @@ export interface ExpandProps {
     localId?: string;
     nestedHeaderIds?: Array<string>;
     /**
-     * This expand's ProseMirror node. Supplying it opts the expand into lazy body loading: until the
-     * expand is first opened, a plain-text mirror of the body is rendered in place of `children`.
-     * Once opened, `children` stay mounted for the rest of the page's life, including after the
-     * expand is collapsed again (PGXT-9021). Omit it to keep `children` in the DOM at all times.
+     * This expand's ProseMirror node. Passing it turns on lazy body loading: until the expand is
+     * first opened, the blocks the serializer wrapped show their text rather than rendering. After
+     * that they stay rendered, even if the reader closes the expand again (PGXT-9021). Leave it out
+     * to always render the body. Browsers without `hidden="until-found"` render it in full shortly
+     * after the page loads, since the text would not be findable there anyway.
      */
     node?: PMNode;
     nodeType: 'expand' | 'nestedExpand';

package/dist/types/ui/expand-body.d.ts

@@ -0,0 +1,64 @@
+import type { Provider, ReactNode } from 'react';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+type ExpandBody = {
+    /**
+     * Opens this expand, then asks the expand above it to do the same.
+     *
+     * Browser find reveals the element holding the text it matched, and that element belongs to the
+     * expand the text is really in — even a deeply nested one, because an expand only ever replaces
+     * its own blocks with text, never a nested expand. So the expands to open are just that expand's
+     * ancestors.
+     */
+    openWithAncestors: () => void;
+    /**
+     * True once this expand has been opened. While it is false, the blocks of the body show
+     * their text instead of rendering.
+     *
+     * Each block reads this and decides for itself. The expand does not swap its body out,
+     * because that would throw away and rebuild everything inside it — including a nested
+     * expand find had just opened, and any nested renderer that had already loaded.
+     */
+    revealed: boolean;
+};
+export declare const ExpandBodyProvider: Provider<ExpandBody | null>;
+export declare const useExpandBody: () => ExpandBody | null;
+type ExpandBodyBlockProps = {
+    children: ReactNode;
+    /** The block's text, or `undefined` if it must always be rendered. */
+    searchText?: string;
+};
+/**
+ * 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 declare const ExpandBodyBlock: ({ children, searchText }: ExpandBodyBlockProps) => ReactNode;
+/**
+ * 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 also returned untouched, so a table with a nested
+ * expand in it, or an extension holding stashed ADF, renders even while collapsed. That
+ * expand needs an element of its own, because the element browser find reveals is the only
+ * way we learn the match was inside it rather than higher up. We give up the saving on those
+ * blocks so the reader searches once instead of once per level.
+ *
+ * `ancestors` is the node's ancestor chain, nearest last.
+ */
+export declare const withExpandBodyBlock: (node: PMNode, ancestors: readonly PMNode[], index: number, serialized: JSX.Element | null) => JSX.Element | null;
+/** Whatever the serializer produced for one child: an element, a string, an array of either. */
+type SerializedChild = ReactNode;
+/**
+ * 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 declare const mergeExpandBodyText: (children: SerializedChild[]) => SerializedChild[];
+export {};

package/dist/types/ui/utils/expand-search-text.d.ts

@@ -1,12 +1,23 @@
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/** Separates text from adjacent blocks so phrases cannot fuse across block boundaries. */
+export declare const BLOCK_SEPARATOR = " ";
+export declare const isExpandNode: (node: PMNode) => boolean;
 /**
- * Plain-text mirror of an expand's body, rendered in its place while collapsed so browser
- * find-in-page can still reach the content.
+ * Whether this block holds something that can be opened on its own: an expand, or an extension
+ * holding stashed ADF that a nested renderer will mount expands from.
  *
- * Cached on the node. ProseMirror nodes are immutable and `render-document` memoises
- * `nodeFromJSON`, so the same node instance is reused across renders — including across the
- * serializer rebuilds that invalidate the module-level `memoizeOne` caches.
+ * Those need a real element even while the expand around them is collapsed. The element is how we
+ * know find matched inside them rather than higher up: the beforematch event says nothing about
+ * where the match was, so the element the browser chose to reveal is the only clue.
+ */
+export declare const holdsRevealableContent: (node: PMNode) => boolean;
+/**
+ * The text shown in place of one block of a collapsed expand's body, so browser find can still
+ * reach the content without the block being rendered.
+ *
+ * Cached on the node. ProseMirror nodes never change, and the serializer reuses the same instances
+ * across renders, so the text only has to be worked out once per block.
  *
- * @returns the mirror text, or `undefined` if this expand must keep its body rendered.
+ * @returns the text, or `undefined` if this block has to be rendered instead.
  */
-export declare const getExpandSearchText: (node: PMNode) => string | undefined;
+export declare const getBlockSearchText: (node: PMNode) => string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/renderer",
-	"version": "137.1.6",
+	"version": "137.1.7",
 	"description": "Renderer component",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -58,8 +58,8 @@
 		"@atlaskit/media-client-react": "^6.2.0",
 		"@atlaskit/media-common": "^14.5.0",
 		"@atlaskit/media-filmstrip": "^52.3.0",
-		"@atlaskit/media-ui": "^30.13.0",
-		"@atlaskit/media-viewer": "^54.6.0",
+		"@atlaskit/media-ui": "^30.14.0",
+		"@atlaskit/media-viewer": "^54.7.0",
 		"@atlaskit/platform-feature-experiments": "^0.3.0",
 		"@atlaskit/platform-feature-flags": "^2.1.0",
 		"@atlaskit/platform-feature-flags-react": "^1.1.0",
@@ -70,7 +70,7 @@
 		"@atlaskit/status": "^5.8.0",
 		"@atlaskit/task-decision": "^21.8.0",
 		"@atlaskit/theme": "^28.1.0",
-		"@atlaskit/tmp-editor-statsig": "^163.0.0",
+		"@atlaskit/tmp-editor-statsig": "^164.0.0",
 		"@atlaskit/tokens": "^16.8.0",
 		"@atlaskit/tooltip": "^24.2.0",
 		"@atlaskit/visually-hidden": "^4.3.0",
@@ -229,9 +229,6 @@
 		"jfp-magma-ssr-iv-editor-links": {
 			"type": "boolean"
 		},
-		"hot-121622_lazy_load_expand_content": {
-			"type": "boolean"
-		},
 		"media-perf-uplift-mutation-fix": {
 			"type": "boolean"
 		},