@atlaskit/editor-plugin-block-menu 0.0.20 → 1.0.1

package/dist/es2019/editor-commands/transforms/list/transformBetweenListTypes.js

@@ -0,0 +1,98 @@
+/**
+ * Extract all inline content from a node
+ */
+const extractInlineContent = node => {
+  const inlineContent = [];
+  for (let i = 0; i < node.childCount; i++) {
+    inlineContent.push(node.child(i));
+  }
+  return inlineContent;
+};
+
+/**
+ * Transform list structure
+ */
+export const transformListStructure = (tr, listNode, targetNodeType, nodes) => {
+  try {
+    const {
+      node: sourceList,
+      pos: listPos
+    } = listNode;
+    const {
+      bulletList,
+      orderedList,
+      taskList,
+      listItem,
+      taskItem,
+      paragraph
+    } = nodes;
+    const isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
+    const isTargetTask = targetNodeType === taskList;
+    const isSourceTask = sourceList.type === taskList;
+    const newListItems = [];
+    const listStart = listPos;
+    const listEnd = listPos + sourceList.nodeSize;
+
+    // Use nodesBetween to efficiently traverse the list structure
+    tr.doc.nodesBetween(listStart, listEnd, (node, pos, parent) => {
+      // Only process direct children of the list (depth 1)
+      if (parent !== sourceList) {
+        return true; // Continue traversal
+      }
+      if (isSourceBulletOrOrdered && isTargetTask) {
+        // Converting from bullet/ordered list to task list
+        // Extract inline content from all children within listItem
+        if (node.type === listItem) {
+          const inlineContent = [];
+
+          // Extract all inline content from all child nodes
+          for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child.type === paragraph) {
+              // Extract inline content from paragraphs
+              inlineContent.push(...extractInlineContent(child));
+            } else if (child.isBlock) {
+              // For other block content types eg. codeBlock, extract their text content and create text nodes
+              const textContent = child.textContent;
+              if (textContent) {
+                const textNode = tr.doc.type.schema.text(textContent);
+                inlineContent.push(textNode);
+              }
+            } else {
+              // Already inline content, add directly
+              inlineContent.push(child);
+            }
+          }
+          if (inlineContent.length > 0) {
+            const newItem = taskItem.create(null, inlineContent);
+            newListItems.push(newItem);
+          }
+        }
+      } else if (isSourceTask && !isTargetTask) {
+        // Converting from task list to bullet/ordered list
+        // Structure: taskItem > inline content -> listItem > paragraph > inline content
+        if (node.type === taskItem) {
+          const inlineContent = extractInlineContent(node);
+          if (inlineContent.length > 0) {
+            const paragraphNode = paragraph.create(null, inlineContent);
+            const newListItem = listItem.create(null, paragraphNode);
+            newListItems.push(newListItem);
+          }
+        }
+      }
+      return false; // Don't traverse into children of list items
+    });
+    if (newListItems.length === 0) {
+      return tr;
+    }
+
+    // Create new list with transformed items
+    const newList = targetNodeType.create(null, newListItems);
+
+    // Replace the entire list
+    tr.replaceWith(listStart, listEnd, newList);
+    return tr;
+  } catch {
+    return tr;
+  }
+};

package/dist/es2019/editor-commands/transforms/list-transforms.js

@@ -1,16 +1,17 @@
 import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
 import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { transformListStructure } from './list/transformBetweenListTypes';
 import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
 
 /**
  * Transform selection to list type
  */
