@atlaskit/editor-common 115.5.0 → 115.6.0

package/dist/es2019/utils/breakout.js

@@ -1,7 +1,19 @@
 import { akEditorBreakoutPadding, akEditorDefaultLayoutWidth, akEditorFullWidthLayoutWidth, akEditorSwoopCubicBezier, akEditorWideLayoutWidth, breakoutWideScaleRatio } from '@atlaskit/editor-shared-styles';
+import commonMessages from '../messages';
 import { mapBreakpointToLayoutMaxWidth } from '../ui/BaseTheme';
 import { getBreakpoint } from '../ui/WidthProvider';
-import { parsePx } from './parsePx';
+import { parsePx } from './dom';
+export const breakoutResizableNodes = ['expand', 'layoutSection', 'codeBlock', 'syncBlock', 'bodiedSyncBlock'];
+export const getBreakoutResizableNodeTypes = schema => {
+  const {
+    expand,
+    codeBlock,
+    layoutSection,
+    syncBlock,
+    bodiedSyncBlock
+  } = schema.nodes;
+  return new Set([expand, codeBlock, layoutSection, syncBlock, bodiedSyncBlock]);
+};
 
 /**
  * Variables required to construct a context for breakout ssr inline script.
@@ -123,11 +135,21 @@ export function calculateBreakoutStyles({
 export function calcBreakoutWidthPx(mode, widthStateWidth, padding) {
   return parsePx(calcBreakoutWidth(mode, widthStateWidth, padding));
 }
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { breakoutResizableNodes } from './breakoutResizableNodes';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getBreakoutResizableNodeTypes } from './getBreakoutResizableNodeTypes';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getNextBreakoutMode } from './getNextBreakoutMode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getTitle } from './getTitle';
+export const getNextBreakoutMode = currentMode => {
+  if (currentMode === 'full-width') {
+    return 'center';
+  } else if (currentMode === 'wide') {
+    return 'full-width';
+  }
+  return 'wide';
+};
+export const getTitle = layout => {
+  switch (layout) {
+    case 'full-width':
+      return commonMessages.layoutFixedWidth;
+    case 'wide':
+      return commonMessages.layoutFullWidth;
+    default:
+      return commonMessages.layoutWide;
+  }
+};

package/dist/es2019/utils/commands.js

@@ -1,14 +1,23 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../analytics';
 import { withAnalytics } from '../editor-analytics';
 import { GapCursorSelection } from '../selection';
-import { atTheBeginningOfDoc } from './atTheBeginningOfDoc';
-import { atTheEndOfDoc } from './atTheEndOfDoc';
-import { filter } from './filter';
-import { insertNewLine } from './insertNewLine';
-import { isEmptyParagraph } from './isEmptyParagraph';
-import { isMediaNode } from './isMediaNode';
+import { isEmptyParagraph } from './editor-core-utils';
+import { isMediaNode } from './nodes';
+export const filter = (predicates, cmd) => {
+  return function (state, dispatch, view) {
+    if (!Array.isArray(predicates)) {
+      predicates = [predicates];
+    }
+    if (predicates.some(pred => !pred(state, view))) {
+      return false;
+    }
+    return cmd(state, dispatch, view) || false;
+  };
+};
+
 /**
  * Walk forwards from a position until we encounter the (inside) start of
  * the next node, or reach the end of the document.
@@ -47,6 +56,33 @@ export const walkPrevNode = $startPos => {
     foundNode: $pos.pos > 0
   };
 };
+export function insertNewLine() {
+  return function (state, dispatch) {
+    const {
+      $from
+    } = state.selection;
+    const parent = $from.parent;
+    const {
+      hardBreak
+    } = state.schema.nodes;
+    if (hardBreak) {
+      const hardBreakNode = hardBreak.createChecked();
+      if (parent && parent.type.validContent(Fragment.from(hardBreakNode))) {
+        if (dispatch) {
+          dispatch(state.tr.replaceSelectionWith(hardBreakNode, false));
+        }
+        return true;
+      }
+    }
+    if (state.selection instanceof TextSelection) {
+      if (dispatch) {
+        dispatch(state.tr.insertText('\n'));
+      }
+      return true;
+    }
+    return false;
+  };
+}
 export const insertNewLineWithAnalytics = editorAnalyticsAPI => withAnalytics(editorAnalyticsAPI, {
   action: ACTION.INSERTED,
   actionSubject: ACTION_SUBJECT.TEXT,
@@ -174,6 +210,19 @@ function canMoveDown(state) {
   }
   return !atTheEndOfDoc(state);
 }
+export function atTheEndOfDoc(state) {
+  const {
+    selection,
+    doc
+  } = state;
+  return doc.nodeSize - selection.$to.pos - 2 === selection.$to.depth;
+}
+export function atTheBeginningOfDoc(state) {
+  const {
+    selection
+  } = state;
+  return selection.$from.pos === selection.$from.depth;
+}
 
 /**
  * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
@@ -210,6 +259,17 @@ export const deleteEmptyParagraphAndMoveBlockUp = canNextNodeMoveUp => {
     return false;
   };
 };
+export const insertContentDeleteRange = (tr, getSelectionResolvedPos, insertions, deletions) => {
+  insertions.forEach(contentInsert => {
+    const [content, pos] = contentInsert;
+    tr.insert(tr.mapping.map(pos), content);
+  });
+  deletions.forEach(deleteRange => {
+    const [firstPos, lastPos] = deleteRange;
+    tr.delete(tr.mapping.map(firstPos), tr.mapping.map(lastPos));
+  });
+  tr.setSelection(new TextSelection(getSelectionResolvedPos(tr)));
+};
 
 /**
  * Check if the selection is empty and at the start of a task or list item
@@ -301,16 +361,4 @@ export const isEmptySelectionAtEnd = state => {
   }
   return empty && ($from.end() === $from.pos || state.selection instanceof GapCursorSelection);
 };
-
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { filter as filterCommand };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { filter } from './filter';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { insertNewLine } from './insertNewLine';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { atTheEndOfDoc } from './atTheEndOfDoc';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { atTheBeginningOfDoc } from './atTheBeginningOfDoc';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { insertContentDeleteRange } from './insertContentDeleteRange';
+export { filter as filterCommand };

package/dist/es2019/utils/compare-props.js

@@ -1,6 +1,5 @@
 import React from 'react';
-import { getKeys } from './getKeys';
-import { serializeValue } from './serializeValue';
+export const getKeys = Object.keys;
 export const getKeysAddedRemovedCommon = (object1, object2) => {
   const oldKeys = object1 !== null ? getKeys(object1) : [];
   const newKeys = object2 !== null ? getKeys(object2) : [];
@@ -13,6 +12,28 @@ export const getKeysAddedRemovedCommon = (object1, object2) => {
     removed
   };
 };
+export const serializeValue = value => {
+  const valueType = typeof value;
+  if (value === null) {
+    return 'null';
+  } else if (value === undefined) {
+    return 'undefined';
+  } else if (valueType === 'string' || valueType === 'number') {
+    return value;
+  } else if (valueType === 'symbol') {
+    return value.toString();
+  }
+  // Calling toString of function returns whole function text with body.
+  // So, just return function with name.
+  else if (valueType === 'function') {
+    return `function:${value.name}`;
+  } else if (valueType === 'object') {
+    return {
+      type: 'object',
+      keys: Object.keys(value)
+    };
+  }
+};
 export const getPropsDifference = (object1, object2, curDepth = 0, maxDepth = 2, keysToIgnore = []) => {
   const {
     added,
@@ -76,8 +97,4 @@ export const getShallowPropsDifference = (object1, object2) => {
     changed,
     removed
   };
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getKeys } from './getKeys';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { serializeValue } from './serializeValue';
+};

package/dist/es2019/utils/compareNodes.js

@@ -1,6 +1,14 @@
 import { fg } from '@atlaskit/platform-feature-flags';
 import { SortOrder } from '../types';
-import { ContentType } from './ContentType';
+export let ContentType = /*#__PURE__*/function (ContentType) {
+  ContentType[ContentType["NUMBER"] = 0] = "NUMBER";
+  ContentType[ContentType["TEXT"] = 5] = "TEXT";
+  ContentType[ContentType["MENTION"] = 10] = "MENTION";
+  ContentType[ContentType["DATE"] = 15] = "DATE";
+  ContentType[ContentType["STATUS"] = 20] = "STATUS";
+  ContentType[ContentType["LINK"] = 25] = "LINK";
+  return ContentType;
+}({});
 function getLinkMark(node) {
   const [linkMark] = node.marks.filter(mark => mark.type.name === 'link');
   return linkMark || null;
@@ -227,6 +235,4 @@ function compareMetaFromNode(metaNodeA, metaNodeB) {
     return metaNodeA.type > metaNodeB.type ? 1 : -1;
   }
   return compareValue(metaNodeA.value, metaNodeB.value);
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { ContentType } from './ContentType';
+}

