@atlaskit/editor-plugin-block-menu 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 1.0.5
+
+### Patch Changes
+
+- [`b76a419d23d3d`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b76a419d23d3d) -
+  [ux] ED-29143 Transform nodes into layout
+- [`0d741324d534a`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/0d741324d534a) -
+  [ux] Adds wrapping of list node types in container node types.
+- Updated dependencies
+
+## 1.0.4
+
+### Patch Changes
+
+- [`30454d0f4baf2`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/30454d0f4baf2) -
+  Support multiple levels list to list transform
+- [`cb4decb701766`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/cb4decb701766) -
+  [ux] Enable max height on block menu flyout menu
+- Updated dependencies
+
 ## 1.0.3
 
 ### Patch Changes

package/dist/cjs/editor-commands/formatNode.js

@@ -18,7 +18,7 @@ var formatNode = exports.formatNode = function formatNode(targetType) {
 
     // Find the node to format from the current selection
     var nodeToFormat;
-    var nodePos = null;
+    var nodePos = selection.from;
 
     // Try to find the current node from selection
     var selectedNode = (0, _utils.findSelectedNodeOfType)([nodes.paragraph, nodes.heading, nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.bulletList, nodes.orderedList, nodes.taskList, nodes.layoutSection])(selection);

package/dist/cjs/editor-commands/transforms/layout-transforms.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertToLayout = void 0;
+var _styles = require("@atlaskit/editor-common/styles");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var convertToLayout = exports.convertToLayout = function convertToLayout(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos;
+  var _ref = tr.doc.type.schema.nodes || {},
+    layoutSection = _ref.layoutSection,
+    layoutColumn = _ref.layoutColumn,
+    paragraph = _ref.paragraph;
+  var content = sourceNode.mark(sourceNode.marks.filter(function (mark) {
+    return mark.type.name !== 'breakout';
+  }));
+  var layoutContent = _model.Fragment.fromArray([layoutColumn.createChecked({
+    width: _styles.DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH
+  }, content), layoutColumn.create({
+    width: _styles.DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH
+  }, paragraph.createAndFill())]);
+  var layoutSectionNode = layoutSection.createChecked(undefined, layoutContent);
+
+  // Replace the original node with the new layout node
+  tr.replaceRangeWith(sourcePos || 0, (sourcePos || 0) + sourceNode.nodeSize, layoutSectionNode);
+  return tr;
+};

package/dist/cjs/editor-commands/transforms/list/transformBetweenListTypes.js

@@ -6,91 +6,93 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.transformListStructure = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _utils = require("../utils");
 /**
  * Convert a block node to inline content suitable for task items
  */
 var convertBlockToInlineContent = function convertBlockToInlineContent(node, schema) {
   var paragraph = schema.nodes.paragraph;
   if (node.type === paragraph) {
-    // Extract inline content from paragraphs
     return (0, _toConsumableArray2.default)(node.content.content);
-  } else if (node.isBlock) {
-    // For other block content types eg. codeBlock, extract their text content and create text nodes
+  }
+  if (node.isBlock) {
     var textContent = node.textContent;
-    if (textContent) {
-      var textNode = schema.text(textContent);
-      return [textNode];
-    }
-  } else {
-    // Already inline content, add directly
-    return [node];
+    return textContent ? [schema.text(textContent)] : [];
   }
-  return [];
+  return [node];
 };
 
 /**
- * Transform list structure
+ * Transform list structure between different list types
  */
-var transformListStructure = exports.transformListStructure = function transformListStructure(tr, listNode, targetNodeType, nodes) {
+var transformListStructure = exports.transformListStructure = function transformListStructure(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos,
+    targetNodeType = context.targetNodeType;
+  var nodes = tr.doc.type.schema.nodes;
   try {
+    var listNode = {
+      node: sourceNode,
+      pos: sourcePos
+    };
     var sourceList = listNode.node,
       listPos = listNode.pos;
-    var bulletList = nodes.bulletList,
-      orderedList = nodes.orderedList,
-      taskList = nodes.taskList,
+    var taskList = nodes.taskList,
       listItem = nodes.listItem,
       taskItem = nodes.taskItem,
       paragraph = nodes.paragraph;
-    var isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
-    var isTargetTask = targetNodeType === taskList;
-    var isSourceTask = sourceList.type === taskList;
-    var newListItems = [];
-    var listStart = listPos;
-    var listEnd = listPos + sourceList.nodeSize;
-
-    // Use nodesBetween to efficiently traverse the list structure
-    tr.doc.nodesBetween(listStart, listEnd, function (node, pos, parent) {
-      // Only process direct children of the list (depth 1)
-      if (parent !== sourceList) {
-        return true; // Continue traversal
-      }
-      if (isSourceBulletOrOrdered && isTargetTask) {
-        // Converting from bullet/ordered list to task list
-        // Extract inline content from all children within listItem
-        if (node.type === listItem) {
-          var inlineContent = [];
-          // Extract inline content from all child nodes
-          node.forEach(function (child) {
-            inlineContent.push.apply(inlineContent, (0, _toConsumableArray2.default)(convertBlockToInlineContent(child, tr.doc.type.schema)));
-          });
-          if (inlineContent.length > 0) {
-            var newItem = taskItem.create(null, inlineContent);
-            newListItems.push(newItem);
+    var isSourceBulletOrOrdered = (0, _utils.isBulletOrOrderedList)(sourceList.type);
+    var isTargetTask = (0, _utils.isTaskList)(targetNodeType);
+    var isSourceTask = (0, _utils.isTaskList)(sourceList.type);
+    var isTargetBulletOrOrdered = (0, _utils.isBulletOrOrderedList)(targetNodeType);
+    var supportedListTypes = (0, _utils.getSupportedListTypesSet)(nodes);
+    var _transformListRecursively = function transformListRecursively(listNode) {
+      var transformedItems = [];
+      listNode.forEach(function (child) {
+        if (isSourceBulletOrOrdered && isTargetTask) {
+          // Convert bullet/ordered => task
+          if (child.type === listItem) {
+            var inlineContent = [];
+            var nestedTaskLists = [];
+            child.forEach(function (grandChild) {
+              if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
+                nestedTaskLists.push(_transformListRecursively(grandChild));
+              } else {
+                inlineContent.push.apply(inlineContent, (0, _toConsumableArray2.default)(convertBlockToInlineContent(grandChild, tr.doc.type.schema)));
+              }
+            });
+            if (inlineContent.length > 0) {
+              transformedItems.push(taskItem.create(null, inlineContent));
+            }
+            transformedItems.push.apply(transformedItems, nestedTaskLists);
           }
-        }
-      } else if (isSourceTask && !isTargetTask) {
-        // Converting from task list to bullet/ordered list
-        // Structure: taskItem > inline content -> listItem > paragraph > inline content
-        if (node.type === taskItem) {
-          var _inlineContent = (0, _toConsumableArray2.default)(node.content.content);
-          if (_inlineContent.length > 0) {
-            var paragraphNode = paragraph.create(null, _inlineContent);
-            var newListItem = listItem.create(null, paragraphNode);
-            newListItems.push(newListItem);
+        } else if (isSourceTask && isTargetBulletOrOrdered) {
+          // Convert task => bullet/ordered
+          if (child.type === taskItem) {
+            var _inlineContent = (0, _toConsumableArray2.default)(child.content.content);
+            if (_inlineContent.length > 0) {
+              var paragraphNode = paragraph.create(null, _inlineContent);
+              transformedItems.push(listItem.create(null, [paragraphNode]));
+            }
+          } else if (child.type === taskList) {
+            var transformedNestedList = _transformListRecursively(child);
+            var lastItem = transformedItems[transformedItems.length - 1];
+            if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
+              // Attach nested list to previous item
+              var updatedContent = [].concat((0, _toConsumableArray2.default)(lastItem.content.content), [transformedNestedList]);
+              transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
+            } else {
+              // No previous item, flatten nested items
+              transformedItems.push.apply(transformedItems, (0, _toConsumableArray2.default)(transformedNestedList.content.content));
+            }
           }
         }
-      }
-      return false; // Don't traverse into children of list items
-    });
-    if (newListItems.length === 0) {
-      return tr;
-    }
-
-    // Create new list with transformed items
-    var newList = targetNodeType.create(null, newListItems);
-
-    // Replace the entire list
-    tr.replaceWith(listStart, listEnd, newList);
+      });
+      return targetNodeType.create(null, transformedItems);
+    };
+    var newList = _transformListRecursively(sourceList);
+    tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch (_unused) {
     return tr;

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

@@ -1,16 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformListToBlockNodes = exports.transformListNode = exports.transformBlockToList = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
+exports.transformListToContainer = exports.transformListToBlockNodes = exports.transformListNode = exports.transformBlockToList = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _model = require("@atlaskit/editor-prosemirror/model");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
-var _utils = require("@atlaskit/editor-prosemirror/utils");
 var _transformBetweenListTypes = require("./list/transformBetweenListTypes");
 var _transformOrderedUnorderedListToBlockNodes = require("./list/transformOrderedUnorderedListToBlockNodes");
 var _transformTaskListToBlockNodes = require("./list/transformTaskListToBlockNodes");
 var _transformToTaskList = require("./list/transformToTaskList");
-var _utils2 = require("./utils");
+var _utils = require("./utils");
 /**
  * Transform selection to list type
  */
@@ -27,7 +29,7 @@ var transformBlockToList = exports.transformBlockToList = function transformBloc
     return null;
   }
   var nodes = tr.doc.type.schema.nodes;
-  var isTargetTask = targetNodeType === nodes.taskList;
+  var isTargetTask = (0, _utils.isTaskList)(targetNodeType);
 
   // Handle task lists differently due to their structure
   if (isTargetTask) {
@@ -63,25 +65,79 @@ var transformListToBlockNodes = exports.transformListToBlockNodes = function tra
   }
 };
 
+/**
+ * Wraps bulletList, orderedList or taskList in node of container type
+ */
+var transformListToContainer = exports.transformListToContainer = function transformListToContainer(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  if (sourcePos === null) {
+    return null;
+  }
+  var schema = tr.doc.type.schema;
+  var _schema$nodes = schema.nodes,
+    blockquote = _schema$nodes.blockquote,
+    taskList = _schema$nodes.taskList,
+    taskItem = _schema$nodes.taskItem,
+    paragraph = _schema$nodes.paragraph;
+
+  // Special case: Task list -> Blockquote
+  // Flattens the task list before wrapping by blockquote
+  if (sourceNode.type === taskList && targetNodeType === blockquote) {
+    var _extractParagraphsFromTaskList = function extractParagraphsFromTaskList(node) {
+      var paragraphs = [];
+      node.forEach(function (child) {
+        if (child.type === taskItem) {
+          if (child.content.size > 0) {
+            var paragraphNode = paragraph.createChecked({}, child.content.content);
+            paragraphs.push(paragraphNode);
+          }
+        } else if (child.type === taskList) {
+          paragraphs.push.apply(paragraphs, (0, _toConsumableArray2.default)(_extractParagraphsFromTaskList(child)));
+        }
+      });
+      return paragraphs;
+    };
+    var liftedParagraphs = _extractParagraphsFromTaskList(sourceNode);
+    var _containerNode = targetNodeType.createAndFill(targetAttrs, _model.Fragment.from(liftedParagraphs));
+    if (!_containerNode) {
+      return null;
+    }
+    tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, _containerNode);
+    return tr;
+  }
+
+  // Default case
+  var containerNode = targetNodeType.createAndFill(targetAttrs, [sourceNode]);
+  if (!containerNode) {
+    return null;
+  }
+  tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, containerNode);
+  return tr;
+};
+
 /**
  * Transform list nodes
  */
 var transformListNode = exports.transformListNode = function transformListNode(context) {
   var targetNodeType = context.targetNodeType;
   // Transform list to block type
-  if ((0, _utils2.isBlockNodeType)(targetNodeType)) {
+  if ((0, _utils.isBlockNodeType)(targetNodeType)) {
     // Lift list items out of the list and convert to target block type
     return transformListToBlockNodes(context);
   }
 
   // Transform list to container type
-  if ((0, _utils2.isContainerNodeType)(targetNodeType)) {
-    // Lift list items out of the list and convert to container type
-    return null;
+  if ((0, _utils.isContainerNodeType)(targetNodeType)) {
+    // Wrap list items into container type, where possible
+    return transformListToContainer(context);
   }
 
   // Transform between list types
-  if ((0, _utils2.isListNodeType)(targetNodeType)) {
+  if ((0, _utils.isListNodeType)(targetNodeType)) {
     return transformBetweenListTypes(context);
   }
   return null;
@@ -98,37 +154,48 @@ var liftListToBlockType = exports.liftListToBlockType = function liftListToBlock
 /**
  * Transform between different list types
  */
-var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes(_ref) {
-  var tr = _ref.tr,
-    targetNodeType = _ref.targetNodeType;
-  var _tr = tr,
-    selection = _tr.selection;
+var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos,
+    targetNodeType = context.targetNodeType;
   var nodes = tr.doc.type.schema.nodes;
-
-  // Find the list node - support bullet lists, ordered lists, and task lists
-  var supportedListTypes = [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean); // Filter out undefined nodes in case some schemas don't have all types
-
-  var listNode = (0, _utils.findParentNodeOfType)(supportedListTypes)(selection);
-  if (!listNode) {
-    return null;
-  }
-  var sourceListType = listNode.node.type;
-  var isSourceBulletOrOrdered = sourceListType === nodes.bulletList || sourceListType === nodes.orderedList;
-  var isTargetTask = targetNodeType === nodes.taskList;
-  var isSourceTask = sourceListType === nodes.taskList;
-  var isTargetBulletOrOrdered = targetNodeType === nodes.bulletList || targetNodeType === nodes.orderedList;
+  var sourceListType = sourceNode.type;
+  var isSourceBulletOrOrdered = (0, _utils.isBulletOrOrderedList)(sourceListType);
+  var isTargetTask = (0, _utils.isTaskList)(targetNodeType);
+  var isSourceTask = (0, _utils.isTaskList)(sourceListType);
+  var isTargetBulletOrOrdered = (0, _utils.isBulletOrOrderedList)(targetNodeType);
 
   // Check if we need structure transformation
   var needsStructureTransform = isSourceBulletOrOrdered && isTargetTask || isSourceTask && isTargetBulletOrOrdered;
   try {
     if (!needsStructureTransform) {
       // Simple type change for same structure lists (bullet <-> ordered)
-      tr.setNodeMarkup(listNode.pos, targetNodeType);
+      // Apply to the main list
+      tr.setNodeMarkup(sourcePos, targetNodeType);
+
+      // Apply to nested lists
+      var listStart = sourcePos;
+      var listEnd = sourcePos + sourceNode.nodeSize;
+      var supportedListTypesSet = (0, _utils.getSupportedListTypesSet)(nodes);
+      tr.doc.nodesBetween(listStart, listEnd, function (node, pos, parent) {
+        // Only process nested lists (not the root list we already handled)
+        if (supportedListTypesSet.has(node.type) && pos !== sourcePos) {
+          var isNestedList = parent && (supportedListTypesSet.has(parent.type) || parent.type === nodes.listItem);
+          if (isNestedList) {
+            var shouldTransformNode = node.type === sourceListType || (0, _utils.isBulletOrOrderedList)(node.type) && isTargetBulletOrOrdered;
+            if (shouldTransformNode) {
+              tr.setNodeMarkup(pos, targetNodeType);
+            }
+          }
+        }
+        return true; // Continue traversing
+      });
+      return tr;
     } else {
-      tr = (0, _transformBetweenListTypes.transformListStructure)(tr, listNode, targetNodeType, nodes);
+      return (0, _transformBetweenListTypes.transformListStructure)(context);
     }
   } catch (_unused) {
     return null;
   }
-  return tr;
 };

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.transformNodeToTargetType = transformNodeToTargetType;
 var _blockTransforms = require("./block-transforms");
 var _containerTransforms = require("./container-transforms");
+var _layoutTransforms = require("./layout-transforms");
 var _listTransforms = require("./list-transforms");
 var _utils = require("./utils");
 function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
@@ -43,6 +44,9 @@ function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
 
   // Route to appropriate transformation strategy based on source node type
   try {
+    if ((0, _utils.isLayoutNodeType)(targetNodeType)) {
+      return (0, _layoutTransforms.convertToLayout)(transformationContext);
+    }
     if ((0, _utils.isBlockNode)(sourceNode)) {
       return (0, _blockTransforms.transformBlockNode)(transformationContext);
     }

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isListNodeType = exports.isListNode = exports.isContainerNodeType = exports.isContainerNode = exports.isBlockNodeType = exports.isBlockNode = exports.getTargetNodeInfo = void 0;
+exports.isTaskList = exports.isListNodeType = exports.isListNode = exports.isLayoutNodeType = exports.isContainerNodeType = exports.isContainerNode = exports.isBulletOrOrderedList = exports.isBlockNodeType = exports.isBlockNode = exports.getTargetNodeInfo = exports.getSupportedListTypesSet = exports.getSupportedListTypes = void 0;
 var getTargetNodeInfo = exports.getTargetNodeInfo = function getTargetNodeInfo(targetType, nodes) {
   switch (targetType) {
     case 'heading1':
@@ -83,6 +83,10 @@ var getTargetNodeInfo = exports.getTargetNodeInfo = function getTargetNodeInfo(t
       return {
         nodeType: nodes.taskList
       };
+    case 'layoutSection':
+      return {
+        nodeType: nodes.layoutSection
+      };
     default:
       return null;
   }
@@ -93,7 +97,7 @@ var isBlockNode = exports.isBlockNode = function isBlockNode(node) {
   return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
 };
 var isListNode = exports.isListNode = function isListNode(node) {
-  return ['bulletList', 'orderedList', 'taskList', 'listItem'].includes(node.type.name);
+  return ['bulletList', 'orderedList', 'taskList'].includes(node.type.name);
 };
 var isContainerNode = exports.isContainerNode = function isContainerNode(node) {
   return ['panel', 'expand', 'blockquote'].includes(node.type.name);
@@ -106,4 +110,21 @@ var isListNodeType = exports.isListNodeType = function isListNodeType(nodeType)
 };
 var isContainerNodeType = exports.isContainerNodeType = function isContainerNodeType(nodeType) {
   return ['panel', 'expand', 'blockquote'].includes(nodeType.name);
+};
+
+// List type utilities
+var isBulletOrOrderedList = exports.isBulletOrOrderedList = function isBulletOrOrderedList(nodeType) {
+  return nodeType.name === 'bulletList' || nodeType.name === 'orderedList';
+};
+var isTaskList = exports.isTaskList = function isTaskList(nodeType) {
+  return nodeType.name === 'taskList';
+};
+var getSupportedListTypes = exports.getSupportedListTypes = function getSupportedListTypes(nodes) {
+  return [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean);
+};
+var getSupportedListTypesSet = exports.getSupportedListTypesSet = function getSupportedListTypesSet(nodes) {
+  return new Set(getSupportedListTypes(nodes));
+};
+var isLayoutNodeType = exports.isLayoutNodeType = function isLayoutNodeType(nodeType) {
+  return nodeType.name === 'layoutSection';
 };

package/dist/cjs/ui/block-menu-components.js

@@ -66,7 +66,8 @@ var getFormatMenuComponents = function getFormatMenuComponents() {
         }),
         elemAfter: /*#__PURE__*/_react.default.createElement(_chevronRight.default, {
           label: 'example nested menu'
-        })
+        }),
+        enableMaxHeight: true
       }, children);
     }
   }, {

package/dist/es2019/editor-commands/formatNode.js

@@ -17,7 +17,7 @@ export const formatNode = targetType => {
 
     // Find the node to format from the current selection
     let nodeToFormat;
-    let nodePos = null;
+    let nodePos = selection.from;
 
     // Try to find the current node from selection
     const selectedNode = findSelectedNodeOfType([nodes.paragraph, nodes.heading, nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.bulletList, nodes.orderedList, nodes.taskList, nodes.layoutSection])(selection);

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

@@ -0,0 +1,25 @@
+import { DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH } from '@atlaskit/editor-common/styles';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+export const convertToLayout = context => {
+  const {
+    tr,
+    sourceNode,
+    sourcePos
+  } = context;
+  const {
+    layoutSection,
+    layoutColumn,
+    paragraph
+  } = tr.doc.type.schema.nodes || {};
+  const content = sourceNode.mark(sourceNode.marks.filter(mark => mark.type.name !== 'breakout'));
+  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())]);
+  const layoutSectionNode = layoutSection.createChecked(undefined, layoutContent);
+
+  // Replace the original node with the new layout node
+  tr.replaceRangeWith(sourcePos || 0, (sourcePos || 0) + sourceNode.nodeSize, layoutSectionNode);
+  return tr;
+};