WIP refactoring for document updating by NodePath. HR reaction updated, so it works within CompositeNode

Author: alexgarbarev

super_editor/example/lib/main_components_in_components.dart

@@ -321,14 +321,7 @@ class _BannerNode extends CompositeNode {
     throw UnimplementedError('Copy more than one child node is not yet implemented');
   }
 
-  @override
-  CompositeNode copyAndReplaceLeaf({required CompositeNodePosition position, required DocumentNode newLeaf}) {
-    return internalCopyAndReplaceLeaf(
-      position: position,
-      newLeaf: newLeaf,
-      compositeNodeBuilder: (old, newChildren) {
-        return _BannerNode(id: old.id, metadata: metadata, children: newChildren);
-      },
-    );
+  CompositeNode copyWithChildren(List<DocumentNode> newChildren) {
+    return _BannerNode(id: id, metadata: metadata, children: newChildren);
   }
 }

super_editor/lib/src/core/document.dart

@@ -53,6 +53,10 @@ abstract class Document implements Iterable<DocumentNode> {
   /// has the given [nodeId], or `-1` if the node does not exist.
   int getNodeIndexById(String nodeId);
 
+  /// Returns the index of the `DocumentNode` in parent node. If this
+  /// is a root node, then returns the index in this `Document`.
+  int getNodeIndexInParent(NodePath path);
+
   /// Returns the [DocumentNode] that appears immediately before the
   /// given [node] in this [Document], or null if the given [node]
   /// is the first node, or the given [node] does not exist in this
@@ -147,9 +151,9 @@ class NodePath {
 
   bool get isRoot => _path.length == 1;
 
-  String get rootId => _path.first;
+  String get rootNodeId => _path.first;
 
-  String get leafId => _path.last;
+  String get leafNodeId => _path.last;
 
   NodePath? toLeafParentPath() {
     if (length > 1) {
@@ -160,7 +164,7 @@ class NodePath {
 
   @override
   String toString() {
-    return isRoot ? rootId : _path.join('.');
+    return isRoot ? rootNodeId : _path.join('.');
   }
 
   @override
@@ -184,6 +188,10 @@ class NodePath {
 
   @override
   int get hashCode => _path.hashCode;
+
+  NodePath append(String childId) {
+    return NodePath([..._path, childId]);
+  }
 }
 
 /// Listener that's notified when a document changes.
@@ -225,9 +233,9 @@ abstract class NodeDocumentChange extends DocumentChange {
   const NodeDocumentChange();
 
   @Deprecated('Use rootNodeId instead or nodePath')
-  String get nodeId => nodePath.rootId;
+  String get nodeId => nodePath.rootNodeId;
 
-  String get rootNodeId => nodePath.rootId;
+  String get rootNodeId => nodePath.rootNodeId;
 
   NodePath get nodePath;
 }
@@ -380,7 +388,7 @@ class DocumentPosition {
     for (var i = nodePath.length - 1; i > 0; i -= 1) {
       resultPosition = CompositeNodePosition(nodePath.getAt(i), resultPosition);
     }
-    return DocumentPosition(nodeId: nodePath.rootId, nodePosition: resultPosition);
+    return DocumentPosition(nodeId: nodePath.rootNodeId, nodePosition: resultPosition);
   }
 
   /// ID of a [DocumentNode] within a [Document].

super_editor/lib/src/core/editor.dart

@@ -1210,7 +1210,7 @@ class MutableDocument with Iterable<DocumentNode> implements Document, Editable
 
   @override
   DocumentNode? getNodeAtPath(NodePath path) {
-    var node = getNodeById(path.rootId);
+    var node = getNodeById(path.rootNodeId);
     for (var i = 1; i < path.length; i += 1) {
       final childId = path.getAt(i);
       assert(
@@ -1222,14 +1222,27 @@ class MutableDocument with Iterable<DocumentNode> implements Document, Editable
     return node;
   }
 
+  @override
+  int getNodeIndexInParent(NodePath path) {
+    final parentPath = path.toLeafParentPath();
+    if (parentPath == null) {
+      return getNodeIndexById(path.rootNodeId);
+    }
+    final parent = getNodeAtPath(parentPath) as CompositeNode;
+    return parent.getChildIndexByNodeId(path.leafNodeId);
+  }
+
   @override
   DocumentNode? getLeafNode(DocumentPosition position) => getNodeAtPath(NodePath.withDocumentPosition(position));
 
   @override
   CompositeNode? getLeafNodeParent(DocumentPosition position) {
     final path = NodePath.withDocumentPosition(position).toLeafParentPath();
-    final node = path != null ? getNodeAtPath(path) : null;
-    assert(node is CompositeNode, 'Unexpected Leaf Parent Node ${node.runtimeType}. CompositeNode expected');
+    if (path == null) {
+      return null;
+    }
+    final node = getNodeAtPath(path);
+    assert(node is CompositeNode, 'Unexpected Leaf Parent Node "${node.runtimeType}". CompositeNode expected');
     return node as CompositeNode;
   }
 
@@ -1383,20 +1396,56 @@ class MutableDocument with Iterable<DocumentNode> implements Document, Editable
     }
   }
 
+  void replaceNodeByPath(NodePath path, DocumentNode newNode) {
+    var replacement = newNode;
+    if (!path.isRoot) {
+      final node = getNodeById(path.rootNodeId);
+      assert(node is CompositeNode);
+      replacement = (node as CompositeNode).copyAndReplaceLeafChildren(
+        nodePath: path.toLeafParentPath()!,
+        childrenReplacer: (CompositeNode leafNode, List<DocumentNode> children) {
+          return children.map((c) => c.id == path.leafNodeId ? newNode : c).toList();
+        },
+      );
+    }
+    return replaceNodeById(path.rootNodeId, replacement);
+  }
+
   /// Replaces leaf node based on [position]. All CompositeNodes are copied and
   /// given newNode is replaced by its id
   void replaceLeafNodeByPosition(DocumentPosition position, DocumentNode newNode) {
-    final nodePosition = position.nodePosition;
-    var replacement = newNode;
-    if (nodePosition is CompositeNodePosition) {
-      final node = getNodeById(position.nodeId);
+    return replaceNodeByPath(NodePath.withDocumentPosition(position), newNode);
+  }
+
+  /// Inserts [newNode] immediately after the given [existingNode].
+  void insertNodeAfterPath({
+    required NodePath existingNodePath,
+    required DocumentNode newNode,
+  }) {
+    if (existingNodePath.isRoot) {
+      return insertNodeAfter(
+        existingNodeId: existingNodePath.rootNodeId,
+        newNode: newNode,
+      );
+    } else {
+      final leafParentPath = existingNodePath.toLeafParentPath()!;
+      final leafParent = getNodeAtPath(leafParentPath) as CompositeNode;
+      final insertIndex = leafParent.getChildIndexByNodeId(existingNodePath.leafNodeId);
+
+      final node = getNodeById(existingNodePath.rootNodeId);
       assert(node is CompositeNode);
-      replacement = (node as CompositeNode).copyAndReplaceLeaf(
-        position: nodePosition,
-        newLeaf: newNode,
+
+      final replacement = (node as CompositeNode).copyAndReplaceLeafChildren(
+        nodePath: leafParentPath,
+        childrenReplacer: (CompositeNode leafNode, List<DocumentNode> children) {
+          final newChildren = List.of(children);
+          newChildren.insert(insertIndex, newNode);
+          return newChildren;
+        },
       );
+
+      replaceNodeById(existingNodePath.rootNodeId, replacement);
     }
-    return replaceNodeById(position.nodeId, replacement);
   }
 
   /// Returns [true] if the content of the [other] [Document] is equivalent

super_editor/lib/src/default_editor/common_editor_operations.dart

@@ -930,10 +930,6 @@ class CommonEditorOperations {
       return true;
     }
 
-    // TODO: Implement support for CompositeNode
-    if (composer.selection!.extent.nodePosition is UpstreamDownstreamNodePosition) {
-      final nodePosition = composer.selection!.extent.nodePosition as UpstreamDownstreamNodePosition;
-      if (nodePosition.affinity == TextAffinity.upstream) {
     final extentLeafPosition = composer.selection!.extent.leafNodePosition;
     if (extentLeafPosition is UpstreamDownstreamNodePosition) {
       if (extentLeafPosition.affinity == TextAffinity.upstream) {

super_editor/lib/src/default_editor/default_document_editor.dart

@@ -168,7 +168,11 @@ final defaultRequestHandlers = List.unmodifiable(<EditRequestHandler>[
       ? InsertNodeAtIndexCommand(nodeIndex: editor.document.length, newNode: request.newNode)
       : null,
   (editor, request) => request is InsertNodeAtIndexRequest
-      ? InsertNodeAtIndexCommand(nodeIndex: request.nodeIndex, newNode: request.newNode)
+      ? InsertNodeAtIndexCommand(
+          parentPath: request.parentPath,
+          nodeIndex: request.nodeIndex,
+          newNode: request.newNode,
+        )
       : null,
   (editor, request) => request is InsertNodeBeforeNodeRequest
       ? InsertNodeBeforeNodeCommand(existingNodeId: request.existingNodeId, newNode: request.newNode)

super_editor/lib/src/default_editor/default_document_editor_reactions.dart

@@ -13,6 +13,7 @@ import 'package:super_editor/src/core/editor.dart';
 import 'package:super_editor/src/default_editor/attributions.dart';
 import 'package:super_editor/src/default_editor/horizontal_rule.dart';
 import 'package:super_editor/src/default_editor/image.dart';
+import 'package:super_editor/src/default_editor/layout_single_column/composite_nodes.dart';
 import 'package:super_editor/src/default_editor/list_items.dart';
 import 'package:super_editor/src/default_editor/paragraph.dart';
 import 'package:super_editor/src/default_editor/tasks.dart';
@@ -314,7 +315,8 @@ class HorizontalRuleConversionReaction extends EditReaction {
     }
 
     final textInsertionEvent = edit.change as TextInsertionEvent;
-    final paragraph = document.getNodeById(textInsertionEvent.nodeId) as TextNode;
+    final paragraphPath = textInsertionEvent.nodePath;
+    final paragraph = document.getNodeAtPath(paragraphPath) as TextNode;
     final match = _hrPattern.firstMatch(paragraph.text.toPlainText())?.group(0);
     if (match == null) {
       return;
@@ -327,20 +329,21 @@ class HorizontalRuleConversionReaction extends EditReaction {
     requestDispatcher.execute([
       DeleteContentRequest(
         documentRange: DocumentRange(
-          start: DocumentPosition(nodeId: paragraph.id, nodePosition: const TextNodePosition(offset: 0)),
-          end: DocumentPosition(nodeId: paragraph.id, nodePosition: TextNodePosition(offset: match.length)),
+          start: DocumentPosition.withPath(nodePath: paragraphPath, nodePosition: const TextNodePosition(offset: 0)),
+          end: DocumentPosition.withPath(nodePath: paragraphPath, nodePosition: TextNodePosition(offset: match.length)),
         ),
       ),
       InsertNodeAtIndexRequest(
-        nodeIndex: document.getNodeIndexById(paragraph.id),
+        parentPath: paragraphPath.toLeafParentPath(),
+        nodeIndex: document.getNodeIndexInParent(paragraphPath),
         newNode: HorizontalRuleNode(
           id: Editor.createNodeId(),
         ),
       ),
       ChangeSelectionRequest(
         DocumentSelection.collapsed(
-          position: DocumentPosition(
-            nodeId: paragraph.id,
+          position: DocumentPosition.withPath(
+            nodePath: paragraphPath,
             nodePosition: const TextNodePosition(offset: 0),
           ),
         ),
@@ -573,7 +576,7 @@ class LinkifyReaction extends EditReaction {
       final edit = edits[i];
       if (edit is DocumentEdit) {
         final change = edit.change;
-        if (change is TextInsertionEvent && change.text.toPlainText() == " " && change.nodePath.isRoot) {
+        if (change is TextInsertionEvent && change.text.toPlainText() == " ") {
           // Every space insertion might appear after a URL.
           linkifyCandidate = change;
           didInsertSpace = true;
@@ -597,14 +600,14 @@ class LinkifyReaction extends EditReaction {
         }
 
         final caretPosition = selection.extent;
-        if (caretPosition.nodeId != linkifyCandidate.nodeId) {
+        if (caretPosition.leafNodeId != linkifyCandidate.nodePath.leafNodeId) {
           // The selection moved to some other node. Don't linkify.
           linkifyCandidate = null;
           continue;
         }
 
         // +1 for the inserted space
-        if ((caretPosition.nodePosition as TextNodePosition).offset != linkifyCandidate.offset + 1) {
+        if ((caretPosition.leafNodePosition as TextNodePosition).offset != linkifyCandidate.offset + 1) {
           // The caret isn't sitting directly after the space. Whatever
           // these events represent, it doesn't represent the user typing
           // a URL and then press SPACE. Don't linkify.
@@ -614,7 +617,7 @@ class LinkifyReaction extends EditReaction {
 
         // The caret sits directly after an inserted space. Get the word before
         // the space from the document, and linkify, if it fits a schema.
-        final textNode = document.getNodeById(linkifyCandidate.nodeId) as TextNode;
+        final textNode = document.getNodeAtPath(linkifyCandidate.nodePath) as TextNode;
         _extractUpstreamWordAndLinkify(textNode.text, linkifyCandidate.offset);
       } else if ((edit is SubmitParagraphIntention && edit.isStart) ||
           (edit is SplitParagraphIntention && edit.isStart) ||
@@ -631,7 +634,7 @@ class LinkifyReaction extends EditReaction {
 
         final nextEdit = edits[i + 1];
         if (nextEdit is DocumentEdit && nextEdit.change is NodeChangeEvent) {
-          final editedNode = document.getNodeById((nextEdit.change as NodeChangeEvent).nodeId);
+          final editedNode = document.getNodeAtPath((nextEdit.change as NodeChangeEvent).nodePath);
           if (editedNode is TextNode) {
             _extractUpstreamWordAndLinkify(editedNode.text, editedNode.text.length);
           }
@@ -1117,11 +1120,11 @@ class EditInspector {
       return false;
     }
 
-    if (lastSelectionChangeEvent.newSelection!.extent.nodeId != textInsertionEvent.nodeId) {
+    if (lastSelectionChangeEvent.newSelection!.extent.leafNodeId != textInsertionEvent.nodePath.leafNodeId) {
       return false;
     }
 
-    final editedNode = document.getNodeById(textInsertionEvent.nodeId)!;
+    final editedNode = document.getNodeAtPath(textInsertionEvent.nodePath)!;
     if (editedNode is! TextNode) {
       return false;
     }

super_editor/lib/src/default_editor/layout_single_column/composite_nodes.dart

@@ -260,31 +260,43 @@ abstract class CompositeNode extends DocumentNode implements ImeNodeSerializatio
     );
   }
 
-  /// Returns a new CompositeNode where leaf at [position] is replaced by
-  /// provided [newLeaf]
-  CompositeNode copyAndReplaceLeaf({
-    required CompositeNodePosition position,
-    required DocumentNode newLeaf,
-  });
+  CompositeNode copyWithChildren(List<DocumentNode> children);
 
-  CompositeNode internalCopyAndReplaceLeaf({
-    required CompositeNodePosition position,
-    required DocumentNode newLeaf,
-    required CompositeNode Function(CompositeNode oldNode, List<DocumentNode> children) compositeNodeBuilder,
+  /// Find a [CompositeNode] specified by [nodePath] and replace it's children using [childrenReplacer] function,
+  /// then returns a new root [CompositeNode]
+  CompositeNode copyAndReplaceLeafChildren({
+    required NodePath nodePath,
+    required List<DocumentNode> Function(CompositeNode leafNode, List<DocumentNode> leafChildren) childrenReplacer,
   }) {
-    DocumentNode childReplacement;
-    final childPosition = position.childNodePosition;
-    if (childPosition is CompositeNodePosition) {
-      final child = getChildByNodeId(position.childNodeId);
-      assert(child is CompositeNode, 'Unexpected child type for CompositeNodePosition (${child.runtimeType})');
-      childReplacement = (child as CompositeNode).copyAndReplaceLeaf(position: childPosition, newLeaf: newLeaf);
-    } else {
-      childReplacement = newLeaf;
+    assert(
+      nodePath.rootNodeId == id,
+      'Invalid NodePathIterator state. `current` should point to children of current CompositeNode',
+    );
+
+    var stack = <CompositeNode>[];
+    var currentNode = this;
+    stack.add(currentNode);
+    for (var i = 1; i < nodePath.length; i += 1) {
+      final childId = nodePath.getAt(i);
+      final child = currentNode.getChildByNodeId(childId);
+      assert(
+        child is CompositeNode,
+        'nodePath should be path to leaf parent, but $childId is not CompositeNode (${child.runtimeType})',
+      );
+      currentNode = child as CompositeNode;
+      stack.add(currentNode);
     }
-    final newChildren = children.map((child) {
-      return child.id == childReplacement.id ? childReplacement : child;
-    }).toList();
-    return compositeNodeBuilder(this, newChildren);
+
+    var adjustedNode = currentNode.copyWithChildren(
+      childrenReplacer(currentNode, currentNode.children.toList()),
+    );
+    for (var i = stack.length - 2; i >= 0; i -= 1) {
+      final child = stack[i];
+      adjustedNode =
+          child.copyWithChildren(child.children.map((c) => c.id == adjustedNode.id ? adjustedNode : c).toList());
+    }
+
+    return adjustedNode;
   }
 
   @override
@@ -504,7 +516,7 @@ extension DocumentPositionCompositeEx on DocumentPosition {
 
   NodePath get nodePath => NodePath.withDocumentPosition(this);
 
-  String get leafNodeId => nodePath.leafId;
+  String get leafNodeId => nodePath.leafNodeId;
 }
 
 extension NodePositionCompositeEx on NodePosition {