@atlaskit/editor-common 115.5.1 → 115.6.0

package/dist/esm/preset/plugin-injection-api.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _typeof from "@babel/runtime/helpers/typeof";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
@@ -126,6 +126,9 @@ var notifyListenersThrottled = throttle(function (_ref3) {
     cb();
   });
 }, THROTTLE_CALLS_FOR_MILLISECONDS);
+export var PluginsData = /*#__PURE__*/_createClass(function PluginsData() {
+  _classCallCheck(this, PluginsData);
+});
 var ActionsAPI = /*#__PURE__*/function () {
   function ActionsAPI() {
     _classCallCheck(this, ActionsAPI);
@@ -440,6 +443,4 @@ export var EditorPluginInjectionAPI = /*#__PURE__*/function () {
       return editorAPICache.get(this);
     }
   }]);
-}();
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { PluginsData } from './PluginsData';
+}();

package/dist/esm/provider-helpers/combine-providers.js

@@ -1,8 +1,7 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { getOnlyFulfilled, waitForAllPromises } from './promise-helpers';
-import { waitForFirstFulfilledPromise } from './waitForFirstFulfilledPromise';
+import { getOnlyFulfilled, waitForAllPromises, waitForFirstFulfilledPromise } from './promise-helpers';
 var flatten = function flatten(arr) {
   var _ref;
   return (_ref = []).concat.apply(_ref, _toConsumableArray(arr));

package/dist/esm/provider-helpers/promise-helpers.js

@@ -1,4 +1,8 @@
-import { ResultStatus } from './ResultStatus';
+export var ResultStatus = /*#__PURE__*/function (ResultStatus) {
+  ResultStatus["FULFILLED"] = "fulfilled";
+  ResultStatus["FAILED"] = "failed";
+  return ResultStatus;
+}({});
 var isFullfilled = function isFullfilled(result) {
   return result.status === ResultStatus.FULFILLED;
 };
@@ -31,6 +35,30 @@ export var waitForAllPromises = function waitForAllPromises(promises) {
   }));
 };
 
