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

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traditionalScheme = exports.standardScheme = void 0;
+/** Green insertions, red deletions. */
+var traditionalScheme = exports.traditionalScheme = {
+  insertColor: 'green',
+  insertUnderlineStyle: 'solid',
+  insertActiveColor: 'green',
+  deleteColor: 'red',
+  deleteActiveColor: 'red',
+  deletedCellColor: 'gray',
+  insertedCellOpacity: 0.5,
+  deletedQuoteNodeShape: 'ring',
+  deletedCellBorderProminence: 'subtle',
+  deletedRowTreatment: 'strikeColor',
+  deletedBlockOutlineActiveEmphasis: 'background',
+  addedCellOverlayZIndex: 1,
+  roundedAddedCellOverlayInheritsBorder: true
+};
+
+/** Purple insertions, gray deletions (red on active). */
+var standardScheme = exports.standardScheme = {
+  insertColor: 'purple',
+  insertUnderlineStyle: 'dotted',
+  insertActiveColor: 'purple',
+  deleteColor: 'gray',
+  deleteActiveColor: 'red',
+  deletedCellColor: 'gray',
+  insertedCellOpacity: 0.2,
+  deletedQuoteNodeShape: 'borderLeft',
+  deletedCellBorderProminence: 'accent',
+  deletedRowTreatment: 'textTint',
+  deletedBlockOutlineActiveEmphasis: 'border',
+  addedCellOverlayZIndex: 2,
+  roundedAddedCellOverlayInheritsBorder: false
+};

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+const 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.
+ */
+const encodeNodeWithAttrs = (node, attrNames) => {
+  var _node$attrs;
+  const attrs = (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 ? _node$attrs : {};
+  // Deterministic order: iterate the allow-list, not `Object.keys(attrs)`.
+  const parts = attrNames.map(name => {
+    var _attrs$name;
+    return `${name}=${JSON.stringify((_attrs$name = attrs[name]) !== null && _attrs$name !== void 0 ? _attrs$name : null)}`;
+  });
+  return `${node.type.name}|${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 const attrAwareTokenEncoder = {
+  encodeCharacter: (char, _marks) => char,
+  encodeNodeStart: node => {
+    const attrNames = DIFFED_ATTRS_BY_NODE_TYPE[node.type.name];
+    if (attrNames) {
+      return encodeNodeWithAttrs(node, attrNames);
+    }
+    return node.type.name;
+  },
+  encodeNodeEnd: node => -typeID(node.type),
+  compareTokens: (a, b) => 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) {
+  const cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  let id = cache[type.name];
+  if (id == null) {
+    cache[type.name] = id = Object.keys(type.schema.nodes).indexOf(type.name) + 1;
+  }
+  return id;
+}

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

@@ -16,6 +16,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';
@@ -212,7 +213,11 @@ const calculateDiffDecorationsInner = ({
       };
     }
   }
-  const 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.
+  const tokenEncoder = diffType === 'smart' && fg('platform_editor_ai_smart_diff') ? attrAwareTokenEncoder : undefined;
+  const changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, tr.doc);
   const changes = getChanges({
     changeset,
     originalDoc,

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

@@ -14,6 +14,7 @@
  * 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';
@@ -62,7 +63,13 @@ export const computeDiffChanges = ({
       newDoc: originalDoc
     };
   }
-  const 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.)
+  const tokenEncoder = diffType === 'smart' ? attrAwareTokenEncoder : undefined;
+  const changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {
       changes: classifySmartChanges({

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

@@ -1,6 +1,7 @@
 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.
@@ -292,7 +293,7 @@ export const diffBySteps = (originalDoc, steps) => {
     const fromB = mapPosition(afterStepToFinal, fromAfterStep);
     const toB = mapPosition(afterStepToFinal, toAfterStep);
     if (shouldCheckGranularDiff(rangedStep.step, rangedStep.before, rangedStep.from, rangedStep.to)) {
-      const granularStepChanges = ChangeSet.create(rangedStep.before).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
+      const 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/es2019/pm-plugins/calculateDiff/smart/classifySmartChanges.js

@@ -635,6 +635,15 @@ const classifyChild = (childA, childB, changes, originalDoc, newDoc, locale, thr
     const childrenB = childRefs(blockB);
     const childrenA = wrapperA ? childRefs(wrapperA) : [];
     const 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.