@atlaskit/editor-plugin-table 12.2.5 → 12.2.7

package/src/pm-plugins/table-resizing/utils/resize-state.ts

@@ -1,417 +0,0 @@
-import { getTableContainerWidth } from '@atlaskit/editor-common/node-width';
-import { tableCellMinWidth, tableNewColumnMinWidth } from '@atlaskit/editor-common/styles';
-import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
-import { calcTableColumnWidths } from '@atlaskit/editor-common/utils';
-import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-import type { EditorState } from '@atlaskit/editor-prosemirror/state';
-import type { Rect } from '@atlaskit/editor-tables/table-map';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
-
-import { getSelectedTableInfo } from '../../utils/analytics';
-
-import { getColWidthFix, hasTableBeenResized, insertColgroupFromNode } from './colgroup';
-import type { ColumnState } from './column-state';
-import { getCellsRefsInColumn, getColumnStateFromDOM } from './column-state';
-import { syncStickyRowToTable } from './dom';
-import { getTableMaxWidth, getTableScalingPercent } from './misc';
-import type { ResizeState, ResizeStateWithAnalytics } from './types';
-
-export const getResizeState = ({
-	minWidth,
-	maxSize,
-	table,
-	tableRef,
-	start,
-	domAtPos,
-	isTableScalingEnabled = false,
-	shouldUseIncreasedScalingPercent = false,
-	isCommentEditor = false,
-}: {
-	minWidth: number;
-	maxSize: number;
-	table: PMNode;
-	tableRef: HTMLTableElement | null;
-	start: number;
-	domAtPos: (pos: number) => { node: Node; offset: number };
-	isTableScalingEnabled: boolean;
-	shouldUseIncreasedScalingPercent: boolean;
-	isCommentEditor: boolean;
-}): ResizeState => {
-	if (
-		(isTableScalingEnabled && !isCommentEditor) ||
-		(isTableScalingEnabled && isCommentEditor && table.attrs?.width)
-	) {
-		const scalePercent = getTableScalingPercent(table, tableRef, shouldUseIncreasedScalingPercent);
-		minWidth = Math.ceil(minWidth / scalePercent);
-	}
-
-	if (hasTableBeenResized(table)) {
-		// If the table has been resized, we can use the column widths from the table node
-		const cols = calcTableColumnWidths(table).map((width, index) => ({
-			width: width === 0 ? tableNewColumnMinWidth : width,
-			minWidth: width === 0 ? tableNewColumnMinWidth : minWidth,
-			index,
-		}));
-
-		const widths = cols.map((col) => col.width);
-		const tableWidth = widths.reduce((sum, width) => sum + width, 0);
-		const overflow = tableWidth > maxSize;
-
-		return {
-			cols,
-			widths,
-			maxSize,
-			tableWidth,
-			overflow,
-			isScaled: isTableScalingEnabled,
-		};
-	}
-
-	const shouldReinsertColgroup = !isTableScalingEnabled;
-
-	// Getting the resize state from DOM
-	const colgroupChildren = insertColgroupFromNode(
-		tableRef,
-		table,
-		isTableScalingEnabled,
-		shouldReinsertColgroup, // don't reinsert colgroup when preserving table width - this causes widths to jump
-		shouldUseIncreasedScalingPercent,
-		isCommentEditor,
-	);
-	const cols = Array.from(colgroupChildren).map((_, index) => {
-		// If the table hasn't been resized and we have a table width attribute, we can use it
-		// to calculate the widths of the columns
-		if (isTableScalingEnabled) {
-			// isCommentEditor when table cols were not resized,
-			// we want to use tableRef.parentElement.clientWidth, which is the same as maxSize
-			const tableNodeWidth =
-				isCommentEditor && !table.attrs?.width ? maxSize : getTableContainerWidth(table);
-			return {
-				index,
-				width: tableNodeWidth / colgroupChildren.length,
-				minWidth,
-			};
-		}
-		const cellsRefs = getCellsRefsInColumn(index, table, start, domAtPos);
-		return getColumnStateFromDOM(cellsRefs, index, minWidth);
-	});
-
-	const widths = cols.map((col) => col.width);
-	const tableWidth = widths.reduce((sum, width) => sum + width, 0);
-
-	const overflow = tableWidth > maxSize;
-
-	return {
-		cols,
-		widths,
-		maxSize,
-		tableWidth,
-		overflow,
-		isScaled: isTableScalingEnabled,
-	};
-};
-
-// updates Colgroup DOM node with new widths
-export const updateColgroup = (
-	state: ResizeState,
-	tableRef: HTMLElement | null,
-	tableNode?: PMNode,
-	isTableScalingEnabled?: boolean,
-	scalePercent?: number,
-): void => {
-	const cols = expValEquals('platform_editor_tables_scaling_css', 'isEnabled', true)
-		? (tableRef?.querySelectorAll(':scope > colgroup > col') as NodeListOf<HTMLElement> | undefined)
-		: (tableRef?.querySelectorAll('col') as NodeListOf<HTMLElement> | undefined);
-	const columnsCount = cols?.length;
-	/**
-     updateColgroup will update whole table scale when click the column resize handle, this behavior will affect when table overflowed, when now resize handle been dragged and extend to make table overflowed, table will show overflow. This need to be confirmed because it conflict with how isTableScalingEnabled work.
-     We don't want to scale the table when resizing columns, only when viewpoint shrinks the table.
-     We need to remove !isColumnResizing if we handled auto scale table when mouseUp event.
-     * */
-	if (isTableScalingEnabled && tableNode) {
-		state.cols
-			.filter((column) => column && !!column.width) // if width is 0, we dont want to apply that.
-			.forEach((column, i) => {
-				const fixedColWidth = getColWidthFix(column.width, columnsCount ?? 0);
-				const scaledWidth = fixedColWidth * (scalePercent || 1);
-				const finalWidth = Math.max(scaledWidth, tableCellMinWidth);
-				// we aren't handling the remaining pixels here when the 48px min width is reached
-				if (cols?.[i]) {
-					cols[i].style.width = `${finalWidth}px`;
-				}
-			});
-	} else {
-		state.cols
-			.filter((column) => column && !!column.width) // if width is 0, we dont want to apply that.
-			.forEach((column, i) => {
-				if (cols?.[i]) {
-					cols[i].style.width = `${getColWidthFix(column.width, columnsCount ?? 0)}px`;
-				}
-			});
-	}
-
-	// colgroup has updated, reflect new widths in sticky header
-	syncStickyRowToTable(tableRef);
-};
-
-export const getTotalWidth = ({ cols }: ResizeState): number => {
-	return cols.reduce((totalWidth, col) => totalWidth + col.width, 0);
-};
-
-// adjust columns to take up the total width
-// difference in total columns widths vs table width happens due to the "Math.floor"
-export const adjustColumnsWidths = (resizeState: ResizeState, maxSize: number): ResizeState => {
-	const totalWidth = getTotalWidth(resizeState);
-	const diff = maxSize - totalWidth;
-	if (diff > 0 || (diff < 0 && Math.abs(diff) < tableCellMinWidth)) {
-		let updated = false;
-		return {
-			...resizeState,
-			cols: resizeState.cols.map((col) => {
-				if (!updated && col.width + diff > col.minWidth) {
-					updated = true;
-					return { ...col, width: col.width + diff };
-				}
-				return col;
-			}),
-		};
-	}
-
-	return resizeState;
-};
-
-export const evenAllColumnsWidths = (resizeState: ResizeState): ResizeState => {
-	const maxSize = getTotalWidth(resizeState);
-	const evenWidth = Math.floor(maxSize / resizeState.cols.length);
-	const cols = resizeState.cols.map((col) => ({ ...col, width: evenWidth }));
-
-	return adjustColumnsWidths({ ...resizeState, cols }, maxSize);
-};
-
-const getSpace = (columns: ColumnState[], start: number, end: number) =>
-	columns
-		.slice(start, end)
-		.map((col) => col.width)
-		.reduce((sum, width) => sum + width, 0);
-
-const evenSelectedColumnsWidths = (resizeState: ResizeState, rect: Rect): ResizeState => {
-	const cols = resizeState.cols;
-	const selectedSpace = getSpace(cols, rect.left, rect.right);
-	const allSpace = getSpace(cols, 0, cols.length);
-
-	const allWidth = allSpace / cols.length;
-	const width = selectedSpace / (rect.right - rect.left);
-
-	// Result equals even distribution of all columns -
-	// unset widths of all columns
-	if (allWidth === width) {
-		return {
-			...resizeState,
-			widths: cols.map(() => width),
-			cols: resizeState.cols.map((col) => ({
-				...col,
-				width: 0,
-			})),
-		};
-	}
-
-	return {
-		...resizeState,
-		widths: cols.map((col, i) => (i >= rect.left && i < rect.right ? width : col.width)),
-		cols: cols.map((col, i) => ({
-			...col,
-			width: i >= rect.left && i < rect.right ? width : col.width,
-		})),
-	};
-};
-
-export const bulkColumnsResize = (
-	resizeState: ResizeState,
-	columnsIndexes: number[],
-	sourceColumnIndex: number,
-) => {
-	const currentTableWidth = getTotalWidth(resizeState);
-	const colIndex =
-		columnsIndexes.indexOf(sourceColumnIndex) > -1 ? sourceColumnIndex : sourceColumnIndex + 1;
-	const sourceCol = resizeState.cols[colIndex];
-	const seenColumns: {
-		[key: number]: { width: number; minWidth: number; index: number };
-	} = {};
-	const widthsDiffs: number[] = [];
-	const cols = resizeState.cols.map((col) => {
-		if (columnsIndexes.indexOf(col.index) > -1) {
-			const diff = col.width - sourceCol.width;
-			if (diff !== 0) {
-				widthsDiffs.push(diff);
-			}
-			return { ...col, width: sourceCol.width };
-		}
-		return col;
-	});
-
-	let newState = {
-		...resizeState,
-		cols: cols.map((col) => {
-			if (
-				columnsIndexes.indexOf(col.index) > -1 ||
-				// take from prev columns only if dragging the first handle to the left
-				(columnsIndexes.indexOf(sourceColumnIndex) > -1 && col.index < colIndex)
-			) {
-				return col;
-			}
-			while (widthsDiffs.length) {
-				const diff = widthsDiffs.shift() || 0;
-				const column = seenColumns[col.index] || col;
-				const maybeWidth = column.width + diff;
-
-				if (maybeWidth > column.minWidth) {
-					seenColumns[column.index] = { ...column, width: maybeWidth };
-				} else {
-					widthsDiffs.push(maybeWidth - column.minWidth);
-					seenColumns[column.index] = { ...column, width: column.minWidth };
-					break;
-				}
-			}
-			return seenColumns[col.index] || col;
-		}),
-	};
-
-	// minimum possible table widths at the current layout
-	const minTableWidth = resizeState.maxSize;
-	// new table widths after bulk resize
-	const newTotalWidth = getTotalWidth(newState);
-	// when all columns are selected, what do we do when sum of columns widths is lower than min possible table widths?
-	if (columnsIndexes.length === resizeState.cols.length && newTotalWidth < minTableWidth) {
-		// table is not in overflow -> normal resize of a single column
-		if (currentTableWidth === minTableWidth) {
-			return resizeState;
-		}
-		// table is in overflow: keep the dragged column at its widths and evenly distribute columns
-		// to recover from overflow state
-		else {
-			const columnWidth = Math.floor(
-				(minTableWidth - sourceCol.width) / (newState.cols.length - 1),
-			);
-			newState = {
-				...resizeState,
-				cols: newState.cols.map((col) => {
-					if (col.index === sourceCol.index) {
-						return col;
-					}
-
-					return { ...col, width: columnWidth };
-				}),
-			};
-		}
-	}
-
-	// fixes total table widths by adding missing pixels to columns widths here and there
-	return adjustColumnsWidths(newState, resizeState.maxSize);
-};
-
-// Get the layout
-const normaliseTableLayout = (input: string | undefined | null) => {
-	switch (input) {
-		case 'wide':
-			return input;
-		case 'full-width':
-			return input;
-		default:
-			return 'default';
-	}
-};
-
-export const getNewResizeStateFromSelectedColumns = (
-	rect: Rect,
-	state: EditorState,
-	domAtPos: (pos: number) => { node: Node; offset: number },
-	getEditorContainerWidth: GetEditorContainerWidth,
-	isTableScalingEnabled = false,
-	isTableFixedColumnWidthsOptionEnabled = false,
-	isCommentEditor = false,
-): ResizeStateWithAnalytics | undefined => {
-	// Fail early so that we don't do complex calculations for no reason
-	const numColumnsSelected = rect.right - rect.left;
-	if (numColumnsSelected <= 1) {
-		return;
-	}
-
-	const { totalRowCount, totalColumnCount, table } = getSelectedTableInfo(state.selection);
-
-	if (!table) {
-		return;
-	}
-
-	// Fail early so that we don't do complex calculations for no reason
-	if (!hasTableBeenResized(table.node)) {
-		return;
-	}
-
-	const maybeTable = domAtPos(table.start).node;
-
-	const maybeTableElement = maybeTable instanceof HTMLElement ? maybeTable : null;
-	const tableRef = maybeTableElement?.closest('table');
-
-	if (!tableRef) {
-		return;
-	}
-
-	const layout = normaliseTableLayout(tableRef?.dataset.layout);
-
-	const maxSize = getTableMaxWidth({
-		table: table.node,
-		tableStart: table.start,
-		state,
-		layout,
-		getEditorContainerWidth,
-	});
-
-	let isTableScalingEnabledOnCurrentTable = isTableScalingEnabled;
-	const isTableScalingWithFixedColumnWidthsOptionEnabled =
-		isTableScalingEnabled && isTableFixedColumnWidthsOptionEnabled;
-	if (isTableScalingWithFixedColumnWidthsOptionEnabled) {
-		isTableScalingEnabledOnCurrentTable = table.node.attrs.displayMode !== 'fixed';
-	}
-
-	let shouldUseIncreasedScalingPercent = isTableScalingWithFixedColumnWidthsOptionEnabled;
-
-	if (isTableScalingEnabled && isCommentEditor) {
-		isTableScalingEnabledOnCurrentTable = true;
-		shouldUseIncreasedScalingPercent = true;
-	}
-
-	const resizeState = getResizeState({
-		minWidth: tableCellMinWidth,
-		maxSize,
-		table: table.node,
-		tableRef,
-		start: table.start,
-		domAtPos,
-		isTableScalingEnabled: isTableScalingEnabledOnCurrentTable,
-		shouldUseIncreasedScalingPercent,
-		isCommentEditor,
-	});
-
-	const newResizeState = evenSelectedColumnsWidths(resizeState, rect);
-
-	const widthsBefore = resizeState.widths;
-	const widthsAfter = newResizeState.widths;
-
-	const changed = resizeState.widths.some(
-		(widthBefore, index) => widthBefore !== widthsAfter[index],
-	);
-
-	return {
-		resizeState: newResizeState,
-		table,
-		changed,
-		attributes: {
-			position: rect.left,
-			count: rect.right - rect.left,
-			totalRowCount,
-			totalColumnCount,
-			widthsBefore,
-			widthsAfter,
-		},
-	};
-};

