@atlaskit/editor-plugin-show-diff 3.2.0 → 3.2.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 3.2.1
+
+### Patch Changes
+
+- [`da2782d8dc1e7`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/da2782d8dc1e7) -
+  Support table row diff displaying in the editor
+
 ## 3.2.0
 
 ### Minor Changes

package/afm-cc/tsconfig.json

@@ -17,6 +17,9 @@
 		"../src/**/examples.*"
 	],
 	"references": [
+		{
+			"path": "../../editor-tables/afm-cc/tsconfig.json"
+		},
 		{
 			"path": "../../../platform/feature-flags/afm-cc/tsconfig.json"
 		},

package/dist/cjs/pm-plugins/calculateDiffDecorations.js

@@ -106,6 +106,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
   var tr = state.tr;
   var steppedDoc = originalDoc;
   var stepMaps = [];
+  var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc);
   var _iterator = _createForOfIteratorHelper(steps),
     _step;
   try {
@@ -115,6 +116,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
       if (result.failed === null && result.doc) {
         steppedDoc = result.doc;
         stepMaps.push(step.getMap());
+        changeset = changeset.addSteps(steppedDoc, [step.getMap()], step);
       }
     }
 
@@ -128,7 +130,6 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
   if (!(0, _document.areNodesEqualIgnoreAttrs)(steppedDoc, tr.doc)) {
     return _view.DecorationSet.empty;
   }
-  var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, tr.doc);
   var changes = (0, _prosemirrorChangeset.simplifyChanges)(changeset.changes, tr.doc);
   var optimizedChanges = optimizeChanges(changes);
   var decorations = [];
@@ -147,7 +148,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
         intl: intl
       });
       if (decoration) {
-        decorations.push(decoration);
+        decorations.push.apply(decorations, (0, _toConsumableArray2.default)(decoration));
       }
     }
   });

package/dist/cjs/pm-plugins/decorations.js

