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

package/dist/esm/pm-plugins/main.js

@@ -6,10 +6,10 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { calculateDiffDecorations } from './calculateDiff/calculateDiffDecorations';
 import { enforceCustomStepRegisters } from './enforceCustomStepRegisters';
 import { getScrollableDecorations } from './getScrollableDecorations';
+import { isExtendedEnabled } from './isExtendedEnabled';
 import { NodeViewSerializer } from './NodeViewSerializer';
 import { scrollToActiveDecoration, scrollToFirstDecoration } from './scrollToDiff';
 export var showDiffPluginKey = new PluginKey('showDiffPlugin');
@@ -31,7 +31,7 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
           originalDoc: undefined,
           decorations: DecorationSet.empty,
           isDisplayingChanges: false
-        }, expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) ? {
+        }, isExtendedEnabled() ? {
           isInverted: false,
           diffType: 'inline',
           hideDeletedDiffs: false,
@@ -44,7 +44,7 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
         var newPluginState = currentPluginState;
         if (meta) {
           if ((meta === null || meta === void 0 ? void 0 : meta.action) === 'SHOW_DIFF') {
-            var _newPluginState, _newPluginState2, _newPluginState3, _newPluginState4;
+            var _newPluginState, _newPluginState2, _newPluginState3, _newPluginState4, _newPluginState5, _newPluginState6, _newPluginState7, _newPluginState8;
             // Update the plugin state with the new metadata
             newPluginState = _objectSpread(_objectSpread(_objectSpread({}, currentPluginState), meta), {}, {
               isDisplayingChanges: true,
@@ -59,17 +59,19 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
                 intl: getIntl(),
                 activeIndexPos: newPluginState.activeIndexPos,
                 api: api
-              }, expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) ? {
-                isInverted: (_newPluginState = newPluginState) === null || _newPluginState === void 0 ? void 0 : _newPluginState.isInverted,
-                diffType: (_newPluginState2 = newPluginState) === null || _newPluginState2 === void 0 ? void 0 : _newPluginState2.diffType,
-                hideDeletedDiffs: (_newPluginState3 = newPluginState) === null || _newPluginState3 === void 0 ? void 0 : _newPluginState3.hideDeletedDiffs,
-                showIndicators: (_newPluginState4 = newPluginState) === null || _newPluginState4 === void 0 ? void 0 : _newPluginState4.showIndicators
+              }, isExtendedEnabled((_newPluginState = newPluginState) === null || _newPluginState === void 0 ? void 0 : _newPluginState.diffType) ? {
+                isInverted: (_newPluginState2 = newPluginState) === null || _newPluginState2 === void 0 ? void 0 : _newPluginState2.isInverted,
+                diffType: (_newPluginState3 = newPluginState) === null || _newPluginState3 === void 0 ? void 0 : _newPluginState3.diffType,
+                hideDeletedDiffs: (_newPluginState4 = newPluginState) === null || _newPluginState4 === void 0 ? void 0 : _newPluginState4.hideDeletedDiffs,
+                showIndicators: (_newPluginState5 = newPluginState) === null || _newPluginState5 === void 0 ? void 0 : _newPluginState5.showIndicators,
+                smartThresholds: (_newPluginState6 = newPluginState) === null || _newPluginState6 === void 0 ? void 0 : _newPluginState6.smartThresholds,
+                deletedDiffPlacement: (_newPluginState7 = newPluginState) === null || _newPluginState7 === void 0 ? void 0 : _newPluginState7.deletedDiffPlacement
               } : {})),
               decorations = _calculateDiffDecorat.decorations,
               diffDescriptors = _calculateDiffDecorat.diffDescriptors;
             // Update the decorations and their ids
             newPluginState.decorations = decorations;
-            if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+            if (isExtendedEnabled((_newPluginState8 = newPluginState) === null || _newPluginState8 === void 0 ? void 0 : _newPluginState8.diffType)) {
               newPluginState.diffDescriptors = diffDescriptors;
             }
           } else if ((meta === null || meta === void 0 ? void 0 : meta.action) === 'HIDE_DIFF') {
@@ -77,15 +79,16 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
               decorations: DecorationSet.empty,
               isDisplayingChanges: false,
               activeIndex: undefined
-            }, expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) ? {
+            }, isExtendedEnabled(currentPluginState.diffType) ? {
               isInverted: false,
               diffType: 'inline',
               hideDeletedDiffs: false,
               diffDescriptors: []
             } : {});
           } else if ((meta === null || meta === void 0 ? void 0 : meta.action) === 'SCROLL_TO_NEXT' || (meta === null || meta === void 0 ? void 0 : meta.action) === 'SCROLL_TO_PREVIOUS') {
+            var _newPluginState9;
             // Update the active index in plugin state and recalculate decorations
-            var _decorations = getScrollableDecorations(currentPluginState.decorations, newState.doc);
+            var _decorations = getScrollableDecorations(currentPluginState.decorations, newState.doc, (_newPluginState9 = newPluginState) === null || _newPluginState9 === void 0 ? void 0 : _newPluginState9.diffType);
             if (_decorations.length > 0) {
               var _currentPluginState$a;
               // Initialize to -1 if undefined so that the first "next" scroll takes us to index 0 (first change).
@@ -119,16 +122,18 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
                   intl: getIntl(),
                   activeIndexPos: newPluginState.activeIndexPos,
                   api: api
-                }, expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) ? {
+                }, isExtendedEnabled(newPluginState.diffType) ? {
                   isInverted: newPluginState.isInverted,
                   diffType: newPluginState.diffType,
                   hideDeletedDiffs: newPluginState.hideDeletedDiffs,
-                  showIndicators: newPluginState.showIndicators
+                  showIndicators: newPluginState.showIndicators,
+                  smartThresholds: newPluginState.smartThresholds,
+                  deletedDiffPlacement: newPluginState.deletedDiffPlacement
                 } : {})),
                 updatedDecorations = _calculateDiffDecorat2.decorations,
                 updatedDiffDescriptors = _calculateDiffDecorat2.diffDescriptors;
               newPluginState.decorations = updatedDecorations;
