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

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

@@ -1,168 +0,0 @@
-import { transformBetweenListTypes, isTaskList } from '@atlaskit/editor-common/transforms';
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
-import { transformOrderedUnorderedListToBlockNodes } from './list/transformOrderedUnorderedListToBlockNodes';
-import { transformTaskListToBlockNodes } from './list/transformTaskListToBlockNodes';
-import { transformToTaskList } from './list/transformToTaskList';
-import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
-
-/**
- * Transform selection to list type
- */
-export const transformBlockToList = context => {
-  const {
-    tr,
-    sourceNode,
-    targetNodeType,
-    targetAttrs
-  } = context;
-  const {
-    $from,
-    $to
-  } = tr.selection;
-  const schema = tr.doc.type.schema;
-  const range = $from.blockRange($to);
-  if (!range) {
-    return null;
-  }
-  const {
-    nodes
-  } = tr.doc.type.schema;
-  const isTargetTask = isTaskList(targetNodeType);
-
-  // Handle task lists differently due to their structure
-  if (isTargetTask) {
-    return transformToTaskList(tr, range, targetNodeType, targetAttrs, nodes);
-  }
-
-  // filter marks that are not allowed in the target node type
-  if (sourceNode.type === schema.nodes.paragraph || sourceNode.type === schema.nodes.heading) {
-    const allowedMarks = targetNodeType.allowedMarks(sourceNode.marks);
-    tr.setNodeMarkup(range.start, null, null, allowedMarks);
-  }
-
-  // For headings, convert to paragraph first since headings cannot be direct children of list items
-  if (sourceNode && sourceNode.type.name.startsWith('heading')) {
-    tr.setBlockType(range.start, range.end, nodes.paragraph);
-  }
-
-  // Get the current range (updated if we converted from heading)
-  const currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
-
-  // Wrap in the target list type
-  const wrapping = findWrapping(currentRange, targetNodeType, targetAttrs);
-  if (!wrapping) {
-    return null;
-  }
-  tr.wrap(currentRange, wrapping);
-  return tr;
-};
-
-/**
- * Transform list to block nodes
- */
-export const transformListToBlockNodes = context => {
-  const {
-    sourceNode
-  } = context;
-  if (sourceNode.type.name === 'taskList') {
-    return transformTaskListToBlockNodes(context);
-  } else {
-    return transformOrderedUnorderedListToBlockNodes(context);
-  }
-};
-
-/**
- * Wraps bulletList, orderedList or taskList in node of container type
- */
-export const transformListToContainer = context => {
-  const {
-    tr,
-    sourceNode,
-    sourcePos,
-    targetNodeType,
-    targetAttrs
-  } = context;
-  if (sourcePos === null) {
-    return null;
-  }
-  const {
-    schema
-  } = tr.doc.type;
-  const {
-    blockquote,
-    taskList,
-    taskItem,
-    paragraph
-  } = schema.nodes;
-
-  // Special case: Task list -> Blockquote
-  // Flattens the task list before wrapping by blockquote
-  if (sourceNode.type === taskList && targetNodeType === blockquote) {
-    const extractParagraphsFromTaskList = node => {
-      const paragraphs = [];
-      node.forEach(child => {
-        if (child.type === taskItem) {
-          if (child.content.size > 0) {
-            const paragraphNode = paragraph.createChecked({}, child.content.content);
-            paragraphs.push(paragraphNode);
-          }
-        } else if (child.type === taskList) {
-          paragraphs.push(...extractParagraphsFromTaskList(child));
-        }
-      });
-      return paragraphs;
-    };
-    const liftedParagraphs = extractParagraphsFromTaskList(sourceNode);
-    const containerNode = targetNodeType.createAndFill(targetAttrs, Fragment.from(liftedParagraphs));
-    if (!containerNode) {
-      return null;
-    }
-    tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, containerNode);
-    return tr;
-  }
-
-  // Default case
-  const containerNode = targetNodeType.createAndFill(targetAttrs, [sourceNode]);
-  if (!containerNode) {
-    return null;
-  }
-  tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, containerNode);
-  return tr;
-};
-
-/**
- * Transform list nodes
- */
-export const transformListNode = context => {
-  const {
-    targetNodeType
-  } = context;
-  // Transform list to block type
-  if (isBlockNodeType(targetNodeType)) {
-    // Lift list items out of the list and convert to target block type
-    return transformListToBlockNodes(context);
-  }
-
-  // Transform list to container type
-  if (isContainerNodeType(targetNodeType)) {
-    // Wrap list items into container type, where possible
-    return transformListToContainer(context);
-  }
-
-  // Transform between list types
-  if (isListNodeType(targetNodeType)) {
-    return transformBetweenListTypes(context);
-  }
-  return null;
-};
-
-/**
- * Lift list content and convert to block type
- */
-export const liftListToBlockType = () => {
-  // Convert to target block type directly
-  return null;
-};
-
-// transformBetweenListTypes is now imported from @atlaskit/editor-common/transforms

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

