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

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

@@ -1,441 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
-import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-import { getInlineNodeTextContent } from './inline-node-transforms';
-import { isBlockNodeType, isListNodeType, isContainerNodeType, isBlockNodeForExtraction, convertNodeToInlineContent, getContentSupportChecker, convertCodeBlockContentToParagraphs, filterMarksForTargetNodeType, getMarksWithBreakout } 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(_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;
-  var marks = [];
-  if (sourceNode.type === schema.nodes.codeBlock) {
-    var paragraphNodes = convertCodeBlockContentToParagraphs(sourceNode, schema);
-    transformedContent = Fragment.fromArray(paragraphNodes);
-    marks = getMarksWithBreakout(sourceNode, targetNodeType);
-  }
-  if (targetNodeType === schema.nodes.blockquote) {
-    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
-  }
-
-  // Preserve marks that are allowed in the target node type
-  // e.g. blocks (heading/ paragraph) with alignment need to remove alignment
-  // as panel/ blockQuote/ expands does not support alignment
-  if (sourceNode.type === schema.nodes.paragraph || sourceNode.type === schema.nodes.heading) {
-    transformedContent = filterMarksForTargetNodeType(transformedContent, targetNodeType);
-  }
-  var newNode = targetNodeType.createAndFill(targetAttrs, transformedContent, marks);
-  if (!newNode) {
-    return null;
-  }
-  tr.replaceRangeWith(selection.from, selection.to, newNode);
-  return tr;
-};
-
-/**
- * Transform container nodes (panel, expand, blockquote)
- */
-export var transformContainerNode = function transformContainerNode(_ref2) {
-  var tr = _ref2.tr,
-    sourceNode = _ref2.sourceNode,
-    sourcePos = _ref2.sourcePos,
-    targetNodeType = _ref2.targetNodeType,
-    targetAttrs = _ref2.targetAttrs;
-  if (sourcePos === null) {
-    return null;
-  }
-
-  // Transform container to block type - unwrap and convert content
-  if (isBlockNodeType(targetNodeType)) {
-    // special case container to codeblock
-    if (targetNodeType.name === 'codeBlock') {
-      return transformBetweenContainerTypes({
-        tr: tr,
-        sourceNode: sourceNode,
-        sourcePos: sourcePos,
-        targetNodeType: targetNodeType,
-        targetAttrs: targetAttrs
-      });
-    }
-    return unwrapAndConvertToBlockType({
-      tr: tr,
-      sourceNode: sourceNode,
-      sourcePos: sourcePos,
-      targetNodeType: targetNodeType,
-      targetAttrs: targetAttrs
-    });
-  }
-
-  // Transform container to list type
-  if (isListNodeType(targetNodeType)) {
-    return unwrapAndConvertToList({
-      tr: tr,
-      sourceNode: sourceNode,
-      sourcePos: sourcePos,
-      targetNodeType: targetNodeType,
-      targetAttrs: targetAttrs
-    });
-  }
-
-  // Transform between container types
-  if (isContainerNodeType(targetNodeType)) {
-    return transformBetweenContainerTypes({
-      tr: tr,
-      sourceNode: sourceNode,
-      sourcePos: sourcePos,
-      targetNodeType: targetNodeType,
-      targetAttrs: targetAttrs
-    });
-  }
-  return null;
-};
-
-/**
- * Unwrap container node and convert content to block type
- */
-export var unwrapAndConvertToBlockType = function unwrapAndConvertToBlockType(context) {
-  var tr = context.tr,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs,
-    sourceNode = context.sourceNode,
-    sourcePos = context.sourcePos;
-  var selection = tr.selection;
-  var schema = selection.$from.doc.type.schema;
-  var _schema$nodes = schema.nodes,
-    paragraph = _schema$nodes.paragraph,
-    heading = _schema$nodes.heading,
-    codeBlock = _schema$nodes.codeBlock,
-    expand = _schema$nodes.expand;
-  var rangeStart = sourcePos !== null ? sourcePos : selection.from;
-  var sourceChildren = _toConsumableArray(sourceNode.children);
-  var transformedContent = [];
-
-  // If the container is expand, we need to extract the title and convert it to a paragraph
-  // and add it to the beginning of the content
-  if (sourceNode.type === expand) {
-    var _sourceNode$attrs;
-    var title = (_sourceNode$attrs = sourceNode.attrs) === null || _sourceNode$attrs === void 0 ? void 0 : _sourceNode$attrs.title;
-    if (title) {
-      var titleContent = schema.text(title);
-      sourceChildren.unshift(paragraph.createChecked({}, titleContent));
-    }
-  }
-
-  // if the container is a code block, convert text content to multiple paragraphs
-  if (sourceNode.type === codeBlock) {
-    sourceChildren = convertCodeBlockContentToParagraphs(sourceNode, schema);
-  }
-
-  // if target node is a paragraph, just do unwrap
-  if (targetNodeType === paragraph) {
-    transformedContent = sourceChildren;
-  }
-
-  // if target node is a headings, do unwrap and convert to heading
-  if (targetNodeType === heading && targetAttrs) {
-    var targetHeadingLevel = targetAttrs.level;
-    sourceChildren.forEach(function (node, index) {
-      if (node.isTextblock) {
-        var headingNode = heading.create({
-          level: targetHeadingLevel
-        }, node.content);
-        sourceChildren[index] = headingNode;
-      }
-    });
-    transformedContent = sourceChildren;
-  }
-
-  // if target node is code block, do unwrap and convert to code block
-  if (targetNodeType === codeBlock) {
-    var codeBlockContent = sourceChildren.map(function (node) {
-      return node.content.textBetween(0, node.content.size, '\n');
-    }).join('\n');
-    var marks = getMarksWithBreakout(sourceNode, targetNodeType);
-    transformedContent = [codeBlock.createChecked({}, schema.text(codeBlockContent), marks)];
-  }
-  var slice = new Slice(Fragment.fromArray(transformedContent), 0, 0);
-  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
-  return tr;
-};
-
-/**
- * Unwrap container node and convert content to list
- */
-export var unwrapAndConvertToList = function unwrapAndConvertToList(_ref3) {
-  var tr = _ref3.tr,
-    sourceNode = _ref3.sourceNode,
-    sourcePos = _ref3.sourcePos,
-    targetNodeType = _ref3.targetNodeType,
-    targetAttrs = _ref3.targetAttrs;
-  var schema = tr.doc.type.schema;
-  var _schema$nodes2 = schema.nodes,
-    listItem = _schema$nodes2.listItem,
-    paragraph = _schema$nodes2.paragraph,
-    taskList = _schema$nodes2.taskList,
-    taskItem = _schema$nodes2.taskItem,
-    heading = _schema$nodes2.heading;
-  var isTargetTaskList = targetNodeType === taskList;
-  var createListItemFromInline = function createListItemFromInline(content) {
-    if (!content) {
-      return isTargetTaskList ? taskItem.create() : listItem.create(null, paragraph.create());
-    } else {
-      return isTargetTaskList ? taskItem.create(null, content) : listItem.create(null, paragraph.create(null, content));
-    }
-  };
-  var getInlineContent = function getInlineContent(textblock) {
-    var inlineContent = [];
-    textblock.forEach(function (inline) {
-      inlineContent.push(inline);
-    });
-    return inlineContent;
-  };
-  var resultContent = [];
-  var currentListItems = [];
-  var targetListItemType = isTargetTaskList ? taskItem : listItem;
-  // Expand's title should become the first item of the list
-  if (sourceNode.type.name === 'expand') {
-    var _sourceNode$attrs2;
-    var title = (_sourceNode$attrs2 = sourceNode.attrs) === null || _sourceNode$attrs2 === void 0 ? void 0 : _sourceNode$attrs2.title;
-    if (title) {
-      var titleContent = schema.text(title);
-      currentListItems.push(createListItemFromInline(titleContent));
-    }
-  }
-  var createListAndAddToContent = function createListAndAddToContent() {
-    if (currentListItems.length) {
-      var currentList = targetNodeType.create(targetAttrs || null, Fragment.from(currentListItems));
-      currentListItems = [];
-      resultContent.push(currentList);
-    }
-  };
-  if (sourceNode.type.name === 'codeBlock') {
-    var codeText = sourceNode.textContent;
-    // check if code block only contains newline characters
-    // eslint-disable-next-line require-unicode-regexp
-    var isOnlyNewLines = function isOnlyNewLines(codeText) {
-      return codeText.replace(/\n/g, '').trim() === '';
-    };
-    if (!codeText || isOnlyNewLines(codeText)) {
-      // Empty code block - create an empty list item
-      currentListItems.push(createListItemFromInline());
-    }
-    if (codeText) {
-      var lines = codeText.split('\n');
-      // Remove empty lines
-      var nonEmptyLines = lines.filter(function (line) {
-        return line.trim().length > 0;
-      });
-      nonEmptyLines.forEach(function (line) {
-        var lineText = schema.text(line);
-        currentListItems.push(createListItemFromInline(lineText));
-      });
-    }
-  } else {
-    sourceNode.forEach(function (child) {
-      if (targetListItemType.validContent(Fragment.from(child))) {
-        currentListItems.push(targetListItemType.create(null, child));
-      } else if (heading === child.type || isTargetTaskList && paragraph === child.type) {
-        var inline = Fragment.from(getInlineContent(child));
-        currentListItems.push(createListItemFromInline(inline));
-      } else {
-        // Create list and add list first
-        createListAndAddToContent();
-        // Then add content that can't be converted into listItem
-        resultContent.push(child);
-      }
-    });
-  }
-  if (!resultContent.length && !currentListItems.length) {
-    return null;
-  }
-  createListAndAddToContent();
-  return tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, Fragment.from(resultContent));
-};
-export var transformBetweenContainerTypes = function transformBetweenContainerTypes(context) {
-  var tr = context.tr,
-    sourceNode = context.sourceNode,
-    sourcePos = context.sourcePos,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs;
-
-  // Special handling for codeBlock target
-  if (targetNodeType.name === 'codeBlock') {
-    var _contentSplits = splitContentForCodeBlock(sourceNode, targetNodeType, targetAttrs, tr.doc.type.schema);
-    if (_contentSplits.length === 0) {
-      var schema = tr.doc.type.schema;
-      var marks = getMarksWithBreakout(sourceNode, targetNodeType);
-      var codeBlock = schema.nodes.codeBlock.create(targetAttrs, null, marks);
-      return tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, codeBlock);
-    }
-    return applySplitsToTransaction(tr, sourcePos, sourceNode.nodeSize, _contentSplits);
-  }
-
-  // Get content validation for target container type
-  var isContentSupported = getContentSupportChecker(targetNodeType);
-
-  // Process content and collect splits
-  var contentSplits = splitContentAroundUnsupportedBlocks(sourceNode, isContentSupported, targetNodeType, targetAttrs, tr.doc.type.schema);
-  return applySplitsToTransaction(tr, sourcePos, sourceNode.nodeSize, contentSplits);
-};
-
-/**
- * Apply content splits to transaction - shared utility for replacing and inserting splits
- */
-var applySplitsToTransaction = function applySplitsToTransaction(tr, sourcePos, sourceNodeSize, contentSplits) {
-  var insertPos = sourcePos;
-  contentSplits.forEach(function (splitNode, index) {
-    if (index === 0) {
-      // Replace the original node with the first split
-      tr.replaceWith(sourcePos, sourcePos + sourceNodeSize, splitNode);
-      insertPos = sourcePos + splitNode.nodeSize;
-    } else {
-      // Insert additional splits after
-      tr.insert(insertPos, splitNode);
-      insertPos += splitNode.nodeSize;
-    }
-  });
-  return tr;
-};
-
-/**
- * Split content for codeBlock transformation, creating codeBlocks for text content
- * and preserving unsupported blocks (like tables) separately
- */
-var splitContentForCodeBlock = function splitContentForCodeBlock(sourceNode, targetNodeType, targetAttrs, schema) {
-  var _sourceNode$attrs3;
-  var splits = [];
-  var children = sourceNode.content.content;
-  var currentTextContent = [];
-  var invalidContent = [];
-  // Handle expand title - add as first text if source is expand with title
-  if (sourceNode.type.name === 'expand' && (_sourceNode$attrs3 = sourceNode.attrs) !== null && _sourceNode$attrs3 !== void 0 && _sourceNode$attrs3.title) {
-    currentTextContent.push(sourceNode.attrs.title);
-  }
-  var flushCurrentCodeBlock = function flushCurrentCodeBlock() {
-    if (currentTextContent.length > 0) {
-      var codeText = currentTextContent.join('\n');
-      var marks = getMarksWithBreakout(sourceNode, targetNodeType);
-      var codeBlockNode = targetNodeType.create(targetAttrs, schema.text(codeText), marks);
-      splits.push(codeBlockNode);
-      currentTextContent = [];
-    }
-  };
-  var isCodeBlockCompatible = function isCodeBlockCompatible(node) {
-    // Only text blocks (paragraph, heading) can be converted to codeBlock text
-    return node.isTextblock || node.type.name === 'codeBlock';
-  };
-  children.forEach(function (childNode) {
-    if (isCodeBlockCompatible(childNode)) {
-      // Extract text content from compatible nodes
-      if (childNode.type.name === 'codeBlock') {
-        // If it's already a codeBlock, extract its text
-        currentTextContent.push(childNode.textContent);
-      } else if (childNode.isTextblock) {
-        // Extract text from text blocks (paragraphs, headings, etc.)
-        var text = getInlineNodeTextContent(Fragment.from(childNode)).inlineTextContent;
-        if (text.trim()) {
-          currentTextContent.push(text);
-        }
-      }
-    } else if (isBlockNodeForExtraction(childNode)) {
-      // Unsupported block node (table, etc.) - flush current codeBlock, add block, continue
-      flushCurrentCodeBlock();
-      splits.push(childNode);
-    } else if (isListNodeType(childNode.type)) {
-      var isTaskList = childNode.type.name === 'taskList';
-      var listItemType = isTaskList ? childNode.type.schema.nodes.taskItem : childNode.type.schema.nodes.listItem;
-      var listItems = findChildrenByType(childNode, listItemType);
-      listItems.forEach(function (listItem) {
-        var content = isTaskList ? Fragment.from(listItem.node) : listItem.node.content;
-        var inlineContent = getInlineNodeTextContent(content);
-        if (inlineContent.inlineTextContent.trim()) {
-          currentTextContent.push(inlineContent.inlineTextContent);
-        }
-        if (inlineContent.invalidContent.length > 0) {
-          invalidContent.push.apply(invalidContent, _toConsumableArray(inlineContent.invalidContent));
-        }
-      });
-    } else {
-      // Other unsupported content - try to extract text if possible
-      var _text = childNode.textContent;
-      if (_text && _text.trim()) {
-        currentTextContent.push(_text);
-      }
-    }
-  });
-
-  // Flush any remaining text content as a codeBlock
-  flushCurrentCodeBlock();
-  return [].concat(splits, invalidContent);
-};
-
-/**
- * Split content around unsupported block nodes, creating separate containers
- * for content before and after each unsupported block
- */
-var splitContentAroundUnsupportedBlocks = function splitContentAroundUnsupportedBlocks(sourceNode, isContentSupported, targetNodeType, targetAttrs, schema) {
-  var _sourceNode$attrs4;
-  var splits = [];
-  var children = sourceNode.content.content;
-  var currentContainerContent = [];
-
-  // Handle expand title - add as first paragraph if source is expand with title
-  if (sourceNode.type.name === 'expand' && (_sourceNode$attrs4 = sourceNode.attrs) !== null && _sourceNode$attrs4 !== void 0 && _sourceNode$attrs4.title) {
-    var titleParagraph = schema.nodes.paragraph.create({}, schema.text(sourceNode.attrs.title));
-    currentContainerContent.push(titleParagraph);
-  }
-  var flushCurrentContainer = function flushCurrentContainer() {
-    if (currentContainerContent.length > 0) {
-      var marks = getMarksWithBreakout(sourceNode, targetNodeType);
-      var containerNode = targetNodeType.create(targetAttrs, Fragment.fromArray(currentContainerContent), marks);
-      splits.push(containerNode);
-      currentContainerContent = [];
-    }
-  };
-  children.forEach(function (childNode) {
-    if (isContentSupported(childNode)) {
-      // Supported content - add to current container
-      currentContainerContent.push(childNode);
-    } else if (childNode.type.name === targetNodeType.name) {
-      // Same type of container merge contents
-      childNode.content.forEach(function (child) {
-        currentContainerContent.push(child);
-      });
-    } else if (childNode.isBlock) {
-      // Unsupported block node - flush current container, add block, continue
-      flushCurrentContainer();
-      splits.push(childNode);
-    } else {
-      // Unsupported inline content - convert to paragraph and add to container
-      var inlineContent = convertNodeToInlineContent(childNode, schema);
-      if (inlineContent.length > 0) {
-        var paragraph = schema.nodes.paragraph.create({}, Fragment.fromArray(inlineContent));
-        currentContainerContent.push(paragraph);
-      }
-    }
-  });
-
-  // Flush any remaining container content
-  flushCurrentContainer();
-  return splits;
-};

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

@@ -1,33 +0,0 @@
-import { isListNodeType } from './utils';
-export var getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent) {
-  var validTransformedContent = '';
-  var invalidContent = [];
-  if (sourceContent.content.length < 1) {
-    return {
-      inlineTextContent: '',
-      invalidContent: invalidContent
-    };
-  }
-  // Headings are not valid inside headings so convert heading nodes to paragraphs
-  sourceContent.forEach(function (node) {
-    if (['paragraph', 'heading', 'taskItem', 'codeBlock'].includes(node.type.name)) {
-      node.content.forEach(function (inlineNode) {
-        if (inlineNode.type.name === 'status') {
-          validTransformedContent += inlineNode.attrs.text;
-        } else {
-          validTransformedContent += "".concat(inlineNode.textContent);
-        }
-      });
-    } else if (!isListNodeType(node.type)) {
-      invalidContent.push(node);
-    }
-  });
-  return {
-    inlineTextContent: validTransformedContent,
-    invalidContent: invalidContent
-  };
-};
-export var getInlineNodeTextNode = function getInlineNodeTextNode(sourceContent, schema) {
-  var text = getInlineNodeTextContent(sourceContent).inlineTextContent;
-  return schema.text(text);
-};