@atlaskit/editor-common 115.5.0 → 115.6.0

package/dist/esm/mark/text-formatting.js

@@ -4,6 +4,33 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 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 { Mark } from '@atlaskit/editor-prosemirror/model';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+
+/**
+ * Determine if a mark of a specific type exists anywhere in the selection.
+ */
+export var anyMarkActive = function anyMarkActive(state, markType) {
+  var _state$selection = state.selection,
+    $from = _state$selection.$from,
+    from = _state$selection.from,
+    to = _state$selection.to,
+    empty = _state$selection.empty;
+  if (empty) {
+    return !!markType.isInSet(state.storedMarks || $from.marks());
+  }
+  var rangeHasMark = false;
+  if (state.selection instanceof CellSelection) {
+    state.selection.forEachCell(function (cell, cellPos) {
+      var from = cellPos;
+      var to = cellPos + cell.nodeSize;
+      if (!rangeHasMark) {
+        rangeHasMark = state.doc.rangeHasMark(from, to, markType);
+      }
+    });
+  } else {
+    rangeHasMark = state.doc.rangeHasMark(from, to, markType);
+  }
+  return rangeHasMark;
+};
 var allMarksAreRuledOut = function allMarksAreRuledOut(marks) {
   return Array.from(marks.values()).every(function (mark) {
     return !mark;
@@ -21,11 +48,11 @@ var allMarksAreRuledOut = function allMarksAreRuledOut(marks) {
  * const activeMarks = wholeSelectionHasMarks(editorState, [markTypes.strong, markTypes.em, markTypes.etc]);
  */
 export var wholeSelectionHasMarks = function wholeSelectionHasMarks(state, markTypes) {
-  var _state$selection = state.selection,
-    $from = _state$selection.$from,
-    from = _state$selection.from,
-    to = _state$selection.to,
-    empty = _state$selection.empty;
+  var _state$selection2 = state.selection,
+    $from = _state$selection2.$from,
+    from = _state$selection2.from,
+    to = _state$selection2.to,
+    empty = _state$selection2.empty;
   if (empty) {
     return new Map(markTypes.map(function (markType) {
       return [markType, !!markType.isInSet(state.storedMarks || $from.marks())];
@@ -144,9 +171,37 @@ var wholeRangeHasMarks = function wholeRangeHasMarks(from, to, doc, markTypes) {
   });
   return isTextContent ? hasMarks : hasNoMarks;
 };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { anyMarkActive } from './anyMarkActive';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isMarkAllowedInRange } from './isMarkAllowedInRange';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isMarkExcluded } from './isMarkExcluded';
+export var isMarkAllowedInRange = function isMarkAllowedInRange(doc, ranges, type) {
+  var _loop2 = function _loop2() {
+      var _ranges$i = ranges[i],
+        $from = _ranges$i.$from,
+        $to = _ranges$i.$to;
+      var can = $from.depth === 0 ? doc.type.allowsMarkType(type) : false;
+      doc.nodesBetween($from.pos, $to.pos, function (node) {
+        if (can) {
+          return false;
+        }
+        can = node.inlineContent && node.type.allowsMarkType(type);
+        return;
+      });
+      if (can) {
+        return {
+          v: can
+        };
+      }
+    },
+    _ret;
+  for (var i = 0; i < ranges.length; i++) {
+    _ret = _loop2();
+    if (_ret) return _ret.v;
+  }
+  return false;
+};
+export var isMarkExcluded = function isMarkExcluded(type, marks) {
+  if (marks) {
+    return marks.some(function (mark) {
+      return mark.type !== type && mark.type.excludes(type);
+    });
+  }
+  return false;
+};

package/dist/esm/media-single/CommentBadge.js

@@ -13,7 +13,6 @@ import CommentIcon from '@atlaskit/icon/core/comment';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import Tooltip from '@atlaskit/tooltip';
 import { commentMessages as messages } from '../media';
-import { getBadgeSize } from './getBadgeSize';
 var commentBadgeWrapper = css({
   position: 'absolute',
   // closest parent element with position relative is .resizer-hover-zone, which includes 10px padding
@@ -31,6 +30,10 @@ var commentBadgeEditorOverrides = function commentBadgeEditorOverrides(badgeOffs
     zIndex: 100
   });
 };
+export var getBadgeSize = function getBadgeSize(width, height) {
+  // width is the original width of image, not resized or currently rendered to user. Defaulting to medium for now
+  return width && width < 70 || height && height < 70 ? 'small' : 'medium';
+};
 export var CommentBadge = /*#__PURE__*/forwardRef(function (_ref, ref) {
   var intl = _ref.intl,
     width = _ref.width,
@@ -117,6 +120,4 @@ export var CommentBadge = /*#__PURE__*/forwardRef(function (_ref, ref) {
       color: "currentColor"
     })
   })));
-});
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getBadgeSize } from './getBadgeSize';
+});

