@atlaskit/editor-plugin-block-menu 1.0.12 → 2.0.0

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

@@ -0,0 +1,282 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
+import { getInlineNodeTextContent } from '../inline-node-transforms';
+import { transformListRecursively } from '../list/transformBetweenListTypes';
+import { getContentSupportChecker, getSupportedListTypesSet, isBlockNode, isBlockNodeForExtraction, isBlockNodeType, isBulletOrOrderedList, isContainerNode, isContainerNodeType, isHeadingOrParagraphNode, isListNode, isListNodeType, isTaskList } from '../utils';
+export var unwrapLayoutNodesToTextNodes = function unwrapLayoutNodesToTextNodes(context, finalTargetNodeType) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  var schema = tr.doc.type.schema || {};
+  var isValid = getContentSupportChecker(finalTargetNodeType);
+  var createTextNode = function createTextNode(node) {
+    var isTextNode = node.type.name === 'text';
+    if (isValid(node) && !isTextNode) {
+      return node;
+    }
+    return targetNodeType.createChecked(targetAttrs, isTextNode ? node : node.content, node.marks);
+  };
+  if (isBlockNode(sourceNode)) {
+    // code block acts like a container, we need to unwrap it
+    if (sourceNode.type === schema.nodes.codeBlock) {
+      var textNodes = sourceNode.textContent.split('\n').map(function (line) {
+        return targetNodeType.createChecked(undefined, line ? schema.text(line) : null);
+      });
+      return textNodes;
+    }
+    return [createTextNode(sourceNode)];
+  }
+  if (isContainerNode(sourceNode)) {
+    var _sourceNode$attrs;
+    var containerNodes = [];
+    if (sourceNode.type.name === 'expand' && (_sourceNode$attrs = sourceNode.attrs) !== null && _sourceNode$attrs !== void 0 && _sourceNode$attrs.title) {
+      containerNodes.push(createTextNode(schema.text(sourceNode.attrs.title)));
+    }
+    sourceNode.content.forEach(function (childNode) {
+      if (isHeadingOrParagraphNode(childNode)) {
+        containerNodes.push(createTextNode(childNode));
+        return;
+      }
+      containerNodes.push(childNode);
+    });
+    return containerNodes;
+  }
+  if (isListNode(sourceNode)) {
+    if (isBlockNodeType(finalTargetNodeType)) {
+      if (sourceNode.type.name === 'taskList') {
+        var taskItemsResult = findChildrenByType(sourceNode, schema.nodes.taskItem);
+        var taskItems = taskItemsResult.map(function (item) {
+          return item.node;
+        });
+        var taskItemFragments = taskItems.map(function (taskItem) {
+          return taskItem.content;
+        });
+        return taskItemFragments.map(function (fragment) {
+          return targetNodeType.createChecked(targetAttrs, fragment.content);
+        });
+      } else {
+        var paragraphs = findChildrenByType(sourceNode, schema.nodes.paragraph);
+        var paragraphNodes = paragraphs.map(function (paragraph) {
+          return paragraph.node;
+        });
+        if (targetNodeType === schema.nodes.heading) {
+          return paragraphNodes.map(function (paragraphNode) {
+            return targetNodeType.createChecked(targetAttrs, paragraphNode.content);
+          });
+        }
+        return paragraphNodes;
+      }
+    }
+    return [sourceNode];
+  }
+  return [sourceNode];
+};
+var transformToBlockNode = function transformToBlockNode(nodes, targetNodeType, schema) {
+  if (targetNodeType === schema.nodes.codeBlock) {
+    var newNodes = [];
+    nodes.forEach(function (node) {
+      if (node.isTextblock) {
+        var inlineTextContent = node.type === schema.nodes.codeBlock ? node.textContent : getInlineNodeTextContent(Fragment.from(node));
+
+        // For first node, add directly
+        if (newNodes.length === 0) {
+          newNodes.push({
+            canBeTransformed: true,
+            content: [inlineTextContent]
+          });
+        } else {
+          // Check if last node can also be transformed, if yes then append content
+          var lastItem = newNodes[newNodes.length - 1];
+          if (lastItem.canBeTransformed) {
+            newNodes[newNodes.length - 1] = {
+              content: [].concat(_toConsumableArray(lastItem.content), [inlineTextContent]),
+              canBeTransformed: true
+            };
+          } else {
+            newNodes.push({
+              content: [inlineTextContent],
+              canBeTransformed: true
+            });
+          }
+        }
+      } else {
+        // If not text block, then cannot be transformed
+        newNodes.push({
+          canBeTransformed: false,
+          content: node
+        });
+      }
+    });
+    return newNodes.map(function (_ref) {
+      var canBeTransformed = _ref.canBeTransformed,
+        content = _ref.content;
+      if (canBeTransformed) {
+        var text = content.join('\n');
+        if (text === '') {
+          return undefined;
+        }
+        return targetNodeType.createChecked(null, schema.text(text));
+      } else {
+        return content;
+      }
+    }).filter(Boolean);
+  }
+  return nodes;
+};
+var transformToContainerNode = function transformToContainerNode(nodes, targetNodeType) {
+  var newNodes = [];
+  var isNodeValid = getContentSupportChecker(targetNodeType);
+  nodes.forEach(function (node) {
+    // If the node is not supported then we append as is
+    if (isBlockNodeForExtraction(node)) {
+      newNodes.push({
+        node: node,
+        canBeTransformed: false
+      });
+    } else {
+      // Remove alignment marks as container nodes don't support them
+      var nodeWithValidAttrs = node.mark(node.marks.filter(function (mark) {
+        return mark.type.name !== 'alignment';
+      }));
+      var isSameNodeType = node.type === targetNodeType;
+
+      // If the node is not valid and not the same type, we cannot transform it
+      if (!isNodeValid(nodeWithValidAttrs) && !isSameNodeType) {
+        newNodes.push({
+          node: node,
+          canBeTransformed: false
+        });
+        return;
+      }
+      var _nodes = isSameNodeType ? node.content.content : [nodeWithValidAttrs];
+      if (newNodes.length === 0) {
+        newNodes.push({
+          node: _nodes,
+          canBeTransformed: true
+        });
+      } else {
+        var lastItem = newNodes[newNodes.length - 1];
+        if (lastItem.canBeTransformed) {
+          newNodes[newNodes.length - 1] = {
+            node: [].concat(_toConsumableArray(lastItem.node), _toConsumableArray(_nodes)),
+            canBeTransformed: true
+          };
+        } else {
+          newNodes.push({
+            node: _nodes,
+            canBeTransformed: true
+          });
+        }
+      }
+    }
+  });
+  return newNodes.map(function (_ref2) {
+    var node = _ref2.node,
+      canBeTransformed = _ref2.canBeTransformed;
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+export var transformToListNode = function transformToListNode(nodes, targetNodeType, schema) {
+  var isTargetTask = isTaskList(targetNodeType);
+  var listItems = [];
+  var listItemType = isTargetTask ? schema.nodes.taskItem : schema.nodes.listItem;
+  var isValid = getContentSupportChecker(listItemType);
+  nodes.forEach(function (node) {
+    // Append unsupported nodes as is
+    if (isBlockNodeForExtraction(node)) {
+      listItems.push({
+        canBeTransformed: false,
+        node: node
+      });
+    } else {
+      var newListItems;
+
+      // If the node is a list, we may need to transform it
+      if (isListNode(node)) {
+        var isSourceBulletOrOrdered = isBulletOrOrderedList(node.type);
+        var _isTargetTask = isTaskList(targetNodeType);
+        var isSourceTask = isTaskList(node.type);
+        var isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
+        var supportedListTypes = getSupportedListTypesSet(schema.nodes);
+        if (node.type === targetNodeType) {
+          // For the same list type, we can keep the structure
+          newListItems = node.content.content;
+        } else {
+          var newList = transformListRecursively({
+            isSourceBulletOrOrdered: isSourceBulletOrOrdered,
+            isSourceTask: isSourceTask,
+            isTargetBulletOrOrdered: isTargetBulletOrOrdered,
+            isTargetTask: _isTargetTask,
+            listNode: node,
+            schema: schema,
+            supportedListTypes: supportedListTypes,
+            targetNodeType: targetNodeType
+          });
+          newListItems = _toConsumableArray(newList.content.content);
+        }
+      } else if (isHeadingOrParagraphNode(node) || isValid(node)) {
+        if (isTargetTask) {
+          var inlineContent = _toConsumableArray(node.content.content);
+          if (inlineContent.length > 0) {
+            newListItems = [listItemType.create(null, inlineContent)];
+          }
+        } else {
+          newListItems = [listItemType.create(null, node)];
+        }
+      } else if (!isValid(node)) {
+        listItems.push({
+          canBeTransformed: false,
+          node: node
+        });
+      }
+      if (newListItems) {
+        if (listItems.length === 0) {
+          listItems.push({
+            canBeTransformed: true,
+            node: newListItems
+          });
+        } else {
+          var lastItem = listItems[listItems.length - 1];
+          if (lastItem.canBeTransformed) {
+            listItems[listItems.length - 1] = {
+              node: [].concat(_toConsumableArray(lastItem.node), _toConsumableArray(newListItems)),
+              canBeTransformed: true
+            };
+          } else {
+            listItems.push({
+              node: newListItems,
+              canBeTransformed: true
+            });
+          }
+        }
+      }
+    }
+  });
+  return listItems.map(function (_ref3) {
+    var node = _ref3.node,
+      canBeTransformed = _ref3.canBeTransformed;
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+export var convertUnwrappedLayoutContent = function convertUnwrappedLayoutContent(nodes, targetNodeType, schema) {
+  if (isBlockNodeType(targetNodeType)) {
+    return transformToBlockNode(nodes, targetNodeType, schema);
+  }
+  if (isContainerNodeType(targetNodeType)) {
+    return transformToContainerNode(nodes, targetNodeType);
+  }
+  if (isListNodeType(targetNodeType)) {
+    return transformToListNode(nodes, targetNodeType, schema);
+  }
+  return [];
+};

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

@@ -1,5 +1,7 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH } from '@atlaskit/editor-common/styles';
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { convertUnwrappedLayoutContent, unwrapLayoutNodesToTextNodes } from './layout/utils';
 export var convertToLayout = function convertToLayout(context) {
   var tr = context.tr,
     sourceNode = context.sourceNode,
@@ -19,6 +21,41 @@ export var convertToLayout = function convertToLayout(context) {
   var layoutSectionNode = layoutSection.createChecked(undefined, layoutContent);
 
   // Replace the original node with the new layout node
-  tr.replaceRangeWith(sourcePos || 0, (sourcePos || 0) + sourceNode.nodeSize, layoutSectionNode);
+  tr.replaceRangeWith(sourcePos, sourcePos + sourceNode.nodeSize, layoutSectionNode);
   return tr;
+};
+export var transformLayoutNode = function transformLayoutNode(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    targetNodeType = context.targetNodeType,
+    sourcePos = context.sourcePos,
+    targetAttrs = context.targetAttrs;
+  var schema = tr.doc.type.schema || {};
+  var _ref2 = schema.nodes || {},
+    layoutSection = _ref2.layoutSection,
+    layoutColumn = _ref2.layoutColumn,
+    paragraph = _ref2.paragraph,
+    heading = _ref2.heading;
+  var layoutColumnNodes = [];
+  var targetTextNodeType = targetNodeType === heading ? heading : paragraph;
+  sourceNode.children.forEach(function (child) {
+    if (child.type === layoutColumn) {
+      var unwrappedContent = [];
+      child.content.forEach(function (node) {
+        // Unwrap all nodes and convert to text nodes
+        var context = {
+          tr: tr,
+          sourceNode: node,
+          targetNodeType: targetTextNodeType,
+          sourcePos: 0,
+          targetAttrs: targetAttrs
+        };
+        var newContent = unwrapLayoutNodesToTextNodes(context, targetNodeType);
+        unwrappedContent.push.apply(unwrappedContent, _toConsumableArray(newContent));
+      });
+      var newColumnContent = convertUnwrappedLayoutContent(unwrappedContent, targetNodeType, schema);
+      layoutColumnNodes.push(layoutColumn.createChecked(child.attrs, Fragment.fromArray(newColumnContent), child.marks));
+    }
+  });
+  return tr.replaceRangeWith(sourcePos, sourcePos + sourceNode.nodeSize, layoutSection.createChecked(sourceNode.attrs, Fragment.fromArray(layoutColumnNodes), sourceNode.marks));
 };

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

@@ -1,4 +1,7 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { getSupportedListTypesSet, isBulletOrOrderedList, isTaskList } from '../utils';
 
 /**
@@ -15,10 +18,87 @@ var convertBlockToInlineContent = function convertBlockToInlineContent(node, sch
   }
   return [node];
 };
+var _transformListRecursively = function transformListRecursively(props) {
+  var transformedItems = [];
+  var listNode = props.listNode,
+    isSourceBulletOrOrdered = props.isSourceBulletOrOrdered,
+    isTargetBulletOrOrdered = props.isTargetBulletOrOrdered,
+    isSourceTask = props.isSourceTask,
+    isTargetTask = props.isTargetTask,
+    supportedListTypes = props.supportedListTypes,
+    schema = props.schema,
+    targetNodeType = props.targetNodeType;
+  var _schema$nodes = schema.nodes,
+    taskList = _schema$nodes.taskList,
+    listItem = _schema$nodes.listItem,
+    taskItem = _schema$nodes.taskItem,
+    paragraph = _schema$nodes.paragraph;
+  listNode.forEach(function (child) {
+    if (isSourceBulletOrOrdered && isTargetTask) {
+      // Convert bullet/ordered => task
+      if (child.type === listItem) {
+        var inlineContent = [];
+        var nestedTaskLists = [];
+        child.forEach(function (grandChild) {
+          if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
+            nestedTaskLists.push(_transformListRecursively(_objectSpread(_objectSpread({}, props), {}, {
+              listNode: grandChild
+            })));
+          } else {
+            inlineContent.push.apply(inlineContent, _toConsumableArray(convertBlockToInlineContent(grandChild, schema)));
+          }
+        });
+        if (inlineContent.length > 0) {
+          transformedItems.push(taskItem.create(null, inlineContent));
+        }
+        transformedItems.push.apply(transformedItems, nestedTaskLists);
+      }
+    } else if (isSourceTask && isTargetBulletOrOrdered) {
+      // Convert task => bullet/ordered
+      if (child.type === taskItem) {
+        var _inlineContent = _toConsumableArray(child.content.content);
+        if (_inlineContent.length > 0) {
+          var paragraphNode = paragraph.create(null, _inlineContent);
+          transformedItems.push(listItem.create(null, [paragraphNode]));
+        }
+      } else if (child.type === taskList) {
+        var transformedNestedList = _transformListRecursively(_objectSpread(_objectSpread({}, props), {}, {
+          listNode: child
+        }));
+        var lastItem = transformedItems[transformedItems.length - 1];
+        if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
+          // Attach nested list to previous item
+          var updatedContent = [].concat(_toConsumableArray(lastItem.content.content), [transformedNestedList]);
+          transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
+        } else {
+          // No previous item, flatten nested items
+          transformedItems.push.apply(transformedItems, _toConsumableArray(transformedNestedList.content.content));
+        }
+      }
+    } else if (isSourceBulletOrOrdered && isTargetBulletOrOrdered) {
+      if (child.type === listItem) {
+        var convertedNestedLists = [];
+        child.forEach(function (grandChild) {
+          if (supportedListTypes.has(grandChild.type) && grandChild.type !== targetNodeType) {
+            var convertedNode = _transformListRecursively(_objectSpread(_objectSpread({}, props), {}, {
+              listNode: grandChild
+            }));
+            convertedNestedLists.push(convertedNode);
+          } else {
+            convertedNestedLists.push(grandChild);
+          }
+        });
+        transformedItems.push(listItem.create(null, convertedNestedLists));
+      }
+    }
+  });
+  return targetNodeType.create(null, transformedItems);
+};
 
 /**
  * Transform list structure between different list types
  */
+export { _transformListRecursively as transformListRecursively };
 export var transformListStructure = function transformListStructure(context) {
   var tr = context.tr,
     sourceNode = context.sourceNode,
@@ -32,60 +112,23 @@ export var transformListStructure = function transformListStructure(context) {
     };
     var sourceList = listNode.node,
       listPos = listNode.pos;
-    var taskList = nodes.taskList,
-      listItem = nodes.listItem,
-      taskItem = nodes.taskItem,
-      paragraph = nodes.paragraph;
+    // const { taskList, listItem, taskItem, paragraph } = nodes;
+
     var isSourceBulletOrOrdered = isBulletOrOrderedList(sourceList.type);
     var isTargetTask = isTaskList(targetNodeType);
     var isSourceTask = isTaskList(sourceList.type);
     var isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
     var supportedListTypes = getSupportedListTypesSet(nodes);
-    var _transformListRecursively = function transformListRecursively(listNode) {
-      var transformedItems = [];
-      listNode.forEach(function (child) {
-        if (isSourceBulletOrOrdered && isTargetTask) {
-          // Convert bullet/ordered => task
-          if (child.type === listItem) {
-            var inlineContent = [];
-            var nestedTaskLists = [];
-            child.forEach(function (grandChild) {
-              if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
-                nestedTaskLists.push(_transformListRecursively(grandChild));
-              } else {
-                inlineContent.push.apply(inlineContent, _toConsumableArray(convertBlockToInlineContent(grandChild, tr.doc.type.schema)));
-              }
-            });
-            if (inlineContent.length > 0) {
-              transformedItems.push(taskItem.create(null, inlineContent));
-            }
-            transformedItems.push.apply(transformedItems, nestedTaskLists);
-          }
-        } else if (isSourceTask && isTargetBulletOrOrdered) {
-          // Convert task => bullet/ordered
-          if (child.type === taskItem) {
-            var _inlineContent = _toConsumableArray(child.content.content);
-            if (_inlineContent.length > 0) {
-              var paragraphNode = paragraph.create(null, _inlineContent);
-              transformedItems.push(listItem.create(null, [paragraphNode]));
-            }
-          } else if (child.type === taskList) {
-            var transformedNestedList = _transformListRecursively(child);
-            var lastItem = transformedItems[transformedItems.length - 1];
-            if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
-              // Attach nested list to previous item
-              var updatedContent = [].concat(_toConsumableArray(lastItem.content.content), [transformedNestedList]);
-              transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
-            } else {
-              // No previous item, flatten nested items
-              transformedItems.push.apply(transformedItems, _toConsumableArray(transformedNestedList.content.content));
-            }
-          }
-        }
-      });
-      return targetNodeType.create(null, transformedItems);
-    };
-    var newList = _transformListRecursively(sourceList);
+    var newList = _transformListRecursively({
+      isSourceBulletOrOrdered: isSourceBulletOrOrdered,
+      isSourceTask: isSourceTask,
+      isTargetBulletOrOrdered: isTargetBulletOrOrdered,
+      isTargetTask: isTargetTask,
+      listNode: sourceList,
+      schema: tr.doc.type.schema,
+      supportedListTypes: supportedListTypes,
+      targetNodeType: targetNodeType
+    });
     tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch (_unused) {

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

@@ -1,8 +1,8 @@
 import { transformBlockNode } from './block-transforms';
 import { transformContainerNode, unwrapAndConvertToList } from './container-transforms';
-import { convertToLayout } from './layout-transforms';
+import { convertToLayout, transformLayoutNode } from './layout-transforms';
 import { transformListNode } from './list-transforms';
-import { getTargetNodeInfo, isBlockNode, isListNode, isListNodeType, isContainerNode, isLayoutNodeType } from './utils';
+import { getTargetNodeInfo, isBlockNode, isListNode, isListNodeType, isContainerNode, isLayoutNodeType, isLayoutNode } from './utils';
 export function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
   var nodes = tr.doc.type.schema.nodes;
   var targetNodeInfo = getTargetNodeInfo(targetType, nodes);
@@ -46,6 +46,9 @@ export function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType)
     if (sourceNode.type.name === 'codeBlock' && isListNodeType(targetNodeType)) {
       return unwrapAndConvertToList(transformationContext);
     }
+    if (isLayoutNode(sourceNode)) {
+      return transformLayoutNode(transformationContext);
+    }
     if (isBlockNode(sourceNode)) {
       return transformBlockNode(transformationContext);
     }

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

@@ -91,6 +91,9 @@ export var getTargetNodeInfo = function getTargetNodeInfo(targetType, nodes) {
 export var isBlockNode = function isBlockNode(node) {
   return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
 };
+export var isHeadingOrParagraphNode = function isHeadingOrParagraphNode(node) {
+  return ['paragraph', 'heading'].includes(node.type.name);
+};
 export var isListNode = function isListNode(node) {
   return ['bulletList', 'orderedList', 'taskList'].includes(node.type.name);
 };
@@ -123,6 +126,9 @@ export var getSupportedListTypesSet = function getSupportedListTypesSet(nodes) {
 export var isLayoutNodeType = function isLayoutNodeType(nodeType) {
   return nodeType.name === 'layoutSection';
 };
+export var isLayoutNode = function isLayoutNode(node) {
+  return node.type.name === 'layoutSection';
+};
 
 /**
  * Check if a node should be extracted as a standalone block node

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

@@ -1,3 +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;
+import type { Fragment, Schema } from '@atlaskit/editor-prosemirror/model';
+export declare const getInlineNodeTextContent: (sourceContent: Fragment) => string;
+export declare const getInlineNodeTextNode: (sourceContent: Fragment, schema: Schema) => import("prosemirror-model").Node;

package/dist/types/editor-commands/transforms/layout/utils.d.ts

@@ -0,0 +1,5 @@
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { TransformContext } from '../types';
+export declare const unwrapLayoutNodesToTextNodes: (context: TransformContext, finalTargetNodeType: NodeType) => PMNode[];
+export declare const transformToListNode: (nodes: PMNode[], targetNodeType: NodeType, schema: Schema) => PMNode[];
+export declare const convertUnwrappedLayoutContent: (nodes: PMNode[], targetNodeType: NodeType, schema: Schema) => PMNode[];

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

@@ -1,2 +1,3 @@
 import type { TransformContext } from './types';
 export declare const convertToLayout: (context: TransformContext) => import("prosemirror-state").Transaction;
+export declare const transformLayoutNode: (context: TransformContext) => import("prosemirror-state").Transaction;

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

@@ -1,5 +1,18 @@
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
 import type { TransformContext } from '../types';
+type TransformListRecursivelyProps = {
+    isSourceBulletOrOrdered: boolean;
+    isSourceTask: boolean;
+    isTargetBulletOrOrdered: boolean;
+    isTargetTask: boolean;
+    listNode: PMNode;
+    schema: Schema;
+    supportedListTypes: Set<NodeType>;
+    targetNodeType: NodeType;
+};
+export declare const transformListRecursively: (props: TransformListRecursivelyProps) => PMNode;
 /**
  * Transform list structure between different list types
  */
 export declare const transformListStructure: (context: TransformContext) => import("prosemirror-state").Transaction;
+export {};

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

@@ -6,6 +6,7 @@ export declare const getTargetNodeInfo: (targetType: FormatNodeTargetType, nodes
     nodeType: NodeType;
 } | null;
 export declare const isBlockNode: (node: PMNode) => boolean;
+export declare const isHeadingOrParagraphNode: (node: PMNode) => boolean;
 export declare const isListNode: (node: PMNode) => boolean;
 export declare const isContainerNode: (node: PMNode) => boolean;
 export declare const isBlockNodeType: (nodeType: NodeType) => boolean;
@@ -16,6 +17,7 @@ export declare const isTaskList: (nodeType: NodeType) => boolean;
 export declare const getSupportedListTypes: (nodes: Record<string, NodeType>) => NodeType[];
 export declare const getSupportedListTypesSet: (nodes: Record<string, NodeType>) => Set<NodeType>;
 export declare const isLayoutNodeType: (nodeType: NodeType) => boolean;
+export declare const isLayoutNode: (node: PMNode) => boolean;
 /**
  * Check if a node should be extracted as a standalone block node
  * rather than converted to inline content

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

@@ -1,3 +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;
+import type { Fragment, Schema } from '@atlaskit/editor-prosemirror/model';
+export declare const getInlineNodeTextContent: (sourceContent: Fragment) => string;
+export declare const getInlineNodeTextNode: (sourceContent: Fragment, schema: Schema) => import("prosemirror-model").Node;

package/dist/types-ts4.5/editor-commands/transforms/layout/utils.d.ts

@@ -0,0 +1,5 @@
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { TransformContext } from '../types';
+export declare const unwrapLayoutNodesToTextNodes: (context: TransformContext, finalTargetNodeType: NodeType) => PMNode[];
+export declare const transformToListNode: (nodes: PMNode[], targetNodeType: NodeType, schema: Schema) => PMNode[];
+export declare const convertUnwrappedLayoutContent: (nodes: PMNode[], targetNodeType: NodeType, schema: Schema) => PMNode[];

package/dist/types-ts4.5/editor-commands/transforms/layout-transforms.d.ts

@@ -1,2 +1,3 @@
 import type { TransformContext } from './types';
 export declare const convertToLayout: (context: TransformContext) => import("prosemirror-state").Transaction;
+export declare const transformLayoutNode: (context: TransformContext) => import("prosemirror-state").Transaction;

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

@@ -1,5 +1,18 @@
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
 import type { TransformContext } from '../types';
+type TransformListRecursivelyProps = {
+    isSourceBulletOrOrdered: boolean;
+    isSourceTask: boolean;
+    isTargetBulletOrOrdered: boolean;
+    isTargetTask: boolean;
+    listNode: PMNode;
+    schema: Schema;
+    supportedListTypes: Set<NodeType>;
+    targetNodeType: NodeType;
+};
+export declare const transformListRecursively: (props: TransformListRecursivelyProps) => PMNode;
 /**
  * Transform list structure between different list types
  */
 export declare const transformListStructure: (context: TransformContext) => import("prosemirror-state").Transaction;
+export {};

package/dist/types-ts4.5/editor-commands/transforms/utils.d.ts

@@ -6,6 +6,7 @@ export declare const getTargetNodeInfo: (targetType: FormatNodeTargetType, nodes
     nodeType: NodeType;
 } | null;
 export declare const isBlockNode: (node: PMNode) => boolean;
+export declare const isHeadingOrParagraphNode: (node: PMNode) => boolean;
 export declare const isListNode: (node: PMNode) => boolean;
 export declare const isContainerNode: (node: PMNode) => boolean;
 export declare const isBlockNodeType: (nodeType: NodeType) => boolean;
@@ -16,6 +17,7 @@ export declare const isTaskList: (nodeType: NodeType) => boolean;
 export declare const getSupportedListTypes: (nodes: Record<string, NodeType>) => NodeType[];
 export declare const getSupportedListTypesSet: (nodes: Record<string, NodeType>) => Set<NodeType>;
 export declare const isLayoutNodeType: (nodeType: NodeType) => boolean;
+export declare const isLayoutNode: (node: PMNode) => boolean;
 /**
  * Check if a node should be extracted as a standalone block node
  * rather than converted to inline content