@atlaskit/editor-plugin-metrics 3.3.0 → 3.4.0

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

@@ -1,21 +1,5 @@
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
 import { getNodeChanges } from './get-node-changes';
-export const getPayloadAttributes = ({
-  pluginState,
-  contentSizeChanged
-}) => ({
-  efficiency: {
-    totalActiveTime: pluginState.activeSessionTime,
-    totalActionCount: pluginState.totalActionCount,
-    actionByTypeCount: pluginState.actionTypeCount
-  },
-  effectiveness: {
-    undoCount: pluginState.actionTypeCount.undoCount,
-    repeatedActionCount: pluginState.repeatedActionCount,
-    safeInsertCount: 0
-  },
-  contentSizeChanged
-});
 export const getAnalyticsPayload = ({
   currentContent,
   pluginState
@@ -25,6 +9,13 @@ export const getAnalyticsPayload = ({
     currentContent,
     pluginState
   });
+  const getActionCountByTypeSum = () => {
+    let actionCountByTypeSum = 0;
+    Object.entries(pluginState.actionTypeCount).forEach(([_actionType, count]) => {
+      actionCountByTypeSum += count;
+    });
+    return pluginState.totalActionCount - actionCountByTypeSum;
+  };
   let nodeInsertionCount = 0;
   let nodeDeletionCount = 0;
   Object.entries(nodeChanges).forEach(([_, change]) => {
@@ -45,13 +36,14 @@ export const getAnalyticsPayload = ({
         actionByTypeCount: {
           ...((_pluginState$actionTy = pluginState.actionTypeCount) !== null && _pluginState$actionTy !== void 0 ? _pluginState$actionTy : {}),
           nodeDeletionCount,
-          nodeInsertionCount
+          nodeInsertionCount,
+          other: getActionCountByTypeSum()
         }
       },
       effectiveness: {
         undoCount: pluginState.actionTypeCount.undoCount,
         repeatedActionCount: pluginState.repeatedActionCount,
-        safeInsertCount: 0
+        safeInsertCount: pluginState.safeInsertCount
       },
       contentSizeChanged: pluginState.contentSizeChanged
     },

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

@@ -0,0 +1,81 @@
+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 const checkTrActionType = tr => {
+  const stepsLength = tr.steps.length;
+  if (stepsLength <= 0) {
+    return undefined;
+  }
+  const contentPastedOrMoved = checkContentPastedOrMoved(tr);
+  if (contentPastedOrMoved) {
+    return contentPastedOrMoved;
+  }
+
+  // Resized column data is either AttrStep or BatchAttrsStep, so we want to check it first
+  const resizedColumnData = checkTableColumnResized(tr);
+  if (resizedColumnData) {
+    return resizedColumnData;
+  }
+
+  // Since we are looking at editor actions, we want to look at the first step only
+  const [firstStep] = tr.steps;
+  const isReplaceStep = firstStep instanceof ReplaceStep;
+  const isReplaceAroundStep = firstStep instanceof ReplaceAroundStep;
+
+  // Check if mark is added or removed, this is for text formatting changes
+  const 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
+    const textInput = checkTextInput(firstStep);
+    if (textInput) {
+      return textInput;
+    }
+
+    // Check if tr is adding/ removing empty lines as we want to ignore continuous typing actions
+    const emptyLineAddedOrDeleted = checkEmptyLineAddedOrDeleted(firstStep);
+    if (emptyLineAddedOrDeleted) {
+      return emptyLineAddedOrDeleted;
+    }
+
+    //Check if tr is removing content
+    const 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
+    const 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
+  const updatingListTypeNode = checkListTypeNodeChanged(firstStep);
+  if (updatingListTypeNode) {
+    return updatingListTypeNode;
+  }
+
+  // Check if tr is updating node attributes so we can track nodeAttributeChangeCount
+  const nodeAttributeChange = checkNodeAttributeChanged(tr, firstStep);
+  if (nodeAttributeChange) {
+    return nodeAttributeChange;
+  }
+  return undefined;
+};

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

@@ -0,0 +1,20 @@
+import { metricsKey } from '../../../main';
+import { ActionType } from '../types';
+const UI_EVENT = 'uiEvent';
+const PASTE_EVENT = 'paste';
+export const checkContentPastedOrMoved = tr => {
+  var _tr$getMeta;
+  const isContentMoved = (_tr$getMeta = tr.getMeta(metricsKey)) === null || _tr$getMeta === void 0 ? void 0 : _tr$getMeta.contentMoved;
+  const 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/es2019/pm-plugins/utils/check-tr-actions/tr-checks/check-deleting-content.js

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

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

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

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

@@ -0,0 +1,23 @@
+import { ActionType } from '../types';
+export const checkListTypeNodeChanged = step => {
+  const {
+    slice: {
+      content
+    }
+  } = step;
+  const childCount = content.childCount;
+  if (childCount < 1) {
+    return undefined;
+  }
+  for (const node of content.content) {
+    const 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
+      };
+    }
+  }
+  return undefined;
+};

package/dist/es2019/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 const checkMarkChanged = step => {
+  if (!(step instanceof AddMarkStep || step instanceof RemoveMarkStep)) {
+    return undefined;
+  }
+  return {
+    type: ActionType.CHANGING_MARK
+  };
+};

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

@@ -0,0 +1,71 @@
+import { ActionType } from '../types';
+const compareAttributes = (prevAttr, newAttr) => {
+  const allKeys = new Set([...Object.keys(prevAttr), ...Object.keys(newAttr)]);
+  for (const key of allKeys) {
+    const prevValue = prevAttr[key];
+    const newValue = newAttr[key];
+    if (prevValue !== newValue && key !== 'localId') {
+      return key;
+    }
+  }
+  return undefined;
+};
+const compareMarks = (prevMarks, newMarks) => {
+  if (!prevMarks && !newMarks) {
+    return undefined;
+  }
+  const previousMarksArr = new Map(prevMarks.map(mark => [mark.type.name, mark.attrs]));
+  const newMarksArr = new Map(newMarks.map(mark => [mark.type.name, mark.attrs]));
+  const allMarks = new Set([...previousMarksArr.keys(), ...newMarksArr.keys()]);
+  for (const key of allMarks) {
+    const previousValue = previousMarksArr.get(key);
+    const newValue = newMarksArr.get(key);
+    if (JSON.stringify(previousValue) !== JSON.stringify(newValue)) {
+      return key;
+    }
+  }
+  return undefined;
+};
+export const checkNodeAttributeChanged = (tr, step) => {
+  const {
+    slice,
+    from,
+    to
+  } = step;
+  const oldNode = tr.docs[0].nodeAt(from);
+  const 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
+  const changedAttr = compareAttributes(oldNode.attrs, newNode.attrs);
+  if (changedAttr) {
+    return {
+      type: ActionType.CHANGING_ATTRS,
+      extraData: {
+        attr: changedAttr,
+        from,
+        to
+      }
+    };
+  }
+
+  // For some changes, we need to compare the marks of the node
+  // e.g. Media Border, Links
+  const changedMarks = compareMarks(oldNode.marks, newNode.marks);
+  if (changedMarks) {
+    return {
+      type: ActionType.CHANGING_ATTRS,
+      extraData: {
+        attr: changedMarks,
+        from,
+        to
+      }
+    };
+  }
+  return undefined;
+};

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

@@ -0,0 +1,18 @@
+import { ActionType } from '../types';
+export const checkStatusChanged = step => {
+  const {
+    slice
+  } = step;
+  const 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/es2019/pm-plugins/utils/check-tr-actions/tr-checks/check-table-column-resized.js

@@ -0,0 +1,53 @@
+import { BatchAttrsStep } from '@atlaskit/adf-schema/steps';
+import { AttrStep } from '@atlaskit/editor-prosemirror/transform';
+import { ActionType } from '../types';
+export const checkTableColumnResized = tr => {
+  const COL_WIDTH_ATTR = 'colwidth';
+  const steps = tr.steps;
+
+  // Find the step that is changing the column width
+  const resizingColumnStep = steps.find(step => step instanceof AttrStep || step instanceof BatchAttrsStep);
+  if (!resizingColumnStep) {
+    return undefined;
+  }
+  let 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;
+    }
+    const {
+      attrs,
+      nodeType,
+      position
+    } = resizingColumnStep.data[0];
+    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
+  const $pos = tr.doc.resolve(pos);
+  const blockRange = $pos.blockRange();
+  if (!blockRange) {
+    return undefined;
+  }
+  const from = blockRange.start;
+  const 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,
+      to
+    }
+  };
+};

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

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

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

@@ -0,0 +1,17 @@
+export let 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;
+}({});

