Avoid redundant anchor lookups in Fragment.anchor() and unkeyed v-for

- anchor(): a membership check followed by .index() scanned the
  parent's children twice; use a single .index() in a try/except,
  for both children and slot_contents.
- Unkeyed ListFragment updates mounted every appended fragment with a
  freshly computed self.anchor(), which walks the tree per item even
  though the anchor (the first element after the list) cannot change
  while appending items from the list's own subtree. Compute it lazily
  once per update run, turning growth by n items from O(n^2) anchor
  work into O(n). Same hoist in ListFragment.mount().

Adds a regression test asserting that growing an unkeyed v-for with a
trailing sibling inserts elements in order, each anchored before that
sibling.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: berendkleinhaneveld

collagraph/fragment.py

@@ -145,22 +145,31 @@ def anchor(self) -> Any | None:
         assert parent is not None
 
         # Check if this fragment is in parent's children
-        if self in parent.children:
+        try:
             idx = parent.children.index(self)
+        except ValueError:
+            idx = None
+
+        if idx is not None:
             length = len(parent.children) - 1
             while 0 <= idx < length:
                 idx += 1
                 if element := parent.children[idx].first():
                     return element
         # Fragment might be slot content - check parent's slot_contents if it's
         # a ComponentFragment
-        elif isinstance(parent, ComponentFragment) and self in parent.slot_contents:
-            idx = parent.slot_contents.index(self)
-            length = len(parent.slot_contents) - 1
-            while 0 <= idx < length:
-                idx += 1
-                if element := parent.slot_contents[idx].first():
-                    return element
+        elif isinstance(parent, ComponentFragment):
+            try:
+                idx = parent.slot_contents.index(self)
+            except ValueError:
+                idx = None
+
+            if idx is not None:
+                length = len(parent.slot_contents) - 1
+                while 0 <= idx < length:
+                    idx += 1
+                    if element := parent.slot_contents[idx].first():
+                        return element
 
         # No sibling anchor found at this level. If the parent doesn't have
         # its own element (e.g., ComponentFragment, ControlFlowFragment), climb
@@ -706,11 +715,18 @@ def update_children(self):
                     fragment.unmount()
                     self.values.pop(index)
 
+                # The anchor is loop-invariant: it is the first element
+                # *after* this ListFragment, and the loop below only
+                # appends items from the list's own subtree before it.
+                # Computed lazily so update-only runs don't pay for it.
+                anchor = _UNSET
                 for i, item in enumerate(items):
                     if i < len(self.children):
                         # Update the content for existing values
                         self.values[i]["context"] = item
                     else:
+                        if anchor is _UNSET:
+                            anchor = self.anchor()
                         # Create a new fragment + context
                         context = reactive({"context": item})
                         self.values.append(context)
@@ -719,15 +735,18 @@ def update_children(self):
                         )
                         self.children.append(fragment)
                         fragment.parent = self
-                        fragment.mount(target, anchor=self.anchor())
+                        fragment.mount(target, anchor=anchor)
 
             # Then we add a watch_effect for the children
             # which adds/removes/updates all the child fragments
             self._watchers["list"] = watch_effect(update_children)
 
+        anchor = _UNSET
         for child in self.children:
             if not child.element:
-                child.mount(target, anchor=self.anchor())
+                if anchor is _UNSET:
+                    anchor = self.anchor()
+                child.mount(target, anchor=anchor)
 
         self._mounted = True
 

tests/test_directive_for.py

@@ -675,3 +675,50 @@ class Items(cg.Component):
     first_item, second_item = container["children"]
     assert first_item["attrs"]["value"] == "a"
     assert second_item["attrs"]["value"] == "b"
+
+
+def test_for_unkeyed_grow_insert_order(parse_source):
+    """
+    Growing an unkeyed v-for in one reactive update must insert the new
+    elements in order, each anchored before the element that follows the
+    list (regression test for hoisting the loop-invariant anchor out of
+    the append loop).
+    """
+    from tests.conftest import CustomElement, TrackingRenderer
+
+    App, _ = parse_source(
+        """
+        <template>
+          <node v-for="item in items" :content="item" />
+          <footer content="footer" />
+        </template>
+        <script>
+        import collagraph as cg
+        class App(cg.Component):
+            pass
+        </script>
+        """
+    )
+
+    renderer = TrackingRenderer()
+    gui = Collagraph(renderer, event_loop_type=EventLoopType.SYNC)
+    container = CustomElement(type="root")
+    state = reactive({"items": []})
+    gui.render(App, container, state)
+
+    renderer.reset_counters()
+    state["items"] = ["a", "b", "c"]
+
+    inserts = [op for op in renderer.operations if op[0] == "insert"]
+    assert inserts == [
+        ("insert", "a", "before footer"),
+        ("insert", "b", "before footer"),
+        ("insert", "c", "before footer"),
+    ]
+    assert [child.type for child in container.children] == [
+        "node",
+        "node",
+        "node",
+        "footer",
+    ]
+    assert [child.content for child in container.children[:3]] == ["a", "b", "c"]