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

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 13.0.0
+
+### Patch Changes
+
+- Updated dependencies
+
+## 12.1.4
+
+### Patch Changes
+
+- [`522f40dd846c1`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/522f40dd846c1) -
+  Fix table-cell diffs in the Post Stream Review experience. Recolouring a table cell is now
+  surfaced in the review with a highlight and a navigable step-through segment, and stepping onto a
+  cell no longer renders a blank cell.
+  - The AI modal mount-point widget could be positioned directly inside a table row, where the
+    browser wrapped it in an anonymous table cell — a blank column that hid the real cell's content.
+    It is now kept out of table structure.
+  - `prosemirror-changeset`'s default token encoder ignores node attributes, so a cell recolour
+    produced no change at all. An attribute-aware encoder now folds an allow-list of table-cell
+    attributes into the diff.
+  - The smart classifier discarded attribute changes on table cells because they sit on the node
+    boundary rather than inside the cell's content. It now emits a whole-cell change when a rigid
+    wrapper's own attributes differ.
+
+- [`3fd2c0404aff0`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/3fd2c0404aff0) -
+  Introduce a data-driven colour-scheme pattern for show-diff decorations: a `DiffColorScheme` type
+  (`types.ts`), shared CSS-generating functions (`factory.ts`) and the two scheme definitions
+  (`schemes.ts`).
+
+  Most scheme fields are ADS accent colour names; seven encode structural differences that no colour
+  can express (`insertUnderlineStyle`, `deletedQuoteNodeShape`, `deletedCellBorderProminence`,
+  `deletedRowTreatment`, `deletedBlockOutlineActiveEmphasis`, `addedCellOverlayZIndex`,
+  `roundedAddedCellOverlayInheritsBorder`), so a new scheme has to decide each of those too.
+
+  Additive only — nothing consumes the factory yet. `standard.ts` and `traditional.ts` are unchanged
+  and remain the source of every rendered style, so there is no behaviour or visual change. Wiring
+  the decoration consumers up behind a feature gate follows separately.
+
+- Updated dependencies
+
 ## 12.1.3
 
 ### Patch Changes

package/compass.yml

@@ -1,7 +1,7 @@
 configVersion: 1
 id: ari:cloud:compass:a436116f-02ce-4520-8fbb-7301462a1674:component/c5751cc6-3513-4070-9deb-af31e86aed34/1617e71c-fdf1-40c0-b143-03bf8d5a1648
 name: '@atlaskit/editor-plugin-show-diff'
-ownerId: ari:cloud:identity::team/ce353f56-2a90-491b-b272-b90dca4fffa2 # Editor FE Platform
+ownerId: ari:cloud:identity::team/cf6a670b-5252-4c68-a769-9207de366beb # Editor Developers
 labels:
   - platform-code
   - platform-afm
@@ -16,14 +16,14 @@ links:
     url: https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master
   - name: Slack Channel
     type: CHAT_CHANNEL
-    url: https://atlassian.enterprise.slack.com/archives/C03SD6QJWPP # #cc-editor-lego
+    url: https://atlassian.enterprise.slack.com/archives/CFG3PSQ9E # #help-editor
   - name: Editor Plugin Show Diff
     type: REPOSITORY
     url: https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master/platform/packages/editor/editor-plugin-show-diff
 customFields:
   - name: Department
     type: text
-    value: Eng - Editor Frontend Platform
+    value: Editor Developers
   - name: Trusted Reviewer Teams
     type: text
     value: ari:cloud:identity::team/cf6a670b-5252-4c68-a769-9207de366beb

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attrAwareTokenEncoder = void 0;
+/**
+ * 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.
+ */
+var attrAwareTokenEncoder = exports.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/cjs/pm-plugins/calculateDiff/calculateDiffDecorations.js

@@ -25,6 +25,7 @@ var _decorationKeys = require("../decorations/decorationKeys");
 var _getAttrChangeRanges = require("../decorations/utils/getAttrChangeRanges");
 var _getMarkChangeRanges = require("../decorations/utils/getMarkChangeRanges");
 var _isExtendedEnabled = require("../isExtendedEnabled");
+var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
 var _optimizeChanges = require("./optimizeChanges");
@@ -237,7 +238,11 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       };
     }
   }
-  var changeset = _prosemirrorChangeset.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' && (0, _platformFeatureFlags.fg)('platform_editor_ai_smart_diff') ? _attrAwareTokenEncoder.attrAwareTokenEncoder : undefined;
+  var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, tr.doc);
   var changes = getChanges({
     changeset: changeset,
     originalDoc: originalDoc,

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.computeDiffChanges = void 0;
 var _prosemirrorChangeset = require("prosemirror-changeset");
+var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
 var _optimizeChanges = require("./optimizeChanges");
@@ -80,7 +81,13 @@ var computeDiffChanges = exports.computeDiffChanges = function computeDiffChange
       newDoc: originalDoc
     };
   }
-  var changeset = _prosemirrorChangeset.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.attrAwareTokenEncoder : undefined;
+  var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {
       changes: (0, _classifySmartChanges.classifySmartChanges)({

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

@@ -10,6 +10,7 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 var _prosemirrorChangeset = require("prosemirror-changeset");
 var _model = require("@atlaskit/editor-prosemirror/model");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _optimizeChanges = require("./optimizeChanges");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -328,7 +329,7 @@ var diffBySteps = exports.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 = _prosemirrorChangeset.ChangeSet.create(rangedStep.before).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
+      var granularStepChanges = _prosemirrorChangeset.ChangeSet.create(rangedStep.before, undefined, _attrAwareTokenEncoder.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/cjs/pm-plugins/calculateDiff/smart/classifySmartChanges.js

@@ -772,6 +772,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((0, _helpers.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.