@@ -1,76 +0,0 @@
-import { transformBlockNode } from './block-transforms';
-import { transformContainerNode, unwrapAndConvertToList } from './container-transforms';
-import { convertToLayout, transformLayoutNode } from './layout-transforms';
-import { transformListNode } from './list-transforms';
-import { getTargetNodeInfo, isBlockNode, isListNode, isListNodeType, isContainerNode, isLayoutNodeType, isLayoutNode } from './utils';
-
-/**
- * Transforms a source node to the specified target type.
- * Throws errors on failure which should be caught at the command level.
- *
- * @param tr - The transaction to apply transformations to
- * @param sourceNode - The node to transform
- * @param sourcePos - The position of the source node in the document
- * @param targetType - The target node type to transform to
- * @returns The modified transaction if successful, null if transformation is not possible
- */
-export function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
-  const {
-    nodes
-  } = tr.doc.type.schema;
-  const targetNodeInfo = getTargetNodeInfo(targetType, nodes);
-  if (!targetNodeInfo) {
-    return null;
-  }
-  const {
-    nodeType: targetNodeType,
-    attrs: targetAttrs
-  } = targetNodeInfo;
-
-  // Early return if trying to transform to the same type
-  if (sourceNode.type.name === targetNodeType.name) {
-    // For headings, also check if the level matches
-    if (targetNodeType.name === 'heading') {
-      var _sourceNode$attrs;
-      const sourceLevel = (_sourceNode$attrs = sourceNode.attrs) === null || _sourceNode$attrs === void 0 ? void 0 : _sourceNode$attrs.level;
-      const targetLevel = targetAttrs === null || targetAttrs === void 0 ? void 0 : targetAttrs.level;
-      if (sourceLevel === targetLevel) {
-        return tr;
-      }
-    } else {
-      return tr;
-    }
-  }
-
-  // Prepare transformation context
-  const transformationContext = {
-    tr,
-    sourceNode,
-    sourcePos,
-    targetNodeType,
-    targetAttrs
-  };
-
-  // Route to appropriate transformation strategy based on source node type
-  if (isLayoutNodeType(targetNodeType)) {
-    return convertToLayout(transformationContext);
-  }
-
-  // special case codeblock to listType
-  if (sourceNode.type.name === 'codeBlock' && isListNodeType(targetNodeType)) {
-    return unwrapAndConvertToList(transformationContext);
-  }
-  if (isLayoutNode(sourceNode)) {
-    return transformLayoutNode(transformationContext);
-  }
-  if (isBlockNode(sourceNode)) {
-    return transformBlockNode(transformationContext);
-  }
-  if (isListNode(sourceNode)) {
-    return transformListNode(transformationContext);
-  }
-  if (isContainerNode(sourceNode)) {
-    return transformContainerNode(transformationContext);
-  }
-  return null;
-}

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

