@atlaskit/editor-common 74.0.1 → 74.1.1

package/dist/es2019/ui/Resizer/index.js

@@ -0,0 +1,92 @@
+import React from 'react';
+import classnames from 'classnames';
+import { Resizable } from 're-resizable';
+import { resizerHandleLeftClassName, resizerHandlePadding, resizerHandleRightClassName, resizerHandleZIndex, resizerItemClassName } from '../../styles/shared/resizer';
+import { handleSides } from './utils';
+export default function ResizerNext(props) {
+  const resizable = React.useRef(null);
+  const {
+    handleResize,
+    handleResizeStart,
+    handleResizeStop
+  } = props;
+  const onResizeStart = React.useCallback(event => {
+    // prevent creating a drag event on Firefox
+    event.preventDefault();
+    handleResizeStart();
+  }, [handleResizeStart]);
+  const onResize = React.useCallback((_event, _direction, _elementRef, delta) => {
+    const resizableCurrent = resizable.current;
+    if (!resizableCurrent || !resizableCurrent.state.original) {
+      return;
+    }
+    const originalState = {
+      x: resizableCurrent.state.original.x,
+      y: resizableCurrent.state.original.y,
+      width: resizableCurrent.state.original.width,
+      height: resizableCurrent.state.original.height
+    };
+    handleResize(originalState, delta);
+  }, [handleResize]);
+  const onResizeStop = React.useCallback((_event, _direction, _elementRef, delta) => {
+    const resizableCurrent = resizable.current;
+    if (!resizableCurrent || !resizableCurrent.state.original) {
+      return;
+    }
+    const originalState = {
+      x: resizableCurrent.state.original.x,
+      y: resizableCurrent.state.original.y,
+      width: resizableCurrent.state.original.width,
+      height: resizableCurrent.state.original.height
+    };
+    handleResizeStop(originalState, delta);
+  }, [handleResizeStop]);
+  let handles = {};
+  if (props.handleClassName) {
+    handleSides.forEach(side => {
+      handles[side] = `${props.handleClassName}-${side}`;
+    });
+  } else {
+    handles = {
+      left: resizerHandleLeftClassName,
+      right: resizerHandleRightClassName
+    };
+  }
+  const innerPadding = props.innerPadding || resizerHandlePadding;
+  const handleStyles = {
+    left: {
+      width: '24px',
+      left: `-${innerPadding}px`,
+      zIndex: resizerHandleZIndex,
+      pointerEvents: 'auto'
+    },
+    right: {
+      width: '24px',
+      right: `-${innerPadding}px`,
+      zIndex: resizerHandleZIndex,
+      pointerEvents: 'auto'
+    }
+  };
+  const className = classnames(props.className, resizerItemClassName);
+  return /*#__PURE__*/React.createElement(Resizable, {
+    ref: resizable,
+    size: {
+      width: props.width,
+      // just content itself (no paddings)
+      height: 'auto'
+    },
+    maxWidth: props.maxWidth,
+    minWidth: props.minWidth,
+    className: className,
+    enable: props.enable,
+    handleClasses: handles,
+    handleStyles: handleStyles,
+    handleWrapperStyle: props.handleWrapperStyle //  is used to override the style of resize handles wrapper, needed for media when it is selected and caption appears makes sure the handlers won't jump.
+    ,
+    handleComponent: props.handleComponent // in media was added as a workaround to fix Up arrow key bug when media has caption and the cursor is place below the image. Our epic has a separate ticket to address this problem.
+    ,
+    onResizeStart: onResizeStart,
+    onResize: onResize,
+    onResizeStop: onResizeStop
+  }, props.children);
+}

package/dist/es2019/ui/Resizer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/ui/Resizer/utils.js

@@ -0,0 +1 @@
+export const handleSides = ['left', 'right'];

package/dist/es2019/ui/index.js

@@ -1,7 +1,7 @@
 export { default as Caption } from './Caption';
