@atlaskit/editor-plugin-show-diff 12.1.2 → 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

@@ -10,14 +10,14 @@ import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { areDocsEqualByBlockStructureAndText } from '../areDocsEqualByBlockStructureAndText';
 import { createDocMarginAnchorWidget } from '../decorations/createAnchorDecorationWidgets';
 import { createBlockChangedDecoration } from '../decorations/createBlockChangedDecoration';
-import { createGranularBlockReferenceWidget } from '../decorations/createGranularBlockReferenceWidget';
 import { createInlineChangedDecoration } from '../decorations/createInlineChangedDecoration';
 import { createNodeChangedDecorationWidget } from '../decorations/createNodeChangedDecorationWidget';
 import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { isExtendedEnabled } from '../isExtendedEnabled';
-import { diffBySteps, getStepChanges } from './diffBySteps';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
+import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
 import { simplifySteps } from './simplifySteps';
@@ -213,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,
@@ -235,7 +239,7 @@ const calculateDiffDecorationsInner = ({
 
   // Our default operations are insertions, so it should match the opposite of isInverted.
   const isInserted = !isInverted;
-  const createDecorationsForChange = (change, showGranularWithBlock) => {
+  const createDecorationsForChange = change => {
     const isActive = activeIndexPos && change.fromB === activeIndexPos.from && change.toB === activeIndexPos.to;
 
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
@@ -247,10 +251,8 @@ const calculateDiffDecorationsInner = ({
       inlineDeletedDiffPlacement
     });
     if (change.inserted.length > 0) {
-      // shouldHideDeleted for block/node decorations: suppressed when isInverted + hideDeletedDiffs,
-      // or when showGranularWithBlock (block reference widget is shown instead).
-      // isInverted gates both — on an inverted diff the inserted side is visually the deleted side.
-      const shouldHideDeleted = isExtendedEnabled(diffType) ? isInverted && (hideDeletedDiffs || showGranularWithBlock && change.deleted.length > 0) : false;
+      // On an inverted diff the inserted side is visually the deleted side.
+      const shouldHideDeleted = isExtendedEnabled(diffType) ? isInverted && hideDeletedDiffs : false;
 
       // For `smart` NODE-level promotions the change range spans a whole container
       // (e.g. an entire list/table/layout, using outer node bounds). Applying a SINGLE
@@ -267,7 +269,7 @@ const calculateDiffDecorationsInner = ({
       // change. Used to decide if indicator anchor positions should be adjusted
       // inward — when the widget is present the anchor must stay at the block
       // boundary to keep the indicator bar continuous with the deleted content.
-      const willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && (hideDeletedDiffs || showGranularWithBlock) && change.inserted.length > 0);
+      const willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
       if (isSmartNodeLevel) {
         for (const [from, to] of leafTextblockRanges(tr.doc, change.fromB, change.toB)) {
           decorations.push(...createInlineChangedDecoration({
@@ -322,7 +324,7 @@ const calculateDiffDecorationsInner = ({
       }));
     }
     if (change.deleted.length > 0) {
-      const shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && (hideDeletedDiffs || showGranularWithBlock) && change.inserted.length > 0 : false;
+      const shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!shouldHideDeleted) {
         decorations.push(...createNodeChangedDecorationWidget({
           change,
@@ -343,85 +345,9 @@ const calculateDiffDecorationsInner = ({
       }
     }
   };
-  if (diffType === 'step' && expValEquals('platform_editor_diff_granular_extended', 'isEnabled', true)) {
-    // Uses getStepChanges instead of getChanges so that we have per-step granularity metadata.
-    // Specifically, we need to know how many granular changes each step produced in order to
-    // apply the shouldHideDeleted suppression threshold (> 3 granular changes per step).
-    // getChanges returns a flat Change[] with no per-step grouping, making this count impossible
-    // to derive after the fact without re-introducing per-change metadata.
-    const stepChanges = getStepChanges(originalDoc, steps);
-    stepChanges.forEach(({
-      isGranular,
-      changes: stepChangeList
-    }) => {
-      const granularCount = isGranular ? stepChangeList.length : 0;
-
-      // Calculate the average ratio of changed content on both A (original) and B (new)
-      // sides of the diff. If 30% or more of the block has changed on average, we show
-      // the block reference widget even if the granular change count is below the threshold.
-      // Block length is derived from the enclosing text block boundaries rather than the
-      // first/last change positions, so unchanged words at the start/end are accounted for.
-      let avgChangedRatio = 0;
-      if (isGranular && stepChangeList.length > 0) {
-        const first = stepChangeList[0];
-        const last = stepChangeList[stepChangeList.length - 1];
-        const resolvedA = originalDoc.resolve(first.fromA);
-        const resolvedB = tr.doc.resolve(first.fromB);
-        let blockStartA = first.fromA;
-        let blockEndA = last.toA;
-        let blockStartB = first.fromB;
-        let blockEndB = last.toB;
-        for (let depth = resolvedA.depth; depth >= 0; depth--) {
-          const node = resolvedA.node(depth);
-          if (node.isTextblock) {
-            blockStartA = resolvedA.start(depth);
-            blockEndA = blockStartA + node.nodeSize - 2; // exclude open/close tokens
-            break;
-          }
-        }
-        for (let depth = resolvedB.depth; depth >= 0; depth--) {
-          const node = resolvedB.node(depth);
-          if (node.isTextblock) {
-            blockStartB = resolvedB.start(depth);
-            blockEndB = blockStartB + node.nodeSize - 2; // exclude open/close tokens
-            break;
-          }
-        }
-        const blockLengthA = blockEndA - blockStartA;
-        const blockLengthB = blockEndB - blockStartB;
-        const totalChangedA = stepChangeList.reduce((sum, c) => sum + (c.toA - c.fromA), 0);
-        const totalChangedB = stepChangeList.reduce((sum, c) => sum + (c.toB - c.fromB), 0);
-        const ratioA = blockLengthA > 0 ? totalChangedA / blockLengthA : 0;
-        const ratioB = blockLengthB > 0 ? totalChangedB / blockLengthB : 0;
-        avgChangedRatio = (ratioA + ratioB) / 2;
-      }
-      const showGranularWithBlock = isGranular && granularCount !== 1 && (granularCount > 3 || avgChangedRatio >= 0.3);
-      stepChangeList.forEach(change => {
-        createDecorationsForChange(change, showGranularWithBlock);
-      });
-      if (showGranularWithBlock && stepChangeList.length > 0 && !hideDeletedDiffs) {
-        const lastChange = stepChangeList[stepChangeList.length - 1];
-        const granularBlockDiffId = crypto.randomUUID();
-        const blockWidgets = createGranularBlockReferenceWidget({
-          change: lastChange,
-          originalDoc,
-          newDoc: tr.doc,
-          isInverted,
-          nodeViewSerializer,
-          colorScheme,
-          intl,
-          activeIndexPos,
-          diffId: granularBlockDiffId,
-          showIndicators
-        });
-        decorations.push(...blockWidgets);
-      }
-    });
-  } else {
-    changes.forEach(change => {
-      createDecorationsForChange(change, /* showGranularWithBlock */false);
-    });
-  }
+  changes.forEach(change => {
+    createDecorationsForChange(change);
+  });
   getMarkChangeRanges(steps).forEach(change => {
     const isActive = activeIndexPos && change.fromB === activeIndexPos.from && change.toB === activeIndexPos.to;
     decorations.push(...createInlineChangedDecoration({

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
@@ -362,108 +363,4 @@ export const diffBySteps = (originalDoc, steps) => {
     });
   }
   return mergeOverlappingByNewDocRange(changes);
-};
-
-/**
- * A fork of `diffBySteps` that returns changes grouped per step, rather than as a flat list.
- *
- * Why forked rather than refactoring `diffBySteps`:
- * - `diffBySteps` returns a flat `Change[]` and is consumed by the existing decoration path.
- *   Changing its return shape would require threading per-step metadata through all callers,
- *   adding complexity to a stable code path.
- * - The per-step grouping is only needed for the `platform_editor_diff_granular_extended` gate,
- *   where we need to know how many granular changes a single step produced in order to decide
- *   whether to suppress deleted decorations (threshold: > 3 granular changes per step).
- * - Keeping the two functions separate means each has a clear, focused contract and neither
- *   accumulates the other's concerns. Shared logic (mapping helpers, `mergeOverlappingByNewDocRange`,
- *   `shouldCheckGranularDiff`, etc.) is already extracted and reused by both.
- */
-export const getStepChanges = (originalDoc, steps) => {
-  const result = [];
-  let currentDoc = originalDoc;
-  const successfulStepMaps = [];
-  const rangedSteps = [];
-  for (const step of steps) {
-    const before = currentDoc;
-    const stepResult = step.apply(currentDoc);
-    if (stepResult.failed !== null || !stepResult.doc) {
-      continue;
-    }
-    const stepMap = step.getMap();
-    const rangeStep = step;
-    if (typeof rangeStep.from === 'number' && typeof rangeStep.to === 'number') {
-      rangedSteps.push({
-        before,
-        doc: stepResult.doc,
-        from: rangeStep.from,
-        to: rangeStep.to,
-        mapIndex: successfulStepMaps.length,
-        step,
-        stepMap
-      });
-    }
-    successfulStepMaps.push(stepMap);
-    currentDoc = stepResult.doc;
-  }
-  for (const rangedStep of rangedSteps) {
-    const originalToBeforeStep = createMapping(successfulStepMaps.slice(0, rangedStep.mapIndex));
-    const beforeStepToOriginal = originalToBeforeStep.invert();
-    const fromA = mapPosition(beforeStepToOriginal, rangedStep.from);
-    const toA = mapPosition(beforeStepToOriginal, rangedStep.to);
-    const fromAfterStep = rangedStep.stepMap.map(rangedStep.from, -1);
-    const toAfterStep = rangedStep.stepMap.map(rangedStep.to, 1);
-    const afterStepToFinal = createMapping(successfulStepMaps.slice(rangedStep.mapIndex + 1));
-    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 optimizedGranularStepChanges = optimizeChanges(simplifyChanges(granularStepChanges.changes, rangedStep.doc));
-      const stepChanges = [];
-      for (const granularChange of optimizedGranularStepChanges) {
-        const expandedA = expandToWordBoundaries(rangedStep.before, granularChange.fromA, granularChange.toA);
-        const expandedB = expandToWordBoundaries(rangedStep.doc, granularChange.fromB, granularChange.toB);
-        const aLeftDelta = granularChange.fromA - expandedA.from;
-        const aRightDelta = expandedA.to - granularChange.toA;
-        const bLeftDelta = granularChange.fromB - expandedB.from;
-        const bRightDelta = expandedB.to - granularChange.toB;
-        let finalA = expandedA;
-        let finalB = expandedB;
-        if (aLeftDelta > bLeftDelta || aRightDelta > bRightDelta) {
-          const extraLeft = Math.max(0, aLeftDelta - bLeftDelta);
-          const extraRight = Math.max(0, aRightDelta - bRightDelta);
-          finalB = expandToWordBoundaries(rangedStep.doc, Math.max(expandedB.from - extraLeft, 0), expandedB.to + extraRight);
-        }
-        if (bLeftDelta > aLeftDelta || bRightDelta > aRightDelta) {
-          const extraLeft = Math.max(0, bLeftDelta - aLeftDelta);
-          const extraRight = Math.max(0, bRightDelta - aRightDelta);
-          finalA = expandToWordBoundaries(rangedStep.before, Math.max(expandedA.from - extraLeft, 0), expandedA.to + extraRight);
-        }
-        stepChanges.push({
-          fromA: mapPosition(beforeStepToOriginal, finalA.from),
-          toA: mapPosition(beforeStepToOriginal, finalA.to),
-          fromB: mapPosition(afterStepToFinal, finalB.from),
-          toB: mapPosition(afterStepToFinal, finalB.to),
-          deleted: createSpans(Math.max(0, finalA.to - finalA.from)),
-          inserted: createSpans(Math.max(0, finalB.to - finalB.from))
-        });
-      }
-      result.push({
-        isGranular: true,
-        changes: mergeOverlappingByNewDocRange(stepChanges)
-      });
-      continue;
-    }
-    result.push({
-      isGranular: false,
-      changes: [{
-        fromA,
-        toA,
-        fromB,
-        toB,
-        deleted: createSpans(Math.max(0, toA - fromA)),
-        inserted: createSpans(Math.max(0, toB - fromB))
-      }]
-    });
-  }
-  return result;
 };

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.