@acorex/platform 20.7.8 → 20.7.9

package/fesm2022/acorex-platform-layout-entity.mjs

@@ -1,15 +1,14 @@
 import { AXToastService } from '@acorex/components/toast';
-import { AXPlatform } from '@acorex/core/platform';
 import * as i6 from '@acorex/core/translation';
 import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
-import * as i4$1 from '@acorex/platform/common';
-import { AXPSettingsService, AXPFilterOperatorMiddlewareService, AXPEntityCommandScope, getEntityInfo, AXPRefreshEvent, AXPReloadEvent, AXPCommonSettings, AXPEntityQueryType, AXPCleanNestedFilters, AXPWorkflowNavigateAction, AXPToastAction, AXP_SEARCH_DEFINITION_PROVIDER } from '@acorex/platform/common';
-import { AXPDeviceService, AXPBroadcastEventService, applyFilterArray, applySortArray, resolveActionLook, AXPExpressionEvaluatorService, AXPDistributedEventListenerService, AXPPlatformScope, AXPColumnWidthService, AXHighlightService, extractValue, setSmart, getChangedPaths, defaultColumnWidthProvider, AXP_COLUMN_WIDTH_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXPSystemActionType } from '@acorex/platform/core';
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injector, runInInjectionContext, Injectable, input, viewChild, signal, ElementRef, ChangeDetectionStrategy, Component, ApplicationRef, EnvironmentInjector, createComponent, computed, ChangeDetectorRef, effect, Input, afterNextRender, untracked, ViewEncapsulation, viewChildren, linkedSignal, HostBinding, output, NgModule } from '@angular/core';
 import { Subject, takeUntil } from 'rxjs';
 import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
+import { AXPDeviceService, AXPBroadcastEventService, applyFilterArray, applySortArray, resolveActionLook, AXPExpressionEvaluatorService, AXPDistributedEventListenerService, AXPPlatformScope, AXPColumnWidthService, AXHighlightService, extractValue, setSmart, getChangedPaths, defaultColumnWidthProvider, AXP_COLUMN_WIDTH_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXPSystemActionType } from '@acorex/platform/core';
 import { merge, castArray, get, cloneDeep, set, orderBy, isNil, isEmpty, isEqual } from 'lodash-es';
+import * as i4$1 from '@acorex/platform/common';
+import { AXPSettingsService, AXPFilterOperatorMiddlewareService, AXPEntityCommandScope, getEntityInfo, AXPRefreshEvent, AXPReloadEvent, AXPCommonSettings, AXPEntityQueryType, AXPCleanNestedFilters, AXPWorkflowNavigateAction, AXPToastAction, AXP_SEARCH_DEFINITION_PROVIDER } from '@acorex/platform/common';
 import { AXPSessionService, AXPAuthGuard } from '@acorex/platform/auth';
 import { Router, RouterModule, ROUTES } from '@angular/router';
 import * as i3 from '@acorex/components/button';
@@ -32,6 +31,7 @@ import { moveItemInArray } from '@angular/cdk/drag-drop';
 import { AXDialogService } from '@acorex/components/dialog';
 import { AXLoadingDialogService } from '@acorex/components/loading-dialog';
 import { AXPopupService } from '@acorex/components/popup';
+import { AXPlatform } from '@acorex/core/platform';
 import * as i2$1 from '@acorex/components/badge';
 import { AXBadgeModule } from '@acorex/components/badge';
 import { AXCheckBoxModule } from '@acorex/components/check-box';
@@ -728,6 +728,10 @@ class PropertyFilter {
         this.externalActionsDelegate = delegate;
         return this;
     }
+    onAction(handler) {
+        this.onActionHandler = handler;
+        return this;
+    }
     field(groupId, path, delegate) {
         const list = this.extraFieldsByGroup.get(groupId) ?? [];
         list.push({ path, delegate });
@@ -1042,6 +1046,9 @@ class PropertyFilter {
                 // For create/update, show cancel + submit
                 d.setActions((a) => a.cancel().submit());
             }
+            if (this.onActionHandler) {
+                d.onAction(this.onActionHandler);
+            }
         });
         return dialog;
     }
