@atlaskit/renderer 137.1.8 → 137.1.10

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

@@ -1,5 +1,5 @@
 import _extends from "@babel/runtime/helpers/extends";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _typeof from "@babel/runtime/helpers/typeof";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
@@ -13,29 +13,45 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+/* eslint-disable @atlaskit/ui-styling-standard/no-classname-prop, @atlaskit/ui-styling-standard/enforce-style-prop, @repo/internal/react/no-class-components */
 import React from 'react';
-import { useIntl } from 'react-intl';
 import { TableSharedCssClassName, tableMarginTop } from '@atlaskit/editor-common/styles';
-import { tableMessages } from '@atlaskit/editor-common/messages';
-import { WidthConsumer, overflowShadow } from '@atlaskit/editor-common/ui';
+import { overflowShadow } from '@atlaskit/editor-common/ui';
+import { getTableContainerWidth } from '@atlaskit/editor-common/node-width';
+import { FullPagePadding } from '../../ui/Renderer/style';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { RendererCssClassName } from '../../consts';
 import { createCompareNodes, convertProsemirrorTableNodeToArrayOfRows, hasMergedCell, compose } from '@atlaskit/editor-common/utils';
 import { SortOrder } from '@atlaskit/editor-common/types';
 import { akEditorDefaultLayoutWidth, akEditorFullWidthLayoutWidth, akEditorMaxWidthLayoutWidth } from '@atlaskit/editor-shared-styles';
-import { getTableContainerWidth } from '@atlaskit/editor-common/node-width';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
-import { FullPagePadding } from '../../ui/Renderer/style';
-import { TableHeader } from './tableCell';
+import { TableCell, TableHeader } from './tableCell';
 import { withSmartCardStorage } from '../../ui/SmartCardStorage';
 import { StickyTable, tableStickyPadding, OverflowParent } from './table/sticky';
 import { Table } from './table/table';
-import { isCommentAppearance, isFullPageAppearance, isFullWidthAppearance, isFullWidthOrFullPageAppearance, isMaxWidthAppearance } from '../utils/appearance';
+import { isCommentAppearance, isFullWidthOrFullPageAppearance, isFullWidthAppearance, isMaxWidthAppearance, isFullPageAppearance } from '../utils/appearance';
 import { TableStickyScrollbar } from './TableStickyScrollbar';
 import { useRendererContext } from '../../renderer-context';
-import { TableProcessorWithContainerStyles, RefSyncBlockFakeBorders } from './tableNew';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { isTableInContentMode } from '@atlaskit/editor-common/table';
 import { isContentModeSupported } from './table/content-mode';
+var stickyContainerBaseStyles = {
+  // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
+  height: "var(--ds-space-250, 20px)",
+  // MAX_BROWSER_SCROLLBAR_HEIGHT
+  // Follow editor to hide by default so it does not show empty gap in SSR
+  // https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master/platform/packages/editor/editor-plugin-table/src/nodeviews/TableComponent.tsx#957
+  // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
+  display: 'block',
+  width: '100%'
+};
+var stickyContainerAdditionalStyles = {
+  visibility: 'hidden',
+  overflowX: 'auto',
+  position: 'sticky',
+  bottom: "var(--ds-space-0, 0px)",
+  zIndex: 1
+};
 export var isTableResizingEnabled = function isTableResizingEnabled(appearance) {
   return isFullWidthOrFullPageAppearance(appearance) || isCommentAppearance(appearance);
 };
