@atlaskit/editor-plugin-show-diff 10.1.23 → 10.2.0

package/dist/es2019/pm-plugins/calculateDiff/smart/helpers.js

@@ -0,0 +1,106 @@
+/**
+ * The granularity level a `smart` change was promoted to. Stored on span `data` so the
+ * decoration pipeline can render each level differently (e.g. node-level deletions shown
+ * below the new content). `null` for non-promoted (inline) changes.
+ */
+
+/** Span `data` payload carried by promoted `smart` changes. */
+
+/**
+ * Build the `deleted`/`inserted` span arrays a `Change` needs. A length of 0 yields an
+ * empty array (no change on that side).
+ */
+export const createSpans = (length, data = null) => length > 0 ? [{
+  length,
+  data
+}] : [];
+
+/**
+ * Build a promoted `Change` spanning `[fromA,toA)` in the original doc and `[fromB,toB)`
+ * in the new doc, with both sides marked changed (mirrors `groupChangesByBlock` so the
+ * decoration pipeline renders both the inserted-block decoration and the deleted-node
+ * widget).
+ *
+ * `level` tags the change's spans so downstream decoration logic can treat node-level
+ * promotions specially (see `smartChangeLevel`).
+ */
+export const makePromotedChange = (fromA, toA, fromB, toB, level) => {
+  const data = level ? {
+    smartLevel: level
+  } : null;
+  // `deleted` and `inserted` must be independent arrays: downstream code may mutate one
+  // side (push/splice), which would silently corrupt the other if they shared a reference.
+  return {
+    fromA,
+    toA,
+    fromB,
+    toB,
+    deleted: createSpans(Math.max(0, toA - fromA), data),
+    inserted: createSpans(Math.max(0, toB - fromB), data)
+  };
+};
+
+/**
+ * Read the `smartLevel` tag off a change's spans, if present. Returns `undefined` for
+ * changes not produced by the `smart` classifier (e.g. inline/block/step diff types).
+ */
+export const smartChangeLevel = change => {
+  const spans = [...change.inserted, ...change.deleted];
+  for (const span of spans) {
+    const data = span.data;
+    if (data && typeof data === 'object' && 'smartLevel' in data) {
+      return data.smartLevel;
+    }
+  }
+  return undefined;
+};
+
+/** True when a change has no original-side (deleted) content — a pure insertion. */
+const isPureInsertion = change => change.toA <= change.fromA;
+
+/**
+ * Coalesce changes that overlap in new-doc (B) coordinates.
+ *
+ * Merging two changes takes the UNION of their A (original-doc) ranges. That is only safe when
+ * their A ranges actually touch/overlap — OR when at least one is a pure insertion (empty A).
+ * Otherwise, merging a deletion at A[110,152] with a later edit at A[162,168] would fabricate an
+ * A span [110,168] covering the untouched gap, which then overlaps a *different* change's A range
+ * (making the same original content appear deleted twice). So we require B-overlap AND
+ * (A-overlap OR a pure insertion) before coalescing.
+ */
+export const mergeOverlappingByNewDocRange = changes => {
+  if (changes.length <= 1) {
+    return changes;
+  }
+  const sorted = [...changes].sort((l, r) => l.fromB - r.fromB);
+  const merged = [];
+  let current = {
+    ...sorted[0]
+  };
+  for (let i = 1; i < sorted.length; i++) {
+    const next = sorted[i];
+    const bOverlaps = next.fromB <= current.toB;
+    // A ranges may be unioned only if they touch, or if either side contributes no A content.
+    const aMergeable = isPureInsertion(current) || isPureInsertion(next) || rangesOverlap(current.fromA, current.toA, next.fromA, next.toA) || next.fromA <= current.toA; // adjacency (sorted by B, A usually monotonic)
+    if (bOverlaps && aMergeable) {
+      current = {
+        fromA: Math.min(current.fromA, next.fromA),
+        toA: Math.max(current.toA, next.toA),
+        fromB: Math.min(current.fromB, next.fromB),
+        toB: Math.max(current.toB, next.toB),
+        deleted: [...current.deleted, ...next.deleted],
+        inserted: [...current.inserted, ...next.inserted]
+      };
+    } else {
+      merged.push(current);
+      current = {
+        ...next
+      };
+    }
+  }
+  merged.push(current);
+  return merged;
+};
+
+/** True when two half-open ranges overlap. */
+export const rangesOverlap = (aFrom, aTo, bFrom, bTo) => aFrom < bTo && bFrom < aTo;