package/dist/esm/media-single/index.js

@@ -2,15 +2,7 @@
 /* eslint-disable @atlaskit/editor/no-re-export */
 
 export { MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH, MEDIA_SINGLE_VIDEO_MIN_PIXEL_WIDTH, MEDIA_SINGLE_SNAP_GAP, MEDIA_SINGLE_HIGHLIGHT_GAP, MEDIA_SINGLE_GUTTER_SIZE, MEDIA_SINGLE_RESIZE_THROTTLE_TIME, Layout as MediaSingleLayout, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, wrappedLayouts, CAPTION_PLACEHOLDER_ID, MEDIA_SINGLE_ADJACENT_HANDLE_MARGIN } from './constants';
-export { calcMediaSingleMaxWidth } from './calcMediaSingleMaxWidth';
-export { calcMinWidth } from './calcMinWidth';
-export { calculateOffsetLeft } from './calculateOffsetLeft';
-export { currentMediaNodeWithPos } from './currentMediaNodeWithPos';
-export { getMaxWidthForNestedNode } from './getMaxWidthForNestedNode';
-export { getMediaSingleInitialWidth } from './getMediaSingleInitialWidth';
-export { getMediaSinglePixelWidth } from './getMediaSinglePixelWidth';
-export { roundToNearest } from './roundToNearest';
-export { calcMediaSinglePixelWidth, getMaxWidthForNestedNodeNext } from './utils';
+export { getMediaSinglePixelWidth, calcMediaSinglePixelWidth, calcMediaSingleMaxWidth, getMediaSingleInitialWidth, calculateOffsetLeft, roundToNearest, calcMinWidth, getMaxWidthForNestedNode, getMaxWidthForNestedNodeNext, currentMediaNodeWithPos } from './utils';
 export { CommentBadge } from './CommentBadge';
 export { CommentBadgeNext } from './CommentBadgeNext';
 export { ExternalImageBadge } from './ExternalImageBadge';

package/dist/esm/media-single/utils.js