-export { default as MediaSingle, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, wrappedLayouts, shouldAddDefaultWrappedWidth } from './MediaSingle';
+export { default as MediaSingle, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, shouldAddDefaultWrappedWidth } from './MediaSingle';
 export { MediaSingleDimensionHelper } from './MediaSingle/styled';
-export { layoutSupportsWidth, calcPxFromColumns, calcPctFromPx, calcPxFromPct, calcColumnsFromPx, snapToGrid } from './MediaSingle/grid';
+export { layoutSupportsWidth, calcPxFromColumns, calcPctFromPx, calcPxFromPct, calcColumnsFromPx, snapToGrid, calcMediaPxWidth, wrappedLayouts } from './MediaSingle/grid';
 export { mediaLinkStyle } from './MediaSingle/link';
 export { default as Popup, findOverflowScrollParent } from './Popup';
 export { default as UnsupportedBlock } from './UnsupportedBlock';
@@ -16,4 +16,5 @@ export { messages as expandMessages, sharedExpandStyles, ExpandIconWrapper, expa
 export { ErrorMessage, HelperMessage, ValidMessage } from './Messages';
 export { clearNextSiblingMarginTopStyle, clearNextSiblingBlockMarkMarginTopStyle } from './clear-next-sibling-margin-top';
 export { IntlErrorBoundary, REACT_INTL_ERROR_MESSAGE } from './IntlErrorBoundary';
-export { default as IntlProviderIfMissingWrapper } from './IntlProviderIfMissingWrapper';
+export { default as IntlProviderIfMissingWrapper } from './IntlProviderIfMissingWrapper';
+export { default as FloatingToolbarButton } from './FloatingToolbar/Button';

package/dist/es2019/ui-color/ColorPalette/styles.js

@@ -1,7 +1,6 @@
 import { css } from '@emotion/react';
-import { gridSize } from '@atlaskit/theme/constants';
 export const colorPaletteWrapper = css`
-  padding: 0 ${gridSize()}px;
+  padding: 0 ${"var(--ds-space-100, 8px)"};
   /* Firefox bug fix: https://product-fabric.atlassian.net/browse/ED-1789 */
   display: flex;
 `;

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

@@ -1,6 +1,13 @@
 import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
 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');
 
 /**

package/dist/es2019/utils/hyperlink.js

@@ -0,0 +1,165 @@
+// File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/utils/hyperlink.ts
+// If changes are made to this file, please make the same update in the linked file.
+
+import { isSafeUrl, linkify, normalizeUrl as normaliseLinkHref } from '@atlaskit/adf-schema';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../analytics/types';
+import { mapSlice } from './slice';
+
+// Regular expression for a windows filepath in the format <DRIVE LETTER>:\<folder name>\
+export const FILEPATH_REGEXP = /([a-zA-Z]:|\\)([^\/:*?<>"|]+\\)?([^\/:*?<>"| ]+(?=\s?))?/gim;
+
+// Don't linkify if starts with $ or {
+export const DONTLINKIFY_REGEXP = /^(\$|{)/;
+
+/**
+ * Instance of class LinkMatcher are used in autoformatting in place of Regex.
+ * Hence it has been made similar to regex with an exec method.
+ * Extending it directly from class Regex was introducing some issues, thus that has been avoided.
+ */
+export class LinkMatcher {
+  static create() {
+    class LinkMatcherRegex {
+      exec(str) {
+        const stringsBySpace = str.slice(0, str.length - 1).split(' ');
+        const lastStringBeforeSpace = stringsBySpace[stringsBySpace.length - 1];
+        const isLastStringValid = lastStringBeforeSpace.length > 0;
+        if (!str.endsWith(' ') || !isLastStringValid) {
+          return null;
+        }
+        if (DONTLINKIFY_REGEXP.test(lastStringBeforeSpace)) {
+          return null;
+        }
+        const links = linkify.match(lastStringBeforeSpace);
+        if (!links || links.length === 0) {
+          return null;
+        }
+        const lastMatch = links[links.length - 1];
+        const lastLink = links[links.length - 1];
+        lastLink.input = str.substring(lastMatch.index);
+        lastLink.length = lastLink.lastIndex - lastLink.index + 1;
+        lastLink.index = str.lastIndexOf(lastStringBeforeSpace) + lastMatch.index;
+        return lastLink;
+      }
+    }
+    return new LinkMatcherRegex();
+  }
+}
+
+/**
+ * Adds protocol to url if needed.
+ */
+export function normalizeUrl(url) {
+  if (!url) {
+    return '';
+  }
+  if (isSafeUrl(url)) {
+    return url;
+  }
+  return normaliseLinkHref(url);
+}
+export function linkifyContent(schema) {
+  return slice => mapSlice(slice, (node, parent) => {
+    const isAllowedInParent = !parent || parent.type !== schema.nodes.codeBlock;
+    const link = node.type.schema.marks.link;
+    if (link === undefined) {
+      throw new Error('Link not in schema - unable to linkify content');
+    }
+    if (isAllowedInParent && node.isText && !link.isInSet(node.marks)) {
+      const linkified = [];
+      const text = node.text;
+      const matches = findLinkMatches(text);
+      let pos = 0;
+      const filepaths = findFilepaths(text);
+      matches.forEach(match => {
+        if (isLinkInMatches(match.start, filepaths)) {
+          return;
+        }
+        if (match.start > 0) {
+          linkified.push(node.cut(pos, match.start));
+        }
+        linkified.push(node.cut(match.start, match.end).mark(link.create({
+          href: normalizeUrl(match.href)
+        }).addToSet(node.marks)));
+        pos = match.end;
+      });
+      if (pos < text.length) {
+        linkified.push(node.cut(pos));
+      }
+      return linkified;
+    }
+    return node;
+  });
+}
+export function getLinkDomain(url) {
+  // Remove protocol and www., if either exists
+  const withoutProtocol = url.toLowerCase().replace(/^(.*):\/\//, '');
+  const withoutWWW = withoutProtocol.replace(/^(www\.)/, '');
+
+  // Remove port, fragment, path, query string
+  return withoutWWW.replace(/[:\/?#](.*)$/, '');
+}
+export function isFromCurrentDomain(url) {
+  if (!window || !window.location) {
+    return false;
+  }
+  const currentDomain = window.location.hostname;
+  const linkDomain = getLinkDomain(url);
+  return currentDomain === linkDomain;
+}
+function findLinkMatches(text) {
+  const matches = [];
+  let linkMatches = text && linkify.match(text);
+  if (linkMatches && linkMatches.length > 0) {
+    linkMatches.forEach(match => {
+      matches.push({
+        start: match.index,
+        end: match.lastIndex,
+        title: match.raw,
+        href: match.url
+      });
+    });
+  }
+  return matches;
+}
+export const findFilepaths = (text, offset = 0) => {
+  // Creation of a copy of the RegExp is necessary as lastIndex is stored on it when we run .exec()
+  const localRegExp = new RegExp(FILEPATH_REGEXP);
+  let match;
+  const matchesList = [];
+  const maxFilepathSize = 260;
+  while ((match = localRegExp.exec(text)) !== null) {
+    const start = match.index + offset;
+    let end = localRegExp.lastIndex + offset;
+    if (end - start > maxFilepathSize) {
+      end = start + maxFilepathSize;
+    } // We don't care about big strings of text that are pretending to be filepaths!!
+    matchesList.push({
+      startIndex: start,
+      endIndex: end
+    });
+  }
+  return matchesList;
+};
+export const isLinkInMatches = (linkStart, matchesList) => {
+  for (let i = 0; i < matchesList.length; i++) {
+    if (linkStart >= matchesList[i].startIndex && linkStart < matchesList[i].endIndex) {
+      return true;
+    }
+  }
+  return false;
+};
+export function getLinkCreationAnalyticsEvent(inputMethod, url) {
+  return {
+    action: ACTION.INSERTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId: ACTION_SUBJECT_ID.LINK,
+    attributes: {
+      inputMethod,
+      fromCurrentDomain: isFromCurrentDomain(url)
+    },
+    eventType: EVENT_TYPE.TRACK,
+    nonPrivacySafeAttributes: {
+      linkDomain: getLinkDomain(url)
+    }
+  };
+}

package/dist/es2019/utils/index.js

@@ -3,7 +3,7 @@ export { getExtensionLozengeData } from './macro';
 export { default as browser } from './browser';
 export { default as ErrorReporter } from './error-reporter';
 export { isPastDate, timestampToIsoFormat, timestampToString, timestampToTaskContext, timestampToUTCDate, todayTimestampInUTC } from './date';
-export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition } from './editor-core-utils';
+export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition, isEmptyParagraph } from './editor-core-utils';
 export { withImageLoader } from './imageLoader';
 export { absoluteBreakoutWidth, calcBreakoutWidth, calcWideWidth, breakoutConsts, calculateBreakoutStyles, calcBreakoutWidthPx } from './breakout';
 export { findChangedNodesFromTransaction, validNode, validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent, isMediaNode, isNodeBeforeMediaNode } from './nodes';
@@ -34,5 +34,8 @@ export { getShallowPropsDifference, getPropsDifference } from './compare-props';
 export { useComponentRenderTracking } from './performance/hooks/use-component-render-tracking';
 export { isOutdatedBrowser } from './outdated-browsers';
 export { isReferencedSource, removeConnectedNodes, getChildrenInfo, getNodeName } from './referentiality';
-export { sendLogs } from './sendLogs';
-export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder } from './list';
+export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder, isListNode, isParagraphNode, isListItemNode, isBulletList } from './list';
+export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLinkDomain, findFilepaths, isLinkInMatches, FILEPATH_REGEXP, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent } from './hyperlink';
+
+// prosemirror-history does not export its plugin key
+export const pmHistoryPluginKey = 'history$';

