@atlaskit/editor-common 115.5.1 → 115.6.0

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

@@ -1,8 +1,27 @@
-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, widthType = 'percentage', gutterOffset = 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
@@ -66,6 +85,77 @@ const calcLegacyWideWidth = (containerWidth, origWidth, contentWidth) => {
   }
   return origWidth;
 };
+
+/**
+ * Calculate maximum width allowed for media single node in fix-width editor in new experience
+ * @param containerWidth width of editor container
+ */
+export const calcMediaSingleMaxWidth = (containerWidth, editorAppearance) => {
+  const fullPagePadding = editorAppearance === 'full-page' && containerWidth <= akEditorFullPageNarrowBreakout && editorExperiment('platform_editor_preview_panel_responsiveness', true, {
+    exposure: true
+  }) ? akEditorGutterPaddingReduced : akEditorGutterPaddingDynamic();
+  const 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 const getMediaSingleInitialWidth = (origWidth = DEFAULT_IMAGE_WIDTH, maxWidth = akEditorDefaultLayoutWidth, minWidth = MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH) => {
+  return Math.max(Math.min(origWidth, maxWidth), minWidth);
+};
+export function calculateOffsetLeft(insideInlineLike, insideLayout, pmViewDom, wrapper) {
+  let offsetLeft = 0;
+  if (wrapper && insideInlineLike && !insideLayout) {
+    const currentNode = wrapper;
+    const 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 const roundToNearest = (value, interval = DEFAULT_ROUNDING_INTERVAL) => 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 const 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 const getMaxWidthForNestedNode = (view, pos) => {
+  if (typeof pos !== 'number') {
+    return null;
+  }
+  if (isRichMediaInsideOfBlockNode(view, pos)) {
+    const $pos = view.state.doc.resolve(pos);
+    const 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;
+};
 const calcParentPadding = (view, resolvedPos) => {
   // since table has constant padding, use hardcoded constant instead of query the dom
   const tablePadding = 8;
@@ -127,19 +217,28 @@ export const getParentWidthForNestedMediaSingleNodeForInsertion = (resolvedPos,
   }
   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 const currentMediaNodeWithPos = editorState => {
+  const {
+    doc,
+    selection,
+    schema
+  } = editorState;
+  if (!doc || !selection || !(selection instanceof NodeSelection) || selection.node.type !== schema.nodes.mediaSingle) {
+    return;
+  }
+  const pos = selection.$anchor.pos + 1;
+  const node = doc.nodeAt(pos);
+  if (!node || node.type !== schema.nodes.media) {
+    return;
+  }
+  return {
+    node,
+    pos
+  };
+};

package/dist/es2019/monitoring/error.js

@@ -4,7 +4,7 @@ import { isFedRamp } from './environment';
 import { normaliseSentryBreadcrumbs, SERIALIZABLE_ATTRIBUTES } from './normalise-sentry-breadcrumbs';
 const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-const packageVersion = "115.5.0";
+const packageVersion = "115.5.1";
 const sanitiseSentryEvents = (data, _hint) => {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/es2019/nesting/utilities.js

@@ -1,10 +1,106 @@
-// 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 const getParentOfTypeCount = nodeType => $pos => {
+  let count = 0;
+  // Loop through parent nodes from bottom to top
+  for (let depth = $pos.depth; depth > 0; depth--) {
+    const 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 const getPositionAfterTopParentNodeOfType = nodeType => $pos => {
+  // Loop through parent nodes from top to bottom
+  for (let depth = 1; depth <= $pos.depth; depth++) {
+    const 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 const isSelectionTableNestedInTable = state => {
+  const table = findTable(state.selection);
+  if (!table) {
+    return false;
+  }
+  const parent = state.doc.resolve(table.pos).parent;
+  const 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 const isNestedTablesSupported = schema => {
+  var _tableCell$contentMat, _tableHeader$contentM;
+  const {
+    table,
+    tableCell,
+    tableHeader
+  } = schema.nodes;
+  if (!table || !tableCell || !tableHeader) {
+    return false;
+  }
+
+  // Check if table cells can contain table nodes by testing their content match
+  const tableCellCanContainTable = ((_tableCell$contentMat = tableCell.contentMatch.matchType(table)) === null || _tableCell$contentMat === void 0 ? void 0 : _tableCell$contentMat.validEnd) === true;
+  const 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 const isPanelNestingTableSupported = schema => {
+  var _panel_c1$contentMatc;
+  const {
+    table,
+    panel_c1
+  } = schema.nodes;
+  if (!table || !panel_c1) {
+    return false;
+  }
+
+  // Confirm the PM schema actually allows table inside panel_c1
+  const 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/es2019/normalize-feature-flags.js

@@ -55,5 +55,12 @@ 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(key => featureFlags[key] === true);
+}

package/dist/es2019/paste/clipboard.js

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

package/dist/es2019/portal/common.js

@@ -1,8 +1,44 @@
-import React, { memo } from 'react';
+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() {
+    const [buckets, setBuckets] = useState(portalManager.getBuckets());
+    useLayoutEffect(() => {
+      portalManager.registerPortalRenderer(setBuckets);
+      return () => {
+        portalManager.unregisterPortalRenderer();
+      };
+    }, []);
+    const portalsElements = useMemo(
+    // Ignored via go/ees005
+    // eslint-disable-next-line react/no-array-index-key
+    () => buckets.map((_, i) => /*#__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 const PortalRenderWrapperInner = ({
+  getChildren,
+  onBeforeRender
+}) => {
+  useLayoutEffect(() => {
+    if (onBeforeRender) {
+      onBeforeRender();
+    }
+  }, [onBeforeRender]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, getChildren());
+};
 const PortalRenderWrapper = /*#__PURE__*/memo(PortalRenderWrapperInner);
 PortalRenderWrapper.displayName = 'PortalRenderWrapper';
 
@@ -36,7 +72,7 @@ export const getPortalProviderAPI = portalManager => {
   const portalsMap = new Map();
   return {
     render: (children, container, key, onBeforeReactDomRender, immediate = false) => {
-      if (isSSR() && expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true)) {
+      if (isSSR() && isSSRStreaming()) {
         let html = '';
         try {
           const renderToStaticMarkup = getRenderToStaticMarkup();
@@ -67,7 +103,7 @@ export const getPortalProviderAPI = portalManager => {
     },
     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 ? void 0 : _portalsMap$get();
@@ -78,8 +114,4 @@ export const 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/es2019/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/es2019/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/es2019/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/es2019/preset/editor-commands.js

@@ -1,13 +1,14 @@
-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 { 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 ({
     tr
@@ -25,5 +26,17 @@ 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 class PassiveTransaction extends 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
+  constructor() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    super({});
+  }
+}

package/dist/es2019/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';

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

@@ -92,6 +92,7 @@ const notifyListenersThrottled = throttle(({
     cb();
   });
 }, THROTTLE_CALLS_FOR_MILLISECONDS);
+export class PluginsData {}
 class ActionsAPI {
   createAPI(
   // Ignored via go/ees005
@@ -354,6 +355,4 @@ export class EditorPluginInjectionAPI {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return editorAPICache.get(this);
   }
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { PluginsData } from './PluginsData';
+}

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

@@ -1,5 +1,4 @@
-import { getOnlyFulfilled, waitForAllPromises } from './promise-helpers';
-import { waitForFirstFulfilledPromise } from './waitForFirstFulfilledPromise';
+import { getOnlyFulfilled, waitForAllPromises, waitForFirstFulfilledPromise } from './promise-helpers';
 const flatten = arr => [].concat(...arr);
 
 /**

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

@@ -1,4 +1,8 @@
-import { ResultStatus } from './ResultStatus';
+export let ResultStatus = /*#__PURE__*/function (ResultStatus) {
+  ResultStatus["FULFILLED"] = "fulfilled";
+  ResultStatus["FAILED"] = "failed";
+  return ResultStatus;
+}({});
 const isFullfilled = result => result.status === ResultStatus.FULFILLED;
 const markFullfilled = value => ({
   status: ResultStatus.FULFILLED,
@@ -23,10 +27,30 @@ export const waitForAllPromises = promises => {
   return Promise.all(promises.map(result => result.then(markFullfilled).catch(markRejected)));
 };
 
+/**
+ * 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 const waitForFirstFulfilledPromise = promises => {
+  const rejectReasons = [];
+  return new Promise((resolve, reject) => {
+    promises.forEach(promise => promise.then(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(reason => {
+      rejectReasons.push(reason);
+      if (rejectReasons.length === promises.length) {
+        reject(reason);
+      }
+    }));
+  });
+};
+
 /**
  * Find all fullfilled promises and return their values
  * @param results
  */
-export const getOnlyFulfilled = results => results.filter(isFullfilled).map(result => result.value);
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-// eslint-disable-next-line @atlaskit/editor/no-re-export
+export const getOnlyFulfilled = results => results.filter(isFullfilled).map(result => result.value);

package/dist/es2019/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 const 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/es2019/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.
@@ -9,5 +9,5 @@ import { isSSR } from '../core-utils/is-ssr';
  */
 export const NodeViewContentHole = /*#__PURE__*/forwardRef((props, ref) => /*#__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/es2019/react-node-view/index.js

@@ -4,9 +4,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';
@@ -90,7 +89,7 @@ export default class ReactNodeView {
       // 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) {
         const refTarget = this.domRef.querySelector('[data-ssr-content-dom-ref]');
         if (refTarget) {
           this.handleRef(refTarget);

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

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