@atlaskit/editor-plugin-metrics 3.3.1 → 3.4.1

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

@@ -6,9 +6,9 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { ActiveSessionTimer } from './utils/active-session-timer';
 import { getAnalyticsPayload } from './utils/analytics';
-import { ActionType, checkTrActionType, shouldSkipTr } from './utils/check-tr-action-type';
-import { isNonTextUndo } from './utils/is-non-text-undo';
+import { getNewPluginState } from './utils/get-new-plugin-state';
 import { isTrWithDocChanges } from './utils/is-tr-with-doc-changes';
+import { shouldSkipTr } from './utils/should-skip-tr';
 export var metricsKey = new PluginKey('metricsPlugin');
 export var initialPluginState = {
   intentToStartEditTime: undefined,
@@ -24,9 +24,12 @@ export var initialPluginState = {
     nodeAttributeChangeCount: 0,
     contentMovedCount: 0,
     nodeDeletionCount: 0,
-    undoCount: 0
+    undoCount: 0,
+    markChangeCount: 0,
+    contentDeletedCount: 0
   },
-  repeatedActionCount: 0
+  repeatedActionCount: 0,
+  safeInsertCount: 0
 };
 export var createPlugin = function createPlugin(api) {
   var timer = new ActiveSessionTimer(api);
@@ -41,6 +44,7 @@ export var createPlugin = function createPlugin(api) {
       // eslint-disable-next-line @typescript-eslint/max-params
       apply: function apply(tr, pluginState, oldState, newState) {
         var _meta$shouldPersistAc;
+        // Return if transaction is remote or replaceDocument is set
         if (tr.getMeta('isRemote') || tr.getMeta('replaceDocument')) {
           return pluginState;
         }
@@ -56,127 +60,46 @@ export var createPlugin = function createPlugin(api) {
         var hasDocChanges = isTrWithDocChanges(tr);
         var intentToStartEditTime = (meta === null || meta === void 0 ? void 0 : meta.intentToStartEditTime) || pluginState.intentToStartEditTime;
         var now = performance.now();
+        // If there is no intentToStartEditTime and there are no doc changes, return the plugin state
         if (!intentToStartEditTime && !hasDocChanges && !tr.storedMarksSet) {
           return pluginState;
         }
+
+        // Set intentToStartEditTime if it is not set and there are doc changes or marks are set
         if (!intentToStartEditTime && (hasDocChanges || tr.storedMarksSet)) {
           intentToStartEditTime = now;
         }
 
-        // Start active session timer if intentToStartEditTime is set and shouldStartTimer is true
-        // shouldPersistActiveSession is set to true when dragging block controls and when insert menu is open
+        // Start active session timer if intentToStartEditTime is defined, shouldStartTimer is true and shouldPersistActiveSession is false
+        // shouldPersistActiveSession is true when dragging block controls and when insert menu is open as user is interacting with the editor without making doc changes
         // Timer should start when menu closes or dragging stops
         if (intentToStartEditTime && meta !== null && meta !== void 0 && meta.shouldStartTimer && !pluginState.shouldPersistActiveSession) {
           timer.startTimer();
         }
-        var undoCount = isNonTextUndo(tr) ? 1 : 0;
-        var newActionTypeCount = pluginState.actionTypeCount ? _objectSpread(_objectSpread({}, pluginState.actionTypeCount), {}, {
-          undoCount: pluginState.actionTypeCount.undoCount + undoCount
-        }) : _objectSpread(_objectSpread({}, initialPluginState.actionTypeCount), {}, {
-          undoCount: undoCount
-        });
         if (hasDocChanges) {
           timer.startTimer();
-          var actionTypeCount = pluginState.actionTypeCount,
-            timeOfLastTextInput = pluginState.timeOfLastTextInput,
-            totalActionCount = pluginState.totalActionCount,
-            previousTrType = pluginState.previousTrType;
           if (shouldSkipTr(tr)) {
             return pluginState;
           }
-          var trType = checkTrActionType(tr);
-          var shouldNotIncrementActionCount = false;
-          var shouldSetTimeOfLastTextInput = false;
-          var isTextInput = false;
-          if (trType) {
-            var _trType$extraData, _previousTrType$extra;
-            var isNotNewStatus = trType.type === ActionType.UPDATING_STATUS && (previousTrType === null || previousTrType === void 0 ? void 0 : previousTrType.type) === ActionType.UPDATING_STATUS && (trType === null || trType === void 0 || (_trType$extraData = trType.extraData) === null || _trType$extraData === void 0 ? void 0 : _trType$extraData.statusId) === (previousTrType === null || previousTrType === void 0 || (_previousTrType$extra = previousTrType.extraData) === null || _previousTrType$extra === void 0 ? void 0 : _previousTrType$extra.statusId);
-            var isAddingTextToListNode = trType.type === ActionType.TEXT_INPUT && !!previousTrType && [ActionType.UPDATING_NEW_LIST_TYPE_ITEM, ActionType.INSERTING_NEW_LIST_TYPE_NODE].includes(previousTrType.type);
-            var isAddingNewListItemAfterTextInput = !!previousTrType && previousTrType.type === ActionType.TEXT_INPUT && [ActionType.UPDATING_NEW_LIST_TYPE_ITEM].includes(trType.type);
-
-            // Check if tr is textInput and only increment textInputCount if previous action was not textInput
-            isTextInput = [ActionType.TEXT_INPUT, ActionType.EMPTY_LINE_ADDED_OR_DELETED].includes(trType.type);
-
-            // timeOfLastTextInput should be set if tr includes continuous text input on the same node
-            shouldSetTimeOfLastTextInput = [ActionType.TEXT_INPUT, ActionType.EMPTY_LINE_ADDED_OR_DELETED, ActionType.UPDATING_NEW_LIST_TYPE_ITEM, ActionType.INSERTING_NEW_LIST_TYPE_NODE, ActionType.UPDATING_STATUS].includes(trType.type) || isNotNewStatus;
-
-            // Should not increase action count if tr is text input,
-            // empty line added or deleted, updating new list item or is updating same status node
-
-            shouldNotIncrementActionCount = isTextInput || isNotNewStatus || isAddingTextToListNode || isAddingNewListItemAfterTextInput;
-          }
-          var newTextInputCount = isTextInput ? actionTypeCount.textInputCount + 1 : actionTypeCount.textInputCount;
-          var newTotalActionCount = totalActionCount + 1;
-          if (timeOfLastTextInput && shouldNotIncrementActionCount) {
-            newTotalActionCount = totalActionCount;
-          }
-          if (timeOfLastTextInput && isTextInput && previousTrType && [ActionType.TEXT_INPUT, ActionType.EMPTY_LINE_ADDED_OR_DELETED, ActionType.UPDATING_NEW_LIST_TYPE_ITEM, ActionType.INSERTING_NEW_LIST_TYPE_NODE].includes(previousTrType.type)) {
-            newTextInputCount = actionTypeCount.textInputCount;
-          }
-          var newNodeAttrCount = actionTypeCount.nodeAttributeChangeCount;
-          var newRepeatedActionCount = pluginState.repeatedActionCount;
-          if ((trType === null || trType === void 0 ? void 0 : trType.type) === ActionType.CHANGING_ATTRS) {
-            newNodeAttrCount = newNodeAttrCount + 1;
-            if ((previousTrType === null || previousTrType === void 0 ? void 0 : previousTrType.type) === ActionType.CHANGING_ATTRS) {
-              var _trType$extraData2 = trType.extraData,
-                newAttr = _trType$extraData2.attr,
-                newFrom = _trType$extraData2.from,
-                newTo = _trType$extraData2.to;
-              var _previousTrType$extra2 = previousTrType.extraData,
-                prevAttr = _previousTrType$extra2.attr,
-                prevFrom = _previousTrType$extra2.from,
-                prevTo = _previousTrType$extra2.to;
-              newRepeatedActionCount = newAttr === prevAttr && newFrom === prevFrom && newTo === prevTo ? newRepeatedActionCount + 1 : newRepeatedActionCount;
-            }
-          }
-          var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
-            activeSessionTime: now - intentToStartEditTime,
-            totalActionCount: newTotalActionCount,
-            timeOfLastTextInput: shouldSetTimeOfLastTextInput ? now : undefined,
-            contentSizeChanged: pluginState.contentSizeChanged + (newState.doc.content.size - oldState.doc.content.size),
-            actionTypeCount: _objectSpread(_objectSpread({}, newActionTypeCount), {}, {
-              textInputCount: newTextInputCount,
-              nodeAttributeChangeCount: newNodeAttrCount
-            }),
+          var newPluginState = getNewPluginState({
+            now: now,
             intentToStartEditTime: intentToStartEditTime,
             shouldPersistActiveSession: shouldPersistActiveSession,
-            previousTrType: trType,
-            repeatedActionCount: newRepeatedActionCount
+            tr: tr,
+            pluginState: pluginState,
+            oldState: oldState,
+            newState: newState
           });
           return newPluginState;
         }
         return _objectSpread(_objectSpread({}, pluginState), {}, {
           lastSelection: (meta === null || meta === void 0 ? void 0 : meta.newSelection) || pluginState.lastSelection,
           intentToStartEditTime: intentToStartEditTime,
-          actionTypeCount: newActionTypeCount,
           shouldPersistActiveSession: shouldPersistActiveSession
         });
       }
     },
     view: function view(_view) {
-      var _api$blockControls;
-      var handleIsDraggingChanged = api === null || api === void 0 || (_api$blockControls = api.blockControls) === null || _api$blockControls === void 0 ? void 0 : _api$blockControls.sharedState.onChange(function (_ref) {
-        var nextSharedState = _ref.nextSharedState,
-          prevSharedState = _ref.prevSharedState;
-        if (nextSharedState) {
-          api === null || api === void 0 || api.core.actions.execute(function (_ref2) {
-            var tr = _ref2.tr;
-            if (!(prevSharedState !== null && prevSharedState !== void 0 && prevSharedState.isDragging) && nextSharedState.isDragging) {
-              api === null || api === void 0 || api.metrics.commands.handleIntentToStartEdit({
-                shouldStartTimer: false,
-                shouldPersistActiveSession: true
-              })({
-                tr: tr
-              });
-            } else if (prevSharedState !== null && prevSharedState !== void 0 && prevSharedState.isDragging && !nextSharedState.isDragging) {
-              api === null || api === void 0 || api.metrics.commands.startActiveSessionTimer()({
-                tr: tr
-              });
-            }
-            return tr;
-          });
-        }
-      });
       var fireAnalyticsEvent = function fireAnalyticsEvent() {
         var pluginState = metricsKey.getState(_view.state);
         if (!pluginState) {
@@ -187,7 +110,8 @@ export var createPlugin = function createPlugin(api) {
           pluginState: pluginState
         });
         if (pluginState && pluginState.totalActionCount > 0 && pluginState.activeSessionTime > 0) {
-          api === null || api === void 0 || api.analytics.actions.fireAnalyticsEvent(payloadToSend, undefined, {
+          var _api$analytics;
+          api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || _api$analytics.actions.fireAnalyticsEvent(payloadToSend, undefined, {
             immediate: true
           });
         }
@@ -203,7 +127,6 @@ export var createPlugin = function createPlugin(api) {
           fireAnalyticsEvent();
           timer.cleanupTimer();
           unbindBeforeUnload();
-          handleIsDraggingChanged === null || handleIsDraggingChanged === void 0 || handleIsDraggingChanged();
         }
       };
     },

package/dist/esm/pm-plugins/utils/analytics.js

@@ -4,37 +4,30 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 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; }
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
 import { getNodeChanges } from './get-node-changes';
-export var getPayloadAttributes = function getPayloadAttributes(_ref) {
-  var pluginState = _ref.pluginState,
-    contentSizeChanged = _ref.contentSizeChanged;
-  return {
-    efficiency: {
-      totalActiveTime: pluginState.activeSessionTime,
-      totalActionCount: pluginState.totalActionCount,
-      actionByTypeCount: pluginState.actionTypeCount
-    },
-    effectiveness: {
-      undoCount: pluginState.actionTypeCount.undoCount,
-      repeatedActionCount: pluginState.repeatedActionCount,
-      safeInsertCount: 0
-    },
-    contentSizeChanged: contentSizeChanged
-  };
-};
-export var getAnalyticsPayload = function getAnalyticsPayload(_ref2) {
+export var getAnalyticsPayload = function getAnalyticsPayload(_ref) {
   var _pluginState$actionTy;
-  var currentContent = _ref2.currentContent,
-    pluginState = _ref2.pluginState;
+  var currentContent = _ref.currentContent,
+    pluginState = _ref.pluginState;
   var nodeChanges = getNodeChanges({
     currentContent: currentContent,
     pluginState: pluginState
   });
+  var getActionCountByTypeSum = function getActionCountByTypeSum() {
+    var actionCountByTypeSum = 0;
+    Object.entries(pluginState.actionTypeCount).forEach(function (_ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2),
+        _actionType = _ref3[0],
+        count = _ref3[1];
+      actionCountByTypeSum += count;
+    });
+    return pluginState.totalActionCount - actionCountByTypeSum;
+  };
   var nodeInsertionCount = 0;
   var nodeDeletionCount = 0;
-  Object.entries(nodeChanges).forEach(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-      _ = _ref4[0],
-      change = _ref4[1];
+  Object.entries(nodeChanges).forEach(function (_ref4) {
+    var _ref5 = _slicedToArray(_ref4, 2),
+      _ = _ref5[0],
+      change = _ref5[1];
     if (change > 0) {
       nodeInsertionCount += change;
     } else if (change < 0) {
@@ -47,17 +40,18 @@ export var getAnalyticsPayload = function getAnalyticsPayload(_ref2) {
     actionSubjectId: ACTION_SUBJECT_ID.ACTIVITY,
     attributes: {
       efficiency: {
-        totalActiveTime: pluginState.activeSessionTime,
+        totalActiveTime: pluginState.activeSessionTime / 1000,
         totalActionCount: pluginState.totalActionCount,
         actionByTypeCount: _objectSpread(_objectSpread({}, (_pluginState$actionTy = pluginState.actionTypeCount) !== null && _pluginState$actionTy !== void 0 ? _pluginState$actionTy : {}), {}, {
           nodeDeletionCount: nodeDeletionCount,
-          nodeInsertionCount: nodeInsertionCount
+          nodeInsertionCount: nodeInsertionCount,
+          other: getActionCountByTypeSum()
         })
       },
       effectiveness: {
         undoCount: pluginState.actionTypeCount.undoCount,
         repeatedActionCount: pluginState.repeatedActionCount,
-        safeInsertCount: 0
+        safeInsertCount: pluginState.safeInsertCount
       },
       contentSizeChanged: pluginState.contentSizeChanged
     },

package/dist/esm/pm-plugins/utils/check-tr-actions/check-tr-action-type.js

@@ -0,0 +1,83 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { ReplaceAroundStep, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { checkContentPastedOrMoved } from './tr-checks/check-content-moved';
+import { checkDeletingContent } from './tr-checks/check-deleting-content';
+import { checkEmptyLineAddedOrDeleted } from './tr-checks/check-empty-line-added-or-deleted';
+import { checkListTypeNodeChanged } from './tr-checks/check-list-type-node-changed';
+import { checkMarkChanged } from './tr-checks/check-mark-changed';
+import { checkNodeAttributeChanged } from './tr-checks/check-node-attribute-changed';
+import { checkStatusChanged } from './tr-checks/check-status-changed';
+import { checkTableColumnResized } from './tr-checks/check-table-column-resized';
+import { checkTextInput } from './tr-checks/check-text-input';
+export var checkTrActionType = function checkTrActionType(tr) {
+  var stepsLength = tr.steps.length;
+  if (stepsLength <= 0) {
+    return undefined;
+  }
+  var contentPastedOrMoved = checkContentPastedOrMoved(tr);
+  if (contentPastedOrMoved) {
+    return contentPastedOrMoved;
+  }
+
+  // Resized column data is either AttrStep or BatchAttrsStep, so we want to check it first
+  var resizedColumnData = checkTableColumnResized(tr);
+  if (resizedColumnData) {
+    return resizedColumnData;
+  }
+
+  // Since we are looking at editor actions, we want to look at the first step only
+  var _tr$steps = _slicedToArray(tr.steps, 1),
+    firstStep = _tr$steps[0];
+  var isReplaceStep = firstStep instanceof ReplaceStep;
+  var isReplaceAroundStep = firstStep instanceof ReplaceAroundStep;
+
+  // Check if mark is added or removed, this is for text formatting changes
+  var marksChanged = checkMarkChanged(firstStep);
+  if (marksChanged) {
+    return marksChanged;
+  }
+
+  // Return early if it's not a replace step or replace around step as following checks are for these steps only
+  if (!(isReplaceStep || isReplaceAroundStep)) {
+    return undefined;
+  }
+  if (isReplaceStep) {
+    // Check if tr is text input as we want to ignore continuous typing actions
+    var textInput = checkTextInput(firstStep);
+    if (textInput) {
+      return textInput;
+    }
+
+    // Check if tr is adding/ removing empty lines as we want to ignore continuous typing actions
+    var emptyLineAddedOrDeleted = checkEmptyLineAddedOrDeleted(firstStep);
+    if (emptyLineAddedOrDeleted) {
+      return emptyLineAddedOrDeleted;
+    }
+
+    //Check if tr is removing content
+    var isDeletingContent = checkDeletingContent(firstStep);
+    if (isDeletingContent) {
+      return isDeletingContent;
+    }
+
+    // Status nodes save status content in attributes and a new transaction is fired each keypress
+    // Check if tr is updating status so we can handle actionCount correctly
+    var status = checkStatusChanged(firstStep);
+    if (status) {
+      return status;
+    }
+  }
+
+  // Check if tr is updating list type node because we want to ignore continuous typing actions and adding new list items
+  var updatingListTypeNode = checkListTypeNodeChanged(firstStep);
+  if (updatingListTypeNode) {
+    return updatingListTypeNode;
+  }
+
+  // Check if tr is updating node attributes so we can track nodeAttributeChangeCount
+  var nodeAttributeChange = checkNodeAttributeChanged(tr, firstStep);
+  if (nodeAttributeChange) {
+    return nodeAttributeChange;
+  }
+  return undefined;
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-content-moved.js

@@ -0,0 +1,20 @@
+import { metricsKey } from '../../../main';
+import { ActionType } from '../types';
+var UI_EVENT = 'uiEvent';
+var PASTE_EVENT = 'paste';
+export var checkContentPastedOrMoved = function checkContentPastedOrMoved(tr) {
+  var _tr$getMeta;
+  var isContentMoved = (_tr$getMeta = tr.getMeta(metricsKey)) === null || _tr$getMeta === void 0 ? void 0 : _tr$getMeta.contentMoved;
+  var isContentPasted = tr.getMeta(UI_EVENT) === PASTE_EVENT;
+  if (isContentMoved) {
+    return {
+      type: ActionType.MOVING_CONTENT
+    };
+  }
+  if (isContentPasted) {
+    return {
+      type: ActionType.PASTING_CONTENT
+    };
+  }
+  return undefined;
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-deleting-content.js

@@ -0,0 +1,14 @@
+import { ActionType } from '../types';
+export var checkDeletingContent = function checkDeletingContent(step) {
+  var _ref = step,
+    content = _ref.slice.content,
+    from = _ref.from,
+    to = _ref.to;
+  var isDeletingContent = to !== from && content.childCount === 0;
+  if (!isDeletingContent) {
+    return undefined;
+  }
+  return {
+    type: ActionType.DELETING_CONTENT
+  };
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-empty-line-added-or-deleted.js

@@ -0,0 +1,23 @@
+import { ActionType } from '../types';
+export var checkEmptyLineAddedOrDeleted = function checkEmptyLineAddedOrDeleted(step) {
+  var _ref = step,
+    content = _ref.slice.content,
+    from = _ref.from,
+    to = _ref.to;
+  var isEmptyLineDeleted = to - from === 2 && content.size === 0;
+  if (isEmptyLineDeleted) {
+    return {
+      type: ActionType.EMPTY_LINE_ADDED_OR_DELETED
+    };
+  }
+  var isEmptyLineAdded = false;
+  content.forEach(function (node) {
+    isEmptyLineAdded = node.type.name === 'paragraph' && node.content.size === 0;
+  });
+  if (!isEmptyLineAdded) {
+    return undefined;
+  }
+  return {
+    type: ActionType.EMPTY_LINE_ADDED_OR_DELETED
+  };
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-list-type-node-changed.js

@@ -0,0 +1,31 @@
+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 { ActionType } from '../types';
+export var checkListTypeNodeChanged = function checkListTypeNodeChanged(step) {
+  var content = step.slice.content;
+  var childCount = content.childCount;
+  if (childCount < 1) {
+    return undefined;
+  }
+  var _iterator = _createForOfIteratorHelper(content.content),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var node = _step.value;
+      var isListTypeNode = ['decisionList', 'decisionItem', 'bulletList', 'listItem', 'orderedList', 'taskList', 'taskItem'].includes(node.type.name);
+      if (isListTypeNode) {
+        return childCount === 1 ? {
+          type: ActionType.INSERTING_NEW_LIST_TYPE_NODE
+        } : {
+          type: ActionType.UPDATING_NEW_LIST_TYPE_ITEM
+        };
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return undefined;
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-mark-changed.js

@@ -0,0 +1,10 @@
+import { AddMarkStep, RemoveMarkStep } from '@atlaskit/editor-prosemirror/transform';
+import { ActionType } from '../types';
+export var checkMarkChanged = function checkMarkChanged(step) {
+  if (!(step instanceof AddMarkStep || step instanceof RemoveMarkStep)) {
+    return undefined;
+  }
+  return {
+    type: ActionType.CHANGING_MARK
+  };
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-node-attribute-changed.js

@@ -0,0 +1,96 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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 { ActionType } from '../types';
+var compareAttributes = function compareAttributes(prevAttr, newAttr) {
+  var allKeys = new Set([].concat(_toConsumableArray(Object.keys(prevAttr)), _toConsumableArray(Object.keys(newAttr))));
+  var _iterator = _createForOfIteratorHelper(allKeys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      var prevValue = prevAttr[key];
+      var newValue = newAttr[key];
+      if (prevValue !== newValue && key !== 'localId') {
+        return key;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return undefined;
+};
+var compareMarks = function compareMarks(prevMarks, newMarks) {
+  if (!prevMarks && !newMarks) {
+    return undefined;
+  }
+  var previousMarksArr = new Map(prevMarks.map(function (mark) {
+    return [mark.type.name, mark.attrs];
+  }));
+  var newMarksArr = new Map(newMarks.map(function (mark) {
+    return [mark.type.name, mark.attrs];
+  }));
+  var allMarks = new Set([].concat(_toConsumableArray(previousMarksArr.keys()), _toConsumableArray(newMarksArr.keys())));
+  var _iterator2 = _createForOfIteratorHelper(allMarks),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var key = _step2.value;
+      var previousValue = previousMarksArr.get(key);
+      var newValue = newMarksArr.get(key);
+      if (JSON.stringify(previousValue) !== JSON.stringify(newValue)) {
+        return key;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return undefined;
+};
+export var checkNodeAttributeChanged = function checkNodeAttributeChanged(tr, step) {
+  var _ref = step,
+    slice = _ref.slice,
+    from = _ref.from,
+    to = _ref.to;
+  var oldNode = tr.docs[0].nodeAt(from);
+  var newNode = slice.content.firstChild;
+  if (!oldNode || !newNode) {
+    return undefined;
+  }
+  if (oldNode.type.name !== newNode.type.name) {
+    return undefined;
+  }
+
+  // We need to compare the attributes of the node
+  var changedAttr = compareAttributes(oldNode.attrs, newNode.attrs);
+  if (changedAttr) {
+    return {
+      type: ActionType.CHANGING_ATTRS,
+      extraData: {
+        attr: changedAttr,
+        from: from,
+        to: to
+      }
+    };
+  }
+
+  // For some changes, we need to compare the marks of the node
+  // e.g. Media Border, Links
+  var changedMarks = compareMarks(oldNode.marks, newNode.marks);
+  if (changedMarks) {
+    return {
+      type: ActionType.CHANGING_ATTRS,
+      extraData: {
+        attr: changedMarks,
+        from: from,
+        to: to
+      }
+    };
+  }
+  return undefined;
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-status-changed.js

@@ -0,0 +1,16 @@
+import { ActionType } from '../types';
+export var checkStatusChanged = function checkStatusChanged(step) {
+  var slice = step.slice;
+  var firstChild = slice.content.firstChild;
+  if (!firstChild) {
+    return undefined;
+  }
+
+  // Get statusId so that we can track whether edits are performed on same status node
+  return firstChild.type.name === 'status' ? {
+    type: ActionType.UPDATING_STATUS,
+    extraData: {
+      statusId: firstChild.attrs.localId
+    }
+  } : undefined;
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-table-column-resized.js

@@ -0,0 +1,54 @@
+import { BatchAttrsStep } from '@atlaskit/adf-schema/steps';
+import { AttrStep } from '@atlaskit/editor-prosemirror/transform';
+import { ActionType } from '../types';
+export var checkTableColumnResized = function checkTableColumnResized(tr) {
+  var COL_WIDTH_ATTR = 'colwidth';
+  var steps = tr.steps;
+
+  // Find the step that is changing the column width
+  var resizingColumnStep = steps.find(function (step) {
+    return step instanceof AttrStep || step instanceof BatchAttrsStep;
+  });
+  if (!resizingColumnStep) {
+    return undefined;
+  }
+  var pos;
+
+  // Find the position of the first column in the step that is being resized
+  if (resizingColumnStep instanceof BatchAttrsStep) {
+    if (resizingColumnStep.data.length === 0) {
+      return undefined;
+    }
+    var _resizingColumnStep$d = resizingColumnStep.data[0],
+      attrs = _resizingColumnStep$d.attrs,
+      nodeType = _resizingColumnStep$d.nodeType,
+      position = _resizingColumnStep$d.position;
+    if (['tableHeader', 'tableCell'].includes(nodeType) && attrs !== null && attrs !== void 0 && attrs[COL_WIDTH_ATTR]) {
+      pos = position;
+    }
+  } else if (resizingColumnStep instanceof AttrStep && resizingColumnStep.attr === COL_WIDTH_ATTR) {
+    pos = resizingColumnStep.pos;
+  }
+  if (!pos) {
+    return undefined;
+  }
+
+  // Find the range of the table that is being resized
+  var $pos = tr.doc.resolve(pos);
+  var blockRange = $pos.blockRange();
+  if (!blockRange) {
+    return undefined;
+  }
+  var from = blockRange.start;
+  var to = from + blockRange.parent.content.size;
+
+  // Use to and from position of table to check whether column width of same table is being resized
+  return {
+    type: ActionType.CHANGING_ATTRS,
+    extraData: {
+      attr: COL_WIDTH_ATTR,
+      from: from,
+      to: to
+    }
+  };
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/tr-checks/check-text-input.js

@@ -0,0 +1,17 @@
+import { ActionType } from '../types';
+export var checkTextInput = function checkTextInput(step) {
+  var _ref = step,
+    content = _ref.slice.content,
+    from = _ref.from,
+    to = _ref.to;
+  var node = content.firstChild;
+  var isAddingCharacter = from === to && content.childCount === 1 && !!node && !!node.text && node.text.length === 1;
+  var isDeletingCharacter = to - from === 1 && content.childCount === 0;
+  var isTextInput = isAddingCharacter || isDeletingCharacter;
+  if (!isTextInput) {
+    return undefined;
+  }
+  return {
+    type: ActionType.TEXT_INPUT
+  };
+};

package/dist/esm/pm-plugins/utils/check-tr-actions/types.js

@@ -0,0 +1,17 @@
+export var ActionType = /*#__PURE__*/function (ActionType) {
+  ActionType["TEXT_INPUT"] = "textInput";
+  ActionType["EMPTY_LINE_ADDED_OR_DELETED"] = "emptyLineAddedOrDeleted";
+  ActionType["INSERTED_FROM_TYPE_AHEAD"] = "insertedFromTypeAhead";
+  ActionType["INSERTING_NEW_LIST_TYPE_NODE"] = "insertingNewListTypeNode";
+  ActionType["UPDATING_NEW_LIST_TYPE_ITEM"] = "updatingNewListItem";
+  ActionType["ADDING_LINK"] = "addingLink";
+  ActionType["UPDATING_STATUS"] = "updatingStatus";
+  ActionType["CHANGING_MARK"] = "changingMark";
+  ActionType["CHANGING_ATTRS"] = "changingAttrs";
+  ActionType["MOVING_CONTENT"] = "contentMoved";
+  ActionType["PASTING_CONTENT"] = "contentPasted";
+  ActionType["DELETING_CONTENT"] = "deletingContent";
+  ActionType["SAFE_INSERT"] = "safeInsert";
+  ActionType["UNDO"] = "undo";
+  return ActionType;
+}({});