package/dist/es2019/pm-plugins/utils/get-new-plugin-state.js

@@ -0,0 +1,101 @@
+import { checkTrActionType } from './check-tr-actions/check-tr-action-type';
+import { ActionType } from './check-tr-actions/types';
+import { isNonTextUndo } from './is-non-text-undo';
+import { isSafeInsert } from './is-safe-insert';
+const textInputActions = [ActionType.TEXT_INPUT, ActionType.EMPTY_LINE_ADDED_OR_DELETED];
+const listActions = [ActionType.UPDATING_NEW_LIST_TYPE_ITEM, ActionType.INSERTING_NEW_LIST_TYPE_NODE];
+const continuousActions = [...textInputActions, ...listActions, ActionType.UPDATING_STATUS];
+const checkIsDesiredAction = (trType, desiredActions) => {
+  return trType && desiredActions.includes(trType.type);
+};
+const getNewActionTypeCount = (shouldIncrement, currentCount) => {
+  return shouldIncrement ? currentCount + 1 : currentCount;
+};
+export const getNewPluginState = ({
+  now,
+  intentToStartEditTime,
+  shouldPersistActiveSession,
+  tr,
+  pluginState,
+  oldState,
+  newState
+}) => {
+  var _trType$extraData, _previousTrType$extra;
+  const {
+    actionTypeCount,
+    timeOfLastTextInput,
+    totalActionCount,
+    previousTrType,
+    safeInsertCount,
+    contentSizeChanged
+  } = pluginState;
+  const newPluginState = {
+    ...pluginState,
+    activeSessionTime: now - intentToStartEditTime,
+    contentSizeChanged: contentSizeChanged + (newState.doc.content.size - oldState.doc.content.size),
+    intentToStartEditTime,
+    shouldPersistActiveSession
+  };
+  const trType = checkTrActionType(tr);
+  const newSafeInsertCount = getNewActionTypeCount(isSafeInsert(tr, oldState.tr.selection.from, trType === null || trType === void 0 ? void 0 : trType.type), safeInsertCount);
+  const newUndoCount = getNewActionTypeCount(isNonTextUndo(tr), actionTypeCount.undoCount);
+  if (!trType) {
+    return {
+      ...newPluginState,
+      totalActionCount: totalActionCount + 1,
+      timeOfLastTextInput: undefined,
+      actionTypeCount: {
+        ...actionTypeCount,
+        undoCount: newUndoCount
+      },
+      previousTrType: trType,
+      safeInsertCount: newSafeInsertCount
+    };
+  }
+
+  // Below are conditions for special cases which should not increase action count if the previous action was the same or was textInput
+  // Check if tr is updating the same status node
+  const isNotNewStatus = trType.type === ActionType.UPDATING_STATUS && (previousTrType === null || previousTrType === void 0 ? void 0 : previousTrType.type) === ActionType.UPDATING_STATUS && (trType === null || trType === void 0 ? void 0 : (_trType$extraData = trType.extraData) === null || _trType$extraData === void 0 ? void 0 : _trType$extraData.statusId) === (previousTrType === null || previousTrType === void 0 ? void 0 : (_previousTrType$extra = previousTrType.extraData) === null || _previousTrType$extra === void 0 ? void 0 : _previousTrType$extra.statusId);
+
+  // Check if tr is adding text after adding a list node
+  const isAddingTextToListNode = trType.type === ActionType.TEXT_INPUT && checkIsDesiredAction(previousTrType, listActions);
+
+  // Check if tr is adding new list item after text input
+  const isAddingNewListItemAfterTextInput = (previousTrType === null || previousTrType === void 0 ? void 0 : previousTrType.type) === ActionType.TEXT_INPUT && trType.type === ActionType.UPDATING_NEW_LIST_TYPE_ITEM;
+
+  // Check if tr is textInput
+  const isTextInput = textInputActions.includes(trType.type);
+
+  // Don't increment action count if tr is text input, not a new status, adding text to list node or adding new list item if timeOfLastTextInput is set
+  const shouldNotIncrementActionCount = timeOfLastTextInput && (isTextInput || isNotNewStatus || isAddingTextToListNode || isAddingNewListItemAfterTextInput);
+  const newTotalActionCount = getNewActionTypeCount(!shouldNotIncrementActionCount, totalActionCount);
+
+  // Increment textInputCount if tr is text input and previous action was not text input or list action
+  const newTextInputCount = getNewActionTypeCount(isTextInput && !(timeOfLastTextInput && checkIsDesiredAction(previousTrType, [...textInputActions, ...listActions])), actionTypeCount.textInputCount);
+  const newNodeAttrCount = getNewActionTypeCount((trType === null || trType === void 0 ? void 0 : trType.type) === ActionType.CHANGING_ATTRS, actionTypeCount.nodeAttributeChangeCount);
+  const isRepeatedAttrAction = (trType === null || trType === void 0 ? void 0 : trType.type) === ActionType.CHANGING_ATTRS && (previousTrType === null || previousTrType === void 0 ? void 0 : previousTrType.type) === ActionType.CHANGING_ATTRS && trType.extraData.attr === previousTrType.extraData.attr && trType.extraData.from === previousTrType.extraData.from && trType.extraData.to === previousTrType.extraData.to;
+  const newRepeatedActionCount = getNewActionTypeCount(isRepeatedAttrAction, pluginState.repeatedActionCount);
+  const contentMoved = getNewActionTypeCount((trType === null || trType === void 0 ? void 0 : trType.type) === ActionType.MOVING_CONTENT, actionTypeCount.contentMovedCount);
+  const newMarkChangeCount = getNewActionTypeCount((trType === null || trType === void 0 ? void 0 : trType.type) === ActionType.CHANGING_MARK, actionTypeCount.markChangeCount);
+  const newContentDeletedCount = getNewActionTypeCount((trType === null || trType === void 0 ? void 0 : trType.type) === ActionType.DELETING_CONTENT, actionTypeCount.contentDeletedCount);
+
+  // timeOfLastTextInput should be set if tr includes continuous text input on the same node
+  const shouldSetTimeOfLastTextInput = continuousActions.includes(trType.type) || isNotNewStatus;
+  return {
+    ...newPluginState,
+    totalActionCount: newTotalActionCount,
+    timeOfLastTextInput: shouldSetTimeOfLastTextInput ? now : undefined,
+    actionTypeCount: {
+      ...actionTypeCount,
+      textInputCount: newTextInputCount,
+      undoCount: newUndoCount,
+      nodeAttributeChangeCount: newNodeAttrCount,
+      contentMovedCount: contentMoved,
+      markChangeCount: newMarkChangeCount,
+      contentDeletedCount: newContentDeletedCount
+    },
+    previousTrType: trType,
+    repeatedActionCount: newRepeatedActionCount,
+    safeInsertCount: newSafeInsertCount
+  };
+};

