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

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 10.3.0
+
+### Minor Changes
+
+- [`21147179a56ea`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/21147179a56ea) -
+  [CCI-17809] Overhaul Post Stream Review segmenting.
+
+  `@atlaskit/editor-plugin-show-diff`: add a generic `computeDiffChanges` utility (new
+  `@atlaskit/editor-plugin-show-diff/calculate-diff` entry point) that returns the classified
+  `Change[]` and reconstructed new document for a given `originalDoc` + `steps`, without rendering
+  decorations. It reuses the same classifier the diff overlay renders from (default
+  `diffType: 'smart'`), so consumers can derive their own reviewable segments that line up with what
+  the overlay would draw. Exposes the `ComputeDiffChangesParams` type.
+
+  `@atlassian/editor-plugin-ai`: support two segmenting strategies in the Post Stream Review
+  step-through, selected by the new `platform_editor_ai_diff_based_segmenting` gate. Gate ON =
+  diff-based (`smart`) segmenting (via the show-diff `computeDiffChanges` utility, shaped into
+  reviewable segments in the AI plugin); gate OFF (default) = top-level-node segmenting, which no
+  longer splits a list into individual list items. Fine segments are now stored in plugin state and
+  remapped on every doc change, so per-segment undo/redo and view-changes stay correct after an
+  undo. Aggregate ("all changes") mode is unchanged.
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 10.2.0
 
 ### Minor Changes

package/calculate-diff/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@atlaskit/editor-plugin-show-diff/calculate-diff",
+  "main": "../dist/cjs/entry-points/calculate-diff.js",
+  "module": "../dist/esm/entry-points/calculate-diff.js",
+  "module:es2019": "../dist/es2019/entry-points/calculate-diff.js",
+  "sideEffects": false,
+  "types": "../dist/types/entry-points/calculate-diff.d.ts"
+}

package/dist/cjs/entry-points/calculate-diff.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "computeDiffChanges", {
+  enumerable: true,
+  get: function get() {
+    return _computeDiffChanges.computeDiffChanges;
+  }
+});
+var _computeDiffChanges = require("../pm-plugins/calculateDiff/computeDiffChanges");

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

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeDiffChanges = void 0;
+var _prosemirrorChangeset = require("prosemirror-changeset");
+var _diffBySteps = require("./diffBySteps");
+var _groupChangesByBlock = require("./groupChangesByBlock");
+var _optimizeChanges = require("./optimizeChanges");
+var _simplifySteps = require("./simplifySteps");
+var _classifySmartChanges = require("./smart/classifySmartChanges");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /**
+ * 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`.
+ */
+/**
+ * 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.
+ */
+var computeDiffChanges = exports.computeDiffChanges = function computeDiffChanges(_ref) {
+  var originalDoc = _ref.originalDoc,
+    steps = _ref.steps,
+    _ref$diffType = _ref.diffType,
+    diffType = _ref$diffType === void 0 ? 'smart' : _ref$diffType,
+    _ref$locale = _ref.locale,
+    locale = _ref$locale === void 0 ? 'en' : _ref$locale,
+    smartThresholds = _ref.smartThresholds;
+  if (!steps || steps.length === 0) {
+    return {
+      changes: [],
+      newDoc: originalDoc
+    };
+  }
+  var simplifiedSteps = (0, _simplifySteps.simplifySteps)(steps, originalDoc);
+  var steppedDoc = originalDoc;
+  var stepMaps = [];
+  try {
+    var _iterator = _createForOfIteratorHelper(simplifiedSteps),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var step = _step.value;
+        var result = step.apply(steppedDoc);
+        if (result.failed === null && result.doc) {
+          stepMaps.push(step.getMap());
+          steppedDoc = result.doc;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } catch (_unused) {
+    // A step's positions fell outside the current doc — `ReplaceStep.apply`
+    // throws a RangeError (rather than returning a failed result) when a
+    // position exceeds the doc size. This can happen for pathological or
+    // inconsistent step sequences. Bail with no changes rather than letting the
+    // error propagate to the caller (which, for the PSR, would crash the
+    // toolbar); the consumer then falls back to its non-diff segmenting path.
+    return {
+      changes: [],
+      newDoc: originalDoc
+    };
+  }
+  var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, steppedDoc);
+  if (diffType === 'smart') {
+    return {
+      changes: (0, _classifySmartChanges.classifySmartChanges)({
+        changes: (0, _prosemirrorChangeset.simplifyChanges)(changeset.changes, steppedDoc),
+        originalDoc: originalDoc,
+        newDoc: steppedDoc,
+        locale: locale,
+        thresholds: smartThresholds
+      }),
+      newDoc: steppedDoc
+    };
+  }
+  if (diffType === 'block') {
+    return {
+      changes: (0, _groupChangesByBlock.groupChangesByBlock)(changeset.changes, originalDoc, steppedDoc),
+      newDoc: steppedDoc
+    };
+  }
+  if (diffType === 'step') {
+    return {
+      changes: (0, _diffBySteps.diffBySteps)(originalDoc, simplifiedSteps),
+      newDoc: steppedDoc
+    };
+  }
+  return {
+    changes: (0, _optimizeChanges.optimizeChanges)((0, _prosemirrorChangeset.simplifyChanges)(changeset.changes, steppedDoc)),
+    newDoc: steppedDoc
+  };
+};

package/dist/es2019/entry-points/calculate-diff.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { computeDiffChanges } from '../pm-plugins/calculateDiff/computeDiffChanges';

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