@@ -1,8 +1,29 @@
-import { breakoutWideScaleRatio } from '@atlaskit/editor-shared-styles';
-import { floatingLayouts } from '../utils/floatingLayouts';
-import { calcMediaSingleMaxWidth } from './calcMediaSingleMaxWidth';
-import { wrappedLayouts } from './constants';
-import { getMediaSingleInitialWidth } from './getMediaSingleInitialWidth';
+import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { akEditorDefaultLayoutWidth, akEditorFullWidthLayoutWidth, akEditorGutterPadding, akEditorGutterPaddingDynamic, akEditorGutterPaddingReduced, akEditorFullPageNarrowBreakout, breakoutWideScaleRatio } from '@atlaskit/editor-shared-styles';
+import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
+import { floatingLayouts, isRichMediaInsideOfBlockNode } from '../utils/rich-media-utils';
+import { DEFAULT_IMAGE_WIDTH, DEFAULT_ROUNDING_INTERVAL, MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH, MEDIA_SINGLE_VIDEO_MIN_PIXEL_WIDTH, wrappedLayouts } from './constants';
+
+/**
+ * Convert media node width to pixel
+ *
+ * for legacy experience, image is aligned inside resize handle bar with a gap. So gutterOffset is used to for this use case.
+ * for new experience, image is aligned with resize handle bar, so gutterOffset is 0
+ *
+ * @param width - media single node width
+ * @param editorWidth - width of editor
+ * @param widthType - width type is defined in the adf document for mediaSingle node, and it is associated with the `width`
+ * @param gutterOffset - resize handle bar offset, determines whether align with resize handle bar
+ * @returns pixel number for media single node
+ */
+export function getMediaSinglePixelWidth(width, editorWidth) {
+  var widthType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'percentage';
+  var gutterOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  if (widthType === 'pixel') {
+    return width;
+  }
+  return Math.ceil((editorWidth + gutterOffset) * (width / 100) - gutterOffset);
+}
 /**
  * Convert width attribute to pixel value for legacy (resized or not resisized) and new media single node for new experience
  * @param width node width attribute
@@ -67,6 +88,83 @@ var calcLegacyWideWidth = function calcLegacyWideWidth(containerWidth, origWidth
   }
   return origWidth;
 };
+
+/**
+ * Calculate maximum width allowed for media single node in fix-width editor in new experience
+ * @param containerWidth width of editor container
+ */
+export var calcMediaSingleMaxWidth = function calcMediaSingleMaxWidth(containerWidth, editorAppearance) {
+  var fullPagePadding = editorAppearance === 'full-page' && containerWidth <= akEditorFullPageNarrowBreakout && editorExperiment('platform_editor_preview_panel_responsiveness', true, {
+    exposure: true
+  }) ? akEditorGutterPaddingReduced : akEditorGutterPaddingDynamic();
+  var fullWidthPadding = editorAppearance === 'full-page' ? fullPagePadding * 2 : akEditorGutterPadding * 2;
+  return Math.min(containerWidth - fullWidthPadding, akEditorFullWidthLayoutWidth);
+};
+
+/**
+ * Calculate initial media single pixel width.
+ * Make it fall between max width and min width
+ * @param origWidth original width of image (media node width)
+ * @param maxWidth default to akEditorDefaultLayoutWidth (760)
+ * @param minWidth default to MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH (24)
+ */
+export var getMediaSingleInitialWidth = function getMediaSingleInitialWidth() {
+  var origWidth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_IMAGE_WIDTH;
+  var maxWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : akEditorDefaultLayoutWidth;
+  var minWidth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH;
+  return Math.max(Math.min(origWidth, maxWidth), minWidth);
+};
+export function calculateOffsetLeft(insideInlineLike, insideLayout, pmViewDom, wrapper) {
+  var offsetLeft = 0;
+  if (wrapper && insideInlineLike && !insideLayout) {
+    var currentNode = wrapper;
+    var boundingRect = currentNode.getBoundingClientRect();
+    offsetLeft = boundingRect.left - pmViewDom.getBoundingClientRect().left;
+  }
+  return offsetLeft;
+}
+
+/**
+ * Returns the number rounded to the nearest interval.
+ * @param {number} value    The number to round
+ * @param {number} interval The numeric interval to round to, default to 0.5
+ * @returns {number} the rounded number
+ */
+export var roundToNearest = function roundToNearest(value) {
+  var interval = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_ROUNDING_INTERVAL;
+  return Math.round(value / interval) * interval;
+};
+
+/**
+ * Retuns minimum value for media single node
+ * @param isVideoFile is child media of video type
+ * @param contentWidth parent content width
+ */
+export var calcMinWidth = function calcMinWidth(isVideoFile, contentWidth) {
+  return Math.min(contentWidth, isVideoFile ? MEDIA_SINGLE_VIDEO_MIN_PIXEL_WIDTH : MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH);
+};
+
+/**
+ * Get parent width for a nested media single node
+ * @param view Editor view
+ * @param pos node position
+ */
+export var getMaxWidthForNestedNode = function getMaxWidthForNestedNode(view, pos) {
+  if (typeof pos !== 'number') {
+    return null;
+  }
+  if (isRichMediaInsideOfBlockNode(view, pos)) {
+    var $pos = view.state.doc.resolve(pos);
+    var domNode = view.nodeDOM($pos.pos);
+    if ($pos.nodeAfter && floatingLayouts.indexOf($pos.nodeAfter.attrs.layout) > -1 && domNode && domNode.parentElement) {
+      return domNode.parentElement.offsetWidth;
+    }
+    if (domNode instanceof HTMLElement) {
+      return domNode.offsetWidth;
+    }
+  }
+  return null;
+};
 var calcParentPadding = function calcParentPadding(view, resolvedPos) {
   // since table has constant padding, use hardcoded constant instead of query the dom
   var tablePadding = 8;
@@ -127,19 +225,26 @@ export var getParentWidthForNestedMediaSingleNodeForInsertion = function getPare
   }
   return null;
 };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getMediaSinglePixelWidth } from './getMediaSinglePixelWidth';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { calcMediaSingleMaxWidth } from './calcMediaSingleMaxWidth';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getMediaSingleInitialWidth } from './getMediaSingleInitialWidth';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { calculateOffsetLeft } from './calculateOffsetLeft';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { roundToNearest } from './roundToNearest';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { calcMinWidth } from './calcMinWidth';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getMaxWidthForNestedNode } from './getMaxWidthForNestedNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { currentMediaNodeWithPos } from './currentMediaNodeWithPos';