package/dist/es2019/pm-plugins/calculateDiff/smart/segmentText.js

@@ -0,0 +1,283 @@
+/**
+ * A half-open offset span `[from, to)` measured in *content offsets* relative to the
+ * start of a textblock (i.e. the same coordinate space as `buildCharsByOffset`).
+ */
+
+/**
+ * Minimal local typing for `Intl.Segmenter`. The TS lib target configured for this
+ * package does not include the `Intl.Segmenter` declarations, so we declare just the
+ * surface we use and access it via a runtime-checked cast. Remove when the lib target is
+ * bumped to include `es2022.intl`/`esnext.intl`.
+ */
+
+// A character is treated as part of a word unless it is whitespace or common punctuation.
+// We deliberately avoid Unicode property escapes (`\p{...}`) and the `u` flag here: the `u`
+// flag is only valid when targeting es6+, and the declaration-generation build config for
+// this package targets an older lib, which rejects it with TS1501. This negated approach
+// keeps word segmentation reasonable across scripts (any non-punctuation, non-space glyph
+// counts as a word char) without needing Unicode-aware regex.
+const NON_WORD_CHARS = ' \t\n\r\f\v.,;:!?…。！？、"\'`“”‘’()[]{}<>/\\|@#$%^&*-+=~';
+const NON_WORD_CHAR_SET = new Set(NON_WORD_CHARS.split(''));
+const isWordChar = ch => !NON_WORD_CHAR_SET.has(ch);
+// Whitespace is checked via a Set rather than a regex to avoid both the `require-unicode-regexp`
+// lint rule and the TS1501 error the `u` flag triggers under this package's build lib target.
+const WHITESPACE_CHAR_SET = new Set([' ', '\t', '\n', '\r', '\f', '\v', '\u00a0']);
+const isWhitespaceChar = ch => WHITESPACE_CHAR_SET.has(ch);
+// Sentence terminators used by the regex fallback. We intentionally keep this small and
+// conservative — the Intl.Segmenter path is the source of truth when available.
+const SENTENCE_TERMINATORS = new Set(['.', '!', '?', '…', '。', '！', '？']);
+
+/**
+ * Build a per-content-offset view of a textblock's characters.
+ *
+ * `chars[i]` is the character at content offset `i`, or `null` when that offset lies
+ * inside a non-text inline node (mention, date, emoji, hardBreak, …). A `null` acts as an
+ * *opaque single token*: it counts as one word and never terminates a sentence.
+ */
+export const buildCharsByOffset = parent => {
+  const chars = Array.from({
+    length: parent.content.size
+  }, () => null);
+  parent.content.forEach((child, offset) => {
+    var _child$text;
+    if (!child.isText) {
+      return;
+    }
+    const text = (_child$text = child.text) !== null && _child$text !== void 0 ? _child$text : '';
+    for (let i = 0; i < text.length; i++) {
+      chars[offset + i] = text[i];
+    }
+  });
+  return chars;
+};
+const getSegmenterCtor = () => {
+  if (typeof Intl === 'undefined') {
+    return undefined;
+  }
+  const ctor = Intl.Segmenter;
+  return typeof ctor === 'function' ? ctor : undefined;
+};
+let cachedLocale;
+let cachedSentenceSegmenter;
+let cachedWordSegmenter;
+const getSegmenters = locale => {
+  const Ctor = getSegmenterCtor();
+  if (!Ctor) {
+    return undefined;
+  }
+  if (cachedLocale !== locale || !cachedSentenceSegmenter || !cachedWordSegmenter) {
+    cachedLocale = locale;
+    cachedSentenceSegmenter = new Ctor(locale, {
+      granularity: 'sentence'
+    });
+    cachedWordSegmenter = new Ctor(locale, {
+      granularity: 'word'
+    });
+  }
+  return {
+    sentence: cachedSentenceSegmenter,
+    word: cachedWordSegmenter
+  };
+};
+
+/**
+ * Convert a char-view into a plain string plus an index map back to content offsets.
+ *
+ * Opaque inline tokens (`null`) are represented in the string by a single sentinel
+ * character (Unicode Object Replacement Character, U+FFFC) so that:
+ * - the segmenter treats them as a word-like glyph rather than whitespace/punctuation;
+ * - they never look like a sentence terminator.
+ * `indexMap[j]` gives the content offset of string index `j`.
+ */
+const OBJECT_REPLACEMENT = '\uFFFC';
+const flattenChars = chars => {
+  let text = '';
+  const indexMap = [];
+  for (let offset = 0; offset < chars.length; offset++) {
+    const ch = chars[offset];
+    text += ch === null ? OBJECT_REPLACEMENT : ch;
+    indexMap.push(offset);
+  }
+  return {
+    text,
+    indexMap
+  };
+};
+const stringIndexToOffset = (indexMap, strIdx, fallback) => {
+  if (strIdx < 0) {
+    return fallback;
+  }
+  if (strIdx >= indexMap.length) {
+    // One-past-the-end maps to the offset after the last char.
+    return indexMap.length > 0 ? indexMap[indexMap.length - 1] + 1 : fallback;
+  }
+  return indexMap[strIdx];
+};
+
+/**
+ * Segment a textblock char-view into sentence spans (content-offset coordinates).
+ * Uses Intl.Segmenter when available, otherwise a conservative regex fallback.
+ */
+export const segmentSentences = (chars, locale) => {
+  if (chars.length === 0) {
+    return [];
+  }
+  const {
+    text,
+    indexMap
+  } = flattenChars(chars);
+  const segmenters = getSegmenters(locale);
+  if (segmenters) {
+    const spans = [];
+    for (const seg of segmenters.sentence.segment(text)) {
+      const startOffset = stringIndexToOffset(indexMap, seg.index, 0);
+      const endOffset = stringIndexToOffset(indexMap, seg.index + seg.segment.length, chars.length);
+      if (endOffset > startOffset) {
+        spans.push({
+          from: startOffset,
+          to: endOffset
+        });
+      }
+    }
+    return spans.length > 0 ? spans : [{
+      from: 0,
+      to: chars.length
+    }];
+  }
+
+  // Regex fallback: split after a sentence terminator followed by whitespace/EOL.
+  // A `null` (OBJECT_REPLACEMENT) is never a terminator.
+  const spans = [];
+  let start = 0;
+  for (let i = 0; i < chars.length; i++) {
+    const ch = chars[i];
+    if (ch !== null && SENTENCE_TERMINATORS.has(ch)) {
+      // Consume trailing spaces as part of this sentence.
+      let end = i + 1;
+      while (end < chars.length && chars[end] !== null && isWhitespaceChar(chars[end])) {
+        end++;
+      }
+      spans.push({
+        from: start,
+        to: end
+      });
+      start = end;
+    }
+  }
+  if (start < chars.length) {
+    spans.push({
+      from: start,
+      to: chars.length
+    });
+  }
+  return spans.length > 0 ? spans : [{
+    from: 0,
+    to: chars.length
+  }];
+};
+
+/**
+ * Count word-like tokens within a content-offset range of the char-view.
+ * Each opaque inline token (`null`) counts as exactly one word.
+ */
+export const countWords = (chars, span, locale) => {
+  const slice = chars.slice(span.from, span.to);
+  if (slice.length === 0) {
+    return 0;
+  }
+  const segmenters = getSegmenters(locale);
+  const {
+    text
+  } = flattenChars(slice);
+  if (segmenters) {
+    let count = 0;
+    for (const seg of segmenters.word.segment(text)) {
+      // Object-replacement sentinel is word-like; count it.
+      if (seg.isWordLike || seg.segment.includes(OBJECT_REPLACEMENT)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  // Regex fallback: a run of word chars OR a single opaque token is one word.
+  let count = 0;
+  let inWord = false;
+  for (const ch of slice) {
+    if (ch === null) {
+      count++;
+      inWord = false;
+      continue;
+    }
+    if (isWordChar(ch)) {
+      if (!inWord) {
+        count++;
+        inWord = true;
+      }
+    } else {
+      inWord = false;
+    }
+  }
+  return count;
+};
+
+/**
+ * Return the word-token spans (content-offset coordinates) within a range. Used to decide
+ * which words a change overlaps. Each opaque inline token is its own span.
+ */
+export const segmentWordSpans = (chars, span, locale) => {
+  const segmenters = getSegmenters(locale);
+  const slice = chars.slice(span.from, span.to);
+  const {
+    text,
+    indexMap
+  } = flattenChars(slice);
+  const spans = [];
+  if (segmenters) {
+    for (const seg of segmenters.word.segment(text)) {
+      if (seg.isWordLike || seg.segment.includes(OBJECT_REPLACEMENT)) {
+        const from = span.from + stringIndexToOffset(indexMap, seg.index, 0);
+        const to = span.from + stringIndexToOffset(indexMap, seg.index + seg.segment.length, slice.length);
+        spans.push({
+          from,
+          to
+        });
+      }
+    }
+    return spans;
+  }
+  let wordStart = -1;
+  for (let i = 0; i < slice.length; i++) {
+    const ch = slice[i];
+    if (ch === null) {
+      if (wordStart !== -1) {
+        spans.push({
+          from: span.from + wordStart,
+          to: span.from + i
+        });
+        wordStart = -1;
+      }
+      spans.push({
+        from: span.from + i,
+        to: span.from + i + 1
+      });
+    } else if (isWordChar(ch)) {
+      if (wordStart === -1) {
+        wordStart = i;
+      }
+    } else if (wordStart !== -1) {
+      spans.push({
+        from: span.from + wordStart,
+        to: span.from + i
+      });
+      wordStart = -1;
+    }
+  }
+  if (wordStart !== -1) {
+    spans.push({
+      from: span.from + wordStart,
+      to: span.from + slice.length
+    });
+  }
+  return spans;
+};

package/dist/es2019/pm-plugins/calculateDiff/smart/thresholds.js

@@ -0,0 +1,45 @@
+/**
+ * Configurable thresholds for the `smart` diffType.
+ *
+ * See docs/smart-diff-design.md §3 and §6 for the exact semantics of each level.
+ */
+
+export const DEFAULT_SMART_THRESHOLDS = {
+  sentence: {
+    ratio: 0.4,
+    minChanged: 2
+  },
+  paragraph: {
+    ratio: 0.4,
+    minChanged: 2
+  },
+  node: {
+    ratio: 0.6,
+    textBearingRatio: 0.6
+  }
+};
+
+/**
+ * Merge caller overrides onto the defaults. Overrides are shallow-merged per level so a
+ * caller can tune a single field (e.g. only `sentence.ratio`) without re-specifying the
+ * rest.
+ */
+export const resolveThresholds = overrides => {
+  if (!overrides) {
+    return DEFAULT_SMART_THRESHOLDS;
+  }
+  return {
+    sentence: {
+      ...DEFAULT_SMART_THRESHOLDS.sentence,
+      ...overrides.sentence
+    },
+    paragraph: {
+      ...DEFAULT_SMART_THRESHOLDS.paragraph,
+      ...overrides.paragraph
+    },
+    node: {
+      ...DEFAULT_SMART_THRESHOLDS.node,
+      ...overrides.node
+    }
+  };
+};

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

@@ -1,6 +1,6 @@
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { isExtendedEnabled } from '../isExtendedEnabled';
 import { standardDecorationMarkerVariable, deletedDecorationMarkerVariable, editingStyleQuoteNode, editingStyleRuleNode, editingStyleCardBlockNode, editingStyleNode, deletedContentStyleNew, deletedStyleQuoteNode, addedCellOverlayStyle, deletedCellOverlayStyle } from './colorSchemes/standard';
 import { traditionalDecorationMarkerVariableActive, traditionalDecorationMarkerVariableNew, traditionalDeletedDecorationMarkerVariableActive, traditionalDeletedDecorationMarkerVariableNew, traditionalStyleQuoteNodeActive, traditionalStyleQuoteNodeNew, traditionalStyleRuleNodeActive, traditionalStyleRuleNodeNew, traditionalStyleCardBlockNodeActive, traditionalStyleCardBlockNodeNew, traditionalStyleNodeActive, traditionalStyleNodeNew, getDeletedTraditionalInlineStyle, deletedTraditionalStyleQuoteNode, traditionalAddedCellOverlayStyle, deletedTraditionalCellOverlayStyle } from './colorSchemes/traditional';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
@@ -20,7 +20,8 @@ const getBlockNodeStyle = ({
   nodeName,
   colorScheme,
   isInserted = true,
-  isActive = false
+  isActive = false,
+  diffType
 }) => {
   const isTraditional = colorScheme === 'traditional';
   if (['mediaSingle', 'mediaGroup', 'table',
@@ -34,13 +35,13 @@ const getBlockNodeStyle = ({
   // Media nodes inside mediaSingle should not get position:relative
   // as it shifts the image outside its parent container (e.g. panel)
   if (nodeName === 'media') {
-    if (!isInserted && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (!isInserted && isExtendedEnabled(diffType)) {
       return isTraditional ? getDeletedTraditionalInlineStyle(false) : deletedDecorationMarkerVariable;
     }
     return isTraditional ? isActive ? traditionalStyleNodeActive : traditionalStyleNodeNew : editingStyleNode;
   }
   if (['tableCell', 'tableHeader'].includes(nodeName)) {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       // This is used for positioning the cell overlay widget decorations
       return convertToInlineCss({
         position: 'relative'
@@ -50,13 +51,13 @@ const getBlockNodeStyle = ({
     return undefined;
   }
   if (nodeName === 'panel') {
-    if (!isInserted && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (!isInserted && isExtendedEnabled(diffType)) {
       return isTraditional ? getDeletedTraditionalInlineStyle(false) : deletedDecorationMarkerVariable;
     }
     return isTraditional ? isActive ? traditionalStyleNodeActive : traditionalStyleNodeNew : editingStyleNode;
   }
   if (['extension', 'embedCard', 'listItem'].includes(nodeName)) {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional && isActive ? traditionalDecorationMarkerVariableActive : isTraditional ? traditionalDecorationMarkerVariableNew : standardDecorationMarkerVariable;
       } else {
@@ -69,7 +70,7 @@ const getBlockNodeStyle = ({
     return isTraditional && isActive ? traditionalDecorationMarkerVariableActive : isTraditional ? traditionalDecorationMarkerVariableNew : standardDecorationMarkerVariable;
   }
   if (nodeName === 'blockquote') {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional ? isActive ? traditionalStyleQuoteNodeActive : traditionalStyleQuoteNodeNew : editingStyleQuoteNode;
       } else {
@@ -79,7 +80,7 @@ const getBlockNodeStyle = ({
     return isTraditional ? isActive ? traditionalStyleQuoteNodeActive : traditionalStyleQuoteNodeNew : editingStyleQuoteNode;
   }
   if (nodeName === 'rule') {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional ? isActive ? traditionalStyleRuleNodeActive : traditionalStyleRuleNodeNew : editingStyleRuleNode;
       } else {
@@ -89,7 +90,7 @@ const getBlockNodeStyle = ({
     return isTraditional ? isActive ? traditionalStyleRuleNodeActive : traditionalStyleRuleNodeNew : editingStyleRuleNode;
   }
   if (nodeName === 'blockCard') {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional ? isActive ? traditionalStyleCardBlockNodeActive : traditionalStyleCardBlockNodeNew : editingStyleCardBlockNode;
       } else {
@@ -98,7 +99,7 @@ const getBlockNodeStyle = ({
     }
     return isTraditional ? isActive ? traditionalStyleCardBlockNodeActive : traditionalStyleCardBlockNodeNew : editingStyleCardBlockNode;
   }
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (isExtendedEnabled(diffType)) {
     if (isInserted) {
       return isTraditional ? isActive ? traditionalStyleNodeActive : traditionalStyleNodeNew : editingStyleNode;
     } else {
@@ -123,7 +124,8 @@ export const createBlockChangedDecoration = ({
   isActive = false,
   shouldHideDeleted = false,
   showIndicators = false,
-  doc
+  doc,
+  diffType
 }) => {
   const decorations = [];
   const diffId = crypto.randomUUID();
@@ -134,11 +136,12 @@ export const createBlockChangedDecoration = ({
       decorationType: 'block',
       diffId,
       isActive,
-      nodeName: change.name
+      nodeName: change.name,
+      diffType
     }))];
   }
   let style;
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) && ['tableCell', 'tableHeader'].includes(change.name)) {
+  if (isExtendedEnabled(diffType) && ['tableCell', 'tableHeader'].includes(change.name)) {
     const cellOverlay = document.createElement('div');
     const cellOverlayStyle = isInserted ? colorScheme === 'traditional' ? traditionalAddedCellOverlayStyle : addedCellOverlayStyle : colorScheme === 'traditional' ? deletedTraditionalCellOverlayStyle : deletedCellOverlayStyle;
     cellOverlay.setAttribute('style', cellOverlayStyle);
@@ -150,18 +153,20 @@ export const createBlockChangedDecoration = ({
       key: 'cell-overlay-decoration'
     }));
   }
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (isExtendedEnabled(diffType)) {
     style = getBlockNodeStyle({
       nodeName: change.name,
       colorScheme,
       isInserted,
-      isActive
+      isActive,
+      diffType
     });
   } else {
     style = getBlockNodeStyle({
       nodeName: change.name,
       colorScheme,
-      isActive
+      isActive,
+      diffType
     });
   }
   const className = getNodeClass(change.name);
@@ -174,10 +179,11 @@ export const createBlockChangedDecoration = ({
       decorationType: 'block',
       diffId,
       isActive,
-      nodeName: change.name
+      nodeName: change.name,
+      diffType
     })));
   }
-  if (decorations.length > 0 && showIndicators && doc && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (decorations.length > 0 && showIndicators && doc && isExtendedEnabled(diffType)) {
     decorations.push(...createBlockIndicatorAnchorWidgets({
       doc,
       from: change.from,

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

@@ -2,7 +2,7 @@ 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 { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { isExtendedEnabled } from '../isExtendedEnabled';
 import { addedCellOverlayStyle, deletedRowStyle, deletedCellOverlayStyle } from './colorSchemes/standard';
 import { deletedTraditionalRowStyle, deletedTraditionalCellOverlayStyle, traditionalAddedCellOverlayStyle } from './colorSchemes/traditional';
 import { buildDiffDecorationSpec } from './decorationKeys';
@@ -13,7 +13,8 @@ import { findSafeInsertPos } from './utils/findSafeInsertPos';
 const extractChangedRows = ({
   change,
   originalDoc,
-  newDoc
+  newDoc,
+  diffType
 }) => {
   const changedRows = [];
 
@@ -50,7 +51,7 @@ const extractChangedRows = ({
 
     // 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' && (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) || !isEmptyRow(rowNode))) {
+    if (rowOverlapsChange && rowNode.type.name === 'tableRow' && (isExtendedEnabled(diffType) || !isEmptyRow(rowNode))) {
       const startOfRow = newTableMap.mapByRow.slice().reverse().find(row => row[0] + tableNew.pos < change.fromB && change.fromB < row[row.length - 1] + tableNew.pos);
       changedRows.push({
         rowIndex,
@@ -101,9 +102,9 @@ const isEmptyRow = rowNode => {
 /**
  * Creates a DOM representation of a deleted table row
  */
-const createChangedRowDOM = (rowNode, nodeViewSerializer, colorScheme, isInserted) => {
+const createChangedRowDOM = (rowNode, nodeViewSerializer, colorScheme, isInserted, diffType) => {
   const tr = document.createElement('tr');
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (isExtendedEnabled(diffType)) {
     if (!isInserted) {
       tr.setAttribute('style', colorScheme === 'traditional' ? deletedTraditionalRowStyle : deletedRowStyle);
     }
@@ -117,7 +118,7 @@ const createChangedRowDOM = (rowNode, nodeViewSerializer, colorScheme, isInserte
     if (cellNode.type.name === 'tableCell' || cellNode.type.name === 'tableHeader') {
       const nodeView = nodeViewSerializer.tryCreateNodeView(cellNode);
       if (nodeView) {
-        if (nodeView instanceof HTMLElement && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+        if (nodeView instanceof HTMLElement && isExtendedEnabled(diffType)) {
           const overlay = document.createElement('span');
           const overlayStyle = colorScheme === 'traditional' ? isInserted ? traditionalAddedCellOverlayStyle : deletedTraditionalCellOverlayStyle : isInserted ? addedCellOverlayStyle : deletedCellOverlayStyle;
           overlay.setAttribute('style', overlayStyle);
@@ -142,7 +143,8 @@ const createChangedRowDOM = (rowNode, nodeViewSerializer, colorScheme, isInserte
 const expandDiffForChangedRows = ({
   changes,
   originalDoc,
-  newDoc
+  newDoc,
+  diffType
 }) => {
   const rowInfo = [];
   for (const change of changes) {
@@ -150,7 +152,8 @@ const expandDiffForChangedRows = ({
     const changedRows = extractChangedRows({
       change,
       originalDoc,
-      newDoc
+      newDoc,
+      diffType
     });
     if (changedRows.length > 0) {
       rowInfo.push(...changedRows);
@@ -168,16 +171,18 @@ export const createChangedRowDecorationWidgets = ({
   newDoc,
   nodeViewSerializer,
   colorScheme,
-  isInserted = false
+  isInserted = false,
+  diffType
 }) => {
   // First, expand the changes to include complete deleted rows
   const changedRows = expandDiffForChangedRows({
     changes: changes.filter(change => change.deleted.length > 0),
     originalDoc,
-    newDoc
+    newDoc,
+    diffType
   });
   return changedRows.map(changedRow => {
-    const rowDOM = createChangedRowDOM(changedRow.rowNode, nodeViewSerializer, colorScheme, isInserted);
+    const rowDOM = createChangedRowDOM(changedRow.rowNode, nodeViewSerializer, colorScheme, isInserted, diffType);
 
     // Find safe insertion position for the deleted row
     const safeInsertPos = findSafeInsertPos(newDoc, changedRow.fromB - 1,
@@ -188,7 +193,8 @@ export const createChangedRowDecorationWidgets = ({
       ...buildDiffDecorationSpec({
         decorationType: 'widget',
         diffId,
-        isActive: false
+        isActive: false,
+        diffType
       })
     });
   });