package/dist/es2019/utils/list.js

@@ -27,4 +27,16 @@ export const getItemCounterDigitsSize = options => {
   const itemsCount = typeof options.itemsCount === 'number' ? options.itemsCount : 0;
   const largestCounter = order + (itemsCount - 1);
   return (_String = String(largestCounter)) === null || _String === void 0 ? void 0 : (_String$split = _String.split('.')) === null || _String$split === void 0 ? void 0 : (_String$split$ = _String$split[0]) === null || _String$split$ === void 0 ? void 0 : _String$split$.length;
-};
+};
+export function isListNode(node) {
+  return Boolean(node && node.type && ['orderedList', 'bulletList'].includes(node.type.name));
+}
+export function isParagraphNode(node) {
+  return Boolean(node && node.type && 'paragraph' === node.type.name);
+}
+export function isListItemNode(node) {
+  return Boolean(node && node.type && 'listItem' === node.type.name);
+}
+export function isBulletList(node) {
+  return Boolean(node && node.type && 'bulletList' === node.type.name);
+}

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "74.0.1",
+	"version": "74.1.1",
 	"sideEffects": false
 }

package/dist/esm/event-dispatcher/index.js

@@ -50,6 +50,9 @@ export var EventDispatcher = /*#__PURE__*/function () {
   }]);
   return EventDispatcher;
 }();