+/**
+ * Will resolve on the first fulfilled promise and disregard the remaining ones. Similar to `Promise.race` but won't
+ * care about rejected promises.
+ * @param promises
+ */
+export var waitForFirstFulfilledPromise = function waitForFirstFulfilledPromise(promises) {
+  var rejectReasons = [];
+  return new Promise(function (resolve, reject) {
+    promises.forEach(function (promise) {
+      return promise.then(function (value) {
+        if (typeof value === 'undefined' || value === null) {
+          throw new Error("Result was not found but the method didn't reject/throw. Please ensure that it doesn't return null or undefined.");
+        }
+        resolve(value);
+      }).catch(function (reason) {
+        rejectReasons.push(reason);
+        if (rejectReasons.length === promises.length) {
+          reject(reason);
+        }
+      });
+    });
+  });
+};
+
 /**
  * Find all fullfilled promises and return their values
  * @param results
@@ -39,6 +67,4 @@ export var getOnlyFulfilled = function getOnlyFulfilled(results) {
   return results.filter(isFullfilled).map(function (result) {
     return result.value;
   });
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-// eslint-disable-next-line @atlaskit/editor/no-re-export
+};

package/dist/esm/rank.js

@@ -1,4 +1,33 @@
-import { rankEditorPlugins } from './rankEditorPlugins';
+// eslint-disable-next-line @repo/internal/deprecations/deprecation-ticket-required -- Ignored via go/ED-25883
+// @deprecated
+// @private This rank is not stable and should not be trusted. If you need to change this file, please let the Editor lego team know about it
+export var rankEditorPlugins = {
+  plugins: ['featureFlagsContextPlugin', 'compositionPlugin', 'inlineCursorTargetPlugin', 'typeAhead', 'typeAheadInsertItem', 'focusHandlerPlugin', 'frozenEditor', 'submitEditor', 'saveOnEnter', 'customAutoformatting', 'newlinePreserveMarksPlugin', 'imageUpload', 'imageUploadInputRule', 'clipboard', 'paste', 'pasteKeymap', 'mention', 'mentionInputRule', 'mentionKeymap', 'emoji', 'placeholderText', 'emojiInputRule', 'emojiKeymap', 'emojiAsciiInputRule', 'blockType', 'quickInsert', 'tasksAndDecisions', 'blockTypeInputRule', 'tasksAndDecisionsInputRule', 'list', 'typeAheadKeymap', 'typeAheadInputRule', 'date',
+  // Needs to be before indentation to handle tab into input field
+  'dateKeymap',
+  // This should be always after `typeAheadKeymap` & `emojiKeymap`
+  'indentationKeymap', 'textColor', 'highlight', 'highlightKeymap', 'alignmentPlugin', 'listInputRule', 'listKeymap', 'codeBlock', 'codeBlockIDEKeyBindings', 'codeBlockKeyMap', 'textFormatting', 'textFormattingCursor', 'textFormattingInputRule', 'textFormattingSmartRule', 'textFormattingClear', 'textFormattingKeymap',
+  // task/decisions keymap needs to be above table keymap so can indent actions in a table
+  'tasksAndDecisionsKeyMap',
+  // expand and table keymaps need to be above selection keymap to add their custom selection behaviour:
+  // https://product-fabric.atlassian.net/wiki/spaces/E/pages/1113098008/Selection+Guide#Special-Cases
+  'expandKeymap', 'tableSelectionKeymap', 'tableKeymap', 'captionKeymap',
+  // media keymap above selection keymap to allow navigating past the mediaSingle node
+  'mediaKeymap',
+  // selection keymap needs to be above gap cursor keymap so it can set node selections from
+  // left/right arrows
+  'selectionKeymap', 'gapCursorKeymap', 'gapCursor', 'syncUrlText', 'fakeCursorToolbarPlugin', 'hyperLink', 'table', 'tableDecorations', 'hyperlinkInputRule', 'tablePMColResizing', 'hyperlinkKeymap', 'tableColResizing', 'undoRedoKeyMap', 'blockTypeKeyMap', 'tableEditing', 'filterStepsPlugin', 'pmCollab', 'collab', 'ruleInputRule', 'ruleKeymap', 'panel', 'media', 'mediaSingleKeymap', 'mediaEditor', 'unsupportedContent', 'jiraIssue', 'helpDialog', 'helpDialogKeymap', 'macro', 'expand', 'extension', 'layout', 'contextPanel', 'selectionToolbar', 'floatingToolbar', 'clearMarksOnChange', 'reactNodeView', 'history', 'undoRedoPlugin', 'codeBlockIndent', 'placeholder', 'width', 'maxContentSize', 'multilineContent', 'grid', 'mobileDimensions', 'scrollGutterPlugin', 'analytics', 'findReplace', 'selection', 'avatarGroup', 'viewUpdateSubscription', 'beforePrimaryToolbar', 'inlineCode'],
+  nodes: ['doc', 'paragraph', 'text', 'bulletList', 'orderedList', 'listItem', 'heading', 'blockquote', 'codeBlock', 'rule', 'panel', 'panel_c1', 'mention', 'confluenceUnsupportedBlock', 'confluenceUnsupportedInline', 'unsupportedBlock', 'unsupportedInline', 'confluenceJiraIssue', 'hardBreak', 'emoji', 'placeholder', 'mediaSingle', 'mediaGroup', 'table', 'expand', 'nestedExpand', 'media', 'tableHeader', 'decisionList', 'tableRow', 'decisionItem', 'tableCell', 'taskList', 'taskItem', 'extension', 'bodiedExtension', 'multiBodiedExtension', 'inlineExtension', 'layoutSection', 'layoutColumn', 'inlineCard', 'blockCard', 'embedCard'],
+  marks: [
+  // Fragment mark is both for inline and block elements
+  'fragment',
+  // Inline marks
+  'link', 'em', 'strong', 'textColor', 'backgroundColor', 'strike', 'subsup', 'underline', 'code', 'typeAheadQuery',
+  // Block marks
+  'alignment', 'breakout', 'indentation', 'annotation', 'dataConsumer', 'border',
+  // Unsupported mark
+  'unsupportedMark', 'unsupportedNodeAttribute']
+};
 
 // eslint-disable-next-line @repo/internal/deprecations/deprecation-ticket-required -- Ignored via go/ED-25883
 // @deprecated
@@ -21,6 +50,4 @@ export function sortByOrderWithTypeName(item) {
   return function (a, b) {
     return rankEditorPlugins[item].indexOf(a.type.name) - rankEditorPlugins[item].indexOf(b.type.name);
   };
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { rankEditorPlugins } from './rankEditorPlugins';
+}

package/dist/esm/react-node-view/NodeViewContentHole.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/extends";
 import React, { forwardRef } from 'react';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { isSSR } from '../core-utils/is-ssr';
+import { isSSRStreaming } from '../core-utils/is-ssr-streaming';
 
 /**
  * A component that serves as a placeholder for the content DOM of a ProseMirror NodeView.
@@ -10,6 +10,6 @@ import { isSSR } from '../core-utils/is-ssr';
 export var NodeViewContentHole = /*#__PURE__*/forwardRef(function (props, ref) {
   return /*#__PURE__*/React.createElement("div", _extends({}, props, {
     ref: ref,
-    "data-ssr-content-dom-ref": isSSR() && expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true) ? '' : undefined
+    "data-ssr-content-dom-ref": isSSR() && isSSRStreaming() ? '' : undefined
   }));
 });

