@atlaskit/editor-common 74.0.1 → 74.1.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @atlaskit/editor-common
 
+## 74.1.0
+
+### Minor Changes
+
+- [`6bc52e5a406`](https://bitbucket.org/atlassian/atlassian-frontend/commits/6bc52e5a406) - [ED-17687] Capture errors caught in error boundaries in Sentry
+- [`8a391616ecc`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8a391616ecc) - Moving insert node API to a new editor plugin to allow it to be more extensible. Also exposing a new editor plugin action for tables to allow for consistent insertion.
+- [`5cc449dac8d`](https://bitbucket.org/atlassian/atlassian-frontend/commits/5cc449dac8d) - Decouple card plugin so that it uses new NextEditorPlugin for any injected dependencies.
+- [`be561d3491c`](https://bitbucket.org/atlassian/atlassian-frontend/commits/be561d3491c) - [ED-17622] Adds new Resizer component
+
+### Patch Changes
+
+- [`9220da2225b`](https://bitbucket.org/atlassian/atlassian-frontend/commits/9220da2225b) - ED-16320: Add checks to certain SLO related events to see if they are explicitly disabled, in preparation for disabling them for synthetic tenants in prod
+- [`b804d3ad561`](https://bitbucket.org/atlassian/atlassian-frontend/commits/b804d3ad561) - Remove unused code related to GASv2 table analytics from editor-plugin table, editor-core and editor-common
+- [`e20cca743c4`](https://bitbucket.org/atlassian/atlassian-frontend/commits/e20cca743c4) - Moving editor analytics plugin to new package.
+- [`f621ae6490a`](https://bitbucket.org/atlassian/atlassian-frontend/commits/f621ae6490a) - Adding type dependency on analytics plugin to tables plugin.
+- [`a142ba1aa28`](https://bitbucket.org/atlassian/atlassian-frontend/commits/a142ba1aa28) - [ED17172] Bump prosemirror-model to 1.16.0 and prosemirror-view to 1.23.7 and removed work-arounds for fixed issues
+- [`9369cc38a68`](https://bitbucket.org/atlassian/atlassian-frontend/commits/9369cc38a68) - Migrated use of `gridSize` to space tokens where possible. There is no expected visual or behaviour change.
+- Updated dependencies
+
 ## 74.0.1
 
 ### Patch Changes

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

@@ -58,17 +58,20 @@ var EventDispatcher = /*#__PURE__*/function () {
   }]);
   return EventDispatcher;
 }();
+exports.EventDispatcher = EventDispatcher;
+function getEventFromEventName(eventName) {
+  return typeof eventName === 'string' ? eventName : eventName.key;
+}
+
 /**
  * Creates a dispatch function that can be called inside ProseMirror Plugin
  * to notify listeners about that plugin's state change.
  */
-exports.EventDispatcher = EventDispatcher;
 function createDispatch(eventDispatcher) {
   return function (eventName, data) {
     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/cjs/insert/index.js

@@ -0,0 +1,274 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldSplitSelectedNodeOnNodeInsertion = exports.safeInsert = exports.normaliseNestedLayout = exports.insertSelectedItem = exports.LookDirection = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _prosemirrorModel = require("prosemirror-model");
+var _prosemirrorState = require("prosemirror-state");
+var _prosemirrorTransform = require("prosemirror-transform");
+var _prosemirrorUtils = require("prosemirror-utils");
+var _selection = require("../selection");
+var _utils = require("../utils");
+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) { (0, _defineProperty2.default)(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; }
+var LookDirection = /*#__PURE__*/function (LookDirection) {
+  LookDirection["Before"] = "before";
+  LookDirection["After"] = "after";
+  return LookDirection;
+}({});
+exports.LookDirection = LookDirection;
+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;
+};
+exports.normaliseNestedLayout = normaliseNestedLayout;
+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 (0, _prosemirrorUtils.hasParentNodeOfType)([nodes.orderedList, nodes.bulletList])(tr.selection);
+};
+var selectionIsInsideAPanel = function selectionIsInsideAPanel(tr) {
+  var nodes = tr.doc.type.schema.nodes;
+  return (0, _prosemirrorUtils.hasParentNodeOfType)(nodes.panel)(tr.selection);
+};
+var selectionIsInNestedList = function selectionIsInNestedList(tr) {
+  var nodes = tr.doc.type.schema.nodes;
+  var parentListNode = (0, _prosemirrorUtils.findParentNodeOfType)([nodes.orderedList, nodes.bulletList])(tr.selection);
+  if (!parentListNode) {
+    return false;
+  }
+  return (0, _utils.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);
+};
+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 _prosemirrorModel.Fragment || !whitelist.includes(content.type)) {
+      return null;
+    }
+
+    // Check for selection
+    if (!tr.selection.empty || (0, _prosemirrorUtils.isNodeSelection)(tr.selection)) {
+      // NOT IMPLEMENTED
+      return null;
+    }
+    var $from = tr.selection.$from;
+    var $insertPos = position ? tr.doc.resolve(position) : (0, _prosemirrorUtils.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 ((0, _utils.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 (0, _prosemirrorUtils.safeInsert)(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 _prosemirrorModel.Slice(_prosemirrorModel.Fragment.from(nodes.rule.createChecked()), 0, 0));
+    }
+    if (!lookDirection) {
+      // fallback to consumer for now
+      return null;
+    }
+
+    // Replace empty paragraph
+    if ((0, _utils.isEmptyParagraph)($insertPos.parent) && (0, _prosemirrorUtils.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 ((0, _prosemirrorUtils.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(_prosemirrorState.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);
+  };
+};
+exports.safeInsert = safeInsert;
+var finaliseInsert = function finaliseInsert(tr, nodeLength) {
+  var lastStep = tr.steps[tr.steps.length - 1];
+  if (!(lastStep instanceof _prosemirrorTransform.ReplaceStep || lastStep instanceof _prosemirrorTransform.ReplaceAroundStep)) {
+    return null;
+  }
+
+  // Place gap cursor after the newly inserted node
+  var gapCursorPos = lastStep.to + lastStep.slice.openStart + nodeLength;
+  return tr.setSelection(new _selection.GapCursorSelection(tr.doc.resolve(gapCursorPos), _selection.Side.RIGHT)).scrollIntoView();
+};
+
+/**
+ * Method extracted from typeahed plugin to be shared with the element browser on handling element insertion.
+ */
+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 _prosemirrorModel.Fragment;
+    var node;
+    try {
+      node = maybeNode instanceof _prosemirrorModel.Node || isInputFragment ? maybeNode : typeof maybeNode === 'string' ? state.schema.text(maybeNode) : _prosemirrorModel.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 = (0, _prosemirrorUtils.safeInsert)(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 : _prosemirrorModel.Fragment.fromArray([node, state.schema.text(' ')]);
+      tr = tr.replaceWith(start, start, fragment);
+      if (opts.selectInlineNode) {
+        // Select inserted node
+        tr = tr.setSelection(_prosemirrorState.NodeSelection.create(tr.doc, start));
+      } else {
+        // Placing cursor after node + space.
+        tr = tr.setSelection(_prosemirrorState.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
+ */
+exports.insertSelectedItem = insertSelectedItem;
+var shouldSplitSelectedNodeOnNodeInsertion = function shouldSplitSelectedNodeOnNodeInsertion(_ref2) {
+  var parentNodeType = _ref2.parentNodeType,
+    grandParentNodeType = _ref2.grandParentNodeType,
+    content = _ref2.content;
+  if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(_prosemirrorModel.Fragment.from(content))) {
+    return true;
+  }
+  return false;
+};
+exports.shouldSplitSelectedNodeOnNodeInsertion = shouldSplitSelectedNodeOnNodeInsertion;

package/dist/cjs/monitoring/error.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logException = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+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) { (0, _defineProperty2.default)(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; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
+var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
+var packageVersion = "74.1.0";
+var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
+  // Remove URL as it has UGC
+  // TODO: Sanitise the URL instead of just removing it
+  if (data.request) {
+    delete data.request.url;
+  }
+  return data;
+};
+var logException = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(error, tags) {
+    var _process$env$CLOUD_EN, _yield$import, BrowserClient, defaultIntegrations, getCurrentHub, _yield$import2, ExtraErrorData, sentryOptions, client, hub;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          if (!(process.env.NODE_ENV !== 'production' || process.env.CLOUD_ENV === 'branch')) {
+            _context.next = 3;
+            break;
+          }
+          return _context.abrupt("return");
+        case 3:
+          _context.next = 5;
+          return Promise.resolve().then(function () {
+            return _interopRequireWildcard(require( /* webpackChunkName: "@atlaskit-internal_editor-sentrybrowser" */'@sentry/browser'));
+          });
+        case 5:
+          _yield$import = _context.sent;
+          BrowserClient = _yield$import.BrowserClient;
+          defaultIntegrations = _yield$import.defaultIntegrations;
+          getCurrentHub = _yield$import.getCurrentHub;
+          _context.next = 11;
+          return Promise.resolve().then(function () {
+            return _interopRequireWildcard(require( /* webpackChunkName: "@atlaskit-internal_editor-sentryintegrations" */'@sentry/integrations'));
+          });
+        case 11:
+          _yield$import2 = _context.sent;
+          ExtraErrorData = _yield$import2.ExtraErrorData;
+          sentryOptions = {
+            dsn: SENTRY_DSN,
+            release: "".concat(packageName, "@").concat(packageVersion),
+            environment: (_process$env$CLOUD_EN = process.env.CLOUD_ENV) !== null && _process$env$CLOUD_EN !== void 0 ? _process$env$CLOUD_EN : 'unknown',
+            ignoreErrors: [
+            // Network issues
+            /^network error/i, /^network failure/i, 'TypeError: Failed to fetch',
+            // A benign error, see https://stackoverflow.com/a/50387233/2645305
+            'ResizeObserver loop limit exceeded', /ResizeObserver loop completed with undelivered notifications/],
+            autoSessionTracking: false,
+            integrations: function integrations(_integrations) {
+              return [].concat((0, _toConsumableArray2.default)(defaultIntegrations.filter(function (_ref2) {
+                var name = _ref2.name;
+                return name !== 'Breadcrumbs';
+              })), [
+              // Extracts all non-native attributes from the error object and attaches them to the event as the extra data
+              // https://docs.sentry.io/platforms/javascript/configuration/integrations/plugin/?original_referrer=https%3A%2F%2Fduckduckgo.com%2F#extraerrordata
+              new ExtraErrorData()]);
+            },
+            beforeSend: sanitiseSentryEvents
+          }; // Use a client to avoid picking up the errors from parent applications
+          client = new BrowserClient(sentryOptions);
+          hub = getCurrentHub();
+          hub.bindClient(client);
+          hub.withScope(function (scope) {
+            scope.setTags(_objectSpread({
+              // Jira environment variables
+              'jira-bundler': window.BUNDLER_VERSION,
+              'jira-variant': window.BUILD_VARIANT,
+              'jira-release': window.BUILD_KEY,
+              // Confluence environment variables
+              'confluence-frontend-version': window.__buildInfo.FRONTEND_VERSION
+            }, tags));
+            hub.captureException(error);
+          });
+          return _context.abrupt("return", client.close());
+        case 21:
+          _context.prev = 21;
+          _context.t0 = _context["catch"](0);
+        case 23:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 21]]);
+  }));
+  return function logException(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+exports.logException = logException;

package/dist/cjs/monitoring/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "logException", {
+  enumerable: true,
+  get: function get() {
+    return _error.logException;
+  }
+});
+var _error = require("./error");

package/dist/cjs/node-width/index.js

@@ -10,6 +10,8 @@ var _constants = require("@atlaskit/theme/constants");
 var _extension = require("../styles/shared/extension");
 var _layout = require("../styles/shared/layout");
 var _breakout = require("../utils/breakout");
+// eslint-disable-next-line @atlaskit/design-system/no-deprecated-imports
+
 /**
  * Calculates width of parent node of a nested node (inside layouts, extension)
  * If current node selection is not nested will return undefined
@@ -52,6 +54,9 @@ var getParentNodeWidth = function getParentNodeWidth(pos, state, containerWidth,
     case schema.nodes.bodiedExtension:
       parentWidth -= _extension.BODIED_EXT_PADDING * 2;
       break;
+
+    // TODO: Migrate away from gridSize
+    // Recommendation: Replace gridSize with 8
     case schema.nodes.expand:
       // padding
       parentWidth -= (0, _constants.gridSize)() * 2;

package/dist/cjs/paste/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "md", {
+  enumerable: true,
+  get: function get() {
+    return _md.md;
+  }
+});
+var _md = require("./md");

package/dist/cjs/paste/md-plugins/ignore-list-heading-md-plugin.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+/*
+ * ED-15646
+ * Headings in list items are not supported in our schema.
+ * As the markdown transformer is used by the paste plugin,
+ * certain pastes will strip invalid lines as
+ * prosemirror-markdown cannot conform to the schema
+ */
+
+function handleHeadingOpen(state, token, acc, index) {
+  var _state$tokens;
+  var isInListItem = ((_state$tokens = state.tokens[index - 1]) === null || _state$tokens === void 0 ? void 0 : _state$tokens.type) === 'list_item_open';
+  if (isInListItem) {
+    acc.push(new state.Token('paragraph_open', 'p', 1));
+  } else {
+    acc.push(token);
+  }
+}
+function handleHeadingClose(state, token, acc, index) {
+  var _state$tokens2;
+  var isInListItem = ((_state$tokens2 = state.tokens[index + 1]) === null || _state$tokens2 === void 0 ? void 0 : _state$tokens2.type) === 'list_item_close';
+  if (isInListItem) {
+    acc.push(new state.Token('paragraph_close', 'p', -1));
+  } else {
+    acc.push(token);
+  }
+}
+function _default(md) {
+  md.core.ruler.after('inline', 'ignore-list-heading-md-plugin', function (state) {
+    state.tokens = state.tokens.reduce(function (acc, token, index) {
+      var type = token.type;
+      if (type === 'heading_open') {
+        handleHeadingOpen(state, token, acc, index);
+      } else if (type === 'heading_close') {
+        handleHeadingClose(state, token, acc, index);
+      } else {
+        acc.push(token);
+      }
+      return acc;
+    }, []);
+  });
+}

package/dist/cjs/paste/md-plugins/linkify-md-plugin.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _linkifyIt = _interopRequireDefault(require("linkify-it"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _utils = require("../../utils");
+// File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/md/linkify-md-plugin.ts
+// If changes are made to this file, please make the same update in the linked file.
+
+// modified version of the original Linkify plugin
+// https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js
+var arrayReplaceAt = function arrayReplaceAt(src, pos, newElements) {
+  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
+};
+var isLinkOpen = function isLinkOpen(str) {
+  return /^<a[>\s]/i.test(str);
+};
+var isLinkClose = function isLinkClose(str) {
+  return /^<\/a\s*>/i.test(str);
+};
+var linkify = function linkify(state) {
+  var blockTokens = state.tokens;
+  var linkify = new _linkifyIt.default();
+  for (var j = 0, l = blockTokens.length; j < l; j++) {
+    if (blockTokens[j].type !== 'inline' || !linkify.pretest(blockTokens[j].content)) {
+      continue;
+    }
+    var tokens = blockTokens[j].children;
+    var htmlLinkLevel = 0;
+
+    // We scan from the end, to keep position when new tags added.
+    // Use reversed logic in links start/end match
+    for (var i = tokens.length - 1; i >= 0; i--) {
+      var currentToken = tokens[i];
+
+      // Skip content of markdown links
+      if (currentToken.type === 'link_close') {
+        i--;
+        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
+          i--;
+        }
+        continue;
+      }
+
+      // Skip content of html tag links
+      if (currentToken.type === 'html_inline') {
+        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
+          htmlLinkLevel--;
+        }
+        if (isLinkClose(currentToken.content)) {
+          htmlLinkLevel++;
+        }
+      }
+      if (htmlLinkLevel > 0) {
+        continue;
+      }
+      if (currentToken.type === 'text' && linkify.test(currentToken.content)) {
+        var text = currentToken.content;
+        var links = (0, _adfSchema.linkifyMatch)(text);
+        if (!links.length) {
+          links = linkify.match(text) || [];
+        }
+
+        // Now split string to nodes
+        var nodes = [];
+        var level = currentToken.level;
+        var lastPos = 0;
+        var filepaths = (0, _utils.findFilepaths)(text);
+        for (var ln = 0; ln < links.length; ln++) {
+          if ((0, _utils.isLinkInMatches)(links[ln].index, filepaths)) {
+            continue;
+          }
+          var url = links[ln].url;
+          var fullUrl = state.md.normalizeLink(url);
+          if (!state.md.validateLink(fullUrl)) {
+            continue;
+          }
+          var urlText = links[ln].text;
+
+          // Linkifier might send raw hostnames like "example.com", where url
+          // starts with domain name. So we prepend http:// in those cases,
+          // and remove it afterwards.
+          //
+          if (!links[ln].schema) {
+            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '');
+          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
+            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');
+          } else {
+            urlText = state.md.normalizeLinkText(urlText);
+          }
+          var pos = links[ln].index;
+          if (pos > lastPos) {
+            var _token = new state.Token('text', '', 0);
+            _token.content = text.slice(lastPos, pos);
+            _token.level = level;
+            nodes.push(_token);
+          }
+          var token = new state.Token('link_open', 'a', 1);
+          token.attrs = [['href', fullUrl]];
+          token.level = level++;
+          token.markup = 'linkify';
+          token.info = 'auto';
+          nodes.push(token);
+          token = new state.Token('text', '', 0);
+          token.content = urlText;
+          token.level = level;
+          nodes.push(token);
+          token = new state.Token('link_close', 'a', -1);
+          token.level = --level;
+          token.markup = 'linkify';
+          token.info = 'auto';
+          nodes.push(token);
+          lastPos = links[ln].lastIndex;
+        }
+        if (lastPos < text.length) {
+          var _token2 = new state.Token('text', '', 0);
+          _token2.content = text.slice(lastPos);
+          _token2.level = level;
+          nodes.push(_token2);
+        }
+
+        // replace current node
+        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
+      }
+    }
+  }
+};
+var _default = function _default(md) {
+  return md.core.ruler.push('custom-linkify', linkify);
+};
+exports.default = _default;