package/dist/es2019/utils/datasource.js

@@ -1,5 +1,17 @@
+import { ASSETS_LIST_OF_LINKS_DATASOURCE_ID, CONFLUENCE_SEARCH_DATASOURCE_ID, JIRA_LIST_OF_LINKS_DATASOURCE_ID } from '@atlaskit/link-datasource';
 import { fg } from '@atlaskit/platform-feature-flags';
-import { getDatasourceType } from './getDatasourceType';
+export const getDatasourceType = datasourceId => {
+  switch (datasourceId) {
+    case JIRA_LIST_OF_LINKS_DATASOURCE_ID:
+      return 'jira';
+    case ASSETS_LIST_OF_LINKS_DATASOURCE_ID:
+      return 'assets';
+    case CONFLUENCE_SEARCH_DATASOURCE_ID:
+      return 'confluence-search';
+    default:
+      return undefined;
+  }
+};
 export const canRenderDatasource = (datasourceId, defaultValue = true) => {
   const datasourceType = getDatasourceType(datasourceId);
   switch (datasourceType) {
@@ -13,6 +25,4 @@ export const canRenderDatasource = (datasourceId, defaultValue = true) => {
     default:
       return defaultValue;
   }
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getDatasourceType } from './getDatasourceType';
+};

package/dist/es2019/utils/document.js

