@acorex/components 21.0.0-next.12 → 21.0.0-next.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
| 
         @@ -12,18 +12,22 @@ import { FormsModule } from '@angular/forms'; 
     | 
|
| 
       12 
12 
     | 
    
         | 
| 
       13 
13 
     | 
    
         
             
            class AXTree2Component {
         
     | 
| 
       14 
14 
     | 
    
         
             
                constructor() {
         
     | 
| 
      
 15 
     | 
    
         
            +
                    // Constants for list ID generation
         
     | 
| 
      
 16 
     | 
    
         
            +
                    this.ROOT_LIST_ID = 'ax-tree-root-list';
         
     | 
| 
      
 17 
     | 
    
         
            +
                    this.NODE_DROP_PREFIX = 'ax-tree-node-drop-';
         
     | 
| 
      
 18 
     | 
    
         
            +
                    this.LIST_PREFIX = 'ax-tree-list-';
         
     | 
| 
       15 
19 
     | 
    
         
             
                    /** Tree data nodes */
         
     | 
| 
       16 
20 
     | 
    
         
             
                    this.nodes = model.required(...(ngDevMode ? [{ debugName: "nodes" }] : []));
         
     | 
| 
       17 
21 
     | 
    
         
             
                    /** Whether to show checkboxes for selection */
         
     | 
| 
       18 
22 
     | 
    
         
             
                    this.showCheckbox = input(true, ...(ngDevMode ? [{ debugName: "showCheckbox" }] : []));
         
     | 
| 
       19 
23 
     | 
    
         
             
                    /** Drag and drop mode: 'none' (disabled), 'handler' (drag handle), 'item' (entire item) */
         
     | 
| 
       20 
24 
     | 
    
         
             
                    this.dragMode = input('handler', ...(ngDevMode ? [{ debugName: "dragMode" }] : []));
         
     | 
| 
      
 25 
     | 
    
         
            +
                    /** Drag operation type: 'order-only' (reorder only), 'move' (move between parents), 'both' (allow both) */
         
     | 
| 
      
 26 
     | 
    
         
            +
                    this.dragOperationType = input('both', ...(ngDevMode ? [{ debugName: "dragOperationType" }] : []));
         
     | 
| 
       21 
27 
     | 
    
         
             
                    /** Whether to show icons */
         
     | 
| 
       22 
28 
     | 
    
         
             
                    this.showIcons = input(true, ...(ngDevMode ? [{ debugName: "showIcons" }] : []));
         
     | 
| 
       23 
29 
     | 
    
         
             
                    /** Whether to show children count badge */
         
     | 
| 
       24 
30 
     | 
    
         
             
                    this.showChildrenBadge = input(true, ...(ngDevMode ? [{ debugName: "showChildrenBadge" }] : []));
         
     | 
| 
       25 
     | 
    
         
            -
                    /** Whether to animate expand/collapse */
         
     | 
| 
       26 
     | 
    
         
            -
                    this.animated = input(true, ...(ngDevMode ? [{ debugName: "animated" }] : []));
         
     | 
| 
       27 
31 
     | 
    
         
             
                    /** Custom icon for expanded nodes */
         
     | 
| 
       28 
32 
     | 
    
         
             
                    this.expandedIcon = input('fa-solid fa-chevron-down', ...(ngDevMode ? [{ debugName: "expandedIcon" }] : []));
         
     | 
| 
       29 
33 
     | 
    
         
             
                    /** Custom icon for collapsed nodes */
         
     | 
| 
         @@ -43,11 +47,15 @@ class AXTree2Component { 
     | 
|
| 
       43 
47 
     | 
    
         
             
                    /** Emitted before a drop operation - set canceled to true to prevent drop */
         
     | 
| 
       44 
48 
     | 
    
         
             
                    this.onBeforeDrop = output();
         
     | 
| 
       45 
49 
     | 
    
         
             
                    /** Emitted when a node is toggled (expanded/collapsed) */
         
     | 
| 
       46 
     | 
    
         
            -
                    this. 
     | 
| 
      
 50 
     | 
    
         
            +
                    this.onNodeToggle = output();
         
     | 
| 
       47 
51 
     | 
    
         
             
                    /** Emitted when a node is selected/deselected */
         
     | 
| 
       48 
     | 
    
         
            -
                    this. 
     | 
| 
       49 
     | 
    
         
            -
                    /** Emitted when  
     | 
| 
       50 
     | 
    
         
            -
                    this. 
     | 
| 
      
 52 
     | 
    
         
            +
                    this.onNodeSelect = output();
         
     | 
| 
      
 53 
     | 
    
         
            +
                    /** Emitted when nodes are reordered within the same parent */
         
     | 
| 
      
 54 
     | 
    
         
            +
                    this.onOrderChange = output();
         
     | 
| 
      
 55 
     | 
    
         
            +
                    /** Emitted when a node is moved to a different parent */
         
     | 
| 
      
 56 
     | 
    
         
            +
                    this.onMoveChange = output();
         
     | 
| 
      
 57 
     | 
    
         
            +
                    /** Emitted for any item change (order or move) */
         
     | 
| 
      
 58 
     | 
    
         
            +
                    this.onItemsChange = output();
         
     | 
| 
       51 
59 
     | 
    
         
             
                    /** Internal signal for tracking loading state */
         
     | 
| 
       52 
60 
     | 
    
         
             
                    this.loadingNodes = signal(new Set(), ...(ngDevMode ? [{ debugName: "loadingNodes" }] : []));
         
     | 
| 
       53 
61 
     | 
    
         
             
                    /** Effect to handle lazy load function changes */
         
     | 
| 
         @@ -68,8 +76,8 @@ class AXTree2Component { 
     | 
|
| 
       68 
76 
     | 
    
         
             
                async toggleNode(node, event) {
         
     | 
| 
       69 
77 
     | 
    
         
             
                    if (node.disabled)
         
     | 
| 
       70 
78 
     | 
    
         
             
                        return;
         
     | 
| 
       71 
     | 
    
         
            -
                    const hasChildren =  
     | 
| 
       72 
     | 
    
         
            -
                    const canLazyLoad = this. 
     | 
| 
      
 79 
     | 
    
         
            +
                    const hasChildren = this.hasChildren(node);
         
     | 
| 
      
 80 
     | 
    
         
            +
                    const canLazyLoad = this.canLazyLoad(node);
         
     | 
| 
       73 
81 
     | 
    
         
             
                    if (hasChildren || canLazyLoad) {
         
     | 
| 
       74 
82 
     | 
    
         
             
                        const willExpand = !node.expanded;
         
     | 
| 
       75 
83 
     | 
    
         
             
                        if (willExpand && canLazyLoad) {
         
     | 
| 
         @@ -78,7 +86,7 @@ class AXTree2Component { 
     | 
|
| 
       78 
86 
     | 
    
         
             
                        }
         
     | 
| 
       79 
87 
     | 
    
         
             
                        node.expanded = willExpand;
         
     | 
| 
       80 
88 
     | 
    
         
             
                        this.nodes.set([...this.nodes()]);
         
     | 
| 
       81 
     | 
    
         
            -
                        this. 
     | 
| 
      
 89 
     | 
    
         
            +
                        this.onNodeToggle.emit({ component: this, node, nativeEvent: event });
         
     | 
| 
       82 
90 
     | 
    
         
             
                    }
         
     | 
| 
       83 
91 
     | 
    
         
             
                }
         
     | 
| 
       84 
92 
     | 
    
         
             
                /**
         
     | 
| 
         @@ -143,7 +151,7 @@ class AXTree2Component { 
     | 
|
| 
       143 
151 
     | 
    
         
             
                    // Update parent states up the tree
         
     | 
| 
       144 
152 
     | 
    
         
             
                    this.updateParentStates(this.nodes(), node);
         
     | 
| 
       145 
153 
     | 
    
         
             
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
       146 
     | 
    
         
            -
                    this. 
     | 
| 
      
 154 
     | 
    
         
            +
                    this.onNodeSelect.emit({
         
     | 
| 
       147 
155 
     | 
    
         
             
                        component: this,
         
     | 
| 
       148 
156 
     | 
    
         
             
                        node,
         
     | 
| 
       149 
157 
     | 
    
         
             
                        isUserInteraction: event.isUserInteraction,
         
     | 
| 
         @@ -226,136 +234,65 @@ class AXTree2Component { 
     | 
|
| 
       226 
234 
     | 
    
         
             
                 */
         
     | 
| 
       227 
235 
     | 
    
         
             
                onDrop(event, parentNode) {
         
     | 
| 
       228 
236 
     | 
    
         
             
                    const targetArray = parentNode?.children ?? this.nodes();
         
     | 
| 
       229 
     | 
    
         
            -
                     
     | 
| 
       230 
     | 
    
         
            -
             
     | 
| 
       231 
     | 
    
         
            -
                         
     | 
| 
      
 237 
     | 
    
         
            +
                    const isReordering = event.previousContainer === event.container;
         
     | 
| 
      
 238 
     | 
    
         
            +
                    if (isReordering) {
         
     | 
| 
      
 239 
     | 
    
         
            +
                        this.handleReorder(event, targetArray, parentNode);
         
     | 
| 
       232 
240 
     | 
    
         
             
                    }
         
     | 
| 
       233 
241 
     | 
    
         
             
                    else {
         
     | 
| 
       234 
     | 
    
         
            -
                         
     | 
| 
       235 
     | 
    
         
            -
                        const sourceListId = event.previousContainer.element.id;
         
     | 
| 
       236 
     | 
    
         
            -
                        const sourceArray = this.getArrayByListId(sourceListId);
         
     | 
| 
       237 
     | 
    
         
            -
                        if (sourceArray) {
         
     | 
| 
       238 
     | 
    
         
            -
                            const movedNode = sourceArray[event.previousIndex];
         
     | 
| 
       239 
     | 
    
         
            -
                            // CRITICAL: Prevent dropping a node into its own descendants (circular reference)
         
     | 
| 
       240 
     | 
    
         
            -
                            if (parentNode && this.isNodeDescendantOf(parentNode, movedNode)) {
         
     | 
| 
       241 
     | 
    
         
            -
                                console.warn('Cannot drop a node into its own descendants');
         
     | 
| 
       242 
     | 
    
         
            -
                                // Do NOT transfer the item - just return early
         
     | 
| 
       243 
     | 
    
         
            -
                                return;
         
     | 
| 
       244 
     | 
    
         
            -
                            }
         
     | 
| 
       245 
     | 
    
         
            -
                            // Emit beforeDrop event - user can cancel by setting canceled = true
         
     | 
| 
       246 
     | 
    
         
            -
                            const beforeDropEvent = {
         
     | 
| 
       247 
     | 
    
         
            -
                                component: this,
         
     | 
| 
       248 
     | 
    
         
            -
                                movedNode,
         
     | 
| 
       249 
     | 
    
         
            -
                                previousParent: this.findParentByListId(sourceListId),
         
     | 
| 
       250 
     | 
    
         
            -
                                currentParent: parentNode,
         
     | 
| 
       251 
     | 
    
         
            -
                                previousIndex: event.previousIndex,
         
     | 
| 
       252 
     | 
    
         
            -
                                currentIndex: event.currentIndex,
         
     | 
| 
       253 
     | 
    
         
            -
                                canceled: false,
         
     | 
| 
       254 
     | 
    
         
            -
                            };
         
     | 
| 
       255 
     | 
    
         
            -
                            this.onBeforeDrop.emit(beforeDropEvent);
         
     | 
| 
       256 
     | 
    
         
            -
                            if (beforeDropEvent.canceled) {
         
     | 
| 
       257 
     | 
    
         
            -
                                console.warn('Drop canceled by user in onBeforeDrop event');
         
     | 
| 
       258 
     | 
    
         
            -
                                return;
         
     | 
| 
       259 
     | 
    
         
            -
                            }
         
     | 
| 
       260 
     | 
    
         
            -
                            transferArrayItem(sourceArray, targetArray, event.previousIndex, event.currentIndex);
         
     | 
| 
       261 
     | 
    
         
            -
                            // Emit drop event
         
     | 
| 
       262 
     | 
    
         
            -
                            this.nodeDrop.emit({
         
     | 
| 
       263 
     | 
    
         
            -
                                component: this,
         
     | 
| 
       264 
     | 
    
         
            -
                                node: movedNode,
         
     | 
| 
       265 
     | 
    
         
            -
                                previousParent: this.findParentByListId(sourceListId),
         
     | 
| 
       266 
     | 
    
         
            -
                                currentParent: parentNode,
         
     | 
| 
       267 
     | 
    
         
            -
                                previousIndex: event.previousIndex,
         
     | 
| 
       268 
     | 
    
         
            -
                                currentIndex: event.currentIndex,
         
     | 
| 
       269 
     | 
    
         
            -
                            });
         
     | 
| 
       270 
     | 
    
         
            -
                        }
         
     | 
| 
      
 242 
     | 
    
         
            +
                        this.handleMove(event, targetArray, parentNode);
         
     | 
| 
       271 
243 
     | 
    
         
             
                    }
         
     | 
| 
       272 
     | 
    
         
            -
                    // Update the signal to trigger change detection
         
     | 
| 
       273 
244 
     | 
    
         
             
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
       274 
245 
     | 
    
         
             
                }
         
     | 
| 
       275 
246 
     | 
    
         
             
                /**
         
     | 
| 
       276 
247 
     | 
    
         
             
                 * Handle drop events when dropping directly onto a node (to make it a child)
         
     | 
| 
       277 
248 
     | 
    
         
             
                 */
         
     | 
| 
       278 
249 
     | 
    
         
             
                onDropOntoNode(event, targetNode) {
         
     | 
| 
      
 250 
     | 
    
         
            +
                    if (!this.canMoveToParent())
         
     | 
| 
      
 251 
     | 
    
         
            +
                        return;
         
     | 
| 
       279 
252 
     | 
    
         
             
                    const sourceListId = event.previousContainer.element.id;
         
     | 
| 
       280 
253 
     | 
    
         
             
                    const sourceArray = this.getArrayByListId(sourceListId);
         
     | 
| 
       281 
254 
     | 
    
         
             
                    if (!sourceArray)
         
     | 
| 
       282 
255 
     | 
    
         
             
                        return;
         
     | 
| 
       283 
256 
     | 
    
         
             
                    const movedNode = sourceArray[event.previousIndex];
         
     | 
| 
       284 
     | 
    
         
            -
                     
     | 
| 
       285 
     | 
    
         
            -
                    if (movedNode.id === targetNode.id || this.isNodeDescendantOf(targetNode, movedNode)) {
         
     | 
| 
       286 
     | 
    
         
            -
                        console.warn('Cannot drop a node onto itself or its descendants');
         
     | 
| 
      
 257 
     | 
    
         
            +
                    if (!this.isValidDropTarget(movedNode, targetNode))
         
     | 
| 
       287 
258 
     | 
    
         
             
                        return;
         
     | 
| 
       288 
     | 
    
         
            -
                     
     | 
| 
       289 
     | 
    
         
            -
                    // Emit beforeDrop event - user can cancel by setting canceled = true
         
     | 
| 
       290 
     | 
    
         
            -
                    const beforeDropEvent = {
         
     | 
| 
       291 
     | 
    
         
            -
                        component: this,
         
     | 
| 
       292 
     | 
    
         
            -
                        movedNode,
         
     | 
| 
       293 
     | 
    
         
            -
                        previousParent: this.findParentByListId(sourceListId),
         
     | 
| 
       294 
     | 
    
         
            -
                        currentParent: targetNode,
         
     | 
| 
       295 
     | 
    
         
            -
                        previousIndex: event.previousIndex,
         
     | 
| 
       296 
     | 
    
         
            -
                        currentIndex: 0, // Always first child when dropping onto node
         
     | 
| 
       297 
     | 
    
         
            -
                        canceled: false,
         
     | 
| 
       298 
     | 
    
         
            -
                    };
         
     | 
| 
       299 
     | 
    
         
            -
                    this.onBeforeDrop.emit(beforeDropEvent);
         
     | 
| 
       300 
     | 
    
         
            -
                    if (beforeDropEvent.canceled) {
         
     | 
| 
       301 
     | 
    
         
            -
                        console.warn('Drop canceled by user in onBeforeDrop event');
         
     | 
| 
      
 259 
     | 
    
         
            +
                    if (!this.emitBeforeDropEvent(movedNode, sourceListId, targetNode, event.previousIndex, 0))
         
     | 
| 
       302 
260 
     | 
    
         
             
                        return;
         
     | 
| 
       303 
     | 
    
         
            -
                     
     | 
| 
       304 
     | 
    
         
            -
                     
     | 
| 
       305 
     | 
    
         
            -
                    if (!targetNode.children) {
         
     | 
| 
       306 
     | 
    
         
            -
                        targetNode.children = [];
         
     | 
| 
       307 
     | 
    
         
            -
                    }
         
     | 
| 
       308 
     | 
    
         
            -
                    // Remove from source
         
     | 
| 
      
 261 
     | 
    
         
            +
                    // Initialize children array and perform transfer
         
     | 
| 
      
 262 
     | 
    
         
            +
                    targetNode.children ??= [];
         
     | 
| 
       309 
263 
     | 
    
         
             
                    sourceArray.splice(event.previousIndex, 1);
         
     | 
| 
       310 
     | 
    
         
            -
                    // Add as first child of target node
         
     | 
| 
       311 
264 
     | 
    
         
             
                    targetNode.children.unshift(movedNode);
         
     | 
| 
       312 
     | 
    
         
            -
                    // Auto-expand the target node to show the new child
         
     | 
| 
       313 
265 
     | 
    
         
             
                    targetNode.expanded = true;
         
     | 
| 
       314 
     | 
    
         
            -
                    // Emit  
     | 
| 
       315 
     | 
    
         
            -
                    this. 
     | 
| 
       316 
     | 
    
         
            -
                        component: this,
         
     | 
| 
       317 
     | 
    
         
            -
                        node: movedNode,
         
     | 
| 
       318 
     | 
    
         
            -
                        previousParent: this.findParentByListId(sourceListId),
         
     | 
| 
       319 
     | 
    
         
            -
                        currentParent: targetNode,
         
     | 
| 
       320 
     | 
    
         
            -
                        previousIndex: event.previousIndex,
         
     | 
| 
       321 
     | 
    
         
            -
                        currentIndex: 0,
         
     | 
| 
       322 
     | 
    
         
            -
                    });
         
     | 
| 
       323 
     | 
    
         
            -
                    // Update the signal to trigger change detection
         
     | 
| 
      
 266 
     | 
    
         
            +
                    // Emit events
         
     | 
| 
      
 267 
     | 
    
         
            +
                    this.emitDropEvents(movedNode, this.findParentByListId(sourceListId), targetNode, event.previousIndex, 0, false);
         
     | 
| 
       324 
268 
     | 
    
         
             
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
       325 
269 
     | 
    
         
             
                }
         
     | 
| 
       326 
270 
     | 
    
         
             
                /**
         
     | 
| 
       327 
271 
     | 
    
         
             
                 * Get array reference by drop list ID
         
     | 
| 
       328 
272 
     | 
    
         
             
                 */
         
     | 
| 
       329 
273 
     | 
    
         
             
                getArrayByListId(listId) {
         
     | 
| 
       330 
     | 
    
         
            -
                    if (listId ===  
     | 
| 
      
 274 
     | 
    
         
            +
                    if (listId === this.ROOT_LIST_ID) {
         
     | 
| 
       331 
275 
     | 
    
         
             
                        return this.nodes();
         
     | 
| 
       332 
276 
     | 
    
         
             
                    }
         
     | 
| 
       333 
     | 
    
         
            -
                     
     | 
| 
       334 
     | 
    
         
            -
             
     | 
| 
       335 
     | 
    
         
            -
                        const nodeId = listId.replace('ax-tree-node-drop-', '');
         
     | 
| 
      
 277 
     | 
    
         
            +
                    if (listId.startsWith(this.NODE_DROP_PREFIX)) {
         
     | 
| 
      
 278 
     | 
    
         
            +
                        const nodeId = listId.replace(this.NODE_DROP_PREFIX, '');
         
     | 
| 
       336 
279 
     | 
    
         
             
                        const node = this.findNodeById(this.nodes(), nodeId);
         
     | 
| 
       337 
280 
     | 
    
         
             
                        return node ? [node] : null;
         
     | 
| 
       338 
281 
     | 
    
         
             
                    }
         
     | 
| 
       339 
     | 
    
         
            -
                     
     | 
| 
       340 
     | 
    
         
            -
                    const nodeId = listId.replace('ax-tree-list-', '');
         
     | 
| 
      
 282 
     | 
    
         
            +
                    const nodeId = listId.replace(this.LIST_PREFIX, '');
         
     | 
| 
       341 
283 
     | 
    
         
             
                    const node = this.findNodeById(this.nodes(), nodeId);
         
     | 
| 
       342 
     | 
    
         
            -
                    return node?.children  
     | 
| 
      
 284 
     | 
    
         
            +
                    return node?.children ?? null;
         
     | 
| 
       343 
285 
     | 
    
         
             
                }
         
     | 
| 
       344 
286 
     | 
    
         
             
                /**
         
     | 
| 
       345 
287 
     | 
    
         
             
                 * Find parent node by list ID
         
     | 
| 
       346 
288 
     | 
    
         
             
                 */
         
     | 
| 
       347 
289 
     | 
    
         
             
                findParentByListId(listId) {
         
     | 
| 
       348 
     | 
    
         
            -
                    if (listId ===  
     | 
| 
      
 290 
     | 
    
         
            +
                    if (listId === this.ROOT_LIST_ID) {
         
     | 
| 
       349 
291 
     | 
    
         
             
                        return undefined;
         
     | 
| 
       350 
292 
     | 
    
         
             
                    }
         
     | 
| 
       351 
     | 
    
         
            -
                     
     | 
| 
       352 
     | 
    
         
            -
                     
     | 
| 
       353 
     | 
    
         
            -
             
     | 
| 
       354 
     | 
    
         
            -
                        return this.findNodeById(this.nodes(), nodeId) || undefined;
         
     | 
| 
       355 
     | 
    
         
            -
                    }
         
     | 
| 
       356 
     | 
    
         
            -
                    // Handle children list drop zones
         
     | 
| 
       357 
     | 
    
         
            -
                    const nodeId = listId.replace('ax-tree-list-', '');
         
     | 
| 
       358 
     | 
    
         
            -
                    return this.findNodeById(this.nodes(), nodeId) || undefined;
         
     | 
| 
      
 293 
     | 
    
         
            +
                    const prefix = listId.startsWith(this.NODE_DROP_PREFIX) ? this.NODE_DROP_PREFIX : this.LIST_PREFIX;
         
     | 
| 
      
 294 
     | 
    
         
            +
                    const nodeId = listId.replace(prefix, '');
         
     | 
| 
      
 295 
     | 
    
         
            +
                    return this.findNodeById(this.nodes(), nodeId) ?? undefined;
         
     | 
| 
       359 
296 
     | 
    
         
             
                }
         
     | 
| 
       360 
297 
     | 
    
         
             
                /**
         
     | 
| 
       361 
298 
     | 
    
         
             
                 * Find a node by ID in the tree
         
     | 
| 
         @@ -400,7 +337,7 @@ class AXTree2Component { 
     | 
|
| 
       400 
337 
     | 
    
         
             
                 * Generate unique list ID for each node
         
     | 
| 
       401 
338 
     | 
    
         
             
                 */
         
     | 
| 
       402 
339 
     | 
    
         
             
                getListId(node) {
         
     | 
| 
       403 
     | 
    
         
            -
                    return node ?  
     | 
| 
      
 340 
     | 
    
         
            +
                    return node ? `${this.LIST_PREFIX}${node.id}` : this.ROOT_LIST_ID;
         
     | 
| 
       404 
341 
     | 
    
         
             
                }
         
     | 
| 
       405 
342 
     | 
    
         
             
                /**
         
     | 
| 
       406 
343 
     | 
    
         
             
                 * Expand all nodes in the tree (with lazy loading support)
         
     | 
| 
         @@ -421,8 +358,8 @@ class AXTree2Component { 
     | 
|
| 
       421 
358 
     | 
    
         
             
                 */
         
     | 
| 
       422 
359 
     | 
    
         
             
                async setExpandedState(nodes, expanded) {
         
     | 
| 
       423 
360 
     | 
    
         
             
                    for (const node of nodes) {
         
     | 
| 
       424 
     | 
    
         
            -
                        const hasChildren =  
     | 
| 
       425 
     | 
    
         
            -
                        const canLazyLoad = this. 
     | 
| 
      
 361 
     | 
    
         
            +
                        const hasChildren = this.hasChildren(node);
         
     | 
| 
      
 362 
     | 
    
         
            +
                        const canLazyLoad = this.canLazyLoad(node);
         
     | 
| 
       426 
363 
     | 
    
         
             
                        if (hasChildren || canLazyLoad) {
         
     | 
| 
       427 
364 
     | 
    
         
             
                            if (expanded && canLazyLoad) {
         
     | 
| 
       428 
365 
     | 
    
         
             
                                await this.loadNodeChildren(node);
         
     | 
| 
         @@ -440,6 +377,12 @@ class AXTree2Component { 
     | 
|
| 
       440 
377 
     | 
    
         
             
                getSelectedCount() {
         
     | 
| 
       441 
378 
     | 
    
         
             
                    return this.countSelected(this.nodes());
         
     | 
| 
       442 
379 
     | 
    
         
             
                }
         
     | 
| 
      
 380 
     | 
    
         
            +
                /**
         
     | 
| 
      
 381 
     | 
    
         
            +
                 * Check if any nodes are selected
         
     | 
| 
      
 382 
     | 
    
         
            +
                 */
         
     | 
| 
      
 383 
     | 
    
         
            +
                hasSelection() {
         
     | 
| 
      
 384 
     | 
    
         
            +
                    return this.getSelectedCount() > 0;
         
     | 
| 
      
 385 
     | 
    
         
            +
                }
         
     | 
| 
       443 
386 
     | 
    
         
             
                /**
         
     | 
| 
       444 
387 
     | 
    
         
             
                 * Recursively count selected nodes
         
     | 
| 
       445 
388 
     | 
    
         
             
                 */
         
     | 
| 
         @@ -483,6 +426,44 @@ class AXTree2Component { 
     | 
|
| 
       483 
426 
     | 
    
         
             
                    this.updateAllParentStates(this.nodes());
         
     | 
| 
       484 
427 
     | 
    
         
             
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
       485 
428 
     | 
    
         
             
                }
         
     | 
| 
      
 429 
     | 
    
         
            +
                /**
         
     | 
| 
      
 430 
     | 
    
         
            +
                 * Select all nodes in the tree
         
     | 
| 
      
 431 
     | 
    
         
            +
                 */
         
     | 
| 
      
 432 
     | 
    
         
            +
                selectAll() {
         
     | 
| 
      
 433 
     | 
    
         
            +
                    this.setAllSelection(this.nodes(), true);
         
     | 
| 
      
 434 
     | 
    
         
            +
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
      
 435 
     | 
    
         
            +
                }
         
     | 
| 
      
 436 
     | 
    
         
            +
                /**
         
     | 
| 
      
 437 
     | 
    
         
            +
                 * Deselect all nodes in the tree
         
     | 
| 
      
 438 
     | 
    
         
            +
                 */
         
     | 
| 
      
 439 
     | 
    
         
            +
                deselectAll() {
         
     | 
| 
      
 440 
     | 
    
         
            +
                    this.setAllSelection(this.nodes(), false);
         
     | 
| 
      
 441 
     | 
    
         
            +
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
      
 442 
     | 
    
         
            +
                }
         
     | 
| 
      
 443 
     | 
    
         
            +
                /**
         
     | 
| 
      
 444 
     | 
    
         
            +
                 * Find a node by ID in the tree
         
     | 
| 
      
 445 
     | 
    
         
            +
                 */
         
     | 
| 
      
 446 
     | 
    
         
            +
                findNode(id) {
         
     | 
| 
      
 447 
     | 
    
         
            +
                    return this.findNodeById(this.nodes(), id);
         
     | 
| 
      
 448 
     | 
    
         
            +
                }
         
     | 
| 
      
 449 
     | 
    
         
            +
                /**
         
     | 
| 
      
 450 
     | 
    
         
            +
                 * Refresh the tree to trigger change detection
         
     | 
| 
      
 451 
     | 
    
         
            +
                 */
         
     | 
| 
      
 452 
     | 
    
         
            +
                refresh() {
         
     | 
| 
      
 453 
     | 
    
         
            +
                    this.nodes.set([...this.nodes()]);
         
     | 
| 
      
 454 
     | 
    
         
            +
                }
         
     | 
| 
      
 455 
     | 
    
         
            +
                /**
         
     | 
| 
      
 456 
     | 
    
         
            +
                 * Recursively set selection state for all nodes
         
     | 
| 
      
 457 
     | 
    
         
            +
                 */
         
     | 
| 
      
 458 
     | 
    
         
            +
                setAllSelection(nodes, selected) {
         
     | 
| 
      
 459 
     | 
    
         
            +
                    nodes.forEach((node) => {
         
     | 
| 
      
 460 
     | 
    
         
            +
                        node.selected = selected;
         
     | 
| 
      
 461 
     | 
    
         
            +
                        node.indeterminate = false;
         
     | 
| 
      
 462 
     | 
    
         
            +
                        if (node.children) {
         
     | 
| 
      
 463 
     | 
    
         
            +
                            this.setAllSelection(node.children, selected);
         
     | 
| 
      
 464 
     | 
    
         
            +
                        }
         
     | 
| 
      
 465 
     | 
    
         
            +
                    });
         
     | 
| 
      
 466 
     | 
    
         
            +
                }
         
     | 
| 
       486 
467 
     | 
    
         
             
                /**
         
     | 
| 
       487 
468 
     | 
    
         
             
                 * Recursively remove selected nodes
         
     | 
| 
       488 
469 
     | 
    
         
             
                 */
         
     | 
| 
         @@ -546,12 +527,124 @@ class AXTree2Component { 
     | 
|
| 
       546 
527 
     | 
    
         
             
                 * Check if node should show expand toggle
         
     | 
| 
       547 
528 
     | 
    
         
             
                 */
         
     | 
| 
       548 
529 
     | 
    
         
             
                shouldShowExpandToggle(node) {
         
     | 
| 
       549 
     | 
    
         
            -
                    return ( 
     | 
| 
       550 
     | 
    
         
            -
             
     | 
| 
       551 
     | 
    
         
            -
             
     | 
| 
      
 530 
     | 
    
         
            +
                    return this.hasChildren(node) || this.canLazyLoad(node);
         
     | 
| 
      
 531 
     | 
    
         
            +
                }
         
     | 
| 
      
 532 
     | 
    
         
            +
                // Helper methods for improved code reusability
         
     | 
| 
      
 533 
     | 
    
         
            +
                /**
         
     | 
| 
      
 534 
     | 
    
         
            +
                 * Check if node has children
         
     | 
| 
      
 535 
     | 
    
         
            +
                 */
         
     | 
| 
      
 536 
     | 
    
         
            +
                hasChildren(node) {
         
     | 
| 
      
 537 
     | 
    
         
            +
                    return Boolean(node.children?.length);
         
     | 
| 
      
 538 
     | 
    
         
            +
                }
         
     | 
| 
      
 539 
     | 
    
         
            +
                /**
         
     | 
| 
      
 540 
     | 
    
         
            +
                 * Check if node can be lazy loaded
         
     | 
| 
      
 541 
     | 
    
         
            +
                 */
         
     | 
| 
      
 542 
     | 
    
         
            +
                canLazyLoad(node) {
         
     | 
| 
      
 543 
     | 
    
         
            +
                    return this.enableLazyLoad() && Boolean(node.childrenCount && node.childrenCount > 0 && !this.hasChildren(node));
         
     | 
| 
      
 544 
     | 
    
         
            +
                }
         
     | 
| 
      
 545 
     | 
    
         
            +
                /**
         
     | 
| 
      
 546 
     | 
    
         
            +
                 * Check if move operation is allowed based on dragOperationType
         
     | 
| 
      
 547 
     | 
    
         
            +
                 */
         
     | 
| 
      
 548 
     | 
    
         
            +
                canMoveToParent() {
         
     | 
| 
      
 549 
     | 
    
         
            +
                    if (this.dragOperationType() === 'order-only') {
         
     | 
| 
      
 550 
     | 
    
         
            +
                        console.warn('Moving between parents is disabled when dragOperationType is "order-only"');
         
     | 
| 
      
 551 
     | 
    
         
            +
                        return false;
         
     | 
| 
      
 552 
     | 
    
         
            +
                    }
         
     | 
| 
      
 553 
     | 
    
         
            +
                    return true;
         
     | 
| 
      
 554 
     | 
    
         
            +
                }
         
     | 
| 
      
 555 
     | 
    
         
            +
                /**
         
     | 
| 
      
 556 
     | 
    
         
            +
                 * Check if reorder operation is allowed based on dragOperationType
         
     | 
| 
      
 557 
     | 
    
         
            +
                 */
         
     | 
| 
      
 558 
     | 
    
         
            +
                canReorder() {
         
     | 
| 
      
 559 
     | 
    
         
            +
                    if (this.dragOperationType() === 'move') {
         
     | 
| 
      
 560 
     | 
    
         
            +
                        console.warn('Reordering is disabled when dragOperationType is "move"');
         
     | 
| 
      
 561 
     | 
    
         
            +
                        return false;
         
     | 
| 
      
 562 
     | 
    
         
            +
                    }
         
     | 
| 
      
 563 
     | 
    
         
            +
                    return true;
         
     | 
| 
      
 564 
     | 
    
         
            +
                }
         
     | 
| 
      
 565 
     | 
    
         
            +
                /**
         
     | 
| 
      
 566 
     | 
    
         
            +
                 * Validate if drop target is valid (prevent circular references)
         
     | 
| 
      
 567 
     | 
    
         
            +
                 */
         
     | 
| 
      
 568 
     | 
    
         
            +
                isValidDropTarget(movedNode, targetNode) {
         
     | 
| 
      
 569 
     | 
    
         
            +
                    if (movedNode.id === targetNode.id || this.isNodeDescendantOf(targetNode, movedNode)) {
         
     | 
| 
      
 570 
     | 
    
         
            +
                        console.warn('Cannot drop a node onto itself or its descendants');
         
     | 
| 
      
 571 
     | 
    
         
            +
                        return false;
         
     | 
| 
      
 572 
     | 
    
         
            +
                    }
         
     | 
| 
      
 573 
     | 
    
         
            +
                    return true;
         
     | 
| 
      
 574 
     | 
    
         
            +
                }
         
     | 
| 
      
 575 
     | 
    
         
            +
                /**
         
     | 
| 
      
 576 
     | 
    
         
            +
                 * Handle reordering within the same list
         
     | 
| 
      
 577 
     | 
    
         
            +
                 */
         
     | 
| 
      
 578 
     | 
    
         
            +
                handleReorder(event, targetArray, parentNode) {
         
     | 
| 
      
 579 
     | 
    
         
            +
                    if (!this.canReorder())
         
     | 
| 
      
 580 
     | 
    
         
            +
                        return;
         
     | 
| 
      
 581 
     | 
    
         
            +
                    const movedNode = targetArray[event.previousIndex];
         
     | 
| 
      
 582 
     | 
    
         
            +
                    moveItemInArray(targetArray, event.previousIndex, event.currentIndex);
         
     | 
| 
      
 583 
     | 
    
         
            +
                    this.emitDropEvents(movedNode, parentNode, parentNode, event.previousIndex, event.currentIndex, true);
         
     | 
| 
      
 584 
     | 
    
         
            +
                }
         
     | 
| 
      
 585 
     | 
    
         
            +
                /**
         
     | 
| 
      
 586 
     | 
    
         
            +
                 * Handle moving between different lists
         
     | 
| 
      
 587 
     | 
    
         
            +
                 */
         
     | 
| 
      
 588 
     | 
    
         
            +
                handleMove(event, targetArray, parentNode) {
         
     | 
| 
      
 589 
     | 
    
         
            +
                    if (!this.canMoveToParent())
         
     | 
| 
      
 590 
     | 
    
         
            +
                        return;
         
     | 
| 
      
 591 
     | 
    
         
            +
                    const sourceListId = event.previousContainer.element.id;
         
     | 
| 
      
 592 
     | 
    
         
            +
                    const sourceArray = this.getArrayByListId(sourceListId);
         
     | 
| 
      
 593 
     | 
    
         
            +
                    if (!sourceArray)
         
     | 
| 
      
 594 
     | 
    
         
            +
                        return;
         
     | 
| 
      
 595 
     | 
    
         
            +
                    const movedNode = sourceArray[event.previousIndex];
         
     | 
| 
      
 596 
     | 
    
         
            +
                    // Prevent circular references
         
     | 
| 
      
 597 
     | 
    
         
            +
                    if (parentNode && !this.isValidDropTarget(movedNode, parentNode))
         
     | 
| 
      
 598 
     | 
    
         
            +
                        return;
         
     | 
| 
      
 599 
     | 
    
         
            +
                    // Check if user wants to cancel
         
     | 
| 
      
 600 
     | 
    
         
            +
                    if (!this.emitBeforeDropEvent(movedNode, sourceListId, parentNode, event.previousIndex, event.currentIndex)) {
         
     | 
| 
      
 601 
     | 
    
         
            +
                        return;
         
     | 
| 
      
 602 
     | 
    
         
            +
                    }
         
     | 
| 
      
 603 
     | 
    
         
            +
                    transferArrayItem(sourceArray, targetArray, event.previousIndex, event.currentIndex);
         
     | 
| 
      
 604 
     | 
    
         
            +
                    this.emitDropEvents(movedNode, this.findParentByListId(sourceListId), parentNode, event.previousIndex, event.currentIndex, false);
         
     | 
| 
      
 605 
     | 
    
         
            +
                }
         
     | 
| 
      
 606 
     | 
    
         
            +
                /**
         
     | 
| 
      
 607 
     | 
    
         
            +
                 * Emit beforeDrop event and return whether to continue
         
     | 
| 
      
 608 
     | 
    
         
            +
                 */
         
     | 
| 
      
 609 
     | 
    
         
            +
                emitBeforeDropEvent(movedNode, sourceListId, currentParent, previousIndex, currentIndex) {
         
     | 
| 
      
 610 
     | 
    
         
            +
                    const beforeDropEvent = {
         
     | 
| 
      
 611 
     | 
    
         
            +
                        component: this,
         
     | 
| 
      
 612 
     | 
    
         
            +
                        movedNode,
         
     | 
| 
      
 613 
     | 
    
         
            +
                        previousParent: this.findParentByListId(sourceListId),
         
     | 
| 
      
 614 
     | 
    
         
            +
                        currentParent,
         
     | 
| 
      
 615 
     | 
    
         
            +
                        previousIndex,
         
     | 
| 
      
 616 
     | 
    
         
            +
                        currentIndex,
         
     | 
| 
      
 617 
     | 
    
         
            +
                        canceled: false,
         
     | 
| 
      
 618 
     | 
    
         
            +
                    };
         
     | 
| 
      
 619 
     | 
    
         
            +
                    this.onBeforeDrop.emit(beforeDropEvent);
         
     | 
| 
      
 620 
     | 
    
         
            +
                    if (beforeDropEvent.canceled) {
         
     | 
| 
      
 621 
     | 
    
         
            +
                        console.warn('Drop canceled by user in onBeforeDrop event');
         
     | 
| 
      
 622 
     | 
    
         
            +
                        return false;
         
     | 
| 
      
 623 
     | 
    
         
            +
                    }
         
     | 
| 
      
 624 
     | 
    
         
            +
                    return true;
         
     | 
| 
      
 625 
     | 
    
         
            +
                }
         
     | 
| 
      
 626 
     | 
    
         
            +
                /**
         
     | 
| 
      
 627 
     | 
    
         
            +
                 * Emit drop events based on operation type
         
     | 
| 
      
 628 
     | 
    
         
            +
                 */
         
     | 
| 
      
 629 
     | 
    
         
            +
                emitDropEvents(node, previousParent, currentParent, previousIndex, currentIndex, isReorder) {
         
     | 
| 
      
 630 
     | 
    
         
            +
                    const dropEvent = {
         
     | 
| 
      
 631 
     | 
    
         
            +
                        component: this,
         
     | 
| 
      
 632 
     | 
    
         
            +
                        node,
         
     | 
| 
      
 633 
     | 
    
         
            +
                        previousParent,
         
     | 
| 
      
 634 
     | 
    
         
            +
                        currentParent,
         
     | 
| 
      
 635 
     | 
    
         
            +
                        previousIndex,
         
     | 
| 
      
 636 
     | 
    
         
            +
                        currentIndex,
         
     | 
| 
      
 637 
     | 
    
         
            +
                    };
         
     | 
| 
      
 638 
     | 
    
         
            +
                    if (isReorder) {
         
     | 
| 
      
 639 
     | 
    
         
            +
                        this.onOrderChange.emit(dropEvent);
         
     | 
| 
      
 640 
     | 
    
         
            +
                    }
         
     | 
| 
      
 641 
     | 
    
         
            +
                    else {
         
     | 
| 
      
 642 
     | 
    
         
            +
                        this.onMoveChange.emit(dropEvent);
         
     | 
| 
      
 643 
     | 
    
         
            +
                    }
         
     | 
| 
      
 644 
     | 
    
         
            +
                    this.onItemsChange.emit(dropEvent);
         
     | 
| 
       552 
645 
     | 
    
         
             
                }
         
     | 
| 
       553 
646 
     | 
    
         
             
                static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: AXTree2Component, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
         
     | 
| 
       554 
     | 
    
         
            -
                static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.6", type: AXTree2Component, isStandalone: true, selector: "ax-tree2", inputs: { nodes: { classPropertyName: "nodes", publicName: "nodes", isSignal: true, isRequired: true, transformFunction: null }, showCheckbox: { classPropertyName: "showCheckbox", publicName: "showCheckbox", isSignal: true, isRequired: false, transformFunction: null }, dragMode: { classPropertyName: "dragMode", publicName: "dragMode", isSignal: true, isRequired: false, transformFunction: null }, showIcons: { classPropertyName: "showIcons", publicName: "showIcons", isSignal: true, isRequired: false, transformFunction: null }, showChildrenBadge: { classPropertyName: "showChildrenBadge", publicName: "showChildrenBadge", isSignal: true, isRequired: false, transformFunction: null }, animated: { classPropertyName: "animated", publicName: "animated", isSignal: true, isRequired: false, transformFunction: null }, expandedIcon: { classPropertyName: "expandedIcon", publicName: "expandedIcon", isSignal: true, isRequired: false, transformFunction: null }, collapsedIcon: { classPropertyName: "collapsedIcon", publicName: "collapsedIcon", isSignal: true, isRequired: false, transformFunction: null }, indentSize: { classPropertyName: "indentSize", publicName: "indentSize", isSignal: true, isRequired: false, transformFunction: null }, nodeHeight: { classPropertyName: "nodeHeight", publicName: "nodeHeight", isSignal: true, isRequired: false, transformFunction: null }, look: { classPropertyName: "look", publicName: "look", isSignal: true, isRequired: false, transformFunction: null }, itemTemplate: { classPropertyName: "itemTemplate", publicName: "itemTemplate", isSignal: true, isRequired: false, transformFunction: null }, lazyLoad: { classPropertyName: "lazyLoad", publicName: "lazyLoad", isSignal: true, isRequired: false, transformFunction: null }, enableLazyLoad: { classPropertyName: "enableLazyLoad", publicName: "enableLazyLoad", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { nodes: "nodesChange", onBeforeDrop: "onBeforeDrop", nodeToggle: "nodeToggle", nodeSelect: "nodeSelect", nodeDrop: "nodeDrop" }, host: { properties: { "class.ax-tree2-default": "look() === 'default'", "class.ax-tree2-card": "look() === 'card'", "class.ax-tree2-with-line": "look() === 'with-line'", "style.--ax-tree-indent-size": "indentSize() + 'px'", "style.--ax-tree-line-offset": "(indentSize() / 2) + 'px'" }, classAttribute: "ax-tree2" }, ngImport: i0, template: "<!-- Root drop list -->\n<div\n  [axDropList]=\"dragMode() !== 'none'\"\n  [sortingDisabled]=\"false\"\n  [id]=\"getListId()\"\n  [attr.data-node-id]=\"null\"\n  dropListGroup=\"ax-tree-nodes\"\n  (dropListDropped)=\"onDrop($event)\"\n  class=\"ax-tree2-drop-list\"\n  [class.ax-tree2-animated]=\"animated()\"\n  [class.ax-tree2-card]=\"look() === 'card'\"\n  [class.ax-tree2-with-lines]=\"look() === 'with-line'\"\n  [class.ax-tree2-compact]=\"nodeHeight() === 'compact'\"\n  [class.ax-tree2-comfortable]=\"nodeHeight() === 'comfortable'\"\n>\n  @for (node of nodes(); track node.id) {\n    @if (node.visible !== false) {\n      <div\n        [axDrag]=\"dragMode() !== 'none'\"\n        [dragDisabled]=\"node.disabled\"\n        [dragData]=\"node\"\n        class=\"ax-tree2-node\"\n        [class.ax-tree2-node-selected]=\"node.selected\"\n        [class.ax-tree2-node-disabled]=\"node.disabled\"\n        [class.ax-tree2-node-loading]=\"node.loading\"\n      >\n        <div\n          class=\"ax-tree2-node-content\"\n          [axDropList]=\"dragMode() !== 'none'\"\n          [id]=\"'ax-tree-node-drop-' + node.id\"\n          [attr.data-node-id]=\"node.id\"\n          [attr.data-drop-type]=\"'onto-node'\"\n          dropListGroup=\"ax-tree-nodes\"\n          (dropListDropped)=\"onDropOntoNode($event, node)\"\n        >\n          @if (dragMode() === 'handler') {\n            <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n          }\n          <ax-button\n            class=\"ax-tree2-expand-toggle ax-sm\"\n            (onClick)=\"toggleNode(node, $any($event))\"\n            [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n            [class.ax-tree2-expanded]=\"node.expanded\"\n            [disabled]=\"node.disabled || node.loading\"\n            [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n          >\n            @if (node.loading) {\n              <ax-icon>\n                <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n              </ax-icon>\n            } @else {\n              <ax-icon>\n                <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n              </ax-icon>\n            }\n          </ax-button>\n          @if (itemTemplate()) {\n            <ng-container\n              [ngTemplateOutlet]=\"itemTemplate()!\"\n              [ngTemplateOutletContext]=\"getTemplateContext(node, 0)\"\n            ></ng-container>\n          } @else {\n            @if (showCheckbox()) {\n              <ax-check-box\n                class=\"ax-tree2-checkbox\"\n                [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                [indeterminate]=\"node.indeterminate || false\"\n                (onValueChanged)=\"toggleSelection(node, $event)\"\n                (click)=\"$event.stopPropagation()\"\n                (pointerdown)=\"$event.stopPropagation()\"\n              ></ax-check-box>\n            }\n            @if (showIcons() && node.icon) {\n              <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n            }\n            <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n            @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n              <ax-badge\n                class=\"ax-tree2-children-badge\"\n                [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n              ></ax-badge>\n            }\n          }\n        </div>\n      </div>\n      @if (node.expanded && node.children && node.children.length > 0) {\n        <div class=\"ax-tree2-children\">\n          <ng-container\n            [ngTemplateOutlet]=\"childrenList\"\n            [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: 1 }\"\n          ></ng-container>\n        </div>\n      }\n    }\n  }\n</div>\n\n<!-- Recursive children template -->\n<ng-template #childrenList let-children=\"children\" let-parent=\"parent\" let-level=\"level\">\n  <div\n    [axDropList]=\"dragMode() !== 'none'\"\n    [id]=\"getListId(parent)\"\n    [attr.data-node-id]=\"parent.id\"\n    dropListGroup=\"ax-tree-nodes\"\n    (dropListDropped)=\"onDrop($event, parent)\"\n    class=\"ax-tree2-drop-list\"\n  >\n    @for (node of children; track node.id) {\n      @if (node.visible !== false) {\n        <div\n          [axDrag]=\"dragMode() !== 'none'\"\n          [dragDisabled]=\"node.disabled\"\n          [dragData]=\"node\"\n          class=\"ax-tree2-node\"\n          [class.ax-tree2-node-selected]=\"node.selected\"\n          [class.ax-tree2-node-disabled]=\"node.disabled\"\n          [class.ax-tree2-node-loading]=\"node.loading\"\n        >\n          <div\n            class=\"ax-tree2-node-content\"\n            [style.padding-left.px]=\"(level * indentSize()) / (look() === 'with-line' ? 3 : 1)\"\n            [axDropList]=\"dragMode() !== 'none'\"\n            [id]=\"'ax-tree-node-drop-' + node.id\"\n            [attr.data-node-id]=\"node.id\"\n            [attr.data-drop-type]=\"'onto-node'\"\n            dropListGroup=\"ax-tree-nodes\"\n            (dropListDropped)=\"onDropOntoNode($event, node)\"\n          >\n            @if (dragMode() === 'handler') {\n              <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n            }\n            <ax-button\n              class=\"ax-tree2-expand-toggle ax-sm\"\n              (onClick)=\"toggleNode(node, $any($event))\"\n              [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n              [class.ax-tree2-expanded]=\"node.expanded\"\n              [disabled]=\"node.disabled || node.loading\"\n              [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n            >\n              @if (node.loading) {\n                <ax-icon>\n                  <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n                </ax-icon>\n              } @else {\n                <ax-icon>\n                  <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n                </ax-icon>\n              }\n            </ax-button>\n\n            @if (itemTemplate()) {\n              <ng-container\n                [ngTemplateOutlet]=\"itemTemplate()!\"\n                [ngTemplateOutletContext]=\"getTemplateContext(node, level)\"\n              ></ng-container>\n            } @else {\n              @if (showCheckbox()) {\n                <ax-check-box\n                  class=\"ax-tree2-checkbox\"\n                  [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                  [indeterminate]=\"node.indeterminate || false\"\n                  (onValueChanged)=\"toggleSelection(node, $event)\"\n                  (click)=\"$event.stopPropagation()\"\n                  (pointerdown)=\"$event.stopPropagation()\"\n                ></ax-check-box>\n              }\n              @if (showIcons() && node.icon) {\n                <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n              }\n              <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n              @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n                <ax-badge\n                  class=\"ax-tree2-children-badge\"\n                  [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n                ></ax-badge>\n              }\n            }\n          </div>\n        </div>\n        @if (node.expanded && node.children && node.children.length > 0) {\n          <div class=\"ax-tree2-children\">\n            <ng-container\n              [ngTemplateOutlet]=\"childrenList\"\n              [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: level + 1 }\"\n            ></ng-container>\n          </div>\n        }\n      }\n    }\n  </div>\n</ng-template>\n", styles: [".ax-tree2{display:block;width:100%;--ax-comp-tree2-indent-size: 12px;--ax-comp-tree2-node-hover-bg: rgba(var(--ax-sys-color-on-lightest-surface), .04);--ax-comp-tree2-node-selected-bg: rgba(var(--ax-sys-color-primary-500), .12);--ax-comp-tree2-node-border-radius: 6px;--ax-comp-tree2-node-margin: .125rem;--ax-comp-tree2-line-color: rgba(var(--ax-sys-color-on-lightest-surface), .15);--ax-comp-tree2-drag-preview-opacity: .9;--ax-comp-tree2-drag-placeholder-bg: rgba(var(--ax-sys-color-on-lightest-surface), .02);--ax-comp-tree2-drop-active-bg: rgba(var(--ax-sys-color-primary-500), .08);--ax-comp-tree2-drop-active-outline: rgba(var(--ax-sys-color-primary-500), .3)}.ax-tree2-drop-list{min-height:2rem}.ax-tree2-compact .ax-tree2-node-content{padding:.25rem .5rem;gap:.375rem;font-size:.8125rem}.ax-tree2-comfortable .ax-tree2-node-content{padding:.75rem .625rem;gap:.625rem;font-size:.9375rem}.ax-tree2-node{position:relative;margin:var(--ax-comp-tree2-node-margin) 0;border-radius:var(--ax-comp-tree2-node-border-radius);border:1px solid transparent;cursor:move}.ax-tree2-node:hover:not(.ax-dragging){background:var(--ax-comp-tree2-node-hover-bg)}.ax-tree2-node.ax-tree2-node-selected{background:var(--ax-comp-tree2-node-selected-bg);border-color:currentColor}.ax-tree2-node.ax-dragging{opacity:var(--ax-comp-tree2-drag-placeholder-opacity);cursor:grabbing!important}.ax-tree2-node.ax-drag-placeholder{background:var(--ax-comp-tree2-drag-placeholder-bg)}.ax-drag-preview{opacity:var(--ax-comp-tree2-drag-preview-opacity)!important;box-shadow:0 4px 12px rgba(var(--ax-sys-color-on-lightest-surface),.2)!important;cursor:grabbing!important;border:2px dashed currentColor!important}.ax-tree2-node-content.ax-drop-list-sorting-active{background:var(--ax-comp-tree2-drop-active-bg);border-radius:var(--ax-comp-tree2-node-border-radius);outline:2px dashed var(--ax-comp-tree2-drop-active-outline);outline-offset:-2px}.ax-tree2-node-content{display:flex;align-items:center;gap:.25rem;cursor:pointer;-webkit-user-select:none;user-select:none}.ax-tree2-drag-handle{cursor:grab;opacity:.6;padding:.25rem}.ax-tree2-drag-handle:hover{opacity:1}.ax-tree2-drag-handle:active{cursor:grabbing}.ax-tree2-expand-toggle{background:none;border:none;cursor:pointer;padding:.25rem;min-width:1.5rem;height:1.5rem}.ax-tree2-expand-toggle:not(.ax-tree2-has-children){opacity:0;pointer-events:none}.ax-tree2-toggle-icon{font-size:.75rem}.ax-tree2-node-icon{font-size:1.125rem;flex-shrink:0}.ax-tree2-node-label{flex:1;font-size:.875rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ax-tree2-children{padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-node-disabled{opacity:.5;cursor:not-allowed;pointer-events:none}.ax-tree2-node-loading{opacity:.7}.ax-tree2-card .ax-tree2-node{border:1px solid rgba(var(--ax-sys-color-border-lightest-surface),1);margin:.5rem 0}.ax-tree2-card .ax-tree2-node-content{padding:1rem}.ax-tree2-with-lines .ax-tree2-children{position:relative;padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-with-lines .ax-tree2-children:before{content:\"\";position:absolute;left:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));top:0;height:calc(100% - .875rem);width:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines .ax-tree2-node{position:relative}.ax-tree2-with-lines .ax-tree2-node:before{content:\"\";position:absolute;left:calc(-1 * var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2)));top:60%;width:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));height:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines>.ax-tree2-drop-list>.ax-tree2-node:before,.ax-tree2-with-lines>.ax-tree2-node:before{display:none}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: AXDragDirective, selector: "[axDrag]", inputs: ["axDrag", "dragData", "dragDisabled", "dragTransition", "dragElementClone", "dropZoneGroup", "dragStartDelay", "dragResetOnDblClick", "dragLockAxis", "dragClonedTemplate", "dragCursor", "dragBoundary", "dragTransitionDuration"], outputs: ["dragPositionChanged"] }, { kind: "directive", type: AXDragHandleDirective, selector: "[axDragHandle]" }, { kind: "directive", type: AXDropListDirective, selector: "[axDropList]", inputs: ["axDropList", "sortingDisabled", "dropListGroup", "dropListOrientation"], outputs: ["dropListDropped"], exportAs: ["axDropList"] }, { kind: "component", type: AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: AXCheckBoxComponent, selector: "ax-check-box", inputs: ["disabled", "tabIndex", "readonly", "color", "value", "name", "id", "isLoading", "indeterminate"], outputs: ["onBlur", "onFocus", "valueChange", "onValueChanged"] }, { kind: "component", type: AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "component", type: AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
         
     | 
| 
      
 647 
     | 
    
         
            +
                static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.6", type: AXTree2Component, isStandalone: true, selector: "ax-tree2", inputs: { nodes: { classPropertyName: "nodes", publicName: "nodes", isSignal: true, isRequired: true, transformFunction: null }, showCheckbox: { classPropertyName: "showCheckbox", publicName: "showCheckbox", isSignal: true, isRequired: false, transformFunction: null }, dragMode: { classPropertyName: "dragMode", publicName: "dragMode", isSignal: true, isRequired: false, transformFunction: null }, dragOperationType: { classPropertyName: "dragOperationType", publicName: "dragOperationType", isSignal: true, isRequired: false, transformFunction: null }, showIcons: { classPropertyName: "showIcons", publicName: "showIcons", isSignal: true, isRequired: false, transformFunction: null }, showChildrenBadge: { classPropertyName: "showChildrenBadge", publicName: "showChildrenBadge", isSignal: true, isRequired: false, transformFunction: null }, expandedIcon: { classPropertyName: "expandedIcon", publicName: "expandedIcon", isSignal: true, isRequired: false, transformFunction: null }, collapsedIcon: { classPropertyName: "collapsedIcon", publicName: "collapsedIcon", isSignal: true, isRequired: false, transformFunction: null }, indentSize: { classPropertyName: "indentSize", publicName: "indentSize", isSignal: true, isRequired: false, transformFunction: null }, nodeHeight: { classPropertyName: "nodeHeight", publicName: "nodeHeight", isSignal: true, isRequired: false, transformFunction: null }, look: { classPropertyName: "look", publicName: "look", isSignal: true, isRequired: false, transformFunction: null }, itemTemplate: { classPropertyName: "itemTemplate", publicName: "itemTemplate", isSignal: true, isRequired: false, transformFunction: null }, lazyLoad: { classPropertyName: "lazyLoad", publicName: "lazyLoad", isSignal: true, isRequired: false, transformFunction: null }, enableLazyLoad: { classPropertyName: "enableLazyLoad", publicName: "enableLazyLoad", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { nodes: "nodesChange", onBeforeDrop: "onBeforeDrop", onNodeToggle: "onNodeToggle", onNodeSelect: "onNodeSelect", onOrderChange: "onOrderChange", onMoveChange: "onMoveChange", onItemsChange: "onItemsChange" }, host: { properties: { "class.ax-tree2-default": "look() === 'default'", "class.ax-tree2-card": "look() === 'card'", "class.ax-tree2-with-line": "look() === 'with-line'", "style.--ax-tree-indent-size": "indentSize() + 'px'", "style.--ax-tree-line-offset": "(indentSize() / 2) + 'px'" }, classAttribute: "ax-tree2" }, ngImport: i0, template: "<!-- Root drop list -->\n<div\n  [axDropList]=\"dragMode() !== 'none'\"\n  [sortingDisabled]=\"false\"\n  [id]=\"getListId()\"\n  [attr.data-node-id]=\"null\"\n  dropListGroup=\"ax-tree-nodes\"\n  (dropListDropped)=\"onDrop($event)\"\n  class=\"ax-tree2-drop-list\"\n  [class.ax-tree2-card]=\"look() === 'card'\"\n  [class.ax-tree2-with-lines]=\"look() === 'with-line'\"\n  [class.ax-tree2-compact]=\"nodeHeight() === 'compact'\"\n  [class.ax-tree2-comfortable]=\"nodeHeight() === 'comfortable'\"\n>\n  @for (node of nodes(); track node.id) {\n    @if (node.visible !== false) {\n      <div\n        [axDrag]=\"dragMode() !== 'none'\"\n        [dragDisabled]=\"node.disabled\"\n        [dragData]=\"node\"\n        class=\"ax-tree2-node\"\n        [class.ax-tree2-node-selected]=\"node.selected\"\n        [class.ax-tree2-node-disabled]=\"node.disabled\"\n        [class.ax-tree2-node-loading]=\"node.loading\"\n      >\n        <div\n          class=\"ax-tree2-node-content\"\n          [axDropList]=\"dragMode() !== 'none'\"\n          [id]=\"'ax-tree-node-drop-' + node.id\"\n          [attr.data-node-id]=\"node.id\"\n          [attr.data-drop-type]=\"'onto-node'\"\n          dropListGroup=\"ax-tree-nodes\"\n          (dropListDropped)=\"onDropOntoNode($event, node)\"\n        >\n          @if (dragMode() === 'handler') {\n            <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n          }\n          <ax-button\n            class=\"ax-tree2-expand-toggle ax-sm\"\n            (onClick)=\"toggleNode(node, $any($event))\"\n            [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n            [class.ax-tree2-expanded]=\"node.expanded\"\n            [disabled]=\"node.disabled || node.loading\"\n            [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n          >\n            @if (node.loading) {\n              <ax-icon>\n                <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n              </ax-icon>\n            } @else {\n              <ax-icon>\n                <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n              </ax-icon>\n            }\n          </ax-button>\n          @if (itemTemplate()) {\n            <ng-container\n              [ngTemplateOutlet]=\"itemTemplate()!\"\n              [ngTemplateOutletContext]=\"getTemplateContext(node, 0)\"\n            ></ng-container>\n          } @else {\n            @if (showCheckbox()) {\n              <ax-check-box\n                class=\"ax-tree2-checkbox\"\n                [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                [indeterminate]=\"node.indeterminate || false\"\n                (onValueChanged)=\"toggleSelection(node, $event)\"\n                (click)=\"$event.stopPropagation()\"\n                (pointerdown)=\"$event.stopPropagation()\"\n              ></ax-check-box>\n            }\n            @if (showIcons() && node.icon) {\n              <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n            }\n            <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n            @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n              <ax-badge\n                class=\"ax-tree2-children-badge\"\n                [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n              ></ax-badge>\n            }\n          }\n        </div>\n      </div>\n      @if (node.expanded && node.children && node.children.length > 0) {\n        <div class=\"ax-tree2-children\">\n          <ng-container\n            [ngTemplateOutlet]=\"childrenList\"\n            [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: 1 }\"\n          ></ng-container>\n        </div>\n      }\n    }\n  }\n</div>\n\n<!-- Recursive children template -->\n<ng-template #childrenList let-children=\"children\" let-parent=\"parent\" let-level=\"level\">\n  <div\n    [axDropList]=\"dragMode() !== 'none'\"\n    [id]=\"getListId(parent)\"\n    [attr.data-node-id]=\"parent.id\"\n    dropListGroup=\"ax-tree-nodes\"\n    (dropListDropped)=\"onDrop($event, parent)\"\n    class=\"ax-tree2-drop-list\"\n  >\n    @for (node of children; track node.id) {\n      @if (node.visible !== false) {\n        <div\n          [axDrag]=\"dragMode() !== 'none'\"\n          [dragDisabled]=\"node.disabled\"\n          [dragData]=\"node\"\n          class=\"ax-tree2-node\"\n          [class.ax-tree2-node-selected]=\"node.selected\"\n          [class.ax-tree2-node-disabled]=\"node.disabled\"\n          [class.ax-tree2-node-loading]=\"node.loading\"\n        >\n          <div\n            class=\"ax-tree2-node-content\"\n            [style.padding-left.px]=\"(level * indentSize()) / (look() === 'with-line' ? 3 : 1)\"\n            [axDropList]=\"dragMode() !== 'none'\"\n            [id]=\"'ax-tree-node-drop-' + node.id\"\n            [attr.data-node-id]=\"node.id\"\n            [attr.data-drop-type]=\"'onto-node'\"\n            dropListGroup=\"ax-tree-nodes\"\n            (dropListDropped)=\"onDropOntoNode($event, node)\"\n          >\n            @if (dragMode() === 'handler') {\n              <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n            }\n            <ax-button\n              class=\"ax-tree2-expand-toggle ax-sm\"\n              (onClick)=\"toggleNode(node, $any($event))\"\n              [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n              [class.ax-tree2-expanded]=\"node.expanded\"\n              [disabled]=\"node.disabled || node.loading\"\n              [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n            >\n              @if (node.loading) {\n                <ax-icon>\n                  <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n                </ax-icon>\n              } @else {\n                <ax-icon>\n                  <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n                </ax-icon>\n              }\n            </ax-button>\n\n            @if (itemTemplate()) {\n              <ng-container\n                [ngTemplateOutlet]=\"itemTemplate()!\"\n                [ngTemplateOutletContext]=\"getTemplateContext(node, level)\"\n              ></ng-container>\n            } @else {\n              @if (showCheckbox()) {\n                <ax-check-box\n                  class=\"ax-tree2-checkbox\"\n                  [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                  [indeterminate]=\"node.indeterminate || false\"\n                  (onValueChanged)=\"toggleSelection(node, $event)\"\n                  (click)=\"$event.stopPropagation()\"\n                  (pointerdown)=\"$event.stopPropagation()\"\n                ></ax-check-box>\n              }\n              @if (showIcons() && node.icon) {\n                <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n              }\n              <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n              @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n                <ax-badge\n                  class=\"ax-tree2-children-badge\"\n                  [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n                ></ax-badge>\n              }\n            }\n          </div>\n        </div>\n        @if (node.expanded && node.children && node.children.length > 0) {\n          <div class=\"ax-tree2-children\">\n            <ng-container\n              [ngTemplateOutlet]=\"childrenList\"\n              [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: level + 1 }\"\n            ></ng-container>\n          </div>\n        }\n      }\n    }\n  </div>\n</ng-template>\n", styles: [".ax-tree2{display:block;width:100%;--ax-comp-tree2-indent-size: 12px;--ax-comp-tree2-node-hover-bg: rgba(var(--ax-sys-color-on-lightest-surface), .04);--ax-comp-tree2-node-selected-bg: rgba(var(--ax-sys-color-primary-500), .12);--ax-comp-tree2-node-border-radius: 6px;--ax-comp-tree2-node-margin: .25rem;--ax-comp-tree2-line-color: rgba(var(--ax-sys-color-on-lightest-surface), .15);--ax-comp-tree2-drag-preview-opacity: .9;--ax-comp-tree2-drag-placeholder-bg: rgba(var(--ax-sys-color-on-lightest-surface), .02);--ax-comp-tree2-drop-active-bg: rgba(var(--ax-sys-color-primary-500), .08);--ax-comp-tree2-drop-active-outline: rgba(var(--ax-sys-color-primary-500), .3)}.ax-tree2-drop-list{min-height:2rem}.ax-tree2-compact .ax-tree2-node-content{padding:.25rem .5rem;gap:.375rem;font-size:.8125rem}.ax-tree2-comfortable .ax-tree2-node-content{padding:.75rem .625rem;gap:.625rem;font-size:.9375rem}.ax-tree2-node{position:relative;margin:var(--ax-comp-tree2-node-margin) 0;border-radius:var(--ax-comp-tree2-node-border-radius);border:1px solid transparent;cursor:move}.ax-tree2-node:hover:not(.ax-dragging){background:var(--ax-comp-tree2-node-hover-bg)}.ax-tree2-node.ax-tree2-node-selected{background:var(--ax-comp-tree2-node-selected-bg);border-color:currentColor}.ax-tree2-node.ax-dragging{opacity:var(--ax-comp-tree2-drag-placeholder-opacity);cursor:grabbing!important}.ax-tree2-node.ax-drag-placeholder{background:var(--ax-comp-tree2-drag-placeholder-bg)}.ax-drag-preview{opacity:var(--ax-comp-tree2-drag-preview-opacity)!important;box-shadow:0 4px 12px rgba(var(--ax-sys-color-on-lightest-surface),.2)!important;cursor:grabbing!important;border:2px dashed currentColor!important}.ax-tree2-node-content.ax-drop-list-sorting-active{background:var(--ax-comp-tree2-drop-active-bg);border-radius:var(--ax-comp-tree2-node-border-radius);outline:2px dashed var(--ax-comp-tree2-drop-active-outline);outline-offset:-2px}.ax-tree2-node-content{display:flex;align-items:center;gap:.5rem;cursor:pointer;-webkit-user-select:none;user-select:none}.ax-tree2-drag-handle{cursor:grab;opacity:.6;padding:.25rem}.ax-tree2-drag-handle:hover{opacity:1}.ax-tree2-drag-handle:active{cursor:grabbing}.ax-tree2-expand-toggle{background:none;border:none;cursor:pointer;padding:.25rem;min-width:1.5rem;height:1.5rem}.ax-tree2-expand-toggle:not(.ax-tree2-has-children){opacity:0;pointer-events:none}.ax-tree2-toggle-icon{font-size:.75rem}.ax-tree2-node-icon{font-size:1.125rem;flex-shrink:0}.ax-tree2-node-label{flex:1;font-size:.875rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ax-tree2-children{padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-node-disabled{opacity:.5;cursor:not-allowed;pointer-events:none}.ax-tree2-node-loading{opacity:.7}.ax-tree2-card .ax-tree2-node{border:1px solid rgba(var(--ax-sys-color-border-lightest-surface),1);margin:.5rem 0}.ax-tree2-card .ax-tree2-node-content{padding:1rem}.ax-tree2-with-lines .ax-tree2-children{position:relative;padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-with-lines .ax-tree2-children:before{content:\"\";position:absolute;left:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));top:0;height:calc(100% - .875rem);width:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines .ax-tree2-node{position:relative}.ax-tree2-with-lines .ax-tree2-node:before{content:\"\";position:absolute;left:calc(-1 * var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2)));top:60%;width:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));height:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines>.ax-tree2-drop-list>.ax-tree2-node:before,.ax-tree2-with-lines>.ax-tree2-node:before{display:none}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: AXDragDirective, selector: "[axDrag]", inputs: ["axDrag", "dragData", "dragDisabled", "dragTransition", "dragElementClone", "dropZoneGroup", "dragStartDelay", "dragResetOnDblClick", "dragLockAxis", "dragClonedTemplate", "dragCursor", "dragBoundary", "dragTransitionDuration"], outputs: ["dragPositionChanged"] }, { kind: "directive", type: AXDragHandleDirective, selector: "[axDragHandle]" }, { kind: "directive", type: AXDropListDirective, selector: "[axDropList]", inputs: ["axDropList", "sortingDisabled", "dropListGroup", "dropListOrientation"], outputs: ["dropListDropped"], exportAs: ["axDropList"] }, { kind: "component", type: AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: AXCheckBoxComponent, selector: "ax-check-box", inputs: ["disabled", "tabIndex", "readonly", "color", "value", "name", "id", "isLoading", "indeterminate"], outputs: ["onBlur", "onFocus", "valueChange", "onValueChanged"] }, { kind: "component", type: AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "component", type: AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
         
     | 
| 
       555 
648 
     | 
    
         
             
            }
         
     | 
| 
       556 
649 
     | 
    
         
             
            i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: AXTree2Component, decorators: [{
         
     | 
| 
       557 
650 
     | 
    
         
             
                        type: Component,
         
     | 
| 
         @@ -573,18 +666,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.6", ngImpor 
     | 
|
| 
       573 
666 
     | 
    
         
             
                                    '[class.ax-tree2-with-line]': "look() === 'with-line'",
         
     | 
| 
       574 
667 
     | 
    
         
             
                                    '[style.--ax-tree-indent-size]': "indentSize() + 'px'",
         
     | 
| 
       575 
668 
     | 
    
         
             
                                    '[style.--ax-tree-line-offset]': "(indentSize() / 2) + 'px'",
         
     | 
| 
       576 
     | 
    
         
            -
                                }, template: "<!-- Root drop list -->\n<div\n  [axDropList]=\"dragMode() !== 'none'\"\n  [sortingDisabled]=\"false\"\n  [id]=\"getListId()\"\n  [attr.data-node-id]=\"null\"\n  dropListGroup=\"ax-tree-nodes\"\n  (dropListDropped)=\"onDrop($event)\"\n  class=\"ax-tree2-drop-list\"\n  [class.ax-tree2-animated]=\"animated()\"\n  [class.ax-tree2-card]=\"look() === 'card'\"\n  [class.ax-tree2-with-lines]=\"look() === 'with-line'\"\n  [class.ax-tree2-compact]=\"nodeHeight() === 'compact'\"\n  [class.ax-tree2-comfortable]=\"nodeHeight() === 'comfortable'\"\n>\n  @for (node of nodes(); track node.id) {\n    @if (node.visible !== false) {\n      <div\n        [axDrag]=\"dragMode() !== 'none'\"\n        [dragDisabled]=\"node.disabled\"\n        [dragData]=\"node\"\n        class=\"ax-tree2-node\"\n        [class.ax-tree2-node-selected]=\"node.selected\"\n        [class.ax-tree2-node-disabled]=\"node.disabled\"\n        [class.ax-tree2-node-loading]=\"node.loading\"\n      >\n        <div\n          class=\"ax-tree2-node-content\"\n          [axDropList]=\"dragMode() !== 'none'\"\n          [id]=\"'ax-tree-node-drop-' + node.id\"\n          [attr.data-node-id]=\"node.id\"\n          [attr.data-drop-type]=\"'onto-node'\"\n          dropListGroup=\"ax-tree-nodes\"\n          (dropListDropped)=\"onDropOntoNode($event, node)\"\n        >\n          @if (dragMode() === 'handler') {\n            <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n          }\n          <ax-button\n            class=\"ax-tree2-expand-toggle ax-sm\"\n            (onClick)=\"toggleNode(node, $any($event))\"\n            [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n            [class.ax-tree2-expanded]=\"node.expanded\"\n            [disabled]=\"node.disabled || node.loading\"\n            [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n          >\n            @if (node.loading) {\n              <ax-icon>\n                <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n              </ax-icon>\n            } @else {\n              <ax-icon>\n                <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n              </ax-icon>\n            }\n          </ax-button>\n          @if (itemTemplate()) {\n            <ng-container\n              [ngTemplateOutlet]=\"itemTemplate()!\"\n              [ngTemplateOutletContext]=\"getTemplateContext(node, 0)\"\n            ></ng-container>\n          } @else {\n            @if (showCheckbox()) {\n              <ax-check-box\n                class=\"ax-tree2-checkbox\"\n                [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                [indeterminate]=\"node.indeterminate || false\"\n                (onValueChanged)=\"toggleSelection(node, $event)\"\n                (click)=\"$event.stopPropagation()\"\n                (pointerdown)=\"$event.stopPropagation()\"\n              ></ax-check-box>\n            }\n            @if (showIcons() && node.icon) {\n              <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n            }\n            <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n            @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n              <ax-badge\n                class=\"ax-tree2-children-badge\"\n                [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n              ></ax-badge>\n            }\n          }\n        </div>\n      </div>\n      @if (node.expanded && node.children && node.children.length > 0) {\n        <div class=\"ax-tree2-children\">\n          <ng-container\n            [ngTemplateOutlet]=\"childrenList\"\n            [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: 1 }\"\n          ></ng-container>\n        </div>\n      }\n    }\n  }\n</div>\n\n<!-- Recursive children template -->\n<ng-template #childrenList let-children=\"children\" let-parent=\"parent\" let-level=\"level\">\n  <div\n    [axDropList]=\"dragMode() !== 'none'\"\n    [id]=\"getListId(parent)\"\n    [attr.data-node-id]=\"parent.id\"\n    dropListGroup=\"ax-tree-nodes\"\n    (dropListDropped)=\"onDrop($event, parent)\"\n    class=\"ax-tree2-drop-list\"\n  >\n    @for (node of children; track node.id) {\n      @if (node.visible !== false) {\n        <div\n          [axDrag]=\"dragMode() !== 'none'\"\n          [dragDisabled]=\"node.disabled\"\n          [dragData]=\"node\"\n          class=\"ax-tree2-node\"\n          [class.ax-tree2-node-selected]=\"node.selected\"\n          [class.ax-tree2-node-disabled]=\"node.disabled\"\n          [class.ax-tree2-node-loading]=\"node.loading\"\n        >\n          <div\n            class=\"ax-tree2-node-content\"\n            [style.padding-left.px]=\"(level * indentSize()) / (look() === 'with-line' ? 3 : 1)\"\n            [axDropList]=\"dragMode() !== 'none'\"\n            [id]=\"'ax-tree-node-drop-' + node.id\"\n            [attr.data-node-id]=\"node.id\"\n            [attr.data-drop-type]=\"'onto-node'\"\n            dropListGroup=\"ax-tree-nodes\"\n            (dropListDropped)=\"onDropOntoNode($event, node)\"\n          >\n            @if (dragMode() === 'handler') {\n              <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n            }\n            <ax-button\n              class=\"ax-tree2-expand-toggle ax-sm\"\n              (onClick)=\"toggleNode(node, $any($event))\"\n              [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n              [class.ax-tree2-expanded]=\"node.expanded\"\n              [disabled]=\"node.disabled || node.loading\"\n              [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n            >\n              @if (node.loading) {\n                <ax-icon>\n                  <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n                </ax-icon>\n              } @else {\n                <ax-icon>\n                  <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n                </ax-icon>\n              }\n            </ax-button>\n\n            @if (itemTemplate()) {\n              <ng-container\n                [ngTemplateOutlet]=\"itemTemplate()!\"\n                [ngTemplateOutletContext]=\"getTemplateContext(node, level)\"\n              ></ng-container>\n            } @else {\n              @if (showCheckbox()) {\n                <ax-check-box\n                  class=\"ax-tree2-checkbox\"\n                  [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                  [indeterminate]=\"node.indeterminate || false\"\n                  (onValueChanged)=\"toggleSelection(node, $event)\"\n                  (click)=\"$event.stopPropagation()\"\n                  (pointerdown)=\"$event.stopPropagation()\"\n                ></ax-check-box>\n              }\n              @if (showIcons() && node.icon) {\n                <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n              }\n              <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n              @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n                <ax-badge\n                  class=\"ax-tree2-children-badge\"\n                  [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n                ></ax-badge>\n              }\n            }\n          </div>\n        </div>\n        @if (node.expanded && node.children && node.children.length > 0) {\n          <div class=\"ax-tree2-children\">\n            <ng-container\n              [ngTemplateOutlet]=\"childrenList\"\n              [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: level + 1 }\"\n            ></ng-container>\n          </div>\n        }\n      }\n    }\n  </div>\n</ng-template>\n", styles: [".ax-tree2{display:block;width:100%;--ax-comp-tree2-indent-size: 12px;--ax-comp-tree2-node-hover-bg: rgba(var(--ax-sys-color-on-lightest-surface), .04);--ax-comp-tree2-node-selected-bg: rgba(var(--ax-sys-color-primary-500), .12);--ax-comp-tree2-node-border-radius: 6px;--ax-comp-tree2-node-margin: .125rem;--ax-comp-tree2-line-color: rgba(var(--ax-sys-color-on-lightest-surface), .15);--ax-comp-tree2-drag-preview-opacity: .9;--ax-comp-tree2-drag-placeholder-bg: rgba(var(--ax-sys-color-on-lightest-surface), .02);--ax-comp-tree2-drop-active-bg: rgba(var(--ax-sys-color-primary-500), .08);--ax-comp-tree2-drop-active-outline: rgba(var(--ax-sys-color-primary-500), .3)}.ax-tree2-drop-list{min-height:2rem}.ax-tree2-compact .ax-tree2-node-content{padding:.25rem .5rem;gap:.375rem;font-size:.8125rem}.ax-tree2-comfortable .ax-tree2-node-content{padding:.75rem .625rem;gap:.625rem;font-size:.9375rem}.ax-tree2-node{position:relative;margin:var(--ax-comp-tree2-node-margin) 0;border-radius:var(--ax-comp-tree2-node-border-radius);border:1px solid transparent;cursor:move}.ax-tree2-node:hover:not(.ax-dragging){background:var(--ax-comp-tree2-node-hover-bg)}.ax-tree2-node.ax-tree2-node-selected{background:var(--ax-comp-tree2-node-selected-bg);border-color:currentColor}.ax-tree2-node.ax-dragging{opacity:var(--ax-comp-tree2-drag-placeholder-opacity);cursor:grabbing!important}.ax-tree2-node.ax-drag-placeholder{background:var(--ax-comp-tree2-drag-placeholder-bg)}.ax-drag-preview{opacity:var(--ax-comp-tree2-drag-preview-opacity)!important;box-shadow:0 4px 12px rgba(var(--ax-sys-color-on-lightest-surface),.2)!important;cursor:grabbing!important;border:2px dashed currentColor!important}.ax-tree2-node-content.ax-drop-list-sorting-active{background:var(--ax-comp-tree2-drop-active-bg);border-radius:var(--ax-comp-tree2-node-border-radius);outline:2px dashed var(--ax-comp-tree2-drop-active-outline);outline-offset:-2px}.ax-tree2-node-content{display:flex;align-items:center;gap:.25rem;cursor:pointer;-webkit-user-select:none;user-select:none}.ax-tree2-drag-handle{cursor:grab;opacity:.6;padding:.25rem}.ax-tree2-drag-handle:hover{opacity:1}.ax-tree2-drag-handle:active{cursor:grabbing}.ax-tree2-expand-toggle{background:none;border:none;cursor:pointer;padding:.25rem;min-width:1.5rem;height:1.5rem}.ax-tree2-expand-toggle:not(.ax-tree2-has-children){opacity:0;pointer-events:none}.ax-tree2-toggle-icon{font-size:.75rem}.ax-tree2-node-icon{font-size:1.125rem;flex-shrink:0}.ax-tree2-node-label{flex:1;font-size:.875rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ax-tree2-children{padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-node-disabled{opacity:.5;cursor:not-allowed;pointer-events:none}.ax-tree2-node-loading{opacity:.7}.ax-tree2-card .ax-tree2-node{border:1px solid rgba(var(--ax-sys-color-border-lightest-surface),1);margin:.5rem 0}.ax-tree2-card .ax-tree2-node-content{padding:1rem}.ax-tree2-with-lines .ax-tree2-children{position:relative;padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-with-lines .ax-tree2-children:before{content:\"\";position:absolute;left:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));top:0;height:calc(100% - .875rem);width:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines .ax-tree2-node{position:relative}.ax-tree2-with-lines .ax-tree2-node:before{content:\"\";position:absolute;left:calc(-1 * var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2)));top:60%;width:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));height:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines>.ax-tree2-drop-list>.ax-tree2-node:before,.ax-tree2-with-lines>.ax-tree2-node:before{display:none}\n"] }]
         
     | 
| 
       577 
     | 
    
         
            -
                    }], propDecorators: { nodes: [{ type: i0.Input, args: [{ isSignal: true, alias: "nodes", required: true }] }, { type: i0.Output, args: ["nodesChange"] }], showCheckbox: [{ type: i0.Input, args: [{ isSignal: true, alias: "showCheckbox", required: false }] }], dragMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "dragMode", required: false }] }],  
     | 
| 
      
 669 
     | 
    
         
            +
                                }, template: "<!-- Root drop list -->\n<div\n  [axDropList]=\"dragMode() !== 'none'\"\n  [sortingDisabled]=\"false\"\n  [id]=\"getListId()\"\n  [attr.data-node-id]=\"null\"\n  dropListGroup=\"ax-tree-nodes\"\n  (dropListDropped)=\"onDrop($event)\"\n  class=\"ax-tree2-drop-list\"\n  [class.ax-tree2-card]=\"look() === 'card'\"\n  [class.ax-tree2-with-lines]=\"look() === 'with-line'\"\n  [class.ax-tree2-compact]=\"nodeHeight() === 'compact'\"\n  [class.ax-tree2-comfortable]=\"nodeHeight() === 'comfortable'\"\n>\n  @for (node of nodes(); track node.id) {\n    @if (node.visible !== false) {\n      <div\n        [axDrag]=\"dragMode() !== 'none'\"\n        [dragDisabled]=\"node.disabled\"\n        [dragData]=\"node\"\n        class=\"ax-tree2-node\"\n        [class.ax-tree2-node-selected]=\"node.selected\"\n        [class.ax-tree2-node-disabled]=\"node.disabled\"\n        [class.ax-tree2-node-loading]=\"node.loading\"\n      >\n        <div\n          class=\"ax-tree2-node-content\"\n          [axDropList]=\"dragMode() !== 'none'\"\n          [id]=\"'ax-tree-node-drop-' + node.id\"\n          [attr.data-node-id]=\"node.id\"\n          [attr.data-drop-type]=\"'onto-node'\"\n          dropListGroup=\"ax-tree-nodes\"\n          (dropListDropped)=\"onDropOntoNode($event, node)\"\n        >\n          @if (dragMode() === 'handler') {\n            <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n          }\n          <ax-button\n            class=\"ax-tree2-expand-toggle ax-sm\"\n            (onClick)=\"toggleNode(node, $any($event))\"\n            [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n            [class.ax-tree2-expanded]=\"node.expanded\"\n            [disabled]=\"node.disabled || node.loading\"\n            [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n          >\n            @if (node.loading) {\n              <ax-icon>\n                <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n              </ax-icon>\n            } @else {\n              <ax-icon>\n                <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n              </ax-icon>\n            }\n          </ax-button>\n          @if (itemTemplate()) {\n            <ng-container\n              [ngTemplateOutlet]=\"itemTemplate()!\"\n              [ngTemplateOutletContext]=\"getTemplateContext(node, 0)\"\n            ></ng-container>\n          } @else {\n            @if (showCheckbox()) {\n              <ax-check-box\n                class=\"ax-tree2-checkbox\"\n                [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                [indeterminate]=\"node.indeterminate || false\"\n                (onValueChanged)=\"toggleSelection(node, $event)\"\n                (click)=\"$event.stopPropagation()\"\n                (pointerdown)=\"$event.stopPropagation()\"\n              ></ax-check-box>\n            }\n            @if (showIcons() && node.icon) {\n              <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n            }\n            <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n            @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n              <ax-badge\n                class=\"ax-tree2-children-badge\"\n                [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n              ></ax-badge>\n            }\n          }\n        </div>\n      </div>\n      @if (node.expanded && node.children && node.children.length > 0) {\n        <div class=\"ax-tree2-children\">\n          <ng-container\n            [ngTemplateOutlet]=\"childrenList\"\n            [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: 1 }\"\n          ></ng-container>\n        </div>\n      }\n    }\n  }\n</div>\n\n<!-- Recursive children template -->\n<ng-template #childrenList let-children=\"children\" let-parent=\"parent\" let-level=\"level\">\n  <div\n    [axDropList]=\"dragMode() !== 'none'\"\n    [id]=\"getListId(parent)\"\n    [attr.data-node-id]=\"parent.id\"\n    dropListGroup=\"ax-tree-nodes\"\n    (dropListDropped)=\"onDrop($event, parent)\"\n    class=\"ax-tree2-drop-list\"\n  >\n    @for (node of children; track node.id) {\n      @if (node.visible !== false) {\n        <div\n          [axDrag]=\"dragMode() !== 'none'\"\n          [dragDisabled]=\"node.disabled\"\n          [dragData]=\"node\"\n          class=\"ax-tree2-node\"\n          [class.ax-tree2-node-selected]=\"node.selected\"\n          [class.ax-tree2-node-disabled]=\"node.disabled\"\n          [class.ax-tree2-node-loading]=\"node.loading\"\n        >\n          <div\n            class=\"ax-tree2-node-content\"\n            [style.padding-left.px]=\"(level * indentSize()) / (look() === 'with-line' ? 3 : 1)\"\n            [axDropList]=\"dragMode() !== 'none'\"\n            [id]=\"'ax-tree-node-drop-' + node.id\"\n            [attr.data-node-id]=\"node.id\"\n            [attr.data-drop-type]=\"'onto-node'\"\n            dropListGroup=\"ax-tree-nodes\"\n            (dropListDropped)=\"onDropOntoNode($event, node)\"\n          >\n            @if (dragMode() === 'handler') {\n              <span class=\"ax-tree2-drag-handle\" axDragHandle title=\"Drag to reorder\"> \u22EE\u22EE </span>\n            }\n            <ax-button\n              class=\"ax-tree2-expand-toggle ax-sm\"\n              (onClick)=\"toggleNode(node, $any($event))\"\n              [class.ax-tree2-has-children]=\"shouldShowExpandToggle(node)\"\n              [class.ax-tree2-expanded]=\"node.expanded\"\n              [disabled]=\"node.disabled || node.loading\"\n              [style.visibility]=\"shouldShowExpandToggle(node) ? 'visible' : 'hidden'\"\n            >\n              @if (node.loading) {\n                <ax-icon>\n                  <i class=\"fa-solid fa-spinner fa-spin ax-tree2-loading-spinner\"></i>\n                </ax-icon>\n              } @else {\n                <ax-icon>\n                  <i [class]=\"node.expanded ? expandedIcon() : collapsedIcon()\" class=\"ax-tree2-toggle-icon\"></i>\n                </ax-icon>\n              }\n            </ax-button>\n\n            @if (itemTemplate()) {\n              <ng-container\n                [ngTemplateOutlet]=\"itemTemplate()!\"\n                [ngTemplateOutletContext]=\"getTemplateContext(node, level)\"\n              ></ng-container>\n            } @else {\n              @if (showCheckbox()) {\n                <ax-check-box\n                  class=\"ax-tree2-checkbox\"\n                  [ngModel]=\"node.indeterminate ? null : node.selected || false\"\n                  [indeterminate]=\"node.indeterminate || false\"\n                  (onValueChanged)=\"toggleSelection(node, $event)\"\n                  (click)=\"$event.stopPropagation()\"\n                  (pointerdown)=\"$event.stopPropagation()\"\n                ></ax-check-box>\n              }\n              @if (showIcons() && node.icon) {\n                <i [class]=\"node.icon\" class=\"ax-tree2-node-icon\"></i>\n              }\n              <span class=\"ax-tree2-node-label\">{{ node.label }}</span>\n              @if (showChildrenBadge() && (node.childrenCount || (node.children && node.children.length > 0))) {\n                <ax-badge\n                  class=\"ax-tree2-children-badge\"\n                  [text]=\"(node.childrenCount ?? node.children?.length ?? 0).toString()\"\n                ></ax-badge>\n              }\n            }\n          </div>\n        </div>\n        @if (node.expanded && node.children && node.children.length > 0) {\n          <div class=\"ax-tree2-children\">\n            <ng-container\n              [ngTemplateOutlet]=\"childrenList\"\n              [ngTemplateOutletContext]=\"{ children: node.children, parent: node, level: level + 1 }\"\n            ></ng-container>\n          </div>\n        }\n      }\n    }\n  </div>\n</ng-template>\n", styles: [".ax-tree2{display:block;width:100%;--ax-comp-tree2-indent-size: 12px;--ax-comp-tree2-node-hover-bg: rgba(var(--ax-sys-color-on-lightest-surface), .04);--ax-comp-tree2-node-selected-bg: rgba(var(--ax-sys-color-primary-500), .12);--ax-comp-tree2-node-border-radius: 6px;--ax-comp-tree2-node-margin: .25rem;--ax-comp-tree2-line-color: rgba(var(--ax-sys-color-on-lightest-surface), .15);--ax-comp-tree2-drag-preview-opacity: .9;--ax-comp-tree2-drag-placeholder-bg: rgba(var(--ax-sys-color-on-lightest-surface), .02);--ax-comp-tree2-drop-active-bg: rgba(var(--ax-sys-color-primary-500), .08);--ax-comp-tree2-drop-active-outline: rgba(var(--ax-sys-color-primary-500), .3)}.ax-tree2-drop-list{min-height:2rem}.ax-tree2-compact .ax-tree2-node-content{padding:.25rem .5rem;gap:.375rem;font-size:.8125rem}.ax-tree2-comfortable .ax-tree2-node-content{padding:.75rem .625rem;gap:.625rem;font-size:.9375rem}.ax-tree2-node{position:relative;margin:var(--ax-comp-tree2-node-margin) 0;border-radius:var(--ax-comp-tree2-node-border-radius);border:1px solid transparent;cursor:move}.ax-tree2-node:hover:not(.ax-dragging){background:var(--ax-comp-tree2-node-hover-bg)}.ax-tree2-node.ax-tree2-node-selected{background:var(--ax-comp-tree2-node-selected-bg);border-color:currentColor}.ax-tree2-node.ax-dragging{opacity:var(--ax-comp-tree2-drag-placeholder-opacity);cursor:grabbing!important}.ax-tree2-node.ax-drag-placeholder{background:var(--ax-comp-tree2-drag-placeholder-bg)}.ax-drag-preview{opacity:var(--ax-comp-tree2-drag-preview-opacity)!important;box-shadow:0 4px 12px rgba(var(--ax-sys-color-on-lightest-surface),.2)!important;cursor:grabbing!important;border:2px dashed currentColor!important}.ax-tree2-node-content.ax-drop-list-sorting-active{background:var(--ax-comp-tree2-drop-active-bg);border-radius:var(--ax-comp-tree2-node-border-radius);outline:2px dashed var(--ax-comp-tree2-drop-active-outline);outline-offset:-2px}.ax-tree2-node-content{display:flex;align-items:center;gap:.5rem;cursor:pointer;-webkit-user-select:none;user-select:none}.ax-tree2-drag-handle{cursor:grab;opacity:.6;padding:.25rem}.ax-tree2-drag-handle:hover{opacity:1}.ax-tree2-drag-handle:active{cursor:grabbing}.ax-tree2-expand-toggle{background:none;border:none;cursor:pointer;padding:.25rem;min-width:1.5rem;height:1.5rem}.ax-tree2-expand-toggle:not(.ax-tree2-has-children){opacity:0;pointer-events:none}.ax-tree2-toggle-icon{font-size:.75rem}.ax-tree2-node-icon{font-size:1.125rem;flex-shrink:0}.ax-tree2-node-label{flex:1;font-size:.875rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ax-tree2-children{padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-node-disabled{opacity:.5;cursor:not-allowed;pointer-events:none}.ax-tree2-node-loading{opacity:.7}.ax-tree2-card .ax-tree2-node{border:1px solid rgba(var(--ax-sys-color-border-lightest-surface),1);margin:.5rem 0}.ax-tree2-card .ax-tree2-node-content{padding:1rem}.ax-tree2-with-lines .ax-tree2-children{position:relative;padding-left:var(--ax-tree-indent-size, var(--ax-comp-tree2-indent-size))}.ax-tree2-with-lines .ax-tree2-children:before{content:\"\";position:absolute;left:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));top:0;height:calc(100% - .875rem);width:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines .ax-tree2-node{position:relative}.ax-tree2-with-lines .ax-tree2-node:before{content:\"\";position:absolute;left:calc(-1 * var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2)));top:60%;width:var(--ax-tree-line-offset, calc(var(--ax-comp-tree2-indent-size) / 2));height:1px;background:var(--ax-tree-line-color, var(--ax-comp-tree2-line-color))}.ax-tree2-with-lines>.ax-tree2-drop-list>.ax-tree2-node:before,.ax-tree2-with-lines>.ax-tree2-node:before{display:none}\n"] }]
         
     | 
| 
      
 670 
     | 
    
         
            +
                    }], propDecorators: { nodes: [{ type: i0.Input, args: [{ isSignal: true, alias: "nodes", required: true }] }, { type: i0.Output, args: ["nodesChange"] }], showCheckbox: [{ type: i0.Input, args: [{ isSignal: true, alias: "showCheckbox", required: false }] }], dragMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "dragMode", required: false }] }], dragOperationType: [{ type: i0.Input, args: [{ isSignal: true, alias: "dragOperationType", required: false }] }], showIcons: [{ type: i0.Input, args: [{ isSignal: true, alias: "showIcons", required: false }] }], showChildrenBadge: [{ type: i0.Input, args: [{ isSignal: true, alias: "showChildrenBadge", required: false }] }], expandedIcon: [{ type: i0.Input, args: [{ isSignal: true, alias: "expandedIcon", required: false }] }], collapsedIcon: [{ type: i0.Input, args: [{ isSignal: true, alias: "collapsedIcon", required: false }] }], indentSize: [{ type: i0.Input, args: [{ isSignal: true, alias: "indentSize", required: false }] }], nodeHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "nodeHeight", required: false }] }], look: [{ type: i0.Input, args: [{ isSignal: true, alias: "look", required: false }] }], itemTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "itemTemplate", required: false }] }], lazyLoad: [{ type: i0.Input, args: [{ isSignal: true, alias: "lazyLoad", required: false }] }], enableLazyLoad: [{ type: i0.Input, args: [{ isSignal: true, alias: "enableLazyLoad", required: false }] }], onBeforeDrop: [{ type: i0.Output, args: ["onBeforeDrop"] }], onNodeToggle: [{ type: i0.Output, args: ["onNodeToggle"] }], onNodeSelect: [{ type: i0.Output, args: ["onNodeSelect"] }], onOrderChange: [{ type: i0.Output, args: ["onOrderChange"] }], onMoveChange: [{ type: i0.Output, args: ["onMoveChange"] }], onItemsChange: [{ type: i0.Output, args: ["onItemsChange"] }] } });
         
     | 