@@ -1,248 +0,0 @@
-import { breakoutResizableNodes } from '@atlaskit/editor-common/utils';
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
-export const getTargetNodeInfo = (targetType, nodes) => {
-  switch (targetType) {
-    case 'heading1':
-      return {
-        nodeType: nodes.heading,
-        attrs: {
-          level: 1
-        }
-      };
-    case 'heading2':
-      return {
-        nodeType: nodes.heading,
-        attrs: {
-          level: 2
-        }
-      };
-    case 'heading3':
-      return {
-        nodeType: nodes.heading,
-        attrs: {
-          level: 3
-        }
-      };
-    case 'heading4':
-      return {
-        nodeType: nodes.heading,
-        attrs: {
-          level: 4
-        }
-      };
-    case 'heading5':
-      return {
-        nodeType: nodes.heading,
-        attrs: {
-          level: 5
-        }
-      };
-    case 'heading6':
-      return {
-        nodeType: nodes.heading,
-        attrs: {
-          level: 6
-        }
-      };
-    case 'paragraph':
-      return {
-        nodeType: nodes.paragraph
-      };
-    case 'blockquote':
-      return {
-        nodeType: nodes.blockquote
-      };
-    case 'expand':
-      return {
-        nodeType: nodes.expand
-      };
-    case 'panel':
-      return {
-        nodeType: nodes.panel,
-        attrs: {
-          panelType: 'info'
-        }
-      };
-    case 'codeBlock':
-      return {
-        nodeType: nodes.codeBlock
-      };
-    case 'bulletList':
-      return {
-        nodeType: nodes.bulletList
-      };
-    case 'orderedList':
-      return {
-        nodeType: nodes.orderedList
-      };
-    case 'taskList':
-      return {
-        nodeType: nodes.taskList
-      };
-    case 'layoutSection':
-      return {
-        nodeType: nodes.layoutSection
-      };
-    default:
-      return null;
-  }
-};
-
-// Helper functions to categorize node types
-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);
-};
-export const isContainerNode = node => {
-  return ['panel', 'expand', 'blockquote'].includes(node.type.name);
-};
-export const isBlockNodeType = nodeType => {
-  return ['paragraph', 'heading', 'codeBlock'].includes(nodeType.name);
-};
-export const isListNodeType = nodeType => {
-  return ['bulletList', 'orderedList', 'taskList'].includes(nodeType.name);
-};
-export const isContainerNodeType = nodeType => {
-  return ['panel', 'expand', 'blockquote'].includes(nodeType.name);
-};
-
-// List type utilities moved to @atlaskit/editor-common/transforms
-
-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
- * rather than converted to inline content
- */
-export const isBlockNodeForExtraction = node => {
-  const blockNodesForExtraction = ['table', 'mediaSingle', 'extension', 'bodiedExtension', 'blockCard', 'embedCard'];
-  return blockNodesForExtraction.includes(node.type.name);
-};
-
-/**
- * Get a function that checks if content is supported in the target container type
- */
-export const getContentSupportChecker = targetNodeType => {
-  return node => {
-    // Check if the target container type can contain this node
-    try {
-      return targetNodeType.validContent(Fragment.from(node));
-    } catch {
-      return false;
-    }
-  };
-};
-
-/**
- * Convert a node to inline content that can be placed in a paragraph
- */
-export const convertNodeToInlineContent = (node, schema) => {
-  // Extract text and inline nodes from any complex node
-  const inlineNodes = [];
-  node.descendants(childNode => {
-    if (childNode.isText) {
-      inlineNodes.push(childNode);
-    } else if (childNode.isInline) {
-      inlineNodes.push(childNode);
-    }
-    return true; // Continue traversing
-  });
-
-  // If no inline content was found but the node has text content,
-  // create a text node with the full text content
-  if (inlineNodes.length === 0 && node.textContent) {
-    return [schema.text(node.textContent)];
-  }
-  return inlineNodes;
-};
-
-/**
- * Filter marks from content based on the target node type
- * @param content The content fragment to filter
- * @param targetNodeType The target node type to check against
- * @returns A new fragment with marks filtered for the target node type
- */
-export const filterMarksForTargetNodeType = (content, targetNodeType) => {
-  const withValidMarks = [];
-  content.forEach(node => {
-    if (node.marks.length > 0) {
-      const allowedMarks = targetNodeType.allowedMarks(node.marks);
-      const updatedNode = node.mark(allowedMarks);
-      withValidMarks.push(updatedNode);
-    } else {
-      withValidMarks.push(node);
-    }
-  });
-  return Fragment.from(withValidMarks);
-};
-
-/** * Convert content from a code block node into multiple paragraph nodes
- */
-export const convertCodeBlockContentToParagraphs = (codeBlockNode, schema) => {
-  const paragraphNodes = [];
-  const codeText = codeBlockNode.textContent;
-  const lines = codeText.split('\n');
-  lines.forEach(line => {
-    const paragraphNode = schema.nodes.paragraph.create(null, line ? schema.text(line) : null);
-    paragraphNodes.push(paragraphNode);
-  });
-  return paragraphNodes;
-};
-const isBreakoutMarkSupported = nodeType => {
-  return editorExperiment('platform_synced_block', true) ? breakoutResizableNodes.includes(nodeType.name) : ['codeBlock', 'expand', 'layoutSection'].includes(nodeType.name);
-};
-export const getMarksWithBreakout = (sourceNode, targetNodeType) => {
-  const allowedMarks = targetNodeType.allowedMarks(sourceNode.marks);
-  const sourceBreakoutMark = sourceNode.marks.find(mark => mark.type.name === 'breakout');
-  if (sourceBreakoutMark && isBreakoutMarkSupported(targetNodeType)) {
-    // Check if breakout mark is already in allowedMarks to avoid duplicates
-    const hasBreakoutMark = allowedMarks.some(mark => mark.type.name === 'breakout');
-    return hasBreakoutMark ? allowedMarks : [...allowedMarks, sourceBreakoutMark];
-  }
-  return allowedMarks;
-};
-
-/**
- * Determines the conversion type based on source and target node types
- * This is for analytics use - these types match existing analytics events for consistency
- */
-export const getConversionType = (from, to) => {
-  // Block node insertion: block-like elements inserted from empty line or wrapping text/list
-  const blockNodes = ['panel', 'expand', 'codeBlock', 'layoutSection', 'taskList'];
-  const textNodes = ['paragraph', 'blockquote'];
-  const headingNodes = ['heading1', 'heading2', 'heading3', 'heading4', 'heading5', 'heading6'];
-  const listNodes = ['bulletList', 'orderedList'];
-
-  // Check if converting to block nodes from text/heading/list nodes
-  if (blockNodes.includes(to) && (textNodes.includes(from) || headingNodes.includes(from) || listNodes.includes(from))) {
-    return 'blockNodeInserted';
-  }
-
-  // Check if converting from paragraph/blockquote to list
-  if (listNodes.includes(to) && textNodes.includes(from)) {
-    return 'listInserted';
-  }
-
-  // Check if converting from list to paragraph/heading/blockquote or between list types
-  if (listNodes.includes(from) && (listNodes.includes(to) || textNodes.includes(to))) {
-    return 'listConverted';
-  }
-
-  // Text formatting: conversions among paragraph/headings/blockquote
-  if ((textNodes.includes(from) || headingNodes.includes(from)) && (textNodes.includes(to) || headingNodes.includes(to))) {
-    return 'textFormatted';
-  }
-  // For other conversions, we do not have a matching event category
-  return undefined;
-};

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