@@ -0,0 +1,94 @@
+/**
+ * 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 { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
+import { diffBySteps } from './diffBySteps';
+import { groupChangesByBlock } from './groupChangesByBlock';
+import { optimizeChanges } from './optimizeChanges';
+import { simplifySteps } from './simplifySteps';
+import { classifySmartChanges } from './smart/classifySmartChanges';
+/**
+ * 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 const computeDiffChanges = ({
+  originalDoc,
+  steps,
+  diffType = 'smart',
+  locale = 'en',
+  smartThresholds
+}) => {
+  if (!steps || steps.length === 0) {
+    return {
+      changes: [],
+      newDoc: originalDoc
+    };
+  }
+  const simplifiedSteps = simplifySteps(steps, originalDoc);
+  let steppedDoc = originalDoc;
+  const stepMaps = [];
+  try {
+    for (const step of simplifiedSteps) {
+      const result = step.apply(steppedDoc);
+      if (result.failed === null && result.doc) {
+        stepMaps.push(step.getMap());
+        steppedDoc = result.doc;
+      }
+    }
+  } catch {
+    // A step's positions fell outside the current doc — `ReplaceStep.apply`
+    // throws a RangeError (rather than returning a failed result) when a
+    // position exceeds the doc size. This can happen for pathological or
+    // inconsistent step sequences. Bail with no changes rather than letting the
+    // error propagate to the caller (which, for the PSR, would crash the
+    // toolbar); the consumer then falls back to its non-diff segmenting path.
+    return {
+      changes: [],
+      newDoc: originalDoc
+    };
+  }
+  const changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, steppedDoc);
+  if (diffType === 'smart') {
+    return {
+      changes: classifySmartChanges({
+        changes: simplifyChanges(changeset.changes, steppedDoc),
+        originalDoc,
+        newDoc: steppedDoc,
+        locale,
+        thresholds: smartThresholds
+      }),
+      newDoc: steppedDoc
+    };
+  }
+  if (diffType === 'block') {
+    return {
+      changes: groupChangesByBlock(changeset.changes, originalDoc, steppedDoc),
+      newDoc: steppedDoc
+    };
+  }
+  if (diffType === 'step') {
+    return {
+      changes: diffBySteps(originalDoc, simplifiedSteps),
+      newDoc: steppedDoc
+    };
+  }
+  return {
+    changes: optimizeChanges(simplifyChanges(changeset.changes, steppedDoc)),
+    newDoc: steppedDoc
+  };
+};

package/dist/esm/entry-points/calculate-diff.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { computeDiffChanges } from '../pm-plugins/calculateDiff/computeDiffChanges';

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

@@ -0,0 +1,107 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * 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 { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
+import { diffBySteps } from './diffBySteps';
+import { groupChangesByBlock } from './groupChangesByBlock';
+import { optimizeChanges } from './optimizeChanges';
+import { simplifySteps } from './simplifySteps';
+import { classifySmartChanges } from './smart/classifySmartChanges';
+/**
+ * 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 var computeDiffChanges = function computeDiffChanges(_ref) {
+  var originalDoc = _ref.originalDoc,
+    steps = _ref.steps,
+    _ref$diffType = _ref.diffType,
+    diffType = _ref$diffType === void 0 ? 'smart' : _ref$diffType,
+    _ref$locale = _ref.locale,
+    locale = _ref$locale === void 0 ? 'en' : _ref$locale,
+    smartThresholds = _ref.smartThresholds;
+  if (!steps || steps.length === 0) {
+    return {
+      changes: [],
+      newDoc: originalDoc
+    };
+  }
+  var simplifiedSteps = simplifySteps(steps, originalDoc);
+  var steppedDoc = originalDoc;
+  var stepMaps = [];
+  try {
+    var _iterator = _createForOfIteratorHelper(simplifiedSteps),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var step = _step.value;
+        var result = step.apply(steppedDoc);
+        if (result.failed === null && result.doc) {
+          stepMaps.push(step.getMap());
+          steppedDoc = result.doc;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } catch (_unused) {
+    // A step's positions fell outside the current doc — `ReplaceStep.apply`
+    // throws a RangeError (rather than returning a failed result) when a
+    // position exceeds the doc size. This can happen for pathological or
+    // inconsistent step sequences. Bail with no changes rather than letting the
+    // error propagate to the caller (which, for the PSR, would crash the
+    // toolbar); the consumer then falls back to its non-diff segmenting path.
+    return {
+      changes: [],
+      newDoc: originalDoc
+    };
+  }
+  var changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, steppedDoc);
+  if (diffType === 'smart') {
+    return {
+      changes: classifySmartChanges({
+        changes: simplifyChanges(changeset.changes, steppedDoc),
+        originalDoc: originalDoc,
+        newDoc: steppedDoc,
+        locale: locale,
+        thresholds: smartThresholds
+      }),
+      newDoc: steppedDoc
+    };
+  }
+  if (diffType === 'block') {
+    return {
+      changes: groupChangesByBlock(changeset.changes, originalDoc, steppedDoc),
+      newDoc: steppedDoc
+    };
+  }
+  if (diffType === 'step') {
+    return {
+      changes: diffBySteps(originalDoc, simplifiedSteps),
+      newDoc: steppedDoc
+    };
+  }
+  return {
+    changes: optimizeChanges(simplifyChanges(changeset.changes, steppedDoc)),
+    newDoc: steppedDoc
+  };
+};

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/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "10.2.0",
+	"version": "10.3.0",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -28,7 +28,7 @@
 		"@atlaskit/editor-prosemirror": "^8.0.0",
 		"@atlaskit/editor-tables": "^3.0.0",
 		"@atlaskit/platform-feature-flags": "^2.0.0",
-		"@atlaskit/tmp-editor-statsig": "^124.0.0",
+		"@atlaskit/tmp-editor-statsig": "^124.1.0",
 		"@atlaskit/tokens": "^15.5.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^0.20.0",