| 
       578 
671 
     | 
    
         | 
| 
       579 
672 
     | 
    
         
             
            class Tree2Module {
         
     | 
| 
       580 
673 
     | 
    
         
             
                static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: Tree2Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
         
     | 
| 
       581 
     | 
    
         
            -
                static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.6", ngImport: i0, type: Tree2Module, imports: [ 
     | 
| 
       582 
     | 
    
         
            -
                static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: Tree2Module, imports: [ 
     | 
| 
      
 674 
     | 
    
         
            +
                static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.6", ngImport: i0, type: Tree2Module, imports: [AXTree2Component] }); }
         
     | 
| 
      
 675 
     | 
    
         
            +
                static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: Tree2Module, imports: [AXTree2Component] }); }
         
     | 
| 
       583 
676 
     | 
    
         
             
            }
         
     | 
| 
       584 
677 
     | 
    
         
             
            i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: Tree2Module, decorators: [{
         
     | 
| 
       585 
678 
     | 
    
         
             
                        type: NgModule,
         
     | 
| 
       586 
679 
     | 
    
         
             
                        args: [{
         
     | 
| 
       587 
     | 
    
         
            -
                                imports: [ 
     | 
| 
      
 680 
     | 
    
         
            +
                                imports: [AXTree2Component],
         
     | 
| 
       588 
681 
     | 
    
         
             
                            }]
         
     | 
| 
       589 
682 
     | 
    
         
             
                    }] });
         
     | 
| 
       590 
683 
     | 
    
         |