@atlaskit/editor-plugin-show-diff 12.1.3 → 13.0.0

package/dist/esm/pm-plugins/calculateDiff/attrAwareTokenEncoder.js

@@ -0,0 +1,70 @@
+/**
+ * Attribute-aware token encoder for `prosemirror-changeset`.
+ *
+ * The library's default encoder reduces a node's open token to `node.type.name`,
+ * ignoring attributes. An attribute-only change (e.g. recolouring a table cell's
+ * `background`) therefore tokenises identically on both sides and reports no
+ * change at all.
+ *
+ * This encoder folds an allow-listed set of attributes into the open token so
+ * such changes register. Everything else encodes exactly as the default. The
+ * allow-list is deliberately narrow — folding in ephemeral attrs like `localId`
+ * would produce phantom diffs.
+ */
+
+var DIFFED_ATTRS_BY_NODE_TYPE = {
+  tableCell: ['background', 'colspan', 'rowspan'],
+  tableHeader: ['background', 'colspan', 'rowspan']
+};
+
+/**
+ * Builds a stable composite token. Iterates the allow-list rather than
+ * `Object.keys` so ordering is deterministic for string comparison.
+ */
+var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
+  var _node$attrs;
+  var attrs = (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 ? _node$attrs : {};
+  // Deterministic order: iterate the allow-list, not `Object.keys(attrs)`.
+  var parts = attrNames.map(function (name) {
+    var _attrs$name;
+    return "".concat(name, "=").concat(JSON.stringify((_attrs$name = attrs[name]) !== null && _attrs$name !== void 0 ? _attrs$name : null));
+  });
+  return "".concat(node.type.name, "|").concat(parts.join('|'));
+};
+
+/**
+ * Identical to the library default except that allow-listed node types encode
+ * their allow-listed attributes into the open token. Characters and node-end
+ * tokens are left as-is, hence the `string | number` token type.
+ */
+export var attrAwareTokenEncoder = {
+  encodeCharacter: function encodeCharacter(char, _marks) {
+    return char;
+  },
+  encodeNodeStart: function encodeNodeStart(node) {
+    var attrNames = DIFFED_ATTRS_BY_NODE_TYPE[node.type.name];
+    if (attrNames) {
+      return encodeNodeWithAttrs(node, attrNames);
+    }
+    return node.type.name;
+  },
+  encodeNodeEnd: function encodeNodeEnd(node) {
+    return -typeID(node.type);
+  },
+  compareTokens: function compareTokens(a, b) {
+    return a === b;
+  }
+};
+
+/**
+ * Mirrors the library's private `typeID` so node-end tokens match the default
+ * encoding exactly. Reimplemented here because it is not exported.
+ */
+function typeID(type) {
+  var cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  var id = cache[type.name];
+  if (id == null) {
+    cache[type.name] = id = Object.keys(type.schema.nodes).indexOf(type.name) + 1;
+  }
+  return id;
+}

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

@@ -24,6 +24,7 @@ import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { isExtendedEnabled } from '../isExtendedEnabled';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
@@ -231,7 +232,11 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       };
     }
   }
-  var changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, tr.doc);
+  // The attribute-aware encoder is only needed by the smart classifier and is
+  // gated with it; other diff types keep the library default so their output is
+  // unchanged.
+  var tokenEncoder = diffType === 'smart' && fg('platform_editor_ai_smart_diff') ? attrAwareTokenEncoder : undefined;
+  var changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, tr.doc);
   var changes = getChanges({
     changeset: changeset,
     originalDoc: originalDoc,

package/dist/esm/pm-plugins/calculateDiff/computeDiffChanges.js

@@ -17,6 +17,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * reconstructed by applying the (simplified) steps to `originalDoc`.
  */
 import { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
@@ -75,7 +76,13 @@ export var computeDiffChanges = function computeDiffChanges(_ref) {
       newDoc: originalDoc
     };
   }
-  var changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, steppedDoc);
+
+  // The attribute-aware encoder only affects the `smart` classification, so it is
+  // applied only for that type. (This utility intentionally applies no feature
+  // gate — see the file docstring — but a caller requesting `smart` is already
+  // behind the smart-diff gate.)
+  var tokenEncoder = diffType === 'smart' ? attrAwareTokenEncoder : undefined;
+  var changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {
       changes: classifySmartChanges({

package/dist/esm/pm-plugins/calculateDiff/diffBySteps.js

@@ -8,6 +8,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 import { simplifyChanges, ChangeSet } from 'prosemirror-changeset';
 import { Mark } from '@atlaskit/editor-prosemirror/model';
 import { Mapping, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { optimizeChanges } from './optimizeChanges';
 
 // @ts-ignore TS1501: This regular expression flag is only available when targeting 'es6' or later.
@@ -322,7 +323,7 @@ export var diffBySteps = function diffBySteps(originalDoc, steps) {
     var fromB = mapPosition(afterStepToFinal, fromAfterStep);
     var toB = mapPosition(afterStepToFinal, toAfterStep);
     if (shouldCheckGranularDiff(rangedStep.step, rangedStep.before, rangedStep.from, rangedStep.to)) {
-      var granularStepChanges = ChangeSet.create(rangedStep.before).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
+      var granularStepChanges = ChangeSet.create(rangedStep.before, undefined, attrAwareTokenEncoder).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
 
       // `simplifyChanges` reads text using `Change.fromB`/`toB`, which are
       // positions in the post-step doc (the "B" doc). Passing the pre-step

package/dist/esm/pm-plugins/calculateDiff/smart/classifySmartChanges.js

@@ -765,6 +765,15 @@ var _classifyChild = function classifyChild(childA, childB, changes, originalDoc
     var childrenB = childRefs(blockB);
     var childrenA = wrapperA ? childRefs(wrapperA) : [];
     var out = [];
+
+    // An attribute-only change on the wrapper itself (e.g. a table cell's
+    // `background`) sits on the node boundary, not inside any inner child, so the
+    // recursion below would emit nothing and the change would be dropped. Emit a
+    // whole-wrapper change instead, which also subsumes any inner content change.
+    if (wrapperA && !wrapperA.node.sameMarkup(blockB.node)) {
+      out.push(makePromotedChange(wrapperA.from, wrapperA.to, blockB.from, blockB.to, 'node'));
+      return out;
+    }
     // LCS-align inner children (mirrors classifyContainer) so a paragraph inserted/deleted
     // inside the cell/column does not mis-pair every subsequent inner child by index. We never
     // promote the wrapper itself here — we only classify each inner child.