package/dist/es2019/pm-plugins/utils/is-safe-insert.js

@@ -0,0 +1,28 @@
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+export const isSafeInsert = (tr, insertPos, trType) => {
+  var _$firstStepPos$node, _$insertPos$node;
+  // Exclude the cases where trType is defined, as it is a specific action
+  // that should not be considered for safe insert actions
+  if (trType) {
+    return false;
+  }
+  if (insertPos > tr.doc.content.size) {
+    return false;
+  }
+  const [firstStep] = tr.steps;
+  if (!(firstStep instanceof ReplaceStep)) {
+    return false;
+  }
+  const firstStepPos = firstStep.from;
+  if (firstStepPos === insertPos) {
+    return false;
+  }
+  const $firstStepPos = tr.doc.resolve(firstStepPos);
+  if ($firstStepPos.node().type.name === 'paragraph') {
+    return false;
+  }
+  const firstStepParentNodeType = (_$firstStepPos$node = $firstStepPos.node($firstStepPos.depth)) === null || _$firstStepPos$node === void 0 ? void 0 : _$firstStepPos$node.type.name;
+  const $insertPos = tr.doc.resolve(insertPos);
+  const parentNodeType = (_$insertPos$node = $insertPos.node($insertPos.depth - 1)) === null || _$insertPos$node === void 0 ? void 0 : _$insertPos$node.type.name;
+  return parentNodeType !== firstStepParentNodeType;
+};