@@ -95,7 +111,7 @@ export var shouldHeaderPinBottom = function shouldHeaderPinBottom(scrollTop, tab
   return tableBottom - rowHeight <= scrollTop && !(tableBottom < scrollTop);
 };
 export var addSortableColumn = function addSortableColumn(rows, tableOrderStatus, onSorting
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-explicit-any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
   return React.Children.map(rows, function (row, index) {
     if (index === 0) {
@@ -126,44 +142,53 @@ export var isHeaderRowEnabled = function isHeaderRowEnabled(rows
     return node.type === TableHeader;
   });
 };
-/**
- * This TableWrapper component was created to make sure that the aria-label can be
- * internationalized without needing to add `intl` to the TableContainer.
- *
- * <TableWrapper wrapperRef={ref} onScroll={handleScroll} stickyHeaders={config}>
- *   <Table>...</Table>
- * </TableWrapper>
- */
-var TableWrapper = function TableWrapper(_ref2) {
-  var children = _ref2.children,
-    wrapperRef = _ref2.wrapperRef,
-    onScroll = _ref2.onScroll,
-    stickyHeaders = _ref2.stickyHeaders,
-    tabIndex = _ref2.tabIndex;
-  var _useIntl = useIntl(),
-    formatMessage = _useIntl.formatMessage;
-  var isScrollableRegion = tabIndex !== undefined;
-  return /*#__PURE__*/React.createElement("div", {
-    // eslint-disable-next-line @atlaskit/ui-styling-standard/no-classname-prop -- Ignored via go/DSP-18766
-    className: TableSharedCssClassName.TABLE_NODE_WRAPPER,
-    ref: wrapperRef,
-    onScroll: stickyHeaders ? onScroll : undefined
-    // Adding tabIndex here because this is a scrollable container and it needs to be focusable so keyboard users can scroll it.
-    // eslint-disable-next-line @atlassian/a11y/no-noninteractive-tabindex
-    ,
-    tabIndex: tabIndex,
-    role: isScrollableRegion ? 'region' : undefined,
-    "aria-label": isScrollableRegion ? formatMessage(tableMessages.tableScrollRegion) : undefined
-  }, children);
-};
 export var tableCanBeSticky = function tableCanBeSticky(node, children
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
   return isHeaderRowEnabled(children) && node && node.firstChild && !hasRowspan(node.firstChild);
 };
 /**
-*
-*/
+ * Fake left/right borders rendered as direct children of TABLE_CONTAINER
+ * (the non-scrolling parent of the horizontally scrolling TABLE_NODE_WRAPPER).
+ *
+ * The visible styling for these divs lives in `tableFakeBorderStyles`
+ * (`renderer/src/ui/Renderer/RendererStyleContainer.tsx`), which is applied
+ * when `isInsideSyncBlock` is true.
+ */
+var TableFakeBorders = function TableFakeBorders(_ref2) {
+  var isNumberColumnEnabled = _ref2.isNumberColumnEnabled;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    className: TableSharedCssClassName.TABLE_LEFT_BORDER,
+    "data-with-numbered-table": isNumberColumnEnabled ? 'true' : undefined,
+    "data-testid": "table-left-border"
+  }), /*#__PURE__*/React.createElement("div", {
+    className: TableSharedCssClassName.TABLE_RIGHT_BORDER,
+    "data-with-numbered-table": isNumberColumnEnabled ? 'true' : undefined,
+    "data-testid": "table-right-border"
+  }));
+};
+
+/**
+ * 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 var RefSyncBlockFakeBorders = function RefSyncBlockFakeBorders(_ref3) {
+  var isNumberColumnEnabled = _ref3.isNumberColumnEnabled;
+  var _useRendererContext = useRendererContext(),
+    nestedRendererType = _useRendererContext.nestedRendererType;
+  var isInsideOfRefSyncBlock = nestedRendererType === 'syncedBlock';
+  if (!isInsideOfRefSyncBlock) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(TableFakeBorders, {
+    isNumberColumnEnabled: isNumberColumnEnabled
+  });
+};
+
+/**
+ * TableContainer renders tables using only CSS-based rules
+ */
 // Ignored via go/ees005
 // eslint-disable-next-line @repo/internal/react/no-class-components
 export var TableContainer = /*#__PURE__*/function (_React$Component) {
@@ -186,6 +211,12 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
     _defineProperty(_this, "stickyWrapperRef", /*#__PURE__*/React.createRef());
     _defineProperty(_this, "wrapperRef", /*#__PURE__*/React.createRef());
     _defineProperty(_this, "overflowParent", null);
+    _defineProperty(_this, "containerRef", null);
+    _defineProperty(_this, "_isInsideNestedRenderer", null);
+    _defineProperty(_this, "_isInsideTableCell", null);
+    // Stores the last computed style values from render() for use by applyNestedRendererTableFix().
+    // This avoids reading from the DOM which can be stale when React removes properties between renders.
+    _defineProperty(_this, "lastComputedStyle", {});
     _defineProperty(_this, "resizeObserver", null);
     _defineProperty(_this, "applyResizerChange", function (entries) {
       var wrapperWidth = _this.state.wrapperWidth;
@@ -213,6 +244,25 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
         });
       }
     });