+
+/**
+ *
+ * @param editorState current editor state
+ * @returns selected media node (child of mediaSingle only) with position
+ */
+export var currentMediaNodeWithPos = function currentMediaNodeWithPos(editorState) {
+  var doc = editorState.doc,
+    selection = editorState.selection,
+    schema = editorState.schema;
+  if (!doc || !selection || !(selection instanceof NodeSelection) || selection.node.type !== schema.nodes.mediaSingle) {
+    return;
+  }
+  var pos = selection.$anchor.pos + 1;
+  var node = doc.nodeAt(pos);
+  if (!node || node.type !== schema.nodes.media) {
+    return;
+  }
+  return {
+    node: node,
+    pos: pos
+  };
+};

package/dist/esm/monitoring/error.js

@@ -10,7 +10,7 @@ import { isFedRamp } from './environment';
 import { normaliseSentryBreadcrumbs, SERIALIZABLE_ATTRIBUTES } from './normalise-sentry-breadcrumbs';
 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 = "115.4.0";
+var packageVersion = "115.5.1";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/esm/nesting/utilities.js

@@ -1,10 +1,108 @@
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getParentOfTypeCount } from './getParentOfTypeCount';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getPositionAfterTopParentNodeOfType } from './getPositionAfterTopParentNodeOfType';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isSelectionTableNestedInTable } from './isSelectionTableNestedInTable';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isNestedTablesSupported } from './isNestedTablesSupported';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isPanelNestingTableSupported } from './isPanelNestingTableSupported';
+import { findTable } from '@atlaskit/editor-tables';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+
+/*
+ * Returns the level of nesting of a given `nodeType` in the current position.
+ * eg. table > table is nested 1 level, table > table > table is nested 2 levels.
+ *
+ * ```typescript
+ * const nestingLevel = getParentOfTypeCount(schema.nodes.table)(position);
+ * ```
+ */
+export var getParentOfTypeCount = function getParentOfTypeCount(nodeType) {
+  return function ($pos) {
+    var count = 0;
+    // Loop through parent nodes from bottom to top
+    for (var depth = $pos.depth; depth > 0; depth--) {
+      var node = $pos.node(depth);
+      // Count the table nodes
+      if (node.type === nodeType) {
+        count++;
+      }
+    }
+    return count;
+  };
+};
+
+/*
+ * Returns the (absolute) position directly after the top parent node of a given `nodeType` in the current position.
+ *
+ * ```typescript
+ * const nestingLevel = getEndTopParentNodeOfType(schema.nodes.table)(position);
+ * ```
+ */
+export var getPositionAfterTopParentNodeOfType = function getPositionAfterTopParentNodeOfType(nodeType) {
+  return function ($pos) {
+    // Loop through parent nodes from top to bottom
+    for (var depth = 1; depth <= $pos.depth; depth++) {
+      var node = $pos.node(depth);
+      // Count the table nodes
+      if (node.type === nodeType) {
+        return $pos.after(depth);
+      }
+    }
+  };
+};
+
+/*
+ * Returns true if the current selection is inside a table nested within a table.
+ *
+ * ```typescript
+ * const isNestedTable = isSelectionTableNestedInTable(state);
+ * ```
+ */
+export var isSelectionTableNestedInTable = function isSelectionTableNestedInTable(state) {
+  var table = findTable(state.selection);
+  if (!table) {
+    return false;
+  }
+  var parent = state.doc.resolve(table.pos).parent;
+  var nodeTypes = state.schema.nodes;
+  return [nodeTypes.tableHeader, nodeTypes.tableCell].includes(parent.type);
+};
+
+/*
+ * Returns true if the schema supports nesting tables inside table cells.
+ * This is determined by checking if table cells can contain table nodes in their content model.
+ *
+ * ```typescript
+ * const supportsNestedTables = isNestedTablesSupported(state.schema);
+ * ```
+ */
+export var isNestedTablesSupported = function isNestedTablesSupported(schema) {
+  var _tableCell$contentMat, _tableHeader$contentM;
+  var _schema$nodes = schema.nodes,
+    table = _schema$nodes.table,
+    tableCell = _schema$nodes.tableCell,
+    tableHeader = _schema$nodes.tableHeader;
+  if (!table || !tableCell || !tableHeader) {
+    return false;
+  }
+
+  // Check if table cells can contain table nodes by testing their content match
+  var tableCellCanContainTable = ((_tableCell$contentMat = tableCell.contentMatch.matchType(table)) === null || _tableCell$contentMat === void 0 ? void 0 : _tableCell$contentMat.validEnd) === true;
+  var tableHeaderCanContainTable = ((_tableHeader$contentM = tableHeader.contentMatch.matchType(table)) === null || _tableHeader$contentM === void 0 ? void 0 : _tableHeader$contentM.validEnd) === true;
+  return tableCellCanContainTable || tableHeaderCanContainTable;
+};
+
+/*
+ * Returns true if the schema supports nesting a table inside a panel (panel_c1 variant),
+ * AND the `platform_editor_nest_table_in_panel` experiment is enabled.
+ *
+ * ```typescript
+ * const supportsTableInPanel = isPanelNestingTableSupported(state.schema);
+ * ```
+ */
+export var isPanelNestingTableSupported = function isPanelNestingTableSupported(schema) {
+  var _panel_c1$contentMatc;
+  var _schema$nodes2 = schema.nodes,
+    table = _schema$nodes2.table,
+    panel_c1 = _schema$nodes2.panel_c1;
+  if (!table || !panel_c1) {
+    return false;
+  }
+
+  // Confirm the PM schema actually allows table inside panel_c1
+  var panelC1CanContainTable = ((_panel_c1$contentMatc = panel_c1.contentMatch.matchType(table)) === null || _panel_c1$contentMatc === void 0 ? void 0 : _panel_c1$contentMatc.validEnd) === true;
+  return panelC1CanContainTable && expValEquals('platform_editor_nest_table_in_panel', 'isEnabled', true);
+};