package/dist/es2019/pm-plugins/utils/should-skip-tr.js

@@ -0,0 +1,38 @@
+import { InsertTypeAheadStep, LinkMetaStep } from '@atlaskit/adf-schema/steps';
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+const isResolvingLink = tr => {
+  var _linkStep$getMetadata;
+  // When links are added, there are two transactions that are fired and we want to ignore the last one where the link is resolved
+  const linkStep = tr.steps.find(step => step instanceof LinkMetaStep);
+  const hasReplaceStep = tr.steps.some(step => step instanceof ReplaceStep);
+  return Boolean(hasReplaceStep && linkStep instanceof LinkMetaStep && ((_linkStep$getMetadata = linkStep.getMetadata()) === null || _linkStep$getMetadata === void 0 ? void 0 : _linkStep$getMetadata.cardAction) === 'RESOLVE');
+};
+const checkTypeAheadStepStage = tr => {
+  var _tr$getMeta;
+  // When nodes are inserted from typeahead, there are multiple transactions that are fired that changes the document
+  // We want to ignore all but the last transaction where the node is inserted
+  if (((_tr$getMeta = tr.getMeta('typeAheadPlugin$')) === null || _tr$getMeta === void 0 ? void 0 : _tr$getMeta.action) === 'INSERT_RAW_QUERY') {
+    return 'INSERT_RAW_QUERY';
+  }
+  if (!tr.getMeta('appendedTransaction')) {
+    return false;
+  }
+  const insertTypeAheadStep = tr.steps.find(step => step instanceof InsertTypeAheadStep);
+  const replaceStep = tr.steps.find(step => step instanceof ReplaceStep);
+  if (!insertTypeAheadStep || !replaceStep) {
+    return false;
+  }
+  return insertTypeAheadStep instanceof InsertTypeAheadStep && insertTypeAheadStep.stage;
+};
+export const shouldSkipTr = tr => {
+  if (isResolvingLink(tr)) {
+    return true;
+  }
+  const typeAheadStepStage = checkTypeAheadStepStage(tr);
+  if (typeAheadStepStage) {
+    return typeAheadStepStage !== 'INSERTING_ITEM';
+  } else {
+    // Ignore all appended transactions apart from when typeahead is inserting an item
+    return tr.getMeta('appendedTransaction');
+  }
+};

