@atlaskit/editor-plugin-block-menu 9.0.18 → 9.1.0

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

@@ -1,334 +0,0 @@
-import { transformListRecursively, isBulletOrOrderedList, isTaskList, getSupportedListTypesSet } from '@atlaskit/editor-common/transforms';
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-import { getInlineNodeTextContent } from '../inline-node-transforms';
-import { getContentSupportChecker, isBlockNode, isBlockNodeForExtraction, isBlockNodeType, isContainerNode, isContainerNodeType, isHeadingOrParagraphNode, isListNode, isListNodeType } 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';
-    let nodeToTransform = node;
-    if (isContainerNodeType(finalTargetNodeType) || isListNodeType(finalTargetNodeType)) {
-      nodeToTransform = node.mark(node.marks.filter(mark => !['alignment', 'indentation'].includes(mark.type.name)));
-    }
-    if (isValid(nodeToTransform) && !isTextNode) {
-      return nodeToTransform;
-    }
-    return targetNodeType.createChecked(targetAttrs, isTextNode ? nodeToTransform : nodeToTransform.content, nodeToTransform.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 transformToCodeBlock = (nodes, schema) => {
-  const newNodes = [];
-  const addToNewNodes = content => {
-    if (newNodes.length === 0) {
-      newNodes.push({
-        canBeTransformed: true,
-        content
-      });
-    } 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, ...content],
-          canBeTransformed: true
-        };
-      } else {
-        newNodes.push({
-          content,
-          canBeTransformed: true
-        });
-      }
-    }
-  };
-  nodes.forEach(node => {
-    if (node.isTextblock) {
-      const inlineTextContent = node.type === schema.nodes.codeBlock ? node.textContent : getInlineNodeTextContent(Fragment.from(node)).inlineTextContent;
-      addToNewNodes([inlineTextContent]);
-    } else if (isListNode(node)) {
-      const textContent = [];
-      const listItemType = node.type === schema.nodes.taskList ? schema.nodes.taskItem : schema.nodes.listItem;
-      const listItems = findChildrenByType(node, listItemType).map(item => item.node);
-      listItems.forEach(listItem => {
-        if (listItem.type === schema.nodes.taskItem) {
-          const inlineTextContent = getInlineNodeTextContent(Fragment.from(listItem)).inlineTextContent;
-          textContent.push(inlineTextContent);
-        } else {
-          const inlineTextContent = getInlineNodeTextContent(listItem.content).inlineTextContent;
-          textContent.push(inlineTextContent);
-        }
-      });
-      addToNewNodes(textContent);
-    } else {
-      // If not text block or list node, 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 schema.nodes.codeBlock.createChecked(null, schema.text(text));
-    } else {
-      return content;
-    }
-  }).filter(Boolean);
-};
-const transformToBlockNode = (nodes, targetNodeType, schema) => {
-  if (targetNodeType === schema.nodes.codeBlock) {
-    return transformToCodeBlock(nodes, schema);
-  }
-  const newNodes = [];
-  nodes.forEach(node => {
-    if (isListNode(node)) {
-      const listItemType = node.type === schema.nodes.taskList ? schema.nodes.taskItem : schema.nodes.listItem;
-      const listItems = findChildrenByType(node, listItemType).map(item => item.node);
-      listItems.forEach(listItem => {
-        if (listItem.type === schema.nodes.taskItem) {
-          const inlineContent = [...listItem.content.content];
-          if (inlineContent.length > 0) {
-            newNodes.push(targetNodeType.createChecked(null, inlineContent));
-          }
-        } else {
-          listItem.forEach(child => {
-            if (isHeadingOrParagraphNode(child)) {
-              newNodes.push(targetNodeType.createChecked(null, [...child.content.content]));
-            }
-          });
-        }
-      });
-    } else {
-      newNodes.push(node);
-    }
-  });
-  return newNodes;
-};
-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 {
-      const isSameNodeType = node.type === targetNodeType;
-
-      // If the node is not valid and not the same type, we cannot transform it
-      if (!isNodeValid(node) && !isSameNodeType) {
-        newNodes.push({
-          node: node,
-          canBeTransformed: false
-        });
-        return;
-      }
-      const nodes = isSameNodeType ? node.content.content : [node];
-      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 unsupportedContent = [];
-  const onhandleUnsupportedContent = content => {
-    unsupportedContent.push(content);
-  };
-  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
-          }, onhandleUnsupportedContent);
-          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;
-    }
-  }), ...unsupportedContent];
-};
-export const convertUnwrappedLayoutContent = (nodes, targetNodeType, schema, targetAttrs) => {
-  if (nodes.length === 1 && nodes[0].content.size === 0 && !isContainerNodeType(targetNodeType)) {
-    if (isBlockNodeType(targetNodeType)) {
-      if (['heading', 'paragraph'].includes(targetNodeType.name)) {
-        return [targetNodeType.createChecked(targetAttrs)];
-      }
-      if (targetNodeType.name === 'codeBlock') {
-        return [targetNodeType.createChecked()];
-      }
-    }
-    if (isListNodeType(targetNodeType)) {
-      const listItem = isTaskList(targetNodeType) ? schema.nodes.taskItem.createChecked() : schema.nodes.listItem.createChecked(null, schema.nodes.paragraph.createChecked());
-      return [targetNodeType.createChecked(null, listItem)];
-    }
-    return nodes;
-  }
-  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,75 +0,0 @@
-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';
-import { getMarksWithBreakout, isHeadingOrParagraphNode } from './utils';
-export const createDefaultLayoutSection = (schema, content, marks) => {
-  const {
-    layoutSection,
-    layoutColumn,
-    paragraph
-  } = schema.nodes;
-  const layoutContent = Fragment.fromArray([layoutColumn.createChecked({
-    width: DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH
-  }, content), layoutColumn.create({
-    width: DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH
-  }, paragraph.createAndFill())]);
-  return layoutSection.createChecked(undefined, layoutContent, marks);
-};
-export const convertToLayout = context => {
-  const {
-    tr,
-    sourceNode,
-    sourcePos
-  } = context;
-  const content = sourceNode.mark(sourceNode.marks.filter(mark => mark.type.name !== 'breakout'));
-
-  // Layout supports breakout mark that can have width attribute
-  // When other nodes with breakout (codeBlock and expand) are converted to a layout, the layout should get width of original node
-  const marks = getMarksWithBreakout(sourceNode, tr.doc.type.schema.nodes.layoutSection);
-  const layoutSectionNode = createDefaultLayoutSection(tr.doc.type.schema, content, marks);
-  if (isHeadingOrParagraphNode(sourceNode)) {
-    // -1 to fix when sourceNode is the last node in the document, unable to convert to layout
-    tr.replaceRangeWith(sourcePos > 0 ? sourcePos - 1 : sourcePos, sourcePos + sourceNode.nodeSize - 1, layoutSectionNode);
-  } else {
-    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, targetAttrs);
-      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/transformOrderedUnorderedListToBlockNodes.js

@@ -1,93 +0,0 @@
-import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
-import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-import { getInlineNodeTextContent } from '../inline-node-transforms';
-import { getContentSupportChecker, isListNode } from '../utils';
-export const transformOrderedUnorderedListToBlockNodes = context => {
-  const {
-    tr,
-    targetNodeType,
-    targetAttrs,
-    sourceNode,
-    sourcePos
-  } = context;
-  const {
-    selection
-  } = tr;
-  const schema = selection.$from.doc.type.schema;
-  const targetNodes = [];
-  // find all list items inside the list node
-  const listItems = findChildrenByType(sourceNode, schema.nodes.listItem);
-  let textContent = [];
-  const flushTextContent = () => {
-    if (targetNodeType !== schema.nodes.codeBlock) {
-      return;
-    }
-    if (textContent.length > 0) {
-      const inlineText = textContent.join('\n');
-      targetNodes.push(schema.nodes.codeBlock.createChecked({}, inlineText !== '' ? schema.text(inlineText) : null));
-      textContent = [];
-    }
-  };
-  listItems.forEach(listItem => {
-    // Convert paragraphs to headings if target is heading
-    const content = listItem.node.content.content;
-    content.forEach(node => {
-      const isValid = getContentSupportChecker(targetNodeType)(node);
-      if (isListNode(node)) {
-        // Skip nested lists as it will return listItems that we will deal with separately
-        return;
-      }
-
-      // Deal with the case where targetNode and node are both codeBlocks, then append text content
-      if (targetNodeType === schema.nodes.codeBlock && node.type === schema.nodes.codeBlock) {
-        const inlineContent = node.textContent;
-        textContent = [...textContent, inlineContent];
-        return;
-      }
-
-      // If the node is not valid for the target container,
-      // flush any existing text content if target is codeBlock
-      // and extract the node without any conversion
-      if (!isValid && !node.isTextblock) {
-        flushTextContent();
-        targetNodes.push(node);
-        return;
-      }
-
-      // If the target is codeBlock, accumulate text content
-      if (targetNodeType === schema.nodes.codeBlock) {
-        const inlineContent = getInlineNodeTextContent(Fragment.from(node)).inlineTextContent;
-        textContent = [...textContent, inlineContent];
-        return;
-      }
-
-      // Convert codeblocks to block nodes
-      if (node.type === schema.nodes.codeBlock) {
-        var _targetAttrs$level;
-        // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace -- Ignored via go/ees017 (to be fixed)
-        const textContent = node.textContent.split('\n');
-        const attributes = targetNodeType === schema.nodes.heading ? {
-          level: (_targetAttrs$level = targetAttrs === null || targetAttrs === void 0 ? void 0 : targetAttrs.level) !== null && _targetAttrs$level !== void 0 ? _targetAttrs$level : 1
-        } : null;
-        textContent.forEach(textLine => {
-          targetNodes.push(targetNodeType.createChecked(attributes, textLine ? schema.text(textLine) : null));
-        });
-        return;
-      }
-      if (targetNodeType === schema.nodes.heading && targetAttrs) {
-        const targetHeadingLevel = targetAttrs.level;
-        targetNodes.push(schema.nodes.heading.createChecked({
-          level: targetHeadingLevel
-        }, node.content));
-        return;
-      }
-      targetNodes.push(node);
-    });
-  });
-  flushTextContent();
-  const fragment = Fragment.fromArray(targetNodes);
-  const slice = new Slice(fragment, 0, 0);
-  const rangeStart = sourcePos !== null ? sourcePos : selection.from;
-  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
-  return tr;
-};

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

@@ -1,47 +0,0 @@
-import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
-import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-export const transformTaskListToBlockNodes = context => {
-  const {
-    tr,
-    targetNodeType,
-    targetAttrs,
-    sourceNode,
-    sourcePos
-  } = context;
-  const {
-    selection
-  } = tr;
-  const schema = selection.$from.doc.type.schema;
-  const taskItemsResult = findChildrenByType(sourceNode, schema.nodes.taskItem);
-  const taskItems = taskItemsResult.map(item => item.node);
-  const taskItemFragments = taskItems.map(taskItem => taskItem.content);
-  let targetNodes = [];
-
-  // Convert fragments to headings if target is heading
-  if (targetNodeType === schema.nodes.heading && targetAttrs) {
-    // convert the fragments to headings
-    const targetHeadingLevel = targetAttrs.level;
-    targetNodes = taskItemFragments.map(fragment => schema.nodes.heading.createChecked({
-      level: targetHeadingLevel
-    }, fragment.content));
-  }
-
-  // Convert fragments to paragraphs if target is paragraphs
-  if (targetNodeType === schema.nodes.paragraph) {
-    // convert the fragments to paragraphs
-    targetNodes = taskItemFragments.map(fragment => schema.nodes.paragraph.createChecked({}, fragment.content));
-  }
-
-  // Convert fragments to code block if target is code block
-  if (targetNodeType === schema.nodes.codeBlock) {
-    // convert the fragments to one code block
-    const codeBlockContent = taskItemFragments.map(fragment => fragment.textBetween(0, fragment.size, '\n')).join('\n');
-    targetNodes = [schema.nodes.codeBlock.createChecked({}, schema.text(codeBlockContent))];
-  }
-
-  // Replace the task list node with the new content in the transaction
-  const slice = new Slice(Fragment.fromArray(targetNodes), 0, 0);
-  const rangeStart = sourcePos !== null ? sourcePos : selection.from;
-  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
-  return tr;
-};

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

@@ -1,38 +0,0 @@
-/**
- * Transform selection to task list
- * Handles the special structure where taskItem contains text directly (no paragraph wrapper)
- */
-export const transformToTaskList = (tr, range, targetNodeType, targetAttrs, nodes) => {
-  try {
-    const {
-      taskItem
-    } = nodes;
-    const listItems = [];
-
-    // Process each block in the range
-    tr.doc.nodesBetween(range.start, range.end, node => {
-      if (node.isBlock) {
-        // For block nodes like paragraphs, directly use their inline content
-        const inlineContent = [...node.content.content];
-        if (inlineContent.length > 0) {
-          // Create task item with inline content directly
-          const listItem = taskItem.create(targetAttrs, inlineContent);
-          listItems.push(listItem);
-        }
-      }
-      return false; // Don't traverse into children
-    });
-    if (listItems.length === 0) {
-      return null;
-    }
-
-    // Create the new task list
-    const newList = targetNodeType.create(targetAttrs, listItems);
-
-    // Replace the range with the new list
-    tr.replaceWith(range.start, range.end, newList);
-    return tr;
-  } catch {
-    return null;
-  }
-};