package/dist/esm/normalize-feature-flags.js

@@ -69,5 +69,14 @@ export function normalizeFeatureFlags(rawFeatureFlags, options) {
     return flags;
   }, {});
 }
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getEnabledFeatureFlagKeys } from './getEnabledFeatureFlagKeys';
+
+/**
+ * Transforms FeatureFlags to a type safe string array of the enabled feature flags.
+ *
+ * Useful for analytics and analysis purposes.
+ */
+export function getEnabledFeatureFlagKeys(featureFlags) {
+  return Object.keys(featureFlags).filter(function (key) {
+    return featureFlags[key] === true;
+  });
+}

package/dist/esm/paste/clipboard.js

@@ -1,10 +1,15 @@
-import { checkClipboardTypes } from './checkClipboardTypes';
+export function checkClipboardTypes(type, item) {
+  // Ignored via go/ees005
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var isDOMStringList = function isDOMStringList(t) {
+    return !t.indexOf && !!t.contains;
+  };
+  return isDOMStringList(type) ? type.contains(item) : type.indexOf(item) > -1;
+}
 export function isPastedFile(rawEvent) {
   var clipboardData = rawEvent.clipboardData;
   if (!clipboardData) {
     return false;
   }
   return checkClipboardTypes(clipboardData.types, 'Files');
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { checkClipboardTypes } from './checkClipboardTypes';
+}

