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

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

@@ -1,348 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-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 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';
-    var nodeToTransform = node;
-    if (isContainerNodeType(finalTargetNodeType) || isListNodeType(finalTargetNodeType)) {
-      nodeToTransform = node.mark(node.marks.filter(function (mark) {
-        return !['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) {
-      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 transformToCodeBlock = function transformToCodeBlock(nodes, schema) {
-  var newNodes = [];
-  var addToNewNodes = function addToNewNodes(content) {
-    if (newNodes.length === 0) {
-      newNodes.push({
-        canBeTransformed: true,
-        content: content
-      });
-    } 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), _toConsumableArray(content)),
-          canBeTransformed: true
-        };
-      } else {
-        newNodes.push({
-          content: content,
-          canBeTransformed: true
-        });
-      }
-    }
-  };
-  nodes.forEach(function (node) {
-    if (node.isTextblock) {
-      var inlineTextContent = node.type === schema.nodes.codeBlock ? node.textContent : getInlineNodeTextContent(Fragment.from(node)).inlineTextContent;
-      addToNewNodes([inlineTextContent]);
-    } else if (isListNode(node)) {
-      var textContent = [];
-      var listItemType = node.type === schema.nodes.taskList ? schema.nodes.taskItem : schema.nodes.listItem;
-      var listItems = findChildrenByType(node, listItemType).map(function (item) {
-        return item.node;
-      });
-      listItems.forEach(function (listItem) {
-        if (listItem.type === schema.nodes.taskItem) {
-          var _inlineTextContent = getInlineNodeTextContent(Fragment.from(listItem)).inlineTextContent;
-          textContent.push(_inlineTextContent);
-        } else {
-          var _inlineTextContent2 = getInlineNodeTextContent(listItem.content).inlineTextContent;
-          textContent.push(_inlineTextContent2);
-        }
-      });
-      addToNewNodes(textContent);
-    } else {
-      // If not text block or list node, 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 schema.nodes.codeBlock.createChecked(null, schema.text(text));
-    } else {
-      return content;
-    }
-  }).filter(Boolean);
-};
-var transformToBlockNode = function transformToBlockNode(nodes, targetNodeType, schema) {
-  if (targetNodeType === schema.nodes.codeBlock) {
-    return transformToCodeBlock(nodes, schema);
-  }
-  var newNodes = [];
-  nodes.forEach(function (node) {
-    if (isListNode(node)) {
-      var listItemType = node.type === schema.nodes.taskList ? schema.nodes.taskItem : schema.nodes.listItem;
-      var listItems = findChildrenByType(node, listItemType).map(function (item) {
-        return item.node;
-      });
-      listItems.forEach(function (listItem) {
-        if (listItem.type === schema.nodes.taskItem) {
-          var inlineContent = _toConsumableArray(listItem.content.content);
-          if (inlineContent.length > 0) {
-            newNodes.push(targetNodeType.createChecked(null, inlineContent));
-          }
-        } else {
-          listItem.forEach(function (child) {
-            if (isHeadingOrParagraphNode(child)) {
-              newNodes.push(targetNodeType.createChecked(null, _toConsumableArray(child.content.content)));
-            }
-          });
-        }
-      });
-    } else {
-      newNodes.push(node);
-    }
-  });
-  return newNodes;
-};
-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 {
-      var 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;
-      }
-      var _nodes = isSameNodeType ? node.content.content : [node];
-      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 unsupportedContent = [];
-  var onhandleUnsupportedContent = function onhandleUnsupportedContent(content) {
-    unsupportedContent.push(content);
-  };
-  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
-          }, onhandleUnsupportedContent);
-          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 [].concat(_toConsumableArray(listItems.map(function (_ref3) {
-    var node = _ref3.node,
-      canBeTransformed = _ref3.canBeTransformed;
-    if (canBeTransformed) {
-      return targetNodeType.createChecked(null, Fragment.fromArray(node));
-    } else {
-      return node;
-    }
-  })), unsupportedContent);
-};
-export var convertUnwrappedLayoutContent = function 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)) {
-      var 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/esm/editor-commands/transforms/layout-transforms.js

@@ -1,72 +0,0 @@
-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';
-import { getMarksWithBreakout, isHeadingOrParagraphNode } from './utils';
-export var createDefaultLayoutSection = function createDefaultLayoutSection(schema, content, marks) {
-  var _schema$nodes = schema.nodes,
-    layoutSection = _schema$nodes.layoutSection,
-    layoutColumn = _schema$nodes.layoutColumn,
-    paragraph = _schema$nodes.paragraph;
-  var 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 var convertToLayout = function convertToLayout(context) {
-  var tr = context.tr,
-    sourceNode = context.sourceNode,
-    sourcePos = context.sourcePos;
-  var content = sourceNode.mark(sourceNode.marks.filter(function (mark) {
-    return 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
-  var marks = getMarksWithBreakout(sourceNode, tr.doc.type.schema.nodes.layoutSection);
-  var 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 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 _ref = schema.nodes || {},
-    layoutSection = _ref.layoutSection,
-    layoutColumn = _ref.layoutColumn,
-    paragraph = _ref.paragraph,
-    heading = _ref.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, 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/esm/editor-commands/transforms/list/transformOrderedUnorderedListToBlockNodes.js

@@ -1,90 +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 { getContentSupportChecker, isListNode } from '../utils';
-export var transformOrderedUnorderedListToBlockNodes = function transformOrderedUnorderedListToBlockNodes(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 targetNodes = [];
-  // find all list items inside the list node
-  var listItems = findChildrenByType(sourceNode, schema.nodes.listItem);
-  var textContent = [];
-  var flushTextContent = function flushTextContent() {
-    if (targetNodeType !== schema.nodes.codeBlock) {
-      return;
-    }
-    if (textContent.length > 0) {
-      var inlineText = textContent.join('\n');
-      targetNodes.push(schema.nodes.codeBlock.createChecked({}, inlineText !== '' ? schema.text(inlineText) : null));
-      textContent = [];
-    }
-  };
-  listItems.forEach(function (listItem) {
-    // Convert paragraphs to headings if target is heading
-    var content = listItem.node.content.content;
-    content.forEach(function (node) {
-      var 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) {
-        var inlineContent = node.textContent;
-        textContent = [].concat(_toConsumableArray(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) {
-        var _inlineContent = getInlineNodeTextContent(Fragment.from(node)).inlineTextContent;
-        textContent = [].concat(_toConsumableArray(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)
-        var _textContent = node.textContent.split('\n');
-        var 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(function (textLine) {
-          targetNodes.push(targetNodeType.createChecked(attributes, textLine ? schema.text(textLine) : null));
-        });
-        return;
-      }
-      if (targetNodeType === schema.nodes.heading && targetAttrs) {
-        var targetHeadingLevel = targetAttrs.level;
-        targetNodes.push(schema.nodes.heading.createChecked({
-          level: targetHeadingLevel
-        }, node.content));
-        return;
-      }
-      targetNodes.push(node);
-    });
-  });
-  flushTextContent();
-  var fragment = Fragment.fromArray(targetNodes);
-  var slice = new Slice(fragment, 0, 0);
-  var rangeStart = sourcePos !== null ? sourcePos : selection.from;
-  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
-  return tr;
-};

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

@@ -1,53 +0,0 @@
-import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
-import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-export var transformTaskListToBlockNodes = function transformTaskListToBlockNodes(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 taskItemsResult = findChildrenByType(sourceNode, schema.nodes.taskItem);
-  var taskItems = taskItemsResult.map(function (item) {
-    return item.node;
-  });
-  var taskItemFragments = taskItems.map(function (taskItem) {
-    return taskItem.content;
-  });
-  var targetNodes = [];
-
-  // Convert fragments to headings if target is heading
-  if (targetNodeType === schema.nodes.heading && targetAttrs) {
-    // convert the fragments to headings
-    var targetHeadingLevel = targetAttrs.level;
-    targetNodes = taskItemFragments.map(function (fragment) {
-      return 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(function (fragment) {
-      return 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
-    var codeBlockContent = taskItemFragments.map(function (fragment) {
-      return 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
-  var slice = new Slice(Fragment.fromArray(targetNodes), 0, 0);
-  var rangeStart = sourcePos !== null ? sourcePos : selection.from;
-  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
-  return tr;
-};

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

@@ -1,37 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-/**
- * Transform selection to task list
- * Handles the special structure where taskItem contains text directly (no paragraph wrapper)
- */
-export var transformToTaskList = function transformToTaskList(tr, range, targetNodeType, targetAttrs, nodes) {
-  try {
-    var taskItem = nodes.taskItem;
-    var listItems = [];
-
-    // Process each block in the range
-    tr.doc.nodesBetween(range.start, range.end, function (node) {
-      if (node.isBlock) {
-        // For block nodes like paragraphs, directly use their inline content
-        var inlineContent = _toConsumableArray(node.content.content);
-        if (inlineContent.length > 0) {
-          // Create task item with inline content directly
-          var 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
-    var newList = targetNodeType.create(targetAttrs, listItems);
-
-    // Replace the range with the new list
-    tr.replaceWith(range.start, range.end, newList);
-    return tr;
-  } catch (_unused) {
-    return null;
-  }
-};