@@ -1376,12 +1383,9 @@ function sortMergedSections(mainSections, extraSections, mainSectionIds) {
 class AXPCreateEntityCommand {
     constructor() {
         this.entityForm = inject(AXPEntityFormBuilderService);
-        this.settingsService = inject(AXPSettingsService);
         this.entityService = inject(AXPEntityDefinitionRegistryService);
         this.toastService = inject(AXToastService);
         this.translationService = inject(AXTranslationService);
-        this.eventService = inject(AXPBroadcastEventService);
-        this.platform = inject(AXPlatform);
         this.context = {};
     }
     async execute(input) {
@@ -1404,100 +1408,83 @@ class AXPCreateEntityCommand {
             };
         }
         const entityRef = await this.entityService.resolve(moduleName, entityName);
-        let dialogRef;
-        try {
-            let chain = this.entityForm.entity(`${moduleName}.${entityName}`).create(data);
-            chain.actions((actions) => {
-                actions.cancel('@general:actions.cancel.title');
-                actions.submit('@general:actions.create.title');
-            });
-            if (excludeProperties && excludeProperties.length > 0) {
-                chain = chain.exclude(...excludeProperties);
-            }
-            if (includeProperties && includeProperties.length > 0) {
-                chain = chain.include(...includeProperties);
-            }
-            // Set dialog title: use decoration.header.title if available, otherwise use entityInfo.title
-            if (headerTitle) {
-                chain = chain.title(headerTitle);
-            }
-            else if (entityInfo?.title) {
-                const createText = await this.translationService.translateAsync('@general:actions.create.title');
-                const translatedTitle = await this.translationService.translateAsync(entityInfo.title);
-                chain = chain.title(`${createText} ${translatedTitle}`);
-            }
-            // Set dialog size: prioritize layout.size, then dialogSize from input, with platform-aware defaults
-            const finalSize = layoutSize || dialogSize;
-            if (this.platform.is('Mobile') || this.platform.is('SM')) {
-                chain.size('full');
-            }
-            else if (finalSize) {
-                chain.size(finalSize);
-            }
-            else {
-                chain.size('md');
-            }
-            dialogRef = await chain.show();
-            if (dialogRef.action() == 'cancel') {
-                dialogRef.close();
-                return {
-                    success: false,
-                };
+        let chain = this.entityForm.entity(`${moduleName}.${entityName}`).create(data);
+        chain.actions((actions) => {
+            actions.cancel('@general:actions.cancel.title');
+            actions.submit('@general:actions.create.title');
+        });
+        if (excludeProperties && excludeProperties.length > 0) {
+            chain = chain.exclude(...excludeProperties);
+        }
+        if (includeProperties && includeProperties.length > 0) {
+            chain = chain.include(...includeProperties);
+        }
+        // Set dialog title: use decoration.header.title if available, otherwise use entityInfo.title
+        if (headerTitle) {
+            chain = chain.title(headerTitle);
+        }
+        else if (entityInfo?.title) {
+            const createText = await this.translationService.translateAsync('@general:actions.create.title');
+            const translatedTitle = await this.translationService.translateAsync(entityInfo.title);
+            chain = chain.title(`${createText} ${translatedTitle}`);
+        }
+        // Set dialog size: prioritize layout.size, then dialogSize from input
+        const finalSize = layoutSize || dialogSize;
+        if (finalSize) {
+            chain.size(finalSize);
+        }
+        const result = await chain
+            .onAction(async (dialogRef) => {
+            if (dialogRef.action() === 'cancel') {
+                return { success: false };
+            }
+            const createFn = entityRef.commands?.create?.execute;
+            if (!createFn) {
+                const msg = await this.translationService.translateAsync('@general:messages.entity.create-command-unavailable');
+                this.toastService.show({
+                    color: 'danger',
+                    title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
+                    content: msg,
+                });
+                throw new Error(msg);
             }
-            else if (dialogRef.action() == 'submit') {
-                dialogRef.setLoading(true);
+            dialogRef.setLoading(true);
+            try {
                 const context = dialogRef.context();
-                const createFn = entityRef.commands?.create?.execute;
-                if (!createFn) {
-                    return {
-                        success: false,
-                        message: {
-                            text: await this.translationService.translateAsync('@general:messages.entity.create-command-unavailable'),
-                        },
-                    };
-                }
                 const result = await createFn(context);
                 if (result) {
-                    dialogRef.close();
                     return {
                         success: true,
-                        data: result,
+                        data: result.data ?? result,
                         message: {
                             text: await this.translationService.translateAsync('@general:messages.generic.success.description'),
                         },
                     };
                 }
                 else {
-                    return (result ?? {
+                    return {
                         success: false,
                         message: {
-                            text: await this.translationService.translateAsync('@general:messages.entity.command-no-result'),
+                            text: await this.translationService.translateAsync('@general:messages.entity.create-failed'),
                         },
-                    });
+                    };
                 }
             }
-            return {
-                success: false,
-                message: {
-                    text: await this.translationService.translateAsync('@general:messages.entity.invalid-action'),
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: {
-                    text: error instanceof Error
-                        ? error.message
-                        : await this.translationService.translateAsync('@general:messages.entity.create-failed'),
-                },
-            };
-        }
-        finally {
-            if (dialogRef) {
+            catch (e) {
+                const errorMsg = e.message ?? (await this.translationService.translateAsync('@general:messages.entity.create-failed'));
+                this.toastService.show({
+                    color: 'danger',
+                    title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
+                    content: errorMsg,
+                });
+                throw e;
+            }
+            finally {
                 dialogRef.setLoading(false);
             }
-        }
+        })
+            .show();
+        return result;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPCreateEntityCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPCreateEntityCommand, providedIn: 'root' }); }
@@ -6640,11 +6627,22 @@ class AXPCategoryTreeService {
     convertToTreeNode(item, config) {
         const textField = config.textField ?? 'title';
         const valueField = config.valueField ?? 'id';
+        // Determine childrenCount properly:
+        // - Use explicit childrenCount from backend if it's a number (including 0)
+        // - Or use children array length if available
+        // - Default to undefined to indicate "unknown" - this allows lazy loading to work
+        let childrenCount;
+        if (typeof item['childrenCount'] === 'number') {
+            childrenCount = item['childrenCount'];
+        }
+        else if (Array.isArray(item['children'])) {
+            childrenCount = item['children'].length;
+        }
         return {
             id: String(item[valueField] ?? ''),
             title: String(item[textField] ?? ''),
             icon: 'fa-solid fa-folder',
-            childrenCount: item['childrenCount'] || item['children']?.length || 0,
+            childrenCount,
             expanded: false,
             data: item,
         };
@@ -6800,7 +6798,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         this.relevantNodeIds = new Set(); // For search filtering
         this.expandedNodesBeforeSearch = []; // Store expanded nodes before search to restore after
         this.nodesExpandedDuringSearch = []; // Track nodes we expanded during search
-        this.isInitializing = false; // Flag to track if we're in initialization phase
         /** Datasource callback for tree-view component. */
         this.datasource = async (id) => {
             if (!this.treeData || !this.treeConfig) {
@@ -6847,31 +6844,48 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                     }
                 });
             }
-            // Mark pre-selected leaf nodes as selected in the child nodes
-            const selectedIds = this.selectedNodeIds();
-            childNodes.forEach((node) => {
-                const nodeId = String(node['id'] ?? '');
-                if (nodeId && selectedIds.includes(nodeId)) {
-                    node['selected'] = true;
-                }
-            });
-            // After children load, programmatically select pre-selected nodes in tree component
-            const treeComponent = this.tree();
-            if (treeComponent && selectedIds.length > 0) {
-                // Use setTimeout to ensure nodes are in tree structure before selecting
-                setTimeout(() => {
-                    childNodes.forEach((node) => {
-                        const nodeId = String(node['id'] ?? '');
-                        if (nodeId && selectedIds.includes(nodeId) && nodeId !== 'all') {
-                            try {
-                                treeComponent.selectNode(nodeId);
-                            }
-                            catch {
-                                // Node might not be in tree yet
-                            }
+            // Mark pre-selected nodes as selected in the child nodes (for visual display)
+            // ONLY do this during initial load, NOT during user selection changes
+            if (!this.isUpdatingSelection) {
+                const selectedIds = this.selectedNodeIds();
+                childNodes.forEach((node) => {
+                    const nodeId = String(node['id'] ?? '');
+                    if (nodeId && selectedIds.includes(nodeId)) {
+                        node['selected'] = true;
+                    }
+                });
+                // After children load, programmatically select pre-selected nodes in tree component
+                // This ensures the tree's internal state matches our selectedNodeIds
+                // Skip this if we're in the middle of a selection update (user is selecting/deselecting)
+                const treeComponent = this.tree();
+                if (treeComponent && selectedIds.length > 0) {
+                    // Use setTimeout to ensure nodes are in tree structure before selecting
+                    setTimeout(() => {
+                        // Double-check we're not in a selection update when timeout fires
+                        if (this.isUpdatingSelection) {
+                            return;
                         }
-                    });
-                }, 10);
+                        this.isUpdatingSelection = true;
+                        try {
+                            // Re-check selectedNodeIds at this point (might have changed)
+                            const currentSelectedIds = this.selectedNodeIds();
+                            childNodes.forEach((node) => {
+                                const nodeId = String(node['id'] ?? '');
+                                if (nodeId && currentSelectedIds.includes(nodeId) && nodeId !== 'all') {
+                                    try {
+                                        treeComponent.selectNode(nodeId);
+                                    }
+                                    catch {
+                                        // Node might not be in tree yet
+                                    }
+                                }
+                            });
+                        }
+                        finally {
+                            this.isUpdatingSelection = false;
+                        }
+                    }, 10);
+                }
             }
             return childNodes;
         };
@@ -6890,7 +6904,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             return;
         }
         this.loading.set(true);
-        this.isInitializing = true; // Mark that we're in initialization phase
         try {
             this.treeConfig = {
                 entityKey: this.entityKey(),
@@ -6900,7 +6913,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             this.treeData = await this.categoryTreeService.initializeCategoryTree(this.treeConfig);
             if (!this.treeData) {
                 this.loading.set(false);
-                this.isInitializing = false;
                 return;
             }
             // Get parentKey from entity definition
@@ -6946,7 +6958,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                 console.error('Error syncing selection after tree render:', error);
             }
         }
-        this.isInitializing = false; // Mark initialization as complete
     }
     //#endregion
     //#region ----   Public Methods   ----
@@ -7368,6 +7379,8 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             this.nodesExpandedDuringSearch = [];
             return;
         }
+        // Store current selected IDs before reload
+        const selectedIds = this.selectedNodeIds();
         // Reload tree to show all nodes (no filtering)
         await treeComponent.reloadData();
         // Collapse nodes that were expanded during search (in reverse order - leaves first)
@@ -7386,88 +7399,136 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         }
         // Clear the stored expanded nodes
         this.expandedNodesBeforeSearch = [];