@@ -1,7 +1,43 @@
+import clamp from 'lodash/clamp';
 import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
-import { getStepRange } from './getStepRange';
-import { hasDocAsParent } from './hasDocAsParent';
+import { isEmptyParagraph } from './editor-core-utils';
+export const getStepRange = transaction => {
+  let from = -1;
+  let to = -1;
+  transaction.mapping.maps.forEach((stepMap, index) => {
+    stepMap.forEach((oldStart, oldEnd) => {
+      const newStart = transaction.mapping.slice(index).map(oldStart, -1);
+      const newEnd = transaction.mapping.slice(index).map(oldEnd);
+      const docSize = transaction.doc.content.size;
+      from = clamp(newStart < from || from === -1 ? newStart : from, 0, docSize);
+      to = clamp(newEnd > to || to === -1 ? newEnd : to, 0, docSize);
+    });
+  });
+  if (from !== -1) {
+    return {
+      from,
+      to
+    };
+  }
+  return null;
+};
+
+// Checks to see if the parent node is the document, ie not contained within another entity
+export function hasDocAsParent($anchor) {
+  return $anchor.depth === 1;
+}
+
+/**
+ * Checks if a node looks like an empty document
+ */
+export function isEmptyDocument(node) {
+  const nodeChild = node.content.firstChild;
+  if (node.childCount !== 1 || !nodeChild) {
+    return false;
+  }
+  return isEmptyParagraph(nodeChild);
+}
 export function bracketTyped(state) {
   const {
     selection
@@ -30,6 +66,31 @@ export function nodesBetweenChanged(tr, f, startPos) {
   }
   tr.doc.nodesBetween(stepRange.from, stepRange.to, f, startPos);
 }
+
+/**
+ * Returns false if node contains only empty inline nodes and hardBreaks.
+ */
+export function hasVisibleContent(node) {
+  const isInlineNodeHasVisibleContent = inlineNode => {
+    return inlineNode.isText ? !!inlineNode.textContent.trim() : inlineNode.type.name !== 'hardBreak';
+  };
+  if (node.isInline) {
+    return isInlineNodeHasVisibleContent(node);
+  } else if (node.isBlock && (node.isLeaf || node.isAtom)) {
+    return true;
+  } else if (!node.childCount) {
+    return false;
+  }
+  for (let index = 0; index < node.childCount; index++) {
+    const child = node.child(index);
+    const invisibleNodeTypes = ['paragraph', 'text', 'hardBreak'];
+    if (!invisibleNodeTypes.includes(child.type.name) || hasVisibleContent(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+export const isSelectionEndOfParagraph = state => state.selection.$to.parent.type === state.schema.nodes.paragraph && state.selection.$to.pos === state.doc.resolve(state.selection.$to.pos).end();
 function getChangedNodesIn({
   tr,
   doc
@@ -149,14 +210,4 @@ function areFragmentsEqual(frag1, frag2, attributesToIgnore, opts) {
     childrenEqual = false;
   });
   return childrenEqual;
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getStepRange } from './getStepRange';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { hasDocAsParent } from './hasDocAsParent';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isEmptyDocument } from './isEmptyDocument';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { hasVisibleContent } from './hasVisibleContent';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isSelectionEndOfParagraph } from './isSelectionEndOfParagraph';
+}

package/dist/es2019/utils/dom.js

@@ -1,3 +1,56 @@
+/**
+ * Walks a DOM tree up to the provided `stopElement`, or if falsy before.
+ * @param element
+ * @param stopElement
+ */
+export function walkUpTreeUntil(element, shouldStop) {
+  let rootElement = element;
+  while (rootElement && rootElement.parentElement && !shouldStop(rootElement)) {
+    rootElement = rootElement.parentElement;
+  }
+  return rootElement;
+}
+
+/**
+ * Takes all children out from wrapped el and puts them directly inside
+ * the parent el, at the wrapped el's position
+ */
+export function unwrap(parent, wrapped) {
+  const docsFragment = document.createDocumentFragment();
+  Array.from(wrapped.children).forEach(child => {
+    docsFragment.appendChild(child);
+  });
+  parent.replaceChild(docsFragment, wrapped);
+}
+
+/**
+ * Walks up DOM removing elements if they are empty until it finds
+ * one that is not
+ */
+export function removeNestedEmptyEls(el) {
+  while (el.parentElement && el.childElementCount === 0 && el.textContent === '') {
+    const parentEl = el.parentElement;
+    parentEl.removeChild(el);
+    el = parentEl;
+  }
+}
+
+/**
+ * IE11 doesn't support classList to SVGElements
+ **/
+export const containsClassName = (node, className) => {
+  if (!node) {
+    return false;
+  }
+  if (node.classList && node.classList.contains) {
+    return node.classList.contains(className);
+  }
+  if (!node.className) {
+    return false;
+  }
+  const classNames = typeof node.className.baseVal === 'string' ? node.className.baseVal : node.className;
+  return classNames.split(' ').indexOf(className) !== -1;
+};
 export function closest(node, s) {
   if (!node) {
     return null;
@@ -28,6 +81,30 @@ export function closest(node, s) {
 export function closestElement(node, s) {
   return closest(node, s);
 }
+
+/**
+ * Util for converting a css pixel size value to a number (of pixels).
+ *
+ * ie.
+ * ```ts
+ * const pixels = parsePx('10px')
+ * //    ^$ const pixels: number
+ * ```
+ * * ```ts
+ * const pixels = parsePx('10')
+ * //    ^$ const pixels: number | undefined
+ * ```
+ */
+// At time of writting prettier would strip the extend here.
+// prettier-ignore
+
+export function parsePx(pxStr) {
+  if (!pxStr.endsWith('px')) {
+    return undefined;
+  }
+  const maybeNumber = parseInt(pxStr, 10);
+  return !Number.isNaN(maybeNumber) ? maybeNumber : undefined;
+}
 // does typescript have function templates yet?
 
 export function mapElem(elem, callback) {
@@ -39,14 +116,4 @@ export function mapElem(elem, callback) {
 }
 export function maphElem(elem, callback) {
   return mapElem(elem, callback);
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { walkUpTreeUntil } from './walkUpTreeUntil';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { unwrap } from './unwrap';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { removeNestedEmptyEls } from './removeNestedEmptyEls';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { containsClassName } from './containsClassName';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { parsePx } from './parsePx';
+}

package/dist/es2019/utils/editor-core-utils.js

@@ -1,4 +1,16 @@
-import { stepHasSlice } from './stepHasSlice';
+import { AllSelection, NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { ReplaceAroundStep, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { closest } from './dom';
+
+/**
+ * Checks if node is an empty paragraph.
+ */
+export function isEmptyParagraph(node) {
+  return !!node && node.type.name === 'paragraph' && !node.childCount;
+}
+export const stepHasSlice = step => step && step.hasOwnProperty('slice');
 
 /**
  * Checks whether a given step is adding nodes of given nodeTypes
@@ -19,6 +31,91 @@ export function stepAddsOneOf(step, nodeTypes) {
   });
   return adds;
 }
+export const extractSliceFromStep = step => {
+  if (!(step instanceof ReplaceStep) && !(step instanceof ReplaceAroundStep)) {
+    return null;
+  }
+
+  // @ts-ignore This is by design. Slice is a private property, but accesible, from ReplaceStep.
+  // However, we need to read it to found if the step was adding a newline
+  const slice = step.slice;
+  return slice;
+};
+export const isTextSelection = selection => selection instanceof TextSelection;
+export const isElementInTableCell = element => {
+  return closest(element, 'td, th');
+};
+export const isLastItemMediaGroup = node => {
+  const {
+    content
+  } = node;
+  return !!content.lastChild && content.lastChild.type.name === 'mediaGroup';
+};
+export const setNodeSelection = (view, pos) => {
+  const {
+    state,
+    dispatch
+  } = view;
+  if (!isFinite(pos)) {
+    return;
+  }
+  const tr = state.tr.setSelection(NodeSelection.create(state.doc, pos));
+  dispatch(tr);
+};
+export function setTextSelection(view, anchor, head) {
+  const {
+    state,
+    dispatch
+  } = view;
+  const tr = state.tr.setSelection(TextSelection.create(state.doc, anchor, head));
+  dispatch(tr);
+}
+export function setAllSelection(view) {
+  const {
+    state,
+    dispatch
+  } = view;
+  const tr = state.tr.setSelection(new AllSelection(view.state.doc));
+  dispatch(tr);
+}
+export function setCellSelection(view, anchor, head) {
+  const {
+    state,
+    dispatch
+  } = view;
+  // Ignored via go/ees005
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  dispatch(state.tr.setSelection(CellSelection.create(state.doc, anchor, head)));
+}
+export function nonNullable(value) {
+  return value !== null && value !== undefined;
+}
+
+// checks if the given position is within the ProseMirror document
+export const isValidPosition = (pos, state) => {
+  if (typeof pos !== 'number') {
+    return false;
+  }
+  if (pos >= 0 && pos <= state.doc.resolve(0).end()) {
+    return true;
+  }
+  return false;
+};
+export const isInLayoutColumn = state => {
+  return hasParentNodeOfType(state.schema.nodes.layoutSection)(state.selection);
+};
+export function filterChildrenBetween(doc, from, to, predicate) {
+  const results = [];
+  doc.nodesBetween(from, to, (node, pos, parent) => {
+    if (predicate(node, pos, parent)) {
+      results.push({
+        node,
+        pos
+      });
+    }
+  });
+  return results;
+}
 export const removeBlockMarks = (state, marks) => {
   const {
     selection,
@@ -51,32 +148,4 @@ export const removeBlockMarks = (state, marks) => {
   });
   return blockMarksExists ? tr : undefined;
 };
-const not = fn => arg => !fn(arg);
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isEmptyParagraph } from './isEmptyParagraph';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { stepHasSlice } from './stepHasSlice';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { extractSliceFromStep } from './extractSliceFromStep';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isTextSelection } from './isTextSelection';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isElementInTableCell } from './isElementInTableCell';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isLastItemMediaGroup } from './isLastItemMediaGroup';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { setNodeSelection } from './setNodeSelection';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { setTextSelection } from './setTextSelection';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { setAllSelection } from './setAllSelection';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { setCellSelection } from './setCellSelection';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { nonNullable } from './nonNullable';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isValidPosition } from './isValidPosition';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isInLayoutColumn } from './isInLayoutColumn';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { filterChildrenBetween } from './filterChildrenBetween';
+const not = fn => arg => !fn(arg);

package/dist/es2019/utils/get-performance-options.js

@@ -1,5 +1,5 @@
 import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '../analytics';
-import { stopMeasure } from '../performance-measures';
+import { startMeasure, stopMeasure } from '../performance-measures';
 
 // This was existing logic when converting from ReactNodeView
 // our current sampling for this event is not bound by node.type
@@ -28,6 +28,11 @@ export function getPerformanceOptions(view) {
     slowThreshold
   };
 }
+export function startMeasureReactNodeViewRendered({
+  nodeTypeName
+}) {
+  startMeasure(`🦉${nodeTypeName}::ReactNodeView`);
+}
 export function stopMeasureReactNodeViewRendered({
   nodeTypeName,
   dispatchAnalyticsEvent,
@@ -47,6 +52,4 @@ export function stopMeasureReactNodeViewRendered({
       });
     }
   });
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { startMeasureReactNodeViewRendered } from './startMeasureReactNodeViewRendered';
+}