package/src/pm-plugins/table-resizing/utils/scale-table.ts

@@ -1,290 +0,0 @@
-import { getTableContainerWidth } from '@atlaskit/editor-common/node-width';
-import { tableCellMinWidth } from '@atlaskit/editor-common/styles';
-import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-import type { DomAtPos } from '@atlaskit/editor-prosemirror/utils';
-import { akEditorTableNumberColumnWidth } from '@atlaskit/editor-shared-styles';
-import { fg } from '@atlaskit/platform-feature-flags';
-
-import type { PluginInjectionAPI } from '../../../types';
-import { updateColumnWidths } from '../../transforms/column-width';
-import { getTableWidth } from '../../utils/nodes';
-import { getLayoutSize } from '../utils/misc';
-import { reduceSpace } from '../utils/resize-logic';
-import {
-	adjustColumnsWidths,
-	getResizeState,
-	getTotalWidth,
-	updateColgroup,
-} from '../utils/resize-state';
-import type { ResizeState } from '../utils/types';
-
-import { hasTableBeenResized, insertColgroupFromNode } from './colgroup';
-import { syncStickyRowToTable } from './dom';
-
-interface ScaleOptions {
-	node: PMNode;
-	prevNode: PMNode;
-	start: number;
-	containerWidth?: number;
-	previousContainerWidth?: number;
-	parentWidth?: number;
-	layoutChanged?: boolean;
-	isFullWidthModeEnabled?: boolean;
-	isTableResizingEnabled?: boolean;
-}
-
-// Base function to trigger the actual scale on a table node.
-// Will only resize/scale if a table has been previously resized.
-const scale = (
-	tableRef: HTMLTableElement,
-	options: ScaleOptions,
-	domAtPos: DomAtPos,
-	isTableScalingEnabledOnCurrentTable = false,
-	shouldUseIncreasedScalingPercent = false,
-	isCommentEditor = false,
-): ResizeState | undefined => {
-	const {
-		node,
-		containerWidth,
-		previousContainerWidth,
-		prevNode,
-		start,
-		layoutChanged,
-		isTableResizingEnabled,
-	} = options;
-
-	const maxSize = isTableResizingEnabled
-		? getTableContainerWidth(node)
-		: getLayoutSize(node.attrs.layout, containerWidth, {});
-
-	const prevTableWidth = getTableWidth(prevNode);
-	const previousMaxSize = isTableResizingEnabled
-		? getTableContainerWidth(node)
-		: getLayoutSize(prevNode.attrs.layout, previousContainerWidth, {});
-
-	let newWidth = maxSize;
-
-	// adjust table width if layout is updated
-	const hasOverflow = prevTableWidth > previousMaxSize;
-
-	if (layoutChanged && hasOverflow) {
-		// No keep overflow if the old content can be in the new size
-		const canFitInNewSize = prevTableWidth < maxSize;
-		if (canFitInNewSize) {
-			newWidth = maxSize;
-		} else {
-			// Keep the same scale.
-			const overflowScale = prevTableWidth / previousMaxSize;
-			newWidth = Math.floor(newWidth * overflowScale);
-		}
-	}
-
-	if (node.attrs.isNumberColumnEnabled) {
-		newWidth -= akEditorTableNumberColumnWidth;
-	}
-
-	const resizeState = getResizeState({
-		minWidth: tableCellMinWidth,
-		maxSize,
-		table: node,
-		tableRef,
-		start,
-		domAtPos,
-		isTableScalingEnabled: isTableScalingEnabledOnCurrentTable,
-		shouldUseIncreasedScalingPercent,
-		isCommentEditor,
-	});
-
-	return scaleTableTo(resizeState, newWidth);
-};
-
-const scaleWithParent = (
-	tableRef: HTMLTableElement,
-	parentWidth: number,
-	table: PMNode,
-	start: number,
-	domAtPos: DomAtPos,
-	isTableScalingEnabledOnCurrentTable = false,
-	shouldUseIncreasedScalingPercent = false,
-	isCommentEditor = false,
-) => {
-	const resizeState = getResizeState({
-		minWidth: tableCellMinWidth,
-		maxSize: parentWidth,
-		table,
-		tableRef,
-		start,
-		domAtPos,
-		isTableScalingEnabled: isTableScalingEnabledOnCurrentTable,
-		shouldUseIncreasedScalingPercent,
-		isCommentEditor,
-	});
-
-	if (table.attrs.isNumberColumnEnabled) {
-		parentWidth -= akEditorTableNumberColumnWidth;
-	}
-
-	return scaleTableTo(resizeState, Math.floor(parentWidth));
-};
-
-// Scales the table to a given size and updates its colgroup DOM node
-export function scaleTableTo(state: ResizeState, maxSize: number): ResizeState {
-	const scaleFactor = maxSize / getTotalWidth(state);
-
-	let newState = {
-		...state,
-		maxSize,
-		cols: state.cols.map((col) => {
-			const { minWidth, width } = col;
-			let newColWidth = Math.floor(width * scaleFactor);
-			if (newColWidth < minWidth) {
-				newColWidth = minWidth;
-			}
-			return { ...col, width: newColWidth };
-		}),
-	};
-
-	const newTotalWidth = getTotalWidth(newState);
-	if (newTotalWidth > maxSize) {
-		newState = reduceSpace(newState, newTotalWidth - maxSize);
-	}
-
-	return adjustColumnsWidths(newState, maxSize);
-}
-
-export const previewScaleTable = (
-	tableRef: HTMLTableElement | null | undefined,
-	options: ScaleOptions,
-	domAtPos: DomAtPos,
-	isTableScalingEnabled: boolean = false,
-	isTableWithFixedColumnWidthsOptionEnabled: boolean = false,
-	isCommentEditor: boolean = false,
-) => {
-	const { node, start, parentWidth } = options;
-
-	if (!tableRef) {
-		return;
-	}
-
-	if (parentWidth) {
-		const isNumberColumnEnabled = node.attrs.isNumberColumnEnabled;
-		const width = isNumberColumnEnabled
-			? parentWidth - akEditorTableNumberColumnWidth
-			: parentWidth;
-		tableRef.style.width = `${width}px`;
-	}
-
-	let isTableScalingEnabledOnCurrentTable = isTableScalingEnabled;
-	const isTableScalingWithFixedColumnWidthsOptionEnabled =
-		isTableScalingEnabled && isTableWithFixedColumnWidthsOptionEnabled;
-
-	if (isTableScalingWithFixedColumnWidthsOptionEnabled) {
-		isTableScalingEnabledOnCurrentTable =
-			isTableScalingEnabled && node.attrs.displayMode !== 'fixed';
-	}
-	// If the table hasn't been resize, the colgroup 48px width values will gracefully scale down.
-	// If we are scaling the table down with isTableScalingEnabled, the colgroup widths may be scaled to a value that is not 48px.
-	if (!hasTableBeenResized(node) && !isTableScalingEnabledOnCurrentTable) {
-		syncStickyRowToTable(tableRef);
-		return;
-	}
-
-	const shouldUseIncreasedScalingPercent =
-		isTableScalingWithFixedColumnWidthsOptionEnabled || (isTableScalingEnabled && isCommentEditor);
-
-	const resizeState = parentWidth
-		? scaleWithParent(
-				tableRef,
-				parentWidth,
-				node,
-				start,
-				domAtPos,
-				false, // Here isTableScalingEnabled = false
-				shouldUseIncreasedScalingPercent,
-			)
-		: scale(tableRef, options, domAtPos, false, shouldUseIncreasedScalingPercent);
-
-	if (resizeState) {
-		updateColgroup(resizeState, tableRef, node, false, 1);
-	}
-};
-
-// Scale the table to meet new requirements (col, layout change etc)
-export const scaleTable =
-	(
-		tableRef: HTMLTableElement | null | undefined,
-		options: ScaleOptions,
-		domAtPos: DomAtPos,
-		api: PluginInjectionAPI | undefined | null,
-		isTableScalingEnabledOnCurrentTable = false,
-		shouldUseIncreasedScalingPercent = false,
-		isCommentEditor = false,
-	) =>
-	(tr: Transaction) => {
-		if (!tableRef) {
-			return tr;
-		}
-		const { node, start, parentWidth, layoutChanged } = options;
-		// If a table has not been resized yet, columns should be auto.
-		if (hasTableBeenResized(node) === false) {
-			// If its not a re-sized table, we still want to re-create cols
-			// To force reflow of columns upon delete.
-			if (!isTableScalingEnabledOnCurrentTable) {
-				const isTableScalingEnabled = false;
-				insertColgroupFromNode(
-					tableRef,
-					node,
-					isTableScalingEnabled,
-					undefined,
-					shouldUseIncreasedScalingPercent,
-					isCommentEditor,
-				);
-			}
-			tr.setMeta('scrollIntoView', false);
-			return tr;
-		}
-
-		let resizeState;
-		if (parentWidth) {
-			resizeState = scaleWithParent(
-				tableRef,
-				parentWidth,
-				node,
-				start,
-				domAtPos,
-				isTableScalingEnabledOnCurrentTable,
-				shouldUseIncreasedScalingPercent,
-			);
-		} else {
-			resizeState = scale(
-				tableRef,
-				options,
-				domAtPos,
-				isTableScalingEnabledOnCurrentTable,
-				shouldUseIncreasedScalingPercent,
-			);
-		}
-
-		if (resizeState) {
-			tr = updateColumnWidths(resizeState, node, start, api)(tr);
-
-			if (!fg('platform_editor_fix_table_resizing_undo')) {
-				tr.setMeta('addToHistory', false);
-			}
-
-			if (tr.docChanged) {
-				tr.setMeta('scrollIntoView', false);
-				// TODO: ED-8995 - We need to do this check to reduce the number of race conditions when working with tables.
-				// This metadata is been used in the sendTransaction function in the Collab plugin
-				/* Added !layoutChanged check here to solve unnecessary scroll bar after publish when click on breakout button multiple times and publish
-           scaleTable is only called once every time a breakout button is clicked, so it is safe not to add the meta 'scaleTable' to the tr.
-           Leaving the tr.setMeta('scaleTable', true) here for race conditions that we aren't aware of.
-         */
-				!layoutChanged && tr.setMeta('scaleTable', true);
-				return tr;
-			}
-		}
-
-		return tr;
-	};