+        // Restore selection state after tree reload
+        if (selectedIds.length > 0) {
+            // Wait for tree to stabilize after reload
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            // Re-sync selection with tree
+            await this.restoreSelectionAfterReload(selectedIds);
+        }
     }
-    async onNodeToggle(event) {
-        // Tree component handles lazy loading via datasource callback
+    /**
+     * Restores selection state after tree reload.
+     * Expands ancestor nodes and selects the previously selected leaf nodes.
+     */
+    async restoreSelectionAfterReload(selectedIds) {
+        const treeComponent = this.tree();
+        if (!treeComponent || selectedIds.length === 0) {
+            return;
+        }
+        this.isUpdatingSelection = true;
+        try {
+            // Build ancestor chains for selected nodes
+            const ancestorChains = await this.buildAncestorChains(selectedIds);
+            // Expand ancestor nodes to make selected nodes visible
+            await this.expandAncestorNodesInOrder(ancestorChains);
+            // Wait for tree to render expanded nodes
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            // Select the nodes visually in the tree
+            for (const id of selectedIds) {
+                try {
+                    treeComponent.selectNode(id);
+                }
+                catch {
+                    // Node might not be in tree yet
+                }
+            }
+        }
+        finally {
+            this.isUpdatingSelection = false;
+        }
     }
     async onNodeSelect(event) {
         const node = event.node;
         const nodeId = String(node['id'] ?? '');
-        if (!node || nodeId === 'all') {
+        if (!node) {
             return;
         }
-        // Cache node data for getSelectedItems
-        const nodeData = node['data'];
-        if (nodeData && typeof nodeData === 'object' && nodeData !== null && !Array.isArray(nodeData)) {
-            this.nodeDataCache.set(nodeId, nodeData);
+        // Only process USER interactions, not programmatic selections
+        // This prevents infinite loops when datasource callback syncs selection
+        if (!event.isUserInteraction) {
+            return;
         }
-        // NOTE: We do NOT call loadAndSelectChildrenRecursively here
-        // The recursive selection should only happen when user explicitly selects a node via checkbox
-        // (handled in handleCheckboxChange). This prevents intermediate parent states from
-        // triggering unwanted sibling selections.
-    }
-    async onSelectionChange(event) {
-        // Don't process during initialization or batch updates - let those handle it
-        if (this.isInitializing || this.isUpdatingSelection) {
+        // Don't process if we're already updating selection
+        if (this.isUpdatingSelection) {
             return;
         }
-        // The tree component fires selection changes, but we only want to track LEAF nodes
-        // Parent nodes are auto-selected/deselected by the tree's intermediate-nested behavior
-        const selectedNodes = event.selectedNodes || [];
-        // Cache node data for all selected nodes first
-        selectedNodes.forEach((node) => {
-            const nodeId = String(node['id'] ?? '');
+        // Cache node data for getSelectedItems (except for 'all' node)
+        if (nodeId !== 'all') {
             const nodeData = node['data'];
-            if (nodeData && nodeId && typeof nodeData === 'object') {
+            if (nodeData && typeof nodeData === 'object' && nodeData !== null && !Array.isArray(nodeData)) {
                 this.nodeDataCache.set(nodeId, nodeData);
             }
-        });
-        // Filter to only leaf nodes (nodes with no children or childrenCount === 0)
-        const leafNodeIds = [];
-        for (const node of selectedNodes) {
-            const nodeId = String(node['id'] ?? '');
-            if (!nodeId || nodeId === 'all') {
-                continue;
-            }
-            // Check if this is a leaf node
+        }
+        // Check if this node is being selected or deselected
+        const isSelected = node['selected'] === true;
+        if (this.allowMultiple()) {
             const children = node['children'];
             const childrenCount = node['childrenCount'];
-            const isLeaf = (!children || children.length === 0) && (childrenCount === undefined || childrenCount === 0);
-            if (isLeaf) {
-                leafNodeIds.push(nodeId);
-            }
-        }
-        // Update selectedNodeIds with only leaf nodes
-        this.selectedNodeIds.set(leafNodeIds);
-    }
-    // protected handleNodeClick(event: any): void {
-    //   // Extract node from event - could be { node: AXTreeNode } or just AXTreeNode
-    //   const node: AXTreeViewNode = event?.node || event;
-    //   if (!node || node.id === 'all') {
-    //     return;
-    //   }
-    //   // Cache node data for getSelectedItems
-    //   if (node.data) {
-    //     this.nodeDataCache.set(node.id, node.data);
-    //   }
-    //   if (this.allowMultiple()) {
-    //     // In multiple mode with checkboxes, clicking the node should toggle the checkbox
-    //     // The checkbox state is handled by onNodeSelect event, so we just sync the selection here
-    //     const currentIds = this.selectedNodeIds();
-    //     const isSelected = currentIds.includes(node.id);
-    //     // Toggle selection state
-    //     // Note: The actual checkbox toggle is handled by the tree component's onNodeSelect event
-    //     if (isSelected) {
-    //       this.selectedNodeIds.set(currentIds.filter((id) => id !== node.id));
-    //     } else {
-    //       this.selectedNodeIds.set([...currentIds, node.id]);
-    //     }
-    //   } else {
-    //     // Single selection - auto-confirm on click
-    //     this.selectedNodeIds.set([node.id]);
-    //     this.close({ selected: this.getSelectedItems() });
-    //   }
-    // }
+            // Determine if this node has children (is a parent node)
+            // A node has children if: childrenCount > 0, or has non-empty children array
+            // Note: childrenCount === undefined means "unknown" - we need to check via datasource
+            const hasLoadedChildren = children && children.length > 0;
+            const hasChildrenCount = childrenCount !== undefined && childrenCount > 0;
+            const isDefinitelyLeaf = childrenCount === 0 && (!children || children.length === 0);
+            if (isSelected) {
+                // SELECTION: Only add LEAF nodes to selectedNodeIds
+                this.isUpdatingSelection = true;
+                try {
+                    if (nodeId === 'all') {
+                        // "All Items" selected - recursively select all leaf descendants
+                        await this.selectAllLeafDescendants(nodeId);
+                    }
+                    else if (isDefinitelyLeaf) {
+                        // This is definitely a leaf node - add it directly
+                        const currentSelected = new Set(this.selectedNodeIds());
+                        currentSelected.add(nodeId);
+                        this.selectedNodeIds.set(Array.from(currentSelected));
+                    }
+                    else if (hasLoadedChildren || hasChildrenCount) {
+                        // This node has children - only add its leaf descendants
+                        await this.selectAllLeafDescendants(nodeId);
+                    }
+                    else {
+                        // childrenCount is undefined - need to check if it has children
+                        const childNodes = await this.datasource(nodeId);
+                        if (!childNodes || childNodes.length === 0) {
+                            // No children - this is a leaf node, add it
+                            const currentSelected = new Set(this.selectedNodeIds());
+                            currentSelected.add(nodeId);
+                            this.selectedNodeIds.set(Array.from(currentSelected));
+                        }
+                        else {
+                            // Has children - only add leaf descendants
+                            await this.selectAllLeafDescendants(nodeId);
+                        }
+                    }
+                }
+                finally {
+                    this.isUpdatingSelection = false;
+                }
+            }
+            else {
+                // DESELECTION: Remove node (if leaf) and all leaf descendants from selectedNodeIds
+                this.isUpdatingSelection = true;
+                try {
+                    await this.deselectAllLeafDescendants(nodeId);
+                }
+                finally {
+                    this.isUpdatingSelection = false;
+                }
+            }
+        }
+        else {
+            // Single selection mode: just update selectedNodeIds
+            if (isSelected) {
+                this.selectedNodeIds.set([nodeId]);
+            }
+            else {
+                this.selectedNodeIds.set([]);
+            }
+        }
+    }
     async onConfirm() {
         // Use internal selectedNodeIds state which is kept in sync via onNodeSelect events
         const selectedItems = await this.getSelectedItems();
@@ -7480,21 +7541,11 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
      * Clears all selected items
      */
     onClearAll() {
+        this.selectedNodeIds.set([]);
         const treeComponent = this.tree();
         if (treeComponent) {
-            // Deselect all nodes in tree component
-            const currentSelected = this.selectedNodeIds();
-            for (const id of currentSelected) {
-                try {
-                    treeComponent.deselectNode(id);
-                }
-                catch {
-                    // Node might not be in tree
-                }
-            }
+            treeComponent.deselectAll();
         }
-        // Clear the selection
-        this.selectedNodeIds.set([]);
     }
     /**
      * Checks if a node matches the current search term
@@ -7513,543 +7564,207 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         return this.selectedNodeIds().includes(id);
     }
     /**
-     * Handles checkbox change event to toggle node selection
-     * In multiple mode: recursively selects/deselects LEAF children only
-     * Parent states are calculated based on leaf descendants
+     * Expands parent nodes, collects all LEAF descendants, and selects them visually.
+     * If the parent itself is a leaf (no children), it will be added.
      */
-    async handleCheckboxChange(nodeId, checked) {
-        if (!nodeId || nodeId === 'all') {
+    async selectAllLeafDescendants(parentId) {
+        if (!this.treeData || !this.treeConfig) {
             return;
         }
-        const id = String(nodeId);
         const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        if (checked) {
-            // Select all descendant LEAF nodes
-            await this.selectLeafDescendants(id);
-        }
-        else {
-            // Deselect all descendant LEAF nodes
-            await this.deselectLeafDescendants(id);
-        }
-        // Update parent states after selection change
-        await this.refreshParentStatesInTree();
-    }
-    /**
-     * Selects all leaf descendants of a node (and the node itself if it's a leaf)
-     */
-    async selectLeafDescendants(nodeId) {
-        this.isUpdatingSelection = true;
         try {
-            // Collect all leaf descendants
-            const leafNodes = new Set();
-            await this.collectLeafDescendants(nodeId, leafNodes);
-            if (leafNodes.size === 0) {
-                // Node itself is a leaf
-                leafNodes.add(nodeId);
-            }
-            // Update selectedNodeIds with leaf nodes only
-            const currentSelected = new Set(this.selectedNodeIds());
-            leafNodes.forEach((id) => currentSelected.add(id));
-            this.selectedNodeIds.set(Array.from(currentSelected));
-            // Sync with tree component
-            const treeComponent = this.tree();
-            if (treeComponent) {
-                for (const leafId of leafNodes) {
-                    try {
-                        const node = treeComponent.findNode(leafId);
-                        if (node) {
-                            treeComponent.selectNode(leafId);
-                        }
-                    }
-                    catch {
-                        // Node might not be in tree
-                    }
+            const leafIds = new Set();
+            // Expand and collect leaf nodes simultaneously
+            await this.collectLeafNodes(parentId, leafIds, treeComponent);
+            // Also check if the parent itself is a leaf (has no children)
+            if (parentId !== 'all') {
+                const isLeaf = await this.isLeafNodeCheck(parentId);
+                if (isLeaf) {
+                    leafIds.add(parentId);
                 }
             }
-        }
-        finally {
-            this.isUpdatingSelection = false;
-        }
-    }
-    /**
-     * Deselects all leaf descendants of a node (and the node itself if it's a leaf)
-     */
-    async deselectLeafDescendants(nodeId) {
-        this.isUpdatingSelection = true;
-        try {
-            // Collect all leaf descendants
-            const leafNodes = new Set();
-            await this.collectLeafDescendants(nodeId, leafNodes);
-            if (leafNodes.size === 0) {
-                // Node itself is a leaf
-                leafNodes.add(nodeId);
-            }
-            // Remove leaf nodes from selectedNodeIds
-            const currentSelected = this.selectedNodeIds();
-            const newSelected = currentSelected.filter((id) => !leafNodes.has(id));
-            this.selectedNodeIds.set(newSelected);
-            // Sync with tree component
-            const treeComponent = this.tree();
+            if (leafIds.size === 0) {
+                return;
+            }
+            // Update our internal state
+            const currentSelected = new Set(this.selectedNodeIds());
+            for (const leafId of leafIds) {
+                currentSelected.add(leafId);
+            }
+            this.selectedNodeIds.set(Array.from(currentSelected));
+            // Select all leaf nodes visually in the tree
             if (treeComponent) {
-                for (const leafId of leafNodes) {
+                for (const leafId of leafIds) {
                     try {
-                        const node = treeComponent.findNode(leafId);
-                        if (node) {
-                            treeComponent.deselectNode(leafId);
-                        }
+                        treeComponent.selectNode(leafId);
                     }
                     catch {
-                        // Node might not be in tree
+                        // Node might not be in tree yet
                     }
                 }
             }
         }
-        finally {
-            this.isUpdatingSelection = false;
+        catch (error) {
+            console.error(`Error selecting leaf descendants for node ${parentId}:`, error);
         }
     }
     /**
-     * Collects all LEAF descendant node IDs recursively
-     * A leaf node is one that has no children
+     * Removes all LEAF descendants from selectedNodeIds.
+     * For 'all' node: clears everything and uses tree's deselectAll().
+     * For other nodes: tree handles visual state via user click.
      */
-    async collectLeafDescendants(parentId, collection) {
-        if (!this.treeData || !this.treeConfig || !parentId || parentId === 'all') {
+    async deselectAllLeafDescendants(parentId) {
+        if (!this.treeData || !this.treeConfig) {
             return;
         }
         try {
-            const childNodes = await this.datasource(parentId);
-            if (!childNodes || childNodes.length === 0) {
-                // No children means this node is a leaf - add the parent itself
-                // But only if it wasn't already added through the parent call
+            // Special case: deselecting 'all' clears everything
+            if (parentId === 'all') {
+                this.selectedNodeIds.set([]);
+                // Use tree's deselectAll() to clear all visual selections
+                const treeComponent = this.tree();
+                if (treeComponent) {
+                    treeComponent.deselectAll();
+                }
                 return;
             }
-            for (const childNode of childNodes) {
-                const childId = String(childNode['id'] ?? '');
-                if (!childId || childId === 'all') {
-                    continue;
-                }
-                // Cache node data
-                const nodeData = childNode['data'];
-                if (nodeData && typeof nodeData === 'object') {
-                    this.nodeDataCache.set(childId, nodeData);
-                }
-                // Check if this child is a leaf by trying to load its children
-                const grandchildNodes = await this.datasource(childId);
-                if (!grandchildNodes || grandchildNodes.length === 0) {
-                    // This child is a leaf node
-                    collection.add(childId);
-                }
-                else {
-                    // This child has children, recurse
-                    await this.collectLeafDescendants(childId, collection);
-                }
+            const leafIds = new Set();
+            await this.collectLeafNodes(parentId, leafIds);
+            // Also check if the parent itself is a leaf
+            const isLeaf = await this.isLeafNodeCheck(parentId);
+            if (isLeaf) {
+                leafIds.add(parentId);
             }
-        }
-        catch (error) {
-            console.error(`Error collecting leaf descendants for node ${parentId}:`, error);
-        }
-    }
-    /**
-     * Refreshes parent states in the tree based on leaf selection
-     */
-    async refreshParentStatesInTree() {
-        const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        // The tree component with intermediate-nested behavior should handle this
-        // But we need to force a refresh by reloading data
-        // For now, we rely on the tree component's built-in behavior
-    }
-    /**
-     * Selects a node and recursively selects all its children
-     */
-    async selectNodeAndChildren(nodeId) {
-        const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        // Set flag to prevent recursive updates during batch operation
-        this.isUpdatingSelection = true;
-        try {
-            // Collect all nodes to select (node + all descendants)
-            const nodesToSelect = new Set([nodeId]);
-            await this.collectAllDescendants(nodeId, nodesToSelect);
-            // Batch update selectedNodeIds
-            const currentSelected = this.selectedNodeIds();
-            const newSelected = [...currentSelected];
-            for (const id of nodesToSelect) {
-                if (!newSelected.includes(id)) {
-                    newSelected.push(id);
-                }
+            if (leafIds.size === 0) {
+                return;
             }
+            // Only update our internal state - tree handles visual state
+            const currentSelected = this.selectedNodeIds();
+            const newSelected = currentSelected.filter((id) => !leafIds.has(id));
             this.selectedNodeIds.set(newSelected);
-            // Batch select in tree component (with small delays to prevent glitches)
-            for (const id of nodesToSelect) {
-                try {
-                    const node = treeComponent.findNode(id);
-                    if (node) {
-                        treeComponent.selectNode(id);
-                        // Small delay to prevent overwhelming the tree component
-                        await new Promise((resolve) => setTimeout(resolve, 5));
-                    }
-                }
-                catch {
-                    // Node might not be in tree yet
-                }
-            }
         }
-        finally {
-            this.isUpdatingSelection = false;
+        catch (error) {
+            console.error(`Error deselecting leaf descendants for node ${parentId}:`, error);
         }
     }
     /**
-     * Collects all descendant node IDs recursively
+     * Recursively expands parent nodes and collects LEAF node IDs.
+     * When treeComponent is provided, expands each parent node before loading children.
      */
-    async collectAllDescendants(parentId, collection) {
-        if (!this.treeData || !this.treeConfig || !parentId || parentId === 'all') {
+    async collectLeafNodes(parentId, collection, treeComponent) {
+        if (!this.treeData || !this.treeConfig) {
             return;
         }
         try {
-            const childNodes = await this.datasource(parentId);
-            if (!childNodes || childNodes.length === 0) {
-                return;
-            }
-            for (const childNode of childNodes) {
-                const childId = String(childNode['id'] ?? '');
-                if (childId && childId !== 'all' && !collection.has(childId)) {
-                    collection.add(childId);
-                    // Cache node data
-                    const nodeData = childNode['data'];
-                    if (nodeData && typeof nodeData === 'object') {
-                        this.nodeDataCache.set(childId, nodeData);
+            let childNodes;
+            if (parentId === 'all') {
+                // Expand 'all' node if tree component provided
+                if (treeComponent) {
+                    try {
+                        treeComponent.expandNode('all');
                     }
-                    else if (childNode && typeof childNode === 'object') {
-                        const valueField = this.treeConfig.valueField || 'id';
-                        const textField = this.treeConfig.textField || 'title';
-                        const dataObj = {
-                            [valueField]: childId,
-                            [textField]: childNode['title'] ?? '',
-                            ...childNode,
-                        };
-                        this.nodeDataCache.set(childId, dataObj);
+                    catch {
+                        // Ignore expand errors
                     }
-                    // Recursively collect descendants
-                    await this.collectAllDescendants(childId, collection);
                 }
+                // Get root node's children
+                const rootNodes = await this.datasource();
+                if (!rootNodes || rootNodes.length === 0) {
+                    return;
+                }
+                const rootNode = rootNodes[0];
+                childNodes = rootNode['children'] || [];
             }
-        }
-        catch (error) {
-            console.error(`Error collecting descendants for node ${parentId}:`, error);
-        }
-    }
-    /**
-     * Deselects a node and recursively deselects all its children
-     */
-    async deselectNodeAndChildren(nodeId) {
-        const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        // Set flag to prevent recursive updates during batch operation
-        this.isUpdatingSelection = true;
-        try {
-            // Collect all nodes to deselect (node + all descendants)
-            const nodesToDeselect = new Set([nodeId]);
-            await this.collectAllDescendants(nodeId, nodesToDeselect);
-            // Batch update selectedNodeIds
-            const currentSelected = this.selectedNodeIds();
-            const newSelected = currentSelected.filter((id) => !nodesToDeselect.has(id));
-            this.selectedNodeIds.set(newSelected);
-            // Batch deselect in tree component (with small delays to prevent glitches)
-            for (const id of nodesToDeselect) {
-                try {
-                    const node = treeComponent.findNode(id);
-                    if (node) {
-                        treeComponent.deselectNode(id);
-                        // Small delay to prevent overwhelming the tree component
-                        await new Promise((resolve) => setTimeout(resolve, 5));
+            else {
+                // Expand this parent node if tree component provided
+                if (treeComponent) {
+                    try {
+                        treeComponent.expandNode(parentId);
+                    }
+                    catch {
+                        // Ignore expand errors
                     }
                 }
-                catch {
-                    // Node might not be in tree
-                }
+                // Load children via datasource
+                childNodes = await this.datasource(parentId);
             }
-        }
-        finally {
-            this.isUpdatingSelection = false;
-        }
-    }
-    /**
-     * Recursively deselects all children of a parent node
-     */
-    async loadAndDeselectChildrenRecursively(parentId) {
-        if (!this.treeData || !this.treeConfig || !parentId || parentId === 'all') {
-            return;
-        }
-        const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        try {
-            // Load children using datasource
-            const childNodes = await this.datasource(parentId);
             if (!childNodes || childNodes.length === 0) {
                 return;
             }
-            const childIdsToDeselect = [];
-            // Collect all child IDs
+            // Process each child
             for (const childNode of childNodes) {
                 const childId = String(childNode['id'] ?? '');
-                if (childId && childId !== 'all') {
-                    childIdsToDeselect.push(childId);
+                if (!childId || childId === 'all' || collection.has(childId)) {
+                    continue;
                 }
-            }
-            // Remove children from selectedNodeIds
-            const currentSelected = this.selectedNodeIds();
-            const updatedSelected = currentSelected.filter((id) => !childIdsToDeselect.includes(id));
-            this.selectedNodeIds.set(updatedSelected);
-            // Deselect in tree component
-            for (const childId of childIdsToDeselect) {
-                try {
-                    treeComponent.deselectNode(childId);
+                // Cache node data
+                this.cacheNodeFromTreeNode(childNode);
+                // Check if this child has children
+                const hasChildren = await this.nodeHasChildren(childId, childNode);
+                if (!hasChildren) {
+                    // This is a LEAF node - add it
+                    collection.add(childId);
                 }
-                catch {
-                    // Node might not be in tree
+                else {
+                    // Has children - expand and recurse (pass tree component to expand children too)
+                    await this.collectLeafNodes(childId, collection, treeComponent);
                 }
             }
-            // Recursively deselect children of each child
-            await Promise.all(childIdsToDeselect.map((childId) => this.loadAndDeselectChildrenRecursively(childId)));
         }
         catch (error) {
-            console.error(`Error deselecting children for node ${parentId}:`, error);
+            console.error(`Error collecting leaf nodes for ${parentId}:`, error);
         }
     }
     /**
-     * Updates parent states based on children selection (select/intermediate)
-     * Called after a node is selected/deselected to update parent checkbox states
+     * Checks if a node has children
      */
-    async updateParentStates(changedNodeId) {
-        if (!this.treeData || !this.treeConfig || !this.allowMultiple()) {
-            return;
-        }
-        const parentKey = this.treeData.categoryEntityDef?.parentKey;
-        if (!parentKey) {
-            return; // No parent key means flat structure
-        }
-        const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        // Start from the changed node's parent and work up the tree
-        const processedParents = new Set();
-        let currentId = changedNodeId;
-        // Process all parents up to root
-        while (currentId && currentId !== 'all') {
-            const nodeData = this.nodeDataCache.get(currentId);
-            if (!nodeData) {
-                break;
-            }
-            const parentId = nodeData[parentKey];
-            const parentIdStr = String(parentId);
-            if (!parentId || parentId === 'all' || parentId === currentId || processedParents.has(parentIdStr)) {
-                break;
+    async nodeHasChildren(nodeId, node) {
+        // First check node properties if available
+        if (node) {
+            const children = node['children'];
+            const childrenCount = node['childrenCount'];
+            if (children && children.length > 0) {
+                return true;
             }
-            processedParents.add(parentIdStr);
-            // Load all children of this parent
-            try {
-                const childNodes = await this.datasource(parentIdStr);
-                if (!childNodes || childNodes.length === 0) {
-                    currentId = parentIdStr;
-                    continue;
-                }
-                // Get current selection state (updated after each parent change)
-                const currentSelected = this.selectedNodeIds();
-                const selectedSet = new Set(currentSelected);
-                let selectedCount = 0;
-                let totalCount = 0;
-                // Count selected children
-                for (const childNode of childNodes) {
-                    const childId = String(childNode['id'] ?? '');
-                    if (childId && childId !== 'all') {
-                        totalCount++;
-                        if (selectedSet.has(childId)) {
-                            selectedCount++;
-                        }
-                    }
-                }
-                // Update parent selection state
-                const isParentSelected = currentSelected.includes(parentIdStr);
-                if (totalCount > 0) {
-                    if (selectedCount === totalCount) {
-                        // All children selected - select parent
-                        if (!isParentSelected) {
-                            this.selectedNodeIds.set([...currentSelected, parentIdStr]);
-                            try {
-                                treeComponent.selectNode(parentIdStr);
-                            }
-                            catch {
-                                // Parent might not be in tree
-                            }
-                        }
-                    }
-                    else if (selectedCount > 0) {
-                        // Some children selected - parent should be in intermediate state
-                        // The tree component handles intermediate state automatically via selectionBehavior
-                        // We just need to ensure parent is not fully selected
-                        if (isParentSelected) {
-                            // Deselect parent to show intermediate state
-                            this.selectedNodeIds.set(currentSelected.filter((id) => id !== parentIdStr));
-                            try {
-                                treeComponent.deselectNode(parentIdStr);
-                            }
-                            catch {
-                                // Parent might not be in tree
-                            }
-                        }
-                    }
-                    else {
-                        // No children selected - deselect parent
-                        if (isParentSelected) {
-                            this.selectedNodeIds.set(currentSelected.filter((id) => id !== parentIdStr));
-                            try {
-                                treeComponent.deselectNode(parentIdStr);
-                            }
-                            catch {
-                                // Parent might not be in tree
-                            }
-                        }
-                    }
-                }
-                // Cache parent data if not already cached
-                if (!this.nodeDataCache.has(parentIdStr)) {
-                    const parentData = await this.fetchItemById(parentIdStr);
-                    if (parentData) {
-                        this.nodeDataCache.set(parentIdStr, parentData);
-                    }
-                }
-                currentId = parentIdStr;
+            if (childrenCount !== undefined && childrenCount > 0) {
+                return true;
             }
-            catch (error) {
-                console.error(`Error updating parent state for ${parentIdStr}:`, error);
-                break;
+            if (childrenCount === 0) {
+                return false;
             }
         }
+        // Query datasource to check
+        const childNodes = await this.datasource(nodeId);
+        return childNodes && childNodes.length > 0;
     }
     /**
-     * Recursively loads and selects all children of a parent node using the datasource
-     * This method directly calls datasource without expanding/collapsing nodes to avoid UI glitches
+     * Checks if a node is a leaf (has no children)
      */
-    async loadAndSelectChildrenRecursively(parentId) {
-        if (!this.treeData || !this.treeConfig || !parentId || parentId === 'all') {
-            return;
-        }
-        const treeComponent = this.tree();
-        if (!treeComponent) {
-            return;
-        }
-        try {
-            // Directly call datasource to get children data without expanding the node
-            // This avoids UI glitches from expand/collapse operations
-            // If node has no children, datasource will return empty array
-            const childNodes = await this.datasource(parentId);
-            if (!childNodes || childNodes.length === 0) {
-                return; // No children to process
-            }
-            // Collect all child IDs to add to selectedNodeIds
-            const childIdsToSelect = [];
-            // Process all children and cache their data
-            for (const childNode of childNodes) {
-                const childId = String(childNode['id'] ?? '');
-                if (childId && childId !== 'all') {
-                    childIdsToSelect.push(childId);
-                    // Cache node data for getSelectedItems
-                    // Try to get data from 'data' property first, then fallback to node itself
-                    let nodeData = childNode['data'];
-                    // If no data property, try to extract data from the node
-                    if (!nodeData || typeof nodeData !== 'object') {
-                        // Create a data object from the node properties
-                        const valueField = this.treeConfig.valueField || 'id';
-                        const textField = this.treeConfig.textField || 'title';
-                        nodeData = {
-                            [valueField]: childId,
-                            [textField]: childNode['title'] ?? '',
-                            ...childNode,
-                        };
-                    }
-                    // Cache the node data
-                    if (nodeData && typeof nodeData === 'object') {
-                        this.nodeDataCache.set(childId, nodeData);
-                    }
-                }
-            }
-            if (childIdsToSelect.length === 0) {
-                return; // No valid children to select
-            }
-            // Update selectedNodeIds to include all children
-            const currentSelected = this.selectedNodeIds();
-            const newSelected = [...currentSelected];
-            let hasNewSelections = false;
-            for (const childId of childIdsToSelect) {
-                if (!newSelected.includes(childId)) {
-                    newSelected.push(childId);
-                    hasNewSelections = true;
-                }
-            }
-            if (hasNewSelections) {
-                this.selectedNodeIds.set(newSelected);
-            }
-            // Try to select children in tree component if they're already loaded
-            // If not loaded yet, they'll be selected when the tree loads them (via markNodeAsSelectedIfNeeded)
-            for (const childId of childIdsToSelect) {
-                try {
-                    // Only try to select if node exists in tree (might not be loaded if parent isn't expanded)
-                    const node = treeComponent.findNode(childId);
-                    if (node) {
-                        treeComponent.selectNode(childId);
-                    }
-                }
-                catch {
-                    // If selection fails, it's okay - we've already added to selectedNodeIds
-                    // The tree will sync selection when the node is loaded via datasource callback
-                }
-            }
-            // Recursively load and select children of each child
-            // Use Promise.all for parallel processing to improve performance
-            await Promise.all(childIdsToSelect.map((childId) => this.loadAndSelectChildrenRecursively(childId)));
-        }
-        catch (error) {
-            console.error(`Error loading children for node ${parentId}:`, error);
-        }
+    async isLeafNodeCheck(nodeId) {
+        const hasChildren = await this.nodeHasChildren(nodeId);
+        return !hasChildren;
     }
-    //#endregion
-    async updateSelectedNodes(selectedIds) {
-        if (!selectedIds || selectedIds.length === 0) {
-            this.selectedNodeIds.set([]);
+    /**
+     * Caches node data from a tree node
+     */
+    cacheNodeFromTreeNode(node) {
+        const nodeId = String(node['id'] ?? '');
+        if (!nodeId || !this.treeConfig) {
             return;
         }
-        const ids = selectedIds.filter((id) => id && id !== 'all');
-        // Set flag to prevent recursive updates during initialization
-        this.isUpdatingSelection = true;
-        try {
-            // Step 1: Fetch node data for pre-selected items that aren't in the cache
-            await this.loadMissingNodeData(ids);
-            // Step 2: Build complete ancestor chains for all selected nodes
-            const ancestorChains = await this.buildAncestorChains(ids);
-            // Step 3: Set selected node IDs (these should be leaf nodes only)
-            this.selectedNodeIds.set(ids);
-            // Step 4: Expand ancestor nodes in order (root to leaf) to load them into tree
-            await this.expandAncestorNodesInOrder(ancestorChains);
-            // Step 5: Wait for tree to render and sync selection
-            await this.syncSelectionWithTree(ids);
-        }
-        finally {
-            this.isUpdatingSelection = false;
+        let nodeData = node['data'];
+        if (!nodeData || typeof nodeData !== 'object') {
+            const valueField = this.treeConfig.valueField || 'id';
+            const textField = this.treeConfig.textField || 'title';
+            nodeData = {
+                [valueField]: nodeId,
+                [textField]: node['title'] ?? '',
+                ...node,
+            };
         }
+        this.nodeDataCache.set(nodeId, nodeData);
     }
+    //#endregion
     /**
      * Builds complete ancestor chains for all selected node IDs.
      * Returns a Map where key is the selected node ID and value is array of ancestor IDs from root to parent.
@@ -8430,42 +8145,38 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         const treeComponent = this.tree();
         if (treeComponent) {
             setTimeout(() => {
-                const selectedIds = this.selectedNodeIds();
-                selectedIds.forEach((id) => {
-                    if (id && id !== 'all') {
-                        treeComponent.selectNode(id);
-                    }
-                });
+                this.isUpdatingSelection = true;
+                try {
+                    const selectedIds = this.selectedNodeIds();
+                    selectedIds.forEach((id) => {
+                        if (id && id !== 'all') {
+                            try {
+                                treeComponent.selectNode(id);
+                            }
+                            catch {
+                                // Node might not be in tree yet
+                            }
+                        }
+                    });
+                }
+                finally {
+                    this.isUpdatingSelection = false;
+                }
             }, 0);
         }
     }
     /**
-     * Processes child nodes: marks excluded as disabled, marks selected, and syncs selection
+     * Processes child nodes: marks excluded as disabled
+     * Selection marking is handled in datasource callback ONLY during initial load
      */
     processChildNodes(childNodes) {
         const excludedId = this.excludedNodeId();
-        const selectedIds = this.selectedNodeIds();
         childNodes.forEach((node) => {
             const nodeId = String(node['id'] ?? '');
             if (excludedId && nodeId === excludedId) {
                 node['disabled'] = true;
             }
-            if (nodeId && selectedIds.includes(nodeId)) {
-                node['selected'] = true;
-            }
         });
-        // Sync selection with tree component
-        const treeComponent = this.tree();
-        if (treeComponent) {
-            setTimeout(() => {
-                childNodes.forEach((node) => {
-                    const nodeId = String(node['id'] ?? '');
-                    if (nodeId && selectedIds.includes(nodeId) && nodeId !== 'all') {
-                        treeComponent.selectNode(nodeId);
-                    }
-                });
-            }, 0);
-        }
     }
     /**
      * Caches node data from items array
@@ -8609,67 +8320,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         const textField = this.treeConfig.textField || 'title';
         return String(nodeData[textField] ?? '');
     }
-    /**
-     * Checks if a node is a leaf node (has no children)
-     */
-    async isLeafNode(nodeId, treeComponent) {
-        if (!treeComponent) {
-            // If no tree component, check if node has children by querying
-            return await this.checkIfNodeHasChildren(nodeId);
-        }
-        try {
-            const node = treeComponent.findNode(nodeId);
-            if (!node) {
-                // Node not found in tree, check via query
-                return await this.checkIfNodeHasChildren(nodeId);
-            }
-            // Check if node has children
-            const children = node['children'];
-            const childrenCount = node['childrenCount'];
-            // If children are loaded, check the array
-            if (children !== undefined) {
-                return !children || children.length === 0;
-            }
-            // If childrenCount is available, use it
-            if (childrenCount !== undefined) {
-                return childrenCount === 0;
-            }
-            // If neither is available, try to check via query
-            return await this.checkIfNodeHasChildren(nodeId);
-        }
-        catch {
-            // If findNode fails, check via query
-            return await this.checkIfNodeHasChildren(nodeId);
-        }
-    }
-    /**
-     * Checks if a node has children by querying the data source
-     */
-    async checkIfNodeHasChildren(nodeId) {
-        if (!this.treeData?.categoryEntityQueryFunc || !this.treeConfig) {
-            return true; // Assume leaf if we can't check
-        }
-        try {
-            const parentKey = this.treeData.categoryEntityDef?.parentKey;
-            if (!parentKey) {
-                return true; // No parent key means flat structure, all nodes are leaves
-            }
-            const event = {
-                ...this.treeData.basicQueryEvent,
-                filter: {
-                    field: parentKey,
-                    value: nodeId,
-                    operator: { type: 'equal' },
-                },
-                take: 1, // Only need to check if any children exist
-            };
-            const res = await this.treeData.categoryEntityQueryFunc(event);
-            return !res?.items || res.items.length === 0;
-        }
-        catch {
-            return true; // Assume leaf on error
-        }
-    }
     async getSelectedItems() {
         // selectedNodeIds now only contains LEAF nodes (already filtered)
         const selectedIds = this.selectedNodeIds();
@@ -8769,8 +8419,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                 [titleField]="textField()"
                 [idField]="valueField()"
                 (onNodeSelect)="onNodeSelect($event)"
-                (onSelectionChange)="onSelectionChange($event)"
-                (onNodeToggle)="onNodeToggle($event)"
                 [nodeTemplate]="itemTemplate"
                 #tree
               >
@@ -8900,8 +8548,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                 [titleField]="textField()"
                 [idField]="valueField()"
                 (onNodeSelect)="onNodeSelect($event)"
-                (onSelectionChange)="onSelectionChange($event)"
-                (onNodeToggle)="onNodeToggle($event)"
                 [nodeTemplate]="itemTemplate"
                 #tree
               >