@atlaskit/renderer 137.1.8 → 137.1.10

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/breakout-ssr.js

@@ -27,7 +27,7 @@ export function BreakoutSSRInlineScript(_ref) {
   }
   var id = Math.floor(Math.random() * (9999999999 - 9999 + 1)) + 9999;
   var shouldSkipScript = {
-    table: fg('platform-ssr-table-resize')
+    table: true
   };
   return /*#__PURE__*/React.createElement("script", {
     "data-breakout-script-id": id
@@ -86,7 +86,6 @@ function applyBreakoutAfterSSR(id, breakoutConsts, shouldSkipBreakoutScript, fla
         return;
       }
 
-      // Remove with feature gate 'platform-ssr-table-resize'
       // Ignored via go/ees005
       // eslint-disable-next-line @atlaskit/editor/no-as-casting
       if (item.target.classList.contains('ak-renderer-document')) {

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.7";
+var packageVersion = "137.1.9";
 var setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'
@@ -775,7 +775,7 @@ var RendererWrapper = /*#__PURE__*/React.memo(function (props) {
   //
 
   // allowRendererContainerStyles is not needed for comment container styling as container should always be set for comments
-  if (appearance === 'comment' && isTopLevelRenderer && fg('platform-ssr-table-resize')) {
+  if (appearance === 'comment' && isTopLevelRenderer) {
     return jsx("div", {
       css: setAsQueryContainerStyles
     }, renderer);
@@ -788,7 +788,7 @@ var RendererWrapper = /*#__PURE__*/React.memo(function (props) {
   return (appearance === 'full-page' || appearance === 'full-width' || (expValEqualsNoExposure('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true)) && appearance === 'max') &&
   // In case of having excerpt-include on page there are multiple renderers nested.
   // Make sure only the root renderer is set to be query container.
-  isTopLevelRenderer && allowRendererContainerStyles && fg('platform-ssr-table-resize') ? jsx("div", {
+  isTopLevelRenderer && allowRendererContainerStyles ? jsx("div", {
     css: setAsQueryContainerStyles
   }, renderer) : renderer;
 });

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;
 };

package/dist/types/react/nodes/table/sticky.d.ts

@@ -15,7 +15,6 @@ type StickyTableProps = {
     allowTableResizing?: boolean;
     children: React.ReactNode[];
     columnWidths?: number[];
-    fixTableSSRResizing?: boolean;
     innerRef: React.RefObject<HTMLDivElement>;
     isNumberColumnEnabled: boolean;
     layout: TableLayout;
@@ -29,7 +28,7 @@ type StickyTableProps = {
     top?: number;
     wrapperWidth: number;
 } & OverflowShadowProps;
-export declare const StickyTable: ({ top, left, mode, shadowClassNames, innerRef, wrapperWidth, tableWidth, isNumberColumnEnabled, layout, children, columnWidths, renderWidth, rowHeight, tableNode, rendererAppearance, allowTableResizing, fixTableSSRResizing, allowFixedColumnWidthOption, }: StickyTableProps) => jsx.JSX.Element;
+export declare const StickyTable: ({ top, left, mode, shadowClassNames, innerRef, wrapperWidth, tableWidth, isNumberColumnEnabled, layout, children, columnWidths, renderWidth, rowHeight, tableNode, rendererAppearance, allowTableResizing, allowFixedColumnWidthOption, }: StickyTableProps) => jsx.JSX.Element;
 /**
  *
  */

package/dist/types/react/nodes/table.d.ts

@@ -26,7 +26,6 @@ export type TableProps = SharedTableProps & {
     allowTableAlignment?: boolean;
     allowTableResizing?: boolean;
     children: React.ReactElement<any> | Array<React.ReactElement<any>>;
-    disableTableOverflowShadow?: boolean;
     isPresentational?: boolean;
     rendererAppearance?: RendererAppearance;
     stickyHeaders?: StickyHeaderConfig;
@@ -42,8 +41,17 @@ export interface TableState {
     headerRowHeight: number;
     stickyMode: StickyMode;
     wrapperWidth: number;
-} /**
- *
+}
+/**
+ * Reads `nestedRendererType` from RendererContext and renders the fake left/right
+ * borders only when the current renderer is the nested renderer for a reference
+ * synced block.
+ */
+export declare const RefSyncBlockFakeBorders: ({ isNumberColumnEnabled, }: {
+    isNumberColumnEnabled: boolean;
+}) => React.JSX.Element | null;
+/**
+ * TableContainer renders tables using only CSS-based rules
  */
 export declare class TableContainer extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableState> {
     state: TableState;
@@ -55,14 +63,74 @@ export declare class TableContainer extends React.Component<TableProps & Overflo
     stickyScrollbar?: TableStickyScrollbar;
     nextFrame: number | undefined;
     overflowParent: OverflowParent | null;
+    private containerRef;
+    private _isInsideNestedRenderer;
+    private _isInsideTableCell;
+    private lastComputedStyle;
     private resizeObserver;
     private applyResizerChange;
     /**
+     * Checks if this table is inside a nested renderer (e.g. Include Page macro)
+     * by looking for multiple .ak-renderer-document ancestors in the DOM.
+     * The result is cached since a table's position in the DOM tree is stable after mount.
+     */
+    private isInsideNestedRenderer;
+    /**
+     * Checks if this table is inside a table cell in the DOM. The result is cached
+     * since a table's position in the DOM tree is stable after mount.
+     */
+    private isInsideTableCell;
+    private isInsideTableContext;
+    /**
+     * For tables inside nested renderers (e.g. Include Page macro), the parent
+     * renderer's CSS override forces width:100%!important and left:0!important
+     * which overrides the inline styles set by this component. Using
+     * style.setProperty with 'important' priority on inline styles beats
+     * stylesheet !important rules per the CSS cascade.
+     *
+     * Tables that are nested inside another table need to remain constrained by
+     * their table-cell context. Do not promote their width to inline !important,
+     * otherwise nested tables rendered through macros such as Excerpt Include can
+     * overflow and overlap adjacent cells.
+     *
+     * Top-level tables in nested renderers still preserve their saved width, but
+     * are capped to their containing block so wide tables do not escape constrained
+     * macro bodies such as Excerpt Include panels.
+     *
+     * Uses lastComputedStyle (populated during render) rather than reading from
+     * element.style, because React may remove properties from the DOM when their
+     * values transition to undefined between renders.
+     *
+     * `platform_nested_table_style_override_2` fixes a follow-up regression where a
+     * NON-resized table inside an Excerpt macro (not Excerpt Include) on a
+     * wide/full-width page shrinks to only show its first columns in the renderer.
+     * Inside a nested renderer (a macro body) a non-resized table's computed width
+     * is a default layout cap (760px/1800px, or a `cqw` length for full-page
+     * appearances) taken from the outer renderer's width context. That value does
+     * not match the macro's own box, so promoting it to inline `!important` makes
+     * the table collapse. Such tables have no author-chosen size to preserve, so
+     * under this gate we re-assert the parent stylesheet's intent (fill the box:
+     * `width: 100%; left: 0`) with inline `!important`.
+     *
+     * Explicitly resized tables (`tableNode.attrs.width` set) are excluded and keep
+     * the original PGXT-10226 behavior: their author-chosen width/left is promoted
+     * verbatim so the Include Page macro does not stretch or indent them. The
+     * table-cell short-circuit (PGXT-10294) above also still applies.
+     */
+    private applyNestedRendererTableFix;
+    /**
+     * Callback ref that captures the container DOM element and also forwards
+     * to the handleRef prop from the overflow shadow HOC.
+     */
+    private setContainerRef;
+    /**
+     * Starts observing table dimensions and wires sticky header/scrollbar behavior after mount.
      *
      * @example
      */
     componentDidMount(): void;
     /**
+     * Updates sticky header wiring and scroll synchronization after prop or state changes.
      *
      * @param prevProps
      * @param prevState
@@ -75,18 +143,19 @@ export declare class TableContainer extends React.Component<TableProps & Overflo
     onScroll: () => void;
     onWrapperScrolled: () => void;
     /**
-     *
+     * Calculates the top offset used when the sticky header is pinned to the table bottom.
      */
     get pinTop(): number | undefined;
     /**
-     *
+     * Determines whether sticky header positioning should include the default scroll root offset.
      */
     get shouldAddOverflowParentOffsetTop_DO_NOT_USE(): boolean | null | undefined;
     /**
-     *
+     * Resolves the top position for the sticky header based on the current sticky mode.
      */
     get stickyTop(): number | undefined;
     /**
+     * Renders the table container, sticky header, table content, sticky scrollbar, and synced block borders.
      *
      * @example
      */
@@ -97,13 +166,14 @@ type TableProcessorState = {
     tableOrderStatus?: TableOrderStatus;
 };
 /**
- *
+ * Processes table children before passing them to the styled table container.
  */
-export declare class TableProcessor extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableProcessorState> {
+export declare class TableProcessorWithContainerStyles extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableProcessorState> {
     state: {
         tableOrderStatus: undefined;
     };
     /**
+     * Renders processed table children inside the table container.
      *
      * @example
      */

package/dist/types/ui/{expand-body.d.ts → utils/expand-body.d.ts}

@@ -19,6 +19,14 @@ type ExpandBody = {
      * expand find had just opened, and any nested renderer that had already loaded.
      */
     revealed: boolean;
+    /**
+     * The expands browser find has opened. One set is shared by a whole chain of expands.
+     *
+     * A table standing in for itself does swap out what it renders, and a nested expand in one of its
+     * rows is rebuilt when it does. This is how that expand knows to come back open rather than
+     * closed over the match the reader was just taken to.
+     */
+    revealedByFind: WeakSet<PMNode>;
 };
 export declare const ExpandBodyProvider: Provider<ExpandBody | null>;
 export declare const useExpandBody: () => ExpandBody | null;
@@ -41,15 +49,28 @@ export declare const ExpandBodyBlock: ({ children, searchText }: ExpandBodyBlock
  * 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.
+ * 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 declare const withExpandBodyBlock: (node: PMNode, ancestors: readonly PMNode[], index: number, serialized: JSX.Element | null) => JSX.Element | null;
+type ExpandBodyTableProps = {
+    /** The serialized table, as `serializeFragmentChild` returned it. */
+    children: JSX.Element;
+    node: PMNode;
+};
+/**
+ * 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 declare const ExpandBodyTable: ({ children, node }: ExpandBodyTableProps) => ReactNode;
 /** Whatever the serializer produced for one child: an element, a string, an array of either. */
 type SerializedChild = ReactNode;
 /**

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

@@ -21,3 +21,17 @@ export declare const holdsRevealableContent: (node: PMNode) => boolean;
  * @returns the text, or `undefined` if this block has to be rendered instead.
  */
 export declare const getBlockSearchText: (node: PMNode) => string | 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.
+ */
+export type TableStandInPart = string | number;
+/**
+ * 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 declare const getTableStandInParts: (table: PMNode) => TableStandInPart[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/renderer",
-	"version": "137.1.8",
+	"version": "137.1.10",
 	"description": "Renderer component",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -33,7 +33,7 @@
 		"@atlaskit/adf-schema": "^57.2.0",
 		"@atlaskit/adf-utils": "^20.7.0",
 		"@atlaskit/afm-i18n-platform-editor-renderer": "2.200.0",
-		"@atlaskit/analytics-listeners": "^11.1.0",
+		"@atlaskit/analytics-listeners": "^11.2.0",
 		"@atlaskit/analytics-namespaced-context": "^8.1.0",
 		"@atlaskit/analytics-next": "^12.4.0",
 		"@atlaskit/browser-apis": "^1.2.0",
@@ -70,8 +70,8 @@
 		"@atlaskit/status": "^5.8.0",
 		"@atlaskit/task-decision": "^21.8.0",
 		"@atlaskit/theme": "^28.1.0",
-		"@atlaskit/tmp-editor-statsig": "^165.0.0",
-		"@atlaskit/tokens": "^16.8.0",
+		"@atlaskit/tmp-editor-statsig": "^167.0.0",
+		"@atlaskit/tokens": "^16.9.0",
 		"@atlaskit/tooltip": "^24.2.0",
 		"@atlaskit/visually-hidden": "^4.3.0",
 		"@babel/runtime": "^7.0.0",
@@ -85,7 +85,7 @@
 		"uuid": "^3.1.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^120.6.0",
+		"@atlaskit/editor-common": "^120.7.0",
 		"@atlaskit/link-provider": "^5.4.0",
 		"@atlaskit/media-core": "^38.1.0",
 		"react": "^18.2.0",
@@ -95,7 +95,7 @@
 	"devDependencies": {
 		"@af/integration-testing": "workspace:^",
 		"@af/visual-regression": "workspace:^",
-		"@atlaskit/analytics-gas-types": "^6.0.0",
+		"@atlaskit/analytics-gas-types": "^6.1.0",
 		"@atlaskit/checkbox": "^19.1.0",
 		"@atlaskit/editor-plugin-media": "^18.0.0",
 		"@atlaskit/editor-test-helpers": "workspace:^",
@@ -164,9 +164,6 @@
 		"cc_comments_log_draft_annotation_ancestor_nodes": {
 			"type": "boolean"
 		},
-		"platform-ssr-table-resize": {
-			"type": "boolean"
-		},
 		"platform_fix_nested_num_column_scaling": {
 			"type": "boolean"
 		},