package/dist/esm/portal/common.js

@@ -1,8 +1,51 @@
-import React, { memo } from 'react';
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import React, { memo, useLayoutEffect, useMemo, useState } from 'react';
 import { createPortal } from 'react-dom';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { isSSR } from '../core-utils/is-ssr';
-import { PortalRenderWrapperInner } from './PortalRenderWrapperInner';
+import { isSSRStreaming } from '../core-utils/is-ssr-streaming';
+import { PortalBucket } from './PortalBucket';
+export function createPortalRendererComponent(portalManager) {
+  return function PortalRenderer() {
+    var _useState = useState(portalManager.getBuckets()),
+      _useState2 = _slicedToArray(_useState, 2),
+      buckets = _useState2[0],
+      setBuckets = _useState2[1];
+    useLayoutEffect(function () {
+      portalManager.registerPortalRenderer(setBuckets);
+      return function () {
+        portalManager.unregisterPortalRenderer();
+      };
+    }, []);
+    var portalsElements = useMemo(
+    // Ignored via go/ees005
+    // eslint-disable-next-line react/no-array-index-key
+    function () {
+      return buckets.map(function (_, i) {
+        return /*#__PURE__*/React.createElement(PortalBucket, {
+          key: i,
+          id: i,
+          portalManager: portalManager
+        });
+      });
+    }, [buckets]);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, portalsElements);
+  };
+}
+
+/**
+ * Wraps the children of a portal to allow for React rendering
+ * lifecycle hook to be exposed, primarily for node virtualization.
+ */
+export var PortalRenderWrapperInner = function PortalRenderWrapperInner(_ref) {
+  var getChildren = _ref.getChildren,
+    onBeforeRender = _ref.onBeforeRender;
+  useLayoutEffect(function () {
+    if (onBeforeRender) {
+      onBeforeRender();
+    }
+  }, [onBeforeRender]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, getChildren());
+};
 var PortalRenderWrapper = /*#__PURE__*/memo(PortalRenderWrapperInner);
 PortalRenderWrapper.displayName = 'PortalRenderWrapper';
 
