@atlaskit/editor-common 115.5.1 → 115.6.0

package/dist/es2019/block-menu/index.js

@@ -5,8 +5,4 @@ export { FORMAT_HEADING_1_MENU_ITEM, FORMAT_HEADING_2_MENU_ITEM, FORMAT_HEADING_
 export { MAIN_BLOCK_MENU_SECTION_RANK, TRANSFORM_MENU_SECTION_RANK, BLOCK_ACTIONS_FEATURED_EXTENSION_ITEM_RANK, TRANSFORM_MENU_ITEM_RANK, TRANSFORM_HEADINGS_MENU_SECTION_RANK, TRANSFORM_STRUCTURE_MENU_SECTION_RANK, TRANSFORM_CLEAR_MENU_SECTION_RANK, BLOCK_ACTIONS_MENU_SECTION_RANK, BLOCK_ACTIONS_COPY_MENU_SECTION_RANK, POSITION_MENU_SECTION_RANK, DELETE_MENU_SECTION_RANK, TRANSFORM_SUGGESTED_MENU_SECTION_RANK, TRANSFORM_CREATE_MENU_SECTION_RANK, AI_MENU_SECTION_RANK } from './rank';
 export { FORMAT_NESTED_MENU_RANK, FORMAT_NESTED_MENU_RANK_REVISED, BLOCK_MENU_SECTION_RANK, PRIMARY_MENU_SECTION_RANK, COPY_MENU_SECTION_RANK, DELETE_SECTION_RANK, MOVE_BLOCK_SECTION_RANK, ADD_BLOCKS_MENU_SECTION_RANK } from './rank-deprecated';
 export { createBlockLinkHashValue, DEFAULT_BLOCK_LINK_HASH_PREFIX, extractBlockIdFromLinkHash, isBlockLinkHash } from './block-link';
-export { SCROLL_TO_BLOCK_TIMING } from './SCROLL_TO_BLOCK_TIMING';
-export { expandElement } from './expandElement';
-export { getLocalIdSelector } from './getLocalIdSelector';
-export { isExpandCollapsed } from './isExpandCollapsed';
-export { expandAllParentsThenScroll, findParentExpands, findNodeWithExpandParents } from './scroll-to-block-utils';
+export { expandAllParentsThenScroll, findParentExpands, isExpandCollapsed, expandElement, findNodeWithExpandParents, SCROLL_TO_BLOCK_TIMING, getLocalIdSelector } from './scroll-to-block-utils';

package/dist/es2019/block-menu/scroll-to-block-utils.js

@@ -3,9 +3,22 @@
  * Used by both Confluence's useScrollOnUrlChange and platform renderer's useScrollToBlock.
  */
 
-import { expandElement } from './expandElement';
-import { isExpandCollapsed } from './isExpandCollapsed';
-import { SCROLL_TO_BLOCK_TIMING } from './SCROLL_TO_BLOCK_TIMING';
+import { fg } from '@atlaskit/platform-feature-flags';
+
+/**
+ * Timing constants for expand animation and DOM update delays.
+ * These values are tuned for the expand component's behavior and React's update cycle.
+ */
+export const SCROLL_TO_BLOCK_TIMING = {
+  /** Minimal delay for DOM/React updates after expanding (no animation in expand component). */
+  DOM_UPDATE_DELAY: 50,
+  /** Delay when expand operation fails and needs retry. */
+  RETRY_DELAY: 100,
+  /** Maximum number of retry attempts before giving up and scrolling anyway. */
+  MAX_ATTEMPTS: 5,
+  /** Maximum depth of nested expands to search (prevents infinite loops). */
+  MAX_EXPAND_DEPTH: 2
+};
 /**
  * Find a node by its localId in an ADF document and determine if it has expand or nestedExpand parents.
  * This is used to identify nodes that may be hidden inside collapsed expands.
@@ -93,6 +106,51 @@ export const findParentExpands = (element, maxDepth = SCROLL_TO_BLOCK_TIMING.MAX
   return expands.reverse();
 };
 
+/**
+ * Check if an expand node is currently collapsed.
+ *
+ * Uses two methods to determine collapse state:
+ * 1. First checks aria-expanded attribute on the toggle button (most reliable).
+ * 2. Falls back to checking content div visibility via computed styles.
+ *
+ * @param expandContainer - The expand container element.
+ * @returns True if the expand is collapsed, false if expanded or state cannot be determined.
+ */
+export const isExpandCollapsed = expandContainer => {
+  // Check for aria-expanded attribute on the toggle button
+  const toggleButton = expandContainer.querySelector('[aria-expanded]');
+  if (toggleButton && toggleButton instanceof HTMLElement) {
+    return toggleButton.getAttribute('aria-expanded') === 'false';
+  }
+
+  // Fallback: check if content div is hidden using the actual class name
+  const contentDiv = expandContainer.querySelector('.ak-editor-expand__content');
+  if (contentDiv && contentDiv instanceof HTMLElement) {
+    const computedStyle = window.getComputedStyle(contentDiv);
+    return computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || contentDiv.hidden;
+  }
+  return false;
+};
+
+/**
+ * Expand a collapsed expand node by clicking its toggle button.
+ *
+ * This function finds the toggle button with aria-expanded="false" and programmatically
+ * clicks it to expand the node. It does not wait for the expansion to complete.
+ *
+ * @param expandContainer - The expand container element.
+ * @returns True if the toggle button was found and clicked, false otherwise.
+ */
+export const expandElement = expandContainer => {
+  // Find and click the toggle button
+  const toggleButton = expandContainer.querySelector('[aria-expanded="false"]');
+  if (toggleButton && toggleButton instanceof HTMLElement) {
+    toggleButton.click();
+    return true;
+  }
+  return false;
+};
+
 /**
  * Expand all parent expands then scroll to the element.
  *
@@ -210,11 +268,36 @@ export const expandAllParentsThenScroll = (element, attempt = 0, scrollFn) => {
   }
   return cleanup;
 };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { SCROLL_TO_BLOCK_TIMING } from './SCROLL_TO_BLOCK_TIMING';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isExpandCollapsed } from './isExpandCollapsed';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { expandElement } from './expandElement';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getLocalIdSelector } from './getLocalIdSelector';
+export const getLocalIdSelector = (localId, container) => {
+  // Check if the element with data-local-id exists
+  let element = container.querySelector(`[data-local-id="${localId}"]`);
+  if (element) {
+    return element;
+  }
+
+  // Special case for decision lists and task lists which already have localId
+  element = container.querySelector(`[data-decision-list-local-id="${localId}"]`);
+  if (element) {
+    return element;
+  }
+  element = container.querySelector(`[data-task-list-local-id="${localId}"]`);
+  if (element) {
+    return element;
+  }
+
+  // Special case for tables which use data-table-local-id
+  element = container.querySelector(`[data-table-local-id="${localId}"]`);
+  if (element) {
+    if (fg('platform_editor_block_menu_v2_patch_4')) {
+      return element.parentElement; // return table wrapper instead of table div, so the height calculation is correct
+    }
+    return element;
+  }
+
+  // Special case for extension, smart cards and media which use lowercase localid
+  element = container.querySelector(`[localid="${localId}"]`);
+  if (element) {
+    return element;
+  }
+  return null;
+};

package/dist/es2019/card/index.js

@@ -1,13 +1,10 @@
 // Disable no-re-export rule for entry point files
 /* eslint-disable @atlaskit/editor/no-re-export */
 
-export { addLinkMetadata } from './addLinkMetadata';
-export { getLinkMetadataFromTransaction } from './getLinkMetadataFromTransaction';
-export { commandWithMetadata } from './utils';
+export { addLinkMetadata, getLinkMetadataFromTransaction, commandWithMetadata } from './utils';
 export { default as buildLayoutButtons, alignmentIcons, wrappingIcons, layoutToMessages, buildLayoutDropdown } from './MediaAndEmbedsToolbar';
 export { LinkToolbarButtonGroup } from './LinkToolbarButtonGroup';
-export { appearancePropsMap } from './appearancePropsMap';
-export { getButtonGroupOption } from './link-toolbar-button-group-options';
+export { appearancePropsMap, getButtonGroupOption } from './link-toolbar-button-group-options';
 export { getDropdownOption } from './link-toolbar-dropdown-options';
 export const DATASOURCE_INNER_CONTAINER_CLASSNAME = 'datasourceView-content-inner-wrap';
 export { IconCard } from './ui/assets/card';

package/dist/es2019/card/link-toolbar-button-group-options.js

@@ -1,4 +1,26 @@
-import { appearancePropsMap } from './appearancePropsMap';
+import MinusIcon from '@atlaskit/icon/core/minus';
+import SmartLinkCardIcon from '@atlaskit/icon/core/smart-link-card';
+import SmartLinkEmbedIcon from '@atlaskit/icon/core/smart-link-embed';
+import SmartLinkInlineIcon from '@atlaskit/icon/core/smart-link-inline';
+import { cardMessages as messages } from '../messages';
+export const appearancePropsMap = {
+  url: {
+    title: messages.urlTitle,
+    icon: MinusIcon
+  },
+  inline: {
+    title: messages.inlineTitle,
+    icon: SmartLinkInlineIcon
+  },
+  block: {
+    title: messages.blockTitle,
+    icon: SmartLinkCardIcon
+  },
+  embed: {
+    title: messages.embedTitle,
+    icon: SmartLinkEmbedIcon
+  }
+};
 export const getButtonGroupOption = (intl, areAnyNewToolbarFlagsEnabled, dispatchCommand, {
   disabled,
   onClick,
@@ -21,6 +43,4 @@ export const getButtonGroupOption = (intl, areAnyNewToolbarFlagsEnabled, dispatc
     selected,
     areAnyNewToolbarFlagsEnabled: areAnyNewToolbarFlagsEnabled
   };
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { appearancePropsMap } from './appearancePropsMap';
+};

package/dist/es2019/card/link-toolbar-dropdown-options.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { appearancePropsMap } from './appearancePropsMap';
+import { appearancePropsMap } from './link-toolbar-button-group-options';
 export const getDropdownOption = (intl, dispatchCommand, {
   disabled,
   onClick,

package/dist/es2019/card/utils.js

@@ -1,4 +1,33 @@
-import { addLinkMetadata } from './addLinkMetadata';
+import { LinkMetaStep } from '@atlaskit/adf-schema/steps';
+/**
+ * Records metadata about the user action and input method relating to a transaction
+ * as a custom LinkStepMetadata prosemirror step so that it is preserved in
+ * the history for undo/redo.
+ */
+export function addLinkMetadata(initialSelection, tr, metadata) {
+  const {
+    storedMarks
+  } = tr;
+  const pos = tr.mapping.map(initialSelection.$from.pos);
+  tr.step(new LinkMetaStep(pos, metadata));
+
+  // When you add a new step all the storedMarks are removed it
+  if (storedMarks) {
+    tr.setStoredMarks(storedMarks);
+  }
+  return tr;
+}
+export function getLinkMetadataFromTransaction(tr) {
+  return tr.steps.reduce((metadata, step) => {
+    if (!(step instanceof LinkMetaStep)) {
+      return metadata;
+    }
+    return {
+      ...metadata,
+      ...step.getMetadata()
+    };
+  }, {});
+}
 /**
  * Adds metadata to the transaction created from a command
  * The metadata describes the user intent and input method
@@ -14,8 +43,4 @@ export const commandWithMetadata = (command, metadata) => {
       dispatch(tr);
     }, view);
   };
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { addLinkMetadata } from './addLinkMetadata';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getLinkMetadataFromTransaction } from './getLinkMetadataFromTransaction';
+};

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

@@ -3,4 +3,5 @@
 
 export { insideTable } from './inside';
 export { getDocStructure } from './document-logger';
-export { isSSR } from './is-ssr';
+export { isSSR } from './is-ssr';
+export { isSSRStreaming } from './is-ssr-streaming';

package/dist/es2019/core-utils/is-ssr-streaming.js

@@ -0,0 +1,16 @@
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+/** Returns true if React SSR streaming is actually active at runtime. */
+export function isSSRStreaming() {
+  try {
+    var _process$env;
+    const isSSRRendered =
+    // In most places there is no document when running on server-side
+    // eslint-disable-next-line @atlaskit/platform/no-direct-document-usage
+    typeof document === 'undefined' || typeof process !== 'undefined' && ((_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.REACT_SSR) || typeof window !== 'undefined' && window.__SSR_RENDERED__ || globalThis.__SSR_RENDERED__;
+    const isSSRReactStreaming = typeof window !== 'undefined' && window.__SSR_REACT_STREAMING__ || globalThis.__SSR_REACT_STREAMING__;
+    return Boolean(isSSRRendered) && expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true) && Boolean(isSSRReactStreaming);
+  } catch {
+    // Catch possible error that might occur and just return false
+    return false;
+  }
+}

package/dist/es2019/element-browser/components/ElementList/ElementList.js

@@ -27,8 +27,7 @@ import useContainerWidth from '../../hooks/use-container-width';
 import useFocus from '../../hooks/use-focus';
 import { Modes } from '../../types';
 import EmptyState from './EmptyState';
-import { getColumnCount } from './getColumnCount';
-import { getScrollbarWidth } from './utils';
+import { getColumnCount, getScrollbarWidth } from './utils';
 export const ICON_HEIGHT = 40;
 export const ICON_WIDTH = 40;
 

package/dist/es2019/element-browser/components/ElementList/utils.js

@@ -1,5 +1,21 @@
-import { ELEMENT_LIST_PADDING, SCROLLBAR_WIDTH } from '../../constants';
-import { getColumnCount } from './getColumnCount';
+import { ELEMENT_LIST_PADDING, FLEX_ITEMS_CONTAINER_BREAKPOINT_NUMBERS, SCROLLBAR_WIDTH } from '../../constants';
+export function getColumnCount(clientWidth) {
+  const {
+    small,
+    medium,
+    large
+  } = FLEX_ITEMS_CONTAINER_BREAKPOINT_NUMBERS;
+  switch (true) {
+    case clientWidth < small:
+      return 1;
+    case clientWidth >= small && clientWidth < medium:
+      return Math.floor(clientWidth / 200);
+    case clientWidth >= large:
+      return Math.floor(clientWidth / 248);
+    default:
+      return Math.floor(clientWidth / 220);
+  }
+}
 export function generateVirtualizedContainerDatum(containerWidth, options) {
   const {
     scrollbarWidth
@@ -31,5 +47,4 @@ export function getScrollbarWidth() {
   } else {
     return CALCULATED_SCROLLBAR_WIDTH;
   }
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
+}

package/dist/es2019/element-browser/hooks/use-select-and-focus-on-arrow-navigation.js

@@ -1,46 +1,51 @@
 import { useCallback, useEffect, useReducer, useRef } from 'react';
 import { fg } from '@atlaskit/platform-feature-flags';
-import { ACTIONS } from './ACTIONS';
-import { ensureSafeIndex } from './ensureSafeIndex'; /**
-                                                     * a custom hook that handles keyboard navigation for Arrow keys based on a
-                                                     * given listSize, and a step (for up and down arrows).
-                                                     *
-                                                     * @param {number} listSize
-                                                     * @param {number} upDownStep
-                                                     *
-                                                     * Example usage:
-                                                     *    const list = ['Confluence','Jira','Atlaskit'];
-                                                     *    const {
-                                                     *      selectedItemIndex,
-                                                     *      focusedItemIndex,
-                                                     *      focusOnSearch,
-                                                     *      focusOnViewMore,
-                                                     *      setFocusedItemIndex,
-                                                     *      onKeyDown
-                                                     *    } = useSelectAndFocusOnArrowNavigation(list.length - 1, 1);
-                                                     *
-                                                     *    return (
-                                                     *      <div onKeyDown={onKeyDown}>
-                                                     *        <SearchBar onClick={() => setFocusedItemIndex(undefined)} focus={focusOnSearch} />
-                                                     *        {list.map((item, index) => (
-                                                     *           <ListItem
-                                                     *            title={item}
-                                                     *            style={{ ..., color: selected ? 'selectedStateColor' : defaultColor }}
-                                                     *            onClick={() => {
-                                                     *              setFocusedItemIndex(index);
-                                                     *            }
-                                                     *          />
-                                                     *        )}
-                                                     *      </div>
-                                                     *    );
-                                                     *
-                                                     *    const SearchBar = ({ focus }) => {
-                                                     *      const ref = useRefToFocusOrScroll(focus);
-                                                     *      return <input ref={ref} />
-                                                     *    }
-                                                     *
-                                                     */
+/**
+ * a custom hook that handles keyboard navigation for Arrow keys based on a
+ * given listSize, and a step (for up and down arrows).
+ *
+ * @param {number} listSize
+ * @param {number} upDownStep
+ *
+ * Example usage:
+ *    const list = ['Confluence','Jira','Atlaskit'];
+ *    const {
+ *      selectedItemIndex,
+ *      focusedItemIndex,
+ *      focusOnSearch,
+ *      focusOnViewMore,
+ *      setFocusedItemIndex,
+ *      onKeyDown
+ *    } = useSelectAndFocusOnArrowNavigation(list.length - 1, 1);
+ *
+ *    return (
+ *      <div onKeyDown={onKeyDown}>
+ *        <SearchBar onClick={() => setFocusedItemIndex(undefined)} focus={focusOnSearch} />
+ *        {list.map((item, index) => (
+ *           <ListItem
+ *            title={item}
+ *            style={{ ..., color: selected ? 'selectedStateColor' : defaultColor }}
+ *            onClick={() => {
+ *              setFocusedItemIndex(index);
+ *            }
+ *          />
+ *        )}
+ *      </div>
+ *    );
+ *
+ *    const SearchBar = ({ focus }) => {
+ *      const ref = useRefToFocusOrScroll(focus);
+ *      return <input ref={ref} />
+ *    }
+ *
+ */
 
+export let ACTIONS = /*#__PURE__*/function (ACTIONS) {
+  ACTIONS["FOCUS_SEARCH"] = "focusOnSearch";
+  ACTIONS["UPDATE_STATE"] = "updateState";
+  ACTIONS["MOVE"] = "move";
+  return ACTIONS;
+}({});
 const reducer = (state, action) => {
   switch (action.type) {
     case ACTIONS.UPDATE_STATE:
@@ -407,6 +412,13 @@ function useSelectAndFocusOnArrowNavigation(listSize, step, canFocusViewMore, it
     setFocusedCategoryIndex: setFocusedCategoryIndex
   };
 }
-export default useSelectAndFocusOnArrowNavigation;
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-// eslint-disable-next-line @atlaskit/editor/no-re-export
+export const ensureSafeIndex = (index, listSize) => {
+  if (index < 0) {
+    return 0;
+  }
+  if (index > listSize) {
+    return listSize;
+  }
+  return index;
+};
+export default useSelectAndFocusOnArrowNavigation;

package/dist/es2019/experiences/ExperienceCheckPopupMutation.js

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { getDocument } from '@atlaskit/browser-apis';
 import { EXPERIENCE_FAILURE_REASON } from './consts';
-import { popupWithNestedElement } from './popupWithNestedElement';
+import { popupWithNestedElement } from './experience-utils';
 const PORTAL_CONTAINER_SELECTOR = 'body > .atlaskit-portal-container';
 
 /**

package/dist/es2019/experiences/experience-state.js

@@ -1,4 +1,14 @@
-import { EXPERIENCE_STATE_TRANSITIONS } from './EXPERIENCE_STATE_TRANSITIONS';
+/**
+ * State transition map defining valid state transitions.
+ */
+export const EXPERIENCE_STATE_TRANSITIONS = {
+  pending: ['started'],
+  started: ['aborted', 'failed', 'succeeded'],
+  aborted: ['started'],
+  failed: ['started'],
+  succeeded: ['started']
+};
+
 /**
  * Validates whether a state transition is allowed.
  *

package/dist/es2019/experiences/experience-utils.js

@@ -1,10 +1,109 @@
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getSelectionAncestorDOM } from './getSelectionAncestorDOM';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { containsPopupWithNestedElement } from './containsPopupWithNestedElement';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { popupWithNestedElement } from './popupWithNestedElement';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getPopupContainerFromEditorView } from './getPopupContainerFromEditorView';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getNodeQuery } from './getNodeQuery';
+/**
+ * Finds the direct child of the ProseMirror root element that contains the current selection.
+ *
+ * Starting from the DOM node at the selection position, this function walks up the DOM tree
+ * until it reaches the ProseMirror root, then returns the last element before the root
+ * (i.e., the second top-level ancestor).
+ *
+ * This is useful for attaching MutationObservers to the narrowest subtree that contains
+ * the selection, while still capturing all relevant mutations within that branch.
+ *
+ * @param editorView - The ProseMirror EditorView instance
+ * @returns The direct child of PM root containing the selection, or null if not found
+ */
+export const getSelectionAncestorDOM = editorView => {
+  if (!editorView) {
+    return null;
+  }
+  const pmDom = editorView.dom;
+  const {
+    selection
+  } = editorView.state;
+
+  // nodeDOM can return null when editor loses focus (e.g. toolbar click) or for certain positions.
+  // Fall back to domAtPos which resolves the DOM node at the given position.
+  let currentNode = editorView.nodeDOM(selection.from);
+  if (!currentNode) {
+    try {
+      const {
+        node
+      } = editorView.domAtPos(selection.from);
+      currentNode = node instanceof HTMLElement ? node : node.parentElement;
+    } catch {
+      return null;
+    }
+  }
+  let lastValidAncestor = currentNode;
+  while (currentNode instanceof HTMLElement && currentNode !== pmDom) {
+    lastValidAncestor = currentNode;
+    currentNode = currentNode.parentElement;
+  }
+  return lastValidAncestor instanceof HTMLElement ? lastValidAncestor : null;
+};
+
+/**
+ * Checks if a given node contains a popup with a nested element identified by a specific test ID.
+ *
+ * @param node - The node to check.
+ * @param nestedElementQuery - The query to look for the nested element.
+ * @returns True if the node contains the popup, false otherwise.
+ */
+export const containsPopupWithNestedElement = (node, nestedElementQuery) => {
+  if (!(node instanceof HTMLElement)) {
+    return false;
+  }
+
+  // Check if node itself has the popup attribute and contains the element matching the nestedElementQuery
+  if (node.matches('[data-editor-popup="true"]')) {
+    return !!node.querySelector(nestedElementQuery);
+  }
+
+  // Check if any direct child with popup attribute contains the element matching the nestedElementQuery
+  return !!node.querySelector(`:scope > [data-editor-popup="true"] ${nestedElementQuery}`);
+};
+
+/**
+ * Returns the popup with a nested element identified by a specific test ID if it exists.
+ *
+ * @param node - The node to check.
+ * @param nestedElementQuery - The query to look for the nested element.
+ * @returns Element if the node contains the popup, undefined otherwise.
+ */
+export const popupWithNestedElement = (node, nestedElementQuery) => {
+  if (!(node instanceof HTMLElement)) {
+    return undefined;
+  }
+
+  // Check if node itself has the popup attribute and contains the element matching the nestedElementQuery
+  if (node.matches('[data-editor-popup="true"]')) {
+    return node.querySelector(nestedElementQuery);
+  }
+
+  // Check if any direct child with popup attribute contains the element matching the nestedElementQuery
+  return node.querySelector(`:scope > [data-editor-popup="true"] ${nestedElementQuery}`);
+};
+
+/**
+ * Searches for the popup container element relative to the provided editor view element.
+ *
+ * @param editorViewEl - The editor view HTMLElement.
+ * @returns The popup container HTMLElement if found, otherwise undefined.
+ */
+export const getPopupContainerFromEditorView = editorViewEl => {
+  const editorContentArea = editorViewEl === null || editorViewEl === void 0 ? void 0 : editorViewEl.closest('.ak-editor-content-area');
+  const pluginsComponentsWrapper = editorContentArea === null || editorContentArea === void 0 ? void 0 : editorContentArea.querySelector(':scope > [data-testid="plugins-components-wrapper"]');
+  return pluginsComponentsWrapper || undefined;
+};
+
+/**
+ * Checks if a node matches or contains the node given by the provided query css selector
+ *
+ * @param query - CSS selector string
+ * @returns true if node matches or contains query or false otherwise
+ */
+export const getNodeQuery = query => node => {
+  if (!node || !(node instanceof Element)) {
+    return false;
+  }
+  return node.matches(query) || node.querySelector(query) !== null;
+};

package/dist/es2019/experiences/index.js

@@ -7,8 +7,4 @@ export { ExperienceCheckComposite } from './ExperienceCheckComposite';
 export { ExperienceCheckDomMutation } from './ExperienceCheckDomMutation';
 export { ExperienceCheckPopupMutation } from './ExperienceCheckPopupMutation';
 export { ExperienceCheckTimeout } from './ExperienceCheckTimeout';
-export { containsPopupWithNestedElement } from './containsPopupWithNestedElement';
-export { getNodeQuery } from './getNodeQuery';
-export { getPopupContainerFromEditorView } from './getPopupContainerFromEditorView';
-export { getSelectionAncestorDOM } from './getSelectionAncestorDOM';
-export { popupWithNestedElement } from './popupWithNestedElement';
+export { containsPopupWithNestedElement, popupWithNestedElement, getPopupContainerFromEditorView, getNodeQuery, getSelectionAncestorDOM } from './experience-utils';

package/dist/es2019/extensibility/ExtensionSSRReactContextsProvider.js

@@ -1,12 +1,12 @@
 import React from 'react';
 import { RawIntlProvider } from 'react-intl';
-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';
 export function ExtensionSSRReactContextsProvider({
   children,
   intl
 }) {
-  if (!expValEquals('platform_editor_editor_ssr_streaming', 'isEnabled', true) || !isSSR()) {
+  if (!isSSR() || !isSSRStreaming()) {
     return children;
   }
   if (!intl) {

package/dist/es2019/extensibility/MultiBodiedExtension/action-api.js

@@ -118,6 +118,48 @@ export const useMultiBodiedExtensionActions = ({
         }
         return true;
       },
+      reorderChildren(fromIndex, toIndex) {
+        const pos = getPos();
+        if (typeof pos !== 'number' || typeof fromIndex !== 'number' || typeof toIndex !== 'number') {
+          throw new Error('Position or index not valid');
+        }
+        if (fromIndex === toIndex) {
+          return true;
+        }
+        const {
+          state,
+          dispatch
+        } = editorView;
+
+        // Use current node from state (not stale closure)
+        const currentNode = state.doc.nodeAt(pos);
+        if (!currentNode) {
+          throw new Error('Could not find extension node');
+        }
+        const $pos = state.doc.resolve(pos);
+        const $startNodePos = state.doc.resolve($pos.start($pos.depth + 1));
+
+        // Collect all current frame nodes
+        const frames = [];
+        currentNode.content.forEach(child => {
+          frames.push(child);
+        });
+        if (fromIndex >= frames.length || toIndex >= frames.length) {
+          throw new Error('Index out of bounds');
+        }
+
+        // Reorder the frames array in memory
+        const [removed] = frames.splice(fromIndex, 1);
+        frames.splice(toIndex, 0, removed);
+
+        // Atomically replace the entire MBE content with reordered frames
+        const tr = state.tr;
+        const containerStart = $startNodePos.pos;
+        const containerEnd = containerStart + currentNode.content.size;
+        tr.replaceWith(containerStart, containerEnd, frames);
+        dispatch(tr);
+        return true;
+      },
       updateParameters(parameters) {
         const {
           state,

package/dist/es2019/extensions/default-extension-provider.js

@@ -1,5 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { getAutoConvertPatternsFromModule } from './getAutoConvertPatternsFromModule';
+import { getAutoConvertPatternsFromModule } from './module-helpers';
 export default class DefaultExtensionProvider {
   constructor(manifests,
   /**