@xiriframework/xiri-ng 0.2.32 → 0.2.33

package/fesm2022/xiriframework-xiri-ng.mjs

@@ -3518,10 +3518,11 @@ function flatten(roots, expandedIds) {
 /**
  * Search projection: returns each match together with its full subtree (all descendants)
  * plus the ancestor path leading to it; everything else is hidden. Matches and their
- * descendants are shown fully; ancestor-only context nodes are flagged dimmed. All shown
- * nodes are treated as expanded. The `matches` predicate decides whether a single row is a hit.
+ * descendants are shown fully; ancestor-only context nodes are flagged dimmed. Within the
+ * filtered result, expand/collapse follows `expandedIds` (same state model as the flat view) —
+ * pass an all-expanded set to show everything. The `matches` predicate decides hits.
  */
-function searchProjection(roots, matches) {
+function searchProjection(roots, matches, expandedIds) {
     const visible = new Set();
     const inMatchSubtree = new Set(); // node matches itself or sits under a match → shown fully
     // underMatch: an ancestor of this node already matched, so the whole subtree is shown.
@@ -3548,15 +3549,18 @@ function searchProjection(roots, matches) {
             if (!visible.has(node))
                 continue;
             const visibleChildren = node.children.filter(c => visible.has(c));
+            const hasChildren = visibleChildren.length > 0;
+            const expanded = hasChildren && expandedIds.has(node.id);
             node.row._tree = {
                 level: node.level,
-                hasChildren: visibleChildren.length > 0,
-                expanded: true,
+                hasChildren,
+                expanded,
                 childCount: visibleChildren.length,
                 dimmed: !inMatchSubtree.has(node),
             };
             out.push(node.row);
-            walk(node.children);
+            if (expanded)
+                walk(node.children);
         }
     };
     walk(roots);
@@ -3607,29 +3611,32 @@ class XiriTableTreeService {
         this.roots = buildTree(rows, this.config.idField, this.config.parentIdField, this.treeColumnId);
         const persisted = this.loadPersisted();
         if (persisted)
-            this.expanded = new Set(persisted);
-        else if (this.config.expandAllByDefault)
-            this.expanded = collectExpandableIds(this.roots);
+            this.expanded = new Set(persisted); // persisted state wins
+        else if (this.config.collapseAllByDefault)
+            this.expanded = new Set(); // opt-in: start collapsed
         else
-            this.expanded = new Set();
+            this.expanded = collectExpandableIds(this.roots); // default: start fully expanded
     }
     /** Returns the visible rows: search projection when searching, otherwise the expand-state flatten. */
     visibleRows(matches) {
         if (this.searchActive && matches)
-            return searchProjection(this.roots, matches);
+            return searchProjection(this.roots, matches, this.expanded);
         return flatten(this.roots, this.expanded);
     }
     /**
      * Applies (or clears) a search. On the empty→active transition the current expand-state is
-     * snapshotted; on active→empty it is restored (Spec §5). Returns the new visible rows.
+     * snapshotted and the tree is fully expanded (so all matches are visible); during the search
+     * the same `expanded` state drives expand/collapse, so the arrows work. On active→empty the
+     * pre-search state is restored (Spec §5). Returns the new visible rows.
      */
     applySearch(matches) {
         if (matches) {
             if (!this.searchActive) {
                 this.savedExpanded = new Set(this.expanded);
+                this.expanded = collectExpandableIds(this.roots); // start fully expanded
                 this.searchActive = true;
             }
-            return searchProjection(this.roots, matches);
+            return searchProjection(this.roots, matches, this.expanded);
         }
         if (this.searchActive) {
             if (this.savedExpanded)
@@ -3645,7 +3652,10 @@ class XiriTableTreeService {
             this.expanded.delete(id);
         else
             this.expanded.add(id);
-        this.persist();
+        // Don't persist transient expand changes made while searching — savedExpanded holds the
+        // real state and is restored on reset.
+        if (!this.searchActive)
+            this.persist();
     }
     expandAll() {
         this.expanded = collectExpandableIds(this.roots);