package/dist/esm/react-node-view/index.js

@@ -6,9 +6,8 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /* eslint-disable @atlaskit/editor/no-re-export */
 
 import React from 'react';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { ACTION_SUBJECT, ACTION_SUBJECT_ID } from '../analytics';
-import { isSSR } from '../core-utils';
+import { isSSR, isSSRStreaming } from '../core-utils';
 import { createDispatch } from '../event-dispatcher';
 import { ErrorBoundary } from '../ui/ErrorBoundary';
 import { getPerformanceOptions, startMeasureReactNodeViewRendered, stopMeasureReactNodeViewRendered } from '../utils';
@@ -100,7 +99,7 @@ var ReactNodeView = /*#__PURE__*/function () {
         // contentDOMWrapper that was appended above. The React ref callback
         // (forwardRef) never fires in renderToStaticMarkup, so contentDOM is
         // left detached. Re-attach it by finding the marked SSR ref target.
-        if (isSSR() && this.domRef && expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true)) {
+        if (isSSR() && isSSRStreaming() && this.domRef) {
           var refTarget = this.domRef.querySelector('[data-ssr-content-dom-ref]');
           if (refTarget) {
             this.handleRef(refTarget);

package/dist/esm/resizer/{snapTo.js → utils.js}

@@ -4,4 +4,9 @@ export var snapTo = function snapTo(target, points) {
   target : points.reduce(function (point, closest) {
     return Math.abs(closest - target) < Math.abs(point - target) ? closest : point;
   });
+};
+export var handleSides = ['left', 'right'];
+export var imageAlignmentMap = {
+  left: 'start',
+  right: 'end'
 };

package/dist/esm/selection/context-helpers.js

@@ -2,8 +2,11 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { nodeToJSON } from '@atlaskit/editor-json-transformer';
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { TextSelection, NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { fg } from '@atlaskit/platform-feature-flags';
 var listDepth = 3;
 export var selectionCoversAllListItems = function selectionCoversAllListItems($from, $to) {
   // Block level lists
@@ -71,7 +74,107 @@ export var getSliceFromSelection = function getSliceFromSelection(selection) {
   }
   return frag;
 };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getFragmentsFromSelection } from './getFragmentsFromSelection';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getLocalIdsFromSelection } from './getLocalIdsFromSelection';
+
+/**
+ * Get the fragments from the selection.
+ * @param selection The selection to get the fragments from.
+ * @param schema The schema to use to convert the nodes to JSON.
+ * @returns The fragments as an array of JSON nodes.
+ */
+export var getFragmentsFromSelection = function getFragmentsFromSelection(selection) {
+  if (!selection || selection.empty) {
+    return null;
+  }
+  var slice = getSliceFromSelection(selection);
+  var content = slice.content;
+  var fragment = [];
+  content.forEach(function (node) {
+    fragment.push(nodeToJSON(node));
+  });
+  return fragment;
+};
+
+/**
+ * Get the local IDs from the selection.
+ * @param selection The selection to get the local IDs from.
+ * @returns The local IDs as an array of strings.
+ */
+export var getLocalIdsFromSelection = function getLocalIdsFromSelection(selection) {
+  if (!selection) {
+    return null;
+  }
+  if (selection instanceof NodeSelection) {
+    if (fg('platform_editor_ai_selection_local_ids')) {
+      var _selection$node$attrs;
+      var _ids = [];
+      var rootLocalId = (_selection$node$attrs = selection.node.attrs) === null || _selection$node$attrs === void 0 ? void 0 : _selection$node$attrs.localId;
+      if (rootLocalId) {
+        _ids.push(rootLocalId);
+      }
+      selection.node.descendants(function (node) {
+        var _node$attrs;
+        if (node.isInline) {
+          return false;
+        }
+        var localId = (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId;
+        if (localId) {
+          _ids.push(localId);
+        }
+      });
+      return _ids;
+    }
+    return [selection.node.attrs.localId];
+  } else if (selection instanceof CellSelection) {
+    if (fg('platform_editor_ai_selection_local_ids')) {
+      var _ids2 = [];
+      var ancestorIds = new Set();
+      // Collect localIds from each selected cell and its descendants
+      selection.forEachCell(function (cellNode, cellPos) {
+        var _cellNode$attrs;
+        var cellLocalId = (_cellNode$attrs = cellNode.attrs) === null || _cellNode$attrs === void 0 ? void 0 : _cellNode$attrs.localId;
+        if (cellLocalId) {
+          _ids2.push(cellLocalId);
+        }
+        cellNode.descendants(function (node) {
+          var _node$attrs2;
+          if (node.isInline) {
+            return false;
+          }
+          var localId = (_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.localId;
+          if (localId) {
+            _ids2.push(localId);
+          }
+        });
+        // Collect ancestor localIds (row, table) separately
+        var $cell = selection.$anchorCell.doc.resolve(cellPos + 1);
+        for (var depth = $cell.depth - 1; depth >= 1; depth--) {
+          var _ancestor$attrs;
+          var ancestor = $cell.node(depth);
+          var localId = (_ancestor$attrs = ancestor.attrs) === null || _ancestor$attrs === void 0 ? void 0 : _ancestor$attrs.localId;
+          if (localId) {
+            ancestorIds.add(localId);
+          }
+        }
+      });
+      var uniqueIds = new Set(_ids2);
+      var uniqueAncestors = _toConsumableArray(ancestorIds).filter(function (id) {
+        return !uniqueIds.has(id);
+      });
+      return [].concat(_toConsumableArray(uniqueIds), _toConsumableArray(uniqueAncestors));
+    }
+    // Fall through to default slice-based behavior when gate is off
+  } else if (selection.empty) {
+    return [selection.$from.parent.attrs.localId];
+  }
+  var slice = getSliceFromSelection(selection);
+  var content = slice.content;
+  var ids = [];
+  content.forEach(function (node) {
+    var _node$attrs3;
+    var localId = (_node$attrs3 = node.attrs) === null || _node$attrs3 === void 0 ? void 0 : _node$attrs3.localId;
+    if (localId) {
+      ids.push(localId);
+    }
+  });
+  return ids;
+};

package/dist/esm/selection/gap-cursor/actions.js

@@ -1,6 +1,5 @@
 import { Selection } from '@atlaskit/editor-prosemirror/state';
-import { GapCursorSelection } from './selection';
-import { Side } from './Side';
+import { GapCursorSelection, Side } from './selection';
 import { isValidTargetNode } from './utils/is-valid-target-node';
 
 // This function captures clicks outside of the ProseMirror contentEditable area

package/dist/esm/selection/gap-cursor/selection.js

@@ -8,8 +8,12 @@ function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstruct
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 import { Slice } from '@atlaskit/editor-prosemirror/model';
 import { Selection } from '@atlaskit/editor-prosemirror/state';
-import { Side } from './Side';
 import { isValidTargetNode } from './utils/is-valid-target-node';
+export var Side = /*#__PURE__*/function (Side) {
+  Side["LEFT"] = "left";
+  Side["RIGHT"] = "right";
+  return Side;
+}({});
 export var JSON_ID = 'gapcursor';
 export var GapCursorSelection = /*#__PURE__*/function (_Selection) {
   /**
@@ -146,6 +150,4 @@ export var GapBookmark = /*#__PURE__*/function () {
       return GapCursorSelection.valid($pos) ? new GapCursorSelection($pos) : Selection.near($pos);
     }
   }]);
-}();
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { Side } from './Side';
+}();