+function getEventFromEventName(eventName) {
+  return typeof eventName === 'string' ? eventName : eventName.key;
+}
 
 /**
  * Creates a dispatch function that can be called inside ProseMirror Plugin
@@ -60,7 +63,6 @@ export function createDispatch(eventDispatcher) {
     if (!eventName) {
       throw new Error('event name is required!');
     }
-    var event = typeof eventName === 'string' ? eventName : eventName.key;
-    eventDispatcher.emit(event, data);
+    eventDispatcher.emit(getEventFromEventName(eventName), data);
   };
 }

package/dist/esm/insert/index.js

@@ -0,0 +1,262 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { Fragment, Node, Slice } from 'prosemirror-model';
+import { NodeSelection, Selection, TextSelection } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+import { canInsert, findParentNodeOfType, hasParentNodeOfType, isNodeSelection, safeInsert as pmSafeInsert } from 'prosemirror-utils';
+import { GapCursorSelection, Side } from '../selection';
+import { isEmptyParagraph, isListItemNode } from '../utils';
+export var LookDirection = /*#__PURE__*/function (LookDirection) {
+  LookDirection["Before"] = "before";
+  LookDirection["After"] = "after";
+  return LookDirection;
+}({});
+export var normaliseNestedLayout = function normaliseNestedLayout(_ref, node) {
+  var selection = _ref.selection,
+    doc = _ref.doc;
+  if (selection.$from.depth > 1) {
+    if (node.attrs.layout && node.attrs.layout !== 'default') {
+      return node.type.createChecked(_objectSpread(_objectSpread({}, node.attrs), {}, {
+        layout: 'default'
+      }), node.content, node.marks);
+    }
+
+    // If its a breakout layout, we can remove the mark
+    // Since default isn't a valid breakout mode.
+    var breakoutMark = doc.type.schema.marks.breakout;
+    if (breakoutMark && breakoutMark.isInSet(node.marks)) {
+      var newMarks = breakoutMark.removeFromSet(node.marks);
+      return node.type.createChecked(node.attrs, node.content, newMarks);
+    }
+  }
+  return node;
+};
+var isLastChild = function isLastChild($pos, doc) {
+  return doc.resolve($pos.after()).node().lastChild === $pos.node();
+};
+var isFirstChild = function isFirstChild($pos, doc) {
+  return doc.resolve($pos.before()).node().firstChild === $pos.node();
+};
+var nodeIsInsideAList = function nodeIsInsideAList(tr) {
+  var nodes = tr.doc.type.schema.nodes;
+  return hasParentNodeOfType([nodes.orderedList, nodes.bulletList])(tr.selection);
+};
+var selectionIsInsideAPanel = function selectionIsInsideAPanel(tr) {
+  var nodes = tr.doc.type.schema.nodes;
+  return hasParentNodeOfType(nodes.panel)(tr.selection);
+};
+var selectionIsInNestedList = function selectionIsInNestedList(tr) {
+  var nodes = tr.doc.type.schema.nodes;
+  var parentListNode = findParentNodeOfType([nodes.orderedList, nodes.bulletList])(tr.selection);
+  if (!parentListNode) {
+    return false;
+  }
+  return isListItemNode(tr.doc.resolve(parentListNode.pos).parent);
+};
+var insertBeforeOrAfter = function insertBeforeOrAfter(tr, lookDirection, $parentPos, $proposedPosition, content) {
+  /**
+   * This block caters for the first item in a parent with the cursor being at the very start
+   * or the last item with the cursor being at the very end
+   *
+   * e.g.
+   * ul
+   *  li {<>}Scenario one
+   *  li
+   *  li Scenario two{<>}
+   */
+
+  if (isFirstChild($proposedPosition, tr.doc) && lookDirection === LookDirection.Before || isLastChild($proposedPosition, tr.doc) && lookDirection === LookDirection.After) {
+    return tr.insert($parentPos[lookDirection](), content);
+  }
+  return tr.insert($proposedPosition[lookDirection](), content);
+};
+
+// FIXME: A more sustainable and configurable way to choose when to split
+var shouldSplit = function shouldSplit(nodeType, schemaNodes) {
+  return [schemaNodes.bulletList, schemaNodes.orderedList, schemaNodes.panel].includes(nodeType);
+};
+export var safeInsert = function safeInsert(content, position) {
+  return function (tr) {
+    var _tr$selection$$from$n;
+    var nodes = tr.doc.type.schema.nodes;
+    var whitelist = [nodes.rule, nodes.mediaSingle];
+    if (content instanceof Fragment || !whitelist.includes(content.type)) {
+      return null;
+    }
+
+    // Check for selection
+    if (!tr.selection.empty || isNodeSelection(tr.selection)) {
+      // NOT IMPLEMENTED
+      return null;
+    }
+    var $from = tr.selection.$from;
+    var $insertPos = position ? tr.doc.resolve(position) : isNodeSelection(tr.selection) ? tr.doc.resolve($from.pos + 1) : $from;
+    var lookDirection;
+    var insertPosEnd = $insertPos.end();
+    var insertPosStart = $insertPos.start();
+
+    // When parent node is an empty paragraph,
+    // check the empty paragraph is the first or last node of its parent.
+    if (isEmptyParagraph($insertPos.parent)) {
+      if (isLastChild($insertPos, tr.doc)) {
+        lookDirection = LookDirection.After;
+      } else if (isFirstChild($insertPos, tr.doc)) {
+        lookDirection = LookDirection.Before;
+      }
+    } else {
+      if ($insertPos.pos === insertPosEnd) {
+        lookDirection = LookDirection.After;
+      } else if ($insertPos.pos === insertPosStart) {
+        lookDirection = LookDirection.Before;
+      }
+    }
+    var grandParentNodeType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
+    var parentNodeType = tr.selection.$from.parent.type;
+
+    // if there is no direction, and cannot split for this particular node
+    var noDirectionAndShouldNotSplit = !lookDirection && !shouldSplitSelectedNodeOnNodeInsertion({
+      parentNodeType: parentNodeType,
+      grandParentNodeType: grandParentNodeType,
+      content: content
+    });
+    var ruleNodeInANestedListNode = content.type === nodes.rule && selectionIsInNestedList(tr);
+    var nonRuleNodeInListNode = !(content.type === nodes.rule) && nodeIsInsideAList(tr);
+    if (ruleNodeInANestedListNode || noDirectionAndShouldNotSplit && nonRuleNodeInListNode || noDirectionAndShouldNotSplit && !nodeIsInsideAList(tr)) {
+      // node to be inserted is an invalid child of selection so insert below selected node
+      return pmSafeInsert(content, tr.selection.from)(tr);
+    }
+
+    // if node is a rule and that is a flat list splitting and not at the end of a list
+    var _tr$selection = tr.selection,
+      from = _tr$selection.from,
+      to = _tr$selection.to;
+    var ruleTypeInAList = content.type === nodes.rule && nodeIsInsideAList(tr);
+    if (ruleTypeInAList && !($insertPos.pos === insertPosEnd)) {
+      return tr.replaceRange(from, to, new Slice(Fragment.from(nodes.rule.createChecked()), 0, 0));
+    }
+    if (!lookDirection) {
+      // fallback to consumer for now
+      return null;
+    }
+
+    // Replace empty paragraph
+    if (isEmptyParagraph($insertPos.parent) && canInsert(tr.doc.resolve($insertPos[lookDirection]()), content)) {
+      return finaliseInsert(tr.replaceWith($insertPos.before(), $insertPos.after(), content), -1);
+    }
+    var $proposedPosition = $insertPos;
+    while ($proposedPosition.depth > 0) {
+      var $parentPos = tr.doc.resolve($proposedPosition[lookDirection]());
+      var parentNode = $parentPos.node();
+
+      // Insert at position (before or after target pos)
+      if (canInsert($proposedPosition, content)) {
+        return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
+      }
+
+      // If we can't insert, and we think we should split, we fallback to consumer for now
+      if (shouldSplit(parentNode.type, tr.doc.type.schema.nodes)) {
+        var nextTr = finaliseInsert(insertBeforeOrAfter(tr, lookDirection, $parentPos, $proposedPosition, content), content.nodeSize);
+
+        // Move selection to the closest text node, otherwise it defaults to the whatever the lookDirection is set to above
+        if ([nodes.orderedList, nodes.bulletList].includes(parentNode.type) && nextTr) {
+          return nextTr.setSelection(TextSelection.between(nextTr.selection.$from, nextTr.selection.$from));
+        } else {
+          return nextTr;
+        }
+      }
+
+      // Can not insert into current parent, step up one parent
+      $proposedPosition = $parentPos;
+    }
+    return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
+  };
+};
+var finaliseInsert = function finaliseInsert(tr, nodeLength) {
+  var lastStep = tr.steps[tr.steps.length - 1];
+  if (!(lastStep instanceof ReplaceStep || lastStep instanceof ReplaceAroundStep)) {
+    return null;
+  }
+
+  // Place gap cursor after the newly inserted node
+  var gapCursorPos = lastStep.to + lastStep.slice.openStart + nodeLength;
+  return tr.setSelection(new GapCursorSelection(tr.doc.resolve(gapCursorPos), Side.RIGHT)).scrollIntoView();
+};
+
+/**
+ * Method extracted from typeahed plugin to be shared with the element browser on handling element insertion.
+ */
+export var insertSelectedItem = function insertSelectedItem(maybeNode) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return function (state, tr, start) {
+    if (!maybeNode) {
+      return tr;
+    }
+    var isInputFragment = maybeNode instanceof Fragment;
+    var node;
+    try {
+      node = maybeNode instanceof Node || isInputFragment ? maybeNode : typeof maybeNode === 'string' ? state.schema.text(maybeNode) : Node.fromJSON(state.schema, maybeNode);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e);
+      return tr;
+    }
+    if (node.isText) {
+      tr = tr.replaceWith(start, start, node);
+
+      /**
+       *
+       * Replacing a type ahead query mark with a block node.
+       *
+       */
+    } else if (node.isBlock) {
+      /**
+       *
+       * Rule has unique insertion behaviour
+       * so using this safeInsert function in order to handle specific cases in flat list vs nested list
+       * instead of a generic pmSafeInsert (i.e appending at the end)
+       *
+       */
+
+      var selectionInsideAPanel = selectionIsInsideAPanel(tr);
+      if (node.type.name === 'rule' && !selectionInsideAPanel) {
+        var _safeInsert;
+        tr = (_safeInsert = safeInsert(node, tr.selection.from)(tr)) !== null && _safeInsert !== void 0 ? _safeInsert : tr;
+      } else {
+        tr = pmSafeInsert(normaliseNestedLayout(state, node), undefined, true)(tr);
+      }
+
+      /**
+       *
+       * Replacing a type ahead query mark with an inline node.
+       *
+       */
+    } else if (node.isInline || isInputFragment) {
+      var fragment = isInputFragment ? node : Fragment.fromArray([node, state.schema.text(' ')]);
+      tr = tr.replaceWith(start, start, fragment);
+      if (opts.selectInlineNode) {
+        // Select inserted node
+        tr = tr.setSelection(NodeSelection.create(tr.doc, start));
+      } else {
+        // Placing cursor after node + space.
+        tr = tr.setSelection(Selection.near(tr.doc.resolve(start + fragment.size)));
+      }
+    }
+    return tr;
+  };
+};
+
+/**
+ * ED-14584: Util to check if the destination node is a paragraph & the
+ * content being inserted is a valid child of the grandparent node.
+ * In this case, the destination node should split
+ */
+export var shouldSplitSelectedNodeOnNodeInsertion = function shouldSplitSelectedNodeOnNodeInsertion(_ref2) {
+  var parentNodeType = _ref2.parentNodeType,
+    grandParentNodeType = _ref2.grandParentNodeType,
+    content = _ref2.content;
+  if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
+    return true;
+  }
+  return false;
+};