@@ -1,50 +0,0 @@
-import { transformToContainer, unwrapAndConvertToBlockType } from './container-transforms';
-import { getInlineNodeTextNode } from './inline-node-transforms';
-import { transformBlockToList } from './list-transforms';
-import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
-
-/**
- * Transform block nodes (paragraph, heading, codeblock)
- */
-export var transformBlockNode = function transformBlockNode(context) {
-  var targetNodeType = context.targetNodeType;
-
-  // Handle transformation to list types
-  if (isListNodeType(targetNodeType)) {
-    return transformBlockToList(context);
-  }
-
-  // Handle transformation to container types (panel, expand, blockquote)
-  if (isContainerNodeType(targetNodeType)) {
-    return transformToContainer(context);
-  }
-
-  // Handle block type transformation (paragraph, heading, codeblock)
-  if (isBlockNodeType(targetNodeType)) {
-    return transformToBlockNode(context);
-  }
-  return null;
-};
-var transformToBlockNode = function transformToBlockNode(context) {
-  var tr = context.tr,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs,
-    sourceNode = context.sourceNode;
-  var selection = tr.selection,
-    doc = tr.doc;
-  var $from = selection.$from,
-    $to = selection.$to;
-  var schema = doc.type.schema;
-  if (targetNodeType === schema.nodes.codeBlock) {
-    var textContent = getInlineNodeTextNode(selection.content().content, schema);
-    var node = schema.nodes.codeBlock.createChecked(undefined, textContent);
-    return tr.replaceRangeWith(selection.from, selection.to, node);
-  }
-
-  // code block acts like a container, we need to unwrap it
-  if (sourceNode.type === schema.nodes.codeBlock) {
-    return unwrapAndConvertToBlockType(context);
-  }
-  tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
-  return tr;
-};