-export const transformToList = ({
-  tr,
-  targetNodeType,
-  targetAttrs
-}) => {
-  // Wrap selection in list of target type
+export const transformBlockToList = context => {
+  const {
+    tr,
+    targetNodeType,
+    targetAttrs
+  } = context;
   const {
     $from,
     $to
@@ -19,13 +20,32 @@ export const transformToList = ({
   if (!range) {
     return null;
   }
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  const isTargetTask = targetNodeType === nodes.taskList;
+
+  // Handle task lists differently due to their structure
+  // TODO: ED-29152 - Implement task list transformation
+  if (isTargetTask) {
+    return null;
+  }
+
+  // For headings, convert to paragraph first since headings cannot be direct children of list items
+  const sourceNode = tr.doc.nodeAt(range.start);
+  if (sourceNode && sourceNode.type.name.startsWith('heading')) {
+    tr.setBlockType(range.start, range.end, nodes.paragraph);
+  }
 
-  // Find if we can wrap the selection in the target list type
-  const wrapping = findWrapping(range, targetNodeType, targetAttrs);
+  // Get the current range (updated if we converted from heading)
+  const currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
+
+  // Wrap in the target list type
+  const wrapping = findWrapping(currentRange, targetNodeType, targetAttrs);
   if (!wrapping) {
     return null;
   }
-  tr.wrap(range, wrapping);
+  tr.wrap(currentRange, wrapping);
   return tr;
 };
 
@@ -77,16 +97,30 @@ export const transformBetweenListTypes = ({
     nodes
   } = tr.doc.type.schema;
 
-  // Find the list node
-  const listNode = findParentNodeOfType([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
+  // Find the list node - support bullet lists, ordered lists, and task lists
+  const supportedListTypes = [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean); // Filter out undefined nodes in case some schemas don't have all types
+
+  const listNode = findParentNodeOfType(supportedListTypes)(selection);
   if (!listNode) {
     return null;
   }
+  const sourceListType = listNode.node.type;
+  const isSourceBulletOrOrdered = sourceListType === nodes.bulletList || sourceListType === nodes.orderedList;
+  const isTargetTask = targetNodeType === nodes.taskList;
+  const isSourceTask = sourceListType === nodes.taskList;
+  const isTargetBulletOrOrdered = targetNodeType === nodes.bulletList || targetNodeType === nodes.orderedList;
+
+  // Check if we need structure transformation
+  const needsStructureTransform = isSourceBulletOrOrdered && isTargetTask || isSourceTask && isTargetBulletOrOrdered;
   try {
-    // Change the list type while preserving content
-    tr.setNodeMarkup(listNode.pos, targetNodeType);
-    return tr;
-  } catch (e) {
+    if (!needsStructureTransform) {
+      // Simple type change for same structure lists (bullet <-> ordered)
+      tr.setNodeMarkup(listNode.pos, targetNodeType);
+    } else {
+      tr = transformListStructure(tr, listNode, targetNodeType, nodes);
+    }
+  } catch {
     return null;
   }
+  return tr;
 };

package/dist/es2019/editor-commands/transforms/utils.js

@@ -61,7 +61,7 @@ export const getTargetNodeInfo = (targetType, nodes) => {
           panelType: 'info'
         }
       };
-    case 'codeblock':
+    case 'codeBlock':
       return {
         nodeType: nodes.codeBlock
       };

package/dist/es2019/ui/block-menu-components.js

@@ -3,7 +3,6 @@ import { MOVE_UP_MENU_ITEM, MOVE_UP_DOWN_MENU_SECTION, MOVE_DOWN_MENU_ITEM, MOVE
 import { ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
 import ChangesIcon from '@atlaskit/icon/core/changes';
 import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
-import { fg } from '@atlaskit/platform-feature-flags';
 import CopyBlockMenuItem from './copy-block';
 import { CopyLinkDropdownItem } from './copy-link';
 import { DeleteDropdownItem } from './delete-button';
@@ -88,7 +87,7 @@ export const getBlockMenuComponents = ({
   api,
   config
 }) => {
-  return [...(fg('platform_editor_block_menu_format') ? getFormatMenuComponents() : []), {
+  return [...getFormatMenuComponents(), {
     type: 'block-menu-section',
     key: COPY_MENU_SECTION.key,
     rank: BLOCK_MENU_SECTION_RANK[COPY_MENU_SECTION.key],

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

@@ -21,19 +21,22 @@ export var formatNode = function formatNode(targetType) {
       nodePos = selectedNode.pos;
     } else {
       // Try to find parent node (including list parents)
-      var parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.layoutSection])(selection);
+      var parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.taskItem, nodes.layoutSection])(selection);
       if (parentNode) {
         nodeToFormat = parentNode.node;
         nodePos = parentNode.pos;
-
+        var paragraphOrHeadingNode = findParentNodeOfType([nodes.paragraph, nodes.heading])(selection);
         // Special case: if we found a listItem, check if we need the parent list instead
-        if (parentNode.node.type === nodes.listItem) {
+        if (parentNode.node.type === nodes.listItem || parentNode.node.type === nodes.taskItem) {
           var listParent = findParentNodeOfType([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
           if (listParent) {
             // For list transformations, we want the list parent, not the listItem
             nodeToFormat = listParent.node;
             nodePos = listParent.pos;
           }
+        } else if (paragraphOrHeadingNode) {
+          nodeToFormat = paragraphOrHeadingNode.node;
+          nodePos = paragraphOrHeadingNode.pos;
         }
       }
     }

package/dist/esm/editor-commands/transforms/block-transforms.js

@@ -1,32 +1,44 @@
 import { transformToContainer } from './container-transforms';
-import { transformToList } from './list-transforms';
+import { getInlineNodeTextContent } from './inline-node-transforms';
+import { transformBlockToList } from './list-transforms';
 import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
 
 /**
  * Transform block nodes (paragraph, heading, codeblock)
  */
 export var transformBlockNode = function transformBlockNode(context) {
-  var tr = context.tr,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs;
-  var selection = tr.selection;
-  var $from = selection.$from,
-    $to = selection.$to;
+  var targetNodeType = context.targetNodeType;
 
   // Handle transformation to list types
   if (isListNodeType(targetNodeType)) {
-    return transformToList(context);
+    return transformBlockToList(context);
   }
 
   // Handle transformation to container types (panel, expand, blockquote)
   if (isContainerNodeType(targetNodeType)) {
-    return transformToContainer();
+    return transformToContainer(context);
   }
 
   // Handle block type transformation (paragraph, heading, codeblock)
   if (isBlockNodeType(targetNodeType)) {
-    tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
-    return tr;
+    return transformToBlockNode(context);
   }
   return null;
+};
+var transformToBlockNode = function transformToBlockNode(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  var selection = tr.selection,
+    doc = tr.doc;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var schema = doc.type.schema;
+  if (targetNodeType === schema.nodes.codeBlock) {
+    var textContent = getInlineNodeTextContent(selection.content().content, tr);
+    var node = schema.nodes.codeBlock.createChecked(undefined, textContent);
+    return tr.replaceRangeWith(selection.from, selection.to, node);
+  }
+  tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
+  return tr;
 };

package/dist/esm/editor-commands/transforms/container-transforms.js

@@ -1,20 +1,52 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { isBlockNodeType, isListNodeType, isContainerNodeType } from './utils';
+var convertInvalidNodeToValidNodeType = function convertInvalidNodeToValidNodeType(sourceContent, sourceNodeType, validNodeType, withMarks) {
+  var validTransformedContent = [];
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(function (node) {
+    if (sourceNodeType === node.type) {
+      validTransformedContent.push(validNodeType.createChecked(node.attrs, node.content, withMarks ? node.marks : undefined));
+    } else {
+      validTransformedContent.push(node);
+    }
+  });
+  return Fragment.from(validTransformedContent);
+};
 
 /**
  * Transform selection to container type
  */
-export var transformToContainer = function transformToContainer() {
-  return null;
+export var transformToContainer = function transformToContainer(_ref) {
+  var tr = _ref.tr,
+    sourceNode = _ref.sourceNode,
+    targetNodeType = _ref.targetNodeType,
+    targetAttrs = _ref.targetAttrs;
+  var selection = tr.selection;
+  var schema = tr.doc.type.schema;
+  var content = selection.content().content;
+  var transformedContent = content;
+  if (sourceNode.type === schema.nodes.codeBlock) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.codeBlock, schema.nodes.paragraph);
+  }
+  if (targetNodeType === schema.nodes.blockquote) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
+  }
+  var newNode = targetNodeType.createAndFill(targetAttrs, transformedContent);
+  if (!newNode) {
+    return null;
+  }
+  tr.replaceRangeWith(selection.from, selection.to, newNode);
+  return tr;
 };
 
 /**
  * Transform container nodes (panel, expand, blockquote)
  */
-export var transformContainerNode = function transformContainerNode(_ref) {
-  var tr = _ref.tr,
-    sourcePos = _ref.sourcePos,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
+export var transformContainerNode = function transformContainerNode(_ref2) {
+  var tr = _ref2.tr,
+    sourcePos = _ref2.sourcePos,
+    targetNodeType = _ref2.targetNodeType,
+    targetAttrs = _ref2.targetAttrs;
   if (sourcePos === null) {
     return null;
   }

package/dist/esm/editor-commands/transforms/inline-node-transforms.js

@@ -0,0 +1,21 @@
+export var getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent, tr) {
+  var validTransformedContent = '';
+  var schema = tr.doc.type.schema;
+  if (sourceContent.content.length > 1) {
+    return;
+  }
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(function (node) {
+    if (['paragraph', 'heading'].includes(node.type.name)) {
+      node.content.forEach(function (inlineNode) {
+        if (inlineNode.type.name === 'status') {
+          validTransformedContent += inlineNode.attrs.text;
+        } else {
+          validTransformedContent += "".concat(inlineNode.textContent);
+        }
+      });
+      validTransformedContent;
+    }
+  });
+  return schema.text(validTransformedContent);
+};

package/dist/esm/editor-commands/transforms/list/transformBetweenListTypes.js

@@ -0,0 +1,95 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/**
+ * Extract all inline content from a node
+ */
+var extractInlineContent = function extractInlineContent(node) {
+  var inlineContent = [];
+  for (var i = 0; i < node.childCount; i++) {
+    inlineContent.push(node.child(i));
+  }
+  return inlineContent;
+};
+
+/**
+ * Transform list structure
+ */
+export var transformListStructure = function transformListStructure(tr, listNode, targetNodeType, nodes) {
+  try {
+    var sourceList = listNode.node,
+      listPos = listNode.pos;
+    var bulletList = nodes.bulletList,
+      orderedList = nodes.orderedList,
+      taskList = nodes.taskList,
+      listItem = nodes.listItem,
+      taskItem = nodes.taskItem,
+      paragraph = nodes.paragraph;
+    var isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
+    var isTargetTask = targetNodeType === taskList;
+    var isSourceTask = sourceList.type === taskList;
+    var newListItems = [];
+    var listStart = listPos;
+    var listEnd = listPos + sourceList.nodeSize;
+
+    // Use nodesBetween to efficiently traverse the list structure
+    tr.doc.nodesBetween(listStart, listEnd, function (node, pos, parent) {
+      // Only process direct children of the list (depth 1)
+      if (parent !== sourceList) {
+        return true; // Continue traversal
+      }
+      if (isSourceBulletOrOrdered && isTargetTask) {
+        // Converting from bullet/ordered list to task list
+        // Extract inline content from all children within listItem
+        if (node.type === listItem) {
+          var inlineContent = [];
+
+          // Extract all inline content from all child nodes
+          for (var i = 0; i < node.childCount; i++) {
+            var child = node.child(i);
+            if (child.type === paragraph) {
+              // Extract inline content from paragraphs
+              inlineContent.push.apply(inlineContent, _toConsumableArray(extractInlineContent(child)));
+            } else if (child.isBlock) {
+              // For other block content types eg. codeBlock, extract their text content and create text nodes
+              var textContent = child.textContent;
+              if (textContent) {
+                var textNode = tr.doc.type.schema.text(textContent);
+                inlineContent.push(textNode);
+              }
+            } else {
+              // Already inline content, add directly
+              inlineContent.push(child);
+            }
+          }
+          if (inlineContent.length > 0) {
+            var newItem = taskItem.create(null, inlineContent);
+            newListItems.push(newItem);
+          }
+        }
+      } else if (isSourceTask && !isTargetTask) {
+        // Converting from task list to bullet/ordered list
+        // Structure: taskItem > inline content -> listItem > paragraph > inline content
+        if (node.type === taskItem) {
+          var _inlineContent = extractInlineContent(node);
+          if (_inlineContent.length > 0) {
+            var paragraphNode = paragraph.create(null, _inlineContent);
+            var newListItem = listItem.create(null, paragraphNode);
+            newListItems.push(newListItem);
+          }
+        }
+      }
+      return false; // Don't traverse into children of list items
+    });
+    if (newListItems.length === 0) {
+      return tr;
+    }
+
+    // Create new list with transformed items
+    var newList = targetNodeType.create(null, newListItems);
+
+    // Replace the entire list
+    tr.replaceWith(listStart, listEnd, newList);
+    return tr;
+  } catch (_unused) {
+    return tr;
+  }
+};

package/dist/esm/editor-commands/transforms/list-transforms.js

@@ -1,15 +1,15 @@
 import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
 import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { transformListStructure } from './list/transformBetweenListTypes';
 import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
 
 /**
  * Transform selection to list type
  */
-export var transformToList = function transformToList(_ref) {
-  var tr = _ref.tr,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
-  // Wrap selection in list of target type
+export var transformBlockToList = function transformBlockToList(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
   var _tr$selection = tr.selection,
     $from = _tr$selection.$from,
     $to = _tr$selection.$to;
@@ -17,13 +17,30 @@ export var transformToList = function transformToList(_ref) {
   if (!range) {
     return null;
   }
+  var nodes = tr.doc.type.schema.nodes;
+  var isTargetTask = targetNodeType === nodes.taskList;
+
+  // Handle task lists differently due to their structure
+  // TODO: ED-29152 - Implement task list transformation
+  if (isTargetTask) {
+    return null;
+  }
+
+  // For headings, convert to paragraph first since headings cannot be direct children of list items
+  var sourceNode = tr.doc.nodeAt(range.start);
+  if (sourceNode && sourceNode.type.name.startsWith('heading')) {
+    tr.setBlockType(range.start, range.end, nodes.paragraph);
+  }
+
+  // Get the current range (updated if we converted from heading)
+  var currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
 
-  // Find if we can wrap the selection in the target list type
-  var wrapping = findWrapping(range, targetNodeType, targetAttrs);
+  // Wrap in the target list type
+  var wrapping = findWrapping(currentRange, targetNodeType, targetAttrs);
   if (!wrapping) {
     return null;
   }
-  tr.wrap(range, wrapping);
+  tr.wrap(currentRange, wrapping);
   return tr;
 };
 
@@ -62,22 +79,37 @@ export var liftListToBlockType = function liftListToBlockType() {
 /**
  * Transform between different list types
  */
-export var transformBetweenListTypes = function transformBetweenListTypes(_ref2) {
-  var tr = _ref2.tr,
-    targetNodeType = _ref2.targetNodeType;
-  var selection = tr.selection;
+export var transformBetweenListTypes = function transformBetweenListTypes(_ref) {
+  var tr = _ref.tr,
+    targetNodeType = _ref.targetNodeType;
+  var _tr = tr,
+    selection = _tr.selection;
   var nodes = tr.doc.type.schema.nodes;
 
-  // Find the list node
-  var listNode = findParentNodeOfType([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
+  // Find the list node - support bullet lists, ordered lists, and task lists
+  var supportedListTypes = [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean); // Filter out undefined nodes in case some schemas don't have all types
+
+  var listNode = findParentNodeOfType(supportedListTypes)(selection);
   if (!listNode) {
     return null;
   }
+  var sourceListType = listNode.node.type;
+  var isSourceBulletOrOrdered = sourceListType === nodes.bulletList || sourceListType === nodes.orderedList;
+  var isTargetTask = targetNodeType === nodes.taskList;
+  var isSourceTask = sourceListType === nodes.taskList;
+  var isTargetBulletOrOrdered = targetNodeType === nodes.bulletList || targetNodeType === nodes.orderedList;
+
+  // Check if we need structure transformation
+  var needsStructureTransform = isSourceBulletOrOrdered && isTargetTask || isSourceTask && isTargetBulletOrOrdered;
   try {
-    // Change the list type while preserving content
-    tr.setNodeMarkup(listNode.pos, targetNodeType);
-    return tr;
-  } catch (e) {
+    if (!needsStructureTransform) {
+      // Simple type change for same structure lists (bullet <-> ordered)
+      tr.setNodeMarkup(listNode.pos, targetNodeType);
+    } else {
+      tr = transformListStructure(tr, listNode, targetNodeType, nodes);
+    }
+  } catch (_unused) {
     return null;
   }
+  return tr;
 };

package/dist/esm/editor-commands/transforms/utils.js

@@ -61,7 +61,7 @@ export var getTargetNodeInfo = function getTargetNodeInfo(targetType, nodes) {
           panelType: 'info'
         }
       };
-    case 'codeblock':
+    case 'codeBlock':
       return {
         nodeType: nodes.codeBlock
       };

package/dist/esm/ui/block-menu-components.js

@@ -4,7 +4,6 @@ import { MOVE_UP_MENU_ITEM, MOVE_UP_DOWN_MENU_SECTION, MOVE_DOWN_MENU_ITEM, MOVE
 import { ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
 import ChangesIcon from '@atlaskit/icon/core/changes';
 import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
-import { fg } from '@atlaskit/platform-feature-flags';
 import CopyBlockMenuItem from './copy-block';
 import { CopyLinkDropdownItem } from './copy-link';
 import { DeleteDropdownItem } from './delete-button';
@@ -91,7 +90,7 @@ var getFormatMenuComponents = function getFormatMenuComponents() {
 export var getBlockMenuComponents = function getBlockMenuComponents(_ref4) {
   var api = _ref4.api,
     config = _ref4.config;
-  return [].concat(_toConsumableArray(fg('platform_editor_block_menu_format') ? getFormatMenuComponents() : []), [{
+  return [].concat(_toConsumableArray(getFormatMenuComponents()), [{
     type: 'block-menu-section',
     key: COPY_MENU_SECTION.key,
     rank: BLOCK_MENU_SECTION_RANK[COPY_MENU_SECTION.key],

package/dist/types/editor-commands/transforms/container-transforms.d.ts

@@ -1,8 +1,8 @@
-import type { TransformFunction } from './types';
+import type { TransformContext, TransformFunction } from './types';
 /**
  * Transform selection to container type
  */
-export declare const transformToContainer: () => null;
+export declare const transformToContainer: ({ tr, sourceNode, targetNodeType, targetAttrs, }: TransformContext) => import("prosemirror-state").Transaction | null;
 /**
  * Transform container nodes (panel, expand, blockquote)
  */

package/dist/types/editor-commands/transforms/inline-node-transforms.d.ts

@@ -0,0 +1,3 @@
+import type { Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const getInlineNodeTextContent: (sourceContent: Fragment, tr: Transaction) => import("prosemirror-model").Node | undefined;

package/dist/types/editor-commands/transforms/list/transformBetweenListTypes.d.ts

@@ -0,0 +1,9 @@
+import type { Node as PMNode, NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Transform list structure
+ */
+export declare const transformListStructure: (tr: Transaction, listNode: {
+    node: PMNode;
+    pos: number;
+}, targetNodeType: NodeType, nodes: Record<string, NodeType>) => Transaction;

package/dist/types/editor-commands/transforms/list-transforms.d.ts

@@ -1,14 +1,9 @@
-import type { NodeType } from '@atlaskit/editor-prosemirror/model';
 import type { Transaction } from '@atlaskit/editor-prosemirror/state';
 import type { TransformContext, TransformFunction } from './types';
 /**
  * Transform selection to list type
  */
-export declare const transformToList: ({ tr, targetNodeType, targetAttrs, }: {
-    targetAttrs?: Record<string, unknown>;
-    targetNodeType: NodeType;
-    tr: Transaction;
-}) => Transaction | null;
+export declare const transformBlockToList: (context: TransformContext) => Transaction | null;
 /**
  * Transform list nodes
  */