package/dist/esm/metricsPlugin.js

@@ -18,9 +18,17 @@ export var metricsPlugin = function metricsPlugin(_ref) {
       }];
     },
     commands: {
-      startActiveSessionTimer: function startActiveSessionTimer() {
+      setContentMoved: function setContentMoved() {
         return function (_ref2) {
           var tr = _ref2.tr;
+          return tr.setMeta(metricsKey, {
+            contentMoved: true
+          });
+        };
+      },
+      startActiveSessionTimer: function startActiveSessionTimer() {
+        return function (_ref3) {
+          var tr = _ref3.tr;
           var pluginState = api === null || api === void 0 ? void 0 : api.metrics.sharedState.currentState();
           if (!(pluginState !== null && pluginState !== void 0 && pluginState.intentToStartEditTime)) {
             return tr;
@@ -32,8 +40,8 @@ export var metricsPlugin = function metricsPlugin(_ref) {
         };
       },
       stopActiveSession: function stopActiveSession() {
-        return function (_ref3) {
-          var tr = _ref3.tr;
+        return function (_ref4) {
+          var tr = _ref4.tr;
           if (!api) {
             return tr;
           }
@@ -42,11 +50,12 @@ export var metricsPlugin = function metricsPlugin(_ref) {
             return tr;
           }
           if (pluginState && pluginState.totalActionCount > 0 && pluginState.activeSessionTime > 0) {
+            var _api$analytics;
             var payloadToSend = getAnalyticsPayload({
               currentContent: tr.doc.content,
               pluginState: pluginState
             });
-            api === null || api === void 0 || api.analytics.actions.attachAnalyticsEvent(payloadToSend)(tr);
+            api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || _api$analytics.actions.attachAnalyticsEvent(payloadToSend)(tr);
           }
           tr.setMeta(metricsKey, {
             stopActiveSession: true
@@ -54,13 +63,13 @@ export var metricsPlugin = function metricsPlugin(_ref) {
           return tr;
         };
       },
-      handleIntentToStartEdit: function handleIntentToStartEdit(_ref4) {
-        var newSelection = _ref4.newSelection,
-          _ref4$shouldStartTime = _ref4.shouldStartTimer,
-          shouldStartTimer = _ref4$shouldStartTime === void 0 ? true : _ref4$shouldStartTime,
-          shouldPersistActiveSession = _ref4.shouldPersistActiveSession;
-        return function (_ref5) {
-          var tr = _ref5.tr;
+      handleIntentToStartEdit: function handleIntentToStartEdit(_ref5) {
+        var newSelection = _ref5.newSelection,
+          _ref5$shouldStartTime = _ref5.shouldStartTimer,
+          shouldStartTimer = _ref5$shouldStartTime === void 0 ? true : _ref5$shouldStartTime,
+          shouldPersistActiveSession = _ref5.shouldPersistActiveSession;
+        return function (_ref6) {
+          var tr = _ref6.tr;
           if (!api) {
             return tr;
           }