@atlaskit/editor-plugin-collab-edit 7.1.11 → 7.2.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/editor-plugin-collab-edit
 
+## 7.2.1
+
+### Patch Changes
+
+- [`c32dc3155a31a`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/c32dc3155a31a) -
+  Added an organic changes monitor which will reported anayltics when an organic change occurs. The
+  new analytic will contain extra information regarding only the transaction which caused the
+  organic change.
+- Updated dependencies
+
+## 7.2.0
+
+### Minor Changes
+
+- [`c6d3be25ea8e1`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/c6d3be25ea8e1) -
+  Export LastOrganicChangeMetadata
+
 ## 7.1.11
 
 ### Patch Changes

package/dist/cjs/collabEditPlugin.js

@@ -13,6 +13,7 @@ var _analytics = require("@atlaskit/editor-common/analytics");
 var _utils = require("@atlaskit/editor-common/utils");
 var _editorJsonTransformer = require("@atlaskit/editor-json-transformer");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _prosemirrorCollab = require("@atlaskit/prosemirror-collab");
 var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _experiments = require("@atlaskit/tmp-editor-statsig/experiments");
@@ -22,6 +23,7 @@ var _filterAnalytics = require("./pm-plugins/filterAnalytics");
 var _main = require("./pm-plugins/main");
 var _pluginKey = require("./pm-plugins/main/plugin-key");
 var _mergeUnconfirmed = require("./pm-plugins/mergeUnconfirmed");
+var _monitorOrganicChanges = require("./pm-plugins/monitor-organic-changes");
 var _nativeCollabProviderPlugin = require("./pm-plugins/native-collab-provider-plugin");
 var _trackAndFilterSpammingSteps = require("./pm-plugins/track-and-filter-spamming-steps");
 var _trackLastOrganicChange = require("./pm-plugins/track-last-organic-change");
@@ -190,7 +192,7 @@ var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref
         return content.every(function (node) {
           try {
             node.check(); // this will throw an error if the node is invalid
-          } catch (error) {
+          } catch (_unused) {
             return false;
           }
           return true;
@@ -301,6 +303,23 @@ var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref
           });
         }
       }));