package/dist/esm/selection/index.js

@@ -6,25 +6,14 @@ import { CellSelection } from '@atlaskit/editor-tables';
 import { selectedRect } from '@atlaskit/editor-tables/utils';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../analytics';
 export { RelativeSelectionPos } from './types';
-export { Side } from './gap-cursor/Side';
-export { GapCursorSelection, JSON_ID, GapBookmark } from './gap-cursor/selection';
+export { GapCursorSelection, Side, JSON_ID, GapBookmark } from './gap-cursor/selection';
 export { setSelectionTopLevelBlocks, setGapCursorAtPos } from './gap-cursor/actions';
 export { isIgnored } from './gap-cursor/utils/is-ignored';
 export { isValidTargetNode } from './gap-cursor/utils/is-valid-target-node';
 export { setGapCursorSelection } from './gap-cursor/utils/setGapCursorSelection';
 export { hideCaretModifier, gapCursorStyles } from './gap-cursor/styles';
-export { atTheBeginningOfDoc } from './atTheBeginningOfDoc';
-export { atTheEndOfDoc } from './atTheEndOfDoc';
-export { endPositionOfParent } from './endPositionOfParent';
-export { expandSelectionBounds } from './expandSelectionBounds';
-export { isMultiBlockRange } from './isMultiBlockRange';
-export { isSelectionAtEndOfNode } from './isSelectionAtEndOfNode';
-export { isSelectionAtStartOfNode } from './isSelectionAtStartOfNode';
-export { startPositionOfParent } from './startPositionOfParent';
-export { atTheBeginningOfBlock, atTheEndOfBlock, deleteSelectedRange, expandSelectionToBlockRange, expandToBlockRange, getSourceNodesFromSelectionRange, isMultiBlockSelection, selectionIsAtTheBeginningOfBlock } from './utils';
-export { getSliceFromSelection } from './context-helpers';
-export { getFragmentsFromSelection } from './getFragmentsFromSelection';
-export { getLocalIdsFromSelection } from './getLocalIdsFromSelection';
+export { atTheBeginningOfBlock, atTheBeginningOfDoc, atTheEndOfBlock, atTheEndOfDoc, deleteSelectedRange, endPositionOfParent, expandSelectionBounds, expandSelectionToBlockRange, expandToBlockRange, getSourceNodesFromSelectionRange, isMultiBlockRange, isMultiBlockSelection, isSelectionAtEndOfNode, isSelectionAtStartOfNode, selectionIsAtTheBeginningOfBlock, startPositionOfParent } from './utils';
+export { getSliceFromSelection, getFragmentsFromSelection, getLocalIdsFromSelection } from './context-helpers';
 export function getNodeSelectionAnalyticsPayload(selection) {
   if (selection instanceof NodeSelection) {
     return {

package/dist/esm/selection/utils.js

@@ -2,10 +2,46 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
 import { isListNode } from '../utils';
-import { endPositionOfParent } from './endPositionOfParent';
 import { GapCursorSelection } from './gap-cursor/selection';
-import { isMultiBlockRange } from './isMultiBlockRange';
-import { startPositionOfParent } from './startPositionOfParent';
+export var isSelectionAtStartOfNode = function isSelectionAtStartOfNode($pos, parentNode) {
+  if (!parentNode) {
+    return false;
+  }
+  for (var i = $pos.depth + 1; i > 0; i--) {
+    var node = $pos.node(i);
+    if (node && node.eq(parentNode)) {
+      break;
+    }
+    if (i > 1 && $pos.before(i) !== $pos.before(i - 1) + 1) {
+      return false;
+    }
+  }
+  return true;
+};
+export var isSelectionAtEndOfNode = function isSelectionAtEndOfNode($pos, parentNode) {
+  if (!parentNode) {
+    return false;
+  }
+  for (var i = $pos.depth + 1; i > 0; i--) {
+    var node = $pos.node(i);
+    if (node && node.eq(parentNode)) {
+      break;
+    }
+    if (i > 1 && $pos.after(i) !== $pos.after(i - 1) - 1) {
+      return false;
+    }
+  }
+  return true;
+};
+export function atTheEndOfDoc(state) {
+  var selection = state.selection,
+    doc = state.doc;
+  return doc.nodeSize - selection.$to.pos - 2 === selection.$to.depth;
+}
+export function atTheBeginningOfDoc(state) {
+  var selection = state.selection;
+  return selection.$from.pos === selection.$from.depth;
+}
 export function atTheEndOfBlock(state) {
   var selection = state.selection;
   var $to = selection.$to;
@@ -31,6 +67,57 @@ export function selectionIsAtTheBeginningOfBlock(selection) {
   }
   return startPositionOfParent($from) === $from.pos;
 }
+export function startPositionOfParent(resolvedPos) {
+  return resolvedPos.start(resolvedPos.depth);
+}
+export function endPositionOfParent(resolvedPos) {
+  return resolvedPos.end(resolvedPos.depth) + 1;
+}
+
+/**
+ *
+ * @param $anchor Resolved selection anchor position
+ * @param $head Resolved selection head position
+ * @returns An expanded selection encompassing surrounding nodes. Hoists up to the shared depth anchor/head depths differ.
+ */
+export var expandSelectionBounds = function expandSelectionBounds($anchor, $head) {
+  var sharedDepth = $anchor.sharedDepth($head.pos) + 1;
+  var $from = $anchor.min($head);
+  var $to = $anchor.max($head);
+  var fromDepth = $from.depth;
+  var toDepth = $to.depth;
+  var selectionStart;
+  var selectionEnd;
+  var selectionHasGrandparent = toDepth > 1 && fromDepth > 1;
+  var selectionIsAcrossDiffParents = selectionHasGrandparent && !$to.parent.isTextblock && !$to.sameParent($from);
+  var selectionIsAcrossTextBlocksWithDiffParents = selectionHasGrandparent && $to.parent.isTextblock && $to.before(toDepth - 1) !== $from.before(fromDepth - 1);
+  if (toDepth > fromDepth) {
+    selectionStart = $from.before(sharedDepth);
+    selectionEnd = $to.after(sharedDepth);
+  } else if (toDepth < fromDepth) {
+    selectionStart = $from.before(sharedDepth);
+    selectionEnd = $to.after(sharedDepth);
+  } else if (selectionIsAcrossDiffParents || selectionIsAcrossTextBlocksWithDiffParents) {
+    // when selection from/to share same depth with different parents, hoist up the selection to the parent of the highest depth in the selection
+    selectionStart = $from.before(sharedDepth);
+    selectionEnd = $to.after(sharedDepth);
+  } else if (!$from.node().inlineContent) {
+    // when selection might be a Node selection, return what was passed in
+    return {
+      $anchor: $anchor,
+      $head: $head
+    };
+  } else {
+    selectionStart = fromDepth ? $from.before() : $from.pos;
+    selectionEnd = toDepth ? $to.after() : $to.pos;
+  }
+  var $expandedFrom = $anchor.doc.resolve(selectionStart);
+  var $expandedTo = $anchor.doc.resolve(selectionEnd);
+  return {
+    $anchor: $anchor === $from ? $expandedFrom : $expandedTo,
+    $head: $head === $to ? $expandedTo : $expandedFrom
+  };
+};
 
 /**
  * Delete what is selected in the given transaction.
@@ -112,6 +199,23 @@ export var expandSelectionToBlockRange = function expandSelectionToBlockRange(_r
     $to = _ref2.$to;
   return expandToBlockRange($from, $to);
 };
+export var isMultiBlockRange = function isMultiBlockRange(range) {
+  if (range.endIndex - range.startIndex <= 1) {
+    return false; // At most one child
+  }
+
+  // Count block nodes in the range, return true if more than one
+  var blockCount = 0;
+  for (var i = range.startIndex; i < range.endIndex; i++) {
+    if (range.parent.child(i).isBlock) {
+      blockCount++;
+    }
+    if (blockCount > 1) {
+      return true;
+    }
+  }
+  return false;
+};
 
 /**
  * Determines if a selection contains multiple block nodes.
@@ -153,20 +257,4 @@ export function getSourceNodesFromSelectionRange(tr, selection) {
   var sliceEnd = isList ? $to.pos + 1 : $to.pos;
   var slice = tr.doc.slice(sliceStart, sliceEnd);
   return _toConsumableArray(slice.content.content);
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isSelectionAtStartOfNode } from './isSelectionAtStartOfNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isSelectionAtEndOfNode } from './isSelectionAtEndOfNode';
-// 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 { startPositionOfParent } from './startPositionOfParent';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { endPositionOfParent } from './endPositionOfParent';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { expandSelectionBounds } from './expandSelectionBounds';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isMultiBlockRange } from './isMultiBlockRange';
+}

package/dist/esm/styles/index.js

@@ -1,9 +1,7 @@
 // Disable no-re-export rule for entry point files
 /* eslint-disable @atlaskit/editor/no-re-export */
 
-export { TableSharedCssClassName } from './shared/TableSharedCssClassName';
-export { calcTableWidth } from './shared/calcTableWidth';
-export { tableSharedStyle, tableMarginTop, tableMarginBottom, tableMarginSides, tableCellMinWidth, tableNewColumnMinWidth, tableCellBorderWidth, tableResizeHandleWidth, tableCellPadding, tableMarginTopWithControl, tableControlsSpacing, tablePadding } from './shared/table';
+export { tableSharedStyle, tableMarginTop, tableMarginBottom, tableMarginSides, tableCellMinWidth, tableNewColumnMinWidth, tableCellBorderWidth, calcTableWidth, TableSharedCssClassName, tableResizeHandleWidth, tableCellPadding, tableMarginTopWithControl, tableControlsSpacing, tablePadding } from './shared/table';
 export { AnnotationSharedClassNames, BlockAnnotationSharedClassNames } from './shared/annotation';
 export { mediaSingleSharedStyle, mediaSingleSharedStyleNew, richMediaClassName } from './shared/media-single';
 export { blockquoteSharedStyles } from './shared/blockquote';

package/dist/esm/styles/shared/table-cell-background-for-compiled.js

@@ -1,4 +1,4 @@
-import { mapBackgroundColors } from './mapBackgroundColors';
+import { mapBackgroundColors } from './tableCell';
 
 /**
  * Pre-built CSS string with `background-color` rules for every named table cell

package/dist/esm/styles/shared/table.js

@@ -3,14 +3,14 @@ var _templateObject, _templateObject2, _templateObject3;
 /* eslint-disable @atlaskit/ui-styling-standard/use-compiled -- Pre-existing lint debt surfaced by this mechanical type-import-only PR. */
 // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 import { css } from '@emotion/react';
-import { akEditorSelectedNodeClassName, akEditorTableNumberColumnWidth, overflowShadow } from '@atlaskit/editor-shared-styles';
+import { tableCellContentDomSelector, tableCellSelector, tableHeaderSelector, tablePrefixSelector } from '@atlaskit/adf-schema';
+import { akEditorBreakoutPadding, akEditorFullWidthLayoutWidth, akEditorSelectedNodeClassName, akEditorTableNumberColumnWidth, akEditorWideLayoutWidth, overflowShadow } from '@atlaskit/editor-shared-styles';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
 import { getBrowserInfo } from '../../utils/browser';
 import { CodeBlockSharedCssClassName } from './code-block';
 import { tableCellBackgroundStyleOverride } from './tableCell';
-import { TableSharedCssClassName } from './TableSharedCssClassName';
 export var tableMarginTop = 24;
 export var tableMarginBottom = 16;
 export var tableMarginTopWithControl = 14;
@@ -22,6 +22,37 @@ export var tableCellPadding = 8;
 export var tableResizeHandleWidth = 6;
 export var tablePadding = 8;
 export var tableControlsSpacing = tableMarginTop + tablePadding - tableCellBorderWidth;
+export var TableSharedCssClassName = {
+  TABLE_CONTAINER: "".concat(tablePrefixSelector, "-container"),
+  TABLE_NODE_WRAPPER: "".concat(tablePrefixSelector, "-wrapper"),
+  TABLE_NODE_WRAPPER_NO_OVERFLOW: "".concat(tablePrefixSelector, "-wrapper-no-overflow"),
+  TABLE_SCROLL_INLINE_SHADOW: "".concat(tablePrefixSelector, "-scroll-inline-shadow"),
+  TABLE_RIGHT_BORDER: "".concat(tablePrefixSelector, "-right-border"),
+  TABLE_LEFT_BORDER: "".concat(tablePrefixSelector, "-left-border"),
+  TABLE_LEFT_SHADOW: "".concat(tablePrefixSelector, "-with-left-shadow"),
+  TABLE_NATIVE_STICKY: "".concat(tablePrefixSelector, "-row-native-sticky"),
+  TABLE_RIGHT_SHADOW: "".concat(tablePrefixSelector, "-with-right-shadow"),
+  TABLE_STICKY_SHADOW: "".concat(tablePrefixSelector, "-sticky-shadow"),
+  TABLE_STICKY_WRAPPER: "".concat(tablePrefixSelector, "-sticky-wrapper"),
+  TABLE_STICKY_SCROLLBAR_CONTAINER: "".concat(tablePrefixSelector, "-sticky-scrollbar-container"),
+  TABLE_STICKY_SENTINEL_TOP: "".concat(tablePrefixSelector, "-sticky-sentinel-top"),
+  TABLE_STICKY_SENTINEL_BOTTOM: "".concat(tablePrefixSelector, "-sticky-sentinel-bottom"),
+  TABLE_STICKY_SCROLLBAR_SENTINEL_TOP: "".concat(tablePrefixSelector, "-sticky-scrollbar-sentinel-top"),
+  TABLE_STICKY_SCROLLBAR_SENTINEL_BOTTOM: "".concat(tablePrefixSelector, "-sticky-scrollbar-sentinel-bottom"),
+  TABLE_SHADOW_SENTINEL_LEFT: "".concat(tablePrefixSelector, "-shadow-sentinel-left"),
+  TABLE_SHADOW_SENTINEL_RIGHT: "".concat(tablePrefixSelector, "-shadow-sentinel-right"),
+  TABLE_STICKY: "".concat(tablePrefixSelector, "-sticky"),
+  // eslint-disable-next-line @atlaskit/editor/no-re-export
+  TABLE_CELL_NODEVIEW_CONTENT_DOM: tableCellContentDomSelector,
+  // eslint-disable-next-line @atlaskit/editor/no-re-export
+  TABLE_CELL_WRAPPER: tableCellSelector,
+  // eslint-disable-next-line @atlaskit/editor/no-re-export
+  TABLE_HEADER_CELL_WRAPPER: tableHeaderSelector,
+  TABLE_ROW_CONTROLS_WRAPPER: "".concat(tablePrefixSelector, "-row-controls-wrapper"),
+  TABLE_COLUMN_CONTROLS_DECORATIONS: "".concat(tablePrefixSelector, "-column-controls-decoration"),
+  TABLE_RESIZER_CONTAINER: "".concat(tablePrefixSelector, "-resizer-container"),
+  TABLE_VIEW_CONTENT_WRAP: 'tableView-content-wrap'
+};
 
 /* first block node has 0 top margin */
 var firstNodeWithNotMarginTop = function firstNodeWithNotMarginTop() {
@@ -38,8 +69,18 @@ var tableSharedStyle = function tableSharedStyle() {
     leftCoverWidth: "var(--ds-space-300, 24px)"
   }), "var(--ds-background-neutral, #0515240F)", "var(--ds-background-neutral, #0515240F)", expValEquals('platform_editor_table_q4_loveability', 'isEnabled', true) ? "/* When the number column is enabled, the left visual edge belongs to the number column.\n\t\t   Remove the left border-radius and left border from the table's ::after overlay\n\t\t   so it doesn't double-up or round where the number column already provides that edge. */\n\t\t.".concat(TableSharedCssClassName.TABLE_CONTAINER, "[data-number-column='true'] {\n\t\t\t> .").concat(TableSharedCssClassName.TABLE_NODE_WRAPPER, " > table::after,\n\t\t\t> .").concat(TableSharedCssClassName.TABLE_STICKY_WRAPPER, " > table::after {\n\t\t\t\tborder-top-left-radius: 0;\n\t\t\t\tborder-bottom-left-radius: 0;\n\t\t\t\tborder-left-color: transparent;\n\t\t\t}\n\t\t}") : '');
 };
-export { tableSharedStyle };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { TableSharedCssClassName } from './TableSharedCssClassName';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { calcTableWidth } from './calcTableWidth';
+export var calcTableWidth = function calcTableWidth(layout, containerWidth) {
+  var addControllerPadding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  switch (layout) {
+    case 'full-width':
+      return containerWidth ? Math.min(containerWidth - (addControllerPadding ? akEditorBreakoutPadding : 0), akEditorFullWidthLayoutWidth) : akEditorFullWidthLayoutWidth;
+    case 'wide':
+      if (containerWidth) {
+        return Math.min(containerWidth - (addControllerPadding ? akEditorBreakoutPadding : 0), akEditorWideLayoutWidth);
+      }
+      return akEditorWideLayoutWidth;
+    default:
+      return 'inherit';
+  }
+};
+export { tableSharedStyle };