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

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

@@ -0,0 +1,272 @@
+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 const unwrapLayoutNodesToTextNodes = (context, finalTargetNodeType) => {
+  const {
+    tr,
+    sourceNode,
+    targetNodeType,
+    targetAttrs
+  } = context;
+  const schema = tr.doc.type.schema || {};
+  const isValid = getContentSupportChecker(finalTargetNodeType);
+  const createTextNode = node => {
+    const 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) {
+      const textNodes = sourceNode.textContent.split('\n').map(line => targetNodeType.createChecked(undefined, line ? schema.text(line) : null));
+      return textNodes;
+    }
+    return [createTextNode(sourceNode)];
+  }
+  if (isContainerNode(sourceNode)) {
+    var _sourceNode$attrs;
+    const 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(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') {
+        const taskItemsResult = findChildrenByType(sourceNode, schema.nodes.taskItem);
+        const taskItems = taskItemsResult.map(item => item.node);
+        const taskItemFragments = taskItems.map(taskItem => taskItem.content);
+        return taskItemFragments.map(fragment => targetNodeType.createChecked(targetAttrs, fragment.content));
+      } else {
+        const paragraphs = findChildrenByType(sourceNode, schema.nodes.paragraph);
+        const paragraphNodes = paragraphs.map(paragraph => paragraph.node);
+        if (targetNodeType === schema.nodes.heading) {
+          return paragraphNodes.map(paragraphNode => targetNodeType.createChecked(targetAttrs, paragraphNode.content));
+        }
+        return paragraphNodes;
+      }
+    }
+    return [sourceNode];
+  }
+  return [sourceNode];
+};
+const transformToBlockNode = (nodes, targetNodeType, schema) => {
+  if (targetNodeType === schema.nodes.codeBlock) {
+    const newNodes = [];
+    nodes.forEach(node => {
+      if (node.isTextblock) {
+        const 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
+          const lastItem = newNodes[newNodes.length - 1];
+          if (lastItem.canBeTransformed) {
+            newNodes[newNodes.length - 1] = {
+              content: [...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(({
+      canBeTransformed,
+      content
+    }) => {
+      if (canBeTransformed) {
+        const text = content.join('\n');
+        if (text === '') {
+          return undefined;
+        }
+        return targetNodeType.createChecked(null, schema.text(text));
+      } else {
+        return content;
+      }
+    }).filter(Boolean);
+  }
+  return nodes;
+};
+const transformToContainerNode = (nodes, targetNodeType) => {
+  const newNodes = [];
+  const isNodeValid = getContentSupportChecker(targetNodeType);
+  nodes.forEach(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
+      const nodeWithValidAttrs = node.mark(node.marks.filter(mark => mark.type.name !== 'alignment'));
+      const 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;
+      }
+      const nodes = isSameNodeType ? node.content.content : [nodeWithValidAttrs];
+      if (newNodes.length === 0) {
+        newNodes.push({
+          node: nodes,
+          canBeTransformed: true
+        });
+      } else {
+        const lastItem = newNodes[newNodes.length - 1];
+        if (lastItem.canBeTransformed) {
+          newNodes[newNodes.length - 1] = {
+            node: [...lastItem.node, ...nodes],
+            canBeTransformed: true
+          };
+        } else {
+          newNodes.push({
+            node: nodes,
+            canBeTransformed: true
+          });
+        }
+      }
+    }
+  });
+  return newNodes.map(({
+    node,
+    canBeTransformed
+  }) => {
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+export const transformToListNode = (nodes, targetNodeType, schema) => {
+  const isTargetTask = isTaskList(targetNodeType);
+  const listItems = [];
+  const listItemType = isTargetTask ? schema.nodes.taskItem : schema.nodes.listItem;
+  const isValid = getContentSupportChecker(listItemType);
+  nodes.forEach(node => {
+    // Append unsupported nodes as is
+    if (isBlockNodeForExtraction(node)) {
+      listItems.push({
+        canBeTransformed: false,
+        node
+      });
+    } else {
+      let newListItems;
+
+      // If the node is a list, we may need to transform it
+      if (isListNode(node)) {
+        const isSourceBulletOrOrdered = isBulletOrOrderedList(node.type);
+        const isTargetTask = isTaskList(targetNodeType);
+        const isSourceTask = isTaskList(node.type);
+        const isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
+        const supportedListTypes = getSupportedListTypesSet(schema.nodes);
+        if (node.type === targetNodeType) {
+          // For the same list type, we can keep the structure
+          newListItems = node.content.content;
+        } else {
+          const newList = transformListRecursively({
+            isSourceBulletOrOrdered,
+            isSourceTask,
+            isTargetBulletOrOrdered,
+            isTargetTask,
+            listNode: node,
+            schema,
+            supportedListTypes,
+            targetNodeType
+          });
+          newListItems = [...newList.content.content];
+        }
+      } else if (isHeadingOrParagraphNode(node) || isValid(node)) {
+        if (isTargetTask) {
+          const inlineContent = [...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
+        });
+      }
+      if (newListItems) {
+        if (listItems.length === 0) {
+          listItems.push({
+            canBeTransformed: true,
+            node: newListItems
+          });
+        } else {
+          const lastItem = listItems[listItems.length - 1];
+          if (lastItem.canBeTransformed) {
+            listItems[listItems.length - 1] = {
+              node: [...lastItem.node, ...newListItems],
+              canBeTransformed: true
+            };
+          } else {
+            listItems.push({
+              node: newListItems,
+              canBeTransformed: true
+            });
+          }
+        }
+      }
+    }
+  });
+  return listItems.map(({
+    node,
+    canBeTransformed
+  }) => {
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+export const 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/es2019/editor-commands/transforms/layout-transforms.js

@@ -1,5 +1,6 @@
 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 const convertToLayout = context => {
   const {
     tr,
@@ -20,6 +21,44 @@ export const convertToLayout = context => {
   const 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 const transformLayoutNode = context => {
+  const {
+    tr,
+    sourceNode,
+    targetNodeType,
+    sourcePos,
+    targetAttrs
+  } = context;
+  const schema = tr.doc.type.schema || {};
+  const {
+    layoutSection,
+    layoutColumn,
+    paragraph,
+    heading
+  } = schema.nodes || {};
+  const layoutColumnNodes = [];
+  const targetTextNodeType = targetNodeType === heading ? heading : paragraph;
+  sourceNode.children.forEach(child => {
+    if (child.type === layoutColumn) {
+      const unwrappedContent = [];
+      child.content.forEach(node => {
+        // Unwrap all nodes and convert to text nodes
+        const context = {
+          tr,
+          sourceNode: node,
+          targetNodeType: targetTextNodeType,
+          sourcePos: 0,
+          targetAttrs
+        };
+        const newContent = unwrapLayoutNodesToTextNodes(context, targetNodeType);
+        unwrappedContent.push(...newContent);
+      });
+      const 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/es2019/editor-commands/transforms/list/transformBetweenListTypes.js

@@ -16,6 +16,88 @@ const convertBlockToInlineContent = (node, schema) => {
   }
   return [node];
 };
+export const transformListRecursively = props => {
+  const transformedItems = [];
+  const {
+    listNode,
+    isSourceBulletOrOrdered,
+    isTargetBulletOrOrdered,
+    isSourceTask,
+    isTargetTask,
+    supportedListTypes,
+    schema,
+    targetNodeType
+  } = props;
+  const {
+    taskList,
+    listItem,
+    taskItem,
+    paragraph
+  } = schema.nodes;
+  listNode.forEach(child => {
+    if (isSourceBulletOrOrdered && isTargetTask) {
+      // Convert bullet/ordered => task
+      if (child.type === listItem) {
+        const inlineContent = [];
+        const nestedTaskLists = [];
+        child.forEach(grandChild => {
+          if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
+            nestedTaskLists.push(transformListRecursively({
+              ...props,
+              listNode: grandChild
+            }));
+          } else {
+            inlineContent.push(...convertBlockToInlineContent(grandChild, schema));
+          }
+        });
+        if (inlineContent.length > 0) {
+          transformedItems.push(taskItem.create(null, inlineContent));
+        }
+        transformedItems.push(...nestedTaskLists);
+      }
+    } else if (isSourceTask && isTargetBulletOrOrdered) {
+      // Convert task => bullet/ordered
+      if (child.type === taskItem) {
+        const inlineContent = [...child.content.content];
+        if (inlineContent.length > 0) {
+          const paragraphNode = paragraph.create(null, inlineContent);
+          transformedItems.push(listItem.create(null, [paragraphNode]));
+        }
+      } else if (child.type === taskList) {
+        const transformedNestedList = transformListRecursively({
+          ...props,
+          listNode: child
+        });
+        const lastItem = transformedItems[transformedItems.length - 1];
+        if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
+          // Attach nested list to previous item
+          const updatedContent = [...lastItem.content.content, transformedNestedList];
+          transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
+        } else {
+          // No previous item, flatten nested items
+          transformedItems.push(...transformedNestedList.content.content);
+        }
+      }
+    } else if (isSourceBulletOrOrdered && isTargetBulletOrOrdered) {
+      if (child.type === listItem) {
+        const convertedNestedLists = [];
+        child.forEach(grandChild => {
+          if (supportedListTypes.has(grandChild.type) && grandChild.type !== targetNodeType) {
+            const convertedNode = transformListRecursively({
+              ...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
@@ -37,62 +119,23 @@ export const transformListStructure = context => {
       node: sourceList,
       pos: listPos
     } = listNode;
-    const {
-      taskList,
-      listItem,
-      taskItem,
-      paragraph
-    } = nodes;
+    // const { taskList, listItem, taskItem, paragraph } = nodes;
+
     const isSourceBulletOrOrdered = isBulletOrOrderedList(sourceList.type);
     const isTargetTask = isTaskList(targetNodeType);
     const isSourceTask = isTaskList(sourceList.type);
     const isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
     const supportedListTypes = getSupportedListTypesSet(nodes);
-    const transformListRecursively = listNode => {
-      const transformedItems = [];
-      listNode.forEach(child => {
-        if (isSourceBulletOrOrdered && isTargetTask) {
-          // Convert bullet/ordered => task
-          if (child.type === listItem) {
-            const inlineContent = [];
-            const nestedTaskLists = [];
-            child.forEach(grandChild => {
-              if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
-                nestedTaskLists.push(transformListRecursively(grandChild));
-              } else {
-                inlineContent.push(...convertBlockToInlineContent(grandChild, tr.doc.type.schema));
-              }
-            });
-            if (inlineContent.length > 0) {
-              transformedItems.push(taskItem.create(null, inlineContent));
-            }
-            transformedItems.push(...nestedTaskLists);
-          }
-        } else if (isSourceTask && isTargetBulletOrOrdered) {
-          // Convert task => bullet/ordered
-          if (child.type === taskItem) {
-            const inlineContent = [...child.content.content];
-            if (inlineContent.length > 0) {
-              const paragraphNode = paragraph.create(null, inlineContent);
-              transformedItems.push(listItem.create(null, [paragraphNode]));
-            }
-          } else if (child.type === taskList) {
-            const transformedNestedList = transformListRecursively(child);
-            const lastItem = transformedItems[transformedItems.length - 1];
-            if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
-              // Attach nested list to previous item
-              const updatedContent = [...lastItem.content.content, transformedNestedList];
-              transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
-            } else {
-              // No previous item, flatten nested items
-              transformedItems.push(...transformedNestedList.content.content);
-            }
-          }
-        }
-      });
-      return targetNodeType.create(null, transformedItems);
-    };
-    const newList = transformListRecursively(sourceList);
+    const newList = transformListRecursively({
+      isSourceBulletOrOrdered,
+      isSourceTask,
+      isTargetBulletOrOrdered,
+      isTargetTask,
+      listNode: sourceList,
+      schema: tr.doc.type.schema,
+      supportedListTypes,
+      targetNodeType
+    });
     tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch {

package/dist/es2019/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) {
   const {
     nodes
@@ -50,6 +50,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/es2019/editor-commands/transforms/utils.js

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

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

@@ -1,5 +1,5 @@
 import { transformToContainer, unwrapAndConvertToBlockType } from './container-transforms';
-import { getInlineNodeTextContent } from './inline-node-transforms';
+import { getInlineNodeTextNode } from './inline-node-transforms';
 import { transformBlockToList } from './list-transforms';
 import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
 
@@ -36,7 +36,7 @@ var transformToBlockNode = function transformToBlockNode(context) {
     $to = selection.$to;
   var schema = doc.type.schema;
   if (targetNodeType === schema.nodes.codeBlock) {
-    var textContent = getInlineNodeTextContent(selection.content().content, tr);
+    var textContent = getInlineNodeTextNode(selection.content().content, schema);
     var node = schema.nodes.codeBlock.createChecked(undefined, textContent);
     return tr.replaceRangeWith(selection.from, selection.to, node);
   }

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

@@ -1,8 +1,7 @@
-export var getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent, tr) {
+export var getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent) {
   var validTransformedContent = '';
-  var schema = tr.doc.type.schema;
-  if (sourceContent.content.length > 1) {
-    return;
+  if (sourceContent.content.length < 1) {
+    return '';
   }
   // Headings are not valid inside headings so convert heading nodes to paragraphs
   sourceContent.forEach(function (node) {
@@ -14,8 +13,11 @@ export var getInlineNodeTextContent = function getInlineNodeTextContent(sourceCo
           validTransformedContent += "".concat(inlineNode.textContent);
         }
       });
-      validTransformedContent;
     }
   });
-  return schema.text(validTransformedContent);
+  return validTransformedContent;
+};
+export var getInlineNodeTextNode = function getInlineNodeTextNode(sourceContent, schema) {
+  var text = getInlineNodeTextContent(sourceContent);
+  return schema.text(text);
 };