@@ -39,7 +82,7 @@ export var getPortalProviderAPI = function getPortalProviderAPI(portalManager) {
   return {
     render: function render(children, container, key, onBeforeReactDomRender) {
       var immediate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-      if (isSSR() && expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true)) {
+      if (isSSR() && isSSRStreaming()) {
         var html = '';
         try {
           var renderToStaticMarkup = getRenderToStaticMarkup();
@@ -72,7 +115,7 @@ export var getPortalProviderAPI = function getPortalProviderAPI(portalManager) {
     },
     remove: function remove(key) {
       var _portalsMap$get;
-      if (isSSR() && expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true)) {
+      if (isSSR() && isSSRStreaming()) {
         return;
       }
       (_portalsMap$get = portalsMap.get(key)) === null || _portalsMap$get === void 0 || _portalsMap$get();
@@ -83,8 +126,4 @@ export var getPortalProviderAPI = function getPortalProviderAPI(portalManager) {
       portalManager.destroy();
     }
   };
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { createPortalRendererComponent } from './createPortalRendererComponent';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { PortalRenderWrapperInner } from './PortalRenderWrapperInner';
+};

package/dist/esm/portal/index.js

@@ -2,6 +2,6 @@
 /* eslint-disable @atlaskit/editor/no-re-export */
 
 export { PortalManager } from './PortalManager';
-export { PortalRenderWrapperInner } from './PortalRenderWrapperInner';
+export { PortalRenderWrapperInner } from './common';
 export { PortalBucket } from './PortalBucket';
 export { usePortalProvider } from './usePortalProvider';

package/dist/esm/portal/usePortalProvider.js

@@ -1,6 +1,5 @@
 import { useEffect, useMemo } from 'react';
-import { getPortalProviderAPI } from './common';
-import { createPortalRendererComponent } from './createPortalRendererComponent';
+import { createPortalRendererComponent, getPortalProviderAPI } from './common';
 import { PortalManager } from './PortalManager';
 /**
  * Initializes PortalManager and creates PortalRendererComponent. Offers an API (portalProviderAPI) for managing portals.

package/dist/esm/preset/core-plugin/index.js

@@ -1,8 +1,7 @@
 import { Node } from '@atlaskit/editor-prosemirror/model';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { getNodeIdProvider } from '../../node-anchor/node-anchor-provider';
-import { processRawFragmentValue } from '../../utils/processRawFragmentValue';
-import { processRawValue, processRawValueWithoutValidation } from '../../utils/processRawValue';
+import { processRawFragmentValue, processRawValue, processRawValueWithoutValidation } from '../../utils/processRawValue';
 import { editorCommandToPMCommand } from '../editor-commands';
 import { appearancePluginKey, createAppearancePlugin } from './pm-plugins/appearance-plugin';
 import { createThrottleSchedule, returnDocumentRequest, returnDocumentRequestNoThrowError } from './requestDocument';

package/dist/esm/preset/editor-commands.js

@@ -1,13 +1,21 @@
-import { PassiveTransaction } from './PassiveTransaction'; /**
-                                                           * Convert a EditorCommand to a standard Prosemirror Command.
-                                                           * The preferred approach to dispatching a `EditorCommand` is via the
-                                                           * `core.actions.execute` on `pluginInjectionAPI`. In some cases
-                                                           * the type may require a Command until we refactor this out and this
-                                                           * function is suitable for those cases.
-                                                           *
-                                                           * @param command A plugin command (a function that modifies and returns a `Transaction`)
-                                                           * @returns Command
-                                                           */
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Convert a EditorCommand to a standard Prosemirror Command.
+ * The preferred approach to dispatching a `EditorCommand` is via the
+ * `core.actions.execute` on `pluginInjectionAPI`. In some cases
+ * the type may require a Command until we refactor this out and this
+ * function is suitable for those cases.
+ *
+ * @param command A plugin command (a function that modifies and returns a `Transaction`)
+ * @returns Command
+ */
 export function editorCommandToPMCommand(command) {
   return function (_ref, dispatch) {
     var tr = _ref.tr;
@@ -24,5 +32,20 @@ export function editorCommandToPMCommand(command) {
     return true;
   };
 }
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { PassiveTransaction } from './PassiveTransaction';
+
+/**
+ * PassiveTransaction is used only to indicate that
+ * an `EditorCommand` should return `true` but should not dispatch.
+ */
+export var PassiveTransaction = /*#__PURE__*/function (_Transaction) {
+  // This is very cheeky but this should never be used outside its intended
+  // purpose - it will likely crash the editor so we should get an early warning
+  // signal
+  function PassiveTransaction() {
+    _classCallCheck(this, PassiveTransaction);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return _callSuper(this, PassiveTransaction, [{}]);
+  }
+  _inherits(PassiveTransaction, _Transaction);
+  return _createClass(PassiveTransaction);
+}(Transaction);

package/dist/esm/preset/index.js

@@ -3,5 +3,4 @@
 
 export { EditorPresetBuilder } from './builder';
 export { EditorPluginInjectionAPI } from './plugin-injection-api';
-export { PassiveTransaction } from './PassiveTransaction';
-export { editorCommandToPMCommand } from './editor-commands';
+export { editorCommandToPMCommand, PassiveTransaction } from './editor-commands';