+    /**
+     * Callback ref that captures the container DOM element and also forwards
+     * to the handleRef prop from the overflow shadow HOC.
+     */
+    _defineProperty(_this, "setContainerRef", function (el) {
+      if (_this.containerRef !== el) {
+        _this._isInsideNestedRenderer = null;
+        _this._isInsideTableCell = null;
+      }
+      _this.containerRef = el;
+      var handleRef = _this.props.handleRef;
+      if (typeof handleRef === 'function') {
+        handleRef(el);
+      } else if (handleRef && _typeof(handleRef) === 'object') {
+        // Ignored via go/ees005
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        handleRef.current = el;
+      }
+    });
     _defineProperty(_this, "componentWillUnmount", function () {
       if (_this.overflowParent) {
         // Ignored via go/ees005
@@ -288,9 +338,148 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
   }
   _inherits(TableContainer, _React$Component);
   return _createClass(TableContainer, [{
+    key: "isInsideNestedRenderer",
+    value:
+    /**
+     * 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.
+     */
+    function isInsideNestedRenderer() {
+      if (this._isInsideNestedRenderer !== null) {
+        return this._isInsideNestedRenderer;
+      }
+      if (!this.containerRef) {
+        return false;
+      }
+      var docAncestorCount = 0;
+      var el = this.containerRef.parentElement;
+      while (el) {
+        if (el.classList.contains(RendererCssClassName.DOCUMENT)) {
+          docAncestorCount++;
+          if (docAncestorCount >= 2) {
+            this._isInsideNestedRenderer = true;
+            return true;
+          }
+        }
+        el = el.parentElement;
+      }
+      this._isInsideNestedRenderer = false;
+      return false;
+    }
+
+    /**
+     * 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.
+     */
+  }, {
+    key: "isInsideTableCell",
+    value: function isInsideTableCell() {
+      if (this._isInsideTableCell !== null) {
+        return this._isInsideTableCell;
+      }
+      if (!this.containerRef) {
+        return false;
+      }
+      this._isInsideTableCell = Boolean(this.containerRef.closest('td, th'));
+      return this._isInsideTableCell;
+    }
+  }, {
+    key: "isInsideTableContext",
+    value: function isInsideTableContext() {
+      return Boolean(this.props.isInsideOfTable || this.isInsideTableCell());
+    }
+
+    /**
+     * 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.
+     */
+  }, {
+    key: "applyNestedRendererTableFix",
+    value: function applyNestedRendererTableFix() {
+      var _this$props$tableNode;
+      if (!this.containerRef || !fg('platform_nested_table_style_override')) {
+        return;
+      }
+      if (!this.isInsideNestedRenderer() || this.isInsideTableContext()) {
+        return;
+      }
+      var _this$lastComputedSty = this.lastComputedStyle,
+        width = _this$lastComputedSty.width,
+        left = _this$lastComputedSty.left,
+        marginLeft = _this$lastComputedSty.marginLeft;
+      var style = this.containerRef.style;
+
+      // A table is "explicitly resized" when the author set a width on the node.
+      // Non-resized tables instead take a default layout cap (e.g. 760px/1800px)
+      // derived from the outer renderer's appearance.
+      var isExplicitlyResized = Boolean((_this$props$tableNode = this.props.tableNode) === null || _this$props$tableNode === void 0 ? void 0 : _this$props$tableNode.attrs.width);
+      if (!isExplicitlyResized && fg('platform_nested_table_style_override_2')) {
+        // PGXT-10421: For a NON-resized table inside a nested renderer (e.g. an
+        // Excerpt macro body), the 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
+        // ignore the available space and collapse to its first columns.
+        //
+        // These tables have no author-chosen size to preserve, so re-assert the
+        // parent stylesheet's intent — fill the available box (`width: 100%`) —
+        // with inline `!important` priority so it survives React re-renders and
+        // wins over the stylesheet rule that leaks into nested renderers.
+        style.setProperty('width', '100%', 'important');
+        style.setProperty('max-width', '100%', 'important');
+        style.setProperty('left', '0', 'important');
+        style.setProperty('margin-left', '0', 'important');
+        return;
+      }
+
+      // PGXT-10226: An explicitly resized table inside a nested renderer (e.g.
+      // Include Page macro) must keep its author-chosen width and position. The
+      // parent stylesheet forces `width: 100% !important; left: 0 !important`,
+      // which would stretch and indent it, so we promote the component's own
+      // computed width/left with inline `!important` to win the cascade.
+      style.setProperty('width', width || 'auto', 'important');
+      style.setProperty('max-width', '100%', 'important');
+      style.setProperty('left', left || 'auto', 'important');
+      style.setProperty('margin-left', marginLeft || '0', 'important');
+    }
+  }, {
     key: "componentDidMount",
     value:
     /**
+     * Starts observing table dimensions and wires sticky header/scrollbar behavior after mount.
      *
      * @example
      */
@@ -312,9 +501,11 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
       if (this.wrapperRef.current && isStickyScrollbarEnabled(this.props.rendererAppearance)) {
         this.stickyScrollbar = new TableStickyScrollbar(this.wrapperRef.current);
       }
+      this.applyNestedRendererTableFix();
     }
 
     /**
+     * Updates sticky header wiring and scroll synchronization after prop or state changes.
      *
      * @param prevProps
      * @param prevState
@@ -343,12 +534,16 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
       if (prevState.stickyMode !== this.state.stickyMode) {
         this.onWrapperScrolled();
       }
+
+      // React re-applies the style prop on every render, which overwrites the
+      // !important priorities set at mount time. Re-apply after each update.
+      this.applyNestedRendererTableFix();
     }
   }, {
     key: "pinTop",
     get:
     /**
-     *
+     * Calculates the top offset used when the sticky header is pinned to the table bottom.
      */
     function get() {
       if (!this.tableRef.current || !this.stickyHeaderRef.current) {
@@ -358,7 +553,7 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
     }
 
     /**
-     *
+     * Determines whether sticky header positioning should include the default scroll root offset.
      */
   }, {
     key: "shouldAddOverflowParentOffsetTop_DO_NOT_USE",
@@ -371,7 +566,7 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
     }
 
     /**
-     *
+     * Resolves the top position for the sticky header based on the current sticky mode.
      */
   }, {
     key: "stickyTop",
@@ -393,6 +588,7 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
     }
 
     /**
+     * Renders the table container, sticky header, table content, sticky scrollbar, and synced block borders.
      *
      * @example
      */
@@ -403,7 +599,6 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
       var _this$props = this.props,
         isNumberColumnEnabled = _this$props.isNumberColumnEnabled,
         layout = _this$props.layout,
-        renderWidth = _this$props.renderWidth,
         columnWidths = _this$props.columnWidths,
         stickyHeaders = _this$props.stickyHeaders,
         tableNode = _this$props.tableNode,
@@ -418,67 +613,43 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
         allowFixedColumnWidthOption = _this$props.allowFixedColumnWidthOption;
       var stickyMode = this.state.stickyMode;
       var lineLengthFixedWidth = akEditorDefaultLayoutWidth;
-      var left;
       var updatedLayout;
-
-      // The tableWidth and left offset logic below must stay aligned with the `breakout-ssr.tsx` logic
-      // Please consider changes below carefully to not negatively impact SSR
-      // `renderWidth` cannot be depended on during SSR
-      var isRenderWidthValid = !!renderWidth && renderWidth > 0;
       var fullPageRendererWidthCSS = editorExperiment('platform_editor_preview_panel_responsiveness', true, {
         exposure: true
       }) ? 'calc(100cqw - var(--ak-renderer--full-page-gutter) * 2)' : "100cqw - ".concat(FullPagePadding, "px * 2");
       var renderWidthCSS = rendererAppearance === 'full-page' ? fullPageRendererWidthCSS : "100cqw";
       var calcDefaultLayoutWidthByAppearance = function calcDefaultLayoutWidthByAppearance(rendererAppearance, tableNode) {
-        if (rendererAppearance === 'full-width' && !(tableNode !== null && tableNode !== void 0 && tableNode.attrs.width)) {
-          return [isRenderWidthValid ? Math.min(akEditorFullWidthLayoutWidth, renderWidth) : akEditorFullWidthLayoutWidth, "min(".concat(akEditorFullWidthLayoutWidth, "px, ").concat(renderWidthCSS, ")")];
-        } else if (rendererAppearance === 'max' && !(tableNode !== null && tableNode !== void 0 && tableNode.attrs.width)) {
-          return [isRenderWidthValid ? Math.min(akEditorMaxWidthLayoutWidth, renderWidth) : akEditorMaxWidthLayoutWidth, "min(".concat(akEditorMaxWidthLayoutWidth, "px, ").concat(renderWidthCSS, ")")];
+        if (rendererAppearance === 'max' && !(tableNode !== null && tableNode !== void 0 && tableNode.attrs.width) && (expValEquals('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true))) {
+          return "min(".concat(akEditorMaxWidthLayoutWidth, "px, ").concat(renderWidthCSS, ")");
+        } else if (rendererAppearance === 'full-width' && !(tableNode !== null && tableNode !== void 0 && tableNode.attrs.width)) {
+          return "min(".concat(akEditorFullWidthLayoutWidth, "px, ").concat(renderWidthCSS, ")");
         } else if (rendererAppearance === 'comment' && allowTableResizing && !(tableNode !== null && tableNode !== void 0 && tableNode.attrs.width)) {
-          var tableContainerWidth = getTableContainerWidth(tableNode);
-          return [isRenderWidthValid ? renderWidth : tableContainerWidth, renderWidthCSS];
+          return renderWidthCSS;
         } else {
           // custom width, or width mapped to breakpoint
-          var _tableContainerWidth = getTableContainerWidth(tableNode);
-          return [isRenderWidthValid ? Math.min(_tableContainerWidth, renderWidth) : _tableContainerWidth, "min(".concat(_tableContainerWidth, "px, ").concat(renderWidthCSS, ")")];
+          var tableContainerWidth = getTableContainerWidth(tableNode);
+          return "min(".concat(tableContainerWidth, "px, ").concat(renderWidthCSS, ")");
         }
       };
-      var _calcDefaultLayoutWid = calcDefaultLayoutWidthByAppearance(rendererAppearance, tableNode),
-        _calcDefaultLayoutWid2 = _slicedToArray(_calcDefaultLayoutWid, 2),
-        tableWidth = _calcDefaultLayoutWid2[0],
-        tableWidthCSS = _calcDefaultLayoutWid2[1];
+      var tableWidthCSS = calcDefaultLayoutWidthByAppearance(rendererAppearance, tableNode);
 
       // Logic for table alignment in renderer
       var isTableAlignStart = tableNode && tableNode.attrs && tableNode.attrs.layout === 'align-start' && allowTableAlignment;
-      var fullWidthLineLength = isRenderWidthValid ? Math.min(akEditorFullWidthLayoutWidth, renderWidth) : akEditorFullWidthLayoutWidth;
       var fullWidthLineLengthCSS = "min(".concat(akEditorFullWidthLayoutWidth, "px, ").concat(renderWidthCSS, ")");
-      var maxWidthLineLength = isRenderWidthValid ? Math.min(akEditorMaxWidthLayoutWidth, renderWidth) : akEditorMaxWidthLayoutWidth;
       var maxWidthLineLengthCSS = "min(".concat(akEditorMaxWidthLayoutWidth, "px, ").concat(renderWidthCSS, ")");
-      var commentLineLength = isRenderWidthValid ? renderWidth : lineLengthFixedWidth;
       var isCommentAppearanceAndTableAlignmentEnabled = isCommentAppearance(rendererAppearance) && allowTableAlignment;
-      var lineLength = isFullWidthAppearance(rendererAppearance) ? fullWidthLineLength : isMaxWidthAppearance(rendererAppearance) && (expValEquals('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true)) ? maxWidthLineLength : isCommentAppearanceAndTableAlignmentEnabled ? commentLineLength : lineLengthFixedWidth;
       var lineLengthCSS = isFullWidthAppearance(rendererAppearance) ? fullWidthLineLengthCSS : isMaxWidthAppearance(rendererAppearance) && (expValEquals('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true)) ? maxWidthLineLengthCSS : isCommentAppearanceAndTableAlignmentEnabled ? renderWidthCSS : "".concat(lineLengthFixedWidth, "px");
-
-      // Setting fixTableSSRResizing to false while FG logic is true in tableNew
-      var fixTableSSRResizing = false;
-      var tableWidthNew = fixTableSSRResizing ? getTableContainerWidth(tableNode) : tableWidth;
-      var shouldCalculateLeftForAlignment = !isInsideOfBlockNode && !isInsideOfTable && isTableAlignStart && (isFullPageAppearance(rendererAppearance) && tableWidthNew <= lineLengthFixedWidth || isFullWidthAppearance(rendererAppearance) || (expValEquals('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true)) && isMaxWidthAppearance(rendererAppearance) || isCommentAppearanceAndTableAlignmentEnabled);
+      var tableWidthNew = getTableContainerWidth(tableNode);
+      var shouldCalculateLeftForAlignment = !isInsideOfBlockNode && !isInsideOfTable && isTableAlignStart && (isFullPageAppearance(rendererAppearance) && tableWidthNew <= lineLengthFixedWidth || isFullWidthAppearance(rendererAppearance) || isMaxWidthAppearance(rendererAppearance) && (expValEquals('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true)) || isCommentAppearanceAndTableAlignmentEnabled);
       var leftCSS;
       if (shouldCalculateLeftForAlignment) {
-        left = (tableWidth - lineLength) / 2;
         leftCSS = "(".concat(tableWidthCSS, " - ").concat(lineLengthCSS, ") / 2");
       }
-      if (fixTableSSRResizing) {
-        if (!shouldCalculateLeftForAlignment && isFullPageAppearance(rendererAppearance)) {
-          // Note tableWidthCSS here is the renderer width
-          // When the screen is super wide we want table to break out.
-          // However if screen is smaller than 760px. We want table align to left.
-          leftCSS = "min(0px, ".concat(lineLengthCSS, " - ").concat(tableWidthCSS, ") / 2");
-        }
-      } else {
-        if (!shouldCalculateLeftForAlignment && isFullPageAppearance(rendererAppearance) && tableWidthNew > lineLengthFixedWidth) {
-          left = lineLengthFixedWidth / 2 - tableWidth / 2;
-        }
+      if (!shouldCalculateLeftForAlignment && isFullPageAppearance(rendererAppearance)) {
+        // Note tableWidthCSS here is the renderer width
+        // When the screen is super wide we want table to break out.
+        // However if screen is smaller than 760px. We want table align to left.
+        leftCSS = "min(0px, ".concat(lineLengthCSS, " - ").concat(tableWidthCSS, ") / 2");
       }
       var children = React.Children.toArray(this.props.children);
 
@@ -498,7 +669,7 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
       // We can only use CSS to determine the width when we have a known width in container.
       // When appearance is full-page, full-width or comment we use CSS based width calculation.
       // Otherwise it's fixed table width (customized width) or inherit.
-      if ((rendererAppearance === 'full-page' || rendererAppearance === 'full-width' || rendererAppearance === 'max') && fixTableSSRResizing) {
+      if (rendererAppearance === 'full-page' || rendererAppearance === 'full-width' || rendererAppearance === 'max' && (expValEquals('editor_tinymce_full_width_mode', 'isEnabled', true) || expValEquals('confluence_max_width_content_appearance', 'isEnabled', true))) {
         finalTableContainerWidth = allowTableResizing ? "calc(".concat(tableWidthCSS, ")") : 'inherit';
       }
       if (rendererAppearance === 'comment' && allowTableResizing && !allowTableAlignment) {
@@ -509,13 +680,13 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
 
         // !NOTE: it a table resized to 760 is copied from 'full-page' editor and pasted in comment editor
         // where (allowTableResizing && !allowTableAlignment), the table will loose 760px width.
-        finalTableContainerWidth = tableNode !== null && tableNode !== void 0 && tableNode.attrs.width && (tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.width) !== akEditorDefaultLayoutWidth ? fixTableSSRResizing ? "calc(".concat(tableWidthCSS, ")") : tableWidth : 'inherit';
+        finalTableContainerWidth = tableNode !== null && tableNode !== void 0 && tableNode.attrs.width && (tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.width) !== akEditorDefaultLayoutWidth ? "calc(".concat(tableWidthCSS, ")") : 'inherit';
       }
       if (rendererAppearance === 'comment' && allowTableResizing && allowTableAlignment) {
         // If table alignment is enabled and layout is not 'align-start' or 'center', we are loading a table that was
         // created before "Support Table in Comments" FF was enabled. So the table should have the same width as renderer container
         // instead of 760 that was set on tableNode when the table had been published.
-        finalTableContainerWidth = ((tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.layout) === 'align-start' || (tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.layout) === 'center') && tableNode !== null && tableNode !== void 0 && tableNode.attrs.width ? fixTableSSRResizing ? "calc(".concat(tableWidthCSS, ")") : tableWidth : 'inherit';
+        finalTableContainerWidth = ((tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.layout) === 'align-start' || (tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.layout) === 'center') && tableNode !== null && tableNode !== void 0 && tableNode.attrs.width ? "calc(".concat(tableWidthCSS, ")") : 'inherit';
       }
       var isContentModeTable = isTableInContentMode({
         tableNode: tableNode,
@@ -525,41 +696,39 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
         }),
         isTableNested: isInsideOfBlockNode || isInsideOfNestedRenderer || isInsideOfTable
       }) && expValEquals('platform_editor_table_fit_to_content_auto_convert', 'isEnabled', true);
-      var style;
-      if (fixTableSSRResizing) {
-        style = _objectSpread(_objectSpread({}, isContentModeTable && {
-          '--renderer-table-max-width': renderWidthCSS
-        }), {}, {
-          width: finalTableContainerWidth,
-          left: leftCSS ? "calc(".concat(leftCSS, ")") : undefined,
-          marginLeft: shouldCalculateLeftForAlignment && leftCSS !== undefined ? "calc(-1 * (".concat(leftCSS, "))") : undefined
-        });
-      } else {
-        style = _objectSpread(_objectSpread({}, isContentModeTable && {
-          '--renderer-table-max-width': "".concat(renderWidth, "px")
-        }), {}, {
-          width: finalTableContainerWidth,
-          left: left,
-          marginLeft: shouldCalculateLeftForAlignment && left !== undefined ? -left : undefined
-        });
-      }
+      var style = _objectSpread(_objectSpread({}, isContentModeTable && {
+        '--renderer-table-max-width': renderWidthCSS
+      }), {}, {
+        width: finalTableContainerWidth,
+        left: leftCSS ? "calc(".concat(leftCSS, ")") : undefined,
+        marginLeft: shouldCalculateLeftForAlignment && leftCSS !== undefined ? "calc(-1 * (".concat(leftCSS, "))") : undefined
+      });
+
+      // Store computed style values for applyNestedRendererTableFix() to use.
+      // Reading from props rather than the DOM ensures correctness when React
+      // removes properties (transitions from set to undefined) between renders.
+      this.lastComputedStyle = {
+        width: typeof style.width === 'number' ? "".concat(style.width, "px") : style.width,
+        left: style.left,
+        marginLeft: style.marginLeft
+      };
       return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
         // eslint-disable-next-line @atlaskit/ui-styling-standard/no-classname-prop -- Ignored via go/DSP-18766
         className: "".concat(TableSharedCssClassName.TABLE_CONTAINER, " ").concat(this.props.shadowClassNames || ''),
         "data-layout": updatedLayout,
-        ref: this.props.handleRef
-        // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
-        ,
+        "data-testid": "table-container",
+        ref: this.setContainerRef,
         style: style
+        // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
       }, isStickyScrollbarEnabled(this.props.rendererAppearance) && /*#__PURE__*/React.createElement("div", {
         // eslint-disable-next-line @atlaskit/ui-styling-standard/no-classname-prop -- Ignored via go/DSP-18766
         className: TableSharedCssClassName.TABLE_STICKY_SCROLLBAR_SENTINEL_TOP,
         "data-testid": "sticky-scrollbar-sentinel-top"
-      }), stickyHeaders && tableCanBeSticky(tableNode, children) && /*#__PURE__*/React.createElement(StickyTable, {
+      }), stickyHeaders && tableNode && !isContentModeTable && tableCanBeSticky(tableNode, children) && /*#__PURE__*/React.createElement(StickyTable, {
         isNumberColumnEnabled: isNumberColumnEnabled,
-        tableWidth: tableWidth,
+        tableWidth: "inherit",
+        renderWidth: 0,
         layout: layout,
-        renderWidth: renderWidth,
         handleRef: this.props.handleRef,
         shadowClassNames: this.props.shadowClassNames,
         top: this.stickyTop,
@@ -572,17 +741,23 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
         rendererAppearance: rendererAppearance,
         allowTableResizing: allowTableResizing,
         allowFixedColumnWidthOption: allowFixedColumnWidthOption
-      }, [children && children[0]]), /*#__PURE__*/React.createElement(TableWrapper, {
-        wrapperRef: this.wrapperRef,
-        onScroll: this.props.stickyHeaders ? this.onWrapperScrolled : undefined,
-        stickyHeaders: stickyHeaders,
-        tabIndex: this.props.tabIndex
+      }, [children && children[0]]), /*#__PURE__*/React.createElement("div", {
+        // eslint-disable-next-line @atlaskit/ui-styling-standard/no-classname-prop -- Ignored via go/DSP-18766
+        className: TableSharedCssClassName.TABLE_NODE_WRAPPER,
+        ref: this.wrapperRef,
+        "data-number-column": tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.isNumberColumnEnabled,
+        "data-layout": tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.layout,
+        "data-autosize": tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.__autoSize,
+        "data-table-local-id": tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.localId,
+        "data-table-width": tableNode === null || tableNode === void 0 ? void 0 : tableNode.attrs.width,
+        "data-vc": "table-node-wrapper",
+        onScroll: this.props.stickyHeaders && this.onWrapperScrolled
       }, /*#__PURE__*/React.createElement(Table, {
         innerRef: this.tableRef,
         columnWidths: columnWidths,
         layout: layout,
+        renderWidth: 0,
         isNumberColumnEnabled: isNumberColumnEnabled,
-        renderWidth: renderWidth,
         tableNode: tableNode,
         rendererAppearance: rendererAppearance,
         isInsideOfBlockNode: isInsideOfBlockNode,
@@ -594,22 +769,13 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
         allowFixedColumnWidthOption: allowFixedColumnWidthOption
       }, this.grabFirstRowRef(children))), isStickyScrollbarEnabled(this.props.rendererAppearance) && /*#__PURE__*/React.createElement("div", {
         // eslint-disable-next-line @atlaskit/ui-styling-standard/no-classname-prop -- Ignored via go/DSP-18766
-        className: TableSharedCssClassName.TABLE_STICKY_SCROLLBAR_CONTAINER,
+        className: "".concat(TableSharedCssClassName.TABLE_STICKY_SCROLLBAR_CONTAINER).concat(fg('confluence_frontend_table_scrollbar_ttvc_fix') ? '-view-page' : ''),
         ref: this.stickyScrollbarRef,
-        style: {
-          // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
-          height: "var(--ds-space-250, 20px)",
-          // MAX_BROWSER_SCROLLBAR_HEIGHT
-          // Follow editor to hide by default so it does not show empty gap in SSR
-          // https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master/platform/packages/editor/editor-plugin-table/src/nodeviews/TableComponent.tsx#957
-          // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
-          display: fixTableSSRResizing ? 'none' : 'block',
-          // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop
-          width: '100%'
-        }
+        "data-vc": "table-sticky-scrollbar-container",
+        style: fg('confluence_frontend_table_scrollbar_ttvc_fix') ? _objectSpread(_objectSpread({}, stickyContainerBaseStyles), stickyContainerAdditionalStyles) : stickyContainerBaseStyles
       }, /*#__PURE__*/React.createElement("div", {
         style: {
-          width: (_this$tableRef$curren = this.tableRef.current) === null || _this$tableRef$curren === void 0 ? void 0 : _this$tableRef$curren.clientWidth,
+          width: fg('confluence_frontend_table_scrollbar_ttvc_fix') ? '100%' : (_this$tableRef$curren = this.tableRef.current) === null || _this$tableRef$curren === void 0 ? void 0 : _this$tableRef$curren.clientWidth,
           // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop -- Ignored via go/DSP-18766
           height: '100%'
         }
@@ -623,19 +789,117 @@ export var TableContainer = /*#__PURE__*/function (_React$Component) {
     }
   }]);
 }(React.Component);
+var getCellEdgePropsByCellOffset = function getCellEdgePropsByCellOffset(tableNode, isNumberColumnEnabled) {
+  var cellEdgePropsByCellOffset = new Map();
+  var cellRightByCellOffset = new Map();
+  var occupiedGrid = [];
+  var tableWidth = 0;
+  var cellOffset = 0;
+  tableNode.forEach(function (rowNode, _rowOffset, rowIndex) {
+    var _occupiedGrid$rowInde;
+    occupiedGrid[rowIndex] = (_occupiedGrid$rowInde = occupiedGrid[rowIndex]) !== null && _occupiedGrid$rowInde !== void 0 ? _occupiedGrid$rowInde : [];
+    var columnIndex = 0;
+    cellOffset += 1;
+    rowNode.forEach(function (cellNode) {
+      while (occupiedGrid[rowIndex][columnIndex]) {
+        columnIndex += 1;
+      }
+      var colspan = cellNode.attrs.colspan || 1;
+      var rowspan = cellNode.attrs.rowspan || 1;
+      var cellLeft = columnIndex;
+      var cellRight = cellLeft + colspan;
+      var cellTop = rowIndex;
+      var cellBottom = cellTop + rowspan;
+      for (var row = cellTop; row < cellBottom; row += 1) {
+        var _occupiedGrid$row;
+        occupiedGrid[row] = (_occupiedGrid$row = occupiedGrid[row]) !== null && _occupiedGrid$row !== void 0 ? _occupiedGrid$row : [];
+        for (var column = cellLeft; column < cellRight; column += 1) {
+          occupiedGrid[row][column] = true;
+        }
+      }
+      tableWidth = Math.max(tableWidth, cellRight);
+      cellRightByCellOffset.set(cellOffset, cellRight);
+      cellEdgePropsByCellOffset.set(cellOffset, {
+        reachesBottom: cellBottom >= tableNode.childCount,
+        // With number column enabled, PM column 0 is not visually leftmost and must not get `data-reaches-left`.
+        reachesLeft: cellLeft === 0 && !isNumberColumnEnabled,
+        reachesRight: false,
+        reachesTop: cellTop === 0
+      });
+      columnIndex = cellRight;
+      cellOffset += cellNode.nodeSize;
+    });
+    cellOffset += 1;
+  });
+  cellRightByCellOffset.forEach(function (cellRight, currentCellOffset) {
+    var edgeProps = cellEdgePropsByCellOffset.get(currentCellOffset);
+    if (edgeProps) {
+      edgeProps.reachesRight = cellRight >= tableWidth;
+    }
+  });
+  return cellEdgePropsByCellOffset;
+};
+var isRenderedTableCell = function isRenderedTableCell(element) {
+  var _ref4 = element.props,
+    nodeType = _ref4.nodeType;
+  return nodeType === 'tableCell' || nodeType === 'tableHeader' || element.type === TableCell || element.type === TableHeader;
+};
+var addTableCellEdgePropsThroughWrappers = function addTableCellEdgePropsThroughWrappers(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 _addEdgePropsToRenderedCells = function addEdgePropsToRenderedCells(element) {
+        if (isRenderedTableCell(element)) {
+          var cellNode = rowNode.child(cellIndex);
+          var edgeProps = cellEdgePropsByCellOffset.get(cellOffset);
+          cellIndex += 1;
+          cellOffset += cellNode.nodeSize;
+          return edgeProps ? /*#__PURE__*/React.cloneElement(element, edgeProps) : element;
+        }
+        var _ref5 = element.props,
+          children = _ref5.children;
+        if (children === undefined) {
+          return element;
+        }
+        var childrenWithEdgeProps = React.Children.map(children, function (child) {
+          return /*#__PURE__*/React.isValidElement(child) ? _addEdgePropsToRenderedCells(child) : child;
+        });
+        return /*#__PURE__*/React.cloneElement(element, undefined, childrenWithEdgeProps);
+      };
+      var rowWithEdgeProps = _addEdgePropsToRenderedCells(row);
+      if (cellIndex !== rowNode.childCount) {
+        throw new Error('Rendered table row does not match its document node');
+      }
+      cellOffset += 1;
+      return rowWithEdgeProps;
+    });
+  } catch (_unused) {
+    // 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.
  */
 // Ignored via go/ees005
 // eslint-disable-next-line @repo/internal/react/no-class-components
-export var TableProcessor = /*#__PURE__*/function (_React$Component2) {
-  function TableProcessor() {
+export var TableProcessorWithContainerStyles = /*#__PURE__*/function (_React$Component2) {
+  function TableProcessorWithContainerStyles() {
     var _this2;
-    _classCallCheck(this, TableProcessor);
+    _classCallCheck(this, TableProcessorWithContainerStyles);
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
     }
-    _this2 = _callSuper(this, TableProcessor, [].concat(args));
+    _this2 = _callSuper(this, TableProcessorWithContainerStyles, [].concat(args));
     _defineProperty(_this2, "state", {
       tableOrderStatus: undefined
     });
@@ -664,36 +928,82 @@ export var TableProcessor = /*#__PURE__*/function (_React$Component2) {
     _defineProperty(_this2, "addNumberColumnIndexes", function (rows) {
       var isNumberColumnEnabled = _this2.props.isNumberColumnEnabled;
       var headerRowEnabled = isHeaderRowEnabled(rows);
+      var lastRowIndex = React.Children.count(rows) - 1;
       return React.Children.map(rows, function (row, index) {
         return /*#__PURE__*/React.cloneElement(React.Children.only(row), {
           isNumberColumnEnabled: isNumberColumnEnabled,
-          index: headerRowEnabled ? index === 0 ? '' : index : index + 1
+          index: headerRowEnabled ? index === 0 ? '' : index : index + 1,
+          isFirstRow: index === 0,
+          isLastRow: index === lastRowIndex
         });
       });
     });
     return _this2;
   }
-  _inherits(TableProcessor, _React$Component2);
-  return _createClass(TableProcessor, [{
+  _inherits(TableProcessorWithContainerStyles, _React$Component2);
+  return _createClass(TableProcessorWithContainerStyles, [{
     key: "render",
     value:
     /**
+     * Renders processed table children inside the table container.
      *
      * @example
      */
     function render() {
-      var children = this.props.children;
+      var _this$props2 = this.props,
+        allowColumnSorting = _this$props2.allowColumnSorting,
+        allowFixedColumnWidthOption = _this$props2.allowFixedColumnWidthOption,
+        allowTableAlignment = _this$props2.allowTableAlignment,
+        allowTableResizing = _this$props2.allowTableResizing,
+        children = _this$props2.children,
+        columnWidths = _this$props2.columnWidths,
+        disableTableOverflowShadow = _this$props2.disableTableOverflowShadow,
+        handleRef = _this$props2.handleRef,
+        isinsideMultiBodiedExtension = _this$props2.isinsideMultiBodiedExtension,
+        isInsideOfBlockNode = _this$props2.isInsideOfBlockNode,
+        isInsideOfNestedRenderer = _this$props2.isInsideOfNestedRenderer,
+        isInsideOfTable = _this$props2.isInsideOfTable,
+        isNumberColumnEnabled = _this$props2.isNumberColumnEnabled,
+        isPresentational = _this$props2.isPresentational,
+        layout = _this$props2.layout,
+        rendererAppearance = _this$props2.rendererAppearance,
+        renderWidth = _this$props2.renderWidth,
+        shadowClassNames = _this$props2.shadowClassNames,
+        smartCardStorage = _this$props2.smartCardStorage,
+        stickyHeaders = _this$props2.stickyHeaders,
+        tabIndex = _this$props2.tabIndex,
+        tableNode = _this$props2.tableNode;
       if (!children) {
         return null;
       }
       var childrenArray = React.Children.toArray(children);
+      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>>[]'
-      )(childrenArray);
-
-      // Ignored via go/ees005
-      // eslint-disable-next-line react/jsx-props-no-spreading
-      return /*#__PURE__*/React.createElement(TableContainer, this.props, orderedChildren);
+      )(childrenWithTableEdgeProps);
+      return /*#__PURE__*/React.createElement(TableContainer, {
+        allowColumnSorting: allowColumnSorting,
+        allowFixedColumnWidthOption: allowFixedColumnWidthOption,
+        allowTableAlignment: allowTableAlignment,
+        allowTableResizing: allowTableResizing,
+        columnWidths: columnWidths,
+        disableTableOverflowShadow: disableTableOverflowShadow,
+        handleRef: handleRef,
+        isinsideMultiBodiedExtension: isinsideMultiBodiedExtension,
+        isInsideOfBlockNode: isInsideOfBlockNode,
+        isInsideOfNestedRenderer: isInsideOfNestedRenderer,
+        isInsideOfTable: isInsideOfTable,
+        isNumberColumnEnabled: isNumberColumnEnabled,
+        isPresentational: isPresentational,
+        layout: layout,
+        rendererAppearance: rendererAppearance,
+        renderWidth: renderWidth,
+        shadowClassNames: shadowClassNames,
+        smartCardStorage: smartCardStorage,
+        stickyHeaders: stickyHeaders,
+        tabIndex: tabIndex,
+        tableNode: tableNode
+      }, orderedChildren);
     }
   }]);
 }(React.Component);
@@ -708,71 +1018,30 @@ var TableWithShadowsAndContainerStyles = overflowShadow(TableProcessorWithContai
   overflowSelector: ":scope > .".concat(TableSharedCssClassName.TABLE_NODE_WRAPPER),
   useShadowObserver: true
 });
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-var TableWithShadows = overflowShadow(TableProcessor, {
-  /**
-   * The :scope is in reference to table container and we are selecting only
-   * direct children that match the table node wrapper selector, not their
-   * descendants.
-   */
-  overflowSelector: ":scope > .".concat(TableSharedCssClassName.TABLE_NODE_WRAPPER),
-  useShadowObserver: true
-});
 var TableWithWidth = function TableWithWidth(props) {
-  var _useRendererContext = useRendererContext(),
-    isTopLevelRenderer = _useRendererContext.isTopLevelRenderer;
+  var _props$columnWidths;
+  var _useRendererContext2 = useRendererContext(),
+    isTopLevelRenderer = _useRendererContext2.isTopLevelRenderer;
   var isInsideOfNestedRenderer = isTopLevelRenderer === false && expValEquals('platform_editor_table_nested_content_mode_fix', 'isEnabled', true);
-  if (fg('platform-ssr-table-resize')) {
-    var _props$columnWidths;
-    var colWidthsSum =
-    // eslint-disable-next-line @atlassian/perf-linting/no-expensive-computations-in-render -- Ignored via go/ees017 (to be fixed)
-    ((_props$columnWidths = props.columnWidths) === null || _props$columnWidths === void 0 ? void 0 : _props$columnWidths.reduce(function (total, val) {
-      return total + val;
-    }, 0)) || 0;
-    if (colWidthsSum || props.allowTableResizing) {
-      return /*#__PURE__*/React.createElement(TableWithShadowsAndContainerStyles
-      // Ignored via go/ees005
-      // eslint-disable-next-line react/jsx-props-no-spreading
-      , _extends({}, props, {
-        isInsideOfNestedRenderer: isInsideOfNestedRenderer
-      }));
-    }
-    return /*#__PURE__*/React.createElement(TableProcessorWithContainerStyles
+  var colWidthsSum =
+  // eslint-disable-next-line @atlassian/perf-linting/no-expensive-computations-in-render -- Ignored via go/ees017 (to be fixed)
+  ((_props$columnWidths = props.columnWidths) === null || _props$columnWidths === void 0 ? void 0 : _props$columnWidths.reduce(function (total, val) {
+    return total + val;
+  }, 0)) || 0;
+  if (colWidthsSum || props.allowTableResizing) {
+    return /*#__PURE__*/React.createElement(TableWithShadowsAndContainerStyles
     // Ignored via go/ees005
     // eslint-disable-next-line react/jsx-props-no-spreading
     , _extends({}, props, {
       isInsideOfNestedRenderer: isInsideOfNestedRenderer
     }));
-  } else {
-    return /*#__PURE__*/React.createElement(WidthConsumer, null, function (_ref3) {
-      var _props$columnWidths2;
-      var width = _ref3.width;
-      var renderWidth = props.rendererAppearance === 'full-page' ? width - FullPagePadding * 2 : width;
-      var colWidthsSum =
-      // eslint-disable-next-line @atlassian/perf-linting/no-expensive-computations-in-render -- Ignored via go/ees017 (to be fixed)
-      ((_props$columnWidths2 = props.columnWidths) === null || _props$columnWidths2 === void 0 ? void 0 : _props$columnWidths2.reduce(function (total, val) {
-        return total + val;
-      }, 0)) || 0;
-      if (colWidthsSum || props.allowTableResizing) {
-        return /*#__PURE__*/React.createElement(TableWithShadows, _extends({
-          renderWidth: renderWidth
-          // Ignored via go/ees005
-          // eslint-disable-next-line react/jsx-props-no-spreading
-        }, props, {
-          isInsideOfNestedRenderer: isInsideOfNestedRenderer
-        }));
-      }
-      // there should not be a case when colWidthsSum is 0 and table is in overflow state - so no need to render shadows in this case
-      return /*#__PURE__*/React.createElement(TableProcessor, _extends({
-        renderWidth: renderWidth
-        // Ignored via go/ees005
-        // eslint-disable-next-line react/jsx-props-no-spreading
-      }, props, {
-        isInsideOfNestedRenderer: isInsideOfNestedRenderer
-      }));
-    });
   }
+  return /*#__PURE__*/React.createElement(TableProcessorWithContainerStyles
+  // Ignored via go/ees005
+  // eslint-disable-next-line react/jsx-props-no-spreading
+  , _extends({}, props, {
+    isInsideOfNestedRenderer: isInsideOfNestedRenderer
+  }));
 };
 var _default_1 = withSmartCardStorage(TableWithWidth);
 export default _default_1;