@@ -8,6 +8,7 @@ var _lazyNodeView = require("@atlaskit/editor-common/lazy-node-view");
 var _messages = require("@atlaskit/editor-common/messages");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _deletedRowsHandler = require("./deletedRowsHandler");
 var _findSafeInsertPos = require("./findSafeInsertPos");
 var editingStyle = (0, _lazyNodeView.convertToInlineCss)({
   background: "var(--ds-background-accent-purple-subtlest, #F3F0FF)",
@@ -360,14 +361,27 @@ var createDeletedContentDecoration = exports.createDeletedContentDecoration = fu
   if (slice.content.content.length === 0) {
     return;
   }
-  var isTableContent = slice.content.content.some(function () {
+  var isTableCellContent = slice.content.content.some(function () {
     return slice.content.content.some(function (siblingNode) {
-      return ['tableHeader', 'tableCell', 'tableRow'].includes(siblingNode.type.name);
+      return ['tableHeader', 'tableCell'].includes(siblingNode.type.name);
     });
   });
-  if (isTableContent) {
+  var isTableRowContent = slice.content.content.some(function () {
+    return slice.content.content.some(function (siblingNode) {
+      return ['tableRow'].includes(siblingNode.type.name);
+    });
+  });
+  if (isTableCellContent) {
     return;
   }
+  if (isTableRowContent) {
+    if (!(0, _platformFeatureFlags.fg)('platform_editor_ai_aifc_patch_ga')) {
+      return;
+    }
+    var _handleDeletedRows = (0, _deletedRowsHandler.handleDeletedRows)([change], doc, newDoc, nodeViewSerializer, colourScheme),
+      decorations = _handleDeletedRows.decorations;
+    return decorations;
+  }
   var serializer = nodeViewSerializer;
 
   // For non-table content, use the existing span wrapper approach
@@ -502,5 +516,5 @@ var createDeletedContentDecoration = exports.createDeletedContentDecoration = fu
   // Widget decoration used for deletions as the content is not in the document
   // and we want to display the deleted content with a style.
   var safeInsertPos = (0, _findSafeInsertPos.findSafeInsertPos)(newDoc, change.fromB, slice);
-  return _view.Decoration.widget(safeInsertPos, dom);
+  return [_view.Decoration.widget(safeInsertPos, dom)];
 };

package/dist/cjs/pm-plugins/deletedRowsHandler.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleDeletedRows = exports.createDeletedRowsDecorations = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _lazyNodeView = require("@atlaskit/editor-common/lazy-node-view");
+var _document = require("@atlaskit/editor-common/utils/document");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var _tableMap = require("@atlaskit/editor-tables/table-map");
+var _findSafeInsertPos = require("./findSafeInsertPos");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+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; }
+var deletedRowStyle = (0, _lazyNodeView.convertToInlineCss)({
+  color: "var(--ds-text-accent-gray, #44546F)",
+  textDecoration: 'line-through',
+  opacity: 0.6,
+  display: 'table-row'
+});
+var deletedTraditionalRowStyle = (0, _lazyNodeView.convertToInlineCss)({
+  textDecorationColor: "var(--ds-border-accent-red, #E2483D)",
+  textDecoration: 'line-through',
+  opacity: 0.6,
+  display: 'table-row'
+});
+/**
+ * Extracts information about deleted table rows from a change
+ */
+var extractDeletedRows = function extractDeletedRows(change, originalDoc, newDoc) {
+  var deletedRows = [];
+
+  // Find the table in the original document
+  var $fromPos = originalDoc.resolve(change.fromA);
+  var tableOld = (0, _utils.findParentNodeClosestToPos)($fromPos, function (node) {
+    return node.type.name === 'table';
+  });
+  if (!tableOld) {
+    return deletedRows;
+  }
+  var oldTableMap = _tableMap.TableMap.get(tableOld.node);
+
+  // Find the table in the new document at the insertion point
+  var $newPos = newDoc.resolve(change.fromB);
+  var tableNew = (0, _utils.findParentNodeClosestToPos)($newPos, function (node) {
+    return node.type.name === 'table';
+  });
+  if (!tableNew) {
+    return deletedRows;
+  }
+  var newTableMap = _tableMap.TableMap.get(tableNew.node);
+
+  // If no rows were deleted, return empty
+  if (oldTableMap.height <= newTableMap.height ||
+  // For now ignore if there are column deletions as well
+  oldTableMap.width !== newTableMap.width) {
+    return deletedRows;
+  }
+
+  // Find which rows were deleted by analyzing the change range
+  var changeStartInTable = change.fromA - tableOld.pos - 1;
+  var changeEndInTable = change.toA - tableOld.pos - 1;
+  var currentOffset = 0;
+  var rowIndex = 0;
+  tableOld.node.content.forEach(function (rowNode, index) {
+    var rowStart = currentOffset;
+    var rowEnd = currentOffset + rowNode.nodeSize;
+
+    // Check if this row overlaps with the deletion range
+    var rowOverlapsChange = rowStart >= changeStartInTable && rowStart < changeEndInTable || rowEnd > changeStartInTable && rowEnd <= changeEndInTable || rowStart < changeStartInTable && rowEnd > changeEndInTable;
+    if (rowOverlapsChange && rowNode.type.name === 'tableRow' && !isEmptyRow(rowNode)) {
+      var startOfRow = newTableMap.mapByRow.slice().reverse().find(function (row) {
+        return row[0] + tableNew.pos < change.fromB && change.fromB < row[row.length - 1] + tableNew.pos;
+      });
+      deletedRows.push({
+        rowIndex: rowIndex,
+        rowNode: rowNode,
+        fromA: tableOld.pos + 1 + rowStart,
+        toA: tableOld.pos + 1 + rowEnd,
+        fromB: startOfRow ? startOfRow[0] + tableNew.start : change.fromB
+      });
+    }
+    currentOffset += rowNode.nodeSize;
+    if (rowNode.type.name === 'tableRow') {
+      rowIndex++;
+    }
+  });
+
+  // Filter changes that never truly got deleted
+  return deletedRows.filter(function (deletedRow) {
+    return !tableNew.node.children.some(function (newRow) {
+      return (0, _document.areNodesEqualIgnoreAttrs)(newRow, deletedRow.rowNode);
+    });
+  });
+};
+
+/**
+ * Checks if a table row is empty (contains no meaningful content)
+ */
+var isEmptyRow = function isEmptyRow(rowNode) {
+  var isEmpty = true;
+  rowNode.descendants(function (node) {
+    if (!isEmpty) {
+      return false;
+    }
+
+    // If we find any inline content with size > 0, the row is not empty
+    if (node.isInline && node.nodeSize > 0) {
+      isEmpty = false;
+      return false;
+    }
+
+    // If we find text content, the row is not empty
+    if (node.isText && node.text && node.text.trim() !== '') {
+      isEmpty = false;
+      return false;
+    }
+    return true;
+  });
+  return isEmpty;
+};
+
+/**
+ * Creates a DOM representation of a deleted table row
+ */
+var createDeletedRowDOM = function createDeletedRowDOM(rowNode, nodeViewSerializer, colourScheme) {
+  var tr = document.createElement('tr');
+  tr.setAttribute('style', colourScheme === 'traditional' ? deletedTraditionalRowStyle : deletedRowStyle);
+  tr.setAttribute('data-testid', 'show-diff-deleted-row');
+
+  // Serialize each cell in the row
+  rowNode.content.forEach(function (cellNode) {
+    if (cellNode.type.name === 'tableCell' || cellNode.type.name === 'tableHeader') {
+      var nodeView = nodeViewSerializer.tryCreateNodeView(cellNode);
+      if (nodeView) {
+        tr.appendChild(nodeView);
+      } else {
+        // Fallback to fragment serialization
+        var serializedContent = nodeViewSerializer.serializeFragment(cellNode.content);
+        if (serializedContent) {
+          tr.appendChild(serializedContent);
+        }
+      }
+    }
+  });
+  return tr;
+};
+
+/**
+ * Expands a diff to include whole deleted rows when table rows are affected
+ */
+var expandDiffForDeletedRows = function expandDiffForDeletedRows(changes, originalDoc, newDoc) {
+  var deletedRowInfo = [];
+  var _iterator = _createForOfIteratorHelper(changes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var change = _step.value;
+      // Check if this change affects table content
+      var deletedRows = extractDeletedRows(change, originalDoc, newDoc);
+      if (deletedRows.length > 0) {
+        deletedRowInfo.push.apply(deletedRowInfo, (0, _toConsumableArray2.default)(deletedRows));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return deletedRowInfo;
+};
+
+/**
+ * Creates decorations for deleted table rows
+ */
+var createDeletedRowsDecorations = exports.createDeletedRowsDecorations = function createDeletedRowsDecorations(_ref) {
+  var deletedRows = _ref.deletedRows,
+    originalDoc = _ref.originalDoc,
+    newDoc = _ref.newDoc,
+    nodeViewSerializer = _ref.nodeViewSerializer,
+    colourScheme = _ref.colourScheme;
+  return deletedRows.map(function (deletedRow) {
+    var rowDOM = createDeletedRowDOM(deletedRow.rowNode, nodeViewSerializer, colourScheme);
+
+    // Find safe insertion position for the deleted row
+    var safeInsertPos = (0, _findSafeInsertPos.findSafeInsertPos)(newDoc, deletedRow.fromB - 1,
+    // -1 to find the first safe position from the table
+    originalDoc.slice(deletedRow.fromA, deletedRow.toA));
+    return _view.Decoration.widget(safeInsertPos, rowDOM, {});
+  });
+};
+
+/**
+ * Main function to handle deleted rows - computes diff and creates decorations
+ */
+var handleDeletedRows = exports.handleDeletedRows = function handleDeletedRows(changes, originalDoc, newDoc, nodeViewSerializer, colourScheme) {
+  // First, expand the changes to include complete deleted rows
+  var deletedRows = expandDiffForDeletedRows(changes.filter(function (change) {
+    return change.deleted.length > 0;
+  }), originalDoc, newDoc);
+  var allDecorations = createDeletedRowsDecorations({
+    deletedRows: deletedRows,
+    originalDoc: originalDoc,
+    newDoc: newDoc,
+    nodeViewSerializer: nodeViewSerializer,
+    colourScheme: colourScheme
+  });
+  return {
+    decorations: allDecorations
+  };
+};

package/dist/es2019/pm-plugins/calculateDiffDecorations.js

@@ -99,11 +99,13 @@ const calculateDiffDecorationsInner = ({
   } = state;
   let steppedDoc = originalDoc;
   const stepMaps = [];
+  let changeset = ChangeSet.create(originalDoc);
   for (const step of steps) {
     const result = step.apply(steppedDoc);
     if (result.failed === null && result.doc) {
       steppedDoc = result.doc;
       stepMaps.push(step.getMap());
+      changeset = changeset.addSteps(steppedDoc, [step.getMap()], step);
     }
   }
 
@@ -112,7 +114,6 @@ const calculateDiffDecorationsInner = ({
   if (!areNodesEqualIgnoreAttrs(steppedDoc, tr.doc)) {
     return DecorationSet.empty;
   }
-  const changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, tr.doc);
   const changes = simplifyChanges(changeset.changes, tr.doc);
   const optimizedChanges = optimizeChanges(changes);
   const decorations = [];
@@ -131,7 +132,7 @@ const calculateDiffDecorationsInner = ({
         intl
       });
       if (decoration) {
-        decorations.push(decoration);
+        decorations.push(...decoration);
       }
     }
   });

package/dist/es2019/pm-plugins/decorations.js

@@ -2,6 +2,7 @@ import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { trackChangesMessages } from '@atlaskit/editor-common/messages';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { handleDeletedRows } from './deletedRowsHandler';
 import { findSafeInsertPos } from './findSafeInsertPos';
 const editingStyle = convertToInlineCss({
   background: "var(--ds-background-accent-purple-subtlest, #F3F0FF)",
@@ -347,10 +348,20 @@ export const createDeletedContentDecoration = ({
   if (slice.content.content.length === 0) {
     return;
   }
-  const isTableContent = slice.content.content.some(() => slice.content.content.some(siblingNode => ['tableHeader', 'tableCell', 'tableRow'].includes(siblingNode.type.name)));
-  if (isTableContent) {
+  const isTableCellContent = slice.content.content.some(() => slice.content.content.some(siblingNode => ['tableHeader', 'tableCell'].includes(siblingNode.type.name)));
+  const isTableRowContent = slice.content.content.some(() => slice.content.content.some(siblingNode => ['tableRow'].includes(siblingNode.type.name)));
+  if (isTableCellContent) {
     return;
   }
+  if (isTableRowContent) {
+    if (!fg('platform_editor_ai_aifc_patch_ga')) {
+      return;
+    }
+    const {
+      decorations
+    } = handleDeletedRows([change], doc, newDoc, nodeViewSerializer, colourScheme);
+    return decorations;
+  }
   const serializer = nodeViewSerializer;
 
   // For non-table content, use the existing span wrapper approach
@@ -481,5 +492,5 @@ export const createDeletedContentDecoration = ({
   // Widget decoration used for deletions as the content is not in the document
   // and we want to display the deleted content with a style.
   const safeInsertPos = findSafeInsertPos(newDoc, change.fromB, slice);
-  return Decoration.widget(safeInsertPos, dom);
+  return [Decoration.widget(safeInsertPos, dom)];
 };

package/dist/es2019/pm-plugins/deletedRowsHandler.js

@@ -0,0 +1,185 @@
+import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
+import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findSafeInsertPos } from './findSafeInsertPos';
+const deletedRowStyle = convertToInlineCss({
+  color: "var(--ds-text-accent-gray, #44546F)",
+  textDecoration: 'line-through',
+  opacity: 0.6,
+  display: 'table-row'
+});
+const deletedTraditionalRowStyle = convertToInlineCss({
+  textDecorationColor: "var(--ds-border-accent-red, #E2483D)",
+  textDecoration: 'line-through',
+  opacity: 0.6,
+  display: 'table-row'
+});
+/**
+ * Extracts information about deleted table rows from a change
+ */
+const extractDeletedRows = (change, originalDoc, newDoc) => {
+  const deletedRows = [];
+
+  // Find the table in the original document
+  const $fromPos = originalDoc.resolve(change.fromA);
+  const tableOld = findParentNodeClosestToPos($fromPos, node => node.type.name === 'table');
+  if (!tableOld) {
+    return deletedRows;
+  }
+  const oldTableMap = TableMap.get(tableOld.node);
+
+  // Find the table in the new document at the insertion point
+  const $newPos = newDoc.resolve(change.fromB);
+  const tableNew = findParentNodeClosestToPos($newPos, node => node.type.name === 'table');
+  if (!tableNew) {
+    return deletedRows;
+  }
+  const newTableMap = TableMap.get(tableNew.node);
+
+  // If no rows were deleted, return empty
+  if (oldTableMap.height <= newTableMap.height ||
+  // For now ignore if there are column deletions as well
+  oldTableMap.width !== newTableMap.width) {
+    return deletedRows;
+  }
+
+  // Find which rows were deleted by analyzing the change range
+  const changeStartInTable = change.fromA - tableOld.pos - 1;
+  const changeEndInTable = change.toA - tableOld.pos - 1;
+  let currentOffset = 0;
+  let rowIndex = 0;
+  tableOld.node.content.forEach((rowNode, index) => {
+    const rowStart = currentOffset;
+    const rowEnd = currentOffset + rowNode.nodeSize;
+
+    // Check if this row overlaps with the deletion range
+    const rowOverlapsChange = rowStart >= changeStartInTable && rowStart < changeEndInTable || rowEnd > changeStartInTable && rowEnd <= changeEndInTable || rowStart < changeStartInTable && rowEnd > changeEndInTable;
+    if (rowOverlapsChange && rowNode.type.name === 'tableRow' && !isEmptyRow(rowNode)) {
+      const startOfRow = newTableMap.mapByRow.slice().reverse().find(row => row[0] + tableNew.pos < change.fromB && change.fromB < row[row.length - 1] + tableNew.pos);
+      deletedRows.push({
+        rowIndex,
+        rowNode,
+        fromA: tableOld.pos + 1 + rowStart,
+        toA: tableOld.pos + 1 + rowEnd,
+        fromB: startOfRow ? startOfRow[0] + tableNew.start : change.fromB
+      });
+    }
+    currentOffset += rowNode.nodeSize;
+    if (rowNode.type.name === 'tableRow') {
+      rowIndex++;
+    }
+  });
+
+  // Filter changes that never truly got deleted
+  return deletedRows.filter(deletedRow => {
+    return !tableNew.node.children.some(newRow => areNodesEqualIgnoreAttrs(newRow, deletedRow.rowNode));
+  });
+};
+
+/**
+ * Checks if a table row is empty (contains no meaningful content)
+ */
+const isEmptyRow = rowNode => {
+  let isEmpty = true;
+  rowNode.descendants(node => {
+    if (!isEmpty) {
+      return false;
+    }
+
+    // If we find any inline content with size > 0, the row is not empty
+    if (node.isInline && node.nodeSize > 0) {
+      isEmpty = false;
+      return false;
+    }
+
+    // If we find text content, the row is not empty
+    if (node.isText && node.text && node.text.trim() !== '') {
+      isEmpty = false;
+      return false;
+    }
+    return true;
+  });
+  return isEmpty;
+};
+
+/**
+ * Creates a DOM representation of a deleted table row
+ */
+const createDeletedRowDOM = (rowNode, nodeViewSerializer, colourScheme) => {
+  const tr = document.createElement('tr');
+  tr.setAttribute('style', colourScheme === 'traditional' ? deletedTraditionalRowStyle : deletedRowStyle);
+  tr.setAttribute('data-testid', 'show-diff-deleted-row');
+
+  // Serialize each cell in the row
+  rowNode.content.forEach(cellNode => {
+    if (cellNode.type.name === 'tableCell' || cellNode.type.name === 'tableHeader') {
+      const nodeView = nodeViewSerializer.tryCreateNodeView(cellNode);
+      if (nodeView) {
+        tr.appendChild(nodeView);
+      } else {
+        // Fallback to fragment serialization
+        const serializedContent = nodeViewSerializer.serializeFragment(cellNode.content);
+        if (serializedContent) {
+          tr.appendChild(serializedContent);
+        }
+      }
+    }
+  });
+  return tr;
+};
+
+/**
+ * Expands a diff to include whole deleted rows when table rows are affected
+ */
+const expandDiffForDeletedRows = (changes, originalDoc, newDoc) => {
+  const deletedRowInfo = [];
+  for (const change of changes) {
+    // Check if this change affects table content
+    const deletedRows = extractDeletedRows(change, originalDoc, newDoc);
+    if (deletedRows.length > 0) {
+      deletedRowInfo.push(...deletedRows);
+    }
+  }
+  return deletedRowInfo;
+};
+
+/**
+ * Creates decorations for deleted table rows
+ */
+export const createDeletedRowsDecorations = ({
+  deletedRows,
+  originalDoc,
+  newDoc,
+  nodeViewSerializer,
+  colourScheme
+}) => {
+  return deletedRows.map(deletedRow => {
+    const rowDOM = createDeletedRowDOM(deletedRow.rowNode, nodeViewSerializer, colourScheme);
+
+    // Find safe insertion position for the deleted row
+    const safeInsertPos = findSafeInsertPos(newDoc, deletedRow.fromB - 1,
+    // -1 to find the first safe position from the table
+    originalDoc.slice(deletedRow.fromA, deletedRow.toA));
+    return Decoration.widget(safeInsertPos, rowDOM, {});
+  });
+};
+
+/**
+ * Main function to handle deleted rows - computes diff and creates decorations
+ */
+export const handleDeletedRows = (changes, originalDoc, newDoc, nodeViewSerializer, colourScheme) => {
+  // First, expand the changes to include complete deleted rows
+  const deletedRows = expandDiffForDeletedRows(changes.filter(change => change.deleted.length > 0), originalDoc, newDoc);
+  const allDecorations = createDeletedRowsDecorations({
+    deletedRows,
+    originalDoc,
+    newDoc,
+    nodeViewSerializer,
+    colourScheme
+  });
+  return {
+    decorations: allDecorations
+  };
+};

package/dist/esm/pm-plugins/calculateDiffDecorations.js

@@ -100,6 +100,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
   var tr = state.tr;
   var steppedDoc = originalDoc;
   var stepMaps = [];
+  var changeset = ChangeSet.create(originalDoc);
   var _iterator = _createForOfIteratorHelper(steps),
     _step;
   try {
@@ -109,6 +110,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
       if (result.failed === null && result.doc) {
         steppedDoc = result.doc;
         stepMaps.push(step.getMap());
+        changeset = changeset.addSteps(steppedDoc, [step.getMap()], step);
       }
     }
 
@@ -122,7 +124,6 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
   if (!areNodesEqualIgnoreAttrs(steppedDoc, tr.doc)) {
     return DecorationSet.empty;
   }
-  var changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, tr.doc);
   var changes = simplifyChanges(changeset.changes, tr.doc);
   var optimizedChanges = optimizeChanges(changes);
   var decorations = [];
@@ -141,7 +142,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref)
         intl: intl
       });
       if (decoration) {
-        decorations.push(decoration);
+        decorations.push.apply(decorations, _toConsumableArray(decoration));
       }
     }
   });

package/dist/esm/pm-plugins/decorations.js

@@ -2,6 +2,7 @@ import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { trackChangesMessages } from '@atlaskit/editor-common/messages';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { handleDeletedRows } from './deletedRowsHandler';
 import { findSafeInsertPos } from './findSafeInsertPos';
 var editingStyle = convertToInlineCss({
   background: "var(--ds-background-accent-purple-subtlest, #F3F0FF)",
@@ -354,14 +355,27 @@ export var createDeletedContentDecoration = function createDeletedContentDecorat
   if (slice.content.content.length === 0) {
     return;
   }
-  var isTableContent = slice.content.content.some(function () {
+  var isTableCellContent = slice.content.content.some(function () {
     return slice.content.content.some(function (siblingNode) {
-      return ['tableHeader', 'tableCell', 'tableRow'].includes(siblingNode.type.name);
+      return ['tableHeader', 'tableCell'].includes(siblingNode.type.name);
     });
   });
-  if (isTableContent) {
+  var isTableRowContent = slice.content.content.some(function () {
+    return slice.content.content.some(function (siblingNode) {
+      return ['tableRow'].includes(siblingNode.type.name);
+    });
+  });
+  if (isTableCellContent) {
     return;
   }
+  if (isTableRowContent) {
+    if (!fg('platform_editor_ai_aifc_patch_ga')) {
+      return;
+    }
+    var _handleDeletedRows = handleDeletedRows([change], doc, newDoc, nodeViewSerializer, colourScheme),
+      decorations = _handleDeletedRows.decorations;
+    return decorations;
+  }
   var serializer = nodeViewSerializer;
 
   // For non-table content, use the existing span wrapper approach
@@ -496,5 +510,5 @@ export var createDeletedContentDecoration = function createDeletedContentDecorat
   // Widget decoration used for deletions as the content is not in the document
   // and we want to display the deleted content with a style.
   var safeInsertPos = findSafeInsertPos(newDoc, change.fromB, slice);
-  return Decoration.widget(safeInsertPos, dom);
+  return [Decoration.widget(safeInsertPos, dom)];
 };

package/dist/esm/pm-plugins/deletedRowsHandler.js

@@ -0,0 +1,207 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+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; }
+import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
+import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findSafeInsertPos } from './findSafeInsertPos';
+var deletedRowStyle = convertToInlineCss({
+  color: "var(--ds-text-accent-gray, #44546F)",
+  textDecoration: 'line-through',
+  opacity: 0.6,
+  display: 'table-row'
+});
+var deletedTraditionalRowStyle = convertToInlineCss({
+  textDecorationColor: "var(--ds-border-accent-red, #E2483D)",
+  textDecoration: 'line-through',
+  opacity: 0.6,
+  display: 'table-row'
+});
+/**
+ * Extracts information about deleted table rows from a change
+ */
+var extractDeletedRows = function extractDeletedRows(change, originalDoc, newDoc) {
+  var deletedRows = [];
+
+  // Find the table in the original document
+  var $fromPos = originalDoc.resolve(change.fromA);
+  var tableOld = findParentNodeClosestToPos($fromPos, function (node) {
+    return node.type.name === 'table';
+  });
+  if (!tableOld) {
+    return deletedRows;
+  }
+  var oldTableMap = TableMap.get(tableOld.node);
+
+  // Find the table in the new document at the insertion point
+  var $newPos = newDoc.resolve(change.fromB);
+  var tableNew = findParentNodeClosestToPos($newPos, function (node) {
+    return node.type.name === 'table';
+  });
+  if (!tableNew) {
+    return deletedRows;
+  }
+  var newTableMap = TableMap.get(tableNew.node);
+
+  // If no rows were deleted, return empty
+  if (oldTableMap.height <= newTableMap.height ||
+  // For now ignore if there are column deletions as well
+  oldTableMap.width !== newTableMap.width) {
+    return deletedRows;
+  }
+
+  // Find which rows were deleted by analyzing the change range
+  var changeStartInTable = change.fromA - tableOld.pos - 1;
+  var changeEndInTable = change.toA - tableOld.pos - 1;
+  var currentOffset = 0;
+  var rowIndex = 0;
+  tableOld.node.content.forEach(function (rowNode, index) {
+    var rowStart = currentOffset;
+    var rowEnd = currentOffset + rowNode.nodeSize;
+
+    // Check if this row overlaps with the deletion range
+    var rowOverlapsChange = rowStart >= changeStartInTable && rowStart < changeEndInTable || rowEnd > changeStartInTable && rowEnd <= changeEndInTable || rowStart < changeStartInTable && rowEnd > changeEndInTable;
+    if (rowOverlapsChange && rowNode.type.name === 'tableRow' && !isEmptyRow(rowNode)) {
+      var startOfRow = newTableMap.mapByRow.slice().reverse().find(function (row) {
+        return row[0] + tableNew.pos < change.fromB && change.fromB < row[row.length - 1] + tableNew.pos;
+      });
+      deletedRows.push({
+        rowIndex: rowIndex,
+        rowNode: rowNode,
+        fromA: tableOld.pos + 1 + rowStart,
+        toA: tableOld.pos + 1 + rowEnd,
+        fromB: startOfRow ? startOfRow[0] + tableNew.start : change.fromB
+      });
+    }
+    currentOffset += rowNode.nodeSize;
+    if (rowNode.type.name === 'tableRow') {
+      rowIndex++;
+    }
+  });
+
+  // Filter changes that never truly got deleted
+  return deletedRows.filter(function (deletedRow) {
+    return !tableNew.node.children.some(function (newRow) {
+      return areNodesEqualIgnoreAttrs(newRow, deletedRow.rowNode);
+    });
+  });
+};
+
+/**
+ * Checks if a table row is empty (contains no meaningful content)
+ */
+var isEmptyRow = function isEmptyRow(rowNode) {
+  var isEmpty = true;
+  rowNode.descendants(function (node) {
+    if (!isEmpty) {
+      return false;
+    }
+
+    // If we find any inline content with size > 0, the row is not empty
+    if (node.isInline && node.nodeSize > 0) {
+      isEmpty = false;
+      return false;
+    }
+
+    // If we find text content, the row is not empty
+    if (node.isText && node.text && node.text.trim() !== '') {
+      isEmpty = false;
+      return false;
+    }
+    return true;
+  });
+  return isEmpty;
+};
+
+/**
+ * Creates a DOM representation of a deleted table row
+ */
+var createDeletedRowDOM = function createDeletedRowDOM(rowNode, nodeViewSerializer, colourScheme) {
+  var tr = document.createElement('tr');
+  tr.setAttribute('style', colourScheme === 'traditional' ? deletedTraditionalRowStyle : deletedRowStyle);
+  tr.setAttribute('data-testid', 'show-diff-deleted-row');
+
+  // Serialize each cell in the row
+  rowNode.content.forEach(function (cellNode) {
+    if (cellNode.type.name === 'tableCell' || cellNode.type.name === 'tableHeader') {
+      var nodeView = nodeViewSerializer.tryCreateNodeView(cellNode);
+      if (nodeView) {
+        tr.appendChild(nodeView);
+      } else {
+        // Fallback to fragment serialization
+        var serializedContent = nodeViewSerializer.serializeFragment(cellNode.content);
+        if (serializedContent) {
+          tr.appendChild(serializedContent);
+        }
+      }
+    }
+  });
+  return tr;
+};
+
+/**
+ * Expands a diff to include whole deleted rows when table rows are affected
+ */
+var expandDiffForDeletedRows = function expandDiffForDeletedRows(changes, originalDoc, newDoc) {
+  var deletedRowInfo = [];
+  var _iterator = _createForOfIteratorHelper(changes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var change = _step.value;
+      // Check if this change affects table content
+      var deletedRows = extractDeletedRows(change, originalDoc, newDoc);
+      if (deletedRows.length > 0) {
+        deletedRowInfo.push.apply(deletedRowInfo, _toConsumableArray(deletedRows));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return deletedRowInfo;
+};
+
+/**
+ * Creates decorations for deleted table rows
+ */
+export var createDeletedRowsDecorations = function createDeletedRowsDecorations(_ref) {
+  var deletedRows = _ref.deletedRows,
+    originalDoc = _ref.originalDoc,
+    newDoc = _ref.newDoc,
+    nodeViewSerializer = _ref.nodeViewSerializer,
+    colourScheme = _ref.colourScheme;
+  return deletedRows.map(function (deletedRow) {
+    var rowDOM = createDeletedRowDOM(deletedRow.rowNode, nodeViewSerializer, colourScheme);
+
+    // Find safe insertion position for the deleted row
+    var safeInsertPos = findSafeInsertPos(newDoc, deletedRow.fromB - 1,
+    // -1 to find the first safe position from the table
+    originalDoc.slice(deletedRow.fromA, deletedRow.toA));
+    return Decoration.widget(safeInsertPos, rowDOM, {});
+  });
+};
+
+/**
+ * Main function to handle deleted rows - computes diff and creates decorations
+ */
+export var handleDeletedRows = function handleDeletedRows(changes, originalDoc, newDoc, nodeViewSerializer, colourScheme) {
+  // First, expand the changes to include complete deleted rows
+  var deletedRows = expandDiffForDeletedRows(changes.filter(function (change) {
+    return change.deleted.length > 0;
+  }), originalDoc, newDoc);
+  var allDecorations = createDeletedRowsDecorations({
+    deletedRows: deletedRows,
+    originalDoc: originalDoc,
+    newDoc: newDoc,
+    nodeViewSerializer: nodeViewSerializer,
+    colourScheme: colourScheme
+  });
+  return {
+    decorations: allDecorations
+  };
+};

package/dist/types/pm-plugins/decorations.d.ts

@@ -25,12 +25,12 @@ export declare const createBlockChangedDecoration: (change: {
     to: number;
 }, colourScheme?: "standard" | "traditional") => Decoration;
 interface DeletedContentDecorationProps {
-    change: Change;
+    change: Pick<Change, 'fromA' | 'toA' | 'fromB' | 'deleted'>;
     colourScheme?: 'standard' | 'traditional';
     doc: PMNode;
     intl: IntlShape;
     newDoc: PMNode;
     nodeViewSerializer: NodeViewSerializer;
 }
-export declare const createDeletedContentDecoration: ({ change, doc, nodeViewSerializer, colourScheme, newDoc, intl, }: DeletedContentDecorationProps) => Decoration | undefined;
+export declare const createDeletedContentDecoration: ({ change, doc, nodeViewSerializer, colourScheme, newDoc, intl, }: DeletedContentDecorationProps) => Decoration[] | undefined;
 export {};

package/dist/types/pm-plugins/deletedRowsHandler.d.ts

@@ -0,0 +1,30 @@
+import type { Change } from 'prosemirror-changeset';
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { NodeViewSerializer } from './NodeViewSerializer';
+interface DeletedRowInfo {
+    fromA: number;
+    fromB: number;
+    rowIndex: number;
+    rowNode: PMNode;
+    toA: number;
+}
+type SimpleChange = Pick<Change, 'fromA' | 'toA' | 'fromB' | 'deleted'>;
+interface DeletedRowsHandlerProps {
+    colourScheme?: 'standard' | 'traditional';
+    deletedRows: DeletedRowInfo[];
+    newDoc: PMNode;
+    nodeViewSerializer: NodeViewSerializer;
+    originalDoc: PMNode;
+}
+/**
+ * Creates decorations for deleted table rows
+ */
+export declare const createDeletedRowsDecorations: ({ deletedRows, originalDoc, newDoc, nodeViewSerializer, colourScheme, }: DeletedRowsHandlerProps) => Decoration[];
+/**
+ * Main function to handle deleted rows - computes diff and creates decorations
+ */
+export declare const handleDeletedRows: (changes: SimpleChange[], originalDoc: PMNode, newDoc: PMNode, nodeViewSerializer: NodeViewSerializer, colourScheme?: "standard" | "traditional") => {
+    decorations: Decoration[];
+};
+export {};

package/dist/types-ts4.5/pm-plugins/decorations.d.ts

@@ -25,12 +25,12 @@ export declare const createBlockChangedDecoration: (change: {
     to: number;
 }, colourScheme?: "standard" | "traditional") => Decoration;
 interface DeletedContentDecorationProps {
-    change: Change;
+    change: Pick<Change, 'fromA' | 'toA' | 'fromB' | 'deleted'>;
     colourScheme?: 'standard' | 'traditional';
     doc: PMNode;
     intl: IntlShape;
     newDoc: PMNode;
     nodeViewSerializer: NodeViewSerializer;
 }
-export declare const createDeletedContentDecoration: ({ change, doc, nodeViewSerializer, colourScheme, newDoc, intl, }: DeletedContentDecorationProps) => Decoration | undefined;
+export declare const createDeletedContentDecoration: ({ change, doc, nodeViewSerializer, colourScheme, newDoc, intl, }: DeletedContentDecorationProps) => Decoration[] | undefined;
 export {};

package/dist/types-ts4.5/pm-plugins/deletedRowsHandler.d.ts

@@ -0,0 +1,30 @@
+import type { Change } from 'prosemirror-changeset';
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { NodeViewSerializer } from './NodeViewSerializer';
+interface DeletedRowInfo {
+    fromA: number;
+    fromB: number;
+    rowIndex: number;
+    rowNode: PMNode;
+    toA: number;
+}
+type SimpleChange = Pick<Change, 'fromA' | 'toA' | 'fromB' | 'deleted'>;
+interface DeletedRowsHandlerProps {
+    colourScheme?: 'standard' | 'traditional';
+    deletedRows: DeletedRowInfo[];
+    newDoc: PMNode;
+    nodeViewSerializer: NodeViewSerializer;
+    originalDoc: PMNode;
+}
+/**
+ * Creates decorations for deleted table rows
+ */
+export declare const createDeletedRowsDecorations: ({ deletedRows, originalDoc, newDoc, nodeViewSerializer, colourScheme, }: DeletedRowsHandlerProps) => Decoration[];
+/**
+ * Main function to handle deleted rows - computes diff and creates decorations
+ */
+export declare const handleDeletedRows: (changes: SimpleChange[], originalDoc: PMNode, newDoc: PMNode, nodeViewSerializer: NodeViewSerializer, colourScheme?: "standard" | "traditional") => {
+    decorations: Decoration[];
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "3.2.0",
+	"version": "3.2.1",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -30,15 +30,16 @@
 	"dependencies": {
 		"@atlaskit/adf-schema": "^51.3.2",
 		"@atlaskit/editor-prosemirror": "7.0.0",
+		"@atlaskit/editor-tables": "^2.9.0",
 		"@atlaskit/platform-feature-flags": "^1.1.0",
-		"@atlaskit/tokens": "^7.0.0",
+		"@atlaskit/tokens": "^7.1.0",
 		"@babel/runtime": "^7.0.0",
 		"lodash": "^4.17.21",
 		"memoize-one": "^6.0.0",
 		"prosemirror-changeset": "^2.2.1"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^110.19.0",
+		"@atlaskit/editor-common": "^110.21.0",
 		"react": "^18.2.0"
 	},
 	"techstack": {
@@ -80,6 +81,9 @@
 	"platform-feature-flags": {
 		"platform_editor_ai_aifc_patch_beta_2": {
 			"type": "boolean"
+		},
+		"platform_editor_ai_aifc_patch_ga": {
+			"type": "boolean"
 		}
 	}
 }

package/afm-post-office/tsconfig.json

@@ -1,30 +0,0 @@
-{
-	"extends": "../../../../tsconfig.entry-points.post-office.json",
-	"compilerOptions": {
-		"target": "es5",
-		"outDir": "../../../../../post-office/tsDist/@atlaskit__editor-plugin-show-diff/app",
-		"rootDir": "../",
-		"composite": true
-	},
-	"include": [
-		"../src/**/*.ts",
-		"../src/**/*.tsx"
-	],
-	"exclude": [
-		"../src/**/__tests__/*",
-		"../src/**/*.test.*",
-		"../src/**/test.*",
-		"../src/**/examples.*"
-	],
-	"references": [
-		{
-			"path": "../../../platform/feature-flags/afm-post-office/tsconfig.json"
-		},
-		{
-			"path": "../../../design-system/tokens/afm-post-office/tsconfig.json"
-		},
-		{
-			"path": "../../editor-common/afm-post-office/tsconfig.json"
-		}
-	]
-}