+      if ((0, _platformFeatureFlags.fg)('platform_editor_collab_organic_change_reporting')) {
+        (0, _monitorOrganicChanges.monitorOrganic)(_objectSpread(_objectSpread({
+          api: api
+        }, props), {}, {
+          onDataProcessed: function onDataProcessed(data) {
+            var _api$analytics4;
+            api === null || api === void 0 || (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 || (_api$analytics4 = _api$analytics4.actions) === null || _api$analytics4 === void 0 || _api$analytics4.fireAnalyticsEvent({
+              action: _analytics.ACTION.ORGANIC_CHANGES_TRACKED,
+              actionSubject: _analytics.ACTION_SUBJECT.COLLAB,
+              attributes: {
+                organicChanges: data
+              },
+              eventType: _analytics.EVENT_TYPE.OPERATIONAL
+            });
+          }
+        }));
+      }
     },
     commands: {
       nudgeTelepointer: function nudgeTelepointer(sessionId) {

package/dist/cjs/pm-plugins/monitor-organic-changes.js

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.monitorOrganic = exports.getScheduler = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _steps = require("@atlaskit/adf-schema/steps");
+var _trackLastOrganicChange = require("./track-last-organic-change");
+var _trackSteps = require("./track-steps");
+var _excluded = ["steps"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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; }
+// This is essentially a queue of cached events. When the background task runs to send these items then this queue is flushed.
+var organicReportingCache = [];
+// Every ten seconds we will try to process the step data.
+var LOW_PRIORITY_DELAY = 10000;
+
+// See https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+
+var getScheduler = exports.getScheduler = function getScheduler(obj) {
+  if (!obj) {
+    return null;
+  }
+  if ('scheduler' in obj) {
+    return obj.scheduler;
+  }
+  return null;
+};
+
+/**
+ * Processes the steps metadata from the cache and calls the callback function with the processed data.
+ *
+ * @param {OrganicCacheType} cache - A cache containing steps metadata.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} onDataProcessed - Callback function to be called with the processed data.
+ */
+var task = function task(cache, onDataProcessed) {
+  var data = [];
+  var _iterator = _createForOfIteratorHelper(cache),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var steps = item.steps,
+        rest = (0, _objectWithoutProperties2.default)(item, _excluded);
+      // We'll use the same grouping and sanitize logic from the track-steps util
+      var stepTypesAmount = (0, _trackSteps.groupSteps)(steps.map(_trackSteps.sanitizeStep));
+      data.push(_objectSpread(_objectSpread({}, rest), {}, {
+        stepTypesAmount: stepTypesAmount
+      }));
+    }
+
+    // clear the cache.
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  cache.length = 0;
+  if (data.length > 0) {
+    onDataProcessed(data);
+  }
+};
+
+/**
+ * Tracks the steps sent by the client by storing them in a cache and scheduling a task to process them. Once the steps are processed, the onDataProcessed callabck will be called.
+ *
+ * This is a non-critical code. If the browser doesn't support the Scheduler API https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+ *
+ * @param {TrackProps} props - The properties required for tracking steps.
+ * @param {ExtractInjectionAPI<CollabEditPlugin> | undefined} props.api - The API for the CollabEdit plugin.
+ * @param {EditorState} props.newEditorState - The new editor state.
+ * @param {Readonly<Transaction[]>} props.transactions - The transactions that contain the steps.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} props.onDataProcessed - Callback function to be called with the processed data.
+ */
+var monitorOrganic = exports.monitorOrganic = function monitorOrganic(_ref) {
+  var newEditorState = _ref.newEditorState,
+    oldEditorState = _ref.oldEditorState,
+    transactions = _ref.transactions,
+    onDataProcessed = _ref.onDataProcessed;
+  // We can exclude analytic steps since they should never trigger an organic change.
+  var newSteps = transactions.flatMap(function (t) {
+    return t.steps;
+  }).filter(function (step) {
+    return !(step instanceof _steps.AnalyticsStep);
+  });
+  var scheduler = getScheduler(window);
+  if (!newSteps.length || !scheduler) {
+    return;
+  }
+
+  // We know that an organic change during startup will trigger a draft sync which will;
+  // fire editor edited event ->  confluence/next/packages/editor-features/src/hooks/useDraftSync/useDraftSync.tsx
+  // and call triggerUpdate() notifying the BE that user edited the page -> confluence/next/packages/editor-features/src/hooks/useDraftSync/useEditorDraftSyncAction.tsx
+  // This can cause a problem with statsig metrics if organic changes are being incorrectly reported, ie an automated change
+  // occurs which contributes the user towards editing a page when in fact they didn't edit the page.
+  //
+  var oldPluginState = _trackLastOrganicChange.trackLastOrganicChangePluginKey.getState(oldEditorState);
+  var newPluginState = _trackLastOrganicChange.trackLastOrganicChangePluginKey.getState(newEditorState);
+  if (newSteps.length && (oldPluginState === null || oldPluginState === void 0 ? void 0 : oldPluginState.lastLocalOrganicBodyChangeAt) !== (newPluginState === null || newPluginState === void 0 ? void 0 : newPluginState.lastLocalOrganicBodyChangeAt)) {
+    var now = Date.now();
+    var isFirstChange = !(oldPluginState !== null && oldPluginState !== void 0 && oldPluginState.lastLocalOrganicBodyChangeAt);
+
+    // Check if we should compact with the previous entry (within 2 seconds) this means with a possible 10sec delay
+    // due to the postTask we could have a potential 5 grouped organic changes listed.
+    var shouldCompact = organicReportingCache.length > 0 && now - organicReportingCache[organicReportingCache.length - 1].startedAt < 2000;
+    if (shouldCompact) {
+      // Compact with previous entry
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      var prev = organicReportingCache.pop(); // We know it exists due to shouldCompact check
+
+      // tr.docChanged
+      organicReportingCache.push({
+        transactions: prev.transactions + 1,
+        startedAt: prev.startedAt,
+        endedAt: now,
+        isFirstChange: prev.isFirstChange || isFirstChange,
+        steps: prev.steps.concat(newSteps)
+      });
+    } else {
+      // Add new entry
+      organicReportingCache.push({
+        transactions: 1,
+        startedAt: now,
+        endedAt: now,
+        isFirstChange: isFirstChange,
+        steps: newSteps
+      });
+    }
+    if (organicReportingCache.length === 1) {
+      scheduler.postTask(function () {
+        task(organicReportingCache, onDataProcessed);
+      }, {
+        priority: 'background',
+        delay: LOW_PRIORITY_DELAY
+      });
+    }
+  }
+};

package/dist/es2019/collabEditPlugin.js

@@ -2,6 +2,7 @@ import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/anal
 import { isEmptyDocument } from '@atlaskit/editor-common/utils';
 import { JSONTransformer } from '@atlaskit/editor-json-transformer';
 import { AddMarkStep, AddNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { collab, getCollabState, sendableSteps } from '@atlaskit/prosemirror-collab';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
@@ -11,6 +12,7 @@ import { filterAnalyticsSteps } from './pm-plugins/filterAnalytics';
 import { createPlugin } from './pm-plugins/main';
 import { pluginKey as mainPluginKey } from './pm-plugins/main/plugin-key';
 import { mergeUnconfirmedSteps } from './pm-plugins/mergeUnconfirmed';
+import { monitorOrganic } from './pm-plugins/monitor-organic-changes';
 import { nativeCollabProviderPlugin } from './pm-plugins/native-collab-provider-plugin';
 import { sanitizeFilteredStep, createPlugin as trackSpammingStepsPlugin } from './pm-plugins/track-and-filter-spamming-steps';
 import { createPlugin as createLastOrganicChangePlugin, trackLastOrganicChangePluginKey } from './pm-plugins/track-last-organic-change';
@@ -146,7 +148,7 @@ export const collabEditPlugin = ({
         return content.every(node => {
           try {
             node.check(); // this will throw an error if the node is invalid
-          } catch (error) {
+          } catch {
             return false;
           }
           return true;
@@ -249,6 +251,23 @@ export const collabEditPlugin = ({
           });
         }
       });
+      if (fg('platform_editor_collab_organic_change_reporting')) {
+        monitorOrganic({
+          api,
+          ...props,
+          onDataProcessed: data => {
+            var _api$analytics4, _api$analytics4$actio;
+            api === null || api === void 0 ? void 0 : (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : (_api$analytics4$actio = _api$analytics4.actions) === null || _api$analytics4$actio === void 0 ? void 0 : _api$analytics4$actio.fireAnalyticsEvent({
+              action: ACTION.ORGANIC_CHANGES_TRACKED,
+              actionSubject: ACTION_SUBJECT.COLLAB,
+              attributes: {
+                organicChanges: data
+              },
+              eventType: EVENT_TYPE.OPERATIONAL
+            });
+          }
+        });
+      }
     },
     commands: {
       nudgeTelepointer: sessionId => ({

package/dist/es2019/pm-plugins/monitor-organic-changes.js

@@ -0,0 +1,120 @@
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+import { trackLastOrganicChangePluginKey } from './track-last-organic-change';
+import { groupSteps, sanitizeStep } from './track-steps';
+// This is essentially a queue of cached events. When the background task runs to send these items then this queue is flushed.
+const organicReportingCache = [];
+// Every ten seconds we will try to process the step data.
+const LOW_PRIORITY_DELAY = 10000;
+
+// See https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+
+export const getScheduler = obj => {
+  if (!obj) {
+    return null;
+  }
+  if ('scheduler' in obj) {
+    return obj.scheduler;
+  }
+  return null;
+};
+
+/**
+ * Processes the steps metadata from the cache and calls the callback function with the processed data.
+ *
+ * @param {OrganicCacheType} cache - A cache containing steps metadata.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} onDataProcessed - Callback function to be called with the processed data.
+ */
+const task = (cache, onDataProcessed) => {
+  const data = [];
+  for (const item of cache) {
+    const {
+      steps,
+      ...rest
+    } = item;
+    // We'll use the same grouping and sanitize logic from the track-steps util
+    const stepTypesAmount = groupSteps(steps.map(sanitizeStep));
+    data.push({
+      ...rest,
+      stepTypesAmount
+    });
+  }
+
+  // clear the cache.
+  cache.length = 0;
+  if (data.length > 0) {
+    onDataProcessed(data);
+  }
+};
+
+/**
+ * Tracks the steps sent by the client by storing them in a cache and scheduling a task to process them. Once the steps are processed, the onDataProcessed callabck will be called.
+ *
+ * This is a non-critical code. If the browser doesn't support the Scheduler API https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+ *
+ * @param {TrackProps} props - The properties required for tracking steps.
+ * @param {ExtractInjectionAPI<CollabEditPlugin> | undefined} props.api - The API for the CollabEdit plugin.
+ * @param {EditorState} props.newEditorState - The new editor state.
+ * @param {Readonly<Transaction[]>} props.transactions - The transactions that contain the steps.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} props.onDataProcessed - Callback function to be called with the processed data.
+ */
+export const monitorOrganic = ({
+  newEditorState,
+  oldEditorState,
+  transactions,
+  onDataProcessed
+}) => {
+  // We can exclude analytic steps since they should never trigger an organic change.
+  const newSteps = transactions.flatMap(t => t.steps).filter(step => !(step instanceof AnalyticsStep));
+  const scheduler = getScheduler(window);
+  if (!newSteps.length || !scheduler) {
+    return;
+  }
+
+  // We know that an organic change during startup will trigger a draft sync which will;
+  // fire editor edited event ->  confluence/next/packages/editor-features/src/hooks/useDraftSync/useDraftSync.tsx
+  // and call triggerUpdate() notifying the BE that user edited the page -> confluence/next/packages/editor-features/src/hooks/useDraftSync/useEditorDraftSyncAction.tsx
+  // This can cause a problem with statsig metrics if organic changes are being incorrectly reported, ie an automated change
+  // occurs which contributes the user towards editing a page when in fact they didn't edit the page.
+  //
+  const oldPluginState = trackLastOrganicChangePluginKey.getState(oldEditorState);
+  const newPluginState = trackLastOrganicChangePluginKey.getState(newEditorState);
+  if (newSteps.length && (oldPluginState === null || oldPluginState === void 0 ? void 0 : oldPluginState.lastLocalOrganicBodyChangeAt) !== (newPluginState === null || newPluginState === void 0 ? void 0 : newPluginState.lastLocalOrganicBodyChangeAt)) {
+    const now = Date.now();
+    const isFirstChange = !(oldPluginState !== null && oldPluginState !== void 0 && oldPluginState.lastLocalOrganicBodyChangeAt);
+
+    // Check if we should compact with the previous entry (within 2 seconds) this means with a possible 10sec delay
+    // due to the postTask we could have a potential 5 grouped organic changes listed.
+    const shouldCompact = organicReportingCache.length > 0 && now - organicReportingCache[organicReportingCache.length - 1].startedAt < 2000;
+    if (shouldCompact) {
+      // Compact with previous entry
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const prev = organicReportingCache.pop(); // We know it exists due to shouldCompact check
+
+      // tr.docChanged
+      organicReportingCache.push({
+        transactions: prev.transactions + 1,
+        startedAt: prev.startedAt,
+        endedAt: now,
+        isFirstChange: prev.isFirstChange || isFirstChange,
+        steps: prev.steps.concat(newSteps)
+      });
+    } else {
+      // Add new entry
+      organicReportingCache.push({
+        transactions: 1,
+        startedAt: now,
+        endedAt: now,
+        isFirstChange,
+        steps: newSteps
+      });
+    }
+    if (organicReportingCache.length === 1) {
+      scheduler.postTask(() => {
+        task(organicReportingCache, onDataProcessed);
+      }, {
+        priority: 'background',
+        delay: LOW_PRIORITY_DELAY
+      });
+    }
+  }
+};

package/dist/esm/collabEditPlugin.js

@@ -8,6 +8,7 @@ import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/anal
 import { isEmptyDocument } from '@atlaskit/editor-common/utils';
 import { JSONTransformer } from '@atlaskit/editor-json-transformer';
 import { AddMarkStep, AddNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { collab, getCollabState, sendableSteps } from '@atlaskit/prosemirror-collab';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
@@ -17,6 +18,7 @@ import { filterAnalyticsSteps } from './pm-plugins/filterAnalytics';
 import { createPlugin } from './pm-plugins/main';
 import { pluginKey as mainPluginKey } from './pm-plugins/main/plugin-key';
 import { mergeUnconfirmedSteps } from './pm-plugins/mergeUnconfirmed';
+import { monitorOrganic } from './pm-plugins/monitor-organic-changes';
 import { nativeCollabProviderPlugin } from './pm-plugins/native-collab-provider-plugin';
 import { sanitizeFilteredStep, createPlugin as trackSpammingStepsPlugin } from './pm-plugins/track-and-filter-spamming-steps';
 import { createPlugin as createLastOrganicChangePlugin, trackLastOrganicChangePluginKey } from './pm-plugins/track-last-organic-change';
@@ -183,7 +185,7 @@ export var collabEditPlugin = function collabEditPlugin(_ref4) {
         return content.every(function (node) {
           try {
             node.check(); // this will throw an error if the node is invalid
-          } catch (error) {
+          } catch (_unused) {
             return false;
           }
           return true;
@@ -294,6 +296,23 @@ export var collabEditPlugin = function collabEditPlugin(_ref4) {
           });
         }
       }));
+      if (fg('platform_editor_collab_organic_change_reporting')) {
+        monitorOrganic(_objectSpread(_objectSpread({
+          api: api
+        }, props), {}, {
+          onDataProcessed: function onDataProcessed(data) {
+            var _api$analytics4;
+            api === null || api === void 0 || (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 || (_api$analytics4 = _api$analytics4.actions) === null || _api$analytics4 === void 0 || _api$analytics4.fireAnalyticsEvent({
+              action: ACTION.ORGANIC_CHANGES_TRACKED,
+              actionSubject: ACTION_SUBJECT.COLLAB,
+              attributes: {
+                organicChanges: data
+              },
+              eventType: EVENT_TYPE.OPERATIONAL
+            });
+          }
+        }));
+      }
     },
     commands: {
       nudgeTelepointer: function nudgeTelepointer(sessionId) {

package/dist/esm/pm-plugins/monitor-organic-changes.js

@@ -0,0 +1,137 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["steps"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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; }
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+import { trackLastOrganicChangePluginKey } from './track-last-organic-change';
+import { groupSteps, sanitizeStep } from './track-steps';
+// This is essentially a queue of cached events. When the background task runs to send these items then this queue is flushed.
+var organicReportingCache = [];
+// Every ten seconds we will try to process the step data.
+var LOW_PRIORITY_DELAY = 10000;
+
+// See https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+
+export var getScheduler = function getScheduler(obj) {
+  if (!obj) {
+    return null;
+  }
+  if ('scheduler' in obj) {
+    return obj.scheduler;
+  }
+  return null;
+};
+
+/**
+ * Processes the steps metadata from the cache and calls the callback function with the processed data.
+ *
+ * @param {OrganicCacheType} cache - A cache containing steps metadata.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} onDataProcessed - Callback function to be called with the processed data.
+ */
+var task = function task(cache, onDataProcessed) {
+  var data = [];
+  var _iterator = _createForOfIteratorHelper(cache),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var steps = item.steps,
+        rest = _objectWithoutProperties(item, _excluded);
+      // We'll use the same grouping and sanitize logic from the track-steps util
+      var stepTypesAmount = groupSteps(steps.map(sanitizeStep));
+      data.push(_objectSpread(_objectSpread({}, rest), {}, {
+        stepTypesAmount: stepTypesAmount
+      }));
+    }
+
+    // clear the cache.
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  cache.length = 0;
+  if (data.length > 0) {
+    onDataProcessed(data);
+  }
+};
+
+/**
+ * Tracks the steps sent by the client by storing them in a cache and scheduling a task to process them. Once the steps are processed, the onDataProcessed callabck will be called.
+ *
+ * This is a non-critical code. If the browser doesn't support the Scheduler API https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+ *
+ * @param {TrackProps} props - The properties required for tracking steps.
+ * @param {ExtractInjectionAPI<CollabEditPlugin> | undefined} props.api - The API for the CollabEdit plugin.
+ * @param {EditorState} props.newEditorState - The new editor state.
+ * @param {Readonly<Transaction[]>} props.transactions - The transactions that contain the steps.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} props.onDataProcessed - Callback function to be called with the processed data.
+ */
+export var monitorOrganic = function monitorOrganic(_ref) {
+  var newEditorState = _ref.newEditorState,
+    oldEditorState = _ref.oldEditorState,
+    transactions = _ref.transactions,
+    onDataProcessed = _ref.onDataProcessed;
+  // We can exclude analytic steps since they should never trigger an organic change.
+  var newSteps = transactions.flatMap(function (t) {
+    return t.steps;
+  }).filter(function (step) {
+    return !(step instanceof AnalyticsStep);
+  });
+  var scheduler = getScheduler(window);
+  if (!newSteps.length || !scheduler) {
+    return;
+  }
+
+  // We know that an organic change during startup will trigger a draft sync which will;
+  // fire editor edited event ->  confluence/next/packages/editor-features/src/hooks/useDraftSync/useDraftSync.tsx
+  // and call triggerUpdate() notifying the BE that user edited the page -> confluence/next/packages/editor-features/src/hooks/useDraftSync/useEditorDraftSyncAction.tsx
+  // This can cause a problem with statsig metrics if organic changes are being incorrectly reported, ie an automated change
+  // occurs which contributes the user towards editing a page when in fact they didn't edit the page.
+  //
+  var oldPluginState = trackLastOrganicChangePluginKey.getState(oldEditorState);
+  var newPluginState = trackLastOrganicChangePluginKey.getState(newEditorState);
+  if (newSteps.length && (oldPluginState === null || oldPluginState === void 0 ? void 0 : oldPluginState.lastLocalOrganicBodyChangeAt) !== (newPluginState === null || newPluginState === void 0 ? void 0 : newPluginState.lastLocalOrganicBodyChangeAt)) {
+    var now = Date.now();
+    var isFirstChange = !(oldPluginState !== null && oldPluginState !== void 0 && oldPluginState.lastLocalOrganicBodyChangeAt);
+
+    // Check if we should compact with the previous entry (within 2 seconds) this means with a possible 10sec delay
+    // due to the postTask we could have a potential 5 grouped organic changes listed.
+    var shouldCompact = organicReportingCache.length > 0 && now - organicReportingCache[organicReportingCache.length - 1].startedAt < 2000;
+    if (shouldCompact) {
+      // Compact with previous entry
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      var prev = organicReportingCache.pop(); // We know it exists due to shouldCompact check
+
+      // tr.docChanged
+      organicReportingCache.push({
+        transactions: prev.transactions + 1,
+        startedAt: prev.startedAt,
+        endedAt: now,
+        isFirstChange: prev.isFirstChange || isFirstChange,
+        steps: prev.steps.concat(newSteps)
+      });
+    } else {
+      // Add new entry
+      organicReportingCache.push({
+        transactions: 1,
+        startedAt: now,
+        endedAt: now,
+        isFirstChange: isFirstChange,
+        steps: newSteps
+      });
+    }
+    if (organicReportingCache.length === 1) {
+      scheduler.postTask(function () {
+        task(organicReportingCache, onDataProcessed);
+      }, {
+        priority: 'background',
+        delay: LOW_PRIORITY_DELAY
+      });
+    }
+  }
+};

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export { collabEditPlugin } from './collabEditPlugin';
 export type { CollabEditPlugin, CollabEditPluginOptions, CollabEditPluginDependencies, } from './collabEditPluginType';
-export type { CollabInitializedMetadata, CollabEditPluginSharedState, ReadOnlyParticipants, PrivateCollabEditOptions, CollabSendableSteps, } from './types';
+export type { CollabInitializedMetadata, LastOrganicChangeMetadata, CollabEditPluginSharedState, ReadOnlyParticipants, PrivateCollabEditOptions, CollabSendableSteps, } from './types';

package/dist/types/pm-plugins/monitor-organic-changes.d.ts

@@ -0,0 +1,39 @@
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { CollabEditPlugin } from '../collabEditPluginType';
+export type OrganicMetadataAnalytics = {
+    endedAt: number;
+    isFirstChange: boolean;
+    startedAt: number;
+    stepTypesAmount: {
+        [key: string]: number;
+    };
+    transactions: number;
+};
+type TrackProps = {
+    api: ExtractInjectionAPI<CollabEditPlugin> | undefined;
+    newEditorState: EditorState;
+    oldEditorState: EditorState;
+    onDataProcessed: (data: OrganicMetadataAnalytics[]) => void;
+    transactions: Readonly<Transaction[]>;
+};
+type Scheduler = {
+    postTask: (cb: () => void, options: {
+        delay: number;
+        priority: 'background';
+    }) => Promise<unknown>;
+};
+export declare const getScheduler: (obj: any) => Scheduler | null;
+/**
+ * Tracks the steps sent by the client by storing them in a cache and scheduling a task to process them. Once the steps are processed, the onDataProcessed callabck will be called.
+ *
+ * This is a non-critical code. If the browser doesn't support the Scheduler API https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+ *
+ * @param {TrackProps} props - The properties required for tracking steps.
+ * @param {ExtractInjectionAPI<CollabEditPlugin> | undefined} props.api - The API for the CollabEdit plugin.
+ * @param {EditorState} props.newEditorState - The new editor state.
+ * @param {Readonly<Transaction[]>} props.transactions - The transactions that contain the steps.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} props.onDataProcessed - Callback function to be called with the processed data.
+ */
+export declare const monitorOrganic: ({ newEditorState, oldEditorState, transactions, onDataProcessed, }: TrackProps) => void;
+export {};

package/dist/types-ts4.5/index.d.ts

@@ -1,3 +1,3 @@
 export { collabEditPlugin } from './collabEditPlugin';
 export type { CollabEditPlugin, CollabEditPluginOptions, CollabEditPluginDependencies, } from './collabEditPluginType';
-export type { CollabInitializedMetadata, CollabEditPluginSharedState, ReadOnlyParticipants, PrivateCollabEditOptions, CollabSendableSteps, } from './types';
+export type { CollabInitializedMetadata, LastOrganicChangeMetadata, CollabEditPluginSharedState, ReadOnlyParticipants, PrivateCollabEditOptions, CollabSendableSteps, } from './types';

package/dist/types-ts4.5/pm-plugins/monitor-organic-changes.d.ts

@@ -0,0 +1,39 @@
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { CollabEditPlugin } from '../collabEditPluginType';
+export type OrganicMetadataAnalytics = {
+    endedAt: number;
+    isFirstChange: boolean;
+    startedAt: number;
+    stepTypesAmount: {
+        [key: string]: number;
+    };
+    transactions: number;
+};
+type TrackProps = {
+    api: ExtractInjectionAPI<CollabEditPlugin> | undefined;
+    newEditorState: EditorState;
+    oldEditorState: EditorState;
+    onDataProcessed: (data: OrganicMetadataAnalytics[]) => void;
+    transactions: Readonly<Transaction[]>;
+};
+type Scheduler = {
+    postTask: (cb: () => void, options: {
+        delay: number;
+        priority: 'background';
+    }) => Promise<unknown>;
+};
+export declare const getScheduler: (obj: any) => Scheduler | null;
+/**
+ * Tracks the steps sent by the client by storing them in a cache and scheduling a task to process them. Once the steps are processed, the onDataProcessed callabck will be called.
+ *
+ * This is a non-critical code. If the browser doesn't support the Scheduler API https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
+ *
+ * @param {TrackProps} props - The properties required for tracking steps.
+ * @param {ExtractInjectionAPI<CollabEditPlugin> | undefined} props.api - The API for the CollabEdit plugin.
+ * @param {EditorState} props.newEditorState - The new editor state.
+ * @param {Readonly<Transaction[]>} props.transactions - The transactions that contain the steps.
+ * @param {(data: OrganicMetadataAnalytics[]) => void} props.onDataProcessed - Callback function to be called with the processed data.
+ */
+export declare const monitorOrganic: ({ newEditorState, oldEditorState, transactions, onDataProcessed, }: TrackProps) => void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-collab-edit",
-	"version": "7.1.11",
+	"version": "7.2.1",
 	"description": "Collab Edit plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -39,12 +39,12 @@
 		"@atlaskit/frontend-utilities": "^3.2.0",
 		"@atlaskit/platform-feature-flags": "^1.1.0",
 		"@atlaskit/prosemirror-collab": "^0.22.0",
-		"@atlaskit/tmp-editor-statsig": "^15.11.0",
+		"@atlaskit/tmp-editor-statsig": "^15.15.0",
 		"@babel/runtime": "^7.0.0",
 		"memoize-one": "^6.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^110.44.0",
+		"@atlaskit/editor-common": "^110.46.0",
 		"react": "^18.2.0",
 		"react-dom": "^18.2.0"
 	},
@@ -94,6 +94,9 @@
 		},
 		"platform_editor_inorganic_batchattrsstep_localid": {
 			"type": "boolean"
+		},
+		"platform_editor_collab_organic_change_reporting": {
+			"type": "boolean"
 		}
 	}
 }