-              if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+              if (isExtendedEnabled(newPluginState.diffType)) {
                 newPluginState.diffDescriptors = updatedDiffDescriptors;
               }
             }
@@ -162,7 +167,7 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
           var pluginState = showDiffPluginKey.getState(view.state);
 
           // Scroll to the first decoration when scrollIntoView was requested
-          if (pluginState !== null && pluginState !== void 0 && pluginState.scrollIntoView && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+          if (pluginState !== null && pluginState !== void 0 && pluginState.scrollIntoView && isExtendedEnabled(pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType)) {
             var _cancelPendingScrollT;
             (_cancelPendingScrollT = cancelPendingScrollToDecoration) === null || _cancelPendingScrollT === void 0 || _cancelPendingScrollT();
             cancelPendingScrollToDecoration = scrollToFirstDecoration(view, pluginState.decorations);
@@ -179,7 +184,7 @@ export var createPlugin = function createPlugin(config, getIntl, api) {
           if ((pluginState === null || pluginState === void 0 ? void 0 : pluginState.activeIndex) !== undefined && activeIndexChanged) {
             var _cancelPendingScrollT2, _api$expand;
             (_cancelPendingScrollT2 = cancelPendingScrollToDecoration) === null || _cancelPendingScrollT2 === void 0 || _cancelPendingScrollT2();
-            var scrollableDecorations = getScrollableDecorations(pluginState.decorations, view.state.doc);
+            var scrollableDecorations = getScrollableDecorations(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType);
             var activeDecoration = scrollableDecorations[pluginState.activeIndex];
             if (activeDecoration && api !== null && api !== void 0 && (_api$expand = api.expand) !== null && _api$expand !== void 0 && (_api$expand = _api$expand.commands) !== null && _api$expand !== void 0 && _api$expand.toggleExpandRange) {
               api === null || api === void 0 || api.core.actions.execute(api.expand.commands.toggleExpandRange(activeDecoration.from, activeDecoration.to, true));

package/dist/types/entry-points/calculate-diff.d.ts

@@ -0,0 +1,2 @@
+export { computeDiffChanges } from '../pm-plugins/calculateDiff/computeDiffChanges';
+export type { ComputeDiffChangesParams } from '../pm-plugins/calculateDiff/computeDiffChanges';

package/dist/types/entry-points/show-diff-plugin-type.d.ts

@@ -1 +1 @@
-export type { DiffParams, PMDiffParams, ShowDiffPlugin } from '../showDiffPluginType';
+export type { DeletedDiffPlacement, DiffParams, DiffType, PMDiffParams, ShowDiffPlugin, SmartDiffThresholds, } from '../showDiffPluginType';

package/dist/types/pm-plugins/calculateDiff/calculateDiffDecorations.d.ts

@@ -3,7 +3,7 @@ import type { IntlShape } from 'react-intl';
 import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import type { ColorScheme, DiffDescriptor, ShowDiffPlugin } from '../../showDiffPluginType';
+import type { ColorScheme, DeletedDiffPlacement, DiffDescriptor, ShowDiffPlugin, SmartDiffThresholds } from '../../showDiffPluginType';
 import type { ShowDiffPluginState } from '../main';
 import type { NodeViewSerializer } from '../NodeViewSerializer';
 type CalculatedDiffs = {
@@ -17,11 +17,13 @@ export declare const calculateDiffDecorations: MemoizedFn<({ state, pluginState,
     };
     api: ExtractInjectionAPI<ShowDiffPlugin> | undefined;
     colorScheme?: ColorScheme;
+    deletedDiffPlacement?: DeletedDiffPlacement;
     hideDeletedDiffs?: boolean;
     intl: IntlShape;
     nodeViewSerializer: NodeViewSerializer;
     pluginState: Omit<ShowDiffPluginState, 'decorations'>;
     showIndicators?: boolean;
+    smartThresholds?: Partial<SmartDiffThresholds>;
     state: EditorState;
 }) => CalculatedDiffs>;
 export {};

package/dist/types/pm-plugins/calculateDiff/computeDiffChanges.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generic, editor-state-free diff-change computation.
+ *
+ * Turns an `originalDoc` + forward `steps` into the classified `Change[]` for the
+ * requested `diffType`, plus the reconstructed new document — the same classifier
+ * the diff overlay uses (`calculateDiffDecorations` → `getChanges`), exposed as a
+ * reusable utility (e.g. to derive reviewable segments without rendering
+ * decorations). It runs the requested `diffType` DIRECTLY and does NOT apply the
+ * overlay's `platform_editor_ai_smart_diff` gate, so a `smart` result here can
+ * differ from what the overlay draws when that gate is off (the overlay falls back
+ * to inline); callers that need overlay parity must account for that gate.
+ *
+ * Pure: no `EditorState`, no transactions, no React. The new document is
+ * reconstructed by applying the (simplified) steps to `originalDoc`.
+ */
+import { type Change } from 'prosemirror-changeset';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
+import type { DiffType, SmartDiffThresholds } from '../../showDiffPluginType';
+export type ComputeDiffChangesParams = {
+    /**
+     * Which classification to run. Defaults to `smart` — the density-aware model.
+     * The other types are supported for parity with the diff overlay's
+     * `getChanges`.
+     */
+    diffType?: DiffType;
+    /** BCP-47 locale for `smart` sentence/word segmentation. Defaults to `en`. */
+    locale?: string;
+    /** The pre-edit document (the diff's left/original side). */
+    originalDoc: PMNode;
+    /** Optional overrides for the `smart` density thresholds. Ignored otherwise. */
+    smartThresholds?: Partial<SmartDiffThresholds>;
+    /** Forward `original → new` steps (the standard non-inverted contract). */
+    steps: ProseMirrorStep[];
+};
+/**
+ * Apply the (simplified) steps to `originalDoc` to reconstruct the new doc, and
+ * compute the classified `Change[]` for the requested `diffType`. Mirrors the
+ * body of `calculateDiffDecorations` → `getChanges` so callers stay in lock-step
+ * with the rendered diff. Returns an empty change list (and `originalDoc` as the
+ * new doc) when there are no steps.
+ */
+export declare const computeDiffChanges: ({ originalDoc, steps, diffType, locale, smartThresholds, }: ComputeDiffChangesParams) => {
+    changes: Change[];
+    newDoc: PMNode;
+};

package/dist/types/pm-plugins/calculateDiff/groupChangesByBlock.d.ts

@@ -1,5 +1,14 @@
 import type { Change } from 'prosemirror-changeset';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Finds the position range (outer bounds) of the top-level block (direct child of doc) that
+ * contains the range [from, to]. Shared with the `smart` diff type so its block grouping is
+ * identical to the `block` diff type by construction.
+ */
+export declare function getTopLevelBlockAt(doc: PMNode, from: number, to: number): {
+    from: number;
+    to: number;
+};
 /**
  * Groups all changes that fall within the same top-level block (direct child of doc)
  * and merges them into a single change spanning the full block in both old and new doc.

package/dist/types/pm-plugins/calculateDiff/smart/classifySmartChanges.d.ts

@@ -0,0 +1,26 @@
+import type { Change } from 'prosemirror-changeset';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { type SmartDiffThresholds } from './thresholds';
+export type ClassifySmartChangesArgs = {
+    changes: Change[];
+    locale: string;
+    newDoc: PMNode;
+    originalDoc: PMNode;
+    thresholds?: Partial<SmartDiffThresholds>;
+};
+/**
+ * Block-first `smart` classifier.
+ *
+ * Groups changes by the top-level block they touch — like the `block` diff type — then
+ * classifies WITHIN each block group:
+ *
+ *   1. structural / node-type change (blockA.type !== blockB.type)  → whole block
+ *   2. text-bearing block (paragraph/heading)                       → sentence / paragraph / inline
+ *   3. container block (list/table/layout/panel/...)                → recurse into children,
+ *      promoting the whole container when changed-child density ≥ node.ratio (with the
+ *      rigid-child escalation: cell → row → table, column → section, item → list).
+ *
+ * Grouping on real top-level block boundaries prevents the "empty structural shell" family
+ * of bugs (e.g. bulletList → table rendering empty bullets).
+ */
+export declare const classifySmartChanges: ({ changes, originalDoc, newDoc, locale, thresholds: overrides, }: ClassifySmartChangesArgs) => Change[];

package/dist/types/pm-plugins/calculateDiff/smart/helpers.d.ts

@@ -0,0 +1,44 @@
+import type { Change } from 'prosemirror-changeset';
+/**
+ * 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.
+ */
+export type SmartChangeLevel = 'sentence' | 'paragraph' | 'node';
+/** Span `data` payload carried by promoted `smart` changes. */
+export type SmartSpanData = {
+    smartLevel: SmartChangeLevel;
+} | null;
+/**
+ * Build the `deleted`/`inserted` span arrays a `Change` needs. A length of 0 yields an
+ * empty array (no change on that side).
+ */
+export declare const createSpans: (length: number, data?: SmartSpanData) => Change["inserted"];
+/**
+ * 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 declare const makePromotedChange: (fromA: number, toA: number, fromB: number, toB: number, level?: SmartChangeLevel) => Change;
+/**
+ * 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 declare const smartChangeLevel: (change: Pick<Change, "inserted" | "deleted">) => SmartChangeLevel | undefined;
+/**
+ * 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 declare const mergeOverlappingByNewDocRange: (changes: Change[]) => Change[];
+/** True when two half-open ranges overlap. */
+export declare const rangesOverlap: (aFrom: number, aTo: number, bFrom: number, bTo: number) => boolean;

package/dist/types/pm-plugins/calculateDiff/smart/segmentText.d.ts

@@ -0,0 +1,32 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/**
+ * 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`).
+ */
+export type OffsetSpan = {
+    from: number;
+    to: number;
+};
+/**
+ * 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 declare const buildCharsByOffset: (parent: PMNode) => Array<string | null>;
+/**
+ * Segment a textblock char-view into sentence spans (content-offset coordinates).
+ * Uses Intl.Segmenter when available, otherwise a conservative regex fallback.
+ */
+export declare const segmentSentences: (chars: Array<string | null>, locale: string) => OffsetSpan[];
+/**
+ * Count word-like tokens within a content-offset range of the char-view.
+ * Each opaque inline token (`null`) counts as exactly one word.
+ */
+export declare const countWords: (chars: Array<string | null>, span: OffsetSpan, locale: string) => number;
+/**
+ * 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 declare const segmentWordSpans: (chars: Array<string | null>, span: OffsetSpan, locale: string) => OffsetSpan[];

package/dist/types/pm-plugins/calculateDiff/smart/thresholds.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Configurable thresholds for the `smart` diffType.
+ *
+ * See docs/smart-diff-design.md §3 and §6 for the exact semantics of each level.
+ */
+export type SmartDiffThresholds = {
+    /**
+     * Node/container level. Unit = direct children.
+     * - `ratio`: promote to node-level when
+     *   `changedChildren / max(childrenOld, childrenNew) >= ratio`.
+     * - `textBearingRatio`: alternatively promote when the fraction of text-bearing
+     *   children (paragraph/heading) that were themselves promoted to paragraph-level
+     *   is `>= textBearingRatio`.
+     */
+    node: {
+        ratio: number;
+        textBearingRatio: number;
+    };
+    /**
+     * Paragraph/textblock level. Unit = sentences.
+     * Promote when `sentencesChanged >= minChanged` AND
+     * `sentencesChanged / max(sentencesOld, sentencesNew) >= ratio`.
+     */
+    paragraph: {
+        minChanged: number;
+        ratio: number;
+    };
+    /**
+     * Sentence level. Unit = words (inline non-text nodes count as one word).
+     * Promote when `wordsChanged >= minChanged` AND
+     * `wordsChanged / max(wordsOld, wordsNew) >= ratio`.
+     */
+    sentence: {
+        minChanged: number;
+        ratio: number;
+    };
+};
+export declare const DEFAULT_SMART_THRESHOLDS: SmartDiffThresholds;
+/**
+ * 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 declare const resolveThresholds: (overrides?: Partial<SmartDiffThresholds>) => SmartDiffThresholds;

package/dist/types/pm-plugins/decorations/createBlockChangedDecoration.d.ts

@@ -1,6 +1,6 @@
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import type { ColorScheme } from '../../showDiffPluginType';
+import type { ColorScheme, DiffType } from '../../showDiffPluginType';
 /**
  * Node decoration used for block-level insertions. When isActive, uses emphasised (pressed) styling.
  *
@@ -9,13 +9,14 @@ import type { ColorScheme } from '../../showDiffPluginType';
  * @param isActive Whether this node is part of the currently active/focused change
  * @returns Prosemirror node decoration or undefined
  */
-export declare const createBlockChangedDecoration: ({ change, colorScheme, isInserted, isActive, shouldHideDeleted, showIndicators, doc, }: {
+export declare const createBlockChangedDecoration: ({ change, colorScheme, isInserted, isActive, shouldHideDeleted, showIndicators, doc, diffType, }: {
     change: {
         from: number;
         name: string;
         to: number;
     };
     colorScheme?: ColorScheme;
+    diffType?: DiffType;
     doc?: PMNode;
     isActive?: boolean;
     isInserted?: boolean;

package/dist/types/pm-plugins/decorations/createChangedRowDecorationWidgets.d.ts

@@ -1,15 +1,16 @@
 import type { Change } from 'prosemirror-changeset';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import type { ColorScheme } from '../../showDiffPluginType';
+import type { ColorScheme, DiffType } from '../../showDiffPluginType';
 import type { NodeViewSerializer } from '../NodeViewSerializer';
 type SimpleChange = Pick<Change, 'fromA' | 'toA' | 'fromB' | 'deleted'>;
 /**
  * Main function to handle deleted rows - computes diff and creates decorations
  */
-export declare const createChangedRowDecorationWidgets: ({ changes, originalDoc, newDoc, nodeViewSerializer, colorScheme, isInserted, }: {
+export declare const createChangedRowDecorationWidgets: ({ changes, originalDoc, newDoc, nodeViewSerializer, colorScheme, isInserted, diffType, }: {
     changes: SimpleChange[];
     colorScheme?: ColorScheme;
+    diffType?: DiffType;
     isInserted?: boolean;
     newDoc: PMNode;
     nodeViewSerializer: NodeViewSerializer;

package/dist/types/pm-plugins/decorations/createInlineChangedDecoration.d.ts

@@ -1,18 +1,19 @@
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import type { ColorScheme } from '../../showDiffPluginType';
+import type { ColorScheme, DiffType } from '../../showDiffPluginType';
 /**
  * Inline decoration used for insertions as the content already exists in the document
  *
  * @param change Changeset "change" containing information about the change content + range
  * @returns Prosemirror inline decoration
  */
-export declare const createInlineChangedDecoration: ({ change, colorScheme, isActive, isInserted, shouldHideDeleted, showIndicators, doc, }: {
+export declare const createInlineChangedDecoration: ({ change, colorScheme, isActive, isInserted, shouldHideDeleted, showIndicators, doc, diffType, }: {
     change: {
         fromB: number;
         toB: number;
     };
     colorScheme?: ColorScheme;
+    diffType?: DiffType;
     doc?: PMNode;
     isActive?: boolean;
     isInserted?: boolean;

package/dist/types/pm-plugins/decorations/createNodeChangedDecorationWidget.d.ts

@@ -2,23 +2,25 @@ import type { Change } from 'prosemirror-changeset';
 import type { IntlShape } from 'react-intl';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import type { ColorScheme } from '../../showDiffPluginType';
+import type { ColorScheme, DiffType } from '../../showDiffPluginType';
 import type { NodeViewSerializer } from '../NodeViewSerializer';
 /**
  * This function is used to create a decoration widget to show content
  * that is not in the current document.
  */
-export declare const createNodeChangedDecorationWidget: ({ change, doc, nodeViewSerializer, colorScheme, newDoc, intl, activeIndexPos, isInserted, showIndicators, }: {
+export declare const createNodeChangedDecorationWidget: ({ change, doc, nodeViewSerializer, colorScheme, newDoc, intl, activeIndexPos, isInserted, showIndicators, placeBelow, diffType, }: {
     activeIndexPos?: {
         from: number;
         to: number;
     };
     change: Pick<Change, "fromA" | "toA" | "fromB" | "deleted" | "toB">;
     colorScheme?: ColorScheme;
+    diffType?: DiffType;
     doc: PMNode;
     intl: IntlShape;
     isInserted?: boolean;
     newDoc: PMNode;
     nodeViewSerializer: NodeViewSerializer;
+    placeBelow?: boolean;
     showIndicators?: boolean;
 }) => Decoration[];

package/dist/types/pm-plugins/decorations/decorationKeys.d.ts

@@ -1,5 +1,5 @@
 import type { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import type { DiffDescriptor } from '../../showDiffPluginType';
+import type { DiffDescriptor, DiffType } from '../../showDiffPluginType';
 /**
  * Decoration families produced by the show-diff plugin.
  * Each family owns its own key space and spec shape.
@@ -53,14 +53,16 @@ export declare const buildAnchorDecorationKey: ({ diffId, anchorType, }: {
  * in the key so independently rendered decorations for the same type remain
  * distinguishable.
  */
-export declare const buildDiffDecorationKey: ({ decorationKeyPrefix, isActive, diffId, }: {
+export declare const buildDiffDecorationKey: ({ decorationKeyPrefix, isActive, diffId, diffType, }: {
     decorationKeyPrefix: (typeof DiffDecorationKey)[DiffDescriptor["type"]];
     diffId?: string;
+    diffType?: DiffType;
     isActive?: boolean;
 }) => string;
-export declare const buildDiffDecorationSpec: ({ decorationType, diffId, isActive, nodeName, side, }: {
+export declare const buildDiffDecorationSpec: ({ decorationType, diffId, isActive, nodeName, side, diffType, }: {
     decorationType: DiffDescriptor["type"];
     diffId: string;
+    diffType?: DiffType;
     isActive?: boolean;
     nodeName?: string;
     side?: number;

package/dist/types/pm-plugins/decorations/utils/wrapBlockNodeView.d.ts

@@ -1,13 +1,14 @@
 import type { IntlShape } from 'react-intl';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-import type { ColorScheme } from '../../../showDiffPluginType';
+import type { ColorScheme, DiffType } from '../../../showDiffPluginType';
 /**
  * Handles all block node rendering with appropriate deleted styling.
  * For heading nodes, applies styles directly to preserve natural margins.
  * For other block nodes, uses wrapper approach with optional lozenge.
  */
-export declare const wrapBlockNodeView: ({ dom, nodeView, targetNode, colorScheme, intl, isActive, isInserted, }: {
+export declare const wrapBlockNodeView: ({ dom, nodeView, targetNode, colorScheme, intl, isActive, isInserted, diffType, }: {
     colorScheme?: ColorScheme;
+    diffType?: DiffType;
     dom: HTMLElement;
     intl: IntlShape;
     isActive?: boolean;
@@ -20,8 +21,9 @@ export declare const wrapBlockNodeView: ({ dom, nodeView, targetNode, colorSchem
  * CSS backgrounds don't work when applied to a wrapper around a paragraph, so
  * the wrapper needs to be injected inside the node around the child content.
  */
-export declare const injectInnerWrapper: ({ node, colorScheme, isActive, isInserted, }: {
+export declare const injectInnerWrapper: ({ node, colorScheme, isActive, isInserted, diffType, }: {
     colorScheme?: ColorScheme;
+    diffType?: DiffType;
     isActive?: boolean;
     isInserted?: boolean;
     node: HTMLElement;
@@ -29,4 +31,4 @@ export declare const injectInnerWrapper: ({ node, colorScheme, isActive, isInser
 /**
  * Creates a styled span wrapper for inline content within a change decoration.
  */
-export declare const createContentWrapper: (colorScheme?: ColorScheme, isActive?: boolean, isInserted?: boolean) => HTMLElement;
+export declare const createContentWrapper: (colorScheme?: ColorScheme, isActive?: boolean, isInserted?: boolean, diffType?: DiffType) => HTMLElement;

package/dist/types/pm-plugins/getScrollableDecorations.d.ts

@@ -1,5 +1,6 @@
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { DiffType } from '../showDiffPluginType';
 /**
  * Returns true when an inline decoration's [from, to) range can actually show in the document:
  * positions are valid, and the slice contains at least one inline node ProseMirror would paint
@@ -24,4 +25,4 @@ export declare function isInlineDiffDecorationRenderableInDoc(doc: PMNode, from:
  * @param doc - Current document; when set, diff-inline ranges are validated against this doc
  * @returns Array of scrollable decorations, sorted and deduplicated
  */
-export declare const getScrollableDecorations: (set: DecorationSet | undefined, doc?: PMNode) => Decoration[];
+export declare const getScrollableDecorations: (set: DecorationSet | undefined, doc?: PMNode, diffType?: DiffType) => Decoration[];

package/dist/types/pm-plugins/isExtendedEnabled.d.ts

@@ -0,0 +1,11 @@
+import type { DiffType } from '../showDiffPluginType';
+/**
+ * The "extended" diff pipeline is normally gated by `platform_editor_diff_plugin_extended`.
+ * The `smart` diff type REQUIRES the extended pipeline, so whenever `smart` is active (and its
+ * own gate `platform_editor_ai_smart_diff` is on) the extended pipeline is force-enabled,
+ * independent of the extended gate. For all other diff types the extended gate alone decides.
+ *
+ * Pass the active `diffType` so callers deep in the decoration layer render the extended shape
+ * when `smart` is active even if `platform_editor_diff_plugin_extended` is off.
+ */
+export declare const isExtendedEnabled: (diffType?: DiffType) => boolean;

package/dist/types/pm-plugins/main.d.ts

@@ -5,7 +5,7 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import type { DiffDescriptor, DiffParams, DiffType, ShowDiffPlugin } from '../showDiffPluginType';
+import type { DeletedDiffPlacement, DiffDescriptor, DiffParams, DiffType, ShowDiffPlugin, SmartDiffThresholds } from '../showDiffPluginType';
 export declare const showDiffPluginKey: PluginKey<ShowDiffPluginState>;
 export type ShowDiffPluginState = {
     activeIndex?: number;
@@ -14,6 +14,11 @@ export type ShowDiffPluginState = {
         to: number;
     };
     decorations: DecorationSet;
+    /**
+     * For the `smart` diffType, where node/paragraph-level deleted content is rendered relative to
+     * the new content. Set via SHOW_DIFF meta. Defaults to `'top'`.
+     */
+    deletedDiffPlacement?: DeletedDiffPlacement;
     /**
      * The diff descriptors of the diff decorations currently being displayed.
      * Only set when `platform_editor_diff_plugin_extended` is on.
@@ -30,6 +35,11 @@ export type ShowDiffPluginState = {
      */
     scrollIntoView?: boolean;
     showIndicators?: boolean;
+    /**
+     * Optional overrides for the `smart` diffType density thresholds. Set via SHOW_DIFF
+     * meta. Only relevant when `diffType === 'smart'`.
+     */
+    smartThresholds?: Partial<SmartDiffThresholds>;
     steps: ProseMirrorStep[];
 };
 export declare const createPlugin: (config: DiffParams | undefined, getIntl: () => IntlShape, api: ExtractInjectionAPI<ShowDiffPlugin> | undefined) => SafePlugin<ShowDiffPluginState>;

package/dist/types/showDiffPluginType.d.ts

@@ -6,8 +6,17 @@ import type { ExpandPlugin } from '@atlaskit/editor-plugin-expand';
 import type { UserIntentPlugin } from '@atlaskit/editor-plugin-user-intent';
 import type { Node } from '@atlaskit/editor-prosemirror/model';
 import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import type { SmartDiffThresholds as SmartDiffThresholdsInternal } from './pm-plugins/calculateDiff/smart/thresholds';
 export type ColorScheme = 'standard' | 'traditional';
-export type DiffType = 'inline' | 'block' | 'step';
+export type DiffType = 'inline' | 'block' | 'step' | 'smart';
+/**
+ * Where node/paragraph-level deleted content is rendered relative to the new (replacement)
+ * content in the `smart` diffType:
+ * - `'top'` (default): the deleted content is anchored above the new content.
+ * - `'bottom'`: the deleted content is anchored below the new content.
+ */
+export type DeletedDiffPlacement = 'top' | 'bottom';
+export type SmartDiffThresholds = SmartDiffThresholdsInternal;
 export type DiffDescriptor = {
     id: string;
     type: 'inline' | 'block' | 'widget';
@@ -26,10 +35,20 @@ export type DiffParams = {
     steps: StepJson[];
 };
 export type PMDiffParams = {
+    /**
+     * For the `smart` diffType, where node/paragraph-level deleted content is rendered relative to
+     * the new content. Defaults to `'top'`. Ignored for other diff types.
+     */
+    deletedDiffPlacement?: DeletedDiffPlacement;
     diffType?: DiffType;
     hideDeletedDiffs?: boolean;
     isInverted?: boolean;
     originalDoc: Node;
+    /**
+     * Optional overrides for the `smart` diffType density thresholds. Ignored for other
+     * diff types. Partial — omitted fields fall back to defaults.
+     */
+    smartThresholds?: Partial<SmartDiffThresholds>;
     /**
      * When true, the editor will scroll to bring the first diff decoration into view
      * after the diff is shown.